};
 
 /** bufs is one longer than it has to be */
-typedef struct drm_waitlist {
+struct drm_waitlist {
        int count;                      /**< Number of possible buffers */
        struct drm_buf **bufs;          /**< List of pointers to buffers */
        struct drm_buf **rp;                    /**< Read pointer */
        struct drm_buf **end;           /**< End pointer */
        spinlock_t read_lock;
        spinlock_t write_lock;
-} drm_waitlist_t;
+};
 
-typedef struct drm_freelist {
+struct drm_freelist {
        int initialized;               /**< Freelist in use */
        atomic_t count;                /**< Number of free buffers */
        struct drm_buf *next;          /**< End pointer */
        int high_mark;                 /**< High water mark */
        atomic_t wfh;                  /**< If waiting for high mark */
        spinlock_t lock;
-} drm_freelist_t;
+};
 
 typedef struct drm_dma_handle {
        dma_addr_t busaddr;
 /**
  * Buffer entry.  There is one of this for each buffer size order.
  */
-typedef struct drm_buf_entry {
+struct drm_buf_entry {
        int buf_size;                   /**< size */
        int buf_count;                  /**< number of buffers */
        struct drm_buf *buflist;                /**< buffer list */
        int seg_count;
        int page_order;
-       drm_dma_handle_t **seglist;
+       struct drm_dma_handle **seglist;
 
-       drm_freelist_t freelist;
-} drm_buf_entry_t;
+       struct drm_freelist freelist;
+};
 
 /** File private data */
 struct drm_file {
 };
 
 /** Wait queue */
-typedef struct drm_queue {
+struct drm_queue {
        atomic_t use_count;             /**< Outstanding uses (+1) */
        atomic_t finalization;          /**< Finalization in progress */
        atomic_t block_count;           /**< Count of processes waiting */
        atomic_t total_locks;           /**< Total locks statistics */
 #endif
        enum drm_ctx_flags flags;       /**< Context preserving and 2D-only */
-       drm_waitlist_t waitlist;        /**< Pending buffers */
+       struct drm_waitlist waitlist;   /**< Pending buffers */
        wait_queue_head_t flush_queue;  /**< Processes waiting until flush */
-} drm_queue_t;
+};
 
 /**
  * Lock data.
 /**
  * DMA data.
  */
-typedef struct drm_device_dma {
+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 */
        struct drm_buf **buflist;               /**< Vector of pointers into drm_device_dma::bufs */
        int seg_count;
                _DRM_DMA_USE_PCI_RO = 0x08
        } flags;
 
-} drm_device_dma_t;
+};
 
 /**
  * AGP memory entry.  Stored as a doubly linked list.
        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 */
 
  *
  * Frees any pages and buffers associated with the given entry.
  */
-static void drm_cleanup_buf_error(struct drm_device * dev, drm_buf_entry_t * entry)
+static void drm_cleanup_buf_error(struct drm_device * dev,
+                                 struct drm_buf_entry * entry)
 {
        int i;
 
  */
 int drm_addbufs_agp(struct drm_device * dev, struct drm_buf_desc * request)
 {
-       drm_device_dma_t *dma = dev->dma;
-       drm_buf_entry_t *entry;
+       struct drm_device_dma *dma = dev->dma;
+       struct drm_buf_entry *entry;
        drm_agp_mem_t *agp_entry;
        struct drm_buf *buf;
        unsigned long offset;
 
 int drm_addbufs_pci(struct drm_device * dev, struct drm_buf_desc * request)
 {
-       drm_device_dma_t *dma = dev->dma;
+       struct drm_device_dma *dma = dev->dma;
        int count;
        int order;
        int size;
        int total;
        int page_order;
-       drm_buf_entry_t *entry;
+       struct drm_buf_entry *entry;
        drm_dma_handle_t *dmah;
        struct drm_buf *buf;
        int alignment;
 
 static int drm_addbufs_sg(struct drm_device * dev, struct drm_buf_desc * request)
 {
-       drm_device_dma_t *dma = dev->dma;
-       drm_buf_entry_t *entry;
+       struct drm_device_dma *dma = dev->dma;
+       struct drm_buf_entry *entry;
        struct drm_buf *buf;
        unsigned long offset;
        unsigned long agp_offset;
 
 static int drm_addbufs_fb(struct drm_device * dev, struct drm_buf_desc * request)
 {
-       drm_device_dma_t *dma = dev->dma;
-       drm_buf_entry_t *entry;
+       struct drm_device_dma *dma = dev->dma;
+       struct drm_buf_entry *entry;
        struct drm_buf *buf;
        unsigned long offset;
        unsigned long agp_offset;
 {
        struct drm_file *priv = filp->private_data;
        struct drm_device *dev = priv->head->dev;
-       drm_device_dma_t *dma = dev->dma;
+       struct drm_device_dma *dma = dev->dma;
        struct drm_buf_info request;
        struct drm_buf_info __user *argp = (void __user *)arg;
        int i;
                        if (dma->bufs[i].buf_count) {
                                struct drm_buf_desc __user *to =
                                    &request.list[count];
-                               drm_buf_entry_t *from = &dma->bufs[i];
-                               drm_freelist_t *list = &dma->bufs[i].freelist;
+                               struct drm_buf_entry *from = &dma->bufs[i];
+                               struct drm_freelist *list = &dma->bufs[i].freelist;
                                if (copy_to_user(&to->count,
                                                 &from->buf_count,
                                                 sizeof(from->buf_count)) ||
 {
        struct drm_file *priv = filp->private_data;
        struct drm_device *dev = priv->head->dev;
-       drm_device_dma_t *dma = dev->dma;
+       struct drm_device_dma *dma = dev->dma;
        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;
 {
        struct drm_file *priv = filp->private_data;
        struct drm_device *dev = priv->head->dev;
-       drm_device_dma_t *dma = dev->dma;
+       struct drm_device_dma *dma = dev->dma;
        struct drm_buf_free request;
        int i;
        int idx;
 {
        struct drm_file *priv = filp->private_data;
        struct drm_device *dev = priv->head->dev;
-       drm_device_dma_t *dma = dev->dma;
+       struct drm_device_dma *dma = dev->dma;
        struct drm_buf_map __user *argp = (void __user *)arg;
        int retcode = 0;
        const int zero = 0;
 
  */
 void drm_dma_takedown(struct drm_device *dev)
 {
-       drm_device_dma_t *dma = dev->dma;
+       struct drm_device_dma *dma = dev->dma;
        int i, j;
 
        if (!dma)
  */
 void drm_core_reclaim_buffers(struct drm_device *dev, struct file *filp)
 {
-       drm_device_dma_t *dma = dev->dma;
+       struct drm_device_dma *dma = dev->dma;
        int i;
 
        if (!dma)
 
        struct drm_device *dev = (struct drm_device *) data;
        int len = 0;
        int i;
-       drm_queue_t *q;
+       struct drm_queue *q;
 
        if (offset > DRM_PROC_LIMIT) {
                *eof = 1;
 {
        struct drm_device *dev = (struct drm_device *) data;
        int len = 0;
-       drm_device_dma_t *dma = dev->dma;
+       struct drm_device_dma *dma = dev->dma;
        int i;
 
        if (!dma || offset > DRM_PROC_LIMIT) {
 
 {
        struct drm_file *priv = vma->vm_file->private_data;
        struct drm_device *dev = priv->head->dev;
-       drm_device_dma_t *dma = dev->dma;
+       struct drm_device_dma *dma = dev->dma;
        unsigned long offset;
        unsigned long page_nr;
        struct page *page;
 {
        struct drm_file *priv = filp->private_data;
        struct drm_device *dev;
-       drm_device_dma_t *dma;
+       struct drm_device_dma *dma;
        unsigned long length = vma->vm_end - vma->vm_start;
 
        dev = priv->head->dev;
 
 
 static struct drm_buf *i810_freelist_get(struct drm_device * dev)
 {
-       drm_device_dma_t *dma = dev->dma;
+       struct drm_device_dma *dma = dev->dma;
        int i;
        int used;
 
 
 static int i810_dma_cleanup(struct drm_device * dev)
 {
-       drm_device_dma_t *dma = dev->dma;
+       struct drm_device_dma *dma = dev->dma;
 
        /* Make sure interrupts are disabled here because the uninstall ioctl
         * may not have been called from userspace and after dev_private
 
 static int i810_freelist_init(struct drm_device * dev, drm_i810_private_t * dev_priv)
 {
-       drm_device_dma_t *dma = dev->dma;
+       struct drm_device_dma *dma = dev->dma;
        int my_idx = 24;
        u32 *hw_status = (u32 *) (dev_priv->hw_status_page + my_idx);
        int i;
 static int i810_flush_queue(struct drm_device * dev)
 {
        drm_i810_private_t *dev_priv = dev->dev_private;
-       drm_device_dma_t *dma = dev->dma;
+       struct drm_device_dma *dma = dev->dma;
        int i, ret = 0;
        RING_LOCALS;
 
 /* Must be called with the lock held */
 static void i810_reclaim_buffers(struct drm_device * dev, struct file *filp)
 {
-       drm_device_dma_t *dma = dev->dma;
+       struct drm_device_dma *dma = dev->dma;
        int i;
 
        if (!dma)
 {
        struct drm_file *priv = filp->private_data;
        struct drm_device *dev = priv->head->dev;
-       drm_device_dma_t *dma = dev->dma;
+       struct drm_device_dma *dma = dev->dma;
        drm_i810_private_t *dev_priv = (drm_i810_private_t *) dev->dev_private;
        u32 *hw_status = dev_priv->hw_status_page;
        drm_i810_sarea_t *sarea_priv = (drm_i810_sarea_t *)
 {
        struct drm_file *priv = filp->private_data;
        struct drm_device *dev = priv->head->dev;
-       drm_device_dma_t *dma = dev->dma;
+       struct drm_device_dma *dma = dev->dma;
        drm_i810_private_t *dev_priv = (drm_i810_private_t *) dev->dev_private;
        u32 *hw_status = dev_priv->hw_status_page;
        drm_i810_sarea_t *sarea_priv = (drm_i810_sarea_t *)
 
 
 static struct drm_buf *i830_freelist_get(struct drm_device * dev)
 {
-       drm_device_dma_t *dma = dev->dma;
+       struct drm_device_dma *dma = dev->dma;
        int i;
        int used;
 
 
 static int i830_dma_cleanup(struct drm_device * dev)
 {
-       drm_device_dma_t *dma = dev->dma;
+       struct drm_device_dma *dma = dev->dma;
 
        /* Make sure interrupts are disabled here because the uninstall ioctl
         * may not have been called from userspace and after dev_private
 
 static int i830_freelist_init(struct drm_device * dev, drm_i830_private_t * dev_priv)
 {
-       drm_device_dma_t *dma = dev->dma;
+       struct drm_device_dma *dma = dev->dma;
        int my_idx = 36;
        u32 *hw_status = (u32 *) (dev_priv->hw_status_page + my_idx);
        int i;
 static int i830_flush_queue(struct drm_device * dev)
 {
        drm_i830_private_t *dev_priv = dev->dev_private;
-       drm_device_dma_t *dma = dev->dma;
+       struct drm_device_dma *dma = dev->dma;
        int i, ret = 0;
        RING_LOCALS;
 
 /* Must be called with the lock held */
 static void i830_reclaim_buffers(struct drm_device * dev, struct file *filp)
 {
-       drm_device_dma_t *dma = dev->dma;
+       struct drm_device_dma *dma = dev->dma;
        int i;
 
        if (!dma)
 {
        struct drm_file *priv = filp->private_data;
        struct drm_device *dev = priv->head->dev;
-       drm_device_dma_t *dma = dev->dma;
+       struct drm_device_dma *dma = dev->dma;
        drm_i830_private_t *dev_priv = (drm_i830_private_t *) dev->dev_private;
        u32 *hw_status = dev_priv->hw_status_page;
        drm_i830_sarea_t *sarea_priv = (drm_i830_sarea_t *)
 
 
 static int mga_freelist_init(struct drm_device * dev, drm_mga_private_t * dev_priv)
 {
-       drm_device_dma_t *dma = dev->dma;
+       struct drm_device_dma *dma = dev->dma;
        struct drm_buf *buf;
        drm_mga_buf_priv_t *buf_priv;
        drm_mga_freelist_t *entry;
  */
 static void mga_freelist_reset(struct drm_device * dev)
 {
-       drm_device_dma_t *dma = dev->dma;
+       struct drm_device_dma *dma = dev->dma;
        struct drm_buf *buf;
        drm_mga_buf_priv_t *buf_priv;
        int i;
 int mga_dma_buffers(DRM_IOCTL_ARGS)
 {
        DRM_DEVICE;
-       drm_device_dma_t *dma = dev->dma;
+       struct drm_device_dma *dma = dev->dma;
        drm_mga_private_t *dev_priv = (drm_mga_private_t *) dev->dev_private;
        struct drm_dma __user *argp = (void __user *)data;
        struct drm_dma d;
 
 {
        DRM_DEVICE;
        drm_mga_private_t *dev_priv = dev->dev_private;
-       drm_device_dma_t *dma = dev->dma;
+       struct drm_device_dma *dma = dev->dma;
        struct drm_buf *buf;
        drm_mga_buf_priv_t *buf_priv;
        drm_mga_vertex_t vertex;
 {
        DRM_DEVICE;
        drm_mga_private_t *dev_priv = dev->dev_private;
-       drm_device_dma_t *dma = dev->dma;
+       struct drm_device_dma *dma = dev->dma;
        struct drm_buf *buf;
        drm_mga_buf_priv_t *buf_priv;
        drm_mga_indices_t indices;
 static int mga_dma_iload(DRM_IOCTL_ARGS)
 {
        DRM_DEVICE;
-       drm_device_dma_t *dma = dev->dma;
+       struct drm_device_dma *dma = dev->dma;
        drm_mga_private_t *dev_priv = dev->dev_private;
        struct drm_buf *buf;
        drm_mga_buf_priv_t *buf_priv;
 
 #if 0
 static int r128_freelist_init(struct drm_device * dev)
 {
-       drm_device_dma_t *dma = dev->dma;
+       struct drm_device_dma *dma = dev->dma;
        drm_r128_private_t *dev_priv = dev->dev_private;
        struct drm_buf *buf;
        drm_r128_buf_priv_t *buf_priv;
 
 static struct drm_buf *r128_freelist_get(struct drm_device * dev)
 {
-       drm_device_dma_t *dma = dev->dma;
+       struct drm_device_dma *dma = dev->dma;
        drm_r128_private_t *dev_priv = dev->dev_private;
        drm_r128_buf_priv_t *buf_priv;
        struct drm_buf *buf;
 
 void r128_freelist_reset(struct drm_device * dev)
 {
-       drm_device_dma_t *dma = dev->dma;
+       struct drm_device_dma *dma = dev->dma;
        int i;
 
        for (i = 0; i < dma->buf_count; i++) {
 int r128_cce_buffers(DRM_IOCTL_ARGS)
 {
        DRM_DEVICE;
-       drm_device_dma_t *dma = dev->dma;
+       struct drm_device_dma *dma = dev->dma;
        int ret = 0;
        struct drm_dma __user *argp = (void __user *)data;
        struct drm_dma d;
 
                                  struct drm_device * dev, drm_r128_blit_t * blit)
 {
        drm_r128_private_t *dev_priv = dev->dev_private;
-       drm_device_dma_t *dma = dev->dma;
+       struct drm_device_dma *dma = dev->dma;
        struct drm_buf *buf;
        drm_r128_buf_priv_t *buf_priv;
        u32 *data;
 {
        DRM_DEVICE;
        drm_r128_private_t *dev_priv = dev->dev_private;
-       drm_device_dma_t *dma = dev->dma;
+       struct drm_device_dma *dma = dev->dma;
        struct drm_buf *buf;
        drm_r128_buf_priv_t *buf_priv;
        drm_r128_vertex_t vertex;
 {
        DRM_DEVICE;
        drm_r128_private_t *dev_priv = dev->dev_private;
-       drm_device_dma_t *dma = dev->dma;
+       struct drm_device_dma *dma = dev->dma;
        struct drm_buf *buf;
        drm_r128_buf_priv_t *buf_priv;
        drm_r128_indices_t elts;
 static int r128_cce_blit(DRM_IOCTL_ARGS)
 {
        DRM_DEVICE;
-       drm_device_dma_t *dma = dev->dma;
+       struct drm_device_dma *dma = dev->dma;
        drm_r128_private_t *dev_priv = dev->dev_private;
        drm_r128_blit_t blit;
        int ret;
 {
        DRM_DEVICE;
        drm_r128_private_t *dev_priv = dev->dev_private;
-       drm_device_dma_t *dma = dev->dma;
+       struct drm_device_dma *dma = dev->dma;
        struct drm_buf *buf;
        drm_r128_buf_priv_t *buf_priv;
        drm_r128_indirect_t indirect;
 
                      drm_radeon_kcmd_buffer_t *cmdbuf)
 {
        drm_radeon_private_t *dev_priv = dev->dev_private;
-       drm_device_dma_t *dma = dev->dma;
+       struct drm_device_dma *dma = dev->dma;
        struct drm_buf *buf = NULL;
        int emit_dispatch_age = 0;
        int ret = 0;
 
 
 struct drm_buf *radeon_freelist_get(struct drm_device * dev)
 {
-       drm_device_dma_t *dma = dev->dma;
+       struct drm_device_dma *dma = dev->dma;
        drm_radeon_private_t *dev_priv = dev->dev_private;
        drm_radeon_buf_priv_t *buf_priv;
        struct drm_buf *buf;
 #if 0
 struct drm_buf *radeon_freelist_get(struct drm_device * dev)
 {
-       drm_device_dma_t *dma = dev->dma;
+       struct drm_device_dma *dma = dev->dma;
        drm_radeon_private_t *dev_priv = dev->dev_private;
        drm_radeon_buf_priv_t *buf_priv;
        struct drm_buf *buf;
 
 void radeon_freelist_reset(struct drm_device * dev)
 {
-       drm_device_dma_t *dma = dev->dma;
+       struct drm_device_dma *dma = dev->dma;
        drm_radeon_private_t *dev_priv = dev->dev_private;
        int i;
 
 int radeon_cp_buffers(DRM_IOCTL_ARGS)
 {
        DRM_DEVICE;
-       drm_device_dma_t *dma = dev->dma;
+       struct drm_device_dma *dma = dev->dma;
        int ret = 0;
        struct drm_dma __user *argp = (void __user *)data;
        struct drm_dma d;
 
        drm_radeon_private_t *dev_priv = dev->dev_private;
        struct drm_file *filp_priv;
        drm_radeon_sarea_t *sarea_priv = dev_priv->sarea_priv;
-       drm_device_dma_t *dma = dev->dma;
+       struct drm_device_dma *dma = dev->dma;
        struct drm_buf *buf;
        drm_radeon_vertex_t vertex;
        drm_radeon_tcl_prim_t prim;
        drm_radeon_private_t *dev_priv = dev->dev_private;
        struct drm_file *filp_priv;
        drm_radeon_sarea_t *sarea_priv = dev_priv->sarea_priv;
-       drm_device_dma_t *dma = dev->dma;
+       struct drm_device_dma *dma = dev->dma;
        struct drm_buf *buf;
        drm_radeon_indices_t elts;
        drm_radeon_tcl_prim_t prim;
 {
        DRM_DEVICE;
        drm_radeon_private_t *dev_priv = dev->dev_private;
-       drm_device_dma_t *dma = dev->dma;
+       struct drm_device_dma *dma = dev->dma;
        struct drm_buf *buf;
        drm_radeon_indirect_t indirect;
        RING_LOCALS;
        drm_radeon_private_t *dev_priv = dev->dev_private;
        struct drm_file *filp_priv;
        drm_radeon_sarea_t *sarea_priv = dev_priv->sarea_priv;
-       drm_device_dma_t *dma = dev->dma;
+       struct drm_device_dma *dma = dev->dma;
        struct drm_buf *buf;
        drm_radeon_vertex2_t vertex;
        int i;
        DRM_DEVICE;
        drm_radeon_private_t *dev_priv = dev->dev_private;
        struct drm_file *filp_priv;
-       drm_device_dma_t *dma = dev->dma;
+       struct drm_device_dma *dma = dev->dma;
        struct drm_buf *buf = NULL;
        int idx;
        drm_radeon_kcmd_buffer_t cmdbuf;
 
 static int savage_freelist_init(struct drm_device * dev)
 {
        drm_savage_private_t *dev_priv = dev->dev_private;
-       drm_device_dma_t *dma = dev->dma;
+       struct drm_device_dma *dma = dev->dma;
        struct drm_buf *buf;
        drm_savage_buf_priv_t *entry;
        int i;
 int savage_bci_buffers(DRM_IOCTL_ARGS)
 {
        DRM_DEVICE;
-       drm_device_dma_t *dma = dev->dma;
+       struct drm_device_dma *dma = dev->dma;
        struct drm_dma d;
        int ret = 0;
 
 
 void savage_reclaim_buffers(struct drm_device *dev, DRMFILE filp)
 {
-       drm_device_dma_t *dma = dev->dma;
+       struct drm_device_dma *dma = dev->dma;
        drm_savage_private_t *dev_priv = dev->dev_private;
        int i;
 
 
 {
        DRM_DEVICE;
        drm_savage_private_t *dev_priv = dev->dev_private;
-       drm_device_dma_t *dma = dev->dma;
+       struct drm_device_dma *dma = dev->dma;
        struct drm_buf *dmabuf;
        drm_savage_cmdbuf_t cmdbuf;
        drm_savage_cmd_header_t *kcmd_addr = NULL;