Submit #2904 ยป 0001-drm-uapi_drm-Update-to-Linux-4.6.patch
| sys/dev/drm/include/linux/types.h | ||
|---|---|---|
| typedef unsigned int gfp_t; | ||
| typedef uint64_t loff_t; | ||
| typedef vm_paddr_t resource_size_t; | ||
| typedef size_t __kernel_size_t; | ||
| #define	DECLARE_BITMAP(n, bits)						\ | ||
| 	unsigned long n[howmany(bits, sizeof(long) * 8)] | ||
| sys/dev/drm/include/uapi_drm/drm.h | ||
|---|---|---|
| #ifndef _DRM_H_ | ||
| #define _DRM_H_ | ||
| #if defined(__DragonFly__) | ||
| #include <linux/types.h> | ||
| typedef unsigned int drm_handle_t; | ||
| #elif defined(__KERNEL__) || defined(__linux__) | ||
| #include <linux/types.h> | ||
| #include <asm/ioctl.h> | ||
| typedef unsigned int drm_handle_t; | ||
| #else /* One of the BSDs */ | ||
| #include <sys/ioccom.h> | ||
| #include <sys/types.h> | ||
| typedef int8_t   __s8; | ||
| typedef uint8_t  __u8; | ||
| typedef int16_t  __s16; | ||
| typedef uint16_t __u16; | ||
| typedef int32_t  __s32; | ||
| typedef uint32_t __u32; | ||
| typedef int64_t  __s64; | ||
| typedef uint64_t __u64; | ||
| typedef size_t   __kernel_size_t; | ||
| typedef unsigned long drm_handle_t; | ||
| #endif | ||
| #define DRM_NAME	"drm"	  /**< Name in kernel, /dev, and /proc */ | ||
| #define DRM_MIN_ORDER	5	  /**< At least 2^5 bytes = 32 bytes */ | ||
| #define DRM_MAX_ORDER	22	  /**< Up to 2^22 bytes = 4MB */ | ||
| ... | ... | |
| 	int version_major;	  /**< Major version */ | ||
| 	int version_minor;	  /**< Minor version */ | ||
| 	int version_patchlevel;	  /**< Patch level */ | ||
| 	size_t name_len;	  /**< Length of name buffer */ | ||
| 	__kernel_size_t name_len;	  /**< Length of name buffer */ | ||
| 	char __user *name;	  /**< Name of driver */ | ||
| 	size_t date_len;	  /**< Length of date buffer */ | ||
| 	__kernel_size_t date_len;	  /**< Length of date buffer */ | ||
| 	char __user *date;	  /**< User-space buffer to hold date */ | ||
| 	size_t desc_len;	  /**< Length of desc buffer */ | ||
| 	__kernel_size_t desc_len;	  /**< Length of desc buffer */ | ||
| 	char __user *desc;	  /**< User-space buffer to hold desc */ | ||
| }; | ||
| ... | ... | |
|  * \sa drmGetBusid() and drmSetBusId(). | ||
|  */ | ||
| struct drm_unique { | ||
| 	size_t unique_len;	  /**< Length of unique */ | ||
| 	__kernel_size_t unique_len;	  /**< Length of unique */ | ||
| 	char __user *unique;	  /**< Unique name for driver instantiation */ | ||
| }; | ||
| ... | ... | |
| 	__u64 value; | ||
| }; | ||
| #define DRM_RDWR O_RDWR | ||
| #define DRM_CLOEXEC O_CLOEXEC | ||
| struct drm_prime_handle { | ||
| 	__u32 handle; | ||
| sys/dev/drm/include/uapi_drm/drm_fourcc.h | ||
|---|---|---|
| #ifndef DRM_FOURCC_H | ||
| #define DRM_FOURCC_H | ||
| #include <linux/types.h> | ||
| #include <uapi_drm/drm.h> | ||
| #define fourcc_code(a, b, c, d) ((__u32)(a) | ((__u32)(b) << 8) | \ | ||
| 				 ((__u32)(c) << 16) | ((__u32)(d) << 24)) | ||
| ... | ... | |
| /* color index */ | ||
| #define DRM_FORMAT_C8		fourcc_code('C', '8', ' ', ' ') /* [7:0] C */ | ||
| /* 8 bpp Red */ | ||
| #define DRM_FORMAT_R8		fourcc_code('R', '8', ' ', ' ') /* [7:0] R */ | ||
| /* 16 bpp RG */ | ||
| #define DRM_FORMAT_RG88		fourcc_code('R', 'G', '8', '8') /* [15:0] R:G 8:8 little endian */ | ||
| #define DRM_FORMAT_GR88		fourcc_code('G', 'R', '8', '8') /* [15:0] G:R 8:8 little endian */ | ||
| /* 8 bpp RGB */ | ||
| #define DRM_FORMAT_RGB332	fourcc_code('R', 'G', 'B', '8') /* [7:0] R:G:B 3:3:2 */ | ||
| #define DRM_FORMAT_BGR233	fourcc_code('B', 'G', 'R', '8') /* [7:0] B:G:R 2:3:3 */ | ||
| ... | ... | |
| /* add more to the end as needed */ | ||
| #define fourcc_mod_code(vendor, val) \ | ||
| 	((((u64)DRM_FORMAT_MOD_VENDOR_## vendor) << 56) | (val & 0x00ffffffffffffffULL)) | ||
| 	((((__u64)DRM_FORMAT_MOD_VENDOR_## vendor) << 56) | (val & 0x00ffffffffffffffULL)) | ||
| /* | ||
|  * Format Modifier tokens: | ||
| ... | ... | |
|  * - multiple of 128 pixels for the width | ||
|  * - multiple of  32 pixels for the height | ||
|  * | ||
|  * For more information: see http://linuxtv.org/downloads/v4l-dvb-apis/re32.html | ||
|  * For more information: see https://linuxtv.org/downloads/v4l-dvb-apis/re32.html | ||
|  */ | ||
| #define DRM_FORMAT_MOD_SAMSUNG_64_32_TILE	fourcc_mod_code(SAMSUNG, 1) | ||
| sys/dev/drm/include/uapi_drm/drm_mode.h | ||
|---|---|---|
| #ifndef _DRM_MODE_H | ||
| #define _DRM_MODE_H | ||
| #include <linux/types.h> | ||
| #include <uapi_drm/drm.h> | ||
| #define DRM_DISPLAY_INFO_LEN	32 | ||
| #define DRM_CONNECTOR_NAME_LEN	32 | ||
| ... | ... | |
| struct drm_mode_modeinfo { | ||
| 	__u32 clock; | ||
| 	__u16 hdisplay, hsync_start, hsync_end, htotal, hskew; | ||
| 	__u16 vdisplay, vsync_start, vsync_end, vtotal, vscan; | ||
| 	__u16 hdisplay; | ||
| 	__u16 hsync_start; | ||
| 	__u16 hsync_end; | ||
| 	__u16 htotal; | ||
| 	__u16 hskew; | ||
| 	__u16 vdisplay; | ||
| 	__u16 vsync_start; | ||
| 	__u16 vsync_end; | ||
| 	__u16 vtotal; | ||
| 	__u16 vscan; | ||
| 	__u32 vrefresh; | ||
| ... | ... | |
| 	__u32 count_crtcs; | ||
| 	__u32 count_connectors; | ||
| 	__u32 count_encoders; | ||
| 	__u32 min_width, max_width; | ||
| 	__u32 min_height, max_height; | ||
| 	__u32 min_width; | ||
| 	__u32 max_width; | ||
| 	__u32 min_height; | ||
| 	__u32 max_height; | ||
| }; | ||
| struct drm_mode_crtc { | ||
| ... | ... | |
| 	__u32 crtc_id; /**< Id */ | ||
| 	__u32 fb_id; /**< Id of framebuffer */ | ||
| 	__u32 x, y; /**< Position on the frameuffer */ | ||
| 	__u32 x; /**< x Position on the framebuffer */ | ||
| 	__u32 y; /**< y Position on the framebuffer */ | ||
| 	__u32 gamma_size; | ||
| 	__u32 mode_valid; | ||
| ... | ... | |
| 	__u32 flags; /* see above flags */ | ||
| 	/* Signed dest location allows it to be partially off screen */ | ||
| 	__s32 crtc_x, crtc_y; | ||
| 	__u32 crtc_w, crtc_h; | ||
| 	__s32 crtc_x; | ||
| 	__s32 crtc_y; | ||
| 	__u32 crtc_w; | ||
| 	__u32 crtc_h; | ||
| 	/* Source values are 16.16 fixed point */ | ||
| 	__u32 src_x, src_y; | ||
| 	__u32 src_h, src_w; | ||
| 	__u32 src_x; | ||
| 	__u32 src_y; | ||
| 	__u32 src_h; | ||
| 	__u32 src_w; | ||
| }; | ||
| struct drm_mode_get_plane { | ||
| ... | ... | |
| 	__u32 connector_type_id; | ||
| 	__u32 connection; | ||
| 	__u32 mm_width, mm_height; /**< HxW in millimeters */ | ||
| 	__u32 mm_width;  /**< width in millimeters */ | ||
| 	__u32 mm_height; /**< height in millimeters */ | ||
| 	__u32 subpixel; | ||
| 	__u32 pad; | ||
| ... | ... | |
| struct drm_mode_fb_cmd { | ||
| 	__u32 fb_id; | ||
| 	__u32 width, height; | ||
| 	__u32 width; | ||
| 	__u32 height; | ||
| 	__u32 pitch; | ||
| 	__u32 bpp; | ||
| 	__u32 depth; | ||
| ... | ... | |
| struct drm_mode_fb_cmd2 { | ||
| 	__u32 fb_id; | ||
| 	__u32 width, height; | ||
| 	__u32 width; | ||
| 	__u32 height; | ||
| 	__u32 pixel_format; /* fourcc code from drm_fourcc.h */ | ||
| 	__u32 flags; /* see above flags */ | ||
| ... | ... | |
| 	__u64 blue; | ||
| }; | ||
| struct drm_color_ctm { | ||
| 	/* Conversion matrix in S31.32 format. */ | ||
| 	__s64 matrix[9]; | ||
| }; | ||
| struct drm_color_lut { | ||
| 	/* | ||
| 	 * Data is U0.16 fixed point format. | ||
| 	 */ | ||
| 	__u16 red; | ||
| 	__u16 green; | ||
| 	__u16 blue; | ||
| 	__u16 reserved; | ||
| }; | ||
| #define DRM_MODE_PAGE_FLIP_EVENT 0x01 | ||
| #define DRM_MODE_PAGE_FLIP_ASYNC 0x02 | ||
| #define DRM_MODE_PAGE_FLIP_FLAGS (DRM_MODE_PAGE_FLIP_EVENT|DRM_MODE_PAGE_FLIP_ASYNC) | ||
| ... | ... | |
| /* create a dumb scanout buffer */ | ||
| struct drm_mode_create_dumb { | ||
| 	uint32_t height; | ||
| 	uint32_t width; | ||
| 	uint32_t bpp; | ||
| 	uint32_t flags; | ||
| 	__u32 height; | ||
| 	__u32 width; | ||
| 	__u32 bpp; | ||
| 	__u32 flags; | ||
| 	/* handle, pitch, size will be returned */ | ||
| 	uint32_t handle; | ||
| 	uint32_t pitch; | ||
| 	uint64_t size; | ||
| 	__u32 handle; | ||
| 	__u32 pitch; | ||
| 	__u64 size; | ||
| }; | ||
| /* set up for mmap of a dumb scanout buffer */ | ||
| ... | ... | |
| }; | ||
| struct drm_mode_destroy_dumb { | ||
| 	uint32_t handle; | ||
| 	__u32 handle; | ||
| }; | ||
| /* page-flip flags are valid, plus: */ | ||
| sys/dev/drm/include/uapi_drm/i915_drm.h | ||
|---|---|---|
| #define I915_BOX_TEXTURE_LOAD  0x8 | ||
| #define I915_BOX_LOST_CONTEXT  0x10 | ||
| /* I915 specific ioctls | ||
|  * The device specific ioctl range is 0x40 to 0x79. | ||
| /* | ||
|  * i915 specific ioctls. | ||
|  * | ||
|  * The device specific ioctl range is [DRM_COMMAND_BASE, DRM_COMMAND_END) ie | ||
|  * [0x40, 0xa0) (a0 is excluded). The numbers below are defined as offset | ||
|  * against DRM_COMMAND_BASE and should be between [0x0, 0x60). | ||
|  */ | ||
| #define DRM_I915_INIT		0x00 | ||
| #define DRM_I915_FLUSH		0x01 | ||
| ... | ... | |
| #define I915_PARAM_REVISION              32 | ||
| #define I915_PARAM_SUBSLICE_TOTAL	 33 | ||
| #define I915_PARAM_EU_TOTAL		 34 | ||
| #define I915_PARAM_HAS_GPU_RESET	 35 | ||
| #define I915_PARAM_HAS_RESOURCE_STREAMER 36 | ||
| #define I915_PARAM_HAS_EXEC_SOFTPIN	 37 | ||
| typedef struct drm_i915_getparam { | ||
| 	int param; | ||
| 	__s32 param; | ||
| 	/* | ||
| 	 * WARNING: Using pointers instead of fixed-size u64 means we need to write | ||
| 	 * compat32 code. Don't repeat this mistake. | ||
| 	 */ | ||
| 	int __user *value; | ||
| } drm_i915_getparam_t; | ||
| ... | ... | |
| 	__u64 alignment; | ||
| 	/** | ||
| 	 * Current DragonFly behavior:  | ||
| 	 * Returned value of the updated offset of the object, for future | ||
| 	 * presumed_offset writes. | ||
| 	 * Future Linux 4.6 compatible behavior: | ||
| 	 * When the EXEC_OBJECT_PINNED flag is specified this is populated by | ||
| 	 * the user with the GTT offset at which this object will be pinned. | ||
| 	 * When the I915_EXEC_NO_RELOC flag is specified this must contain the | ||
| 	 * presumed_offset of the object. | ||
| 	 * During execbuffer2 the kernel populates it with the value of the | ||
| 	 * current GTT offset of the object, for future presumed_offset writes. | ||
| 	 */ | ||
| 	__u64 offset; | ||
| #define EXEC_OBJECT_NEEDS_FENCE (1<<0) | ||
| #define EXEC_OBJECT_NEEDS_GTT	(1<<1) | ||
| #define EXEC_OBJECT_WRITE	(1<<2) | ||
| #ifdef __DragonFly__ | ||
| #define __EXEC_OBJECT_UNKNOWN_FLAGS -(EXEC_OBJECT_WRITE<<1) | ||
| #else /* Linux 4.6 */ | ||
| #define EXEC_OBJECT_SUPPORTS_48B_ADDRESS (1<<3) | ||
| #define EXEC_OBJECT_PINNED	(1<<4) | ||
| #define __EXEC_OBJECT_UNKNOWN_FLAGS -(EXEC_OBJECT_PINNED<<1) | ||
| #endif | ||
| 	__u64 flags; | ||
| 	__u64 rsvd1; | ||
| ... | ... | |
| #define I915_EXEC_HANDLE_LUT		(1<<12) | ||
| /** Used for switching BSD rings on the platforms with two BSD rings */ | ||
| #define I915_EXEC_BSD_MASK		(3<<13) | ||
| #define I915_EXEC_BSD_DEFAULT		(0<<13) /* default ping-pong mode */ | ||
| #define I915_EXEC_BSD_RING1		(1<<13) | ||
| #define I915_EXEC_BSD_RING2		(2<<13) | ||
| #define I915_EXEC_BSD_SHIFT	 (13) | ||
| #define I915_EXEC_BSD_MASK	 (3 << I915_EXEC_BSD_SHIFT) | ||
| /* default ping-pong mode */ | ||
| #define I915_EXEC_BSD_DEFAULT	 (0 << I915_EXEC_BSD_SHIFT) | ||
| #define I915_EXEC_BSD_RING1	 (1 << I915_EXEC_BSD_SHIFT) | ||
| #define I915_EXEC_BSD_RING2	 (2 << I915_EXEC_BSD_SHIFT) | ||
| #ifdef __DragonFly__ | ||
| #define __I915_EXEC_UNKNOWN_FLAGS -(1<<15) | ||
| #else /* Linux 4.6 */ | ||
| /** Tell the kernel that the batchbuffer is processed by | ||
|  *  the resource streamer. | ||
|  */ | ||
| #define I915_EXEC_RESOURCE_STREAMER     (1<<15) | ||
| #define __I915_EXEC_UNKNOWN_FLAGS -(I915_EXEC_RESOURCE_STREAMER<<1) | ||
| #endif | ||
| #define I915_EXEC_CONTEXT_ID_MASK	(0xffffffff) | ||
| #define i915_execbuffer2_set_context_id(eb2, context) \ | ||
| ... | ... | |
| 	/** Handle of the buffer to check for busy */ | ||
| 	__u32 handle; | ||
| 	/** Current DragonFly behavior: */ | ||
| 	/** Return busy status (1 if busy, 0 if idle). | ||
| 	 * The high word is used to indicate on which rings the object | ||
| 	 * currently resides: | ||
| 	 *  16:31 - busy (r or r/w) rings (16 render, 17 bsd, 18 blt, etc) | ||
| 	 */ | ||
| 	/** Future Linux 4.6 compatible behavior */ | ||
| 	/** Return busy status | ||
| 	 * | ||
| 	 * A return of 0 implies that the object is idle (after | ||
| 	 * having flushed any pending activity), and a non-zero return that | ||
| 	 * the object is still in-flight on the GPU. (The GPU has not yet | ||
| 	 * signaled completion for all pending requests that reference the | ||
| 	 * object.) | ||
| 	 * | ||
| 	 * The returned dword is split into two fields to indicate both | ||
| 	 * the engines on which the object is being read, and the | ||
| 	 * engine on which it is currently being written (if any). | ||
| 	 * | ||
| 	 * The low word (bits 0:15) indicate if the object is being written | ||
| 	 * to by any engine (there can only be one, as the GEM implicit | ||
| 	 * synchronisation rules force writes to be serialised). Only the | ||
| 	 * engine for the last write is reported. | ||
| 	 * | ||
| 	 * The high word (bits 16:31) are a bitmask of which engines are | ||
| 	 * currently reading from the object. Multiple engines may be | ||
| 	 * reading from the object simultaneously. | ||
| 	 * | ||
| 	 * The value of each engine is the same as specified in the | ||
| 	 * EXECBUFFER2 ioctl, i.e. I915_EXEC_RENDER, I915_EXEC_BSD etc. | ||
| 	 * Note I915_EXEC_DEFAULT is a symbolic value and is mapped to | ||
| 	 * the I915_EXEC_RENDER engine for execution, and so it is never | ||
| 	 * reported as active itself. Some hardware may have parallel | ||
| 	 * execution engines, e.g. multiple media engines, which are | ||
| 	 * mapped to the same identifier in the EXECBUFFER2 ioctl and | ||
| 	 * so are not separately reported for busyness. | ||
| 	 */ | ||
| 	__u32 busy; | ||
| }; | ||
| ... | ... | |
| }; | ||
| struct drm_i915_reg_read { | ||
| 	/* | ||
| 	 * Register offset. | ||
| 	 * For 64bit wide registers where the upper 32bits don't immediately | ||
| 	 * follow the lower 32bits, the offset of the lower 32bits must | ||
| 	 * be specified | ||
| 	 */ | ||
| 	__u64 offset; | ||
| 	__u64 val; /* Return value */ | ||
| }; | ||
| /* Known registers: | ||
|  * | ||
|  * Render engine timestamp - 0x2358 + 64bit - gen7+ | ||
|  * - Note this register returns an invalid value if using the default | ||
|  *   single instruction 8byte read, in order to workaround that use | ||
|  *   offset (0x2538 | 1) instead. | ||
|  * | ||
|  */ | ||
| struct drm_i915_reset_stats { | ||
| 	__u32 ctx_id; | ||
| ... | ... | |
| 	__u32 size; | ||
| 	__u64 param; | ||
| #define I915_CONTEXT_PARAM_BAN_PERIOD 0x1 | ||
| #define I915_CONTEXT_PARAM_NO_ZEROMAP	0x2 | ||
| #define I915_CONTEXT_PARAM_GTT_SIZE	0x3 | ||
| 	__u64 value; | ||
| }; | ||
| sys/dev/drm/include/uapi_drm/radeon_drm.h | ||
|---|---|---|
| #define RADEON_GEM_DOMAIN_VRAM		0x4 | ||
| struct drm_radeon_gem_info { | ||
| 	uint64_t	gart_size; | ||
| 	uint64_t	vram_size; | ||
| 	uint64_t	vram_visible; | ||
| 	__u64	gart_size; | ||
| 	__u64	vram_size; | ||
| 	__u64	vram_visible; | ||
| }; | ||
| #define RADEON_GEM_NO_BACKING_STORE	(1 << 0) | ||
| ... | ... | |
| #define RADEON_GEM_NO_CPU_ACCESS	(1 << 4) | ||
| struct drm_radeon_gem_create { | ||
| 	uint64_t	size; | ||
| 	uint64_t	alignment; | ||
| 	uint32_t	handle; | ||
| 	uint32_t	initial_domain; | ||
| 	uint32_t	flags; | ||
| 	__u64	size; | ||
| 	__u64	alignment; | ||
| 	__u32	handle; | ||
| 	__u32	initial_domain; | ||
| 	__u32	flags; | ||
| }; | ||
| /* | ||
| ... | ... | |
| #define RADEON_GEM_USERPTR_REGISTER	(1 << 3) | ||
| struct drm_radeon_gem_userptr { | ||
| 	uint64_t		addr; | ||
| 	uint64_t		size; | ||
| 	uint32_t		flags; | ||
| 	uint32_t		handle; | ||
| 	__u64		addr; | ||
| 	__u64		size; | ||
| 	__u32		flags; | ||
| 	__u32		handle; | ||
| }; | ||
| #define RADEON_TILING_MACRO				0x1 | ||
| ... | ... | |
| #define RADEON_TILING_EG_STENCIL_TILE_SPLIT_MASK	0xf | ||
| struct drm_radeon_gem_set_tiling { | ||
| 	uint32_t	handle; | ||
| 	uint32_t	tiling_flags; | ||
| 	uint32_t	pitch; | ||
| 	__u32	handle; | ||
| 	__u32	tiling_flags; | ||
| 	__u32	pitch; | ||
| }; | ||
| struct drm_radeon_gem_get_tiling { | ||
| 	uint32_t	handle; | ||
| 	uint32_t	tiling_flags; | ||
| 	uint32_t	pitch; | ||
| 	__u32	handle; | ||
| 	__u32	tiling_flags; | ||
| 	__u32	pitch; | ||
| }; | ||
| struct drm_radeon_gem_mmap { | ||
| 	uint32_t	handle; | ||
| 	uint32_t	pad; | ||
| 	uint64_t	offset; | ||
| 	uint64_t	size; | ||
| 	uint64_t	addr_ptr; | ||
| 	__u32	handle; | ||
| 	__u32	pad; | ||
| 	__u64	offset; | ||
| 	__u64	size; | ||
| 	__u64	addr_ptr; | ||
| }; | ||
| struct drm_radeon_gem_set_domain { | ||
| 	uint32_t	handle; | ||
| 	uint32_t	read_domains; | ||
| 	uint32_t	write_domain; | ||
| 	__u32	handle; | ||
| 	__u32	read_domains; | ||
| 	__u32	write_domain; | ||
| }; | ||
| struct drm_radeon_gem_wait_idle { | ||
| 	uint32_t	handle; | ||
| 	uint32_t	pad; | ||
| 	__u32	handle; | ||
| 	__u32	pad; | ||
| }; | ||
| struct drm_radeon_gem_busy { | ||
| 	uint32_t	handle; | ||
| 	uint32_t        domain; | ||
| 	__u32	handle; | ||
| 	__u32        domain; | ||
| }; | ||
| struct drm_radeon_gem_pread { | ||
| 	/** Handle for the object being read. */ | ||
| 	uint32_t handle; | ||
| 	uint32_t pad; | ||
| 	__u32 handle; | ||
| 	__u32 pad; | ||
| 	/** Offset into the object to read from */ | ||
| 	uint64_t offset; | ||
| 	__u64 offset; | ||
| 	/** Length of data to read */ | ||
| 	uint64_t size; | ||
| 	__u64 size; | ||
| 	/** Pointer to write the data into. */ | ||
| 	/* void *, but pointers are not 32/64 compatible */ | ||
| 	uint64_t data_ptr; | ||
| 	__u64 data_ptr; | ||
| }; | ||
| struct drm_radeon_gem_pwrite { | ||
| 	/** Handle for the object being written to. */ | ||
| 	uint32_t handle; | ||
| 	uint32_t pad; | ||
| 	__u32 handle; | ||
| 	__u32 pad; | ||
| 	/** Offset into the object to write to */ | ||
| 	uint64_t offset; | ||
| 	__u64 offset; | ||
| 	/** Length of data to write */ | ||
| 	uint64_t size; | ||
| 	__u64 size; | ||
| 	/** Pointer to read the data from. */ | ||
| 	/* void *, but pointers are not 32/64 compatible */ | ||
| 	uint64_t data_ptr; | ||
| 	__u64 data_ptr; | ||
| }; | ||
| /* Sets or returns a value associated with a buffer. */ | ||
| struct drm_radeon_gem_op { | ||
| 	uint32_t	handle; /* buffer */ | ||
| 	uint32_t	op;     /* RADEON_GEM_OP_* */ | ||
| 	uint64_t	value;  /* input or return value */ | ||
| 	__u32	handle; /* buffer */ | ||
| 	__u32	op;     /* RADEON_GEM_OP_* */ | ||
| 	__u64	value;  /* input or return value */ | ||
| }; | ||
| #define RADEON_GEM_OP_GET_INITIAL_DOMAIN	0 | ||
| ... | ... | |
| #define RADEON_VM_PAGE_SNOOPED		(1 << 4) | ||
| struct drm_radeon_gem_va { | ||
| 	uint32_t		handle; | ||
| 	uint32_t		operation; | ||
| 	uint32_t		vm_id; | ||
| 	uint32_t		flags; | ||
| 	uint64_t		offset; | ||
| 	__u32		handle; | ||
| 	__u32		operation; | ||
| 	__u32		vm_id; | ||
| 	__u32		flags; | ||
| 	__u64		offset; | ||
| }; | ||
| #define RADEON_CHUNK_ID_RELOCS	0x01 | ||
| ... | ... | |
| /* 0 = normal, + = higher priority, - = lower priority */ | ||
| struct drm_radeon_cs_chunk { | ||
| 	uint32_t		chunk_id; | ||
| 	uint32_t		length_dw; | ||
| 	uint64_t		chunk_data; | ||
| 	__u32		chunk_id; | ||
| 	__u32		length_dw; | ||
| 	__u64		chunk_data; | ||
| }; | ||
| /* drm_radeon_cs_reloc.flags */ | ||
| #define RADEON_RELOC_PRIO_MASK		(0xf << 0) | ||
| struct drm_radeon_cs_reloc { | ||
| 	uint32_t		handle; | ||
| 	uint32_t		read_domains; | ||
| 	uint32_t		write_domain; | ||
| 	uint32_t		flags; | ||
| 	__u32		handle; | ||
| 	__u32		read_domains; | ||
| 	__u32		write_domain; | ||
| 	__u32		flags; | ||
| }; | ||
| struct drm_radeon_cs { | ||
| 	uint32_t		num_chunks; | ||
| 	uint32_t		cs_id; | ||
| 	/* this points to uint64_t * which point to cs chunks */ | ||
| 	uint64_t		chunks; | ||
| 	__u32		num_chunks; | ||
| 	__u32		cs_id; | ||
| 	/* this points to __u64 * which point to cs chunks */ | ||
| 	__u64		chunks; | ||
| 	/* updates to the limits after this CS ioctl */ | ||
| 	uint64_t		gart_limit; | ||
| 	uint64_t		vram_limit; | ||
| 	__u64		gart_limit; | ||
| 	__u64		vram_limit; | ||
| }; | ||
| #define RADEON_INFO_DEVICE_ID		0x00 | ||
| ... | ... | |
| #define RADEON_INFO_VRAM_USAGE		0x1e | ||
| #define RADEON_INFO_GTT_USAGE		0x1f | ||
| #define RADEON_INFO_ACTIVE_CU_COUNT	0x20 | ||
| #define RADEON_INFO_CURRENT_GPU_TEMP	0x21 | ||
| #define RADEON_INFO_CURRENT_GPU_SCLK	0x22 | ||
| #define RADEON_INFO_CURRENT_GPU_MCLK	0x23 | ||
| #define RADEON_INFO_READ_REG		0x24 | ||
| #define RADEON_INFO_VA_UNMAP_WORKING	0x25 | ||
| #define RADEON_INFO_GPU_RESET_COUNTER	0x26 | ||
| struct drm_radeon_info { | ||
| 	uint32_t		request; | ||
| 	uint32_t		pad; | ||
| 	uint64_t		value; | ||
| 	__u32		request; | ||
| 	__u32		pad; | ||
| 	__u64		value; | ||
| }; | ||
| /* Those correspond to the tile index to use, this is to explicitly state | ||