drm: detypedef drm.h and fixup all problems
parent
4be9554fcd
commit
b95ac8b7b3
|
@ -296,13 +296,9 @@ typedef struct drm_ioctl_desc {
|
|||
int flags;
|
||||
} drm_ioctl_desc_t;
|
||||
|
||||
typedef struct drm_devstate {
|
||||
pid_t owner; /**< X server pid holding x_lock */
|
||||
} drm_devstate_t;
|
||||
|
||||
typedef struct drm_magic_entry {
|
||||
struct list_head head;
|
||||
drm_hash_item_t hash_item;
|
||||
struct drm_hash_item hash_item;
|
||||
struct drm_file *priv;
|
||||
} drm_magic_entry_t;
|
||||
|
||||
|
@ -346,10 +342,10 @@ typedef struct drm_buf {
|
|||
/** bufs is one longer than it has to be */
|
||||
typedef struct drm_waitlist {
|
||||
int count; /**< Number of possible buffers */
|
||||
drm_buf_t **bufs; /**< List of pointers to buffers */
|
||||
drm_buf_t **rp; /**< Read pointer */
|
||||
drm_buf_t **wp; /**< Write pointer */
|
||||
drm_buf_t **end; /**< End pointer */
|
||||
struct drm_buf **bufs; /**< List of pointers to buffers */
|
||||
struct drm_buf **rp; /**< Read pointer */
|
||||
struct drm_buf **wp; /**< Write pointer */
|
||||
struct drm_buf **end; /**< End pointer */
|
||||
spinlock_t read_lock;
|
||||
spinlock_t write_lock;
|
||||
} drm_waitlist_t;
|
||||
|
@ -357,7 +353,7 @@ typedef struct drm_waitlist {
|
|||
typedef struct drm_freelist {
|
||||
int initialized; /**< Freelist in use */
|
||||
atomic_t count; /**< Number of free buffers */
|
||||
drm_buf_t *next; /**< End pointer */
|
||||
struct drm_buf *next; /**< End pointer */
|
||||
|
||||
wait_queue_head_t waiting; /**< Processes waiting on free bufs */
|
||||
int low_mark; /**< Low water mark */
|
||||
|
@ -378,11 +374,11 @@ typedef struct drm_dma_handle {
|
|||
typedef struct drm_buf_entry {
|
||||
int buf_size; /**< size */
|
||||
int buf_count; /**< number of buffers */
|
||||
drm_buf_t *buflist; /**< buffer list */
|
||||
struct drm_buf *buflist; /**< buffer list */
|
||||
int seg_count;
|
||||
int page_order;
|
||||
drm_dma_handle_t **seglist;
|
||||
drm_freelist_t freelist;
|
||||
struct drm_dma_handle **seglist;
|
||||
struct drm_freelist freelist;
|
||||
} drm_buf_entry_t;
|
||||
|
||||
/*
|
||||
|
@ -440,8 +436,8 @@ typedef struct drm_queue {
|
|||
atomic_t total_flushed; /**< Total flushes statistic */
|
||||
atomic_t total_locks; /**< Total locks statistics */
|
||||
#endif
|
||||
drm_ctx_flags_t flags; /**< Context preserving and 2D-only */
|
||||
drm_waitlist_t waitlist; /**< Pending buffers */
|
||||
enum drm_ctx_flags flags; /**< Context preserving and 2D-only */
|
||||
struct drm_waitlist waitlist; /**< Pending buffers */
|
||||
wait_queue_head_t flush_queue; /**< Processes waiting until flush */
|
||||
} drm_queue_t;
|
||||
|
||||
|
@ -449,7 +445,7 @@ typedef struct drm_queue {
|
|||
* Lock data.
|
||||
*/
|
||||
typedef struct drm_lock_data {
|
||||
drm_hw_lock_t *hw_lock; /**< Hardware lock */
|
||||
struct drm_hw_lock *hw_lock; /**< Hardware lock */
|
||||
struct file *filp; /**< File descr of lock holder (0=kernel) */
|
||||
wait_queue_head_t lock_queue; /**< Queue of blocked processes */
|
||||
unsigned long lock_time; /**< Time of last lock in jiffies */
|
||||
|
@ -464,9 +460,9 @@ typedef struct drm_lock_data {
|
|||
*/
|
||||
typedef struct drm_device_dma {
|
||||
|
||||
drm_buf_entry_t bufs[DRM_MAX_ORDER + 1]; /**< buffers, grouped by their size order */
|
||||
struct drm_buf_entry bufs[DRM_MAX_ORDER + 1]; /**< buffers, grouped by their size order */
|
||||
int buf_count; /**< total number of buffers */
|
||||
drm_buf_t **buflist; /**< Vector of pointers into drm_device_dma::bufs */
|
||||
struct drm_buf **buflist; /**< Vector of pointers into drm_device_dma::bufs */
|
||||
int seg_count;
|
||||
int page_count; /**< number of pages */
|
||||
unsigned long *pagelist; /**< page list */
|
||||
|
@ -524,7 +520,7 @@ typedef struct drm_sg_mem {
|
|||
|
||||
typedef struct drm_sigdata {
|
||||
int context;
|
||||
drm_hw_lock_t *lock;
|
||||
struct drm_hw_lock *lock;
|
||||
} drm_sigdata_t;
|
||||
|
||||
|
||||
|
@ -553,13 +549,13 @@ typedef struct drm_mm {
|
|||
*/
|
||||
typedef struct drm_map_list {
|
||||
struct list_head head; /**< list head */
|
||||
drm_hash_item_t hash;
|
||||
drm_map_t *map; /**< mapping */
|
||||
struct drm_hash_item hash;
|
||||
struct drm_map *map; /**< mapping */
|
||||
drm_u64_t user_token;
|
||||
drm_mm_node_t *file_offset_node;
|
||||
} drm_map_list_t;
|
||||
|
||||
typedef drm_map_t drm_local_map_t;
|
||||
typedef struct drm_map drm_local_map_t;
|
||||
|
||||
/**
|
||||
* Context handle list
|
||||
|
@ -567,7 +563,7 @@ typedef drm_map_t drm_local_map_t;
|
|||
typedef struct drm_ctx_list {
|
||||
struct list_head head; /**< list head */
|
||||
drm_context_t handle; /**< context handle */
|
||||
drm_file_t *tag; /**< associated fd private data */
|
||||
struct drm_file *tag; /**< associated fd private data */
|
||||
} drm_ctx_list_t;
|
||||
|
||||
typedef struct drm_vbl_sig {
|
||||
|
@ -646,9 +642,9 @@ struct drm_driver {
|
|||
struct file * filp);
|
||||
void (*reclaim_buffers_idlelocked) (struct drm_device *dev,
|
||||
struct file * filp);
|
||||
unsigned long (*get_map_ofs) (drm_map_t * map);
|
||||
unsigned long (*get_map_ofs) (struct drm_map * map);
|
||||
unsigned long (*get_reg_ofs) (struct drm_device * dev);
|
||||
void (*set_version) (struct drm_device * dev, drm_set_version_t * sv);
|
||||
void (*set_version) (struct drm_device * dev, struct drm_set_version * sv);
|
||||
|
||||
struct drm_fence_driver *fence_driver;
|
||||
struct drm_bo_driver *bo_driver;
|
||||
|
@ -713,14 +709,14 @@ typedef struct drm_device {
|
|||
/** \name Performance counters */
|
||||
/*@{ */
|
||||
unsigned long counters;
|
||||
drm_stat_type_t types[15];
|
||||
enum drm_stat_type types[15];
|
||||
atomic_t counts[15];
|
||||
/*@} */
|
||||
|
||||
/** \name Authentication */
|
||||
/*@{ */
|
||||
struct list_head filelist;
|
||||
drm_open_hash_t magiclist;
|
||||
struct drm_open_hash magiclist;
|
||||
struct list_head magicfree;
|
||||
/*@} */
|
||||
|
||||
|
@ -728,7 +724,7 @@ typedef struct drm_device {
|
|||
/*@{ */
|
||||
struct list_head maplist; /**< Linked list of regions */
|
||||
int map_count; /**< Number of mappable regions */
|
||||
drm_open_hash_t map_hash; /**< User token hash table for maps */
|
||||
struct drm_open_hash map_hash; /**< User token hash table for maps */
|
||||
drm_mm_t offset_manager; /**< User token manager */
|
||||
drm_open_hash_t object_hash; /**< User token hash table for objects */
|
||||
struct address_space *dev_mapping; /**< For unmap_mapping_range() */
|
||||
|
@ -743,7 +739,7 @@ typedef struct drm_device {
|
|||
struct idr ctx_idr;
|
||||
|
||||
struct list_head vmalist; /**< List of vmas (for debugging) */
|
||||
drm_lock_data_t lock; /**< Information on hardware lock */
|
||||
struct drm_lock_data lock; /**< Information on hardware lock */
|
||||
/*@} */
|
||||
|
||||
/** \name DMA queues (contexts) */
|
||||
|
@ -751,8 +747,8 @@ typedef struct drm_device {
|
|||
int queue_count; /**< Number of active DMA queues */
|
||||
int queue_reserved; /**< Number of reserved DMA queues */
|
||||
int queue_slots; /**< Actual length of queuelist */
|
||||
drm_queue_t **queuelist; /**< Vector of pointers to DMA queues */
|
||||
drm_device_dma_t *dma; /**< Optional pointer for DMA support */
|
||||
struct drm_queue **queuelist; /**< Vector of pointers to DMA queues */
|
||||
struct drm_device_dma *dma; /**< Optional pointer for DMA support */
|
||||
/*@} */
|
||||
|
||||
/** \name Context support */
|
||||
|
@ -792,7 +788,7 @@ typedef struct drm_device {
|
|||
wait_queue_head_t buf_readers; /**< Processes waiting to read */
|
||||
wait_queue_head_t buf_writers; /**< Processes waiting to ctx switch */
|
||||
|
||||
drm_agp_head_t *agp; /**< AGP data */
|
||||
struct drm_agp_head *agp; /**< AGP data */
|
||||
|
||||
struct pci_dev *pdev; /**< PCI device structure */
|
||||
int pci_vendor; /**< PCI vendor id */
|
||||
|
@ -800,15 +796,15 @@ typedef struct drm_device {
|
|||
#ifdef __alpha__
|
||||
struct pci_controller *hose;
|
||||
#endif
|
||||
drm_sg_mem_t *sg; /**< Scatter gather memory */
|
||||
struct drm_sg_mem *sg; /**< Scatter gather memory */
|
||||
void *dev_private; /**< device private data */
|
||||
drm_sigdata_t sigdata; /**< For block_all_signals */
|
||||
struct drm_sigdata sigdata; /**< For block_all_signals */
|
||||
sigset_t sigmask;
|
||||
|
||||
struct drm_driver *driver;
|
||||
drm_local_map_t *agp_buffer_map;
|
||||
unsigned int agp_buffer_token;
|
||||
drm_head_t primary; /**< primary screen head */
|
||||
struct drm_head primary; /**< primary screen head */
|
||||
|
||||
drm_fence_manager_t fm;
|
||||
drm_buffer_manager_t bm;
|
||||
|
@ -915,7 +911,7 @@ unsigned int drm_poll(struct file *filp, struct poll_table_struct *wait);
|
|||
|
||||
/* Mapping support (drm_vm.h) */
|
||||
extern int drm_mmap(struct file *filp, struct vm_area_struct *vma);
|
||||
extern unsigned long drm_core_get_map_ofs(drm_map_t * map);
|
||||
extern unsigned long drm_core_get_map_ofs(struct drm_map * map);
|
||||
extern unsigned long drm_core_get_reg_ofs(struct drm_device *dev);
|
||||
extern pgprot_t drm_io_prot(uint32_t map_type, struct vm_area_struct *vma);
|
||||
|
||||
|
@ -992,7 +988,7 @@ extern int drm_rmdraw(struct inode *inode, struct file *filp,
|
|||
unsigned int cmd, unsigned long arg);
|
||||
extern int drm_update_drawable_info(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg);
|
||||
extern drm_drawable_info_t *drm_get_drawable_info(drm_device_t *dev,
|
||||
extern struct drm_drawable_info *drm_get_drawable_info(drm_device_t *dev,
|
||||
drm_drawable_t id);
|
||||
extern void drm_drawable_free_all(drm_device_t *dev);
|
||||
|
||||
|
@ -1021,12 +1017,12 @@ extern int drm_i_have_hw_lock(struct file *filp);
|
|||
extern int drm_kernel_take_hw_lock(struct file *filp);
|
||||
|
||||
/* Buffer management support (drm_bufs.h) */
|
||||
extern int drm_addbufs_agp(drm_device_t * dev, drm_buf_desc_t * request);
|
||||
extern int drm_addbufs_pci(drm_device_t * dev, drm_buf_desc_t * request);
|
||||
extern int drm_addbufs_fb (drm_device_t * dev, drm_buf_desc_t * request);
|
||||
extern int drm_addbufs_agp(drm_device_t * dev, struct drm_buf_desc * request);
|
||||
extern int drm_addbufs_pci(drm_device_t * dev, struct drm_buf_desc * request);
|
||||
extern int drm_addbufs_fb (drm_device_t * dev, struct drm_buf_desc * request);
|
||||
extern int drm_addmap(drm_device_t * dev, unsigned int offset,
|
||||
unsigned int size, drm_map_type_t type,
|
||||
drm_map_flags_t flags, drm_local_map_t ** map_ptr);
|
||||
unsigned int size, enum drm_map_type type,
|
||||
enum drm_map_flags flags, drm_local_map_t ** map_ptr);
|
||||
extern int drm_addmap_ioctl(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg);
|
||||
extern int drm_rmmap(drm_device_t *dev, drm_local_map_t *map);
|
||||
|
@ -1081,22 +1077,22 @@ extern int drm_agp_acquire_ioctl(struct inode *inode, struct file *filp,
|
|||
extern int drm_agp_release(drm_device_t *dev);
|
||||
extern int drm_agp_release_ioctl(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg);
|
||||
extern int drm_agp_enable(drm_device_t *dev, drm_agp_mode_t mode);
|
||||
extern int drm_agp_enable(drm_device_t *dev, struct drm_agp_mode mode);
|
||||
extern int drm_agp_enable_ioctl(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg);
|
||||
extern int drm_agp_info(drm_device_t * dev, drm_agp_info_t *info);
|
||||
extern int drm_agp_info(drm_device_t * dev, struct drm_agp_info *info);
|
||||
extern int drm_agp_info_ioctl(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg);
|
||||
extern int drm_agp_alloc(drm_device_t *dev, drm_agp_buffer_t *request);
|
||||
extern int drm_agp_alloc(drm_device_t *dev, struct drm_agp_buffer *request);
|
||||
extern int drm_agp_alloc_ioctl(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg);
|
||||
extern int drm_agp_free(drm_device_t *dev, drm_agp_buffer_t *request);
|
||||
extern int drm_agp_free(drm_device_t *dev, struct drm_agp_buffer *request);
|
||||
extern int drm_agp_free_ioctl(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg);
|
||||
extern int drm_agp_unbind(drm_device_t *dev, drm_agp_binding_t *request);
|
||||
extern int drm_agp_unbind(drm_device_t *dev, struct drm_agp_binding *request);
|
||||
extern int drm_agp_unbind_ioctl(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg);
|
||||
extern int drm_agp_bind(drm_device_t *dev, drm_agp_binding_t *request);
|
||||
extern int drm_agp_bind(drm_device_t *dev, struct drm_agp_binding *request);
|
||||
extern int drm_agp_bind_ioctl(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg);
|
||||
#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,11)
|
||||
|
@ -1134,7 +1130,7 @@ extern int drm_proc_cleanup(int minor,
|
|||
extern void drm_sg_cleanup(drm_sg_mem_t * entry);
|
||||
extern int drm_sg_alloc_ioctl(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg);
|
||||
extern int drm_sg_alloc(drm_device_t *dev, drm_scatter_gather_t * request);
|
||||
extern int drm_sg_alloc(drm_device_t *dev, struct drm_scatter_gather * request);
|
||||
extern int drm_sg_free(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg);
|
||||
|
||||
|
|
|
@ -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;
|
||||
|
||||
|
@ -75,14 +75,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;
|
||||
}
|
||||
|
@ -181,7 +181,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;
|
||||
|
@ -203,10 +203,10 @@ 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);
|
||||
|
@ -224,7 +224,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;
|
||||
|
@ -264,8 +264,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)))
|
||||
|
@ -323,7 +323,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;
|
||||
|
@ -347,10 +347,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);
|
||||
|
@ -370,7 +370,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;
|
||||
|
@ -398,10 +398,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);
|
||||
|
@ -422,7 +422,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;
|
||||
|
||||
|
@ -448,10 +448,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);
|
||||
|
|
|
@ -45,15 +45,15 @@
|
|||
* the one with matching magic number, while holding the drm_device::struct_mutex
|
||||
* lock.
|
||||
*/
|
||||
static drm_file_t *drm_find_file(drm_device_t * dev, drm_magic_t magic)
|
||||
static struct drm_file *drm_find_file(struct drm_device * dev, drm_magic_t magic)
|
||||
{
|
||||
drm_file_t *retval = NULL;
|
||||
drm_magic_entry_t *pt;
|
||||
drm_hash_item_t *hash;
|
||||
struct drm_file *retval = NULL;
|
||||
struct drm_magic_entry *pt;
|
||||
struct drm_hash_item *hash;
|
||||
|
||||
mutex_lock(&dev->struct_mutex);
|
||||
if (!drm_ht_find_item(&dev->magiclist, (unsigned long) magic, &hash)) {
|
||||
pt = drm_hash_entry(hash, drm_magic_entry_t, hash_item);
|
||||
if (!drm_ht_find_item(&dev->magiclist, (unsigned long)magic, &hash)) {
|
||||
pt = drm_hash_entry(hash, struct drm_magic_entry, hash_item);
|
||||
retval = pt->priv;
|
||||
}
|
||||
mutex_unlock(&dev->struct_mutex);
|
||||
|
@ -71,10 +71,10 @@ static drm_file_t *drm_find_file(drm_device_t * dev, drm_magic_t magic)
|
|||
* associated the magic number hash key in drm_device::magiclist, while holding
|
||||
* the drm_device::struct_mutex lock.
|
||||
*/
|
||||
static int drm_add_magic(drm_device_t *dev, drm_file_t *priv,
|
||||
static int drm_add_magic(struct drm_device * dev, struct drm_file * priv,
|
||||
drm_magic_t magic)
|
||||
{
|
||||
drm_magic_entry_t *entry;
|
||||
struct drm_magic_entry *entry;
|
||||
|
||||
DRM_DEBUG("%d\n", magic);
|
||||
|
||||
|
@ -101,10 +101,10 @@ static int drm_add_magic(drm_device_t *dev, drm_file_t *priv,
|
|||
* Searches and unlinks the entry in drm_device::magiclist with the magic
|
||||
* number hash key, while holding the drm_device::struct_mutex lock.
|
||||
*/
|
||||
static int drm_remove_magic(drm_device_t * dev, drm_magic_t magic)
|
||||
static int drm_remove_magic(struct drm_device * dev, drm_magic_t magic)
|
||||
{
|
||||
drm_magic_entry_t *pt;
|
||||
drm_hash_item_t *hash;
|
||||
struct drm_magic_entry *pt;
|
||||
struct drm_hash_item *hash;
|
||||
|
||||
DRM_DEBUG("%d\n", magic);
|
||||
|
||||
|
@ -113,7 +113,7 @@ static int drm_remove_magic(drm_device_t * dev, drm_magic_t magic)
|
|||
mutex_unlock(&dev->struct_mutex);
|
||||
return -EINVAL;
|
||||
}
|
||||
pt = drm_hash_entry(hash, drm_magic_entry_t, hash_item);
|
||||
pt = drm_hash_entry(hash, struct drm_magic_entry, hash_item);
|
||||
drm_ht_remove_item(&dev->magiclist, hash);
|
||||
list_del(&pt->head);
|
||||
mutex_unlock(&dev->struct_mutex);
|
||||
|
@ -141,9 +141,9 @@ int drm_getmagic(struct inode *inode, struct file *filp,
|
|||
{
|
||||
static drm_magic_t sequence = 0;
|
||||
static DEFINE_SPINLOCK(lock);
|
||||
drm_file_t *priv = filp->private_data;
|
||||
drm_device_t *dev = priv->head->dev;
|
||||
drm_auth_t auth;
|
||||
struct drm_file *priv = filp->private_data;
|
||||
struct drm_device *dev = priv->head->dev;
|
||||
struct drm_auth auth;
|
||||
|
||||
/* Find unique magic */
|
||||
if (priv->magic) {
|
||||
|
@ -161,7 +161,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;
|
||||
}
|
||||
|
@ -180,12 +180,12 @@ int drm_getmagic(struct inode *inode, struct file *filp,
|
|||
int drm_authmagic(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg)
|
||||
{
|
||||
drm_file_t *priv = filp->private_data;
|
||||
drm_device_t *dev = priv->head->dev;
|
||||
drm_auth_t auth;
|
||||
drm_file_t *file;
|
||||
struct drm_file *priv = filp->private_data;
|
||||
struct drm_device *dev = priv->head->dev;
|
||||
struct drm_auth auth;
|
||||
struct drm_file *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))) {
|
||||
|
|
|
@ -102,11 +102,12 @@ static int drm_map_handle(drm_device_t *dev, drm_hash_item_t *hash,
|
|||
* applicable and if supported by the kernel.
|
||||
*/
|
||||
static int drm_addmap_core(drm_device_t * dev, unsigned int offset,
|
||||
unsigned int size, drm_map_type_t type,
|
||||
drm_map_flags_t flags, drm_map_list_t ** maplist)
|
||||
unsigned int size, enum drm_map_type type,
|
||||
enum drm_map_flags flags,
|
||||
struct drm_map_list **maplist)
|
||||
{
|
||||
drm_map_t *map;
|
||||
drm_map_list_t *list;
|
||||
struct drm_map *map;
|
||||
struct drm_map_list *list;
|
||||
drm_dma_handle_t *dmah;
|
||||
unsigned long user_token;
|
||||
int ret;
|
||||
|
@ -311,10 +312,10 @@ static int drm_addmap_core(drm_device_t * dev, unsigned int offset,
|
|||
}
|
||||
|
||||
int drm_addmap(drm_device_t * dev, unsigned int offset,
|
||||
unsigned int size, drm_map_type_t type,
|
||||
drm_map_flags_t flags, drm_local_map_t ** map_ptr)
|
||||
unsigned int size, enum drm_map_type type,
|
||||
enum drm_map_flags flags, drm_local_map_t ** map_ptr)
|
||||
{
|
||||
drm_map_list_t *list;
|
||||
struct drm_map_list *list;
|
||||
int rc;
|
||||
|
||||
rc = drm_addmap_core(dev, offset, size, type, flags, &list);
|
||||
|
@ -330,9 +331,9 @@ int drm_addmap_ioctl(struct inode *inode, struct file *filp,
|
|||
{
|
||||
drm_file_t *priv = filp->private_data;
|
||||
drm_device_t *dev = priv->head->dev;
|
||||
drm_map_t map;
|
||||
struct drm_map map;
|
||||
drm_map_list_t *maplist;
|
||||
drm_map_t __user *argp = (void __user *)arg;
|
||||
struct drm_map __user *argp = (void __user *)arg;
|
||||
int err;
|
||||
|
||||
if (!(filp->f_mode & 3))
|
||||
|
@ -351,7 +352,7 @@ int drm_addmap_ioctl(struct inode *inode, struct file *filp,
|
|||
if (err)
|
||||
return err;
|
||||
|
||||
if (copy_to_user(argp, maplist->map, sizeof(drm_map_t)))
|
||||
if (copy_to_user(argp, maplist->map, sizeof(struct drm_map)))
|
||||
return -EFAULT;
|
||||
|
||||
/* avoid a warning on 64-bit, this casting isn't very nice, but the API is set so too late */
|
||||
|
@ -367,7 +368,7 @@ int drm_addmap_ioctl(struct inode *inode, struct file *filp,
|
|||
* \param inode device inode.
|
||||
* \param filp file pointer.
|
||||
* \param cmd command.
|
||||
* \param arg pointer to a drm_map_t structure.
|
||||
* \param arg pointer to a struct drm_map structure.
|
||||
* \return zero on success or a negative value on error.
|
||||
*
|
||||
* Searches the map on drm_device::maplist, removes it from the list, see if
|
||||
|
@ -459,12 +460,12 @@ int drm_rmmap_ioctl(struct inode *inode, struct file *filp,
|
|||
{
|
||||
drm_file_t *priv = filp->private_data;
|
||||
drm_device_t *dev = priv->head->dev;
|
||||
drm_map_t request;
|
||||
struct drm_map request;
|
||||
drm_local_map_t *map = NULL;
|
||||
drm_map_list_t *r_list;
|
||||
int ret;
|
||||
|
||||
if (copy_from_user(&request, (drm_map_t __user *) arg, sizeof(request))) {
|
||||
if (copy_from_user(&request, (struct drm_map __user *) arg, sizeof(request))) {
|
||||
return -EFAULT;
|
||||
}
|
||||
|
||||
|
@ -512,7 +513,7 @@ int drm_rmmap_ioctl(struct inode *inode, struct file *filp,
|
|||
*
|
||||
* Frees any pages and buffers associated with the given entry.
|
||||
*/
|
||||
static void drm_cleanup_buf_error(drm_device_t * dev, drm_buf_entry_t * entry)
|
||||
static void drm_cleanup_buf_error(drm_device_t * dev, struct drm_buf_entry * entry)
|
||||
{
|
||||
int i;
|
||||
|
||||
|
@ -550,17 +551,17 @@ static void drm_cleanup_buf_error(drm_device_t * dev, drm_buf_entry_t * entry)
|
|||
* Add AGP buffers for DMA transfers
|
||||
*
|
||||
* \param dev drm_device_t to which the buffers are to be added.
|
||||
* \param request pointer to a drm_buf_desc_t describing the request.
|
||||
* \param request pointer to a struct drm_buf_desc describing the request.
|
||||
* \return zero on success or a negative number on failure.
|
||||
*
|
||||
* After some sanity checks creates a drm_buf structure for each buffer and
|
||||
* reallocates the buffer list of the same size order to accommodate the new
|
||||
* buffers.
|
||||
*/
|
||||
int drm_addbufs_agp(drm_device_t * dev, drm_buf_desc_t * request)
|
||||
int drm_addbufs_agp(drm_device_t * dev, struct drm_buf_desc * request)
|
||||
{
|
||||
drm_device_dma_t *dma = dev->dma;
|
||||
drm_buf_entry_t *entry;
|
||||
struct drm_buf_entry *entry;
|
||||
drm_agp_mem_t *agp_entry;
|
||||
drm_buf_t *buf;
|
||||
unsigned long offset;
|
||||
|
@ -727,7 +728,7 @@ int drm_addbufs_agp(drm_device_t * dev, drm_buf_desc_t * request)
|
|||
EXPORT_SYMBOL(drm_addbufs_agp);
|
||||
#endif /* __OS_HAS_AGP */
|
||||
|
||||
int drm_addbufs_pci(drm_device_t * dev, drm_buf_desc_t * request)
|
||||
int drm_addbufs_pci(drm_device_t * dev, struct drm_buf_desc * request)
|
||||
{
|
||||
drm_device_dma_t *dma = dev->dma;
|
||||
int count;
|
||||
|
@ -735,7 +736,7 @@ int drm_addbufs_pci(drm_device_t * dev, drm_buf_desc_t * request)
|
|||
int size;
|
||||
int total;
|
||||
int page_order;
|
||||
drm_buf_entry_t *entry;
|
||||
struct drm_buf_entry *entry;
|
||||
drm_dma_handle_t *dmah;
|
||||
drm_buf_t *buf;
|
||||
int alignment;
|
||||
|
@ -953,10 +954,10 @@ int drm_addbufs_pci(drm_device_t * dev, drm_buf_desc_t * request)
|
|||
}
|
||||
EXPORT_SYMBOL(drm_addbufs_pci);
|
||||
|
||||
static int drm_addbufs_sg(drm_device_t * dev, drm_buf_desc_t * request)
|
||||
static int drm_addbufs_sg(drm_device_t * dev, struct drm_buf_desc * request)
|
||||
{
|
||||
drm_device_dma_t *dma = dev->dma;
|
||||
drm_buf_entry_t *entry;
|
||||
struct drm_buf_entry *entry;
|
||||
drm_buf_t *buf;
|
||||
unsigned long offset;
|
||||
unsigned long agp_offset;
|
||||
|
@ -1115,10 +1116,10 @@ static int drm_addbufs_sg(drm_device_t * dev, drm_buf_desc_t * request)
|
|||
return 0;
|
||||
}
|
||||
|
||||
int drm_addbufs_fb(drm_device_t * dev, drm_buf_desc_t * request)
|
||||
int drm_addbufs_fb(drm_device_t * dev, struct drm_buf_desc * request)
|
||||
{
|
||||
drm_device_dma_t *dma = dev->dma;
|
||||
drm_buf_entry_t *entry;
|
||||
struct drm_buf_entry *entry;
|
||||
drm_buf_t *buf;
|
||||
unsigned long offset;
|
||||
unsigned long agp_offset;
|
||||
|
@ -1283,7 +1284,7 @@ EXPORT_SYMBOL(drm_addbufs_fb);
|
|||
* \param inode device inode.
|
||||
* \param filp file pointer.
|
||||
* \param cmd command.
|
||||
* \param arg pointer to a drm_buf_desc_t request.
|
||||
* \param arg pointer to a struct drm_buf_desc request.
|
||||
* \return zero on success or a negative number on failure.
|
||||
*
|
||||
* According with the memory type specified in drm_buf_desc::flags and the
|
||||
|
@ -1294,7 +1295,7 @@ EXPORT_SYMBOL(drm_addbufs_fb);
|
|||
int drm_addbufs(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg)
|
||||
{
|
||||
drm_buf_desc_t request;
|
||||
struct drm_buf_desc request;
|
||||
drm_file_t *priv = filp->private_data;
|
||||
drm_device_t *dev = priv->head->dev;
|
||||
int ret;
|
||||
|
@ -1302,7 +1303,7 @@ int drm_addbufs(struct inode *inode, struct file *filp,
|
|||
if (!drm_core_check_feature(dev, DRIVER_HAVE_DMA))
|
||||
return -EINVAL;
|
||||
|
||||
if (copy_from_user(&request, (drm_buf_desc_t __user *) arg,
|
||||
if (copy_from_user(&request, (struct drm_buf_desc __user *) arg,
|
||||
sizeof(request)))
|
||||
return -EFAULT;
|
||||
|
||||
|
@ -1350,8 +1351,8 @@ int drm_infobufs(struct inode *inode, struct file *filp,
|
|||
drm_file_t *priv = filp->private_data;
|
||||
drm_device_t *dev = priv->head->dev;
|
||||
drm_device_dma_t *dma = dev->dma;
|
||||
drm_buf_info_t request;
|
||||
drm_buf_info_t __user *argp = (void __user *)arg;
|
||||
struct drm_buf_info request;
|
||||
struct drm_buf_info __user *argp = (void __user *)arg;
|
||||
int i;
|
||||
int count;
|
||||
|
||||
|
@ -1382,9 +1383,9 @@ int drm_infobufs(struct inode *inode, struct file *filp,
|
|||
if (request.count >= count) {
|
||||
for (i = 0, count = 0; i < DRM_MAX_ORDER + 1; i++) {
|
||||
if (dma->bufs[i].buf_count) {
|
||||
drm_buf_desc_t __user *to =
|
||||
struct drm_buf_desc __user *to =
|
||||
&request.list[count];
|
||||
drm_buf_entry_t *from = &dma->bufs[i];
|
||||
struct drm_buf_entry *from = &dma->bufs[i];
|
||||
drm_freelist_t *list = &dma->bufs[i].freelist;
|
||||
if (copy_to_user(&to->count,
|
||||
&from->buf_count,
|
||||
|
@ -1438,9 +1439,9 @@ int drm_markbufs(struct inode *inode, struct file *filp,
|
|||
drm_file_t *priv = filp->private_data;
|
||||
drm_device_t *dev = priv->head->dev;
|
||||
drm_device_dma_t *dma = dev->dma;
|
||||
drm_buf_desc_t request;
|
||||
struct drm_buf_desc request;
|
||||
int order;
|
||||
drm_buf_entry_t *entry;
|
||||
struct drm_buf_entry *entry;
|
||||
|
||||
if (!drm_core_check_feature(dev, DRIVER_HAVE_DMA))
|
||||
return -EINVAL;
|
||||
|
@ -1449,7 +1450,7 @@ int drm_markbufs(struct inode *inode, struct file *filp,
|
|||
return -EINVAL;
|
||||
|
||||
if (copy_from_user(&request,
|
||||
(drm_buf_desc_t __user *) arg, sizeof(request)))
|
||||
(struct drm_buf_desc __user *) arg, sizeof(request)))
|
||||
return -EFAULT;
|
||||
|
||||
DRM_DEBUG("%d, %d, %d\n",
|
||||
|
@ -1488,7 +1489,7 @@ int drm_freebufs(struct inode *inode, struct file *filp,
|
|||
drm_file_t *priv = filp->private_data;
|
||||
drm_device_t *dev = priv->head->dev;
|
||||
drm_device_dma_t *dma = dev->dma;
|
||||
drm_buf_free_t request;
|
||||
struct drm_buf_free request;
|
||||
int i;
|
||||
int idx;
|
||||
drm_buf_t *buf;
|
||||
|
@ -1500,7 +1501,7 @@ int drm_freebufs(struct inode *inode, struct file *filp,
|
|||
return -EINVAL;
|
||||
|
||||
if (copy_from_user(&request,
|
||||
(drm_buf_free_t __user *) arg, sizeof(request)))
|
||||
(struct drm_buf_free __user *) arg, sizeof(request)))
|
||||
return -EFAULT;
|
||||
|
||||
DRM_DEBUG("%d\n", request.count);
|
||||
|
@ -1544,12 +1545,12 @@ int drm_mapbufs(struct inode *inode, struct file *filp,
|
|||
drm_file_t *priv = filp->private_data;
|
||||
drm_device_t *dev = priv->head->dev;
|
||||
drm_device_dma_t *dma = dev->dma;
|
||||
drm_buf_map_t __user *argp = (void __user *)arg;
|
||||
struct drm_buf_map __user *argp = (void __user *)arg;
|
||||
int retcode = 0;
|
||||
const int zero = 0;
|
||||
unsigned long virtual;
|
||||
unsigned long address;
|
||||
drm_buf_map_t request;
|
||||
struct drm_buf_map request;
|
||||
int i;
|
||||
|
||||
if (!drm_core_check_feature(dev, DRIVER_HAVE_DMA))
|
||||
|
@ -1575,7 +1576,7 @@ int drm_mapbufs(struct inode *inode, struct file *filp,
|
|||
&& (dma->flags & _DRM_DMA_USE_SG))
|
||||
|| (drm_core_check_feature(dev, DRIVER_FB_DMA)
|
||||
&& (dma->flags & _DRM_DMA_USE_FB))) {
|
||||
drm_map_t *map = dev->agp_buffer_map;
|
||||
struct drm_map *map = dev->agp_buffer_map;
|
||||
unsigned long token = dev->agp_buffer_token;
|
||||
|
||||
if (!map) {
|
||||
|
|
|
@ -145,10 +145,10 @@ int drm_getsareactx(struct inode *inode, struct file *filp,
|
|||
{
|
||||
drm_file_t *priv = filp->private_data;
|
||||
drm_device_t *dev = priv->head->dev;
|
||||
drm_ctx_priv_map_t __user *argp = (void __user *)arg;
|
||||
drm_ctx_priv_map_t request;
|
||||
drm_map_t *map;
|
||||
drm_map_list_t *_entry;
|
||||
struct drm_ctx_priv_map __user *argp = (void __user *)arg;
|
||||
struct drm_ctx_priv_map request;
|
||||
struct drm_map *map;
|
||||
struct drm_map_list *_entry;
|
||||
|
||||
if (copy_from_user(&request, argp, sizeof(request)))
|
||||
return -EFAULT;
|
||||
|
@ -196,12 +196,12 @@ int drm_setsareactx(struct inode *inode, struct file *filp,
|
|||
{
|
||||
drm_file_t *priv = filp->private_data;
|
||||
drm_device_t *dev = priv->head->dev;
|
||||
drm_ctx_priv_map_t request;
|
||||
drm_map_t *map = NULL;
|
||||
drm_map_list_t *r_list = NULL;
|
||||
struct drm_ctx_priv_map request;
|
||||
struct drm_map *map = NULL;
|
||||
struct drm_map_list *r_list = NULL;
|
||||
|
||||
if (copy_from_user(&request,
|
||||
(drm_ctx_priv_map_t __user *) arg, sizeof(request)))
|
||||
(struct drm_ctx_priv_map __user *) arg, sizeof(request)))
|
||||
return -EFAULT;
|
||||
|
||||
mutex_lock(&dev->struct_mutex);
|
||||
|
@ -301,9 +301,9 @@ static int drm_context_switch_complete(drm_device_t * dev, int new)
|
|||
int drm_resctx(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg)
|
||||
{
|
||||
drm_ctx_res_t res;
|
||||
drm_ctx_t __user *argp = (void __user *)arg;
|
||||
drm_ctx_t ctx;
|
||||
struct drm_ctx_res res;
|
||||
struct drm_ctx __user *argp = (void __user *)arg;
|
||||
struct drm_ctx ctx;
|
||||
int i;
|
||||
|
||||
if (copy_from_user(&res, argp, sizeof(res)))
|
||||
|
@ -339,10 +339,10 @@ int drm_addctx(struct inode *inode, struct file *filp,
|
|||
unsigned int cmd, unsigned long arg)
|
||||
{
|
||||
drm_file_t *priv = filp->private_data;
|
||||
drm_device_t *dev = priv->head->dev;
|
||||
drm_ctx_list_t *ctx_entry;
|
||||
drm_ctx_t __user *argp = (void __user *)arg;
|
||||
drm_ctx_t ctx;
|
||||
struct drm_device *dev = priv->head->dev;
|
||||
struct drm_ctx_list *ctx_entry;
|
||||
struct drm_ctx __user *argp = (void __user *)arg;
|
||||
struct drm_ctx ctx;
|
||||
|
||||
if (copy_from_user(&ctx, argp, sizeof(ctx)))
|
||||
return -EFAULT;
|
||||
|
@ -406,8 +406,8 @@ int drm_modctx(struct inode *inode, struct file *filp,
|
|||
int drm_getctx(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg)
|
||||
{
|
||||
drm_ctx_t __user *argp = (void __user *)arg;
|
||||
drm_ctx_t ctx;
|
||||
struct drm_ctx __user *argp = (void __user *)arg;
|
||||
struct drm_ctx ctx;
|
||||
|
||||
if (copy_from_user(&ctx, argp, sizeof(ctx)))
|
||||
return -EFAULT;
|
||||
|
@ -436,9 +436,9 @@ int drm_switchctx(struct inode *inode, struct file *filp,
|
|||
{
|
||||
drm_file_t *priv = filp->private_data;
|
||||
drm_device_t *dev = priv->head->dev;
|
||||
drm_ctx_t ctx;
|
||||
struct drm_ctx ctx;
|
||||
|
||||
if (copy_from_user(&ctx, (drm_ctx_t __user *) arg, sizeof(ctx)))
|
||||
if (copy_from_user(&ctx, (struct drm_ctx __user *) arg, sizeof(ctx)))
|
||||
return -EFAULT;
|
||||
|
||||
DRM_DEBUG("%d\n", ctx.handle);
|
||||
|
@ -461,9 +461,9 @@ int drm_newctx(struct inode *inode, struct file *filp,
|
|||
{
|
||||
drm_file_t *priv = filp->private_data;
|
||||
drm_device_t *dev = priv->head->dev;
|
||||
drm_ctx_t ctx;
|
||||
struct drm_ctx ctx;
|
||||
|
||||
if (copy_from_user(&ctx, (drm_ctx_t __user *) arg, sizeof(ctx)))
|
||||
if (copy_from_user(&ctx, (struct drm_ctx __user *) arg, sizeof(ctx)))
|
||||
return -EFAULT;
|
||||
|
||||
DRM_DEBUG("%d\n", ctx.handle);
|
||||
|
@ -488,9 +488,9 @@ int drm_rmctx(struct inode *inode, struct file *filp,
|
|||
{
|
||||
drm_file_t *priv = filp->private_data;
|
||||
drm_device_t *dev = priv->head->dev;
|
||||
drm_ctx_t ctx;
|
||||
struct drm_ctx ctx;
|
||||
|
||||
if (copy_from_user(&ctx, (drm_ctx_t __user *) arg, sizeof(ctx)))
|
||||
if (copy_from_user(&ctx, (struct drm_ctx __user *) arg, sizeof(ctx)))
|
||||
return -EFAULT;
|
||||
|
||||
DRM_DEBUG("%d\n", ctx.handle);
|
||||
|
|
|
@ -44,7 +44,7 @@ int drm_adddraw(DRM_IOCTL_ARGS)
|
|||
{
|
||||
DRM_DEVICE;
|
||||
unsigned long irqflags;
|
||||
drm_draw_t draw;
|
||||
struct drm_draw draw;
|
||||
int new_id = 0;
|
||||
int ret;
|
||||
|
||||
|
@ -67,7 +67,7 @@ again:
|
|||
|
||||
DRM_DEBUG("%d\n", draw.handle);
|
||||
|
||||
DRM_COPY_TO_USER_IOCTL((drm_draw_t __user *)data, draw, sizeof(draw));
|
||||
DRM_COPY_TO_USER_IOCTL((struct drm_draw __user *)data, draw, sizeof(draw));
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
@ -78,10 +78,10 @@ again:
|
|||
int drm_rmdraw(DRM_IOCTL_ARGS)
|
||||
{
|
||||
DRM_DEVICE;
|
||||
drm_draw_t draw;
|
||||
struct drm_draw draw;
|
||||
unsigned long irqflags;
|
||||
|
||||
DRM_COPY_FROM_USER_IOCTL(draw, (drm_draw_t __user *) data,
|
||||
DRM_COPY_FROM_USER_IOCTL(draw, (struct drm_draw __user *) data,
|
||||
sizeof(draw));
|
||||
|
||||
spin_lock_irqsave(&dev->drw_lock, irqflags);
|
||||
|
@ -99,13 +99,13 @@ int drm_rmdraw(DRM_IOCTL_ARGS)
|
|||
int drm_update_drawable_info(DRM_IOCTL_ARGS)
|
||||
{
|
||||
DRM_DEVICE;
|
||||
drm_update_draw_t update;
|
||||
struct drm_update_draw update;
|
||||
unsigned long irqflags;
|
||||
drm_clip_rect_t *rects;
|
||||
struct drm_clip_rect *rects;
|
||||
struct drm_drawable_info *info;
|
||||
int err;
|
||||
|
||||
DRM_COPY_FROM_USER_IOCTL(update, (drm_update_draw_t __user *) data,
|
||||
DRM_COPY_FROM_USER_IOCTL(update, (struct drm_update_draw __user *) data,
|
||||
sizeof(update));
|
||||
|
||||
info = idr_find(&dev->drw_idr, update.handle);
|
||||
|
@ -123,7 +123,7 @@ int drm_update_drawable_info(DRM_IOCTL_ARGS)
|
|||
switch (update.type) {
|
||||
case DRM_DRAWABLE_CLIPRECTS:
|
||||
if (update.num != info->num_rects) {
|
||||
rects = drm_alloc(update.num * sizeof(drm_clip_rect_t),
|
||||
rects = drm_alloc(update.num * sizeof(struct drm_clip_rect),
|
||||
DRM_MEM_BUFS);
|
||||
} else
|
||||
rects = info->rects;
|
||||
|
@ -135,7 +135,7 @@ int drm_update_drawable_info(DRM_IOCTL_ARGS)
|
|||
}
|
||||
|
||||
if (update.num && DRM_COPY_FROM_USER(rects,
|
||||
(drm_clip_rect_t __user *)
|
||||
(struct drm_clip_rect __user *)
|
||||
(unsigned long)update.data,
|
||||
update.num *
|
||||
sizeof(*rects))) {
|
||||
|
@ -148,7 +148,7 @@ int drm_update_drawable_info(DRM_IOCTL_ARGS)
|
|||
|
||||
if (rects != info->rects) {
|
||||
drm_free(info->rects, info->num_rects *
|
||||
sizeof(drm_clip_rect_t), DRM_MEM_BUFS);
|
||||
sizeof(struct drm_clip_rect), DRM_MEM_BUFS);
|
||||
}
|
||||
|
||||
info->rects = rects;
|
||||
|
@ -168,7 +168,7 @@ int drm_update_drawable_info(DRM_IOCTL_ARGS)
|
|||
|
||||
error:
|
||||
if (rects != info->rects)
|
||||
drm_free(rects, update.num * sizeof(drm_clip_rect_t),
|
||||
drm_free(rects, update.num * sizeof(struct drm_clip_rect),
|
||||
DRM_MEM_BUFS);
|
||||
|
||||
return err;
|
||||
|
@ -177,7 +177,7 @@ error:
|
|||
/**
|
||||
* Caller must hold the drawable spinlock!
|
||||
*/
|
||||
drm_drawable_info_t *drm_get_drawable_info(drm_device_t *dev, drm_drawable_t id)
|
||||
struct drm_drawable_info *drm_get_drawable_info(drm_device_t *dev, drm_drawable_t id)
|
||||
{
|
||||
return idr_find(&dev->drw_idr, id);
|
||||
}
|
||||
|
@ -189,7 +189,7 @@ static int drm_drawable_free(int idr, void *p, void *data)
|
|||
|
||||
if (info) {
|
||||
drm_free(info->rects, info->num_rects *
|
||||
sizeof(drm_clip_rect_t), DRM_MEM_BUFS);
|
||||
sizeof(struct drm_clip_rect), DRM_MEM_BUFS);
|
||||
drm_free(info, sizeof(*info), DRM_MEM_BUFS);
|
||||
}
|
||||
|
||||
|
|
|
@ -550,8 +550,8 @@ static int drm_version(struct inode *inode, struct file *filp,
|
|||
{
|
||||
drm_file_t *priv = filp->private_data;
|
||||
drm_device_t *dev = priv->head->dev;
|
||||
drm_version_t __user *argp = (void __user *)arg;
|
||||
drm_version_t version;
|
||||
struct drm_version __user *argp = (void __user *)arg;
|
||||
struct drm_version version;
|
||||
int len;
|
||||
|
||||
if (copy_from_user(&version, argp, sizeof(version)))
|
||||
|
|
|
@ -54,8 +54,8 @@ int drm_getunique(struct inode *inode, struct file *filp,
|
|||
{
|
||||
drm_file_t *priv = filp->private_data;
|
||||
drm_device_t *dev = priv->head->dev;
|
||||
drm_unique_t __user *argp = (void __user *)arg;
|
||||
drm_unique_t u;
|
||||
struct drm_unique __user *argp = (void __user *)arg;
|
||||
struct drm_unique u;
|
||||
|
||||
if (copy_from_user(&u, argp, sizeof(u)))
|
||||
return -EFAULT;
|
||||
|
@ -88,13 +88,13 @@ int drm_setunique(struct inode *inode, struct file *filp,
|
|||
{
|
||||
drm_file_t *priv = filp->private_data;
|
||||
drm_device_t *dev = priv->head->dev;
|
||||
drm_unique_t u;
|
||||
struct drm_unique u;
|
||||
int domain, bus, slot, func, ret;
|
||||
|
||||
if (dev->unique_len || dev->unique)
|
||||
return -EBUSY;
|
||||
|
||||
if (copy_from_user(&u, (drm_unique_t __user *) arg, sizeof(u)))
|
||||
if (copy_from_user(&u, (struct drm_unique __user *) arg, sizeof(u)))
|
||||
return -EFAULT;
|
||||
|
||||
if (!u.unique_len || u.unique_len > 1024)
|
||||
|
@ -181,9 +181,9 @@ int drm_getmap(struct inode *inode, struct file *filp,
|
|||
{
|
||||
drm_file_t *priv = filp->private_data;
|
||||
drm_device_t *dev = priv->head->dev;
|
||||
drm_map_t __user *argp = (void __user *)arg;
|
||||
drm_map_t map;
|
||||
drm_map_list_t *r_list = NULL;
|
||||
struct drm_map __user *argp = (void __user *)arg;
|
||||
struct drm_map map;
|
||||
struct drm_map_list *r_list = NULL;
|
||||
struct list_head *list;
|
||||
int idx;
|
||||
int i;
|
||||
|
@ -242,8 +242,8 @@ int drm_getclient(struct inode *inode, struct file *filp,
|
|||
{
|
||||
drm_file_t *priv = filp->private_data;
|
||||
drm_device_t *dev = priv->head->dev;
|
||||
drm_client_t __user *argp = (drm_client_t __user *)arg;
|
||||
drm_client_t client;
|
||||
struct drm_client __user *argp = (struct drm_client __user *)arg;
|
||||
struct drm_client client;
|
||||
drm_file_t *pt;
|
||||
int idx;
|
||||
int i;
|
||||
|
@ -291,7 +291,7 @@ int drm_getstats(struct inode *inode, struct file *filp,
|
|||
{
|
||||
drm_file_t *priv = filp->private_data;
|
||||
drm_device_t *dev = priv->head->dev;
|
||||
drm_stats_t stats;
|
||||
struct drm_stats stats;
|
||||
int i;
|
||||
|
||||
memset(&stats, 0, sizeof(stats));
|
||||
|
@ -311,7 +311,7 @@ int drm_getstats(struct inode *inode, struct file *filp,
|
|||
|
||||
mutex_unlock(&dev->struct_mutex);
|
||||
|
||||
if (copy_to_user((drm_stats_t __user *) arg, &stats, sizeof(stats)))
|
||||
if (copy_to_user((struct drm_stats __user *) arg, &stats, sizeof(stats)))
|
||||
return -EFAULT;
|
||||
return 0;
|
||||
}
|
||||
|
@ -330,10 +330,10 @@ int drm_getstats(struct inode *inode, struct file *filp,
|
|||
int drm_setversion(DRM_IOCTL_ARGS)
|
||||
{
|
||||
DRM_DEVICE;
|
||||
drm_set_version_t sv;
|
||||
drm_set_version_t retv;
|
||||
struct drm_set_version sv;
|
||||
struct drm_set_version retv;
|
||||
int if_version;
|
||||
drm_set_version_t __user *argp = (void __user *)data;
|
||||
struct drm_set_version __user *argp = (void __user *)data;
|
||||
|
||||
if (copy_from_user(&sv, argp, sizeof(sv)))
|
||||
return -EFAULT;
|
||||
|
|
|
@ -55,8 +55,8 @@ int drm_irq_by_busid(struct inode *inode, struct file *filp,
|
|||
{
|
||||
drm_file_t *priv = filp->private_data;
|
||||
drm_device_t *dev = priv->head->dev;
|
||||
drm_irq_busid_t __user *argp = (void __user *)arg;
|
||||
drm_irq_busid_t p;
|
||||
struct drm_irq_busid __user *argp = (void __user *)arg;
|
||||
struct drm_irq_busid p;
|
||||
|
||||
if (!drm_core_check_feature(dev, DRIVER_HAVE_IRQ))
|
||||
return -EINVAL;
|
||||
|
@ -197,11 +197,11 @@ int drm_control(struct inode *inode, struct file *filp,
|
|||
{
|
||||
drm_file_t *priv = filp->private_data;
|
||||
drm_device_t *dev = priv->head->dev;
|
||||
drm_control_t ctl;
|
||||
struct drm_control ctl;
|
||||
|
||||
/* if we haven't irq we fallback for compatibility reasons - this used to be a separate function in drm_dma.h */
|
||||
|
||||
if (copy_from_user(&ctl, (drm_control_t __user *) arg, sizeof(ctl)))
|
||||
if (copy_from_user(&ctl, (struct drm_control __user *) arg, sizeof(ctl)))
|
||||
return -EFAULT;
|
||||
|
||||
switch (ctl.func) {
|
||||
|
@ -244,8 +244,8 @@ int drm_wait_vblank(DRM_IOCTL_ARGS)
|
|||
{
|
||||
drm_file_t *priv = filp->private_data;
|
||||
drm_device_t *dev = priv->head->dev;
|
||||
drm_wait_vblank_t __user *argp = (void __user *)data;
|
||||
drm_wait_vblank_t vblwait;
|
||||
union drm_wait_vblank __user *argp = (void __user *)data;
|
||||
union drm_wait_vblank vblwait;
|
||||
struct timeval now;
|
||||
int ret = 0;
|
||||
unsigned int flags, seq;
|
||||
|
|
|
@ -54,12 +54,12 @@ int drm_lock(struct inode *inode, struct file *filp,
|
|||
drm_file_t *priv = filp->private_data;
|
||||
drm_device_t *dev = priv->head->dev;
|
||||
DECLARE_WAITQUEUE(entry, current);
|
||||
drm_lock_t lock;
|
||||
struct drm_lock lock;
|
||||
int ret = 0;
|
||||
|
||||
++priv->lock_count;
|
||||
|
||||
if (copy_from_user(&lock, (drm_lock_t __user *) arg, sizeof(lock)))
|
||||
if (copy_from_user(&lock, (struct drm_lock __user *) arg, sizeof(lock)))
|
||||
return -EFAULT;
|
||||
|
||||
if (lock.context == DRM_KERNEL_CONTEXT) {
|
||||
|
@ -154,10 +154,10 @@ int drm_unlock(struct inode *inode, struct file *filp,
|
|||
{
|
||||
drm_file_t *priv = filp->private_data;
|
||||
drm_device_t *dev = priv->head->dev;
|
||||
drm_lock_t lock;
|
||||
struct drm_lock lock;
|
||||
unsigned long irqflags;
|
||||
|
||||
if (copy_from_user(&lock, (drm_lock_t __user *) arg, sizeof(lock)))
|
||||
if (copy_from_user(&lock, (struct drm_lock __user *) arg, sizeof(lock)))
|
||||
return -EFAULT;
|
||||
|
||||
if (lock.context == DRM_KERNEL_CONTEXT) {
|
||||
|
|
|
@ -209,8 +209,8 @@ static int drm__vm_info(char *buf, char **start, off_t offset, int request,
|
|||
{
|
||||
drm_device_t *dev = (drm_device_t *) data;
|
||||
int len = 0;
|
||||
drm_map_t *map;
|
||||
drm_map_list_t *r_list;
|
||||
struct drm_map *map;
|
||||
struct drm_map_list *r_list;
|
||||
|
||||
/* Hardcoded from _DRM_FRAME_BUFFER,
|
||||
_DRM_REGISTERS, _DRM_SHM, _DRM_AGP,
|
||||
|
|
|
@ -36,7 +36,7 @@
|
|||
|
||||
#define DEBUG_SCATTER 0
|
||||
|
||||
void drm_sg_cleanup(drm_sg_mem_t * entry)
|
||||
void drm_sg_cleanup(struct drm_sg_mem *entry)
|
||||
{
|
||||
struct page *page;
|
||||
int i;
|
||||
|
@ -63,9 +63,9 @@ EXPORT_SYMBOL(drm_sg_cleanup);
|
|||
# define ScatterHandle(x) (unsigned int)(x)
|
||||
#endif
|
||||
|
||||
int drm_sg_alloc(drm_device_t * dev, drm_scatter_gather_t * request)
|
||||
int drm_sg_alloc(struct drm_device *dev, struct drm_scatter_gather * request)
|
||||
{
|
||||
drm_sg_mem_t *entry;
|
||||
struct drm_sg_mem *entry;
|
||||
unsigned long pages, i, j;
|
||||
|
||||
DRM_DEBUG("%s\n", __FUNCTION__);
|
||||
|
@ -191,8 +191,8 @@ int drm_sg_alloc_ioctl(struct inode *inode, struct file *filp,
|
|||
unsigned int cmd, unsigned long arg)
|
||||
{
|
||||
drm_file_t *priv = filp->private_data;
|
||||
drm_scatter_gather_t __user *argp = (void __user *)arg;
|
||||
drm_scatter_gather_t request;
|
||||
struct drm_scatter_gather __user *argp = (void __user *)arg;
|
||||
struct drm_scatter_gather request;
|
||||
int ret;
|
||||
|
||||
if (copy_from_user(&request, argp, sizeof(request)))
|
||||
|
@ -216,14 +216,14 @@ int drm_sg_free(struct inode *inode, struct file *filp,
|
|||
{
|
||||
drm_file_t *priv = filp->private_data;
|
||||
drm_device_t *dev = priv->head->dev;
|
||||
drm_scatter_gather_t request;
|
||||
drm_sg_mem_t *entry;
|
||||
struct drm_scatter_gather request;
|
||||
struct drm_sg_mem *entry;
|
||||
|
||||
if (!drm_core_check_feature(dev, DRIVER_SG))
|
||||
return -EINVAL;
|
||||
|
||||
if (copy_from_user(&request,
|
||||
(drm_scatter_gather_t __user *) arg,
|
||||
(struct drm_scatter_gather __user *) arg,
|
||||
sizeof(request)))
|
||||
return -EFAULT;
|
||||
|
||||
|
|
|
@ -87,7 +87,7 @@ static __inline__ struct page *drm_do_vm_nopage(struct vm_area_struct *vma,
|
|||
{
|
||||
drm_file_t *priv = vma->vm_file->private_data;
|
||||
drm_device_t *dev = priv->head->dev;
|
||||
drm_map_t *map = NULL;
|
||||
struct drm_map *map = NULL;
|
||||
drm_map_list_t *r_list;
|
||||
drm_hash_item_t *hash;
|
||||
|
||||
|
@ -172,7 +172,7 @@ static __inline__ struct page *drm_do_vm_nopage(struct vm_area_struct *vma,
|
|||
static __inline__ struct page *drm_do_vm_shm_nopage(struct vm_area_struct *vma,
|
||||
unsigned long address)
|
||||
{
|
||||
drm_map_t *map = (drm_map_t *) vma->vm_private_data;
|
||||
struct drm_map *map = (struct drm_map *) vma->vm_private_data;
|
||||
unsigned long offset;
|
||||
unsigned long i;
|
||||
struct page *page;
|
||||
|
@ -206,7 +206,7 @@ static void drm_vm_shm_close(struct vm_area_struct *vma)
|
|||
drm_file_t *priv = vma->vm_file->private_data;
|
||||
drm_device_t *dev = priv->head->dev;
|
||||
drm_vma_entry_t *pt, *temp;
|
||||
drm_map_t *map;
|
||||
struct drm_map *map;
|
||||
drm_map_list_t *r_list;
|
||||
int found_maps = 0;
|
||||
|
||||
|
@ -321,7 +321,7 @@ static __inline__ struct page *drm_do_vm_dma_nopage(struct vm_area_struct *vma,
|
|||
static __inline__ struct page *drm_do_vm_sg_nopage(struct vm_area_struct *vma,
|
||||
unsigned long address)
|
||||
{
|
||||
drm_map_t *map = (drm_map_t *) vma->vm_private_data;
|
||||
struct drm_map *map = (struct drm_map *) vma->vm_private_data;
|
||||
drm_file_t *priv = vma->vm_file->private_data;
|
||||
drm_device_t *dev = priv->head->dev;
|
||||
drm_sg_mem_t *entry = dev->sg;
|
||||
|
@ -524,7 +524,7 @@ static int drm_mmap_dma(struct file *filp, struct vm_area_struct *vma)
|
|||
return 0;
|
||||
}
|
||||
|
||||
unsigned long drm_core_get_map_ofs(drm_map_t * map)
|
||||
unsigned long drm_core_get_map_ofs(struct drm_map * map)
|
||||
{
|
||||
return map->offset;
|
||||
}
|
||||
|
@ -557,9 +557,9 @@ static int drm_mmap_locked(struct file *filp, struct vm_area_struct *vma)
|
|||
{
|
||||
drm_file_t *priv = filp->private_data;
|
||||
drm_device_t *dev = priv->head->dev;
|
||||
drm_map_t *map = NULL;
|
||||
struct drm_map *map = NULL;
|
||||
unsigned long offset = 0;
|
||||
drm_hash_item_t *hash;
|
||||
struct drm_hash_item *hash;
|
||||
|
||||
DRM_DEBUG("start = 0x%lx, end = 0x%lx, page offset = 0x%lx\n",
|
||||
vma->vm_start, vma->vm_end, vma->vm_pgoff);
|
||||
|
|
|
@ -346,7 +346,7 @@ static int i810_dma_initialize(drm_device_t * dev,
|
|||
drm_i810_private_t * dev_priv,
|
||||
drm_i810_init_t * init)
|
||||
{
|
||||
drm_map_list_t *r_list;
|
||||
struct drm_map_list *r_list;
|
||||
memset(dev_priv, 0, sizeof(drm_i810_private_t));
|
||||
|
||||
list_for_each_entry(r_list, &dev->maplist, head) {
|
||||
|
@ -692,7 +692,7 @@ static void i810_dma_dispatch_clear(drm_device_t * dev, int flags,
|
|||
drm_i810_private_t *dev_priv = dev->dev_private;
|
||||
drm_i810_sarea_t *sarea_priv = dev_priv->sarea_priv;
|
||||
int nbox = sarea_priv->nbox;
|
||||
drm_clip_rect_t *pbox = sarea_priv->boxes;
|
||||
struct drm_clip_rect *pbox = sarea_priv->boxes;
|
||||
int pitch = dev_priv->pitch;
|
||||
int cpp = 2;
|
||||
int i;
|
||||
|
@ -765,7 +765,7 @@ static void i810_dma_dispatch_swap(drm_device_t * dev)
|
|||
drm_i810_private_t *dev_priv = dev->dev_private;
|
||||
drm_i810_sarea_t *sarea_priv = dev_priv->sarea_priv;
|
||||
int nbox = sarea_priv->nbox;
|
||||
drm_clip_rect_t *pbox = sarea_priv->boxes;
|
||||
struct drm_clip_rect *pbox = sarea_priv->boxes;
|
||||
int pitch = dev_priv->pitch;
|
||||
int cpp = 2;
|
||||
int i;
|
||||
|
@ -812,7 +812,7 @@ static void i810_dma_dispatch_vertex(drm_device_t * dev,
|
|||
drm_i810_private_t *dev_priv = dev->dev_private;
|
||||
drm_i810_buf_priv_t *buf_priv = buf->dev_private;
|
||||
drm_i810_sarea_t *sarea_priv = dev_priv->sarea_priv;
|
||||
drm_clip_rect_t *box = sarea_priv->boxes;
|
||||
struct drm_clip_rect *box = sarea_priv->boxes;
|
||||
int nbox = sarea_priv->nbox;
|
||||
unsigned long address = (unsigned long)buf->bus_address;
|
||||
unsigned long start = address - dev->agp->base;
|
||||
|
@ -1140,7 +1140,7 @@ static int i810_getbuf(struct inode *inode, struct file *filp, unsigned int cmd,
|
|||
DRM_DEBUG("i810_dma: %d returning %d, granted = %d\n",
|
||||
current->pid, retcode, d.granted);
|
||||
|
||||
if (copy_to_user((drm_dma_t __user *) arg, &d, sizeof(d)))
|
||||
if (copy_to_user((void __user *) arg, &d, sizeof(d)))
|
||||
return -EFAULT;
|
||||
sarea_priv->last_dispatch = (int)hw_status[5];
|
||||
|
||||
|
|
|
@ -163,7 +163,7 @@ typedef struct _drm_i810_sarea {
|
|||
unsigned int dirty;
|
||||
|
||||
unsigned int nbox;
|
||||
drm_clip_rect_t boxes[I810_NR_SAREA_CLIPRECTS];
|
||||
struct drm_clip_rect boxes[I810_NR_SAREA_CLIPRECTS];
|
||||
|
||||
/* Maintain an LRU of contiguous regions of texture space. If
|
||||
* you think you own a region of texture memory, and it has an
|
||||
|
|
|
@ -77,8 +77,8 @@ typedef struct _drm_i810_ring_buffer {
|
|||
} drm_i810_ring_buffer_t;
|
||||
|
||||
typedef struct drm_i810_private {
|
||||
drm_map_t *sarea_map;
|
||||
drm_map_t *mmio_map;
|
||||
struct drm_map *sarea_map;
|
||||
struct drm_map *mmio_map;
|
||||
|
||||
drm_i810_sarea_t *sarea_priv;
|
||||
drm_i810_ring_buffer_t ring;
|
||||
|
|
|
@ -920,61 +920,61 @@ typedef struct drm_mm_init_arg {
|
|||
#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_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, 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_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, drm_map_t)
|
||||
#define DRM_IOCTL_RM_MAP DRM_IOW( 0x1b, struct drm_map)
|
||||
|
||||
#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_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, 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_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)
|
||||
|
||||
#define DRM_IOCTL_MM_INIT DRM_IOWR(0xc0, drm_mm_init_arg_t)
|
||||
#define DRM_IOCTL_MM_TAKEDOWN DRM_IOWR(0xc1, drm_mm_type_arg_t)
|
||||
|
@ -1016,8 +1016,7 @@ typedef struct drm_mm_init_arg {
|
|||
#define DRM_COMMAND_END 0xA0
|
||||
|
||||
/* typedef area */
|
||||
#if 1
|
||||
/*!defined(__KERNEL__) || defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__)*/
|
||||
#if !defined(__KERNEL__) || defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__)
|
||||
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;
|
||||
|
|
|
@ -50,29 +50,35 @@
|
|||
#define SAREA_DRAWABLE_CLAIMED_ENTRY 0x80000000
|
||||
|
||||
/** SAREA drawable */
|
||||
typedef struct drm_sarea_drawable {
|
||||
struct drm_sarea_drawable {
|
||||
unsigned int stamp;
|
||||
unsigned int flags;
|
||||
} drm_sarea_drawable_t;
|
||||
};
|
||||
|
||||
/** SAREA frame */
|
||||
typedef struct drm_sarea_frame {
|
||||
struct drm_sarea_frame {
|
||||
unsigned int x;
|
||||
unsigned int y;
|
||||
unsigned int width;
|
||||
unsigned int height;
|
||||
unsigned int fullscreen;
|
||||
} drm_sarea_frame_t;
|
||||
};
|
||||
|
||||
/** SAREA */
|
||||
typedef struct drm_sarea {
|
||||
struct drm_sarea {
|
||||
/** first thing is always the DRM locking structure */
|
||||
drm_hw_lock_t lock;
|
||||
struct drm_hw_lock lock;
|
||||
/** \todo Use readers/writer lock for drm_sarea::drawable_lock */
|
||||
drm_hw_lock_t drawable_lock;
|
||||
drm_sarea_drawable_t drawableTable[SAREA_MAX_DRAWABLES]; /**< drawables */
|
||||
drm_sarea_frame_t frame; /**< frame */
|
||||
struct drm_hw_lock drawable_lock;
|
||||
struct drm_sarea_drawable drawableTable[SAREA_MAX_DRAWABLES]; /**< drawables */
|
||||
struct drm_sarea_frame frame; /**< frame */
|
||||
drm_context_t dummy_context;
|
||||
} drm_sarea_t;
|
||||
};
|
||||
|
||||
#ifndef __KERNEL__
|
||||
typedef struct drm_sarea_drawable drm_sarea_drawable_t;
|
||||
typedef struct drm_sarea_frame drm_sarea_frame_t;
|
||||
typedef struct drm_sarea drm_sarea_t;
|
||||
#endif
|
||||
|
||||
#endif /* _DRM_SAREA_H_ */
|
||||
|
|
|
@ -398,11 +398,11 @@ static int i915_emit_cmds(drm_device_t * dev, int __user * buffer, int dwords)
|
|||
}
|
||||
|
||||
static int i915_emit_box(drm_device_t * dev,
|
||||
drm_clip_rect_t __user * boxes,
|
||||
struct drm_clip_rect __user * boxes,
|
||||
int i, int DR1, int DR4)
|
||||
{
|
||||
drm_i915_private_t *dev_priv = dev->dev_private;
|
||||
drm_clip_rect_t box;
|
||||
struct drm_clip_rect box;
|
||||
RING_LOCALS;
|
||||
|
||||
if (DRM_COPY_FROM_USER_UNCHECKED(&box, &boxes[i], sizeof(box))) {
|
||||
|
@ -524,7 +524,7 @@ static int i915_dispatch_batchbuffer(drm_device_t * dev,
|
|||
drm_i915_batchbuffer_t * batch)
|
||||
{
|
||||
drm_i915_private_t *dev_priv = dev->dev_private;
|
||||
drm_clip_rect_t __user *boxes = batch->cliprects;
|
||||
struct drm_clip_rect __user *boxes = batch->cliprects;
|
||||
int nbox = batch->num_cliprects;
|
||||
int i = 0, count;
|
||||
RING_LOCALS;
|
||||
|
@ -683,7 +683,7 @@ static int i915_batchbuffer(DRM_IOCTL_ARGS)
|
|||
|
||||
if (batch.num_cliprects && DRM_VERIFYAREA_READ(batch.cliprects,
|
||||
batch.num_cliprects *
|
||||
sizeof(drm_clip_rect_t)))
|
||||
sizeof(struct drm_clip_rect)))
|
||||
return DRM_ERR(EFAULT);
|
||||
|
||||
ret = i915_dispatch_batchbuffer(dev, &batch);
|
||||
|
@ -712,7 +712,7 @@ static int i915_cmdbuffer(DRM_IOCTL_ARGS)
|
|||
if (cmdbuf.num_cliprects &&
|
||||
DRM_VERIFYAREA_READ(cmdbuf.cliprects,
|
||||
cmdbuf.num_cliprects *
|
||||
sizeof(drm_clip_rect_t))) {
|
||||
sizeof(struct drm_clip_rect))) {
|
||||
DRM_ERROR("Fault accessing cliprects\n");
|
||||
return DRM_ERR(EFAULT);
|
||||
}
|
||||
|
|
|
@ -64,7 +64,7 @@ typedef struct _drm_i915_init {
|
|||
} drm_i915_init_t;
|
||||
|
||||
typedef struct _drm_i915_sarea {
|
||||
drm_tex_region_t texList[I915_NR_TEX_REGIONS + 1];
|
||||
struct drm_tex_region texList[I915_NR_TEX_REGIONS + 1];
|
||||
int last_upload; /* last time texture was uploaded */
|
||||
int last_enqueue; /* last time a buffer was enqueued */
|
||||
int last_dispatch; /* age of the most recently dispatched buffer */
|
||||
|
@ -194,7 +194,7 @@ typedef struct _drm_i915_batchbuffer {
|
|||
int DR1; /* hw flags for GFX_OP_DRAWRECT_INFO */
|
||||
int DR4; /* window origin for GFX_OP_DRAWRECT_INFO */
|
||||
int num_cliprects; /* mulitpass with multiple cliprects? */
|
||||
drm_clip_rect_t __user *cliprects; /* pointer to userspace cliprects */
|
||||
struct drm_clip_rect __user *cliprects; /* pointer to userspace cliprects */
|
||||
} drm_i915_batchbuffer_t;
|
||||
|
||||
/* As above, but pass a pointer to userspace buffer which can be
|
||||
|
@ -206,7 +206,7 @@ typedef struct _drm_i915_cmdbuffer {
|
|||
int DR1; /* hw flags for GFX_OP_DRAWRECT_INFO */
|
||||
int DR4; /* window origin for GFX_OP_DRAWRECT_INFO */
|
||||
int num_cliprects; /* mulitpass with multiple cliprects? */
|
||||
drm_clip_rect_t __user *cliprects; /* pointer to userspace cliprects */
|
||||
struct drm_clip_rect __user *cliprects; /* pointer to userspace cliprects */
|
||||
} drm_i915_cmdbuffer_t;
|
||||
|
||||
/* Userspace can request & wait on irq's:
|
||||
|
@ -283,7 +283,7 @@ typedef struct drm_i915_vblank_pipe {
|
|||
*/
|
||||
typedef struct drm_i915_vblank_swap {
|
||||
drm_drawable_t drawable;
|
||||
drm_vblank_seq_type_t seqtype;
|
||||
enum drm_vblank_seq_type seqtype;
|
||||
unsigned int sequence;
|
||||
} drm_i915_vblank_swap_t;
|
||||
|
||||
|
|
|
@ -43,7 +43,8 @@
|
|||
* This function must be called with the drawable spinlock held.
|
||||
*/
|
||||
static void
|
||||
i915_dispatch_vsync_flip(drm_device_t *dev, drm_drawable_info_t *drw, int pipe)
|
||||
i915_dispatch_vsync_flip(drm_device_t *dev, struct drm_drawable_info *drw,
|
||||
int pipe)
|
||||
{
|
||||
drm_i915_private_t *dev_priv = (drm_i915_private_t *) dev->dev_private;
|
||||
drm_i915_sarea_t *sarea_priv = dev_priv->sarea_priv;
|
||||
|
@ -67,7 +68,7 @@ i915_dispatch_vsync_flip(drm_device_t *dev, drm_drawable_info_t *drw, int pipe)
|
|||
|
||||
if (x2 > 0 && y2 > 0) {
|
||||
int i, num_rects = drw->num_rects;
|
||||
drm_clip_rect_t *rect = drw->rects;
|
||||
struct drm_clip_rect *rect = drw->rects;
|
||||
|
||||
for (i = 0; i < num_rects; i++)
|
||||
if (!(rect[i].x1 >= x2 || rect[i].y1 >= y2 ||
|
||||
|
@ -94,7 +95,7 @@ static void i915_vblank_tasklet(drm_device_t *dev)
|
|||
int nhits, nrects, slice[2], upper[2], lower[2], i, num_pages;
|
||||
unsigned counter[2] = { atomic_read(&dev->vbl_received),
|
||||
atomic_read(&dev->vbl_received2) };
|
||||
drm_drawable_info_t *drw;
|
||||
struct drm_drawable_info *drw;
|
||||
drm_i915_sarea_t *sarea_priv = dev_priv->sarea_priv;
|
||||
u32 cpp = dev_priv->cpp, offsets[3];
|
||||
u32 cmd = (cpp == 4) ? (XY_SRC_COPY_BLT_CMD |
|
||||
|
@ -139,7 +140,7 @@ static void i915_vblank_tasklet(drm_device_t *dev)
|
|||
list_for_each(hit, &hits) {
|
||||
drm_i915_vbl_swap_t *swap_cmp =
|
||||
list_entry(hit, drm_i915_vbl_swap_t, head);
|
||||
drm_drawable_info_t *drw_cmp =
|
||||
struct drm_drawable_info *drw_cmp =
|
||||
drm_get_drawable_info(dev, swap_cmp->drw_id);
|
||||
|
||||
if (drw_cmp &&
|
||||
|
@ -198,7 +199,7 @@ static void i915_vblank_tasklet(drm_device_t *dev)
|
|||
list_for_each(hit, &hits) {
|
||||
drm_i915_vbl_swap_t *swap_hit =
|
||||
list_entry(hit, drm_i915_vbl_swap_t, head);
|
||||
drm_clip_rect_t *rect;
|
||||
struct drm_clip_rect *rect;
|
||||
int num_rects, pipe, front, back;
|
||||
unsigned short top, bottom;
|
||||
|
||||
|
@ -625,7 +626,7 @@ int i915_vblank_swap(DRM_IOCTL_ARGS)
|
|||
swap.sequence--;
|
||||
|
||||
if ((curseq - swap.sequence) <= (1<<23)) {
|
||||
drm_drawable_info_t *drw;
|
||||
struct drm_drawable_info *drw;
|
||||
|
||||
LOCK_TEST_WITH_RETURN(dev, filp);
|
||||
|
||||
|
|
|
@ -47,7 +47,7 @@ static void mark_block(drm_device_t * dev, struct mem_block *p, int in_use)
|
|||
{
|
||||
drm_i915_private_t *dev_priv = dev->dev_private;
|
||||
drm_i915_sarea_t *sarea_priv = dev_priv->sarea_priv;
|
||||
drm_tex_region_t *list;
|
||||
struct drm_tex_region *list;
|
||||
unsigned shift, nr;
|
||||
unsigned start;
|
||||
unsigned end;
|
||||
|
|
|
@ -1462,10 +1462,10 @@ int mach64_freelist_put(drm_mach64_private_t * dev_priv, drm_buf_t * copy_buf)
|
|||
/*@{*/
|
||||
|
||||
static int mach64_dma_get_buffers(DRMFILE filp, drm_device_t * dev,
|
||||
drm_dma_t * d)
|
||||
struct drm_dma * d)
|
||||
{
|
||||
int i;
|
||||
drm_buf_t *buf;
|
||||
struct drm_buf *buf;
|
||||
drm_mach64_private_t *dev_priv = dev->dev_private;
|
||||
|
||||
for (i = d->granted_count; i < d->request_count; i++) {
|
||||
|
@ -1495,13 +1495,13 @@ static int mach64_dma_get_buffers(DRMFILE filp, drm_device_t * dev,
|
|||
int mach64_dma_buffers(DRM_IOCTL_ARGS)
|
||||
{
|
||||
DRM_DEVICE;
|
||||
drm_device_dma_t *dma = dev->dma;
|
||||
drm_dma_t d;
|
||||
struct drm_device_dma *dma = dev->dma;
|
||||
struct drm_dma d;
|
||||
int ret = 0;
|
||||
|
||||
LOCK_TEST_WITH_RETURN(dev, filp);
|
||||
|
||||
DRM_COPY_FROM_USER_IOCTL(d, (drm_dma_t *) data, sizeof(d));
|
||||
DRM_COPY_FROM_USER_IOCTL(d, (struct drm_dma *) data, sizeof(d));
|
||||
|
||||
/* Please don't send us buffers.
|
||||
*/
|
||||
|
@ -1525,7 +1525,7 @@ int mach64_dma_buffers(DRM_IOCTL_ARGS)
|
|||
ret = mach64_dma_get_buffers(filp, dev, &d);
|
||||
}
|
||||
|
||||
DRM_COPY_TO_USER_IOCTL((drm_dma_t *) data, d, sizeof(d));
|
||||
DRM_COPY_TO_USER_IOCTL((struct drm_dma *) data, d, sizeof(d));
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
|
|
@ -130,7 +130,7 @@ typedef struct drm_mach64_sarea {
|
|||
|
||||
/* The current cliprects, or a subset thereof.
|
||||
*/
|
||||
drm_clip_rect_t boxes[MACH64_NR_SAREA_CLIPRECTS];
|
||||
struct drm_clip_rect boxes[MACH64_NR_SAREA_CLIPRECTS];
|
||||
unsigned int nbox;
|
||||
|
||||
/* Counters for client-side throttling of rendering clients.
|
||||
|
@ -139,7 +139,7 @@ typedef struct drm_mach64_sarea {
|
|||
|
||||
/* Texture memory LRU.
|
||||
*/
|
||||
drm_tex_region_t tex_list[MACH64_NR_TEX_HEAPS][MACH64_NR_TEX_REGIONS +
|
||||
struct drm_tex_region tex_list[MACH64_NR_TEX_HEAPS][MACH64_NR_TEX_REGIONS +
|
||||
1];
|
||||
unsigned int tex_age[MACH64_NR_TEX_HEAPS];
|
||||
int ctx_owner;
|
||||
|
|
|
@ -86,10 +86,10 @@ static void mach64_print_dirty(const char *msg, unsigned int flags)
|
|||
* negative for an error
|
||||
*/
|
||||
static int mach64_emit_cliprect(DRMFILE filp, drm_mach64_private_t * dev_priv,
|
||||
drm_clip_rect_t * box)
|
||||
struct drm_clip_rect * box)
|
||||
{
|
||||
u32 sc_left_right, sc_top_bottom;
|
||||
drm_clip_rect_t scissor;
|
||||
struct drm_clip_rect scissor;
|
||||
drm_mach64_sarea_t *sarea_priv = dev_priv->sarea_priv;
|
||||
drm_mach64_context_regs_t *regs = &sarea_priv->context_state;
|
||||
DMALOCALS;
|
||||
|
@ -222,7 +222,7 @@ static int mach64_dma_dispatch_clear(DRMFILE filp, drm_device_t * dev,
|
|||
drm_mach64_sarea_t *sarea_priv = dev_priv->sarea_priv;
|
||||
drm_mach64_context_regs_t *ctx = &sarea_priv->context_state;
|
||||
int nbox = sarea_priv->nbox;
|
||||
drm_clip_rect_t *pbox = sarea_priv->boxes;
|
||||
struct drm_clip_rect *pbox = sarea_priv->boxes;
|
||||
u32 fb_bpp, depth_bpp;
|
||||
int i;
|
||||
DMALOCALS;
|
||||
|
@ -360,7 +360,7 @@ static int mach64_dma_dispatch_swap(DRMFILE filp, drm_device_t * dev)
|
|||
drm_mach64_private_t *dev_priv = dev->dev_private;
|
||||
drm_mach64_sarea_t *sarea_priv = dev_priv->sarea_priv;
|
||||
int nbox = sarea_priv->nbox;
|
||||
drm_clip_rect_t *pbox = sarea_priv->boxes;
|
||||
struct drm_clip_rect *pbox = sarea_priv->boxes;
|
||||
u32 fb_bpp;
|
||||
int i;
|
||||
DMALOCALS;
|
||||
|
|
|
@ -443,11 +443,11 @@ static int mga_do_agp_dma_bootstrap(drm_device_t * dev,
|
|||
const unsigned secondary_size = dma_bs->secondary_bin_count
|
||||
* dma_bs->secondary_bin_size;
|
||||
const unsigned agp_size = (dma_bs->agp_size << 20);
|
||||
drm_buf_desc_t req;
|
||||
drm_agp_mode_t mode;
|
||||
drm_agp_info_t info;
|
||||
drm_agp_buffer_t agp_req;
|
||||
drm_agp_binding_t bind_req;
|
||||
struct drm_buf_desc req;
|
||||
struct drm_agp_mode mode;
|
||||
struct drm_agp_info info;
|
||||
struct drm_agp_buffer agp_req;
|
||||
struct drm_agp_binding bind_req;
|
||||
|
||||
/* Acquire AGP. */
|
||||
err = drm_agp_acquire(dev);
|
||||
|
@ -611,7 +611,7 @@ static int mga_do_pci_dma_bootstrap(drm_device_t * dev,
|
|||
unsigned int primary_size;
|
||||
unsigned int bin_count;
|
||||
int err;
|
||||
drm_buf_desc_t req;
|
||||
struct drm_buf_desc req;
|
||||
|
||||
|
||||
if (dev->dma == NULL) {
|
||||
|
@ -967,8 +967,8 @@ static int mga_do_cleanup_dma(drm_device_t * dev, int full_cleanup)
|
|||
|
||||
if (dev_priv->used_new_dma_init) {
|
||||
if (dev_priv->agp_handle != 0) {
|
||||
drm_agp_binding_t unbind_req;
|
||||
drm_agp_buffer_t free_req;
|
||||
struct drm_agp_binding unbind_req;
|
||||
struct drm_agp_buffer free_req;
|
||||
|
||||
unbind_req.handle = dev_priv->agp_handle;
|
||||
drm_agp_unbind(dev, &unbind_req);
|
||||
|
@ -1043,11 +1043,11 @@ int mga_dma_flush(DRM_IOCTL_ARGS)
|
|||
{
|
||||
DRM_DEVICE;
|
||||
drm_mga_private_t *dev_priv = (drm_mga_private_t *) dev->dev_private;
|
||||
drm_lock_t lock;
|
||||
struct drm_lock lock;
|
||||
|
||||
LOCK_TEST_WITH_RETURN(dev, filp);
|
||||
|
||||
DRM_COPY_FROM_USER_IOCTL(lock, (drm_lock_t __user *) data,
|
||||
DRM_COPY_FROM_USER_IOCTL(lock, (struct drm_lock __user *) data,
|
||||
sizeof(lock));
|
||||
|
||||
DRM_DEBUG("%s%s%s\n",
|
||||
|
@ -1089,7 +1089,7 @@ int mga_dma_reset(DRM_IOCTL_ARGS)
|
|||
* DMA buffer management
|
||||
*/
|
||||
|
||||
static int mga_dma_get_buffers(DRMFILE filp, drm_device_t * dev, drm_dma_t * d)
|
||||
static int mga_dma_get_buffers(DRMFILE filp, drm_device_t * dev, struct drm_dma * d)
|
||||
{
|
||||
drm_buf_t *buf;
|
||||
int i;
|
||||
|
@ -1118,8 +1118,8 @@ int mga_dma_buffers(DRM_IOCTL_ARGS)
|
|||
DRM_DEVICE;
|
||||
drm_device_dma_t *dma = dev->dma;
|
||||
drm_mga_private_t *dev_priv = (drm_mga_private_t *) dev->dev_private;
|
||||
drm_dma_t __user *argp = (void __user *)data;
|
||||
drm_dma_t d;
|
||||
struct drm_dma __user *argp = (void __user *)data;
|
||||
struct drm_dma d;
|
||||
int ret = 0;
|
||||
|
||||
LOCK_TEST_WITH_RETURN(dev, filp);
|
||||
|
|
|
@ -181,7 +181,7 @@ typedef struct _drm_mga_sarea {
|
|||
|
||||
/* The current cliprects, or a subset thereof.
|
||||
*/
|
||||
drm_clip_rect_t boxes[MGA_NR_SAREA_CLIPRECTS];
|
||||
struct drm_clip_rect boxes[MGA_NR_SAREA_CLIPRECTS];
|
||||
unsigned int nbox;
|
||||
|
||||
/* Information about the most recently used 3d drawable. The
|
||||
|
@ -202,7 +202,7 @@ typedef struct _drm_mga_sarea {
|
|||
unsigned int exported_nback;
|
||||
int exported_back_x, exported_front_x, exported_w;
|
||||
int exported_back_y, exported_front_y, exported_h;
|
||||
drm_clip_rect_t exported_boxes[MGA_NR_SAREA_CLIPRECTS];
|
||||
struct drm_clip_rect exported_boxes[MGA_NR_SAREA_CLIPRECTS];
|
||||
|
||||
/* Counters for aging textures and for client-side throttling.
|
||||
*/
|
||||
|
@ -216,7 +216,7 @@ typedef struct _drm_mga_sarea {
|
|||
|
||||
/* LRU lists for texture memory in agp space and on the card.
|
||||
*/
|
||||
drm_tex_region_t texList[MGA_NR_TEX_HEAPS][MGA_NR_TEX_REGIONS + 1];
|
||||
struct drm_tex_region texList[MGA_NR_TEX_HEAPS][MGA_NR_TEX_REGIONS + 1];
|
||||
unsigned int texAge[MGA_NR_TEX_HEAPS];
|
||||
|
||||
/* Mechanism to validate card state.
|
||||
|
|
|
@ -43,7 +43,7 @@
|
|||
*/
|
||||
|
||||
static void mga_emit_clip_rect(drm_mga_private_t * dev_priv,
|
||||
drm_clip_rect_t * box)
|
||||
struct drm_clip_rect * box)
|
||||
{
|
||||
drm_mga_sarea_t *sarea_priv = dev_priv->sarea_priv;
|
||||
drm_mga_context_regs_t *ctx = &sarea_priv->context_state;
|
||||
|
@ -509,7 +509,7 @@ static void mga_dma_dispatch_clear(drm_device_t * dev, drm_mga_clear_t * clear)
|
|||
drm_mga_private_t *dev_priv = dev->dev_private;
|
||||
drm_mga_sarea_t *sarea_priv = dev_priv->sarea_priv;
|
||||
drm_mga_context_regs_t *ctx = &sarea_priv->context_state;
|
||||
drm_clip_rect_t *pbox = sarea_priv->boxes;
|
||||
struct drm_clip_rect *pbox = sarea_priv->boxes;
|
||||
int nbox = sarea_priv->nbox;
|
||||
int i;
|
||||
DMA_LOCALS;
|
||||
|
@ -525,7 +525,7 @@ static void mga_dma_dispatch_clear(drm_device_t * dev, drm_mga_clear_t * clear)
|
|||
ADVANCE_DMA();
|
||||
|
||||
for (i = 0; i < nbox; i++) {
|
||||
drm_clip_rect_t *box = &pbox[i];
|
||||
struct drm_clip_rect *box = &pbox[i];
|
||||
u32 height = box->y2 - box->y1;
|
||||
|
||||
DRM_DEBUG(" from=%d,%d to=%d,%d\n",
|
||||
|
@ -599,7 +599,7 @@ static void mga_dma_dispatch_swap(drm_device_t * dev)
|
|||
drm_mga_private_t *dev_priv = dev->dev_private;
|
||||
drm_mga_sarea_t *sarea_priv = dev_priv->sarea_priv;
|
||||
drm_mga_context_regs_t *ctx = &sarea_priv->context_state;
|
||||
drm_clip_rect_t *pbox = sarea_priv->boxes;
|
||||
struct drm_clip_rect *pbox = sarea_priv->boxes;
|
||||
int nbox = sarea_priv->nbox;
|
||||
int i;
|
||||
DMA_LOCALS;
|
||||
|
@ -626,7 +626,7 @@ static void mga_dma_dispatch_swap(drm_device_t * dev)
|
|||
MGA_DWGCTL, MGA_DWGCTL_COPY);
|
||||
|
||||
for (i = 0; i < nbox; i++) {
|
||||
drm_clip_rect_t *box = &pbox[i];
|
||||
struct drm_clip_rect *box = &pbox[i];
|
||||
u32 height = box->y2 - box->y1;
|
||||
u32 start = box->y1 * dev_priv->front_pitch;
|
||||
|
||||
|
@ -805,7 +805,7 @@ static void mga_dma_dispatch_blit(drm_device_t * dev, drm_mga_blit_t * blit)
|
|||
drm_mga_private_t *dev_priv = dev->dev_private;
|
||||
drm_mga_sarea_t *sarea_priv = dev_priv->sarea_priv;
|
||||
drm_mga_context_regs_t *ctx = &sarea_priv->context_state;
|
||||
drm_clip_rect_t *pbox = sarea_priv->boxes;
|
||||
struct drm_clip_rect *pbox = sarea_priv->boxes;
|
||||
int nbox = sarea_priv->nbox;
|
||||
u32 scandir = 0, i;
|
||||
DMA_LOCALS;
|
||||
|
|
|
@ -137,7 +137,7 @@ enum nouveau_bus_type {
|
|||
|
||||
struct drm_nouveau_sarea {
|
||||
/* the cliprects */
|
||||
drm_clip_rect_t boxes[NOUVEAU_MAX_SAREA_CLIPRECTS];
|
||||
struct drm_clip_rect boxes[NOUVEAU_MAX_SAREA_CLIPRECTS];
|
||||
unsigned int nbox;
|
||||
};
|
||||
|
||||
|
|
|
@ -288,7 +288,7 @@ int nouveau_mem_init(struct drm_device *dev)
|
|||
{
|
||||
struct drm_nouveau_private *dev_priv = dev->dev_private;
|
||||
uint32_t fb_size;
|
||||
drm_scatter_gather_t sgreq;
|
||||
struct drm_scatter_gather sgreq;
|
||||
dev_priv->agp_phys=0;
|
||||
dev_priv->fb_phys=0;
|
||||
sgreq . size = 4 << 20; //4MB of PCI scatter-gather zone
|
||||
|
@ -298,10 +298,10 @@ int nouveau_mem_init(struct drm_device *dev)
|
|||
if (drm_device_is_agp(dev))
|
||||
{
|
||||
int err;
|
||||
drm_agp_info_t info;
|
||||
drm_agp_mode_t mode;
|
||||
drm_agp_buffer_t agp_req;
|
||||
drm_agp_binding_t bind_req;
|
||||
struct drm_agp_info info;
|
||||
struct drm_agp_mode mode;
|
||||
struct drm_agp_buffer agp_req;
|
||||
struct drm_agp_binding bind_req;
|
||||
|
||||
err = drm_agp_acquire(dev);
|
||||
if (err) {
|
||||
|
|
|
@ -884,7 +884,7 @@ int r128_wait_ring(drm_r128_private_t * dev_priv, int n)
|
|||
return DRM_ERR(EBUSY);
|
||||
}
|
||||
|
||||
static int r128_cce_get_buffers(DRMFILE filp, drm_device_t * dev, drm_dma_t * d)
|
||||
static int r128_cce_get_buffers(DRMFILE filp, drm_device_t * dev, struct drm_dma * d)
|
||||
{
|
||||
int i;
|
||||
drm_buf_t *buf;
|
||||
|
@ -913,8 +913,8 @@ int r128_cce_buffers(DRM_IOCTL_ARGS)
|
|||
DRM_DEVICE;
|
||||
drm_device_dma_t *dma = dev->dma;
|
||||
int ret = 0;
|
||||
drm_dma_t __user *argp = (void __user *)data;
|
||||
drm_dma_t d;
|
||||
struct drm_dma __user *argp = (void __user *)data;
|
||||
struct drm_dma d;
|
||||
|
||||
LOCK_TEST_WITH_RETURN(dev, filp);
|
||||
|
||||
|
|
|
@ -153,7 +153,7 @@ typedef struct drm_r128_sarea {
|
|||
|
||||
/* The current cliprects, or a subset thereof.
|
||||
*/
|
||||
drm_clip_rect_t boxes[R128_NR_SAREA_CLIPRECTS];
|
||||
struct drm_clip_rect boxes[R128_NR_SAREA_CLIPRECTS];
|
||||
unsigned int nbox;
|
||||
|
||||
/* Counters for client-side throttling of rendering clients.
|
||||
|
@ -161,7 +161,7 @@ typedef struct drm_r128_sarea {
|
|||
unsigned int last_frame;
|
||||
unsigned int last_dispatch;
|
||||
|
||||
drm_tex_region_t tex_list[R128_NR_TEX_HEAPS][R128_NR_TEX_REGIONS + 1];
|
||||
struct drm_tex_region tex_list[R128_NR_TEX_HEAPS][R128_NR_TEX_REGIONS + 1];
|
||||
unsigned int tex_age[R128_NR_TEX_HEAPS];
|
||||
int ctx_owner;
|
||||
int pfAllowPageFlip; /* number of 3d windows (0,1,2 or more) */
|
||||
|
|
|
@ -38,7 +38,7 @@
|
|||
*/
|
||||
|
||||
static void r128_emit_clip_rects(drm_r128_private_t * dev_priv,
|
||||
drm_clip_rect_t * boxes, int count)
|
||||
struct drm_clip_rect * boxes, int count)
|
||||
{
|
||||
u32 aux_sc_cntl = 0x00000000;
|
||||
RING_LOCALS;
|
||||
|
@ -358,7 +358,7 @@ static void r128_cce_dispatch_clear(drm_device_t * dev,
|
|||
drm_r128_private_t *dev_priv = dev->dev_private;
|
||||
drm_r128_sarea_t *sarea_priv = dev_priv->sarea_priv;
|
||||
int nbox = sarea_priv->nbox;
|
||||
drm_clip_rect_t *pbox = sarea_priv->boxes;
|
||||
struct drm_clip_rect *pbox = sarea_priv->boxes;
|
||||
unsigned int flags = clear->flags;
|
||||
int i;
|
||||
RING_LOCALS;
|
||||
|
@ -463,7 +463,7 @@ static void r128_cce_dispatch_swap(drm_device_t * dev)
|
|||
drm_r128_private_t *dev_priv = dev->dev_private;
|
||||
drm_r128_sarea_t *sarea_priv = dev_priv->sarea_priv;
|
||||
int nbox = sarea_priv->nbox;
|
||||
drm_clip_rect_t *pbox = sarea_priv->boxes;
|
||||
struct drm_clip_rect *pbox = sarea_priv->boxes;
|
||||
int i;
|
||||
RING_LOCALS;
|
||||
DRM_DEBUG("%s\n", __FUNCTION__);
|
||||
|
|
|
@ -55,7 +55,7 @@ static const int r300_cliprect_cntl[4] = {
|
|||
static int r300_emit_cliprects(drm_radeon_private_t *dev_priv,
|
||||
drm_radeon_kcmd_buffer_t *cmdbuf, int n)
|
||||
{
|
||||
drm_clip_rect_t box;
|
||||
struct drm_clip_rect box;
|
||||
int nr;
|
||||
int i;
|
||||
RING_LOCALS;
|
||||
|
|
|
@ -2191,7 +2191,7 @@ int radeon_wait_ring(drm_radeon_private_t * dev_priv, int n)
|
|||
}
|
||||
|
||||
static int radeon_cp_get_buffers(DRMFILE filp, drm_device_t * dev,
|
||||
drm_dma_t * d)
|
||||
struct drm_dma * d)
|
||||
{
|
||||
int i;
|
||||
drm_buf_t *buf;
|
||||
|
@ -2220,8 +2220,8 @@ int radeon_cp_buffers(DRM_IOCTL_ARGS)
|
|||
DRM_DEVICE;
|
||||
drm_device_dma_t *dma = dev->dma;
|
||||
int ret = 0;
|
||||
drm_dma_t __user *argp = (void __user *)data;
|
||||
drm_dma_t d;
|
||||
struct drm_dma __user *argp = (void __user *)data;
|
||||
struct drm_dma d;
|
||||
|
||||
LOCK_TEST_WITH_RETURN(dev, filp);
|
||||
|
||||
|
|
|
@ -417,7 +417,7 @@ typedef struct {
|
|||
|
||||
/* The current cliprects, or a subset thereof.
|
||||
*/
|
||||
drm_clip_rect_t boxes[RADEON_NR_SAREA_CLIPRECTS];
|
||||
struct drm_clip_rect boxes[RADEON_NR_SAREA_CLIPRECTS];
|
||||
unsigned int nbox;
|
||||
|
||||
/* Counters for client-side throttling of rendering clients.
|
||||
|
@ -426,7 +426,7 @@ typedef struct {
|
|||
unsigned int last_dispatch;
|
||||
unsigned int last_clear;
|
||||
|
||||
drm_tex_region_t tex_list[RADEON_NR_TEX_HEAPS][RADEON_NR_TEX_REGIONS +
|
||||
struct drm_tex_region tex_list[RADEON_NR_TEX_HEAPS][RADEON_NR_TEX_REGIONS +
|
||||
1];
|
||||
unsigned int tex_age[RADEON_NR_TEX_HEAPS];
|
||||
int ctx_owner;
|
||||
|
@ -604,7 +604,7 @@ typedef struct drm_radeon_cmd_buffer {
|
|||
int bufsz;
|
||||
char __user *buf;
|
||||
int nbox;
|
||||
drm_clip_rect_t __user *boxes;
|
||||
struct drm_clip_rect __user *boxes;
|
||||
} drm_radeon_cmd_buffer_t;
|
||||
|
||||
typedef struct drm_radeon_tex_image {
|
||||
|
|
|
@ -312,7 +312,7 @@ typedef struct drm_radeon_kcmd_buffer {
|
|||
int bufsz;
|
||||
char *buf;
|
||||
int nbox;
|
||||
drm_clip_rect_t __user *boxes;
|
||||
struct drm_clip_rect __user *boxes;
|
||||
} drm_radeon_kcmd_buffer_t;
|
||||
|
||||
extern int radeon_no_wb;
|
||||
|
|
|
@ -421,7 +421,7 @@ static __inline__ int radeon_check_and_fixup_packet3(drm_radeon_private_t *
|
|||
*/
|
||||
|
||||
static __inline__ void radeon_emit_clip_rect(drm_radeon_private_t * dev_priv,
|
||||
drm_clip_rect_t * box)
|
||||
struct drm_clip_rect * box)
|
||||
{
|
||||
RING_LOCALS;
|
||||
|
||||
|
@ -852,7 +852,7 @@ static void radeon_cp_dispatch_clear(drm_device_t * dev,
|
|||
drm_radeon_sarea_t *sarea_priv = dev_priv->sarea_priv;
|
||||
drm_radeon_depth_clear_t *depth_clear = &dev_priv->depth_clear;
|
||||
int nbox = sarea_priv->nbox;
|
||||
drm_clip_rect_t *pbox = sarea_priv->boxes;
|
||||
struct drm_clip_rect *pbox = sarea_priv->boxes;
|
||||
unsigned int flags = clear->flags;
|
||||
u32 rb3d_cntl = 0, rb3d_stencilrefmask = 0;
|
||||
int i;
|
||||
|
@ -1340,7 +1340,7 @@ static void radeon_cp_dispatch_swap(drm_device_t * dev)
|
|||
drm_radeon_private_t *dev_priv = dev->dev_private;
|
||||
drm_radeon_sarea_t *sarea_priv = dev_priv->sarea_priv;
|
||||
int nbox = sarea_priv->nbox;
|
||||
drm_clip_rect_t *pbox = sarea_priv->boxes;
|
||||
struct drm_clip_rect *pbox = sarea_priv->boxes;
|
||||
int i;
|
||||
RING_LOCALS;
|
||||
DRM_DEBUG("\n");
|
||||
|
@ -1415,7 +1415,7 @@ static void radeon_cp_dispatch_swap(drm_device_t * dev)
|
|||
static void radeon_cp_dispatch_flip(drm_device_t * dev)
|
||||
{
|
||||
drm_radeon_private_t *dev_priv = dev->dev_private;
|
||||
drm_sarea_t *sarea = (drm_sarea_t *) dev_priv->sarea->handle;
|
||||
struct drm_sarea *sarea = (struct drm_sarea *) dev_priv->sarea->handle;
|
||||
int offset = (dev_priv->sarea_priv->pfCurrentPage == 1)
|
||||
? dev_priv->front_offset : dev_priv->back_offset;
|
||||
RING_LOCALS;
|
||||
|
@ -2795,10 +2795,10 @@ static int radeon_emit_packet3_cliprect(drm_device_t *dev,
|
|||
int orig_nbox)
|
||||
{
|
||||
drm_radeon_private_t *dev_priv = dev->dev_private;
|
||||
drm_clip_rect_t box;
|
||||
struct drm_clip_rect box;
|
||||
unsigned int cmdsz;
|
||||
int ret;
|
||||
drm_clip_rect_t __user *boxes = cmdbuf->boxes;
|
||||
struct drm_clip_rect __user *boxes = cmdbuf->boxes;
|
||||
int i = 0;
|
||||
RING_LOCALS;
|
||||
|
||||
|
|
|
@ -1006,7 +1006,7 @@ static int savage_bci_event_wait(DRM_IOCTL_ARGS)
|
|||
* DMA buffer management
|
||||
*/
|
||||
|
||||
static int savage_bci_get_buffers(DRMFILE filp, drm_device_t *dev, drm_dma_t *d)
|
||||
static int savage_bci_get_buffers(DRMFILE filp, drm_device_t *dev, struct drm_dma *d)
|
||||
{
|
||||
drm_buf_t *buf;
|
||||
int i;
|
||||
|
@ -1034,12 +1034,12 @@ int savage_bci_buffers(DRM_IOCTL_ARGS)
|
|||
{
|
||||
DRM_DEVICE;
|
||||
drm_device_dma_t *dma = dev->dma;
|
||||
drm_dma_t d;
|
||||
struct drm_dma d;
|
||||
int ret = 0;
|
||||
|
||||
LOCK_TEST_WITH_RETURN(dev, filp);
|
||||
|
||||
DRM_COPY_FROM_USER_IOCTL(d, (drm_dma_t __user *)data, sizeof(d));
|
||||
DRM_COPY_FROM_USER_IOCTL(d, (struct drm_dma __user *)data, sizeof(d));
|
||||
|
||||
/* Please don't send us buffers.
|
||||
*/
|
||||
|
@ -1063,7 +1063,7 @@ int savage_bci_buffers(DRM_IOCTL_ARGS)
|
|||
ret = savage_bci_get_buffers(filp, dev, &d);
|
||||
}
|
||||
|
||||
DRM_COPY_TO_USER_IOCTL((drm_dma_t __user *)data, d, sizeof(d));
|
||||
DRM_COPY_TO_USER_IOCTL((struct drm_dma __user *)data, d, sizeof(d));
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
|
|
@ -47,7 +47,7 @@
|
|||
typedef struct _drm_savage_sarea {
|
||||
/* LRU lists for texture memory in agp space and on the card.
|
||||
*/
|
||||
drm_tex_region_t texList[SAVAGE_NR_TEX_HEAPS][SAVAGE_NR_TEX_REGIONS+1];
|
||||
struct drm_tex_region texList[SAVAGE_NR_TEX_HEAPS][SAVAGE_NR_TEX_REGIONS+1];
|
||||
unsigned int texAge[SAVAGE_NR_TEX_HEAPS];
|
||||
|
||||
/* Mechanism to validate card state.
|
||||
|
@ -112,7 +112,7 @@ typedef struct drm_savage_cmdbuf {
|
|||
unsigned int vb_size; /* size of client vertex buffer in bytes */
|
||||
unsigned int vb_stride; /* stride of vertices in 32bit words */
|
||||
/* boxes in client's address space */
|
||||
drm_clip_rect_t __user *box_addr;
|
||||
struct drm_clip_rect __user *box_addr;
|
||||
unsigned int nbox; /* number of clipping boxes */
|
||||
} drm_savage_cmdbuf_t;
|
||||
|
||||
|
|
|
@ -192,7 +192,7 @@ typedef struct drm_savage_private {
|
|||
/* Err, there is a macro wait_event in include/linux/wait.h.
|
||||
* Avoid unwanted macro expansion. */
|
||||
void (*emit_clip_rect)(struct drm_savage_private *dev_priv,
|
||||
const drm_clip_rect_t *pbox);
|
||||
const struct drm_clip_rect *pbox);
|
||||
void (*dma_flush)(struct drm_savage_private *dev_priv);
|
||||
} drm_savage_private_t;
|
||||
|
||||
|
@ -216,9 +216,9 @@ extern void savage_reclaim_buffers(drm_device_t *dev, DRMFILE filp);
|
|||
|
||||
/* state functions */
|
||||
extern void savage_emit_clip_rect_s3d(drm_savage_private_t *dev_priv,
|
||||
const drm_clip_rect_t *pbox);
|
||||
const struct drm_clip_rect *pbox);
|
||||
extern void savage_emit_clip_rect_s4(drm_savage_private_t *dev_priv,
|
||||
const drm_clip_rect_t *pbox);
|
||||
const struct drm_clip_rect *pbox);
|
||||
|
||||
#define SAVAGE_FB_SIZE_S3 0x01000000 /* 16MB */
|
||||
#define SAVAGE_FB_SIZE_S4 0x02000000 /* 32MB */
|
||||
|
|
|
@ -27,7 +27,7 @@
|
|||
#include "savage_drv.h"
|
||||
|
||||
void savage_emit_clip_rect_s3d(drm_savage_private_t *dev_priv,
|
||||
const drm_clip_rect_t *pbox)
|
||||
const struct drm_clip_rect *pbox)
|
||||
{
|
||||
uint32_t scstart = dev_priv->state.s3d.new_scstart;
|
||||
uint32_t scend = dev_priv->state.s3d.new_scend;
|
||||
|
@ -53,7 +53,7 @@ void savage_emit_clip_rect_s3d(drm_savage_private_t *dev_priv,
|
|||
}
|
||||
|
||||
void savage_emit_clip_rect_s4(drm_savage_private_t *dev_priv,
|
||||
const drm_clip_rect_t *pbox)
|
||||
const struct drm_clip_rect *pbox)
|
||||
{
|
||||
uint32_t drawctrl0 = dev_priv->state.s4.new_drawctrl0;
|
||||
uint32_t drawctrl1 = dev_priv->state.s4.new_drawctrl1;
|
||||
|
@ -790,7 +790,7 @@ static int savage_dispatch_clear(drm_savage_private_t *dev_priv,
|
|||
const drm_savage_cmd_header_t *cmd_header,
|
||||
const drm_savage_cmd_header_t *data,
|
||||
unsigned int nbox,
|
||||
const drm_clip_rect_t *boxes)
|
||||
const struct drm_clip_rect *boxes)
|
||||
{
|
||||
unsigned int flags = cmd_header->clear0.flags;
|
||||
unsigned int clear_cmd;
|
||||
|
@ -860,7 +860,7 @@ static int savage_dispatch_clear(drm_savage_private_t *dev_priv,
|
|||
}
|
||||
|
||||
static int savage_dispatch_swap(drm_savage_private_t *dev_priv,
|
||||
unsigned int nbox, const drm_clip_rect_t *boxes)
|
||||
unsigned int nbox, const struct drm_clip_rect *boxes)
|
||||
{
|
||||
unsigned int swap_cmd;
|
||||
unsigned int i;
|
||||
|
@ -895,7 +895,7 @@ static int savage_dispatch_draw(drm_savage_private_t *dev_priv,
|
|||
const unsigned int *vtxbuf,
|
||||
unsigned int vb_size, unsigned int vb_stride,
|
||||
unsigned int nbox,
|
||||
const drm_clip_rect_t *boxes)
|
||||
const struct drm_clip_rect *boxes)
|
||||
{
|
||||
unsigned int i, j;
|
||||
int ret;
|
||||
|
@ -962,7 +962,7 @@ int savage_bci_cmdbuf(DRM_IOCTL_ARGS)
|
|||
drm_savage_cmd_header_t *kcmd_addr = NULL;
|
||||
drm_savage_cmd_header_t *first_draw_cmd;
|
||||
unsigned int *kvb_addr = NULL;
|
||||
drm_clip_rect_t *kbox_addr = NULL;
|
||||
struct drm_clip_rect *kbox_addr = NULL;
|
||||
unsigned int i, j;
|
||||
int ret = 0;
|
||||
|
||||
|
@ -1018,7 +1018,7 @@ int savage_bci_cmdbuf(DRM_IOCTL_ARGS)
|
|||
cmdbuf.vb_addr = kvb_addr;
|
||||
}
|
||||
if (cmdbuf.nbox) {
|
||||
kbox_addr = drm_alloc(cmdbuf.nbox * sizeof(drm_clip_rect_t),
|
||||
kbox_addr = drm_alloc(cmdbuf.nbox * sizeof(struct drm_clip_rect),
|
||||
DRM_MEM_DRIVER);
|
||||
if (kbox_addr == NULL) {
|
||||
ret = DRM_ERR(ENOMEM);
|
||||
|
@ -1026,7 +1026,7 @@ int savage_bci_cmdbuf(DRM_IOCTL_ARGS)
|
|||
}
|
||||
|
||||
if (DRM_COPY_FROM_USER(kbox_addr, cmdbuf.box_addr,
|
||||
cmdbuf.nbox * sizeof(drm_clip_rect_t))) {
|
||||
cmdbuf.nbox * sizeof(struct drm_clip_rect))) {
|
||||
ret = DRM_ERR(EFAULT);
|
||||
goto done;
|
||||
}
|
||||
|
@ -1157,7 +1157,7 @@ done:
|
|||
/* If we didn't need to allocate them, these'll be NULL */
|
||||
drm_free(kcmd_addr, cmdbuf.size * 8, DRM_MEM_DRIVER);
|
||||
drm_free(kvb_addr, cmdbuf.vb_size, DRM_MEM_DRIVER);
|
||||
drm_free(kbox_addr, cmdbuf.nbox * sizeof(drm_clip_rect_t),
|
||||
drm_free(kbox_addr, cmdbuf.nbox * sizeof(struct drm_clip_rect),
|
||||
DRM_MEM_DRIVER);
|
||||
|
||||
return ret;
|
||||
|
|
|
@ -54,7 +54,7 @@
|
|||
#define VIA_NR_XVMC_LOCKS 5
|
||||
#define VIA_MAX_CACHELINE_SIZE 64
|
||||
#define XVMCLOCKPTR(saPriv,lockNo) \
|
||||
((volatile drm_hw_lock_t *)(((((unsigned long) (saPriv)->XvMCLockArea) + \
|
||||
((volatile struct drm_hw_lock *)(((((unsigned long) (saPriv)->XvMCLockArea) + \
|
||||
(VIA_MAX_CACHELINE_SIZE - 1)) & \
|
||||
~(VIA_MAX_CACHELINE_SIZE - 1)) + \
|
||||
VIA_MAX_CACHELINE_SIZE*(lockNo)))
|
||||
|
@ -187,7 +187,7 @@ typedef struct _drm_via_tex_region {
|
|||
typedef struct _drm_via_sarea {
|
||||
unsigned int dirty;
|
||||
unsigned int nbox;
|
||||
drm_clip_rect_t boxes[VIA_NR_SAREA_CLIPRECTS];
|
||||
struct drm_clip_rect boxes[VIA_NR_SAREA_CLIPRECTS];
|
||||
drm_via_tex_region_t texList[VIA_NR_TEX_REGIONS + 1];
|
||||
int texAge; /* last time texture was uploaded */
|
||||
int ctxOwner; /* last context to upload state */
|
||||
|
|
Loading…
Reference in New Issue