drm: remove a bunch of typedefs on the userspace interface (c60ce623) · Commits · e / devices / android_kernel_xiaomi_markw

drivers/char/drm/drm.h

+187 −142

Original line number	Diff line number	Diff line
		@@ -109,31 +109,31 @@ typedef unsigned int drm_magic_t;
		* \note KW: Actually it's illegal to change either for
		* backwards-compatibility reasons.
		*/
		typedef struct drm_clip_rect {
		struct drm_clip_rect {
		unsigned short x1;
		unsigned short y1;
		unsigned short x2;
		unsigned short y2;
		} drm_clip_rect_t;
		};

		/**
		* Drawable information.
		*/
		typedef struct drm_drawable_info {
		struct drm_drawable_info {
		unsigned int num_rects;
		drm_clip_rect_t *rects;
		} drm_drawable_info_t;
		struct drm_clip_rect *rects;
		};

		/**
		* Texture region,
		*/
		typedef struct drm_tex_region {
		struct drm_tex_region {
		unsigned char next;
		unsigned char prev;
		unsigned char in_use;
		unsigned char padding;
		unsigned int age;
		} drm_tex_region_t;
		};

		/**
		* Hardware lock.
		@@ -142,17 +142,17 @@ typedef struct drm_tex_region {
		* processor bus contention on a multiprocessor system, there should not be any
		* other data stored in the same cache line.
		*/
		typedef struct drm_hw_lock {
		struct drm_hw_lock {
		__volatile__ unsigned int lock; /*< lock variable /
		char padding[60]; /*< Pad to cache line /
		} drm_hw_lock_t;
		};

		/**
		* DRM_IOCTL_VERSION ioctl argument type.
		*
		* \sa drmGetVersion().
		*/
		typedef struct drm_version {
		struct drm_version {
		int version_major; /*< Major version /
		int version_minor; /*< Minor version /
		int version_patchlevel; /*< Patch level /
		@@ -162,33 +162,33 @@ typedef struct drm_version {
		char __user date; /< User-space buffer to hold date /
		size_t desc_len; /*< Length of desc buffer /
		char __user desc; /< User-space buffer to hold desc /
		} drm_version_t;
		};

		/**
		* DRM_IOCTL_GET_UNIQUE ioctl argument type.
		*
		* \sa drmGetBusid() and drmSetBusId().
		*/
		typedef struct drm_unique {
		struct drm_unique {
		size_t unique_len; /*< Length of unique /
		char __user unique; /< Unique name for driver instantiation /
		} drm_unique_t;
		};

		typedef struct drm_list {
		struct drm_list {
		int count; /*< Length of user-space structures /
		drm_version_t __user *version;
		} drm_list_t;
		struct drm_version __user *version;
		};

		typedef struct drm_block {
		struct drm_block {
		int unused;
		} drm_block_t;
		};

		/**
		* DRM_IOCTL_CONTROL ioctl argument type.
		*
		* \sa drmCtlInstHandler() and drmCtlUninstHandler().
		*/
		typedef struct drm_control {
		struct drm_control {
		enum {
		DRM_ADD_COMMAND,
		DRM_RM_COMMAND,
		@@ -196,24 +196,24 @@ typedef struct drm_control {
		DRM_UNINST_HANDLER
		} func;
		int irq;
		} drm_control_t;
		};

		/**
		* Type of memory to map.
		*/
		typedef enum drm_map_type {
		enum drm_map_type {
		_DRM_FRAME_BUFFER = 0, /*< WC (no caching), no core dump /
		_DRM_REGISTERS = 1, /*< no caching, no core dump /
		_DRM_SHM = 2, /*< shared, cached /
		_DRM_AGP = 3, /*< AGP/GART /
		_DRM_SCATTER_GATHER = 4, /*< Scatter/gather memory for PCI DMA /
		_DRM_CONSISTENT = 5, /*< Consistent memory for PCI DMA /
		} drm_map_type_t;
		};

		/**
		* Memory mapping flags.
		*/
		typedef enum drm_map_flags {
		enum drm_map_flags {
		_DRM_RESTRICTED = 0x01, /*< Cannot be mapped to user-virtual /
		_DRM_READ_ONLY = 0x02,
		_DRM_LOCKED = 0x04, /*< shared, cached, locked /
		@@ -221,12 +221,12 @@ typedef enum drm_map_flags {
		_DRM_WRITE_COMBINING = 0x10, /*< use write-combining if available /
		_DRM_CONTAINS_LOCK = 0x20, /*< SHM page that contains lock /
		_DRM_REMOVABLE = 0x40 /*< Removable mapping /
		} drm_map_flags_t;
		};

		typedef struct drm_ctx_priv_map {
		struct drm_ctx_priv_map {
		unsigned int ctx_id; /*< Context requesting private mapping /
		void handle; /< Handle of map /
		} drm_ctx_priv_map_t;
		};

		/**
		* DRM_IOCTL_GET_MAP, DRM_IOCTL_ADD_MAP and DRM_IOCTL_RM_MAP ioctls
		@@ -234,30 +234,30 @@ typedef struct drm_ctx_priv_map {
		*
		* \sa drmAddMap().
		*/
		typedef struct drm_map {
		struct drm_map {
		unsigned long offset; /*< Requested physical address (0 for SAREA)/
		unsigned long size; /*< Requested physical size (bytes) /
		drm_map_type_t type; /*< Type of memory to map /
		drm_map_flags_t flags; /*< Flags /
		enum drm_map_type type; /*< Type of memory to map /
		enum drm_map_flags flags; /*< Flags /
		void handle; /< User-space: "Handle" to pass to mmap() /
		/*< Kernel-space: kernel-virtual address /
		int mtrr; /*< MTRR slot used /
		/* Private data */
		} drm_map_t;
		};

		/**
		* DRM_IOCTL_GET_CLIENT ioctl argument type.
		*/
		typedef struct drm_client {
		struct drm_client {
		int idx; /*< Which client desired? /
		int auth; /*< Is client authenticated? /
		unsigned long pid; /*< Process ID /
		unsigned long uid; /*< User ID /
		unsigned long magic; /*< Magic /
		unsigned long iocs; /*< Ioctl count /
		} drm_client_t;
		};

		typedef enum {
		enum drm_stat_type {
		_DRM_STAT_LOCK,
		_DRM_STAT_OPENS,
		_DRM_STAT_CLOSES,
		@@ -275,23 +275,23 @@ typedef enum {
		_DRM_STAT_SPECIAL, /*< Special DMA (e.g., priority or polled) /
		_DRM_STAT_MISSED /*< Missed DMA opportunity /
		/* Add to the END of the list */
		} drm_stat_type_t;
		};

		/**
		* DRM_IOCTL_GET_STATS ioctl argument type.
		*/
		typedef struct drm_stats {
		struct drm_stats {
		unsigned long count;
		struct {
		unsigned long value;
		drm_stat_type_t type;
		enum drm_stat_type type;
		} data[15];
		} drm_stats_t;
		};

		/**
		* Hardware locking flags.
		*/
		typedef enum drm_lock_flags {
		enum drm_lock_flags {
		_DRM_LOCK_READY = 0x01, /*< Wait until hardware is ready for DMA /
		_DRM_LOCK_QUIESCENT = 0x02, /*< Wait until hardware quiescent /
		_DRM_LOCK_FLUSH = 0x04, /*< Flush this context's DMA queue first /
		@@ -301,17 +301,17 @@ typedef enum drm_lock_flags {
		full-screen DGA-like mode. */
		_DRM_HALT_ALL_QUEUES = 0x10, /*< Halt all current and future queues /
		_DRM_HALT_CUR_QUEUES = 0x20 /*< Halt all current queues /
		} drm_lock_flags_t;
		};

		/**
		* DRM_IOCTL_LOCK, DRM_IOCTL_UNLOCK and DRM_IOCTL_FINISH ioctl argument type.
		*
		* \sa drmGetLock() and drmUnlock().
		*/
		typedef struct drm_lock {
		struct drm_lock {
		int context;
		drm_lock_flags_t flags;
		} drm_lock_t;
		enum drm_lock_flags flags;
		};

		/**
		* DMA flags
		@@ -321,7 +321,7 @@ typedef struct drm_lock {
		*
		* \sa drm_dma.
		*/
		typedef enum drm_dma_flags {
		enum drm_dma_flags {
		/* Flags for DMA buffer dispatch */
		_DRM_DMA_BLOCK = 0x01, /**<
		* Block until buffer dispatched.
		@@ -340,14 +340,14 @@ typedef enum drm_dma_flags {
		_DRM_DMA_WAIT = 0x10, /*< Wait for free buffers /
		_DRM_DMA_SMALLER_OK = 0x20, /*< Smaller-than-requested buffers OK /
		_DRM_DMA_LARGER_OK = 0x40 /*< Larger-than-requested buffers OK /
		} drm_dma_flags_t;
		};

		/**
		* DRM_IOCTL_ADD_BUFS and DRM_IOCTL_MARK_BUFS ioctl argument type.
		*
		* \sa drmAddBufs().
		*/
		typedef struct drm_buf_desc {
		struct drm_buf_desc {
		int count; /*< Number of buffers of this size /
		int size; /*< Size in bytes /
		int low_mark; /*< Low water mark /
		@@ -363,44 +363,44 @@ typedef struct drm_buf_desc {
		* Start address of where the AGP buffers are
		* in the AGP aperture
		*/
		} drm_buf_desc_t;
		};

		/**
		* DRM_IOCTL_INFO_BUFS ioctl argument type.
		*/
		typedef struct drm_buf_info {
		struct drm_buf_info {
		int count; /*< Entries in list /
		drm_buf_desc_t __user *list;
		} drm_buf_info_t;
		struct drm_buf_desc __user *list;
		};

		/**
		* DRM_IOCTL_FREE_BUFS ioctl argument type.
		*/
		typedef struct drm_buf_free {
		struct drm_buf_free {
		int count;
		int __user *list;
		} drm_buf_free_t;
		};

		/**
		* Buffer information
		*
		* \sa drm_buf_map.
		*/
		typedef struct drm_buf_pub {
		struct drm_buf_pub {
		int idx; /*< Index into the master buffer list /
		int total; /*< Buffer size /
		int used; /*< Amount of buffer in use (for DMA) /
		void __user address; /< Address of buffer /
		} drm_buf_pub_t;
		};

		/**
		* DRM_IOCTL_MAP_BUFS ioctl argument type.
		*/
		typedef struct drm_buf_map {
		struct drm_buf_map {
		int count; /*< Length of the buffer list /
		void __user virtual; /< Mmap'd area in user-virtual /
		drm_buf_pub_t __user list; /< Buffer information /
		} drm_buf_map_t;
		struct drm_buf_pub __user list; /< Buffer information /
		};

		/**
		* DRM_IOCTL_DMA ioctl argument type.
		@@ -409,48 +409,48 @@ typedef struct drm_buf_map {
		*
		* \sa drmDMA().
		*/
		typedef struct drm_dma {
		struct drm_dma {
		int context; /*< Context handle /
		int send_count; /*< Number of buffers to send /
		int __user send_indices; /< List of handles to buffers /
		int __user send_sizes; /< Lengths of data to send /
		drm_dma_flags_t flags; /*< Flags /
		enum drm_dma_flags flags; /*< Flags /
		int request_count; /*< Number of buffers requested /
		int request_size; /*< Desired size for buffers /
		int __user request_indices; /< Buffer information /
		int __user *request_sizes;
		int granted_count; /*< Number of buffers granted /
		} drm_dma_t;
		};

		typedef enum {
		enum drm_ctx_flags {
		_DRM_CONTEXT_PRESERVED = 0x01,
		_DRM_CONTEXT_2DONLY = 0x02
		} drm_ctx_flags_t;
		};

		/**
		* DRM_IOCTL_ADD_CTX ioctl argument type.
		*
		* \sa drmCreateContext() and drmDestroyContext().
		*/
		typedef struct drm_ctx {
		struct drm_ctx {
		drm_context_t handle;
		drm_ctx_flags_t flags;
		} drm_ctx_t;
		enum drm_ctx_flags flags;
		};

		/**
		* DRM_IOCTL_RES_CTX ioctl argument type.
		*/
		typedef struct drm_ctx_res {
		struct drm_ctx_res {
		int count;
		drm_ctx_t __user *contexts;
		} drm_ctx_res_t;
		struct drm_ctx __user *contexts;
		};

		/**
		* DRM_IOCTL_ADD_DRAW and DRM_IOCTL_RM_DRAW ioctl argument type.
		*/
		typedef struct drm_draw {
		struct drm_draw {
		drm_drawable_t handle;
		} drm_draw_t;
		};

		/**
		* DRM_IOCTL_UPDATE_DRAW ioctl argument type.
		@@ -459,52 +459,52 @@ typedef enum {
		DRM_DRAWABLE_CLIPRECTS,
		} drm_drawable_info_type_t;

		typedef struct drm_update_draw {
		struct drm_update_draw {
		drm_drawable_t handle;
		unsigned int type;
		unsigned int num;
		unsigned long long data;
		} drm_update_draw_t;
		};

		/**
		* DRM_IOCTL_GET_MAGIC and DRM_IOCTL_AUTH_MAGIC ioctl argument type.
		*/
		typedef struct drm_auth {
		struct drm_auth {
		drm_magic_t magic;
		} drm_auth_t;
		};

		/**
		* DRM_IOCTL_IRQ_BUSID ioctl argument type.
		*
		* \sa drmGetInterruptFromBusID().
		*/
		typedef struct drm_irq_busid {
		struct drm_irq_busid {
		int irq; /*< IRQ number /
		int busnum; /*< bus number /
		int devnum; /*< device number /
		int funcnum; /*< function number /
		} drm_irq_busid_t;
		};

		typedef enum {
		enum drm_vblank_seq_type {
		_DRM_VBLANK_ABSOLUTE = 0x0, /*< Wait for specific vblank sequence number /
		_DRM_VBLANK_RELATIVE = 0x1, /*< Wait for given number of vblanks /
		_DRM_VBLANK_NEXTONMISS = 0x10000000, /*< If missed, wait for next vblank /
		_DRM_VBLANK_SECONDARY = 0x20000000, /*< Secondary display controller /
		_DRM_VBLANK_SIGNAL = 0x40000000 /*< Send signal instead of blocking /
		} drm_vblank_seq_type_t;
		};

		#define _DRM_VBLANK_TYPES_MASK (_DRM_VBLANK_ABSOLUTE \| _DRM_VBLANK_RELATIVE)
		#define _DRM_VBLANK_FLAGS_MASK (_DRM_VBLANK_SIGNAL \| _DRM_VBLANK_SECONDARY \| \
		_DRM_VBLANK_NEXTONMISS)

		struct drm_wait_vblank_request {
		drm_vblank_seq_type_t type;
		enum drm_vblank_seq_type type;
		unsigned int sequence;
		unsigned long signal;
		};

		struct drm_wait_vblank_reply {
		drm_vblank_seq_type_t type;
		enum drm_vblank_seq_type type;
		unsigned int sequence;
		long tval_sec;
		long tval_usec;
		@@ -515,41 +515,41 @@ struct drm_wait_vblank_reply {
		*
		* \sa drmWaitVBlank().
		*/
		typedef union drm_wait_vblank {
		union drm_wait_vblank {
		struct drm_wait_vblank_request request;
		struct drm_wait_vblank_reply reply;
		} drm_wait_vblank_t;
		};

		/**
		* DRM_IOCTL_AGP_ENABLE ioctl argument type.
		*
		* \sa drmAgpEnable().
		*/
		typedef struct drm_agp_mode {
		struct drm_agp_mode {
		unsigned long mode; /*< AGP mode /
		} drm_agp_mode_t;
		};

		/**
		* DRM_IOCTL_AGP_ALLOC and DRM_IOCTL_AGP_FREE ioctls argument type.
		*
		* \sa drmAgpAlloc() and drmAgpFree().
		*/
		typedef struct drm_agp_buffer {
		struct drm_agp_buffer {
		unsigned long size; /*< In bytes -- will round to page boundary /
		unsigned long handle; /*< Used for binding / unbinding /
		unsigned long type; /*< Type of memory to allocate /
		unsigned long physical; /*< Physical used by i810 /
		} drm_agp_buffer_t;
		};

		/**
		* DRM_IOCTL_AGP_BIND and DRM_IOCTL_AGP_UNBIND ioctls argument type.
		*
		* \sa drmAgpBind() and drmAgpUnbind().
		*/
		typedef struct drm_agp_binding {
		struct drm_agp_binding {
		unsigned long handle; /*< From drm_agp_buffer /
		unsigned long offset; /*< In bytes -- will round to page boundary /
		} drm_agp_binding_t;
		};

		/**
		* DRM_IOCTL_AGP_INFO ioctl argument type.
		@@ -558,7 +558,7 @@ typedef struct drm_agp_binding {
		* drmAgpBase(), drmAgpSize(), drmAgpMemoryUsed(), drmAgpMemoryAvail(),
		* drmAgpVendorId() and drmAgpDeviceId().
		*/
		typedef struct drm_agp_info {
		struct drm_agp_info {
		int agp_version_major;
		int agp_version_minor;
		unsigned long mode;
		@@ -570,25 +570,25 @@ typedef struct drm_agp_info {
		/* PCI information */
		unsigned short id_vendor;
		unsigned short id_device;
		} drm_agp_info_t;
		};

		/**
		* DRM_IOCTL_SG_ALLOC ioctl argument type.
		*/
		typedef struct drm_scatter_gather {
		struct drm_scatter_gather {
		unsigned long size; /*< In bytes -- will round to page boundary /
		unsigned long handle; /*< Used for mapping / unmapping /
		} drm_scatter_gather_t;
		};

		/**
		* DRM_IOCTL_SET_VERSION ioctl argument type.
		*/
		typedef struct drm_set_version {
		struct drm_set_version {
		int drm_di_major;
		int drm_di_minor;
		int drm_dd_major;
		int drm_dd_minor;
		} drm_set_version_t;
		};

		#define DRM_IOCTL_BASE 'd'
		#define DRM_IO(nr) _IO(DRM_IOCTL_BASE,nr)
		@@ -596,61 +596,61 @@ typedef struct drm_set_version {
		#define DRM_IOW(nr,type) _IOW(DRM_IOCTL_BASE,nr,type)
		#define DRM_IOWR(nr,type) _IOWR(DRM_IOCTL_BASE,nr,type)

		#define DRM_IOCTL_VERSION DRM_IOWR(0x00, drm_version_t)
		#define DRM_IOCTL_GET_UNIQUE DRM_IOWR(0x01, drm_unique_t)
		#define DRM_IOCTL_GET_MAGIC DRM_IOR( 0x02, drm_auth_t)
		#define DRM_IOCTL_IRQ_BUSID DRM_IOWR(0x03, drm_irq_busid_t)
		#define DRM_IOCTL_GET_MAP DRM_IOWR(0x04, drm_map_t)
		#define DRM_IOCTL_GET_CLIENT DRM_IOWR(0x05, drm_client_t)
		#define DRM_IOCTL_GET_STATS DRM_IOR( 0x06, drm_stats_t)
		#define DRM_IOCTL_SET_VERSION DRM_IOWR(0x07, drm_set_version_t)

		#define DRM_IOCTL_SET_UNIQUE DRM_IOW( 0x10, drm_unique_t)
		#define DRM_IOCTL_AUTH_MAGIC DRM_IOW( 0x11, drm_auth_t)
		#define DRM_IOCTL_BLOCK DRM_IOWR(0x12, drm_block_t)
		#define DRM_IOCTL_UNBLOCK DRM_IOWR(0x13, drm_block_t)
		#define DRM_IOCTL_CONTROL DRM_IOW( 0x14, drm_control_t)
		#define DRM_IOCTL_ADD_MAP DRM_IOWR(0x15, drm_map_t)
		#define DRM_IOCTL_ADD_BUFS DRM_IOWR(0x16, drm_buf_desc_t)
		#define DRM_IOCTL_MARK_BUFS DRM_IOW( 0x17, drm_buf_desc_t)
		#define DRM_IOCTL_INFO_BUFS DRM_IOWR(0x18, drm_buf_info_t)
		#define DRM_IOCTL_MAP_BUFS DRM_IOWR(0x19, drm_buf_map_t)
		#define DRM_IOCTL_FREE_BUFS DRM_IOW( 0x1a, drm_buf_free_t)

		#define DRM_IOCTL_RM_MAP DRM_IOW( 0x1b, drm_map_t)

		#define DRM_IOCTL_SET_SAREA_CTX DRM_IOW( 0x1c, drm_ctx_priv_map_t)
		#define DRM_IOCTL_GET_SAREA_CTX DRM_IOWR(0x1d, drm_ctx_priv_map_t)

		#define DRM_IOCTL_ADD_CTX DRM_IOWR(0x20, drm_ctx_t)
		#define DRM_IOCTL_RM_CTX DRM_IOWR(0x21, drm_ctx_t)
		#define DRM_IOCTL_MOD_CTX DRM_IOW( 0x22, drm_ctx_t)
		#define DRM_IOCTL_GET_CTX DRM_IOWR(0x23, drm_ctx_t)
		#define DRM_IOCTL_SWITCH_CTX DRM_IOW( 0x24, drm_ctx_t)
		#define DRM_IOCTL_NEW_CTX DRM_IOW( 0x25, drm_ctx_t)
		#define DRM_IOCTL_RES_CTX DRM_IOWR(0x26, drm_ctx_res_t)
		#define DRM_IOCTL_ADD_DRAW DRM_IOWR(0x27, drm_draw_t)
		#define DRM_IOCTL_RM_DRAW DRM_IOWR(0x28, drm_draw_t)
		#define DRM_IOCTL_DMA DRM_IOWR(0x29, drm_dma_t)
		#define DRM_IOCTL_LOCK DRM_IOW( 0x2a, drm_lock_t)
		#define DRM_IOCTL_UNLOCK DRM_IOW( 0x2b, drm_lock_t)
		#define DRM_IOCTL_FINISH DRM_IOW( 0x2c, drm_lock_t)
		#define DRM_IOCTL_VERSION DRM_IOWR(0x00, struct drm_version)
		#define DRM_IOCTL_GET_UNIQUE DRM_IOWR(0x01, struct drm_unique)
		#define DRM_IOCTL_GET_MAGIC DRM_IOR( 0x02, struct drm_auth)
		#define DRM_IOCTL_IRQ_BUSID DRM_IOWR(0x03, struct drm_irq_busid)
		#define DRM_IOCTL_GET_MAP DRM_IOWR(0x04, struct drm_map)
		#define DRM_IOCTL_GET_CLIENT DRM_IOWR(0x05, struct drm_client)
		#define DRM_IOCTL_GET_STATS DRM_IOR( 0x06, struct drm_stats)
		#define DRM_IOCTL_SET_VERSION DRM_IOWR(0x07, struct drm_set_version)

		#define DRM_IOCTL_SET_UNIQUE DRM_IOW( 0x10, struct drm_unique)
		#define DRM_IOCTL_AUTH_MAGIC DRM_IOW( 0x11, struct drm_auth)
		#define DRM_IOCTL_BLOCK DRM_IOWR(0x12, struct drm_block)
		#define DRM_IOCTL_UNBLOCK DRM_IOWR(0x13, struct drm_block)
		#define DRM_IOCTL_CONTROL DRM_IOW( 0x14, struct drm_control)
		#define DRM_IOCTL_ADD_MAP DRM_IOWR(0x15, struct drm_map)
		#define DRM_IOCTL_ADD_BUFS DRM_IOWR(0x16, struct drm_buf_desc)
		#define DRM_IOCTL_MARK_BUFS DRM_IOW( 0x17, struct drm_buf_desc)
		#define DRM_IOCTL_INFO_BUFS DRM_IOWR(0x18, struct drm_buf_info)
		#define DRM_IOCTL_MAP_BUFS DRM_IOWR(0x19, struct drm_buf_map)
		#define DRM_IOCTL_FREE_BUFS DRM_IOW( 0x1a, struct drm_buf_free)

		#define DRM_IOCTL_RM_MAP DRM_IOW( 0x1b, struct drm_map)

		#define DRM_IOCTL_SET_SAREA_CTX DRM_IOW( 0x1c, struct drm_ctx_priv_map)
		#define DRM_IOCTL_GET_SAREA_CTX DRM_IOWR(0x1d, struct drm_ctx_priv_map)

		#define DRM_IOCTL_ADD_CTX DRM_IOWR(0x20, struct drm_ctx)
		#define DRM_IOCTL_RM_CTX DRM_IOWR(0x21, struct drm_ctx)
		#define DRM_IOCTL_MOD_CTX DRM_IOW( 0x22, struct drm_ctx)
		#define DRM_IOCTL_GET_CTX DRM_IOWR(0x23, struct drm_ctx)
		#define DRM_IOCTL_SWITCH_CTX DRM_IOW( 0x24, struct drm_ctx)
		#define DRM_IOCTL_NEW_CTX DRM_IOW( 0x25, struct drm_ctx)
		#define DRM_IOCTL_RES_CTX DRM_IOWR(0x26, struct drm_ctx_res)
		#define DRM_IOCTL_ADD_DRAW DRM_IOWR(0x27, struct drm_draw)
		#define DRM_IOCTL_RM_DRAW DRM_IOWR(0x28, struct drm_draw)
		#define DRM_IOCTL_DMA DRM_IOWR(0x29, struct drm_dma)
		#define DRM_IOCTL_LOCK DRM_IOW( 0x2a, struct drm_lock)
		#define DRM_IOCTL_UNLOCK DRM_IOW( 0x2b, struct drm_lock)
		#define DRM_IOCTL_FINISH DRM_IOW( 0x2c, struct drm_lock)

		#define DRM_IOCTL_AGP_ACQUIRE DRM_IO( 0x30)
		#define DRM_IOCTL_AGP_RELEASE DRM_IO( 0x31)
		#define DRM_IOCTL_AGP_ENABLE DRM_IOW( 0x32, drm_agp_mode_t)
		#define DRM_IOCTL_AGP_INFO DRM_IOR( 0x33, drm_agp_info_t)
		#define DRM_IOCTL_AGP_ALLOC DRM_IOWR(0x34, drm_agp_buffer_t)
		#define DRM_IOCTL_AGP_FREE DRM_IOW( 0x35, drm_agp_buffer_t)
		#define DRM_IOCTL_AGP_BIND DRM_IOW( 0x36, drm_agp_binding_t)
		#define DRM_IOCTL_AGP_UNBIND DRM_IOW( 0x37, drm_agp_binding_t)
		#define DRM_IOCTL_AGP_ENABLE DRM_IOW( 0x32, struct drm_agp_mode)
		#define DRM_IOCTL_AGP_INFO DRM_IOR( 0x33, struct drm_agp_info)
		#define DRM_IOCTL_AGP_ALLOC DRM_IOWR(0x34, struct drm_agp_buffer)
		#define DRM_IOCTL_AGP_FREE DRM_IOW( 0x35, struct drm_agp_buffer)
		#define DRM_IOCTL_AGP_BIND DRM_IOW( 0x36, struct drm_agp_binding)
		#define DRM_IOCTL_AGP_UNBIND DRM_IOW( 0x37, struct drm_agp_binding)

		#define DRM_IOCTL_SG_ALLOC DRM_IOW( 0x38, drm_scatter_gather_t)
		#define DRM_IOCTL_SG_FREE DRM_IOW( 0x39, drm_scatter_gather_t)
		#define DRM_IOCTL_SG_ALLOC DRM_IOW( 0x38, struct drm_scatter_gather)
		#define DRM_IOCTL_SG_FREE DRM_IOW( 0x39, struct drm_scatter_gather)

		#define DRM_IOCTL_WAIT_VBLANK DRM_IOWR(0x3a, drm_wait_vblank_t)
		#define DRM_IOCTL_WAIT_VBLANK DRM_IOWR(0x3a, union drm_wait_vblank)

		#define DRM_IOCTL_UPDATE_DRAW DRM_IOW(0x3f, drm_update_draw_t)
		#define DRM_IOCTL_UPDATE_DRAW DRM_IOW(0x3f, struct drm_update_draw)

		/**
		* Device specific ioctls should only be in their respective headers
		@@ -663,4 +663,49 @@ typedef struct drm_set_version {
		#define DRM_COMMAND_BASE 0x40
		#define DRM_COMMAND_END 0xA0

		/* typedef area */
		#ifndef __KERNEL__
		typedef struct drm_clip_rect drm_clip_rect_t;
		typedef struct drm_drawable_info drm_drawable_info_t;
		typedef struct drm_tex_region drm_tex_region_t;
		typedef struct drm_hw_lock drm_hw_lock_t;
		typedef struct drm_version drm_version_t;
		typedef struct drm_unique drm_unique_t;
		typedef struct drm_list drm_list_t;
		typedef struct drm_block drm_block_t;
		typedef struct drm_control drm_control_t;
		typedef enum drm_map_type drm_map_type_t;
		typedef enum drm_map_flags drm_map_flags_t;
		typedef struct drm_ctx_priv_map drm_ctx_priv_map_t;
		typedef struct drm_map drm_map_t;
		typedef struct drm_client drm_client_t;
		typedef enum drm_stat_type drm_stat_type_t;
		typedef struct drm_stats drm_stats_t;
		typedef enum drm_lock_flags drm_lock_flags_t;
		typedef struct drm_lock drm_lock_t;
		typedef enum drm_dma_flags drm_dma_flags_t;
		typedef struct drm_buf_desc drm_buf_desc_t;
		typedef struct drm_buf_info drm_buf_info_t;
		typedef struct drm_buf_free drm_buf_free_t;
		typedef struct drm_buf_pub drm_buf_pub_t;
		typedef struct drm_buf_map drm_buf_map_t;
		typedef struct drm_dma drm_dma_t;
		typedef union drm_wait_vblank drm_wait_vblank_t;
		typedef struct drm_agp_mode drm_agp_mode_t;
		typedef enum drm_ctx_flags drm_ctx_flags_t;
		typedef struct drm_ctx drm_ctx_t;
		typedef struct drm_ctx_res drm_ctx_res_t;
		typedef struct drm_draw drm_draw_t;
		typedef struct drm_update_draw drm_update_draw_t;
		typedef struct drm_auth drm_auth_t;
		typedef struct drm_irq_busid drm_irq_busid_t;
		typedef enum drm_vblank_seq_type drm_vblank_seq_type_t;

		typedef struct drm_agp_buffer drm_agp_buffer_t;
		typedef struct drm_agp_binding drm_agp_binding_t;
		typedef struct drm_agp_info drm_agp_info_t;
		typedef struct drm_scatter_gather drm_scatter_gather_t;
		typedef struct drm_set_version drm_set_version_t;
		#endif

		#endif

drivers/char/drm/drmP.h

+23 −22

File changed.

Preview size limit exceeded, changes collapsed.

drivers/char/drm/drm_agpsupport.c

+18 −18

Original line number	Diff line number	Diff line
		@@ -48,7 +48,7 @@
		* Verifies the AGP device has been initialized and acquired and fills in the
		* drm_agp_info structure with the information in drm_agp_head::agp_info.
		*/
		int drm_agp_info(drm_device_t * dev, drm_agp_info_t * info)
		int drm_agp_info(drm_device_t * dev, struct drm_agp_info * info)
		{
		DRM_AGP_KERN *kern;

		@@ -76,14 +76,14 @@ int drm_agp_info_ioctl(struct inode inode, struct file filp,
		{
		drm_file_t *priv = filp->private_data;
		drm_device_t *dev = priv->head->dev;
		drm_agp_info_t info;
		struct drm_agp_info info;
		int err;

		err = drm_agp_info(dev, &info);
		if (err)
		return err;

		if (copy_to_user((drm_agp_info_t __user *) arg, &info, sizeof(info)))
		if (copy_to_user((struct drm_agp_info __user *) arg, &info, sizeof(info)))
		return -EFAULT;
		return 0;
		}
		@@ -168,7 +168,7 @@ int drm_agp_release_ioctl(struct inode inode, struct file filp,
		* Verifies the AGP device has been acquired but not enabled, and calls
		* \c agp_enable.
		*/
		int drm_agp_enable(drm_device_t * dev, drm_agp_mode_t mode)
		int drm_agp_enable(drm_device_t * dev, struct drm_agp_mode mode)
		{
		if (!dev->agp \|\| !dev->agp->acquired)
		return -EINVAL;
		@@ -187,9 +187,9 @@ int drm_agp_enable_ioctl(struct inode inode, struct file filp,
		{
		drm_file_t *priv = filp->private_data;
		drm_device_t *dev = priv->head->dev;
		drm_agp_mode_t mode;
		struct drm_agp_mode mode;

		if (copy_from_user(&mode, (drm_agp_mode_t __user *) arg, sizeof(mode)))
		if (copy_from_user(&mode, (struct drm_agp_mode __user *) arg, sizeof(mode)))
		return -EFAULT;

		return drm_agp_enable(dev, mode);
		@@ -207,7 +207,7 @@ int drm_agp_enable_ioctl(struct inode inode, struct file filp,
		* Verifies the AGP device is present and has been acquired, allocates the
		* memory via alloc_agp() and creates a drm_agp_mem entry for it.
		*/
		int drm_agp_alloc(drm_device_t dev, drm_agp_buffer_t request)
		int drm_agp_alloc(drm_device_t dev, struct drm_agp_buffer request)
		{
		drm_agp_mem_t *entry;
		DRM_AGP_MEM *memory;
		@@ -246,8 +246,8 @@ int drm_agp_alloc_ioctl(struct inode inode, struct file filp,
		{
		drm_file_t *priv = filp->private_data;
		drm_device_t *dev = priv->head->dev;
		drm_agp_buffer_t request;
		drm_agp_buffer_t __user argp = (void __user )arg;
		struct drm_agp_buffer request;
		struct drm_agp_buffer __user argp = (void __user )arg;
		int err;

		if (copy_from_user(&request, argp, sizeof(request)))
		@@ -305,7 +305,7 @@ static drm_agp_mem_t drm_agp_lookup_entry(drm_device_t dev,
		* Verifies the AGP device is present and acquired, looks-up the AGP memory
		* entry and passes it to the unbind_agp() function.
		*/
		int drm_agp_unbind(drm_device_t dev, drm_agp_binding_t request)
		int drm_agp_unbind(drm_device_t dev, struct drm_agp_binding request)
		{
		drm_agp_mem_t *entry;
		int ret;
		@@ -328,10 +328,10 @@ int drm_agp_unbind_ioctl(struct inode inode, struct file filp,
		{
		drm_file_t *priv = filp->private_data;
		drm_device_t *dev = priv->head->dev;
		drm_agp_binding_t request;
		struct drm_agp_binding request;

		if (copy_from_user
		(&request, (drm_agp_binding_t __user *) arg, sizeof(request)))
		(&request, (struct drm_agp_binding __user *) arg, sizeof(request)))
		return -EFAULT;

		return drm_agp_unbind(dev, &request);
		@@ -350,7 +350,7 @@ int drm_agp_unbind_ioctl(struct inode inode, struct file filp,
		* is currently bound into the GATT. Looks-up the AGP memory entry and passes
		* it to bind_agp() function.
		*/
		int drm_agp_bind(drm_device_t dev, drm_agp_binding_t request)
		int drm_agp_bind(drm_device_t dev, struct drm_agp_binding request)
		{
		drm_agp_mem_t *entry;
		int retcode;
		@@ -377,10 +377,10 @@ int drm_agp_bind_ioctl(struct inode inode, struct file filp,
		{
		drm_file_t *priv = filp->private_data;
		drm_device_t *dev = priv->head->dev;
		drm_agp_binding_t request;
		struct drm_agp_binding request;

		if (copy_from_user
		(&request, (drm_agp_binding_t __user *) arg, sizeof(request)))
		(&request, (struct drm_agp_binding __user *) arg, sizeof(request)))
		return -EFAULT;

		return drm_agp_bind(dev, &request);
		@@ -400,7 +400,7 @@ int drm_agp_bind_ioctl(struct inode inode, struct file filp,
		* unbind_agp(). Frees it via free_agp() as well as the entry itself
		* and unlinks from the doubly linked list it's inserted in.
		*/
		int drm_agp_free(drm_device_t dev, drm_agp_buffer_t request)
		int drm_agp_free(drm_device_t dev, struct drm_agp_buffer request)
		{
		drm_agp_mem_t *entry;

		@@ -424,10 +424,10 @@ int drm_agp_free_ioctl(struct inode inode, struct file filp,
		{
		drm_file_t *priv = filp->private_data;
		drm_device_t *dev = priv->head->dev;
		drm_agp_buffer_t request;
		struct drm_agp_buffer request;

		if (copy_from_user
		(&request, (drm_agp_buffer_t __user *) arg, sizeof(request)))
		(&request, (struct drm_agp_buffer __user *) arg, sizeof(request)))
		return -EFAULT;

		return drm_agp_free(dev, &request);

drivers/char/drm/drm_auth.c

+4 −4

Original line number	Diff line number	Diff line
		@@ -144,7 +144,7 @@ int drm_getmagic(struct inode inode, struct file filp,
		static DEFINE_SPINLOCK(lock);
		drm_file_t *priv = filp->private_data;
		drm_device_t *dev = priv->head->dev;
		drm_auth_t auth;
		struct drm_auth auth;

		/* Find unique magic */
		if (priv->magic) {
		@@ -162,7 +162,7 @@ int drm_getmagic(struct inode inode, struct file filp,
		}

		DRM_DEBUG("%u\n", auth.magic);
		if (copy_to_user((drm_auth_t __user *) arg, &auth, sizeof(auth)))
		if (copy_to_user((struct drm_auth __user *) arg, &auth, sizeof(auth)))
		return -EFAULT;
		return 0;
		}
		@@ -183,10 +183,10 @@ int drm_authmagic(struct inode inode, struct file filp,
		{
		drm_file_t *priv = filp->private_data;
		drm_device_t *dev = priv->head->dev;
		drm_auth_t auth;
		struct drm_auth auth;
		drm_file_t *file;

		if (copy_from_user(&auth, (drm_auth_t __user *) arg, sizeof(auth)))
		if (copy_from_user(&auth, (struct drm_auth __user *) arg, sizeof(auth)))
		return -EFAULT;
		DRM_DEBUG("%u\n", auth.magic);
		if ((file = drm_find_file(dev, auth.magic))) {

drivers/char/drm/drm_bufs.c

+29 −29

File changed.

Preview size limit exceeded, changes collapsed.