Merge branch 'drm-patches' of ssh://master.kernel.org/pub/scm/linux/kernel/git/airlied/drm-2.6

* 'drm-patches' of ssh://master.kernel.org/pub/scm/linux/kernel/git/airlied/drm-2.6:
  drm: remove core typedefs from the ioc32 wrappers
  drm: remove sarea typedefs
  drm: detypedef the hashtab and more of sman
  drm: de-typedef sman
  drm: detypedeffing continues...
  drm: detypef waitlist/freelist/buf_entry/device_dma/drm_queue structs
  drm: drop drm_vma_entry_t, drm_magic_entry_t
  drm: drop drm_buf_t typedef
  drm: fixup other drivers for typedef removals
  drm: remove drm_file_t, drm_device_t and drm_head_t typedefs
  drm: remove a bunch of typedefs on the userspace interface
  r300: updates register header
  radeon: add support for vblank on crtc2
  drm: cleanup list initialisation
  drm: fix typo on code drm getsarea
  drm: remove DRM_GETSAREA and replace with drm_getsarea function
  drm: cleanup use of Linux list handling macros

77 files changed, 2485 insertions, 2214 deletions

diff --git a/drivers/char/drm/ati_pcigart.c b/drivers/char/drm/ati_pcigart.c
index 5b91bc04ea4e..3345641ff904 100644
--- a/drivers/char/drm/ati_pcigart.c
+++ b/drivers/char/drm/ati_pcigart.c
@@ -73,9 +73,9 @@ static void drm_ati_free_pcigart_table(void *address, int order)
         free_pages((unsigned long)address, order);
 }
 
-int drm_ati_pcigart_cleanup(drm_device_t *dev, drm_ati_pcigart_info *gart_info)
+int drm_ati_pcigart_cleanup(struct drm_device *dev, struct drm_ati_pcigart_info *gart_info)
 {
-        drm_sg_mem_t *entry = dev->sg;
+        struct drm_sg_mem *entry = dev->sg;
         unsigned long pages;
         int i;
         int order;
@@ -122,9 +122,9 @@ int drm_ati_pcigart_cleanup(drm_device_t *dev, drm_ati_pcigart_info *gart_info)
 }
 EXPORT_SYMBOL(drm_ati_pcigart_cleanup);
 
-int drm_ati_pcigart_init(drm_device_t *dev, drm_ati_pcigart_info *gart_info)
+int drm_ati_pcigart_init(struct drm_device *dev, struct drm_ati_pcigart_info *gart_info)
 {
-        drm_sg_mem_t *entry = dev->sg;
+        struct drm_sg_mem *entry = dev->sg;
         void *address = NULL;
         unsigned long pages;
         u32 *pci_gart, page_base, bus_address = 0;
diff --git a/drivers/char/drm/drm.h b/drivers/char/drm/drm.h
index 089198491f16..2d6f2d0bd02b 100644
--- a/drivers/char/drm/drm.h
+++ b/drivers/char/drm/drm.h
@@ -109,31 +109,31 @@ typedef unsigned int drm_magic_t;
  * \note KW: Actually it's illegal to change either for
  * backwards-compatibility reasons.
  */
-typedef struct drm_clip_rect {
+struct drm_clip_rect {
         unsigned short x1;
         unsigned short y1;
         unsigned short x2;
         unsigned short y2;
-} drm_clip_rect_t;
+};
 
 /**
  * Drawable information.
  */
-typedef struct drm_drawable_info {
+struct drm_drawable_info {
         unsigned int num_rects;
-        drm_clip_rect_t *rects;
-} drm_drawable_info_t;
+        struct drm_clip_rect *rects;
+};
 
 /**
  * Texture region,
  */
-typedef struct drm_tex_region {
+struct drm_tex_region {
         unsigned char next;
         unsigned char prev;
         unsigned char in_use;
         unsigned char padding;
         unsigned int age;
-} drm_tex_region_t;
+};
 
 /**
  * Hardware lock.
@@ -142,17 +142,17 @@ typedef struct drm_tex_region {
  * processor bus contention on a multiprocessor system, there should not be any
  * other data stored in the same cache line.
  */
-typedef struct drm_hw_lock {
+struct drm_hw_lock {
         __volatile__ unsigned int lock;         /**< lock variable */
         char padding[60];                       /**< Pad to cache line */
-} drm_hw_lock_t;
+};
 
 /**
  * DRM_IOCTL_VERSION ioctl argument type.
  *
  * \sa drmGetVersion().
  */
-typedef struct drm_version {
+struct drm_version {
         int version_major;        /**< Major version */
         int version_minor;        /**< Minor version */
         int version_patchlevel;   /**< Patch level */
@@ -162,33 +162,33 @@ typedef struct drm_version {
         char __user *date;        /**< User-space buffer to hold date */
         size_t desc_len;          /**< Length of desc buffer */
         char __user *desc;        /**< User-space buffer to hold desc */
-} drm_version_t;
+};
 
 /**
  * DRM_IOCTL_GET_UNIQUE ioctl argument type.
  *
  * \sa drmGetBusid() and drmSetBusId().
  */
-typedef struct drm_unique {
+struct drm_unique {
         size_t unique_len;        /**< Length of unique */
         char __user *unique;      /**< Unique name for driver instantiation */
-} drm_unique_t;
+};
 
-typedef struct drm_list {
+struct drm_list {
         int count;                /**< Length of user-space structures */
-        drm_version_t __user *version;
-} drm_list_t;
+        struct drm_version __user *version;
+};
 
-typedef struct drm_block {
+struct drm_block {
         int unused;
-} drm_block_t;
+};
 
 /**
  * DRM_IOCTL_CONTROL ioctl argument type.
  *
  * \sa drmCtlInstHandler() and drmCtlUninstHandler().
  */
-typedef struct drm_control {
+struct drm_control {
         enum {
                 DRM_ADD_COMMAND,
                 DRM_RM_COMMAND,
@@ -196,24 +196,24 @@ typedef struct drm_control {
                 DRM_UNINST_HANDLER
         } func;
         int irq;
-} drm_control_t;
+};
 
 /**
  * Type of memory to map.
  */
-typedef enum drm_map_type {
+enum drm_map_type {
         _DRM_FRAME_BUFFER = 0,    /**< WC (no caching), no core dump */
         _DRM_REGISTERS = 1,       /**< no caching, no core dump */
         _DRM_SHM = 2,             /**< shared, cached */
         _DRM_AGP = 3,             /**< AGP/GART */
         _DRM_SCATTER_GATHER = 4,  /**< Scatter/gather memory for PCI DMA */
         _DRM_CONSISTENT = 5,      /**< Consistent memory for PCI DMA */
-} drm_map_type_t;
+};
 
 /**
  * Memory mapping flags.
  */
-typedef enum drm_map_flags {
+enum drm_map_flags {
         _DRM_RESTRICTED = 0x01,      /**< Cannot be mapped to user-virtual */
         _DRM_READ_ONLY = 0x02,
         _DRM_LOCKED = 0x04,          /**< shared, cached, locked */
@@ -221,12 +221,12 @@ typedef enum drm_map_flags {
         _DRM_WRITE_COMBINING = 0x10, /**< use write-combining if available */
         _DRM_CONTAINS_LOCK = 0x20,   /**< SHM page that contains lock */
         _DRM_REMOVABLE = 0x40        /**< Removable mapping */
-} drm_map_flags_t;
+};
 
-typedef struct drm_ctx_priv_map {
+struct drm_ctx_priv_map {
         unsigned int ctx_id;     /**< Context requesting private mapping */
         void *handle;            /**< Handle of map */
-} drm_ctx_priv_map_t;
+};
 
 /**
  * DRM_IOCTL_GET_MAP, DRM_IOCTL_ADD_MAP and DRM_IOCTL_RM_MAP ioctls
@@ -234,30 +234,30 @@ typedef struct drm_ctx_priv_map {
  *
  * \sa drmAddMap().
  */
-typedef struct drm_map {
+struct drm_map {
         unsigned long offset;    /**< Requested physical address (0 for SAREA)*/
         unsigned long size;      /**< Requested physical size (bytes) */
-        drm_map_type_t type;     /**< Type of memory to map */
-        drm_map_flags_t flags;   /**< Flags */
+        enum drm_map_type type;  /**< Type of memory to map */
+        enum drm_map_flags flags;        /**< Flags */
         void *handle;            /**< User-space: "Handle" to pass to mmap() */
                                  /**< Kernel-space: kernel-virtual address */
         int mtrr;                /**< MTRR slot used */
         /*   Private data */
-} drm_map_t;
+};
 
 /**
  * DRM_IOCTL_GET_CLIENT ioctl argument type.
  */
-typedef struct drm_client {
+struct drm_client {
         int idx;                /**< Which client desired? */
         int auth;               /**< Is client authenticated? */
         unsigned long pid;      /**< Process ID */
         unsigned long uid;      /**< User ID */
         unsigned long magic;    /**< Magic */
         unsigned long iocs;     /**< Ioctl count */
-} drm_client_t;
+};
 
-typedef enum {
+enum drm_stat_type {
         _DRM_STAT_LOCK,
         _DRM_STAT_OPENS,
         _DRM_STAT_CLOSES,
@@ -275,23 +275,23 @@ typedef enum {
         _DRM_STAT_SPECIAL,      /**< Special DMA (e.g., priority or polled) */
         _DRM_STAT_MISSED        /**< Missed DMA opportunity */
             /* Add to the *END* of the list */
-} drm_stat_type_t;
+};
 
 /**
  * DRM_IOCTL_GET_STATS ioctl argument type.
  */
-typedef struct drm_stats {
+struct drm_stats {
         unsigned long count;
         struct {
                 unsigned long value;
-                drm_stat_type_t type;
+                enum drm_stat_type type;
         } data[15];
-} drm_stats_t;
+};
 
 /**
  * Hardware locking flags.
  */
-typedef enum drm_lock_flags {
+enum drm_lock_flags {
         _DRM_LOCK_READY = 0x01,      /**< Wait until hardware is ready for DMA */
         _DRM_LOCK_QUIESCENT = 0x02,  /**< Wait until hardware quiescent */
         _DRM_LOCK_FLUSH = 0x04,      /**< Flush this context's DMA queue first */
@@ -301,17 +301,17 @@ typedef enum drm_lock_flags {
            full-screen DGA-like mode. */
         _DRM_HALT_ALL_QUEUES = 0x10, /**< Halt all current and future queues */
         _DRM_HALT_CUR_QUEUES = 0x20  /**< Halt all current queues */
-} drm_lock_flags_t;
+};
 
 /**
  * DRM_IOCTL_LOCK, DRM_IOCTL_UNLOCK and DRM_IOCTL_FINISH ioctl argument type.
  *
  * \sa drmGetLock() and drmUnlock().
  */
-typedef struct drm_lock {
+struct drm_lock {
         int context;
-        drm_lock_flags_t flags;
-} drm_lock_t;
+        enum drm_lock_flags flags;
+};
 
 /**
  * DMA flags
@@ -321,7 +321,7 @@ typedef struct drm_lock {
  *
  * \sa drm_dma.
  */
-typedef enum drm_dma_flags {
+enum drm_dma_flags {
         /* Flags for DMA buffer dispatch */
         _DRM_DMA_BLOCK = 0x01,        /**<
                                        * Block until buffer dispatched.
@@ -340,14 +340,14 @@ typedef enum drm_dma_flags {
         _DRM_DMA_WAIT = 0x10,         /**< Wait for free buffers */
         _DRM_DMA_SMALLER_OK = 0x20,   /**< Smaller-than-requested buffers OK */
         _DRM_DMA_LARGER_OK = 0x40     /**< Larger-than-requested buffers OK */
-} drm_dma_flags_t;
+};
 
 /**
  * DRM_IOCTL_ADD_BUFS and DRM_IOCTL_MARK_BUFS ioctl argument type.
  *
  * \sa drmAddBufs().
  */
-typedef struct drm_buf_desc {
+struct drm_buf_desc {
         int count;               /**< Number of buffers of this size */
         int size;                /**< Size in bytes */
         int low_mark;            /**< Low water mark */
@@ -363,44 +363,44 @@ typedef struct drm_buf_desc {
                                   * Start address of where the AGP buffers are
                                   * in the AGP aperture
                                   */
-} drm_buf_desc_t;
+};
 
 /**
  * DRM_IOCTL_INFO_BUFS ioctl argument type.
  */
-typedef struct drm_buf_info {
+struct drm_buf_info {
         int count;              /**< Entries in list */
-        drm_buf_desc_t __user *list;
-} drm_buf_info_t;
+        struct drm_buf_desc __user *list;
+};
 
 /**
  * DRM_IOCTL_FREE_BUFS ioctl argument type.
  */
-typedef struct drm_buf_free {
+struct drm_buf_free {
         int count;
         int __user *list;
-} drm_buf_free_t;
+};
 
 /**
  * Buffer information
  *
  * \sa drm_buf_map.
  */
-typedef struct drm_buf_pub {
+struct drm_buf_pub {
         int idx;                       /**< Index into the master buffer list */
         int total;                     /**< Buffer size */
         int used;                      /**< Amount of buffer in use (for DMA) */
         void __user *address;          /**< Address of buffer */
-} drm_buf_pub_t;
+};
 
 /**
  * DRM_IOCTL_MAP_BUFS ioctl argument type.
  */
-typedef struct drm_buf_map {
+struct drm_buf_map {
         int count;              /**< Length of the buffer list */
         void __user *virtual;           /**< Mmap'd area in user-virtual */
-        drm_buf_pub_t __user *list;     /**< Buffer information */
-} drm_buf_map_t;
+        struct drm_buf_pub __user *list;        /**< Buffer information */
+};
 
 /**
  * DRM_IOCTL_DMA ioctl argument type.
@@ -409,48 +409,48 @@ typedef struct drm_buf_map {
  *
  * \sa drmDMA().
  */
-typedef struct drm_dma {
+struct drm_dma {
         int context;                      /**< Context handle */
         int send_count;                   /**< Number of buffers to send */
         int __user *send_indices;         /**< List of handles to buffers */
         int __user *send_sizes;           /**< Lengths of data to send */
-        drm_dma_flags_t flags;            /**< Flags */
+        enum drm_dma_flags flags;         /**< Flags */
         int request_count;                /**< Number of buffers requested */
         int request_size;                 /**< Desired size for buffers */
         int __user *request_indices;      /**< Buffer information */
         int __user *request_sizes;
         int granted_count;                /**< Number of buffers granted */
-} drm_dma_t;
+};
 
-typedef enum {
+enum drm_ctx_flags {
         _DRM_CONTEXT_PRESERVED = 0x01,
         _DRM_CONTEXT_2DONLY = 0x02
-} drm_ctx_flags_t;
+};
 
 /**
  * DRM_IOCTL_ADD_CTX ioctl argument type.
  *
  * \sa drmCreateContext() and drmDestroyContext().
  */
-typedef struct drm_ctx {
+struct drm_ctx {
         drm_context_t handle;
-        drm_ctx_flags_t flags;
-} drm_ctx_t;
+        enum drm_ctx_flags flags;
+};
 
 /**
  * DRM_IOCTL_RES_CTX ioctl argument type.
  */
-typedef struct drm_ctx_res {
+struct drm_ctx_res {
         int count;
-        drm_ctx_t __user *contexts;
-} drm_ctx_res_t;
+        struct drm_ctx __user *contexts;
+};
 
 /**
  * DRM_IOCTL_ADD_DRAW and DRM_IOCTL_RM_DRAW ioctl argument type.
  */
-typedef struct drm_draw {
+struct drm_draw {
         drm_drawable_t handle;
-} drm_draw_t;
+};
 
 /**
  * DRM_IOCTL_UPDATE_DRAW ioctl argument type.
@@ -459,52 +459,52 @@ typedef enum {
         DRM_DRAWABLE_CLIPRECTS,
 } drm_drawable_info_type_t;
 
-typedef struct drm_update_draw {
+struct drm_update_draw {
         drm_drawable_t handle;
         unsigned int type;
         unsigned int num;
         unsigned long long data;
-} drm_update_draw_t;
+};
 
 /**
  * DRM_IOCTL_GET_MAGIC and DRM_IOCTL_AUTH_MAGIC ioctl argument type.
  */
-typedef struct drm_auth {
+struct drm_auth {
         drm_magic_t magic;
-} drm_auth_t;
+};
 
 /**
  * DRM_IOCTL_IRQ_BUSID ioctl argument type.
  *
  * \sa drmGetInterruptFromBusID().
  */
-typedef struct drm_irq_busid {
+struct drm_irq_busid {
         int irq;        /**< IRQ number */
         int busnum;     /**< bus number */
         int devnum;     /**< device number */
         int funcnum;    /**< function number */
-} drm_irq_busid_t;
+};
 
-typedef enum {
+enum drm_vblank_seq_type {
         _DRM_VBLANK_ABSOLUTE = 0x0,     /**< Wait for specific vblank sequence number */
         _DRM_VBLANK_RELATIVE = 0x1,     /**< Wait for given number of vblanks */
         _DRM_VBLANK_NEXTONMISS = 0x10000000,    /**< If missed, wait for next vblank */
         _DRM_VBLANK_SECONDARY = 0x20000000,     /**< Secondary display controller */
         _DRM_VBLANK_SIGNAL = 0x40000000 /**< Send signal instead of blocking */
-} drm_vblank_seq_type_t;
+};
 
 #define _DRM_VBLANK_TYPES_MASK (_DRM_VBLANK_ABSOLUTE | _DRM_VBLANK_RELATIVE)
 #define _DRM_VBLANK_FLAGS_MASK (_DRM_VBLANK_SIGNAL | _DRM_VBLANK_SECONDARY | \
                                 _DRM_VBLANK_NEXTONMISS)
 
 struct drm_wait_vblank_request {
-        drm_vblank_seq_type_t type;
+        enum drm_vblank_seq_type type;
         unsigned int sequence;
         unsigned long signal;
 };
 
 struct drm_wait_vblank_reply {
-        drm_vblank_seq_type_t type;
+        enum drm_vblank_seq_type type;
         unsigned int sequence;
         long tval_sec;
         long tval_usec;
@@ -515,41 +515,41 @@ struct drm_wait_vblank_reply {
  *
  * \sa drmWaitVBlank().
  */
-typedef union drm_wait_vblank {
+union drm_wait_vblank {
         struct drm_wait_vblank_request request;
         struct drm_wait_vblank_reply reply;
-} drm_wait_vblank_t;
+};
 
 /**
  * DRM_IOCTL_AGP_ENABLE ioctl argument type.
  *
  * \sa drmAgpEnable().
  */
-typedef struct drm_agp_mode {
+struct drm_agp_mode {
         unsigned long mode;     /**< AGP mode */
-} drm_agp_mode_t;
+};
 
 /**
  * DRM_IOCTL_AGP_ALLOC and DRM_IOCTL_AGP_FREE ioctls argument type.
  *
  * \sa drmAgpAlloc() and drmAgpFree().
  */
-typedef struct drm_agp_buffer {
+struct drm_agp_buffer {
         unsigned long size;     /**< In bytes -- will round to page boundary */
         unsigned long handle;   /**< Used for binding / unbinding */
         unsigned long type;     /**< Type of memory to allocate */
         unsigned long physical; /**< Physical used by i810 */
-} drm_agp_buffer_t;
+};
 
 /**
  * DRM_IOCTL_AGP_BIND and DRM_IOCTL_AGP_UNBIND ioctls argument type.
  *
  * \sa drmAgpBind() and drmAgpUnbind().
  */
-typedef struct drm_agp_binding {
+struct drm_agp_binding {
         unsigned long handle;   /**< From drm_agp_buffer */
         unsigned long offset;   /**< In bytes -- will round to page boundary */
-} drm_agp_binding_t;
+};
 
 /**
  * DRM_IOCTL_AGP_INFO ioctl argument type.
@@ -558,7 +558,7 @@ typedef struct drm_agp_binding {
  * drmAgpBase(), drmAgpSize(), drmAgpMemoryUsed(), drmAgpMemoryAvail(),
  * drmAgpVendorId() and drmAgpDeviceId().
  */
-typedef struct drm_agp_info {
+struct drm_agp_info {
         int agp_version_major;
         int agp_version_minor;
         unsigned long mode;
@@ -570,25 +570,25 @@ typedef struct drm_agp_info {
         /* PCI information */
         unsigned short id_vendor;
         unsigned short id_device;
-} drm_agp_info_t;
+};
 
 /**
  * DRM_IOCTL_SG_ALLOC ioctl argument type.
  */
-typedef struct drm_scatter_gather {
+struct drm_scatter_gather {
         unsigned long size;     /**< In bytes -- will round to page boundary */
         unsigned long handle;   /**< Used for mapping / unmapping */
-} drm_scatter_gather_t;
+};
 
 /**
  * DRM_IOCTL_SET_VERSION ioctl argument type.
  */
-typedef struct drm_set_version {
+struct drm_set_version {
         int drm_di_major;
         int drm_di_minor;
         int drm_dd_major;
         int drm_dd_minor;
-} drm_set_version_t;
+};
 
 #define DRM_IOCTL_BASE                  'd'
 #define DRM_IO(nr)                      _IO(DRM_IOCTL_BASE,nr)
@@ -596,61 +596,61 @@ typedef struct drm_set_version {
 #define DRM_IOW(nr,type)                _IOW(DRM_IOCTL_BASE,nr,type)
 #define DRM_IOWR(nr,type)               _IOWR(DRM_IOCTL_BASE,nr,type)
 
-#define DRM_IOCTL_VERSION               DRM_IOWR(0x00, drm_version_t)
-#define DRM_IOCTL_GET_UNIQUE            DRM_IOWR(0x01, drm_unique_t)
-#define DRM_IOCTL_GET_MAGIC             DRM_IOR( 0x02, drm_auth_t)
-#define DRM_IOCTL_IRQ_BUSID             DRM_IOWR(0x03, drm_irq_busid_t)
-#define DRM_IOCTL_GET_MAP               DRM_IOWR(0x04, drm_map_t)
-#define DRM_IOCTL_GET_CLIENT            DRM_IOWR(0x05, drm_client_t)
-#define DRM_IOCTL_GET_STATS             DRM_IOR( 0x06, drm_stats_t)
-#define DRM_IOCTL_SET_VERSION           DRM_IOWR(0x07, drm_set_version_t)
-
-#define DRM_IOCTL_SET_UNIQUE            DRM_IOW( 0x10, drm_unique_t)
-#define DRM_IOCTL_AUTH_MAGIC            DRM_IOW( 0x11, drm_auth_t)
-#define DRM_IOCTL_BLOCK                 DRM_IOWR(0x12, drm_block_t)
-#define DRM_IOCTL_UNBLOCK               DRM_IOWR(0x13, drm_block_t)
-#define DRM_IOCTL_CONTROL               DRM_IOW( 0x14, drm_control_t)
-#define DRM_IOCTL_ADD_MAP               DRM_IOWR(0x15, drm_map_t)
-#define DRM_IOCTL_ADD_BUFS              DRM_IOWR(0x16, drm_buf_desc_t)
-#define DRM_IOCTL_MARK_BUFS             DRM_IOW( 0x17, drm_buf_desc_t)
-#define DRM_IOCTL_INFO_BUFS             DRM_IOWR(0x18, drm_buf_info_t)
-#define DRM_IOCTL_MAP_BUFS              DRM_IOWR(0x19, drm_buf_map_t)
-#define DRM_IOCTL_FREE_BUFS             DRM_IOW( 0x1a, drm_buf_free_t)
-
-#define DRM_IOCTL_RM_MAP                DRM_IOW( 0x1b, drm_map_t)
-
-#define DRM_IOCTL_SET_SAREA_CTX         DRM_IOW( 0x1c, drm_ctx_priv_map_t)
-#define DRM_IOCTL_GET_SAREA_CTX         DRM_IOWR(0x1d, drm_ctx_priv_map_t)
-
-#define DRM_IOCTL_ADD_CTX               DRM_IOWR(0x20, drm_ctx_t)
-#define DRM_IOCTL_RM_CTX                DRM_IOWR(0x21, drm_ctx_t)
-#define DRM_IOCTL_MOD_CTX               DRM_IOW( 0x22, drm_ctx_t)
-#define DRM_IOCTL_GET_CTX               DRM_IOWR(0x23, drm_ctx_t)
-#define DRM_IOCTL_SWITCH_CTX            DRM_IOW( 0x24, drm_ctx_t)
-#define DRM_IOCTL_NEW_CTX               DRM_IOW( 0x25, drm_ctx_t)
-#define DRM_IOCTL_RES_CTX               DRM_IOWR(0x26, drm_ctx_res_t)
-#define DRM_IOCTL_ADD_DRAW              DRM_IOWR(0x27, drm_draw_t)
-#define DRM_IOCTL_RM_DRAW               DRM_IOWR(0x28, drm_draw_t)
-#define DRM_IOCTL_DMA                   DRM_IOWR(0x29, drm_dma_t)
-#define DRM_IOCTL_LOCK                  DRM_IOW( 0x2a, drm_lock_t)
-#define DRM_IOCTL_UNLOCK                DRM_IOW( 0x2b, drm_lock_t)
-#define DRM_IOCTL_FINISH                DRM_IOW( 0x2c, drm_lock_t)
+#define DRM_IOCTL_VERSION               DRM_IOWR(0x00, struct drm_version)
+#define DRM_IOCTL_GET_UNIQUE            DRM_IOWR(0x01, struct drm_unique)
+#define DRM_IOCTL_GET_MAGIC             DRM_IOR( 0x02, struct drm_auth)
+#define DRM_IOCTL_IRQ_BUSID             DRM_IOWR(0x03, struct drm_irq_busid)
+#define DRM_IOCTL_GET_MAP               DRM_IOWR(0x04, struct drm_map)
+#define DRM_IOCTL_GET_CLIENT            DRM_IOWR(0x05, struct drm_client)
+#define DRM_IOCTL_GET_STATS             DRM_IOR( 0x06, struct drm_stats)
+#define DRM_IOCTL_SET_VERSION           DRM_IOWR(0x07, struct drm_set_version)
+
+#define DRM_IOCTL_SET_UNIQUE            DRM_IOW( 0x10, struct drm_unique)
+#define DRM_IOCTL_AUTH_MAGIC            DRM_IOW( 0x11, struct drm_auth)
+#define DRM_IOCTL_BLOCK                 DRM_IOWR(0x12, struct drm_block)
+#define DRM_IOCTL_UNBLOCK               DRM_IOWR(0x13, struct drm_block)
+#define DRM_IOCTL_CONTROL               DRM_IOW( 0x14, struct drm_control)
+#define DRM_IOCTL_ADD_MAP               DRM_IOWR(0x15, struct drm_map)
+#define DRM_IOCTL_ADD_BUFS              DRM_IOWR(0x16, struct drm_buf_desc)
+#define DRM_IOCTL_MARK_BUFS             DRM_IOW( 0x17, struct drm_buf_desc)
+#define DRM_IOCTL_INFO_BUFS             DRM_IOWR(0x18, struct drm_buf_info)
+#define DRM_IOCTL_MAP_BUFS              DRM_IOWR(0x19, struct drm_buf_map)
+#define DRM_IOCTL_FREE_BUFS             DRM_IOW( 0x1a, struct drm_buf_free)
+
+#define DRM_IOCTL_RM_MAP                DRM_IOW( 0x1b, struct drm_map)
+
+#define DRM_IOCTL_SET_SAREA_CTX         DRM_IOW( 0x1c, struct drm_ctx_priv_map)
+#define DRM_IOCTL_GET_SAREA_CTX         DRM_IOWR(0x1d, struct drm_ctx_priv_map)
+
+#define DRM_IOCTL_ADD_CTX               DRM_IOWR(0x20, struct drm_ctx)
+#define DRM_IOCTL_RM_CTX                DRM_IOWR(0x21, struct drm_ctx)
+#define DRM_IOCTL_MOD_CTX               DRM_IOW( 0x22, struct drm_ctx)
+#define DRM_IOCTL_GET_CTX               DRM_IOWR(0x23, struct drm_ctx)
+#define DRM_IOCTL_SWITCH_CTX            DRM_IOW( 0x24, struct drm_ctx)
+#define DRM_IOCTL_NEW_CTX               DRM_IOW( 0x25, struct drm_ctx)
+#define DRM_IOCTL_RES_CTX               DRM_IOWR(0x26, struct drm_ctx_res)
+#define DRM_IOCTL_ADD_DRAW              DRM_IOWR(0x27, struct drm_draw)
+#define DRM_IOCTL_RM_DRAW               DRM_IOWR(0x28, struct drm_draw)
+#define DRM_IOCTL_DMA                   DRM_IOWR(0x29, struct drm_dma)
+#define DRM_IOCTL_LOCK                  DRM_IOW( 0x2a, struct drm_lock)
+#define DRM_IOCTL_UNLOCK                DRM_IOW( 0x2b, struct drm_lock)
+#define DRM_IOCTL_FINISH                DRM_IOW( 0x2c, struct drm_lock)
 
 #define DRM_IOCTL_AGP_ACQUIRE           DRM_IO(  0x30)
 #define DRM_IOCTL_AGP_RELEASE           DRM_IO(  0x31)
-#define DRM_IOCTL_AGP_ENABLE            DRM_IOW( 0x32, drm_agp_mode_t)
-#define DRM_IOCTL_AGP_INFO              DRM_IOR( 0x33, drm_agp_info_t)
-#define DRM_IOCTL_AGP_ALLOC             DRM_IOWR(0x34, drm_agp_buffer_t)
-#define DRM_IOCTL_AGP_FREE              DRM_IOW( 0x35, drm_agp_buffer_t)
-#define DRM_IOCTL_AGP_BIND              DRM_IOW( 0x36, drm_agp_binding_t)
-#define DRM_IOCTL_AGP_UNBIND            DRM_IOW( 0x37, drm_agp_binding_t)
+#define DRM_IOCTL_AGP_ENABLE            DRM_IOW( 0x32, struct drm_agp_mode)
+#define DRM_IOCTL_AGP_INFO              DRM_IOR( 0x33, struct drm_agp_info)
+#define DRM_IOCTL_AGP_ALLOC             DRM_IOWR(0x34, struct drm_agp_buffer)
+#define DRM_IOCTL_AGP_FREE              DRM_IOW( 0x35, struct drm_agp_buffer)
+#define DRM_IOCTL_AGP_BIND              DRM_IOW( 0x36, struct drm_agp_binding)
+#define DRM_IOCTL_AGP_UNBIND            DRM_IOW( 0x37, struct drm_agp_binding)
 
-#define DRM_IOCTL_SG_ALLOC              DRM_IOW( 0x38, drm_scatter_gather_t)
-#define DRM_IOCTL_SG_FREE               DRM_IOW( 0x39, drm_scatter_gather_t)
+#define DRM_IOCTL_SG_ALLOC              DRM_IOW( 0x38, struct drm_scatter_gather)
+#define DRM_IOCTL_SG_FREE               DRM_IOW( 0x39, struct drm_scatter_gather)
 
-#define DRM_IOCTL_WAIT_VBLANK           DRM_IOWR(0x3a, drm_wait_vblank_t)
+#define DRM_IOCTL_WAIT_VBLANK           DRM_IOWR(0x3a, union drm_wait_vblank)
 
-#define DRM_IOCTL_UPDATE_DRAW           DRM_IOW(0x3f, drm_update_draw_t)
+#define DRM_IOCTL_UPDATE_DRAW           DRM_IOW(0x3f, struct drm_update_draw)
 
 /**
  * Device specific ioctls should only be in their respective headers
@@ -663,4 +663,49 @@ typedef struct drm_set_version {
 #define DRM_COMMAND_BASE                0x40
 #define DRM_COMMAND_END                 0xA0
 
+/* typedef area */
+#ifndef __KERNEL__
+typedef struct drm_clip_rect drm_clip_rect_t;
+typedef struct drm_drawable_info drm_drawable_info_t;
+typedef struct drm_tex_region drm_tex_region_t;
+typedef struct drm_hw_lock drm_hw_lock_t;
+typedef struct drm_version drm_version_t;
+typedef struct drm_unique drm_unique_t;
+typedef struct drm_list drm_list_t;
+typedef struct drm_block drm_block_t;
+typedef struct drm_control drm_control_t;
+typedef enum drm_map_type drm_map_type_t;
+typedef enum drm_map_flags drm_map_flags_t;
+typedef struct drm_ctx_priv_map drm_ctx_priv_map_t;
+typedef struct drm_map drm_map_t;
+typedef struct drm_client drm_client_t;
+typedef enum drm_stat_type drm_stat_type_t;
+typedef struct drm_stats drm_stats_t;
+typedef enum drm_lock_flags drm_lock_flags_t;
+typedef struct drm_lock drm_lock_t;
+typedef enum drm_dma_flags drm_dma_flags_t;
+typedef struct drm_buf_desc drm_buf_desc_t;
+typedef struct drm_buf_info drm_buf_info_t;
+typedef struct drm_buf_free drm_buf_free_t;
+typedef struct drm_buf_pub drm_buf_pub_t;
+typedef struct drm_buf_map drm_buf_map_t;
+typedef struct drm_dma drm_dma_t;
+typedef union drm_wait_vblank drm_wait_vblank_t;
+typedef struct drm_agp_mode drm_agp_mode_t;
+typedef enum drm_ctx_flags drm_ctx_flags_t;
+typedef struct drm_ctx drm_ctx_t;
+typedef struct drm_ctx_res drm_ctx_res_t;
+typedef struct drm_draw drm_draw_t;
+typedef struct drm_update_draw drm_update_draw_t;
+typedef struct drm_auth drm_auth_t;
+typedef struct drm_irq_busid drm_irq_busid_t;
+typedef enum drm_vblank_seq_type drm_vblank_seq_type_t;
+
+typedef struct drm_agp_buffer drm_agp_buffer_t;
+typedef struct drm_agp_binding drm_agp_binding_t;
+typedef struct drm_agp_info drm_agp_info_t;
+typedef struct drm_scatter_gather drm_scatter_gather_t;
+typedef struct drm_set_version drm_set_version_t;
+#endif
+
 #endif
diff --git a/drivers/char/drm/drmP.h b/drivers/char/drm/drmP.h
index d494315752a2..1277693e9ca4 100644
--- a/drivers/char/drm/drmP.h
+++ b/drivers/char/drm/drmP.h
@@ -274,32 +274,23 @@ 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 {
-        drm_hash_item_t hash_item;
+struct drm_magic_entry {
         struct list_head head;
+        struct drm_hash_item hash_item;
         struct drm_file *priv;
         struct drm_magic_entry *next;
-} drm_magic_entry_t;
-
-typedef struct drm_magic_head {
-        struct drm_magic_entry *head;
-        struct drm_magic_entry *tail;
-} drm_magic_head_t;
+};
 
-typedef struct drm_vma_entry {
+struct drm_vma_entry {
+        struct list_head head;
         struct vm_area_struct *vma;
-        struct drm_vma_entry *next;
         pid_t pid;
-} drm_vma_entry_t;
+};
 
 /**
  * DMA buffer.
  */
-typedef struct drm_buf {
+struct drm_buf {
         int idx;                       /**< Index into master buflist */
         int total;                     /**< Buffer size */
         int order;                     /**< log-base-2(total) */
@@ -325,30 +316,30 @@ typedef struct drm_buf {
 
         int dev_priv_size;               /**< Size of buffer private storage */
         void *dev_private;               /**< Per-buffer private storage */
-} drm_buf_t;
+};
 
 /** bufs is one longer than it has to be */
-typedef struct drm_waitlist {
+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;
+};
 
-typedef struct drm_freelist {
+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 */
         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;
@@ -359,19 +350,19 @@ typedef struct drm_dma_handle {
 /**
  * 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 */
-        drm_buf_t *buflist;             /**< buffer list */
+        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 */
-typedef struct drm_file {
+struct drm_file {
         int authenticated;
         int master;
         int minor;
@@ -379,16 +370,15 @@ typedef struct drm_file {
         uid_t uid;
         drm_magic_t magic;
         unsigned long ioctl_count;
-        struct drm_file *next;
-        struct drm_file *prev;
+        struct list_head lhead;
         struct drm_head *head;
         int remove_auth_on_close;
         unsigned long lock_count;
         void *driver_priv;
-} drm_file_t;
+};
 
 /** 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 */
@@ -401,16 +391,16 @@ 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;
+};
 
 /**
  * Lock data.
  */
-typedef struct drm_lock_data {
-        drm_hw_lock_t *hw_lock;         /**< Hardware lock */
+struct drm_lock_data {
+        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 */
@@ -418,16 +408,16 @@ typedef struct drm_lock_data {
         uint32_t kernel_waiters;
         uint32_t user_waiters;
         int idle_has_lock;
-} drm_lock_data_t;
+};
 
 /**
  * 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 */
-        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 */
@@ -439,28 +429,27 @@ typedef struct drm_device_dma {
                 _DRM_DMA_USE_PCI_RO = 0x08
         } flags;
 
-} drm_device_dma_t;
+};
 
 /**
  * AGP memory entry.  Stored as a doubly linked list.
  */
-typedef struct drm_agp_mem {
+struct drm_agp_mem {
         unsigned long handle;           /**< handle */
         DRM_AGP_MEM *memory;
         unsigned long bound;            /**< address */
         int pages;
-        struct drm_agp_mem *prev;       /**< previous entry */
-        struct drm_agp_mem *next;       /**< next entry */
-} drm_agp_mem_t;
+        struct list_head head;
+};
 
 /**
  * AGP data.
  *
  * \sa drm_agp_init() and drm_device::agp.
  */
-typedef struct drm_agp_head {
+struct drm_agp_head {
         DRM_AGP_KERN agp_info;          /**< AGP device information */
-        drm_agp_mem_t *memory;          /**< memory entries */
+        struct list_head memory;
         unsigned long mode;             /**< AGP mode */
         struct agp_bridge_data *bridge;
         int enabled;                    /**< whether the AGP bus as been enabled */
@@ -469,51 +458,51 @@ typedef struct drm_agp_head {
         int agp_mtrr;
         int cant_use_aperture;
         unsigned long page_mask;
-} drm_agp_head_t;
+};
 
 /**
  * Scatter-gather memory.
  */
-typedef struct drm_sg_mem {
+struct drm_sg_mem {
         unsigned long handle;
         void *virtual;
         int pages;
         struct page **pagelist;
         dma_addr_t *busaddr;
-} drm_sg_mem_t;
+};
 
-typedef struct drm_sigdata {
+struct drm_sigdata {
         int context;
-        drm_hw_lock_t *lock;
-} drm_sigdata_t;
+        struct drm_hw_lock *lock;
+};
 
 /**
  * Mappings list
  */
-typedef struct drm_map_list {
+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 */
         unsigned int user_token;
-} drm_map_list_t;
+};
 
-typedef drm_map_t drm_local_map_t;
+typedef struct drm_map drm_local_map_t;
 
 /**
  * Context handle list
  */
-typedef struct drm_ctx_list {
+struct drm_ctx_list {
         struct list_head head;          /**< list head */
         drm_context_t handle;           /**< context handle */
-        drm_file_t *tag;                /**< associated fd private data */
-} drm_ctx_list_t;
+        struct drm_file *tag;           /**< associated fd private data */
+};
 
-typedef struct drm_vbl_sig {
+struct drm_vbl_sig {
         struct list_head head;
         unsigned int sequence;
         struct siginfo info;
         struct task_struct *task;
-} drm_vbl_sig_t;
+};
 
 /* location of GART table */
 #define DRM_ATI_GART_MAIN 1
@@ -523,19 +512,19 @@ typedef struct drm_vbl_sig {
 #define DRM_ATI_GART_PCIE 2
 #define DRM_ATI_GART_IGP 3
 
-typedef struct ati_pcigart_info {
+struct drm_ati_pcigart_info {
         int gart_table_location;
         int gart_reg_if;
         void *addr;
         dma_addr_t bus_addr;
         drm_local_map_t mapping;
         int table_size;
-} drm_ati_pcigart_info;
+};
 
 /*
  * Generic memory manager structs
  */
-typedef struct drm_mm_node {
+struct drm_mm_node {
         struct list_head fl_entry;
         struct list_head ml_entry;
         int free;
@@ -543,12 +532,12 @@ typedef struct drm_mm_node {
         unsigned long size;
         struct drm_mm *mm;
         void *private;
-} drm_mm_node_t;
+};
 
-typedef struct drm_mm {
+struct drm_mm {
         struct list_head fl_entry;
         struct list_head ml_entry;
-} drm_mm_t;
+};
 
 /**
  * DRM driver structure. This structure represent the common code for
@@ -560,21 +549,21 @@ struct drm_device;
 struct drm_driver {
         int (*load) (struct drm_device *, unsigned long flags);
         int (*firstopen) (struct drm_device *);
-        int (*open) (struct drm_device *, drm_file_t *);
+        int (*open) (struct drm_device *, struct drm_file *);
         void (*preclose) (struct drm_device *, struct file * filp);
-        void (*postclose) (struct drm_device *, drm_file_t *);
+        void (*postclose) (struct drm_device *, struct drm_file *);
         void (*lastclose) (struct drm_device *);
         int (*unload) (struct drm_device *);
         int (*dma_ioctl) (DRM_IOCTL_ARGS);
         void (*dma_ready) (struct drm_device *);
         int (*dma_quiescent) (struct drm_device *);
-        int (*context_ctor) (struct drm_device * dev, int context);
-        int (*context_dtor) (struct drm_device * dev, int context);
-        int (*kernel_context_switch) (struct drm_device * dev, int old,
+        int (*context_ctor) (struct drm_device *dev, int context);
+        int (*context_dtor) (struct drm_device *dev, int context);
+        int (*kernel_context_switch) (struct drm_device *dev, int old,
                                       int new);
-        void (*kernel_context_switch_unlock) (struct drm_device * dev);
-        int (*vblank_wait) (struct drm_device * dev, unsigned int *sequence);
-        int (*vblank_wait2) (struct drm_device * dev, unsigned int *sequence);
+        void (*kernel_context_switch_unlock) (struct drm_device *dev);
+        int (*vblank_wait) (struct drm_device *dev, unsigned int *sequence);
+        int (*vblank_wait2) (struct drm_device *dev, unsigned int *sequence);
         int (*dri_library_name) (struct drm_device *dev, char *buf);
 
         /**
@@ -588,22 +577,23 @@ struct drm_driver {
          * card is absolutely \b not AGP (return of 0), absolutely \b is AGP
          * (return of 1), or may or may not be AGP (return of 2).
          */
-        int (*device_is_agp) (struct drm_device * dev);
+        int (*device_is_agp) (struct drm_device *dev);
 
         /* these have to be filled in */
 
         irqreturn_t(*irq_handler) (DRM_IRQ_ARGS);
-        void (*irq_preinstall) (struct drm_device * dev);
-        void (*irq_postinstall) (struct drm_device * dev);
-        void (*irq_uninstall) (struct drm_device * dev);
-        void (*reclaim_buffers) (struct drm_device * dev, struct file * filp);
+        void (*irq_preinstall) (struct drm_device *dev);
+        void (*irq_postinstall) (struct drm_device *dev);
+        void (*irq_uninstall) (struct drm_device *dev);
+        void (*reclaim_buffers) (struct drm_device *dev, struct file * filp);
         void (*reclaim_buffers_locked) (struct drm_device *dev,
                                         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_reg_ofs) (struct drm_device * dev);
-        void (*set_version) (struct drm_device * dev, drm_set_version_t * sv);
+        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,
+                             struct drm_set_version *sv);
 
         int major;
         int minor;
@@ -625,19 +615,19 @@ struct drm_driver {
  * that may contain multiple heads. Embed one per head of these in the
  * private drm_device structure.
  */
-typedef struct drm_head {
+struct drm_head {
         int minor;                      /**< Minor device number */
         struct drm_device *dev;
         struct proc_dir_entry *dev_root;  /**< proc directory entry */
         dev_t device;                   /**< Device number for mknod */
         struct class_device *dev_class;
-} drm_head_t;
+};
 
 /**
  * DRM device structure. This structure represent a complete card that
  * may contain multiple heads.
  */
-typedef struct drm_device {
+struct drm_device {
         char *unique;                   /**< Unique identifier: e.g., busid */
         int unique_len;                 /**< Length of unique field */
         char *devname;                  /**< For /proc/interrupts */
@@ -663,35 +653,34 @@ 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 */
         /*@{ */
-        drm_file_t *file_first;         /**< file list head */
-        drm_file_t *file_last;          /**< file list tail */
-        drm_open_hash_t magiclist;      /**< magic hash table */
+        struct list_head filelist;
+        struct drm_open_hash magiclist; /**< magic hash table */
         struct list_head magicfree;
         /*@} */
 
         /** \name Memory management */
         /*@{ */
-        drm_map_list_t *maplist;        /**< Linked list of regions */
+        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 */
 
         /** \name Context handle management */
         /*@{ */
-        drm_ctx_list_t *ctxlist;        /**< Linked list of context handles */
+        struct list_head ctxlist;       /**< Linked list of context handles */
         int ctx_count;                  /**< Number of context handles */
         struct mutex ctxlist_mutex;     /**< For ctxlist */
 
-        drm_map_t **context_sareas;         /**< per-context SAREA's */
+        struct drm_map **context_sareas;            /**< per-context SAREA's */
         int max_context;
 
-        drm_vma_entry_t *vmalist;       /**< List of vmas (for debugging) */
-        drm_lock_data_t lock;           /**< Information on hardware lock */
+        struct list_head vmalist;       /**< List of vmas (for debugging) */
+        struct drm_lock_data lock;      /**< Information on hardware lock */
         /*@} */
 
         /** \name DMA queues (contexts) */
@@ -699,8 +688,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 */
@@ -725,8 +714,8 @@ typedef struct drm_device {
         atomic_t vbl_received;
         atomic_t vbl_received2;         /**< number of secondary VBLANK interrupts */
         spinlock_t vbl_lock;
-        drm_vbl_sig_t vbl_sigs;         /**< signal list to send on VBLANK */
-        drm_vbl_sig_t vbl_sigs2;        /**< signals to send on secondary VBLANK */
+        struct list_head vbl_sigs;              /**< signal list to send on VBLANK */
+        struct list_head vbl_sigs2;     /**< signals to send on secondary VBLANK */
         unsigned int vbl_pending;
         spinlock_t tasklet_lock;        /**< For drm_locked_tasklet */
         void (*locked_tasklet_func)(struct drm_device *dev);
@@ -739,7 +728,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 */
@@ -747,16 +736,16 @@ 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 */
         unsigned long *ctx_bitmap;      /**< context bitmap */
         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 */
 
         /** \name Drawable information */
         /*@{ */
@@ -764,9 +753,9 @@ typedef struct drm_device {
         unsigned int drw_bitfield_length;
         u32 *drw_bitfield;
         unsigned int drw_info_length;
-        drm_drawable_info_t **drw_info;
+        struct drm_drawable_info **drw_info;
         /*@} */
-} drm_device_t;
+};
 
 static __inline__ int drm_core_check_feature(struct drm_device *dev,
                                              int feature)
@@ -838,7 +827,7 @@ extern int drm_ioctl(struct inode *inode, struct file *filp,
                      unsigned int cmd, unsigned long arg);
 extern long drm_compat_ioctl(struct file *filp,
                              unsigned int cmd, unsigned long arg);
-extern int drm_lastclose(drm_device_t *dev);
+extern int drm_lastclose(struct drm_device *dev);
 
                                 /* Device support (drm_fops.h) */
 extern int drm_open(struct inode *inode, struct file *filp);
@@ -857,7 +846,7 @@ extern int drm_mem_info(char *buf, char **start, off_t offset,
                         int request, int *eof, void *data);
 extern void *drm_realloc(void *oldpt, size_t oldsize, size_t size, int area);
 
-extern DRM_AGP_MEM *drm_alloc_agp(drm_device_t * dev, int pages, u32 type);
+extern DRM_AGP_MEM *drm_alloc_agp(struct drm_device *dev, int pages, u32 type);
 extern int drm_free_agp(DRM_AGP_MEM * handle, int pages);
 extern int drm_bind_agp(DRM_AGP_MEM * handle, unsigned int start);
 extern int drm_unbind_agp(DRM_AGP_MEM * handle);
@@ -896,9 +885,9 @@ extern int drm_newctx(struct inode *inode, struct file *filp,
 extern int drm_rmctx(struct inode *inode, struct file *filp,
                      unsigned int cmd, unsigned long arg);
 
-extern int drm_ctxbitmap_init(drm_device_t * dev);
-extern void drm_ctxbitmap_cleanup(drm_device_t * dev);
-extern void drm_ctxbitmap_free(drm_device_t * dev, int ctx_handle);
+extern int drm_ctxbitmap_init(struct drm_device *dev);
+extern void drm_ctxbitmap_cleanup(struct drm_device *dev);
+extern void drm_ctxbitmap_free(struct drm_device *dev, int ctx_handle);
 
 extern int drm_setsareactx(struct inode *inode, struct file *filp,
                            unsigned int cmd, unsigned long arg);
@@ -912,7 +901,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(struct drm_device *dev,
                                                   drm_drawable_t id);
 
                                 /* Authentication IOCTL support (drm_auth.h) */
@@ -926,10 +915,10 @@ extern int drm_lock(struct inode *inode, struct file *filp,
                     unsigned int cmd, unsigned long arg);
 extern int drm_unlock(struct inode *inode, struct file *filp,
                       unsigned int cmd, unsigned long arg);
-extern int drm_lock_take(drm_lock_data_t *lock_data, unsigned int context);
-extern int drm_lock_free(drm_lock_data_t *lock_data, unsigned int context);
-extern void drm_idlelock_take(drm_lock_data_t *lock_data);
-extern void drm_idlelock_release(drm_lock_data_t *lock_data);
+extern int drm_lock_take(struct drm_lock_data *lock_data, unsigned int context);
+extern int drm_lock_free(struct drm_lock_data *lock_data, unsigned int context);
+extern void drm_idlelock_take(struct drm_lock_data *lock_data);
+extern void drm_idlelock_release(struct drm_lock_data *lock_data);
 
 /*
  * These are exported to drivers so that they can implement fencing using
@@ -940,15 +929,15 @@ 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_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);
+extern int drm_addbufs_agp(struct drm_device *dev, struct drm_buf_desc * request);
+extern int drm_addbufs_pci(struct drm_device *dev, struct drm_buf_desc * request);
+extern int drm_addmap(struct drm_device *dev, unsigned int offset,
+                      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);
-extern int drm_rmmap_locked(drm_device_t * dev, drm_local_map_t * map);
+extern int drm_rmmap(struct drm_device *dev, drm_local_map_t * map);
+extern int drm_rmmap_locked(struct drm_device *dev, drm_local_map_t * map);
 extern int drm_rmmap_ioctl(struct inode *inode, struct file *filp,
                            unsigned int cmd, unsigned long arg);
 
@@ -963,56 +952,56 @@ extern int drm_freebufs(struct inode *inode, struct file *filp,
                         unsigned int cmd, unsigned long arg);
 extern int drm_mapbufs(struct inode *inode, struct file *filp,
                        unsigned int cmd, unsigned long arg);
-extern unsigned long drm_get_resource_start(drm_device_t * dev,
+extern unsigned long drm_get_resource_start(struct drm_device *dev,
                                             unsigned int resource);
-extern unsigned long drm_get_resource_len(drm_device_t * dev,
+extern unsigned long drm_get_resource_len(struct drm_device *dev,
                                           unsigned int resource);
 
                                 /* DMA support (drm_dma.h) */
-extern int drm_dma_setup(drm_device_t * dev);
-extern void drm_dma_takedown(drm_device_t * dev);
-extern void drm_free_buffer(drm_device_t * dev, drm_buf_t * buf);
-extern void drm_core_reclaim_buffers(drm_device_t * dev, struct file *filp);
+extern int drm_dma_setup(struct drm_device *dev);
+extern void drm_dma_takedown(struct drm_device *dev);
+extern void drm_free_buffer(struct drm_device *dev, struct drm_buf * buf);
+extern void drm_core_reclaim_buffers(struct drm_device *dev, struct file *filp);
 
                                 /* IRQ support (drm_irq.h) */
 extern int drm_control(struct inode *inode, struct file *filp,
                        unsigned int cmd, unsigned long arg);
 extern irqreturn_t drm_irq_handler(DRM_IRQ_ARGS);
-extern int drm_irq_uninstall(drm_device_t * dev);
-extern void drm_driver_irq_preinstall(drm_device_t * dev);
-extern void drm_driver_irq_postinstall(drm_device_t * dev);
-extern void drm_driver_irq_uninstall(drm_device_t * dev);
+extern int drm_irq_uninstall(struct drm_device *dev);
+extern void drm_driver_irq_preinstall(struct drm_device *dev);
+extern void drm_driver_irq_postinstall(struct drm_device *dev);
+extern void drm_driver_irq_uninstall(struct drm_device *dev);
 
 extern int drm_wait_vblank(struct inode *inode, struct file *filp,
                            unsigned int cmd, unsigned long arg);
-extern int drm_vblank_wait(drm_device_t * dev, unsigned int *vbl_seq);
-extern void drm_vbl_send_signals(drm_device_t * dev);
-extern void drm_locked_tasklet(drm_device_t *dev, void(*func)(drm_device_t*));
+extern int drm_vblank_wait(struct drm_device *dev, unsigned int *vbl_seq);
+extern void drm_vbl_send_signals(struct drm_device *dev);
+extern void drm_locked_tasklet(struct drm_device *dev, void(*func)(struct drm_device*));
 
                                 /* AGP/GART support (drm_agpsupport.h) */
-extern drm_agp_head_t *drm_agp_init(drm_device_t * dev);
-extern int drm_agp_acquire(drm_device_t * dev);
+extern struct drm_agp_head *drm_agp_init(struct drm_device *dev);
+extern int drm_agp_acquire(struct drm_device *dev);
 extern int drm_agp_acquire_ioctl(struct inode *inode, struct file *filp,
                                  unsigned int cmd, unsigned long arg);
-extern int drm_agp_release(drm_device_t * dev);
+extern int drm_agp_release(struct drm_device *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(struct drm_device *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(struct drm_device *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(struct drm_device *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(struct drm_device *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(struct drm_device *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(struct drm_device *dev, struct drm_agp_binding *request);
 extern int drm_agp_bind_ioctl(struct inode *inode, struct file *filp,
                         unsigned int cmd, unsigned long arg);
 extern DRM_AGP_MEM *drm_agp_allocate_memory(struct agp_bridge_data *bridge,
@@ -1024,16 +1013,18 @@ extern int drm_agp_unbind_memory(DRM_AGP_MEM * handle);
                                 /* Stub support (drm_stub.h) */
 extern int drm_get_dev(struct pci_dev *pdev, const struct pci_device_id *ent,
                        struct drm_driver *driver);
-extern int drm_put_dev(drm_device_t * dev);
-extern int drm_put_head(drm_head_t * head);
+extern int drm_put_dev(struct drm_device *dev);
+extern int drm_put_head(struct drm_head *head);
 extern unsigned int drm_debug;
 extern unsigned int drm_cards_limit;
-extern drm_head_t **drm_heads;
+extern struct drm_head **drm_heads;
 extern struct class *drm_class;
 extern struct proc_dir_entry *drm_proc_root;
 
+extern drm_local_map_t *drm_getsarea(struct drm_device *dev);
+
                                 /* Proc support (drm_proc.h) */
-extern int drm_proc_init(drm_device_t * dev,
+extern int drm_proc_init(struct drm_device *dev,
                          int minor,
                          struct proc_dir_entry *root,
                          struct proc_dir_entry **dev_root);
@@ -1042,45 +1033,45 @@ extern int drm_proc_cleanup(int minor,
                             struct proc_dir_entry *dev_root);
 
                                 /* Scatter Gather Support (drm_scatter.h) */
-extern void drm_sg_cleanup(drm_sg_mem_t * entry);
+extern void drm_sg_cleanup(struct drm_sg_mem * entry);
 extern int drm_sg_alloc(struct inode *inode, struct file *filp,
                         unsigned int cmd, unsigned long arg);
 extern int drm_sg_free(struct inode *inode, struct file *filp,
                        unsigned int cmd, unsigned long arg);
 
                                /* ATI PCIGART support (ati_pcigart.h) */
-extern int drm_ati_pcigart_init(drm_device_t * dev,
-                                drm_ati_pcigart_info * gart_info);
-extern int drm_ati_pcigart_cleanup(drm_device_t * dev,
-                                   drm_ati_pcigart_info * gart_info);
+extern int drm_ati_pcigart_init(struct drm_device *dev,
+                                struct drm_ati_pcigart_info * gart_info);
+extern int drm_ati_pcigart_cleanup(struct drm_device *dev,
+                                   struct drm_ati_pcigart_info * gart_info);
 
-extern drm_dma_handle_t *drm_pci_alloc(drm_device_t * dev, size_t size,
+extern drm_dma_handle_t *drm_pci_alloc(struct drm_device *dev, size_t size,
                                        size_t align, dma_addr_t maxaddr);
-extern void __drm_pci_free(drm_device_t * dev, drm_dma_handle_t * dmah);
-extern void drm_pci_free(drm_device_t * dev, drm_dma_handle_t * dmah);
+extern void __drm_pci_free(struct drm_device *dev, drm_dma_handle_t * dmah);
+extern void drm_pci_free(struct drm_device *dev, drm_dma_handle_t * dmah);
 
                                /* sysfs support (drm_sysfs.c) */
 extern struct class *drm_sysfs_create(struct module *owner, char *name);
 extern void drm_sysfs_destroy(struct class *cs);
 extern struct class_device *drm_sysfs_device_add(struct class *cs,
-                                                 drm_head_t *head);
+                                                 struct drm_head *head);
 extern void drm_sysfs_device_remove(struct class_device *class_dev);
 
 /*
  * Basic memory manager support (drm_mm.c)
  */
-extern drm_mm_node_t *drm_mm_get_block(drm_mm_node_t * parent,
+extern struct drm_mm_node *drm_mm_get_block(struct drm_mm_node * parent,
                                        unsigned long size,
                                        unsigned alignment);
-void drm_mm_put_block(drm_mm_node_t * cur);
-extern drm_mm_node_t *drm_mm_search_free(const drm_mm_t *mm, unsigned long size,
+void drm_mm_put_block(struct drm_mm_node * cur);
+extern struct drm_mm_node *drm_mm_search_free(const struct drm_mm *mm, unsigned long size,
                                          unsigned alignment, int best_match);
-extern int drm_mm_init(drm_mm_t *mm, unsigned long start, unsigned long size);
-extern void drm_mm_takedown(drm_mm_t *mm);
-extern int drm_mm_clean(drm_mm_t *mm);
-extern unsigned long drm_mm_tail_space(drm_mm_t *mm);
-extern int drm_mm_remove_space_from_tail(drm_mm_t *mm, unsigned long size);
-extern int drm_mm_add_space_to_tail(drm_mm_t *mm, unsigned long size);
+extern int drm_mm_init(struct drm_mm *mm, unsigned long start, unsigned long size);
+extern void drm_mm_takedown(struct drm_mm *mm);
+extern int drm_mm_clean(struct drm_mm *mm);
+extern unsigned long drm_mm_tail_space(struct drm_mm *mm);
+extern int drm_mm_remove_space_from_tail(struct drm_mm *mm, unsigned long size);
+extern int drm_mm_add_space_to_tail(struct drm_mm *mm, unsigned long size);
 
 extern void drm_core_ioremap(struct drm_map *map, struct drm_device *dev);
 extern void drm_core_ioremapfree(struct drm_map *map, struct drm_device *dev);
@@ -1088,14 +1079,14 @@ extern void drm_core_ioremapfree(struct drm_map *map, struct drm_device *dev);
 static __inline__ struct drm_map *drm_core_findmap(struct drm_device *dev,
                                                    unsigned int token)
 {
-        drm_map_list_t *_entry;
-        list_for_each_entry(_entry, &dev->maplist->head, head)
+        struct drm_map_list *_entry;
+        list_for_each_entry(_entry, &dev->maplist, head)
             if (_entry->user_token == token)
                 return _entry->map;
         return NULL;
 }
 
-static __inline__ int drm_device_is_agp(drm_device_t * dev)
+static __inline__ int drm_device_is_agp(struct drm_device *dev)
 {
         if (dev->driver->device_is_agp != NULL) {
                 int err = (*dev->driver->device_is_agp) (dev);
@@ -1108,7 +1099,7 @@ static __inline__ int drm_device_is_agp(drm_device_t * dev)
         return pci_find_capability(dev->pdev, PCI_CAP_ID_AGP);
 }
 
-static __inline__ int drm_device_is_pcie(drm_device_t * dev)
+static __inline__ int drm_device_is_pcie(struct drm_device *dev)
 {
         return pci_find_capability(dev->pdev, PCI_CAP_ID_EXP);
 }
@@ -1143,7 +1134,7 @@ extern void *drm_calloc(size_t nmemb, size_t size, int area);
 
 /*@}*/
 
-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);
 
 #endif                          /* __KERNEL__ */
diff --git a/drivers/char/drm/drm_agpsupport.c b/drivers/char/drm/drm_agpsupport.c
index 40bfd9b01e39..354f0e3674bf 100644
--- a/drivers/char/drm/drm_agpsupport.c
+++ b/drivers/char/drm/drm_agpsupport.c
@@ -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(struct drm_device *dev, struct drm_agp_info *info)
 {
         DRM_AGP_KERN *kern;
 
@@ -74,16 +74,16 @@ EXPORT_SYMBOL(drm_agp_info);
 int drm_agp_info_ioctl(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_agp_info_t info;
+        struct drm_file *priv = filp->private_data;
+        struct drm_device *dev = priv->head->dev;
+        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;
 }
@@ -97,7 +97,7 @@ int drm_agp_info_ioctl(struct inode *inode, struct file *filp,
  * Verifies the AGP device hasn't been acquired before and calls
  * \c agp_backend_acquire.
  */
-int drm_agp_acquire(drm_device_t * dev)
+int drm_agp_acquire(struct drm_device * dev)
 {
         if (!dev->agp)
                 return -ENODEV;
@@ -126,9 +126,9 @@ EXPORT_SYMBOL(drm_agp_acquire);
 int drm_agp_acquire_ioctl(struct inode *inode, struct file *filp,
                           unsigned int cmd, unsigned long arg)
 {
-        drm_file_t *priv = filp->private_data;
+        struct drm_file *priv = filp->private_data;
 
-        return drm_agp_acquire((drm_device_t *) priv->head->dev);
+        return drm_agp_acquire((struct drm_device *) priv->head->dev);
 }
 
 /**
@@ -139,7 +139,7 @@ int drm_agp_acquire_ioctl(struct inode *inode, struct file *filp,
  *
  * Verifies the AGP device has been acquired and calls \c agp_backend_release.
  */
-int drm_agp_release(drm_device_t * dev)
+int drm_agp_release(struct drm_device * dev)
 {
         if (!dev->agp || !dev->agp->acquired)
                 return -EINVAL;
@@ -152,8 +152,8 @@ EXPORT_SYMBOL(drm_agp_release);
 int drm_agp_release_ioctl(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;
+        struct drm_file *priv = filp->private_data;
+        struct drm_device *dev = priv->head->dev;
 
         return drm_agp_release(dev);
 }
@@ -168,7 +168,7 @@ int drm_agp_release_ioctl(struct inode *inode, struct file *filp,
  * Verifies the AGP device has been acquired but not enabled, and calls
  * \c agp_enable.
  */
-int drm_agp_enable(drm_device_t * dev, drm_agp_mode_t mode)
+int drm_agp_enable(struct drm_device * dev, struct drm_agp_mode mode)
 {
         if (!dev->agp || !dev->agp->acquired)
                 return -EINVAL;
@@ -185,11 +185,11 @@ EXPORT_SYMBOL(drm_agp_enable);
 int drm_agp_enable_ioctl(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_agp_mode_t mode;
+        struct drm_file *priv = filp->private_data;
+        struct drm_device *dev = priv->head->dev;
+        struct drm_agp_mode mode;
 
-        if (copy_from_user(&mode, (drm_agp_mode_t __user *) arg, sizeof(mode)))
+        if (copy_from_user(&mode, (struct drm_agp_mode __user *) arg, sizeof(mode)))
                 return -EFAULT;
 
         return drm_agp_enable(dev, mode);
@@ -207,9 +207,9 @@ 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(struct drm_device *dev, struct drm_agp_buffer *request)
 {
-        drm_agp_mem_t *entry;
+        struct drm_agp_mem *entry;
         DRM_AGP_MEM *memory;
         unsigned long pages;
         u32 type;
@@ -232,11 +232,7 @@ int drm_agp_alloc(drm_device_t *dev, drm_agp_buffer_t *request)
         entry->memory = memory;
         entry->bound = 0;
         entry->pages = pages;
-        entry->prev = NULL;
-        entry->next = dev->agp->memory;
-        if (dev->agp->memory)
-                dev->agp->memory->prev = entry;
-        dev->agp->memory = entry;
+        list_add(&entry->head, &dev->agp->memory);
 
         request->handle = entry->handle;
         request->physical = memory->physical;
@@ -248,10 +244,10 @@ EXPORT_SYMBOL(drm_agp_alloc);
 int drm_agp_alloc_ioctl(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_agp_buffer_t request;
-        drm_agp_buffer_t __user *argp = (void __user *)arg;
+        struct drm_file *priv = filp->private_data;
+        struct drm_device *dev = priv->head->dev;
+        struct drm_agp_buffer request;
+        struct drm_agp_buffer __user *argp = (void __user *)arg;
         int err;
 
         if (copy_from_user(&request, argp, sizeof(request)))
@@ -262,10 +258,12 @@ int drm_agp_alloc_ioctl(struct inode *inode, struct file *filp,
                 return err;
 
         if (copy_to_user(argp, &request, sizeof(request))) {
-                drm_agp_mem_t *entry = dev->agp->memory;
-
-                dev->agp->memory = entry->next;
-                dev->agp->memory->prev = NULL;
+                struct drm_agp_mem *entry;
+                list_for_each_entry(entry, &dev->agp->memory, head) {
+                        if (entry->handle == request.handle)
+                                break;
+                }
+                list_del(&entry->head);
                 drm_free_agp(entry->memory, entry->pages);
                 drm_free(entry, sizeof(*entry), DRM_MEM_AGPLISTS);
                 return -EFAULT;
@@ -283,12 +281,12 @@ int drm_agp_alloc_ioctl(struct inode *inode, struct file *filp,
  *
  * Walks through drm_agp_head::memory until finding a matching handle.
  */
-static drm_agp_mem_t *drm_agp_lookup_entry(drm_device_t * dev,
+static struct drm_agp_mem *drm_agp_lookup_entry(struct drm_device * dev,
                                            unsigned long handle)
 {
-        drm_agp_mem_t *entry;
+        struct drm_agp_mem *entry;
 
-        for (entry = dev->agp->memory; entry; entry = entry->next) {
+        list_for_each_entry(entry, &dev->agp->memory, head) {
                 if (entry->handle == handle)
                         return entry;
         }
@@ -307,9 +305,9 @@ 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(struct drm_device *dev, struct drm_agp_binding *request)
 {
-        drm_agp_mem_t *entry;
+        struct drm_agp_mem *entry;
         int ret;
 
         if (!dev->agp || !dev->agp->acquired)
@@ -328,12 +326,12 @@ EXPORT_SYMBOL(drm_agp_unbind);
 int drm_agp_unbind_ioctl(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_agp_binding_t request;
+        struct drm_file *priv = filp->private_data;
+        struct drm_device *dev = priv->head->dev;
+        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);
@@ -352,9 +350,9 @@ 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(struct drm_device *dev, struct drm_agp_binding *request)
 {
-        drm_agp_mem_t *entry;
+        struct drm_agp_mem *entry;
         int retcode;
         int page;
 
@@ -377,12 +375,12 @@ EXPORT_SYMBOL(drm_agp_bind);
 int drm_agp_bind_ioctl(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_agp_binding_t request;
+        struct drm_file *priv = filp->private_data;
+        struct drm_device *dev = priv->head->dev;
+        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);
@@ -402,9 +400,9 @@ 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(struct drm_device *dev, struct drm_agp_buffer *request)
 {
-        drm_agp_mem_t *entry;
+        struct drm_agp_mem *entry;
 
         if (!dev->agp || !dev->agp->acquired)
                 return -EINVAL;
@@ -413,13 +411,7 @@ int drm_agp_free(drm_device_t *dev, drm_agp_buffer_t *request)
         if (entry->bound)
                 drm_unbind_agp(entry->memory);
 
-        if (entry->prev)
-                entry->prev->next = entry->next;
-        else
-                dev->agp->memory = entry->next;
-
-        if (entry->next)
-                entry->next->prev = entry->prev;
+        list_del(&entry->head);
 
         drm_free_agp(entry->memory, entry->pages);
         drm_free(entry, sizeof(*entry), DRM_MEM_AGPLISTS);
@@ -430,12 +422,12 @@ EXPORT_SYMBOL(drm_agp_free);
 int drm_agp_free_ioctl(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_agp_buffer_t request;
+        struct drm_file *priv = filp->private_data;
+        struct drm_device *dev = priv->head->dev;
+        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);
@@ -450,9 +442,9 @@ int drm_agp_free_ioctl(struct inode *inode, struct file *filp,
  * via the inter_module_* functions. Creates and initializes a drm_agp_head
  * structure.
  */
-drm_agp_head_t *drm_agp_init(drm_device_t * dev)
+struct drm_agp_head *drm_agp_init(struct drm_device *dev)
 {
-        drm_agp_head_t *head = NULL;
+        struct drm_agp_head *head = NULL;
 
         if (!(head = drm_alloc(sizeof(*head), DRM_MEM_AGPLISTS)))
                 return NULL;
@@ -472,7 +464,7 @@ drm_agp_head_t *drm_agp_init(drm_device_t * dev)
                 drm_free(head, sizeof(*head), DRM_MEM_AGPLISTS);
                 return NULL;
         }
-        head->memory = NULL;
+        INIT_LIST_HEAD(&head->memory);
         head->cant_use_aperture = head->agp_info.cant_use_aperture;
         head->page_mask = head->agp_info.page_mask;
 
diff --git a/drivers/char/drm/drm_auth.c b/drivers/char/drm/drm_auth.c
index c7b19d35bcd6..7f777da872cd 100644
--- a/drivers/char/drm/drm_auth.c
+++ b/drivers/char/drm/drm_auth.c
@@ -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);
+                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);
 
@@ -102,10 +102,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);
 
@@ -114,7 +114,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);
@@ -142,9 +142,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) {
@@ -162,7 +162,7 @@ int drm_getmagic(struct inode *inode, struct file *filp,
         }
 
         DRM_DEBUG("%u\n", auth.magic);
-        if (copy_to_user((drm_auth_t __user *) arg, &auth, sizeof(auth)))
+        if (copy_to_user((struct drm_auth __user *) arg, &auth, sizeof(auth)))
                 return -EFAULT;
         return 0;
 }
@@ -181,12 +181,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))) {
diff --git a/drivers/char/drm/drm_bufs.c b/drivers/char/drm/drm_bufs.c
index c11345856ffe..923174c54a1c 100644
--- a/drivers/char/drm/drm_bufs.c
+++ b/drivers/char/drm/drm_bufs.c
@@ -36,26 +36,24 @@
 #include <linux/vmalloc.h>
 #include "drmP.h"
 
-unsigned long drm_get_resource_start(drm_device_t *dev, unsigned int resource)
+unsigned long drm_get_resource_start(struct drm_device *dev, unsigned int resource)
 {
         return pci_resource_start(dev->pdev, resource);
 }
 EXPORT_SYMBOL(drm_get_resource_start);
 
-unsigned long drm_get_resource_len(drm_device_t *dev, unsigned int resource)
+unsigned long drm_get_resource_len(struct drm_device *dev, unsigned int resource)
 {
         return pci_resource_len(dev->pdev, resource);
 }
 
 EXPORT_SYMBOL(drm_get_resource_len);
 
-static drm_map_list_t *drm_find_matching_map(drm_device_t *dev,
+static struct drm_map_list *drm_find_matching_map(struct drm_device *dev,
                                              drm_local_map_t *map)
 {
-        struct list_head *list;
-
-        list_for_each(list, &dev->maplist->head) {
-                drm_map_list_t *entry = list_entry(list, drm_map_list_t, head);
+        struct drm_map_list *entry;
+        list_for_each_entry(entry, &dev->maplist, head) {
                 if (entry->map && map->type == entry->map->type &&
                     ((entry->map->offset == map->offset) ||
                      (map->type == _DRM_SHM && map->flags==_DRM_CONTAINS_LOCK))) {
@@ -66,7 +64,7 @@ static drm_map_list_t *drm_find_matching_map(drm_device_t *dev,
         return NULL;
 }
 
-static int drm_map_handle(drm_device_t *dev, drm_hash_item_t *hash,
+static int drm_map_handle(struct drm_device *dev, struct drm_hash_item *hash,
                           unsigned long user_token, int hashed_handle)
 {
         int use_hashed_handle;
@@ -103,12 +101,13 @@ static int drm_map_handle(drm_device_t *dev, drm_hash_item_t *hash,
  * type.  Adds the map to the map list drm_device::maplist. Adds MTRR's where
  * 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)
+static int drm_addmap_core(struct drm_device * dev, unsigned int offset,
+                           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;
@@ -214,7 +213,7 @@ static int drm_addmap_core(drm_device_t * dev, unsigned int offset,
                 }
                 break;
         case _DRM_AGP: {
-                drm_agp_mem_t *entry;
+                struct drm_agp_mem *entry;
                 int valid = 0;
 
                 if (!drm_core_has_AGP(dev)) {
@@ -237,14 +236,14 @@ static int drm_addmap_core(drm_device_t * dev, unsigned int offset,
                  * skipped and we double check that dev->agp->memory is
                  * actually set as well as being invalid before EPERM'ing
                  */
-                for (entry = dev->agp->memory; entry; entry = entry->next) {
+                list_for_each_entry(entry, &dev->agp->memory, head) {
                         if ((map->offset >= entry->bound) &&
                             (map->offset + map->size <= entry->bound + entry->pages * PAGE_SIZE)) {
                                 valid = 1;
                                 break;
                         }
                 }
-                if (dev->agp->memory && !valid) {
+                if (!list_empty(&dev->agp->memory) && !valid) {
                         drm_free(map, sizeof(*map), DRM_MEM_MAPS);
                         return -EPERM;
                 }
@@ -289,7 +288,7 @@ static int drm_addmap_core(drm_device_t * dev, unsigned int offset,
         list->map = map;
 
         mutex_lock(&dev->struct_mutex);
-        list_add(&list->head, &dev->maplist->head);
+        list_add(&list->head, &dev->maplist);
 
         /* Assign a 32-bit handle */
         /* We do it here so that dev->struct_mutex protects the increment */
@@ -312,11 +311,11 @@ static int drm_addmap_core(drm_device_t * dev, unsigned int offset,
         return 0;
         }
 
-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)
+int drm_addmap(struct drm_device * dev, unsigned int offset,
+               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,11 +329,11 @@ EXPORT_SYMBOL(drm_addmap);
 int drm_addmap_ioctl(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_map_t map;
-        drm_map_list_t *maplist;
-        drm_map_t __user *argp = (void __user *)arg;
+        struct drm_file *priv = filp->private_data;
+        struct drm_device *dev = priv->head->dev;
+        struct drm_map map;
+        struct drm_map_list *maplist;
+        struct drm_map __user *argp = (void __user *)arg;
         int err;
 
         if (!(filp->f_mode & 3))
@@ -353,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 */
@@ -369,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
@@ -378,31 +377,26 @@ int drm_addmap_ioctl(struct inode *inode, struct file *filp,
  *
  * \sa drm_addmap
  */
-int drm_rmmap_locked(drm_device_t *dev, drm_local_map_t *map)
+int drm_rmmap_locked(struct drm_device *dev, drm_local_map_t *map)
 {
-        struct list_head *list;
-        drm_map_list_t *r_list = NULL;
+        struct drm_map_list *r_list = NULL, *list_t;
         drm_dma_handle_t dmah;
+        int found = 0;
 
         /* Find the list entry for the map and remove it */
-        list_for_each(list, &dev->maplist->head) {
-                r_list = list_entry(list, drm_map_list_t, head);
-
+        list_for_each_entry_safe(r_list, list_t, &dev->maplist, head) {
                 if (r_list->map == map) {
-                        list_del(list);
+                        list_del(&r_list->head);
                         drm_ht_remove_key(&dev->map_hash,
                                           r_list->user_token >> PAGE_SHIFT);
-                        drm_free(list, sizeof(*list), DRM_MEM_MAPS);
+                        drm_free(r_list, sizeof(*r_list), DRM_MEM_MAPS);
+                        found = 1;
                         break;
                 }
         }
 
-        /* List has wrapped around to the head pointer, or it's empty and we
-         * didn't find anything.
-         */
-        if (list == (&dev->maplist->head)) {
+        if (!found)
                 return -EINVAL;
-        }
 
         switch (map->type) {
         case _DRM_REGISTERS:
@@ -433,7 +427,7 @@ int drm_rmmap_locked(drm_device_t *dev, drm_local_map_t *map)
         return 0;
 }
 
-int drm_rmmap(drm_device_t *dev, drm_local_map_t *map)
+int drm_rmmap(struct drm_device *dev, drm_local_map_t *map)
 {
         int ret;
 
@@ -456,21 +450,19 @@ int drm_rmmap(drm_device_t *dev, drm_local_map_t *map)
 int drm_rmmap_ioctl(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_map_t request;
+        struct drm_file *priv = filp->private_data;
+        struct drm_device *dev = priv->head->dev;
+        struct drm_map request;
         drm_local_map_t *map = NULL;
-        struct list_head *list;
+        struct drm_map_list *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;
         }
 
         mutex_lock(&dev->struct_mutex);
-        list_for_each(list, &dev->maplist->head) {
-                drm_map_list_t *r_list = list_entry(list, drm_map_list_t, head);
-
+        list_for_each_entry(r_list, &dev->maplist, head) {
                 if (r_list->map &&
                     r_list->user_token == (unsigned long)request.handle &&
                     r_list->map->flags & _DRM_REMOVABLE) {
@@ -482,7 +474,7 @@ int drm_rmmap_ioctl(struct inode *inode, struct file *filp,
         /* List has wrapped around to the head pointer, or its empty we didn't
          * find anything.
          */
-        if (list == (&dev->maplist->head)) {
+        if (list_empty(&dev->maplist) || !map) {
                 mutex_unlock(&dev->struct_mutex);
                 return -EINVAL;
         }
@@ -513,7 +505,8 @@ 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(struct drm_device * dev,
+                                  struct drm_buf_entry * entry)
 {
         int i;
 
@@ -550,20 +543,20 @@ 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 dev struct drm_device to which the buffers are to be added.
+ * \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(struct drm_device * dev, struct drm_buf_desc * request)
 {
-        drm_device_dma_t *dma = dev->dma;
-        drm_buf_entry_t *entry;
-        drm_agp_mem_t *agp_entry;
-        drm_buf_t *buf;
+        struct drm_device_dma *dma = dev->dma;
+        struct drm_buf_entry *entry;
+        struct drm_agp_mem *agp_entry;
+        struct drm_buf *buf;
         unsigned long offset;
         unsigned long agp_offset;
         int count;
@@ -574,7 +567,7 @@ int drm_addbufs_agp(drm_device_t * dev, drm_buf_desc_t * request)
         int total;
         int byte_count;
         int i, valid;
-        drm_buf_t **temp_buflist;
+        struct drm_buf **temp_buflist;
 
         if (!dma)
                 return -EINVAL;
@@ -606,14 +599,14 @@ int drm_addbufs_agp(drm_device_t * dev, drm_buf_desc_t * request)
 
         /* Make sure buffers are located in AGP memory that we own */
         valid = 0;
-        for (agp_entry = dev->agp->memory; agp_entry; agp_entry = agp_entry->next) {
+        list_for_each_entry(agp_entry, &dev->agp->memory, head) {
                 if ((agp_offset >= agp_entry->bound) &&
                     (agp_offset + total * count <= agp_entry->bound + agp_entry->pages * PAGE_SIZE)) {
                         valid = 1;
                         break;
                 }
         }
-        if (dev->agp->memory && !valid) {
+        if (!list_empty(&dev->agp->memory) && !valid) {
                 DRM_DEBUG("zone invalid\n");
                 return -EINVAL;
         }
@@ -728,24 +721,24 @@ 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(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;
-        drm_buf_t *buf;
+        struct drm_buf *buf;
         int alignment;
         unsigned long offset;
         int i;
         int byte_count;
         int page_count;
         unsigned long *temp_pagelist;
-        drm_buf_t **temp_buflist;
+        struct drm_buf **temp_buflist;
 
         if (!drm_core_check_feature(dev, DRIVER_PCI_DMA))
                 return -EINVAL;
@@ -954,11 +947,11 @@ 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(struct drm_device * dev, struct drm_buf_desc * request)
 {
-        drm_device_dma_t *dma = dev->dma;
-        drm_buf_entry_t *entry;
-        drm_buf_t *buf;
+        struct drm_device_dma *dma = dev->dma;
+        struct drm_buf_entry *entry;
+        struct drm_buf *buf;
         unsigned long offset;
         unsigned long agp_offset;
         int count;
@@ -969,7 +962,7 @@ static int drm_addbufs_sg(drm_device_t * dev, drm_buf_desc_t * request)
         int total;
         int byte_count;
         int i;
-        drm_buf_t **temp_buflist;
+        struct drm_buf **temp_buflist;
 
         if (!drm_core_check_feature(dev, DRIVER_SG))
                 return -EINVAL;
@@ -1116,11 +1109,11 @@ static int drm_addbufs_sg(drm_device_t * dev, drm_buf_desc_t * request)
         return 0;
 }
 
-static int drm_addbufs_fb(drm_device_t * dev, drm_buf_desc_t * request)
+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;
-        drm_buf_t *buf;
+        struct drm_device_dma *dma = dev->dma;
+        struct drm_buf_entry *entry;
+        struct drm_buf *buf;
         unsigned long offset;
         unsigned long agp_offset;
         int count;
@@ -1131,7 +1124,7 @@ static int drm_addbufs_fb(drm_device_t * dev, drm_buf_desc_t * request)
         int total;
         int byte_count;
         int i;
-        drm_buf_t **temp_buflist;
+        struct drm_buf **temp_buflist;
 
         if (!drm_core_check_feature(dev, DRIVER_FB_DMA))
                 return -EINVAL;
@@ -1283,7 +1276,7 @@ static int drm_addbufs_fb(drm_device_t * dev, drm_buf_desc_t * request)
  * \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,15 +1287,15 @@ static int drm_addbufs_fb(drm_device_t * dev, drm_buf_desc_t * request)
 int drm_addbufs(struct inode *inode, struct file *filp,
                 unsigned int cmd, unsigned long arg)
 {
-        drm_buf_desc_t request;
-        drm_file_t *priv = filp->private_data;
-        drm_device_t *dev = priv->head->dev;
+        struct drm_buf_desc request;
+        struct drm_file *priv = filp->private_data;
+        struct drm_device *dev = priv->head->dev;
         int ret;
 
         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;
 
@@ -1346,11 +1339,11 @@ int drm_addbufs(struct inode *inode, struct file *filp,
 int drm_infobufs(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_device_dma_t *dma = dev->dma;
-        drm_buf_info_t request;
-        drm_buf_info_t __user *argp = (void __user *)arg;
+        struct drm_file *priv = filp->private_data;
+        struct drm_device *dev = priv->head->dev;
+        struct drm_device_dma *dma = dev->dma;
+        struct drm_buf_info request;
+        struct drm_buf_info __user *argp = (void __user *)arg;
         int i;
         int count;
 
@@ -1381,10 +1374,10 @@ 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];
-                                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)) ||
@@ -1434,12 +1427,12 @@ int drm_infobufs(struct inode *inode, struct file *filp,
 int drm_markbufs(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_device_dma_t *dma = dev->dma;
-        drm_buf_desc_t request;
+        struct drm_file *priv = filp->private_data;
+        struct drm_device *dev = priv->head->dev;
+        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;
@@ -1448,7 +1441,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",
@@ -1484,13 +1477,13 @@ int drm_markbufs(struct inode *inode, struct file *filp,
 int drm_freebufs(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_device_dma_t *dma = dev->dma;
-        drm_buf_free_t request;
+        struct drm_file *priv = filp->private_data;
+        struct drm_device *dev = priv->head->dev;
+        struct drm_device_dma *dma = dev->dma;
+        struct drm_buf_free request;
         int i;
         int idx;
-        drm_buf_t *buf;
+        struct drm_buf *buf;
 
         if (!drm_core_check_feature(dev, DRIVER_HAVE_DMA))
                 return -EINVAL;
@@ -1499,7 +1492,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);
@@ -1540,15 +1533,15 @@ int drm_freebufs(struct inode *inode, struct file *filp,
 int drm_mapbufs(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_device_dma_t *dma = dev->dma;
-        drm_buf_map_t __user *argp = (void __user *)arg;
+        struct drm_file *priv = filp->private_data;
+        struct drm_device *dev = priv->head->dev;
+        struct drm_device_dma *dma = dev->dma;
+        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))
@@ -1574,7 +1567,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) {
diff --git a/drivers/char/drm/drm_context.c b/drivers/char/drm/drm_context.c
index 83094c73da67..7fc055adec25 100644
--- a/drivers/char/drm/drm_context.c
+++ b/drivers/char/drm/drm_context.c
@@ -56,7 +56,7 @@
  * in drm_device::context_sareas, while holding the drm_device::struct_mutex
  * lock.
  */
-void drm_ctxbitmap_free(drm_device_t * dev, int ctx_handle)
+void drm_ctxbitmap_free(struct drm_device * dev, int ctx_handle)
 {
         if (ctx_handle < 0)
                 goto failed;
@@ -85,7 +85,7 @@ void drm_ctxbitmap_free(drm_device_t * dev, int ctx_handle)
  * drm_device::context_sareas to accommodate the new entry while holding the
  * drm_device::struct_mutex lock.
  */
-static int drm_ctxbitmap_next(drm_device_t * dev)
+static int drm_ctxbitmap_next(struct drm_device * dev)
 {
         int bit;
 
@@ -100,7 +100,7 @@ static int drm_ctxbitmap_next(drm_device_t * dev)
                 if ((bit + 1) > dev->max_context) {
                         dev->max_context = (bit + 1);
                         if (dev->context_sareas) {
-                                drm_map_t **ctx_sareas;
+                                struct drm_map **ctx_sareas;
 
                                 ctx_sareas = drm_realloc(dev->context_sareas,
                                                          (dev->max_context -
@@ -147,7 +147,7 @@ static int drm_ctxbitmap_next(drm_device_t * dev)
  * Allocates and initialize drm_device::ctx_bitmap and drm_device::context_sareas, while holding
  * the drm_device::struct_mutex lock.
  */
-int drm_ctxbitmap_init(drm_device_t * dev)
+int drm_ctxbitmap_init(struct drm_device * dev)
 {
         int i;
         int temp;
@@ -180,7 +180,7 @@ int drm_ctxbitmap_init(drm_device_t * dev)
  * Frees drm_device::ctx_bitmap and drm_device::context_sareas, while holding
  * the drm_device::struct_mutex lock.
  */
-void drm_ctxbitmap_cleanup(drm_device_t * dev)
+void drm_ctxbitmap_cleanup(struct drm_device * dev)
 {
         mutex_lock(&dev->struct_mutex);
         if (dev->context_sareas)
@@ -212,12 +212,12 @@ void drm_ctxbitmap_cleanup(drm_device_t * dev)
 int drm_getsareactx(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_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_file *priv = filp->private_data;
+        struct drm_device *dev = priv->head->dev;
+        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;
@@ -233,7 +233,7 @@ int drm_getsareactx(struct inode *inode, struct file *filp,
         mutex_unlock(&dev->struct_mutex);
 
         request.handle = NULL;
-        list_for_each_entry(_entry, &dev->maplist->head, head) {
+        list_for_each_entry(_entry, &dev->maplist, head) {
                 if (_entry->map == map) {
                         request.handle =
                             (void *)(unsigned long)_entry->user_token;
@@ -263,20 +263,19 @@ int drm_getsareactx(struct inode *inode, struct file *filp,
 int drm_setsareactx(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_priv_map_t request;
-        drm_map_t *map = NULL;
-        drm_map_list_t *r_list = NULL;
-        struct list_head *list;
+        struct drm_file *priv = filp->private_data;
+        struct drm_device *dev = priv->head->dev;
+        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);
-        list_for_each(list, &dev->maplist->head) {
-                r_list = list_entry(list, drm_map_list_t, head);
+        list_for_each_entry(r_list, &dev->maplist, head) {
                 if (r_list->map
                     && r_list->user_token == (unsigned long)request.handle)
                         goto found;
@@ -314,7 +313,7 @@ int drm_setsareactx(struct inode *inode, struct file *filp,
  *
  * Attempt to set drm_device::context_flag.
  */
-static int drm_context_switch(drm_device_t * dev, int old, int new)
+static int drm_context_switch(struct drm_device * dev, int old, int new)
 {
         if (test_and_set_bit(0, &dev->context_flag)) {
                 DRM_ERROR("Reentering -- FIXME\n");
@@ -342,7 +341,7 @@ static int drm_context_switch(drm_device_t * dev, int old, int new)
  * hardware lock is held, clears the drm_device::context_flag and wakes up
  * drm_device::context_wait.
  */
-static int drm_context_switch_complete(drm_device_t * dev, int new)
+static int drm_context_switch_complete(struct drm_device * dev, int new)
 {
         dev->last_context = new;        /* PRE/POST: This is the _only_ writer. */
         dev->last_switch = jiffies;
@@ -372,9 +371,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_res __user *argp = (void __user *)arg;
+        struct drm_ctx ctx;
         int i;
 
         if (copy_from_user(&res, argp, sizeof(res)))
@@ -409,11 +408,11 @@ int drm_resctx(struct inode *inode, struct file *filp,
 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_file *priv = filp->private_data;
+        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;
@@ -449,7 +448,7 @@ int drm_addctx(struct inode *inode, struct file *filp,
         ctx_entry->tag = priv;
 
         mutex_lock(&dev->ctxlist_mutex);
-        list_add(&ctx_entry->head, &dev->ctxlist->head);
+        list_add(&ctx_entry->head, &dev->ctxlist);
         ++dev->ctx_count;
         mutex_unlock(&dev->ctxlist_mutex);
 
@@ -477,8 +476,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;
@@ -505,11 +504,11 @@ int drm_getctx(struct inode *inode, struct file *filp,
 int drm_switchctx(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_t ctx;
+        struct drm_file *priv = filp->private_data;
+        struct drm_device *dev = priv->head->dev;
+        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);
@@ -530,11 +529,11 @@ int drm_switchctx(struct inode *inode, struct file *filp,
 int drm_newctx(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_t ctx;
+        struct drm_file *priv = filp->private_data;
+        struct drm_device *dev = priv->head->dev;
+        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);
@@ -557,11 +556,11 @@ int drm_newctx(struct inode *inode, struct file *filp,
 int drm_rmctx(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_t ctx;
+        struct drm_file *priv = filp->private_data;
+        struct drm_device *dev = priv->head->dev;
+        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);
@@ -575,10 +574,10 @@ int drm_rmctx(struct inode *inode, struct file *filp,
         }
 
         mutex_lock(&dev->ctxlist_mutex);
-        if (!list_empty(&dev->ctxlist->head)) {
-                drm_ctx_list_t *pos, *n;
+        if (!list_empty(&dev->ctxlist)) {
+                struct drm_ctx_list *pos, *n;
 
-                list_for_each_entry_safe(pos, n, &dev->ctxlist->head, head) {
+                list_for_each_entry_safe(pos, n, &dev->ctxlist, head) {
                         if (pos->handle == ctx.handle) {
                                 list_del(&pos->head);
                                 drm_free(pos, sizeof(*pos), DRM_MEM_CTXLIST);
diff --git a/drivers/char/drm/drm_dma.c b/drivers/char/drm/drm_dma.c
index 32ed19c9ec1c..802fbdbfe1b3 100644
--- a/drivers/char/drm/drm_dma.c
+++ b/drivers/char/drm/drm_dma.c
@@ -43,7 +43,7 @@
  *
  * Allocate and initialize a drm_device_dma structure.
  */
-int drm_dma_setup(drm_device_t * dev)
+int drm_dma_setup(struct drm_device *dev)
 {
         int i;
 
@@ -67,9 +67,9 @@ int drm_dma_setup(drm_device_t * dev)
  * Free all pages associated with DMA buffers, the buffers and pages lists, and
  * finally the drm_device::dma structure itself.
  */
-void drm_dma_takedown(drm_device_t * dev)
+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)
@@ -129,7 +129,7 @@ void drm_dma_takedown(drm_device_t * dev)
  *
  * Resets the fields of \p buf.
  */
-void drm_free_buffer(drm_device_t * dev, drm_buf_t * buf)
+void drm_free_buffer(struct drm_device *dev, struct drm_buf * buf)
 {
         if (!buf)
                 return;
@@ -152,9 +152,9 @@ void drm_free_buffer(drm_device_t * dev, drm_buf_t * buf)
  *
  * Frees each buffer associated with \p filp not already on the hardware.
  */
-void drm_core_reclaim_buffers(drm_device_t * dev, struct file *filp)
+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)
diff --git a/drivers/char/drm/drm_drawable.c b/drivers/char/drm/drm_drawable.c
index b33313be2547..309e585a5442 100644
--- a/drivers/char/drm/drm_drawable.c
+++ b/drivers/char/drm/drm_drawable.c
@@ -47,9 +47,9 @@ int drm_adddraw(DRM_IOCTL_ARGS)
         int i, j;
         u32 *bitfield = dev->drw_bitfield;
         unsigned int bitfield_length = dev->drw_bitfield_length;
-        drm_drawable_info_t **info = dev->drw_info;
+        struct drm_drawable_info **info = dev->drw_info;
         unsigned int info_length = dev->drw_info_length;
-        drm_draw_t draw;
+        struct drm_draw draw;
 
         for (i = 0, j = 0; i < bitfield_length; i++) {
                 if (bitfield[i] == ~0)
@@ -120,7 +120,7 @@ done:
 
         spin_unlock_irqrestore(&dev->drw_lock, irqflags);
 
-        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;
 }
@@ -131,16 +131,16 @@ done:
 int drm_rmdraw(DRM_IOCTL_ARGS)
 {
         DRM_DEVICE;
-        drm_draw_t draw;
+        struct drm_draw draw;
         int id, idx;
         unsigned int shift;
         unsigned long irqflags;
         u32 *bitfield = dev->drw_bitfield;
         unsigned int bitfield_length = dev->drw_bitfield_length;
-        drm_drawable_info_t **info = dev->drw_info;
+        struct drm_drawable_info **info = dev->drw_info;
         unsigned int info_length = dev->drw_info_length;
 
-        DRM_COPY_FROM_USER_IOCTL(draw, (drm_draw_t __user *) data,
+        DRM_COPY_FROM_USER_IOCTL(draw, (struct drm_draw __user *) data,
                                  sizeof(draw));
 
         id = draw.handle - 1;
@@ -161,7 +161,7 @@ int drm_rmdraw(DRM_IOCTL_ARGS)
 
         if (info[id]) {
                 drm_free(info[id]->rects, info[id]->num_rects *
-                         sizeof(drm_clip_rect_t), DRM_MEM_BUFS);
+                         sizeof(struct drm_clip_rect), DRM_MEM_BUFS);
                 drm_free(info[id], sizeof(**info), DRM_MEM_BUFS);
         }
 
@@ -230,15 +230,15 @@ 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 int id, idx, shift;
         u32 *bitfield = dev->drw_bitfield;
         unsigned long irqflags, bitfield_length = dev->drw_bitfield_length;
-        drm_drawable_info_t *info;
-        drm_clip_rect_t *rects;
+        struct drm_drawable_info *info;
+        struct drm_clip_rect *rects;
         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));
 
         id = update.handle - 1;
@@ -254,7 +254,7 @@ int drm_update_drawable_info(DRM_IOCTL_ARGS) {
         info = dev->drw_info[id];
 
         if (!info) {
-                info = drm_calloc(1, sizeof(drm_drawable_info_t), DRM_MEM_BUFS);
+                info = drm_calloc(1, sizeof(struct drm_drawable_info), DRM_MEM_BUFS);
 
                 if (!info) {
                         DRM_ERROR("Failed to allocate drawable info memory\n");
@@ -265,7 +265,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;
@@ -277,7 +277,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))) {
@@ -290,7 +290,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;
@@ -314,7 +314,7 @@ error:
                 drm_free(info, sizeof(*info), DRM_MEM_BUFS);
         else if (rects != dev->drw_info[id]->rects)
                 drm_free(rects, update.num *
-                         sizeof(drm_clip_rect_t), DRM_MEM_BUFS);
+                         sizeof(struct drm_clip_rect), DRM_MEM_BUFS);
 
         return err;
 }
@@ -322,7 +322,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(struct drm_device *dev, drm_drawable_t id) {
         u32 *bitfield = dev->drw_bitfield;
         unsigned int idx, shift;
 
diff --git a/drivers/char/drm/drm_drv.c b/drivers/char/drm/drm_drv.c
index 8e77b7ed0f44..d5cf5cfccf78 100644
--- a/drivers/char/drm/drm_drv.c
+++ b/drivers/char/drm/drm_drv.c
@@ -129,11 +129,11 @@ static drm_ioctl_desc_t drm_ioctls[] = {
  *
  * \sa drm_device
  */
-int drm_lastclose(drm_device_t * dev)
+int drm_lastclose(struct drm_device * dev)
 {
-        drm_magic_entry_t *pt, *next;
-        drm_map_list_t *r_list;
-        drm_vma_entry_t *vma, *vma_next;
+        struct drm_magic_entry *pt, *next;
+        struct drm_map_list *r_list, *list_t;
+        struct drm_vma_entry *vma, *vma_temp;
         int i;
 
         DRM_DEBUG("\n");
@@ -154,11 +154,11 @@ int drm_lastclose(drm_device_t * dev)
         /* Free drawable information memory */
         for (i = 0; i < dev->drw_bitfield_length / sizeof(*dev->drw_bitfield);
              i++) {
-                drm_drawable_info_t *info = drm_get_drawable_info(dev, i);
+                struct drm_drawable_info *info = drm_get_drawable_info(dev, i);
 
                 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);
                 }
         }
@@ -178,19 +178,17 @@ int drm_lastclose(drm_device_t * dev)
 
         /* Clear AGP information */
         if (drm_core_has_AGP(dev) && dev->agp) {
-                drm_agp_mem_t *entry;
-                drm_agp_mem_t *nexte;
+                struct drm_agp_mem *entry, *tempe;
 
                 /* Remove AGP resources, but leave dev->agp
                    intact until drv_cleanup is called. */
-                for (entry = dev->agp->memory; entry; entry = nexte) {
-                        nexte = entry->next;
+                list_for_each_entry_safe(entry, tempe, &dev->agp->memory, head) {
                         if (entry->bound)
                                 drm_unbind_agp(entry->memory);
                         drm_free_agp(entry->memory, entry->pages);
                         drm_free(entry, sizeof(*entry), DRM_MEM_AGPLISTS);
                 }
-                dev->agp->memory = NULL;
+                INIT_LIST_HEAD(&dev->agp->memory);
 
                 if (dev->agp->acquired)
                         drm_agp_release(dev);
@@ -204,20 +202,14 @@ int drm_lastclose(drm_device_t * dev)
         }
 
         /* Clear vma list (only built for debugging) */
-        if (dev->vmalist) {
-                for (vma = dev->vmalist; vma; vma = vma_next) {
-                        vma_next = vma->next;
-                        drm_free(vma, sizeof(*vma), DRM_MEM_VMAS);
-                }
-                dev->vmalist = NULL;
+        list_for_each_entry_safe(vma, vma_temp, &dev->vmalist, head) {
+                list_del(&vma->head);
+                drm_free(vma, sizeof(*vma), DRM_MEM_VMAS);
         }
 
-        if (dev->maplist) {
-                while (!list_empty(&dev->maplist->head)) {
-                        struct list_head *list = dev->maplist->head.next;
-                        r_list = list_entry(list, drm_map_list_t, head);
-                        drm_rmmap_locked(dev, r_list->map);
-                }
+        list_for_each_entry_safe(r_list, list_t, &dev->maplist, head) {
+                drm_rmmap_locked(dev, r_list->map);
+                r_list = NULL;
         }
 
         if (drm_core_check_feature(dev, DRIVER_DMA_QUEUE) && dev->queuelist) {
@@ -298,7 +290,7 @@ EXPORT_SYMBOL(drm_init);
  *
  * \sa drm_init
  */
-static void drm_cleanup(drm_device_t * dev)
+static void drm_cleanup(struct drm_device * dev)
 {
         DRM_DEBUG("\n");
 
@@ -309,11 +301,7 @@ static void drm_cleanup(drm_device_t * dev)
 
         drm_lastclose(dev);
 
-        if (dev->maplist) {
-                drm_free(dev->maplist, sizeof(*dev->maplist), DRM_MEM_MAPS);
-                dev->maplist = NULL;
-                drm_ht_remove(&dev->map_hash);
-        }
+        drm_ht_remove(&dev->map_hash);
 
         drm_ctxbitmap_cleanup(dev);
 
@@ -342,8 +330,8 @@ static void drm_cleanup(drm_device_t * dev)
 void drm_exit(struct drm_driver *driver)
 {
         int i;
-        drm_device_t *dev = NULL;
-        drm_head_t *head;
+        struct drm_device *dev = NULL;
+        struct drm_head *head;
 
         DRM_DEBUG("\n");
 
@@ -442,10 +430,10 @@ module_exit(drm_core_exit);
 static int drm_version(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_version_t __user *argp = (void __user *)arg;
-        drm_version_t version;
+        struct drm_file *priv = filp->private_data;
+        struct drm_device *dev = priv->head->dev;
+        struct drm_version __user *argp = (void __user *)arg;
+        struct drm_version version;
         int len;
 
         if (copy_from_user(&version, argp, sizeof(version)))
@@ -478,8 +466,8 @@ static int drm_version(struct inode *inode, struct file *filp,
 int drm_ioctl(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;
+        struct drm_file *priv = filp->private_data;
+        struct drm_device *dev = priv->head->dev;
         drm_ioctl_desc_t *ioctl;
         drm_ioctl_t *func;
         unsigned int nr = DRM_IOCTL_NR(cmd);
@@ -529,3 +517,17 @@ int drm_ioctl(struct inode *inode, struct file *filp,
 }
 
 EXPORT_SYMBOL(drm_ioctl);
+
+drm_local_map_t *drm_getsarea(struct drm_device *dev)
+{
+        struct drm_map_list *entry;
+
+        list_for_each_entry(entry, &dev->maplist, head) {
+                if (entry->map && entry->map->type == _DRM_SHM &&
+                    (entry->map->flags & _DRM_CONTAINS_LOCK)) {
+                        return entry->map;
+                }
+        }
+        return NULL;
+}
+EXPORT_SYMBOL(drm_getsarea);
diff --git a/drivers/char/drm/drm_fops.c b/drivers/char/drm/drm_fops.c
index 3b159cab3bc8..7bc51bac450d 100644
--- a/drivers/char/drm/drm_fops.c
+++ b/drivers/char/drm/drm_fops.c
@@ -39,9 +39,9 @@
 #include <linux/poll.h>
 
 static int drm_open_helper(struct inode *inode, struct file *filp,
-                           drm_device_t * dev);
+                           struct drm_device * dev);
 
-static int drm_setup(drm_device_t * dev)
+static int drm_setup(struct drm_device * dev)
 {
         drm_local_map_t *map;
         int i;
@@ -79,13 +79,6 @@ static int drm_setup(drm_device_t * dev)
         drm_ht_create(&dev->magiclist, DRM_MAGIC_HASH_ORDER);
         INIT_LIST_HEAD(&dev->magicfree);
 
-        dev->ctxlist = drm_alloc(sizeof(*dev->ctxlist), DRM_MEM_CTXLIST);
-        if (dev->ctxlist == NULL)
-                return -ENOMEM;
-        memset(dev->ctxlist, 0, sizeof(*dev->ctxlist));
-        INIT_LIST_HEAD(&dev->ctxlist->head);
-
-        dev->vmalist = NULL;
         dev->sigdata.lock = NULL;
         init_waitqueue_head(&dev->lock.lock_queue);
         dev->queue_count = 0;
@@ -135,7 +128,7 @@ static int drm_setup(drm_device_t * dev)
  */
 int drm_open(struct inode *inode, struct file *filp)
 {
-        drm_device_t *dev = NULL;
+        struct drm_device *dev = NULL;
         int minor = iminor(inode);
         int retcode = 0;
 
@@ -174,7 +167,7 @@ EXPORT_SYMBOL(drm_open);
  */
 int drm_stub_open(struct inode *inode, struct file *filp)
 {
-        drm_device_t *dev = NULL;
+        struct drm_device *dev = NULL;
         int minor = iminor(inode);
         int err = -ENODEV;
         const struct file_operations *old_fops;
@@ -230,10 +223,10 @@ static int drm_cpu_valid(void)
  * filp and add it into the double linked list in \p dev.
  */
 static int drm_open_helper(struct inode *inode, struct file *filp,
-                           drm_device_t * dev)
+                           struct drm_device * dev)
 {
         int minor = iminor(inode);
-        drm_file_t *priv;
+        struct drm_file *priv;
         int ret;
 
         if (filp->f_flags & O_EXCL)
@@ -258,6 +251,8 @@ static int drm_open_helper(struct inode *inode, struct file *filp,
         priv->authenticated = capable(CAP_SYS_ADMIN);
         priv->lock_count = 0;
 
+        INIT_LIST_HEAD(&priv->lhead);
+
         if (dev->driver->open) {
                 ret = dev->driver->open(dev, priv);
                 if (ret < 0)
@@ -265,19 +260,10 @@ static int drm_open_helper(struct inode *inode, struct file *filp,
         }
 
         mutex_lock(&dev->struct_mutex);
-        if (!dev->file_last) {
-                priv->next = NULL;
-                priv->prev = NULL;
-                dev->file_first = priv;
-                dev->file_last = priv;
-                /* first opener automatically becomes master */
+        if (list_empty(&dev->filelist))
                 priv->master = 1;
-        } else {
-                priv->next = NULL;
-                priv->prev = dev->file_last;
-                dev->file_last->next = priv;
-                dev->file_last = priv;
-        }
+
+        list_add(&priv->lhead, &dev->filelist);
         mutex_unlock(&dev->struct_mutex);
 
 #ifdef __alpha__
@@ -309,8 +295,8 @@ static int drm_open_helper(struct inode *inode, struct file *filp,
 /** No-op. */
 int drm_fasync(int fd, struct file *filp, int on)
 {
-        drm_file_t *priv = filp->private_data;
-        drm_device_t *dev = priv->head->dev;
+        struct drm_file *priv = filp->private_data;
+        struct drm_device *dev = priv->head->dev;
         int retcode;
 
         DRM_DEBUG("fd = %d, device = 0x%lx\n", fd,
@@ -336,8 +322,8 @@ EXPORT_SYMBOL(drm_fasync);
  */
 int drm_release(struct inode *inode, struct file *filp)
 {
-        drm_file_t *priv = filp->private_data;
-        drm_device_t *dev;
+        struct drm_file *priv = filp->private_data;
+        struct drm_device *dev;
         int retcode = 0;
 
         lock_kernel();
@@ -414,10 +400,10 @@ int drm_release(struct inode *inode, struct file *filp)
         drm_fasync(-1, filp, 0);
 
         mutex_lock(&dev->ctxlist_mutex);
-        if (dev->ctxlist && (!list_empty(&dev->ctxlist->head))) {
-                drm_ctx_list_t *pos, *n;
+        if (!list_empty(&dev->ctxlist)) {
+                struct drm_ctx_list *pos, *n;
 
-                list_for_each_entry_safe(pos, n, &dev->ctxlist->head, head) {
+                list_for_each_entry_safe(pos, n, &dev->ctxlist, head) {
                         if (pos->tag == priv &&
                             pos->handle != DRM_KERNEL_CONTEXT) {
                                 if (dev->driver->context_dtor)
@@ -436,22 +422,12 @@ int drm_release(struct inode *inode, struct file *filp)
 
         mutex_lock(&dev->struct_mutex);
         if (priv->remove_auth_on_close == 1) {
-                drm_file_t *temp = dev->file_first;
-                while (temp) {
+                struct drm_file *temp;
+
+                list_for_each_entry(temp, &dev->filelist, lhead)
                         temp->authenticated = 0;
-                        temp = temp->next;
-                }
-        }
-        if (priv->prev) {
-                priv->prev->next = priv->next;
-        } else {
-                dev->file_first = priv->next;
-        }
-        if (priv->next) {
-                priv->next->prev = priv->prev;
-        } else {
-                dev->file_last = priv->prev;
         }
+        list_del(&priv->lhead);
         mutex_unlock(&dev->struct_mutex);
 
         if (dev->driver->postclose)
diff --git a/drivers/char/drm/drm_hashtab.c b/drivers/char/drm/drm_hashtab.c
index 31acb621dcce..3ad319070704 100644
--- a/drivers/char/drm/drm_hashtab.c
+++ b/drivers/char/drm/drm_hashtab.c
@@ -36,7 +36,7 @@
 #include "drm_hashtab.h"
 #include <linux/hash.h>
 
-int drm_ht_create(drm_open_hash_t *ht, unsigned int order)
+int drm_ht_create(struct drm_open_hash *ht, unsigned int order)
 {
         unsigned int i;
 
@@ -63,9 +63,9 @@ int drm_ht_create(drm_open_hash_t *ht, unsigned int order)
         return 0;
 }
 
-void drm_ht_verbose_list(drm_open_hash_t *ht, unsigned long key)
+void drm_ht_verbose_list(struct drm_open_hash *ht, unsigned long key)
 {
-        drm_hash_item_t *entry;
+        struct drm_hash_item *entry;
         struct hlist_head *h_list;
         struct hlist_node *list;
         unsigned int hashed_key;
@@ -75,15 +75,15 @@ void drm_ht_verbose_list(drm_open_hash_t *ht, unsigned long key)
         DRM_DEBUG("Key is 0x%08lx, Hashed key is 0x%08x\n", key, hashed_key);
         h_list = &ht->table[hashed_key];
         hlist_for_each(list, h_list) {
-                entry = hlist_entry(list, drm_hash_item_t, head);
+                entry = hlist_entry(list, struct drm_hash_item, head);
                 DRM_DEBUG("count %d, key: 0x%08lx\n", count++, entry->key);
         }
 }
 
-static struct hlist_node *drm_ht_find_key(drm_open_hash_t *ht, 
+static struct hlist_node *drm_ht_find_key(struct drm_open_hash *ht, 
                                           unsigned long key)
 {
-        drm_hash_item_t *entry;
+        struct drm_hash_item *entry;
         struct hlist_head *h_list;
         struct hlist_node *list;
         unsigned int hashed_key;
@@ -91,7 +91,7 @@ static struct hlist_node *drm_ht_find_key(drm_open_hash_t *ht,
         hashed_key = hash_long(key, ht->order);
         h_list = &ht->table[hashed_key];
         hlist_for_each(list, h_list) {
-                entry = hlist_entry(list, drm_hash_item_t, head);
+                entry = hlist_entry(list, struct drm_hash_item, head);
                 if (entry->key == key)
                         return list;
                 if (entry->key > key)
@@ -101,9 +101,9 @@ static struct hlist_node *drm_ht_find_key(drm_open_hash_t *ht,
 }
 
 
-int drm_ht_insert_item(drm_open_hash_t *ht, drm_hash_item_t *item)
+int drm_ht_insert_item(struct drm_open_hash *ht, struct drm_hash_item *item)
 {
-        drm_hash_item_t *entry;
+        struct drm_hash_item *entry;
         struct hlist_head *h_list;
         struct hlist_node *list, *parent;
         unsigned int hashed_key;
@@ -113,7 +113,7 @@ int drm_ht_insert_item(drm_open_hash_t *ht, drm_hash_item_t *item)
         h_list = &ht->table[hashed_key];
         parent = NULL;
         hlist_for_each(list, h_list) {
-                entry = hlist_entry(list, drm_hash_item_t, head);
+                entry = hlist_entry(list, struct drm_hash_item, head);
                 if (entry->key == key)
                         return -EINVAL;
                 if (entry->key > key)
@@ -132,7 +132,7 @@ int drm_ht_insert_item(drm_open_hash_t *ht, drm_hash_item_t *item)
  * Just insert an item and return any "bits" bit key that hasn't been 
  * used before.
  */
-int drm_ht_just_insert_please(drm_open_hash_t *ht, drm_hash_item_t *item,
+int drm_ht_just_insert_please(struct drm_open_hash *ht, struct drm_hash_item *item,
                               unsigned long seed, int bits, int shift,
                               unsigned long add)
 {
@@ -156,8 +156,8 @@ int drm_ht_just_insert_please(drm_open_hash_t *ht, drm_hash_item_t *item,
         return 0;
 }
 
-int drm_ht_find_item(drm_open_hash_t *ht, unsigned long key,
-                     drm_hash_item_t **item)
+int drm_ht_find_item(struct drm_open_hash *ht, unsigned long key,
+                     struct drm_hash_item **item)
 {
         struct hlist_node *list;
 
@@ -165,11 +165,11 @@ int drm_ht_find_item(drm_open_hash_t *ht, unsigned long key,
         if (!list)
                 return -EINVAL;
 
-        *item = hlist_entry(list, drm_hash_item_t, head);
+        *item = hlist_entry(list, struct drm_hash_item, head);
         return 0;
 }
 
-int drm_ht_remove_key(drm_open_hash_t *ht, unsigned long key)
+int drm_ht_remove_key(struct drm_open_hash *ht, unsigned long key)
 {
         struct hlist_node *list;
 
@@ -182,14 +182,14 @@ int drm_ht_remove_key(drm_open_hash_t *ht, unsigned long key)
         return -EINVAL;
 }
 
-int drm_ht_remove_item(drm_open_hash_t *ht, drm_hash_item_t *item)
+int drm_ht_remove_item(struct drm_open_hash *ht, struct drm_hash_item *item)
 {
         hlist_del_init(&item->head);
         ht->fill--;
         return 0;
 }
 
-void drm_ht_remove(drm_open_hash_t *ht)
+void drm_ht_remove(struct drm_open_hash *ht)
 {
         if (ht->table) {
                 if (ht->use_vmalloc)
diff --git a/drivers/char/drm/drm_hashtab.h b/drivers/char/drm/drm_hashtab.h
index 613091c970af..0f1376774168 100644
--- a/drivers/char/drm/drm_hashtab.h
+++ b/drivers/char/drm/drm_hashtab.h
@@ -37,31 +37,31 @@
 
 #define drm_hash_entry(_ptr, _type, _member) container_of(_ptr, _type, _member)
 
-typedef struct drm_hash_item{
+struct drm_hash_item {
         struct hlist_node head;
         unsigned long key;
-} drm_hash_item_t;
+};
 
-typedef struct drm_open_hash{
+struct drm_open_hash {
         unsigned int size;
         unsigned int order;
         unsigned int fill;
         struct hlist_head *table;
         int use_vmalloc;
-} drm_open_hash_t;
+};
 
 
-extern int drm_ht_create(drm_open_hash_t *ht, unsigned int order);
-extern int drm_ht_insert_item(drm_open_hash_t *ht, drm_hash_item_t *item);
-extern int drm_ht_just_insert_please(drm_open_hash_t *ht, drm_hash_item_t *item,
+extern int drm_ht_create(struct drm_open_hash *ht, unsigned int order);
+extern int drm_ht_insert_item(struct drm_open_hash *ht, struct drm_hash_item *item);
+extern int drm_ht_just_insert_please(struct drm_open_hash *ht, struct drm_hash_item *item,
                                      unsigned long seed, int bits, int shift,
                                      unsigned long add);
-extern int drm_ht_find_item(drm_open_hash_t *ht, unsigned long key, drm_hash_item_t **item);
+extern int drm_ht_find_item(struct drm_open_hash *ht, unsigned long key, struct drm_hash_item **item);
 
-extern void drm_ht_verbose_list(drm_open_hash_t *ht, unsigned long key);
-extern int drm_ht_remove_key(drm_open_hash_t *ht, unsigned long key);
-extern int drm_ht_remove_item(drm_open_hash_t *ht, drm_hash_item_t *item);
-extern void drm_ht_remove(drm_open_hash_t *ht);
+extern void drm_ht_verbose_list(struct drm_open_hash *ht, unsigned long key);
+extern int drm_ht_remove_key(struct drm_open_hash *ht, unsigned long key);
+extern int drm_ht_remove_item(struct drm_open_hash *ht, struct drm_hash_item *item);
+extern void drm_ht_remove(struct drm_open_hash *ht);
 
 
 #endif
diff --git a/drivers/char/drm/drm_ioc32.c b/drivers/char/drm/drm_ioc32.c
index fafeb34f89d5..462f46f2049a 100644
--- a/drivers/char/drm/drm_ioc32.c
+++ b/drivers/char/drm/drm_ioc32.c
@@ -82,7 +82,7 @@ static int compat_drm_version(struct file *file, unsigned int cmd,
                               unsigned long arg)
 {
         drm_version32_t v32;
-        drm_version_t __user *version;
+        struct drm_version __user *version;
         int err;
 
         if (copy_from_user(&v32, (void __user *)arg, sizeof(v32)))
@@ -129,7 +129,7 @@ static int compat_drm_getunique(struct file *file, unsigned int cmd,
                                 unsigned long arg)
 {
         drm_unique32_t uq32;
-        drm_unique_t __user *u;
+        struct drm_unique __user *u;
         int err;
 
         if (copy_from_user(&uq32, (void __user *)arg, sizeof(uq32)))
@@ -159,7 +159,7 @@ static int compat_drm_setunique(struct file *file, unsigned int cmd,
                                 unsigned long arg)
 {
         drm_unique32_t uq32;
-        drm_unique_t __user *u;
+        struct drm_unique __user *u;
 
         if (copy_from_user(&uq32, (void __user *)arg, sizeof(uq32)))
                 return -EFAULT;
@@ -179,8 +179,8 @@ static int compat_drm_setunique(struct file *file, unsigned int cmd,
 typedef struct drm_map32 {
         u32 offset;             /**< Requested physical address (0 for SAREA)*/
         u32 size;               /**< Requested physical size (bytes) */
-        drm_map_type_t type;    /**< Type of memory to map */
-        drm_map_flags_t flags;  /**< Flags */
+        enum drm_map_type type; /**< Type of memory to map */
+        enum drm_map_flags flags;       /**< Flags */
         u32 handle;             /**< User-space: "Handle" to pass to mmap() */
         int mtrr;               /**< MTRR slot used */
 } drm_map32_t;
@@ -190,7 +190,7 @@ static int compat_drm_getmap(struct file *file, unsigned int cmd,
 {
         drm_map32_t __user *argp = (void __user *)arg;
         drm_map32_t m32;
-        drm_map_t __user *map;
+        struct drm_map __user *map;
         int idx, err;
         void *handle;
 
@@ -228,7 +228,7 @@ static int compat_drm_addmap(struct file *file, unsigned int cmd,
 {
         drm_map32_t __user *argp = (void __user *)arg;
         drm_map32_t m32;
-        drm_map_t __user *map;
+        struct drm_map __user *map;
         int err;
         void *handle;
 
@@ -270,7 +270,7 @@ static int compat_drm_rmmap(struct file *file, unsigned int cmd,
                             unsigned long arg)
 {
         drm_map32_t __user *argp = (void __user *)arg;
-        drm_map_t __user *map;
+        struct drm_map __user *map;
         u32 handle;
 
         if (get_user(handle, &argp->handle))
@@ -300,7 +300,7 @@ static int compat_drm_getclient(struct file *file, unsigned int cmd,
 {
         drm_client32_t c32;
         drm_client32_t __user *argp = (void __user *)arg;
-        drm_client_t __user *client;
+        struct drm_client __user *client;
         int idx, err;
 
         if (get_user(idx, &argp->idx))
@@ -333,7 +333,7 @@ typedef struct drm_stats32 {
         u32 count;
         struct {
                 u32 value;
-                drm_stat_type_t type;
+                enum drm_stat_type type;
         } data[15];
 } drm_stats32_t;
 
@@ -342,7 +342,7 @@ static int compat_drm_getstats(struct file *file, unsigned int cmd,
 {
         drm_stats32_t s32;
         drm_stats32_t __user *argp = (void __user *)arg;
-        drm_stats_t __user *stats;
+        struct drm_stats __user *stats;
         int i, err;
 
         stats = compat_alloc_user_space(sizeof(*stats));
@@ -379,7 +379,7 @@ static int compat_drm_addbufs(struct file *file, unsigned int cmd,
                               unsigned long arg)
 {
         drm_buf_desc32_t __user *argp = (void __user *)arg;
-        drm_buf_desc_t __user *buf;
+        struct drm_buf_desc __user *buf;
         int err;
         unsigned long agp_start;
 
@@ -411,7 +411,7 @@ static int compat_drm_markbufs(struct file *file, unsigned int cmd,
 {
         drm_buf_desc32_t b32;
         drm_buf_desc32_t __user *argp = (void __user *)arg;
-        drm_buf_desc_t __user *buf;
+        struct drm_buf_desc __user *buf;
 
         if (copy_from_user(&b32, argp, sizeof(b32)))
                 return -EFAULT;
@@ -440,8 +440,8 @@ static int compat_drm_infobufs(struct file *file, unsigned int cmd,
         drm_buf_info32_t req32;
         drm_buf_info32_t __user *argp = (void __user *)arg;
         drm_buf_desc32_t __user *to;
-        drm_buf_info_t __user *request;
-        drm_buf_desc_t __user *list;
+        struct drm_buf_info __user *request;
+        struct drm_buf_desc __user *list;
         size_t nbytes;
         int i, err;
         int count, actual;
@@ -457,11 +457,11 @@ static int compat_drm_infobufs(struct file *file, unsigned int cmd,
             && !access_ok(VERIFY_WRITE, to, count * sizeof(drm_buf_desc32_t)))
                 return -EFAULT;
 
-        nbytes = sizeof(*request) + count * sizeof(drm_buf_desc_t);
+        nbytes = sizeof(*request) + count * sizeof(struct drm_buf_desc);
         request = compat_alloc_user_space(nbytes);
         if (!access_ok(VERIFY_WRITE, request, nbytes))
                 return -EFAULT;
-        list = (drm_buf_desc_t *) (request + 1);
+        list = (struct drm_buf_desc *) (request + 1);
 
         if (__put_user(count, &request->count)
             || __put_user(list, &request->list))
@@ -477,7 +477,7 @@ static int compat_drm_infobufs(struct file *file, unsigned int cmd,
         if (count >= actual)
                 for (i = 0; i < actual; ++i)
                         if (__copy_in_user(&to[i], &list[i],
-                                           offsetof(drm_buf_desc_t, flags)))
+                                           offsetof(struct drm_buf_desc, flags)))
                                 return -EFAULT;
 
         if (__put_user(actual, &argp->count))
@@ -505,8 +505,8 @@ static int compat_drm_mapbufs(struct file *file, unsigned int cmd,
         drm_buf_map32_t __user *argp = (void __user *)arg;
         drm_buf_map32_t req32;
         drm_buf_pub32_t __user *list32;
-        drm_buf_map_t __user *request;
-        drm_buf_pub_t __user *list;
+        struct drm_buf_map __user *request;
+        struct drm_buf_pub __user *list;
         int i, err;
         int count, actual;
         size_t nbytes;
@@ -519,11 +519,11 @@ static int compat_drm_mapbufs(struct file *file, unsigned int cmd,
 
         if (count < 0)
                 return -EINVAL;
-        nbytes = sizeof(*request) + count * sizeof(drm_buf_pub_t);
+        nbytes = sizeof(*request) + count * sizeof(struct drm_buf_pub);
         request = compat_alloc_user_space(nbytes);
         if (!access_ok(VERIFY_WRITE, request, nbytes))
                 return -EFAULT;
-        list = (drm_buf_pub_t *) (request + 1);
+        list = (struct drm_buf_pub *) (request + 1);
 
         if (__put_user(count, &request->count)
             || __put_user(list, &request->list))
@@ -539,7 +539,7 @@ static int compat_drm_mapbufs(struct file *file, unsigned int cmd,
         if (count >= actual)
                 for (i = 0; i < actual; ++i)
                         if (__copy_in_user(&list32[i], &list[i],
-                                           offsetof(drm_buf_pub_t, address))
+                                           offsetof(struct drm_buf_pub, address))
                             || __get_user(addr, &list[i].address)
                             || __put_user((unsigned long)addr,
                                           &list32[i].address))
@@ -562,7 +562,7 @@ static int compat_drm_freebufs(struct file *file, unsigned int cmd,
                                unsigned long arg)
 {
         drm_buf_free32_t req32;
-        drm_buf_free_t __user *request;
+        struct drm_buf_free __user *request;
         drm_buf_free32_t __user *argp = (void __user *)arg;
 
         if (copy_from_user(&req32, argp, sizeof(req32)))
@@ -589,7 +589,7 @@ static int compat_drm_setsareactx(struct file *file, unsigned int cmd,
                                   unsigned long arg)
 {
         drm_ctx_priv_map32_t req32;
-        drm_ctx_priv_map_t __user *request;
+        struct drm_ctx_priv_map __user *request;
         drm_ctx_priv_map32_t __user *argp = (void __user *)arg;
 
         if (copy_from_user(&req32, argp, sizeof(req32)))
@@ -610,7 +610,7 @@ static int compat_drm_setsareactx(struct file *file, unsigned int cmd,
 static int compat_drm_getsareactx(struct file *file, unsigned int cmd,
                                   unsigned long arg)
 {
-        drm_ctx_priv_map_t __user *request;
+        struct drm_ctx_priv_map __user *request;
         drm_ctx_priv_map32_t __user *argp = (void __user *)arg;
         int err;
         unsigned int ctx_id;
@@ -648,7 +648,7 @@ static int compat_drm_resctx(struct file *file, unsigned int cmd,
 {
         drm_ctx_res32_t __user *argp = (void __user *)arg;
         drm_ctx_res32_t res32;
-        drm_ctx_res_t __user *res;
+        struct drm_ctx_res __user *res;
         int err;
 
         if (copy_from_user(&res32, argp, sizeof(res32)))
@@ -658,7 +658,7 @@ static int compat_drm_resctx(struct file *file, unsigned int cmd,
         if (!access_ok(VERIFY_WRITE, res, sizeof(*res)))
                 return -EFAULT;
         if (__put_user(res32.count, &res->count)
-            || __put_user((drm_ctx_t __user *) (unsigned long)res32.contexts,
+            || __put_user((struct drm_ctx __user *) (unsigned long)res32.contexts,
                           &res->contexts))
                 return -EFAULT;
 
@@ -679,7 +679,7 @@ typedef struct drm_dma32 {
         int send_count;           /**< Number of buffers to send */
         u32 send_indices;         /**< List of handles to buffers */
         u32 send_sizes;           /**< Lengths of data to send */
-        drm_dma_flags_t flags;            /**< Flags */
+        enum drm_dma_flags flags;                 /**< Flags */
         int request_count;        /**< Number of buffers requested */
         int request_size;         /**< Desired size for buffers */
         u32 request_indices;      /**< Buffer information */
@@ -692,7 +692,7 @@ static int compat_drm_dma(struct file *file, unsigned int cmd,
 {
         drm_dma32_t d32;
         drm_dma32_t __user *argp = (void __user *)arg;
-        drm_dma_t __user *d;
+        struct drm_dma __user *d;
         int err;
 
         if (copy_from_user(&d32, argp, sizeof(d32)))
@@ -740,7 +740,7 @@ static int compat_drm_agp_enable(struct file *file, unsigned int cmd,
 {
         drm_agp_mode32_t __user *argp = (void __user *)arg;
         drm_agp_mode32_t m32;
-        drm_agp_mode_t __user *mode;
+        struct drm_agp_mode __user *mode;
 
         if (get_user(m32.mode, &argp->mode))
                 return -EFAULT;
@@ -772,7 +772,7 @@ static int compat_drm_agp_info(struct file *file, unsigned int cmd,
 {
         drm_agp_info32_t __user *argp = (void __user *)arg;
         drm_agp_info32_t i32;
-        drm_agp_info_t __user *info;
+        struct drm_agp_info __user *info;
         int err;
 
         info = compat_alloc_user_space(sizeof(*info));
@@ -813,7 +813,7 @@ static int compat_drm_agp_alloc(struct file *file, unsigned int cmd,
 {
         drm_agp_buffer32_t __user *argp = (void __user *)arg;
         drm_agp_buffer32_t req32;
-        drm_agp_buffer_t __user *request;
+        struct drm_agp_buffer __user *request;
         int err;
 
         if (copy_from_user(&req32, argp, sizeof(req32)))
@@ -845,7 +845,7 @@ static int compat_drm_agp_free(struct file *file, unsigned int cmd,
                                unsigned long arg)
 {
         drm_agp_buffer32_t __user *argp = (void __user *)arg;
-        drm_agp_buffer_t __user *request;
+        struct drm_agp_buffer __user *request;
         u32 handle;
 
         request = compat_alloc_user_space(sizeof(*request));
@@ -868,7 +868,7 @@ static int compat_drm_agp_bind(struct file *file, unsigned int cmd,
 {
         drm_agp_binding32_t __user *argp = (void __user *)arg;
         drm_agp_binding32_t req32;
-        drm_agp_binding_t __user *request;
+        struct drm_agp_binding __user *request;
 
         if (copy_from_user(&req32, argp, sizeof(req32)))
                 return -EFAULT;
@@ -887,7 +887,7 @@ static int compat_drm_agp_unbind(struct file *file, unsigned int cmd,
                                  unsigned long arg)
 {
         drm_agp_binding32_t __user *argp = (void __user *)arg;
-        drm_agp_binding_t __user *request;
+        struct drm_agp_binding __user *request;
         u32 handle;
 
         request = compat_alloc_user_space(sizeof(*request));
@@ -910,7 +910,7 @@ static int compat_drm_sg_alloc(struct file *file, unsigned int cmd,
                                unsigned long arg)
 {
         drm_scatter_gather32_t __user *argp = (void __user *)arg;
-        drm_scatter_gather_t __user *request;
+        struct drm_scatter_gather __user *request;
         int err;
         unsigned long x;
 
@@ -938,7 +938,7 @@ static int compat_drm_sg_free(struct file *file, unsigned int cmd,
                               unsigned long arg)
 {
         drm_scatter_gather32_t __user *argp = (void __user *)arg;
-        drm_scatter_gather_t __user *request;
+        struct drm_scatter_gather __user *request;
         unsigned long x;
 
         request = compat_alloc_user_space(sizeof(*request));
@@ -953,13 +953,13 @@ static int compat_drm_sg_free(struct file *file, unsigned int cmd,
 }
 
 struct drm_wait_vblank_request32 {
-        drm_vblank_seq_type_t type;
+        enum drm_vblank_seq_type type;
         unsigned int sequence;
         u32 signal;
 };
 
 struct drm_wait_vblank_reply32 {
-        drm_vblank_seq_type_t type;
+        enum drm_vblank_seq_type type;
         unsigned int sequence;
         s32 tval_sec;
         s32 tval_usec;
@@ -975,7 +975,7 @@ static int compat_drm_wait_vblank(struct file *file, unsigned int cmd,
 {
         drm_wait_vblank32_t __user *argp = (void __user *)arg;
         drm_wait_vblank32_t req32;
-        drm_wait_vblank_t __user *request;
+        union drm_wait_vblank __user *request;
         int err;
 
         if (copy_from_user(&req32, argp, sizeof(req32)))
diff --git a/drivers/char/drm/drm_ioctl.c b/drivers/char/drm/drm_ioctl.c
index 565895547d75..b195e102e737 100644
--- a/drivers/char/drm/drm_ioctl.c
+++ b/drivers/char/drm/drm_ioctl.c
@@ -52,10 +52,10 @@
 int drm_getunique(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_unique_t __user *argp = (void __user *)arg;
-        drm_unique_t u;
+        struct drm_file *priv = filp->private_data;
+        struct drm_device *dev = priv->head->dev;
+        struct drm_unique __user *argp = (void __user *)arg;
+        struct drm_unique u;
 
         if (copy_from_user(&u, argp, sizeof(u)))
                 return -EFAULT;
@@ -86,15 +86,15 @@ int drm_getunique(struct inode *inode, struct file *filp,
 int drm_setunique(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_unique_t u;
+        struct drm_file *priv = filp->private_data;
+        struct drm_device *dev = priv->head->dev;
+        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)
@@ -136,7 +136,7 @@ int drm_setunique(struct inode *inode, struct file *filp,
         return 0;
 }
 
-static int drm_set_busid(drm_device_t * dev)
+static int drm_set_busid(struct drm_device * dev)
 {
         int len;
 
@@ -184,11 +184,11 @@ static int drm_set_busid(drm_device_t * dev)
 int drm_getmap(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_map_t __user *argp = (void __user *)arg;
-        drm_map_t map;
-        drm_map_list_t *r_list = NULL;
+        struct drm_file *priv = filp->private_data;
+        struct drm_device *dev = priv->head->dev;
+        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;
@@ -204,9 +204,9 @@ int drm_getmap(struct inode *inode, struct file *filp,
         }
 
         i = 0;
-        list_for_each(list, &dev->maplist->head) {
+        list_for_each(list, &dev->maplist) {
                 if (i == idx) {
-                        r_list = list_entry(list, drm_map_list_t, head);
+                        r_list = list_entry(list, struct drm_map_list, head);
                         break;
                 }
                 i++;
@@ -245,11 +245,11 @@ int drm_getmap(struct inode *inode, struct file *filp,
 int drm_getclient(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_client_t __user *argp = (drm_client_t __user *)arg;
-        drm_client_t client;
-        drm_file_t *pt;
+        struct drm_file *priv = filp->private_data;
+        struct drm_device *dev = priv->head->dev;
+        struct drm_client __user *argp = (struct drm_client __user *)arg;
+        struct drm_client client;
+        struct drm_file *pt;
         int idx;
         int i;
 
@@ -257,12 +257,18 @@ int drm_getclient(struct inode *inode, struct file *filp,
                 return -EFAULT;
         idx = client.idx;
         mutex_lock(&dev->struct_mutex);
-        for (i = 0, pt = dev->file_first; i < idx && pt; i++, pt = pt->next) ;
-
-        if (!pt) {
+        
+        if (list_empty(&dev->filelist)) {
                 mutex_unlock(&dev->struct_mutex);
                 return -EINVAL;
         }
+
+        i = 0;
+        list_for_each_entry(pt, &dev->filelist, lhead) {
+                if (i++ >= idx)
+                        break;
+        }
+
         client.auth = pt->authenticated;
         client.pid = pt->pid;
         client.uid = pt->uid;
@@ -288,9 +294,9 @@ int drm_getclient(struct inode *inode, struct file *filp,
 int drm_getstats(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_stats_t stats;
+        struct drm_file *priv = filp->private_data;
+        struct drm_device *dev = priv->head->dev;
+        struct drm_stats stats;
         int i;
 
         memset(&stats, 0, sizeof(stats));
@@ -310,7 +316,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;
 }
@@ -329,10 +335,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;
         int ret;
 
         if (copy_from_user(&sv, argp, sizeof(sv)))
diff --git a/drivers/char/drm/drm_irq.c b/drivers/char/drm/drm_irq.c
index 2e75331fd83e..871d2fde09b3 100644
--- a/drivers/char/drm/drm_irq.c
+++ b/drivers/char/drm/drm_irq.c
@@ -53,10 +53,10 @@
 int drm_irq_by_busid(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_irq_busid_t __user *argp = (void __user *)arg;
-        drm_irq_busid_t p;
+        struct drm_file *priv = filp->private_data;
+        struct drm_device *dev = priv->head->dev;
+        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;
@@ -87,7 +87,7 @@ int drm_irq_by_busid(struct inode *inode, struct file *filp,
  * \c drm_driver_irq_preinstall() and \c drm_driver_irq_postinstall() functions
  * before and after the installation.
  */
-static int drm_irq_install(drm_device_t * dev)
+static int drm_irq_install(struct drm_device * dev)
 {
         int ret;
         unsigned long sh_flags = 0;
@@ -120,8 +120,8 @@ static int drm_irq_install(drm_device_t * dev)
 
                 spin_lock_init(&dev->vbl_lock);
 
-                INIT_LIST_HEAD(&dev->vbl_sigs.head);
-                INIT_LIST_HEAD(&dev->vbl_sigs2.head);
+                INIT_LIST_HEAD(&dev->vbl_sigs);
+                INIT_LIST_HEAD(&dev->vbl_sigs2);
 
                 dev->vbl_pending = 0;
         }
@@ -155,7 +155,7 @@ static int drm_irq_install(drm_device_t * dev)
  *
  * Calls the driver's \c drm_driver_irq_uninstall() function, and stops the irq.
  */
-int drm_irq_uninstall(drm_device_t * dev)
+int drm_irq_uninstall(struct drm_device * dev)
 {
         int irq_enabled;
 
@@ -197,13 +197,13 @@ EXPORT_SYMBOL(drm_irq_uninstall);
 int drm_control(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_control_t ctl;
+        struct drm_file *priv = filp->private_data;
+        struct drm_device *dev = priv->head->dev;
+        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,10 +244,10 @@ int drm_control(struct inode *inode, struct file *filp,
  */
 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;
+        struct drm_file *priv = filp->private_data;
+        struct drm_device *dev = priv->head->dev;
+        union drm_wait_vblank __user *argp = (void __user *)data;
+        union drm_wait_vblank vblwait;
         struct timeval now;
         int ret = 0;
         unsigned int flags, seq;
@@ -292,9 +292,9 @@ int drm_wait_vblank(DRM_IOCTL_ARGS)
 
         if (flags & _DRM_VBLANK_SIGNAL) {
                 unsigned long irqflags;
-                drm_vbl_sig_t *vbl_sigs = (flags & _DRM_VBLANK_SECONDARY)
+                struct list_head *vbl_sigs = (flags & _DRM_VBLANK_SECONDARY)
                                       ? &dev->vbl_sigs2 : &dev->vbl_sigs;
-                drm_vbl_sig_t *vbl_sig;
+                struct drm_vbl_sig *vbl_sig;
 
                 spin_lock_irqsave(&dev->vbl_lock, irqflags);
 
@@ -302,7 +302,7 @@ int drm_wait_vblank(DRM_IOCTL_ARGS)
                  * for the same vblank sequence number; nothing to be done in
                  * that case
                  */
-                list_for_each_entry(vbl_sig, &vbl_sigs->head, head) {
+                list_for_each_entry(vbl_sig, vbl_sigs, head) {
                         if (vbl_sig->sequence == vblwait.request.sequence
                             && vbl_sig->info.si_signo == vblwait.request.signal
                             && vbl_sig->task == current) {
@@ -324,7 +324,7 @@ int drm_wait_vblank(DRM_IOCTL_ARGS)
 
                 if (!
                     (vbl_sig =
-                     drm_alloc(sizeof(drm_vbl_sig_t), DRM_MEM_DRIVER))) {
+                     drm_alloc(sizeof(struct drm_vbl_sig), DRM_MEM_DRIVER))) {
                         return -ENOMEM;
                 }
 
@@ -336,7 +336,7 @@ int drm_wait_vblank(DRM_IOCTL_ARGS)
 
                 spin_lock_irqsave(&dev->vbl_lock, irqflags);
 
-                list_add_tail((struct list_head *)vbl_sig, &vbl_sigs->head);
+                list_add_tail(&vbl_sig->head, vbl_sigs);
 
                 spin_unlock_irqrestore(&dev->vbl_lock, irqflags);
 
@@ -371,7 +371,7 @@ int drm_wait_vblank(DRM_IOCTL_ARGS)
  *
  * If a signal is not requested, then calls vblank_wait().
  */
-void drm_vbl_send_signals(drm_device_t * dev)
+void drm_vbl_send_signals(struct drm_device * dev)
 {
         unsigned long flags;
         int i;
@@ -379,20 +379,18 @@ void drm_vbl_send_signals(drm_device_t * dev)
         spin_lock_irqsave(&dev->vbl_lock, flags);
 
         for (i = 0; i < 2; i++) {
-                struct list_head *list, *tmp;
-                drm_vbl_sig_t *vbl_sig;
-                drm_vbl_sig_t *vbl_sigs = i ? &dev->vbl_sigs2 : &dev->vbl_sigs;
+                struct drm_vbl_sig *vbl_sig, *tmp;
+                struct list_head *vbl_sigs = i ? &dev->vbl_sigs2 : &dev->vbl_sigs;
                 unsigned int vbl_seq = atomic_read(i ? &dev->vbl_received2 :
                                                    &dev->vbl_received);
 
-                list_for_each_safe(list, tmp, &vbl_sigs->head) {
-                        vbl_sig = list_entry(list, drm_vbl_sig_t, head);
+                list_for_each_entry_safe(vbl_sig, tmp, vbl_sigs, head) {
                         if ((vbl_seq - vbl_sig->sequence) <= (1 << 23)) {
                                 vbl_sig->info.si_code = vbl_seq;
                                 send_sig_info(vbl_sig->info.si_signo,
                                               &vbl_sig->info, vbl_sig->task);
 
-                                list_del(list);
+                                list_del(&vbl_sig->head);
 
                                 drm_free(vbl_sig, sizeof(*vbl_sig),
                                          DRM_MEM_DRIVER);
@@ -418,7 +416,7 @@ EXPORT_SYMBOL(drm_vbl_send_signals);
  */
 static void drm_locked_tasklet_func(unsigned long data)
 {
-        drm_device_t *dev = (drm_device_t*)data;
+        struct drm_device *dev = (struct drm_device *)data;
         unsigned long irqflags;
 
         spin_lock_irqsave(&dev->tasklet_lock, irqflags);
@@ -455,7 +453,7 @@ static void drm_locked_tasklet_func(unsigned long data)
  * context, it must not make any assumptions about this. Also, the HW lock will
  * be held with the kernel context or any client context.
  */
-void drm_locked_tasklet(drm_device_t *dev, void (*func)(drm_device_t*))
+void drm_locked_tasklet(struct drm_device *dev, void (*func)(struct drm_device *))
 {
         unsigned long irqflags;
         static DECLARE_TASKLET(drm_tasklet, drm_locked_tasklet_func, 0);
diff --git a/drivers/char/drm/drm_lock.c b/drivers/char/drm/drm_lock.c
index befd1af19dfe..c0534b5a8b78 100644
--- a/drivers/char/drm/drm_lock.c
+++ b/drivers/char/drm/drm_lock.c
@@ -51,15 +51,15 @@ static int drm_notifier(void *priv);
 int drm_lock(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;
+        struct drm_file *priv = filp->private_data;
+        struct drm_device *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) {
@@ -152,12 +152,12 @@ int drm_lock(struct inode *inode, struct file *filp,
 int drm_unlock(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_lock_t lock;
+        struct drm_file *priv = filp->private_data;
+        struct drm_device *dev = priv->head->dev;
+        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) {
@@ -202,7 +202,7 @@ int drm_unlock(struct inode *inode, struct file *filp,
  *
  * Attempt to mark the lock as held by the given context, via the \p cmpxchg instruction.
  */
-int drm_lock_take(drm_lock_data_t *lock_data,
+int drm_lock_take(struct drm_lock_data *lock_data,
                   unsigned int context)
 {
         unsigned int old, new, prev;
@@ -251,7 +251,7 @@ int drm_lock_take(drm_lock_data_t *lock_data,
  * Resets the lock file pointer.
  * Marks the lock as held by the given context, via the \p cmpxchg instruction.
  */
-static int drm_lock_transfer(drm_lock_data_t *lock_data,
+static int drm_lock_transfer(struct drm_lock_data *lock_data,
                              unsigned int context)
 {
         unsigned int old, new, prev;
@@ -277,7 +277,7 @@ static int drm_lock_transfer(drm_lock_data_t *lock_data,
  * Marks the lock as not held, via the \p cmpxchg instruction. Wakes any task
  * waiting on the lock queue.
  */
-int drm_lock_free(drm_lock_data_t *lock_data, unsigned int context)
+int drm_lock_free(struct drm_lock_data *lock_data, unsigned int context)
 {
         unsigned int old, new, prev;
         volatile unsigned int *lock = &lock_data->hw_lock->lock;
@@ -319,7 +319,7 @@ int drm_lock_free(drm_lock_data_t *lock_data, unsigned int context)
  */
 static int drm_notifier(void *priv)
 {
-        drm_sigdata_t *s = (drm_sigdata_t *) priv;
+        struct drm_sigdata *s = (struct drm_sigdata *) priv;
         unsigned int old, new, prev;
 
         /* Allow signal delivery if lock isn't held */
@@ -350,7 +350,7 @@ static int drm_notifier(void *priv)
  * having to worry about starvation.
  */
 
-void drm_idlelock_take(drm_lock_data_t *lock_data)
+void drm_idlelock_take(struct drm_lock_data *lock_data)
 {
         int ret = 0;
 
@@ -369,7 +369,7 @@ void drm_idlelock_take(drm_lock_data_t *lock_data)
 }
 EXPORT_SYMBOL(drm_idlelock_take);
 
-void drm_idlelock_release(drm_lock_data_t *lock_data)
+void drm_idlelock_release(struct drm_lock_data *lock_data)
 {
         unsigned int old, prev;
         volatile unsigned int *lock = &lock_data->hw_lock->lock;
diff --git a/drivers/char/drm/drm_memory.c b/drivers/char/drm/drm_memory.c
index 92a867082376..93019901bd30 100644
--- a/drivers/char/drm/drm_memory.c
+++ b/drivers/char/drm/drm_memory.c
@@ -80,7 +80,7 @@ void *drm_realloc(void *oldpt, size_t oldsize, size_t size, int area)
 
 #if __OS_HAS_AGP
 static void *agp_remap(unsigned long offset, unsigned long size,
-                       drm_device_t * dev)
+                       struct drm_device * dev)
 {
         unsigned long *phys_addr_map, i, num_pages =
             PAGE_ALIGN(size) / PAGE_SIZE;
@@ -94,7 +94,7 @@ static void *agp_remap(unsigned long offset, unsigned long size,
         offset -= dev->hose->mem_space->start;
 #endif
 
-        for (agpmem = dev->agp->memory; agpmem; agpmem = agpmem->next)
+        list_for_each_entry(agpmem, &dev->agp->memory, head)
                 if (agpmem->bound <= offset
                     && (agpmem->bound + (agpmem->pages << PAGE_SHIFT)) >=
                     (offset + size))
@@ -123,7 +123,7 @@ static void *agp_remap(unsigned long offset, unsigned long size,
 }
 
 /** Wrapper around agp_allocate_memory() */
-DRM_AGP_MEM *drm_alloc_agp(drm_device_t * dev, int pages, u32 type)
+DRM_AGP_MEM *drm_alloc_agp(struct drm_device * dev, int pages, u32 type)
 {
         return drm_agp_allocate_memory(dev->agp->bridge, pages, type);
 }
@@ -148,7 +148,7 @@ int drm_unbind_agp(DRM_AGP_MEM * handle)
 
 #else  /*  __OS_HAS_AGP  */
 static inline void *agp_remap(unsigned long offset, unsigned long size,
-                              drm_device_t * dev)
+                              struct drm_device * dev)
 {
         return NULL;
 }
diff --git a/drivers/char/drm/drm_mm.c b/drivers/char/drm/drm_mm.c
index 2ec1d9f26264..3e6bc14f7441 100644
--- a/drivers/char/drm/drm_mm.c
+++ b/drivers/char/drm/drm_mm.c
@@ -44,26 +44,26 @@
 #include "drmP.h"
 #include <linux/slab.h>
 
-unsigned long drm_mm_tail_space(drm_mm_t *mm)
+unsigned long drm_mm_tail_space(struct drm_mm *mm)
 {
         struct list_head *tail_node;
-        drm_mm_node_t *entry;
+        struct drm_mm_node *entry;
 
         tail_node = mm->ml_entry.prev;
-        entry = list_entry(tail_node, drm_mm_node_t, ml_entry);
+        entry = list_entry(tail_node, struct drm_mm_node, ml_entry);
         if (!entry->free)
                 return 0;
 
         return entry->size;
 }
 
-int drm_mm_remove_space_from_tail(drm_mm_t *mm, unsigned long size)
+int drm_mm_remove_space_from_tail(struct drm_mm *mm, unsigned long size)
 {
         struct list_head *tail_node;
-        drm_mm_node_t *entry;
+        struct drm_mm_node *entry;
 
         tail_node = mm->ml_entry.prev;
-        entry = list_entry(tail_node, drm_mm_node_t, ml_entry);
+        entry = list_entry(tail_node, struct drm_mm_node, ml_entry);
         if (!entry->free)
                 return -ENOMEM;
 
@@ -75,13 +75,13 @@ int drm_mm_remove_space_from_tail(drm_mm_t *mm, unsigned long size)
 }
 
 
-static int drm_mm_create_tail_node(drm_mm_t *mm,
+static int drm_mm_create_tail_node(struct drm_mm *mm,
                             unsigned long start,
                             unsigned long size)
 {
-        drm_mm_node_t *child;
+        struct drm_mm_node *child;
 
-        child = (drm_mm_node_t *)
+        child = (struct drm_mm_node *)
                 drm_alloc(sizeof(*child), DRM_MEM_MM);
         if (!child)
                 return -ENOMEM;
@@ -98,13 +98,13 @@ static int drm_mm_create_tail_node(drm_mm_t *mm,
 }
 
 
-int drm_mm_add_space_to_tail(drm_mm_t *mm, unsigned long size)
+int drm_mm_add_space_to_tail(struct drm_mm *mm, unsigned long size)
 {
         struct list_head *tail_node;
-        drm_mm_node_t *entry;
+        struct drm_mm_node *entry;
 
         tail_node = mm->ml_entry.prev;
-        entry = list_entry(tail_node, drm_mm_node_t, ml_entry);
+        entry = list_entry(tail_node, struct drm_mm_node, ml_entry);
         if (!entry->free) {
                 return drm_mm_create_tail_node(mm, entry->start + entry->size, size);
         }
@@ -112,12 +112,12 @@ int drm_mm_add_space_to_tail(drm_mm_t *mm, unsigned long size)
         return 0;
 }
 
-static drm_mm_node_t *drm_mm_split_at_start(drm_mm_node_t *parent,
+static struct drm_mm_node *drm_mm_split_at_start(struct drm_mm_node *parent,
                                             unsigned long size)
 {
-        drm_mm_node_t *child;
+        struct drm_mm_node *child;
 
-        child = (drm_mm_node_t *)
+        child = (struct drm_mm_node *)
                 drm_alloc(sizeof(*child), DRM_MEM_MM);
         if (!child)
                 return NULL;
@@ -139,12 +139,12 @@ static drm_mm_node_t *drm_mm_split_at_start(drm_mm_node_t *parent,
 
 
 
-drm_mm_node_t *drm_mm_get_block(drm_mm_node_t * parent,
+struct drm_mm_node *drm_mm_get_block(struct drm_mm_node * parent,
                                 unsigned long size, unsigned alignment)
 {
 
-        drm_mm_node_t *align_splitoff = NULL;
-        drm_mm_node_t *child;
+        struct drm_mm_node *align_splitoff = NULL;
+        struct drm_mm_node *child;
         unsigned tmp = 0;
 
         if (alignment)
@@ -175,26 +175,26 @@ drm_mm_node_t *drm_mm_get_block(drm_mm_node_t * parent,
  * Otherwise add to the free stack.
  */
 
-void drm_mm_put_block(drm_mm_node_t * cur)
+void drm_mm_put_block(struct drm_mm_node * cur)
 {
 
-        drm_mm_t *mm = cur->mm;
+        struct drm_mm *mm = cur->mm;
         struct list_head *cur_head = &cur->ml_entry;
         struct list_head *root_head = &mm->ml_entry;
-        drm_mm_node_t *prev_node = NULL;
-        drm_mm_node_t *next_node;
+        struct drm_mm_node *prev_node = NULL;
+        struct drm_mm_node *next_node;
 
         int merged = 0;
 
         if (cur_head->prev != root_head) {
-                prev_node = list_entry(cur_head->prev, drm_mm_node_t, ml_entry);
+                prev_node = list_entry(cur_head->prev, struct drm_mm_node, ml_entry);
                 if (prev_node->free) {
                         prev_node->size += cur->size;
                         merged = 1;
                 }
         }
         if (cur_head->next != root_head) {
-                next_node = list_entry(cur_head->next, drm_mm_node_t, ml_entry);
+                next_node = list_entry(cur_head->next, struct drm_mm_node, ml_entry);
                 if (next_node->free) {
                         if (merged) {
                                 prev_node->size += next_node->size;
@@ -218,14 +218,14 @@ void drm_mm_put_block(drm_mm_node_t * cur)
         }
 }
 
-drm_mm_node_t *drm_mm_search_free(const drm_mm_t * mm,
+struct drm_mm_node *drm_mm_search_free(const struct drm_mm * mm,
                                   unsigned long size,
                                   unsigned alignment, int best_match)
 {
         struct list_head *list;
         const struct list_head *free_stack = &mm->fl_entry;
-        drm_mm_node_t *entry;
-        drm_mm_node_t *best;
+        struct drm_mm_node *entry;
+        struct drm_mm_node *best;
         unsigned long best_size;
         unsigned wasted;
 
@@ -233,7 +233,7 @@ drm_mm_node_t *drm_mm_search_free(const drm_mm_t * mm,
         best_size = ~0UL;
 
         list_for_each(list, free_stack) {
-                entry = list_entry(list, drm_mm_node_t, fl_entry);
+                entry = list_entry(list, struct drm_mm_node, fl_entry);
                 wasted = 0;
 
                 if (entry->size < size)
@@ -259,14 +259,14 @@ drm_mm_node_t *drm_mm_search_free(const drm_mm_t * mm,
         return best;
 }
 
-int drm_mm_clean(drm_mm_t * mm)
+int drm_mm_clean(struct drm_mm * mm)
 {
         struct list_head *head = &mm->ml_entry;
 
         return (head->next->next == head);
 }
 
-int drm_mm_init(drm_mm_t * mm, unsigned long start, unsigned long size)
+int drm_mm_init(struct drm_mm * mm, unsigned long start, unsigned long size)
 {
         INIT_LIST_HEAD(&mm->ml_entry);
         INIT_LIST_HEAD(&mm->fl_entry);
@@ -275,12 +275,12 @@ int drm_mm_init(drm_mm_t * mm, unsigned long start, unsigned long size)
 }
 
 
-void drm_mm_takedown(drm_mm_t * mm)
+void drm_mm_takedown(struct drm_mm * mm)
 {
         struct list_head *bnode = mm->fl_entry.next;
-        drm_mm_node_t *entry;
+        struct drm_mm_node *entry;
 
-        entry = list_entry(bnode, drm_mm_node_t, fl_entry);
+        entry = list_entry(bnode, struct drm_mm_node, fl_entry);
 
         if (entry->ml_entry.next != &mm->ml_entry ||
             entry->fl_entry.next != &mm->fl_entry) {
diff --git a/drivers/char/drm/drm_os_linux.h b/drivers/char/drm/drm_os_linux.h
index 0fe7b4497927..0b8d3433386d 100644
--- a/drivers/char/drm/drm_os_linux.h
+++ b/drivers/char/drm/drm_os_linux.h
@@ -34,8 +34,8 @@
 /** Read/write memory barrier */
 #define DRM_MEMORYBARRIER()             mb()
 /** DRM device local declaration */
-#define DRM_DEVICE      drm_file_t      *priv   = filp->private_data; \
-                        drm_device_t    *dev    = priv->head->dev
+#define DRM_DEVICE      struct drm_file *priv   = filp->private_data; \
+                        struct drm_device *dev  = priv->head->dev
 
 /** IRQ handler arguments and return type and values */
 #define DRM_IRQ_ARGS            int irq, void *arg
@@ -96,24 +96,6 @@ static __inline__ int mtrr_del(int reg, unsigned long base, unsigned long size)
 
 #define DRM_GET_PRIV_WITH_RETURN(_priv, _filp) _priv = _filp->private_data
 
-/**
- * Get the pointer to the SAREA.
- *
- * Searches the SAREA on the mapping lists and points drm_device::sarea to it.
- */
-#define DRM_GETSAREA()                                                   \
-do {                                                                     \
-        drm_map_list_t *entry;                                           \
-        list_for_each_entry( entry, &dev->maplist->head, head ) {        \
-                if ( entry->map &&                                       \
-                     entry->map->type == _DRM_SHM &&                     \
-                     (entry->map->flags & _DRM_CONTAINS_LOCK) ) {        \
-                        dev_priv->sarea = entry->map;                    \
-                        break;                                           \
-                }                                                        \
-        }                                                                \
-} while (0)
-
 #define DRM_HZ HZ
 
 #define DRM_WAIT_ON( ret, queue, timeout, condition )           \
diff --git a/drivers/char/drm/drm_pci.c b/drivers/char/drm/drm_pci.c
index 86a0f1c22091..e292bb0eaca2 100644
--- a/drivers/char/drm/drm_pci.c
+++ b/drivers/char/drm/drm_pci.c
@@ -47,7 +47,7 @@
 /**
  * \brief Allocate a PCI consistent memory block, for DMA.
  */
-drm_dma_handle_t *drm_pci_alloc(drm_device_t * dev, size_t size, size_t align,
+drm_dma_handle_t *drm_pci_alloc(struct drm_device * dev, size_t size, size_t align,
                                 dma_addr_t maxaddr)
 {
         drm_dma_handle_t *dmah;
@@ -126,7 +126,7 @@ EXPORT_SYMBOL(drm_pci_alloc);
  *
  * This function is for internal use in the Linux-specific DRM core code.
  */
-void __drm_pci_free(drm_device_t * dev, drm_dma_handle_t * dmah)
+void __drm_pci_free(struct drm_device * dev, drm_dma_handle_t * dmah)
 {
 #if 1
         unsigned long addr;
@@ -172,7 +172,7 @@ void __drm_pci_free(drm_device_t * dev, drm_dma_handle_t * dmah)
 /**
  * \brief Free a PCI consistent memory block
  */
-void drm_pci_free(drm_device_t * dev, drm_dma_handle_t * dmah)
+void drm_pci_free(struct drm_device * dev, drm_dma_handle_t * dmah)
 {
         __drm_pci_free(dev, dmah);
         kfree(dmah);
diff --git a/drivers/char/drm/drm_proc.c b/drivers/char/drm/drm_proc.c
index b204498d1a28..12dfea89c7f3 100644
--- a/drivers/char/drm/drm_proc.c
+++ b/drivers/char/drm/drm_proc.c
@@ -87,7 +87,7 @@ static struct drm_proc_list {
  * "/proc/dri/%minor%/", and each entry in proc_list as
  * "/proc/dri/%minor%/%name%".
  */
-int drm_proc_init(drm_device_t * dev, int minor,
+int drm_proc_init(struct drm_device * dev, int minor,
                   struct proc_dir_entry *root, struct proc_dir_entry **dev_root)
 {
         struct proc_dir_entry *ent;
@@ -163,7 +163,7 @@ int drm_proc_cleanup(int minor, struct proc_dir_entry *root,
 static int drm_name_info(char *buf, char **start, off_t offset, int request,
                          int *eof, void *data)
 {
-        drm_device_t *dev = (drm_device_t *) data;
+        struct drm_device *dev = (struct drm_device *) data;
         int len = 0;
 
         if (offset > DRM_PROC_LIMIT) {
@@ -205,11 +205,10 @@ static int drm_name_info(char *buf, char **start, off_t offset, int request,
 static int drm__vm_info(char *buf, char **start, off_t offset, int request,
                         int *eof, void *data)
 {
-        drm_device_t *dev = (drm_device_t *) data;
+        struct drm_device *dev = (struct drm_device *) data;
         int len = 0;
-        drm_map_t *map;
-        drm_map_list_t *r_list;
-        struct list_head *list;
+        struct drm_map *map;
+        struct drm_map_list *r_list;
 
         /* Hardcoded from _DRM_FRAME_BUFFER,
            _DRM_REGISTERS, _DRM_SHM, _DRM_AGP, and
@@ -229,9 +228,7 @@ static int drm__vm_info(char *buf, char **start, off_t offset, int request,
         DRM_PROC_PRINT("slot     offset       size type flags    "
                        "address mtrr\n\n");
         i = 0;
-        if (dev->maplist != NULL)
-                list_for_each(list, &dev->maplist->head) {
-                r_list = list_entry(list, drm_map_list_t, head);
+        list_for_each_entry(r_list, &dev->maplist, head) {
                 map = r_list->map;
                 if (!map)
                         continue;
@@ -242,14 +239,15 @@ static int drm__vm_info(char *buf, char **start, off_t offset, int request,
                 DRM_PROC_PRINT("%4d 0x%08lx 0x%08lx %4.4s  0x%02x 0x%08x ",
                                i,
                                map->offset,
-                               map->size, type, map->flags, r_list->user_token);
+                               map->size, type, map->flags,
+                               r_list->user_token);
                 if (map->mtrr < 0) {
                         DRM_PROC_PRINT("none\n");
                 } else {
                         DRM_PROC_PRINT("%4d\n", map->mtrr);
                 }
                 i++;
-                }
+        }
 
         if (len > request + offset)
                 return request;
@@ -263,7 +261,7 @@ static int drm__vm_info(char *buf, char **start, off_t offset, int request,
 static int drm_vm_info(char *buf, char **start, off_t offset, int request,
                        int *eof, void *data)
 {
-        drm_device_t *dev = (drm_device_t *) data;
+        struct drm_device *dev = (struct drm_device *) data;
         int ret;
 
         mutex_lock(&dev->struct_mutex);
@@ -286,10 +284,10 @@ static int drm_vm_info(char *buf, char **start, off_t offset, int request,
 static int drm__queues_info(char *buf, char **start, off_t offset,
                             int request, int *eof, void *data)
 {
-        drm_device_t *dev = (drm_device_t *) data;
+        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;
@@ -336,7 +334,7 @@ static int drm__queues_info(char *buf, char **start, off_t offset,
 static int drm_queues_info(char *buf, char **start, off_t offset, int request,
                            int *eof, void *data)
 {
-        drm_device_t *dev = (drm_device_t *) data;
+        struct drm_device *dev = (struct drm_device *) data;
         int ret;
 
         mutex_lock(&dev->struct_mutex);
@@ -359,9 +357,9 @@ static int drm_queues_info(char *buf, char **start, off_t offset, int request,
 static int drm__bufs_info(char *buf, char **start, off_t offset, int request,
                           int *eof, void *data)
 {
-        drm_device_t *dev = (drm_device_t *) data;
+        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) {
@@ -408,7 +406,7 @@ static int drm__bufs_info(char *buf, char **start, off_t offset, int request,
 static int drm_bufs_info(char *buf, char **start, off_t offset, int request,
                          int *eof, void *data)
 {
-        drm_device_t *dev = (drm_device_t *) data;
+        struct drm_device *dev = (struct drm_device *) data;
         int ret;
 
         mutex_lock(&dev->struct_mutex);
@@ -431,9 +429,9 @@ static int drm_bufs_info(char *buf, char **start, off_t offset, int request,
 static int drm__clients_info(char *buf, char **start, off_t offset,
                              int request, int *eof, void *data)
 {
-        drm_device_t *dev = (drm_device_t *) data;
+        struct drm_device *dev = (struct drm_device *) data;
         int len = 0;
-        drm_file_t *priv;
+        struct drm_file *priv;
 
         if (offset > DRM_PROC_LIMIT) {
                 *eof = 1;
@@ -444,7 +442,7 @@ static int drm__clients_info(char *buf, char **start, off_t offset,
         *eof = 0;
 
         DRM_PROC_PRINT("a dev   pid    uid      magic     ioctls\n\n");
-        for (priv = dev->file_first; priv; priv = priv->next) {
+        list_for_each_entry(priv, &dev->filelist, lhead) {
                 DRM_PROC_PRINT("%c %3d %5d %5d %10u %10lu\n",
                                priv->authenticated ? 'y' : 'n',
                                priv->minor,
@@ -464,7 +462,7 @@ static int drm__clients_info(char *buf, char **start, off_t offset,
 static int drm_clients_info(char *buf, char **start, off_t offset,
                             int request, int *eof, void *data)
 {
-        drm_device_t *dev = (drm_device_t *) data;
+        struct drm_device *dev = (struct drm_device *) data;
         int ret;
 
         mutex_lock(&dev->struct_mutex);
@@ -478,9 +476,9 @@ static int drm_clients_info(char *buf, char **start, off_t offset,
 static int drm__vma_info(char *buf, char **start, off_t offset, int request,
                          int *eof, void *data)
 {
-        drm_device_t *dev = (drm_device_t *) data;
+        struct drm_device *dev = (struct drm_device *) data;
         int len = 0;
-        drm_vma_entry_t *pt;
+        struct drm_vma_entry *pt;
         struct vm_area_struct *vma;
 #if defined(__i386__)
         unsigned int pgprot;
@@ -497,7 +495,7 @@ static int drm__vma_info(char *buf, char **start, off_t offset, int request,
         DRM_PROC_PRINT("vma use count: %d, high_memory = %p, 0x%08lx\n",
                        atomic_read(&dev->vma_count),
                        high_memory, virt_to_phys(high_memory));
-        for (pt = dev->vmalist; pt; pt = pt->next) {
+        list_for_each_entry(pt, &dev->vmalist, head) {
                 if (!(vma = pt->vma))
                         continue;
                 DRM_PROC_PRINT("\n%5d 0x%08lx-0x%08lx %c%c%c%c%c%c 0x%08lx000",
@@ -537,7 +535,7 @@ static int drm__vma_info(char *buf, char **start, off_t offset, int request,
 static int drm_vma_info(char *buf, char **start, off_t offset, int request,
                         int *eof, void *data)
 {
-        drm_device_t *dev = (drm_device_t *) data;
+        struct drm_device *dev = (struct drm_device *) data;
         int ret;
 
         mutex_lock(&dev->struct_mutex);
diff --git a/drivers/char/drm/drm_sarea.h b/drivers/char/drm/drm_sarea.h
index e94297b751b8..f5466966081e 100644
--- a/drivers/char/drm/drm_sarea.h
+++ b/drivers/char/drm/drm_sarea.h
@@ -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_ */
diff --git a/drivers/char/drm/drm_scatter.c b/drivers/char/drm/drm_scatter.c
index 06ef7ddbe67d..067d25daaf17 100644
--- a/drivers/char/drm/drm_scatter.c
+++ b/drivers/char/drm/drm_scatter.c
@@ -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;
@@ -65,11 +65,11 @@ void drm_sg_cleanup(drm_sg_mem_t * entry)
 int drm_sg_alloc(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_scatter_gather_t __user *argp = (void __user *)arg;
-        drm_scatter_gather_t request;
-        drm_sg_mem_t *entry;
+        struct drm_file *priv = filp->private_data;
+        struct drm_device *dev = priv->head->dev;
+        struct drm_scatter_gather __user *argp = (void __user *)arg;
+        struct drm_scatter_gather request;
+        struct drm_sg_mem *entry;
         unsigned long pages, i, j;
 
         DRM_DEBUG("%s\n", __FUNCTION__);
@@ -201,16 +201,16 @@ int drm_sg_alloc(struct inode *inode, struct file *filp,
 int drm_sg_free(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_scatter_gather_t request;
-        drm_sg_mem_t *entry;
+        struct drm_file *priv = filp->private_data;
+        struct drm_device *dev = priv->head->dev;
+        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;
 
diff --git a/drivers/char/drm/drm_sman.c b/drivers/char/drm/drm_sman.c
index e15db6d6bea9..8421a93946d8 100644
--- a/drivers/char/drm/drm_sman.c
+++ b/drivers/char/drm/drm_sman.c
@@ -38,13 +38,13 @@
 
 #include "drm_sman.h"
 
-typedef struct drm_owner_item {
-        drm_hash_item_t owner_hash;
+struct drm_owner_item {
+        struct drm_hash_item owner_hash;
         struct list_head sman_list;
         struct list_head mem_blocks;
-} drm_owner_item_t;
+};
 
-void drm_sman_takedown(drm_sman_t * sman)
+void drm_sman_takedown(struct drm_sman * sman)
 {
         drm_ht_remove(&sman->user_hash_tab);
         drm_ht_remove(&sman->owner_hash_tab);
@@ -56,12 +56,12 @@ void drm_sman_takedown(drm_sman_t * sman)
 EXPORT_SYMBOL(drm_sman_takedown);
 
 int
-drm_sman_init(drm_sman_t * sman, unsigned int num_managers,
+drm_sman_init(struct drm_sman * sman, unsigned int num_managers,
               unsigned int user_order, unsigned int owner_order)
 {
         int ret = 0;
 
-        sman->mm = (drm_sman_mm_t *) drm_calloc(num_managers, sizeof(*sman->mm),
+        sman->mm = (struct drm_sman_mm *) drm_calloc(num_managers, sizeof(*sman->mm),
                                                 DRM_MEM_MM);
         if (!sman->mm) {
                 ret = -ENOMEM;
@@ -88,8 +88,8 @@ EXPORT_SYMBOL(drm_sman_init);
 static void *drm_sman_mm_allocate(void *private, unsigned long size,
                                   unsigned alignment)
 {
-        drm_mm_t *mm = (drm_mm_t *) private;
-        drm_mm_node_t *tmp;
+        struct drm_mm *mm = (struct drm_mm *) private;
+        struct drm_mm_node *tmp;
 
         tmp = drm_mm_search_free(mm, size, alignment, 1);
         if (!tmp) {
@@ -101,30 +101,30 @@ static void *drm_sman_mm_allocate(void *private, unsigned long size,
 
 static void drm_sman_mm_free(void *private, void *ref)
 {
-        drm_mm_node_t *node = (drm_mm_node_t *) ref;
+        struct drm_mm_node *node = (struct drm_mm_node *) ref;
 
         drm_mm_put_block(node);
 }
 
 static void drm_sman_mm_destroy(void *private)
 {
-        drm_mm_t *mm = (drm_mm_t *) private;
+        struct drm_mm *mm = (struct drm_mm *) private;
         drm_mm_takedown(mm);
         drm_free(mm, sizeof(*mm), DRM_MEM_MM);
 }
 
 static unsigned long drm_sman_mm_offset(void *private, void *ref)
 {
-        drm_mm_node_t *node = (drm_mm_node_t *) ref;
+        struct drm_mm_node *node = (struct drm_mm_node *) ref;
         return node->start;
 }
 
 int
-drm_sman_set_range(drm_sman_t * sman, unsigned int manager,
+drm_sman_set_range(struct drm_sman * sman, unsigned int manager,
                    unsigned long start, unsigned long size)
 {
-        drm_sman_mm_t *sman_mm;
-        drm_mm_t *mm;
+        struct drm_sman_mm *sman_mm;
+        struct drm_mm *mm;
         int ret;
 
         BUG_ON(manager >= sman->num_managers);
@@ -153,8 +153,8 @@ drm_sman_set_range(drm_sman_t * sman, unsigned int manager,
 EXPORT_SYMBOL(drm_sman_set_range);
 
 int
-drm_sman_set_manager(drm_sman_t * sman, unsigned int manager,
-                     drm_sman_mm_t * allocator)
+drm_sman_set_manager(struct drm_sman * sman, unsigned int manager,
+                     struct drm_sman_mm * allocator)
 {
         BUG_ON(manager >= sman->num_managers);
         sman->mm[manager] = *allocator;
@@ -163,16 +163,16 @@ drm_sman_set_manager(drm_sman_t * sman, unsigned int manager,
 }
 EXPORT_SYMBOL(drm_sman_set_manager);
 
-static drm_owner_item_t *drm_sman_get_owner_item(drm_sman_t * sman,
+static struct drm_owner_item *drm_sman_get_owner_item(struct drm_sman * sman,
                                                  unsigned long owner)
 {
         int ret;
-        drm_hash_item_t *owner_hash_item;
-        drm_owner_item_t *owner_item;
+        struct drm_hash_item *owner_hash_item;
+        struct drm_owner_item *owner_item;
 
         ret = drm_ht_find_item(&sman->owner_hash_tab, owner, &owner_hash_item);
         if (!ret) {
-                return drm_hash_entry(owner_hash_item, drm_owner_item_t,
+                return drm_hash_entry(owner_hash_item, struct drm_owner_item,
                                       owner_hash);
         }
 
@@ -194,14 +194,14 @@ out:
         return NULL;
 }
 
-drm_memblock_item_t *drm_sman_alloc(drm_sman_t *sman, unsigned int manager,
+struct drm_memblock_item *drm_sman_alloc(struct drm_sman *sman, unsigned int manager,
                                     unsigned long size, unsigned alignment,
                                     unsigned long owner)
 {
         void *tmp;
-        drm_sman_mm_t *sman_mm;
-        drm_owner_item_t *owner_item;
-        drm_memblock_item_t *memblock;
+        struct drm_sman_mm *sman_mm;
+        struct drm_owner_item *owner_item;
+        struct drm_memblock_item *memblock;
 
         BUG_ON(manager >= sman->num_managers);
 
@@ -246,9 +246,9 @@ out:
 
 EXPORT_SYMBOL(drm_sman_alloc);
 
-static void drm_sman_free(drm_memblock_item_t *item)
+static void drm_sman_free(struct drm_memblock_item *item)
 {
-        drm_sman_t *sman = item->sman;
+        struct drm_sman *sman = item->sman;
 
         list_del(&item->owner_list);
         drm_ht_remove_item(&sman->user_hash_tab, &item->user_hash);
@@ -256,40 +256,41 @@ static void drm_sman_free(drm_memblock_item_t *item)
         drm_free(item, sizeof(*item), DRM_MEM_MM);
 }
 
-int drm_sman_free_key(drm_sman_t *sman, unsigned int key)
+int drm_sman_free_key(struct drm_sman *sman, unsigned int key)
 {
-        drm_hash_item_t *hash_item;
-        drm_memblock_item_t *memblock_item;
+        struct drm_hash_item *hash_item;
+        struct drm_memblock_item *memblock_item;
 
         if (drm_ht_find_item(&sman->user_hash_tab, key, &hash_item))
                 return -EINVAL;
 
-        memblock_item = drm_hash_entry(hash_item, drm_memblock_item_t, user_hash);
+        memblock_item = drm_hash_entry(hash_item, struct drm_memblock_item,
+                                       user_hash);
         drm_sman_free(memblock_item);
         return 0;
 }
 
 EXPORT_SYMBOL(drm_sman_free_key);
 
-static void drm_sman_remove_owner(drm_sman_t *sman,
-                                  drm_owner_item_t *owner_item)
+static void drm_sman_remove_owner(struct drm_sman *sman,
+                                  struct drm_owner_item *owner_item)
 {
         list_del(&owner_item->sman_list);
         drm_ht_remove_item(&sman->owner_hash_tab, &owner_item->owner_hash);
         drm_free(owner_item, sizeof(*owner_item), DRM_MEM_MM);
 }
 
-int drm_sman_owner_clean(drm_sman_t *sman, unsigned long owner)
+int drm_sman_owner_clean(struct drm_sman *sman, unsigned long owner)
 {
 
-        drm_hash_item_t *hash_item;
-        drm_owner_item_t *owner_item;
+        struct drm_hash_item *hash_item;
+        struct drm_owner_item *owner_item;
 
         if (drm_ht_find_item(&sman->owner_hash_tab, owner, &hash_item)) {
                 return -1;
         }
 
-        owner_item = drm_hash_entry(hash_item, drm_owner_item_t, owner_hash);
+        owner_item = drm_hash_entry(hash_item, struct drm_owner_item, owner_hash);
         if (owner_item->mem_blocks.next == &owner_item->mem_blocks) {
                 drm_sman_remove_owner(sman, owner_item);
                 return -1;
@@ -300,10 +301,10 @@ int drm_sman_owner_clean(drm_sman_t *sman, unsigned long owner)
 
 EXPORT_SYMBOL(drm_sman_owner_clean);
 
-static void drm_sman_do_owner_cleanup(drm_sman_t *sman,
-                                      drm_owner_item_t *owner_item)
+static void drm_sman_do_owner_cleanup(struct drm_sman *sman,
+                                      struct drm_owner_item *owner_item)
 {
-        drm_memblock_item_t *entry, *next;
+        struct drm_memblock_item *entry, *next;
 
         list_for_each_entry_safe(entry, next, &owner_item->mem_blocks,
                                  owner_list) {
@@ -312,28 +313,28 @@ static void drm_sman_do_owner_cleanup(drm_sman_t *sman,
         drm_sman_remove_owner(sman, owner_item);
 }
 
-void drm_sman_owner_cleanup(drm_sman_t *sman, unsigned long owner)
+void drm_sman_owner_cleanup(struct drm_sman *sman, unsigned long owner)
 {
 
-        drm_hash_item_t *hash_item;
-        drm_owner_item_t *owner_item;
+        struct drm_hash_item *hash_item;
+        struct drm_owner_item *owner_item;
 
         if (drm_ht_find_item(&sman->owner_hash_tab, owner, &hash_item)) {
 
                 return;
         }
 
-        owner_item = drm_hash_entry(hash_item, drm_owner_item_t, owner_hash);
+        owner_item = drm_hash_entry(hash_item, struct drm_owner_item, owner_hash);
         drm_sman_do_owner_cleanup(sman, owner_item);
 }
 
 EXPORT_SYMBOL(drm_sman_owner_cleanup);
 
-void drm_sman_cleanup(drm_sman_t *sman)
+void drm_sman_cleanup(struct drm_sman *sman)
 {
-        drm_owner_item_t *entry, *next;
+        struct drm_owner_item *entry, *next;
         unsigned int i;
-        drm_sman_mm_t *sman_mm;
+        struct drm_sman_mm *sman_mm;
 
         list_for_each_entry_safe(entry, next, &sman->owner_items, sman_list) {
                 drm_sman_do_owner_cleanup(sman, entry);
diff --git a/drivers/char/drm/drm_sman.h b/drivers/char/drm/drm_sman.h
index ddc732a1bf27..39a39fefeef1 100644
--- a/drivers/char/drm/drm_sman.h
+++ b/drivers/char/drm/drm_sman.h
@@ -50,7 +50,7 @@
  * for memory management.
  */
 
-typedef struct drm_sman_mm {
+struct drm_sman_mm {
         /* private info. If allocated, needs to be destroyed by the destroy
            function */
         void *private;
@@ -74,30 +74,30 @@ typedef struct drm_sman_mm {
            "alloc" function */
 
         unsigned long (*offset) (void *private, void *ref);
-} drm_sman_mm_t;
+};
 
-typedef struct drm_memblock_item {
+struct drm_memblock_item {
         struct list_head owner_list;
-        drm_hash_item_t user_hash;
+        struct drm_hash_item user_hash;
         void *mm_info;
-        drm_sman_mm_t *mm;
+        struct drm_sman_mm *mm;
         struct drm_sman *sman;
-} drm_memblock_item_t;
+};
 
-typedef struct drm_sman {
-        drm_sman_mm_t *mm;
+struct drm_sman {
+        struct drm_sman_mm *mm;
         int num_managers;
-        drm_open_hash_t owner_hash_tab;
-        drm_open_hash_t user_hash_tab;
+        struct drm_open_hash owner_hash_tab;
+        struct drm_open_hash user_hash_tab;
         struct list_head owner_items;
-} drm_sman_t;
+};
 
 /*
  * Take down a memory manager. This function should only be called after a
  * successful init and after a call to drm_sman_cleanup.
  */
 
-extern void drm_sman_takedown(drm_sman_t * sman);
+extern void drm_sman_takedown(struct drm_sman * sman);
 
 /*
  * Allocate structures for a manager.
@@ -112,7 +112,7 @@ extern void drm_sman_takedown(drm_sman_t * sman);
  *
  */
 
-extern int drm_sman_init(drm_sman_t * sman, unsigned int num_managers,
+extern int drm_sman_init(struct drm_sman * sman, unsigned int num_managers,
                          unsigned int user_order, unsigned int owner_order);
 
 /*
@@ -120,7 +120,7 @@ extern int drm_sman_init(drm_sman_t * sman, unsigned int num_managers,
  * manager unless a customized allogator is used.
  */
 
-extern int drm_sman_set_range(drm_sman_t * sman, unsigned int manager,
+extern int drm_sman_set_range(struct drm_sman * sman, unsigned int manager,
                               unsigned long start, unsigned long size);
 
 /*
@@ -129,23 +129,23 @@ extern int drm_sman_set_range(drm_sman_t * sman, unsigned int manager,
  * so it can be destroyed after this call.
  */
 
-extern int drm_sman_set_manager(drm_sman_t * sman, unsigned int mananger,
-                                drm_sman_mm_t * allocator);
+extern int drm_sman_set_manager(struct drm_sman * sman, unsigned int mananger,
+                                struct drm_sman_mm * allocator);
 
 /*
  * Allocate a memory block. Aligment is not implemented yet.
  */
 
-extern drm_memblock_item_t *drm_sman_alloc(drm_sman_t * sman,
-                                           unsigned int manager,
-                                           unsigned long size,
-                                           unsigned alignment,
-                                           unsigned long owner);
+extern struct drm_memblock_item *drm_sman_alloc(struct drm_sman * sman,
+                                                unsigned int manager,
+                                                unsigned long size,
+                                                unsigned alignment,
+                                                unsigned long owner);
 /*
  * Free a memory block identified by its user hash key.
  */
 
-extern int drm_sman_free_key(drm_sman_t * sman, unsigned int key);
+extern int drm_sman_free_key(struct drm_sman * sman, unsigned int key);
 
 /*
  * returns 1 iff there are no stale memory blocks associated with this owner.
@@ -154,7 +154,7 @@ extern int drm_sman_free_key(drm_sman_t * sman, unsigned int key);
  * resources associated with owner.
  */
 
-extern int drm_sman_owner_clean(drm_sman_t * sman, unsigned long owner);
+extern int drm_sman_owner_clean(struct drm_sman * sman, unsigned long owner);
 
 /*
  * Frees all stale memory blocks associated with this owner. Note that this
@@ -164,13 +164,13 @@ extern int drm_sman_owner_clean(drm_sman_t * sman, unsigned long owner);
  * is not going to be referenced anymore.
  */
 
-extern void drm_sman_owner_cleanup(drm_sman_t * sman, unsigned long owner);
+extern void drm_sman_owner_cleanup(struct drm_sman * sman, unsigned long owner);
 
 /*
  * Frees all stale memory blocks associated with the memory manager.
  * See idling above.
  */
 
-extern void drm_sman_cleanup(drm_sman_t * sman);
+extern void drm_sman_cleanup(struct drm_sman * sman);
 
 #endif
diff --git a/drivers/char/drm/drm_stub.c b/drivers/char/drm/drm_stub.c
index 19408adcc775..9138b49e676e 100644
--- a/drivers/char/drm/drm_stub.c
+++ b/drivers/char/drm/drm_stub.c
@@ -49,16 +49,21 @@ MODULE_PARM_DESC(debug, "Enable debug output");
 module_param_named(cards_limit, drm_cards_limit, int, 0444);
 module_param_named(debug, drm_debug, int, 0600);
 
-drm_head_t **drm_heads;
+struct drm_head **drm_heads;
 struct class *drm_class;
 struct proc_dir_entry *drm_proc_root;
 
-static int drm_fill_in_dev(drm_device_t * dev, struct pci_dev *pdev,
+static int drm_fill_in_dev(struct drm_device * dev, struct pci_dev *pdev,
                            const struct pci_device_id *ent,
                            struct drm_driver *driver)
 {
         int retcode;
 
+        INIT_LIST_HEAD(&dev->filelist);
+        INIT_LIST_HEAD(&dev->ctxlist);
+        INIT_LIST_HEAD(&dev->vmalist);
+        INIT_LIST_HEAD(&dev->maplist);
+
         spin_lock_init(&dev->count_lock);
         spin_lock_init(&dev->drw_lock);
         spin_lock_init(&dev->tasklet_lock);
@@ -76,12 +81,7 @@ static int drm_fill_in_dev(drm_device_t * dev, struct pci_dev *pdev,
 #endif
         dev->irq = pdev->irq;
 
-        dev->maplist = drm_calloc(1, sizeof(*dev->maplist), DRM_MEM_MAPS);
-        if (dev->maplist == NULL)
-                return -ENOMEM;
-        INIT_LIST_HEAD(&dev->maplist->head);
         if (drm_ht_create(&dev->map_hash, 12)) {
-                drm_free(dev->maplist, sizeof(*dev->maplist), DRM_MEM_MAPS);
                 return -ENOMEM;
         }
 
@@ -143,9 +143,9 @@ static int drm_fill_in_dev(drm_device_t * dev, struct pci_dev *pdev,
  * create the proc init entry via proc_init(). This routines assigns
  * minor numbers to secondary heads of multi-headed cards
  */
-static int drm_get_head(drm_device_t * dev, drm_head_t * head)
+static int drm_get_head(struct drm_device * dev, struct drm_head * head)
 {
-        drm_head_t **heads = drm_heads;
+        struct drm_head **heads = drm_heads;
         int ret;
         int minor;
 
@@ -154,7 +154,7 @@ static int drm_get_head(drm_device_t * dev, drm_head_t * head)
         for (minor = 0; minor < drm_cards_limit; minor++, heads++) {
                 if (!*heads) {
 
-                        *head = (drm_head_t) {
+                        *head = (struct drm_head) {
                         .dev = dev,.device =
                                     MKDEV(DRM_MAJOR, minor),.minor = minor,};
 
@@ -184,7 +184,7 @@ static int drm_get_head(drm_device_t * dev, drm_head_t * head)
       err_g2:
         drm_proc_cleanup(minor, drm_proc_root, head->dev_root);
       err_g1:
-        *head = (drm_head_t) {
+        *head = (struct drm_head) {
         .dev = NULL};
         return ret;
 }
@@ -203,7 +203,7 @@ static int drm_get_head(drm_device_t * dev, drm_head_t * head)
 int drm_get_dev(struct pci_dev *pdev, const struct pci_device_id *ent,
                 struct drm_driver *driver)
 {
-        drm_device_t *dev;
+        struct drm_device *dev;
         int ret;
 
         DRM_DEBUG("\n");
@@ -246,7 +246,7 @@ err_g1:
  * "drm" data, otherwise unregisters the "drm" data, frees the dev list and
  * unregisters the character device.
  */
-int drm_put_dev(drm_device_t * dev)
+int drm_put_dev(struct drm_device * dev)
 {
         DRM_DEBUG("release primary %s\n", dev->driver->pci_driver.name);
 
@@ -274,7 +274,7 @@ int drm_put_dev(drm_device_t * dev)
  * last minor released.
  *
  */
-int drm_put_head(drm_head_t * head)
+int drm_put_head(struct drm_head * head)
 {
         int minor = head->minor;
 
@@ -283,7 +283,7 @@ int drm_put_head(drm_head_t * head)
         drm_proc_cleanup(minor, drm_proc_root, head->dev_root);
         drm_sysfs_device_remove(head->dev_class);
 
-        *head = (drm_head_t) {.dev = NULL};
+        *head = (struct drm_head) {.dev = NULL};
 
         drm_heads[minor] = NULL;
 
diff --git a/drivers/char/drm/drm_sysfs.c b/drivers/char/drm/drm_sysfs.c
index cc8e2ebe128c..cf4349b00b07 100644
--- a/drivers/char/drm/drm_sysfs.c
+++ b/drivers/char/drm/drm_sysfs.c
@@ -80,7 +80,7 @@ void drm_sysfs_destroy(struct class *class)
 
 static ssize_t show_dri(struct class_device *class_device, char *buf)
 {
-        drm_device_t * dev = ((drm_head_t *)class_get_devdata(class_device))->dev;
+        struct drm_device * dev = ((struct drm_head *)class_get_devdata(class_device))->dev;
         if (dev->driver->dri_library_name)
                 return dev->driver->dri_library_name(dev, buf);
         return snprintf(buf, PAGE_SIZE, "%s\n", dev->driver->pci_driver.name);
@@ -104,7 +104,7 @@ static struct class_device_attribute class_device_attrs[] = {
  * Note: the struct class passed to this function must have previously been
  * created with a call to drm_sysfs_create().
  */
-struct class_device *drm_sysfs_device_add(struct class *cs, drm_head_t *head)
+struct class_device *drm_sysfs_device_add(struct class *cs, struct drm_head *head)
 {
         struct class_device *class_dev;
         int i, j, err;
diff --git a/drivers/char/drm/drm_vm.c b/drivers/char/drm/drm_vm.c
index b5c5b9fa84c3..68e36e51ba0c 100644
--- a/drivers/char/drm/drm_vm.c
+++ b/drivers/char/drm/drm_vm.c
@@ -79,11 +79,11 @@ static pgprot_t drm_io_prot(uint32_t map_type, struct vm_area_struct *vma)
 static __inline__ struct page *drm_do_vm_nopage(struct vm_area_struct *vma,
                                                 unsigned long address)
 {
-        drm_file_t *priv = vma->vm_file->private_data;
-        drm_device_t *dev = priv->head->dev;
-        drm_map_t *map = NULL;
-        drm_map_list_t *r_list;
-        drm_hash_item_t *hash;
+        struct drm_file *priv = vma->vm_file->private_data;
+        struct drm_device *dev = priv->head->dev;
+        struct drm_map *map = NULL;
+        struct drm_map_list *r_list;
+        struct drm_hash_item *hash;
 
         /*
          * Find the right map
@@ -97,7 +97,7 @@ static __inline__ struct page *drm_do_vm_nopage(struct vm_area_struct *vma,
         if (drm_ht_find_item(&dev->map_hash, vma->vm_pgoff, &hash))
                 goto vm_nopage_error;
 
-        r_list = drm_hash_entry(hash, drm_map_list_t, hash);
+        r_list = drm_hash_entry(hash, struct drm_map_list, hash);
         map = r_list->map;
 
         if (map && map->type == _DRM_AGP) {
@@ -116,7 +116,7 @@ static __inline__ struct page *drm_do_vm_nopage(struct vm_area_struct *vma,
                 /*
                  * It's AGP memory - find the real physical page to map
                  */
-                for (agpmem = dev->agp->memory; agpmem; agpmem = agpmem->next) {
+                list_for_each_entry(agpmem, &dev->agp->memory, head) {
                         if (agpmem->bound <= baddr &&
                             agpmem->bound + agpmem->pages * PAGE_SIZE > baddr)
                                 break;
@@ -163,7 +163,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;
@@ -194,12 +194,11 @@ static __inline__ struct page *drm_do_vm_shm_nopage(struct vm_area_struct *vma,
  */
 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, *prev, *next;
-        drm_map_t *map;
-        drm_map_list_t *r_list;
-        struct list_head *list;
+        struct drm_file *priv = vma->vm_file->private_data;
+        struct drm_device *dev = priv->head->dev;
+        struct drm_vma_entry *pt, *temp;
+        struct drm_map *map;
+        struct drm_map_list *r_list;
         int found_maps = 0;
 
         DRM_DEBUG("0x%08lx,0x%08lx\n",
@@ -209,30 +208,22 @@ static void drm_vm_shm_close(struct vm_area_struct *vma)
         map = vma->vm_private_data;
 
         mutex_lock(&dev->struct_mutex);
-        for (pt = dev->vmalist, prev = NULL; pt; pt = next) {
-                next = pt->next;
+        list_for_each_entry_safe(pt, temp, &dev->vmalist, head) {
                 if (pt->vma->vm_private_data == map)
                         found_maps++;
                 if (pt->vma == vma) {
-                        if (prev) {
-                                prev->next = pt->next;
-                        } else {
-                                dev->vmalist = pt->next;
-                        }
+                        list_del(&pt->head);
                         drm_free(pt, sizeof(*pt), DRM_MEM_VMAS);
-                } else {
-                        prev = pt;
                 }
         }
+
         /* We were the only map that was found */
         if (found_maps == 1 && map->flags & _DRM_REMOVABLE) {
                 /* Check to see if we are in the maplist, if we are not, then
                  * we delete this mappings information.
                  */
                 found_maps = 0;
-                list = &dev->maplist->head;
-                list_for_each(list, &dev->maplist->head) {
-                        r_list = list_entry(list, drm_map_list_t, head);
+                list_for_each_entry(r_list, &dev->maplist, head) {
                         if (r_list->map == map)
                                 found_maps++;
                 }
@@ -283,9 +274,9 @@ static void drm_vm_shm_close(struct vm_area_struct *vma)
 static __inline__ struct page *drm_do_vm_dma_nopage(struct vm_area_struct *vma,
                                                     unsigned long address)
 {
-        drm_file_t *priv = vma->vm_file->private_data;
-        drm_device_t *dev = priv->head->dev;
-        drm_device_dma_t *dma = dev->dma;
+        struct drm_file *priv = vma->vm_file->private_data;
+        struct drm_device *dev = priv->head->dev;
+        struct drm_device_dma *dma = dev->dma;
         unsigned long offset;
         unsigned long page_nr;
         struct page *page;
@@ -319,10 +310,10 @@ 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;
-        drm_file_t *priv = vma->vm_file->private_data;
-        drm_device_t *dev = priv->head->dev;
-        drm_sg_mem_t *entry = dev->sg;
+        struct drm_map *map = (struct drm_map *) vma->vm_private_data;
+        struct drm_file *priv = vma->vm_file->private_data;
+        struct drm_device *dev = priv->head->dev;
+        struct drm_sg_mem *entry = dev->sg;
         unsigned long offset;
         unsigned long map_offset;
         unsigned long page_offset;
@@ -414,9 +405,9 @@ static struct vm_operations_struct drm_vm_sg_ops = {
  */
 static void drm_vm_open_locked(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 *vma_entry;
+        struct drm_file *priv = vma->vm_file->private_data;
+        struct drm_device *dev = priv->head->dev;
+        struct drm_vma_entry *vma_entry;
 
         DRM_DEBUG("0x%08lx,0x%08lx\n",
                   vma->vm_start, vma->vm_end - vma->vm_start);
@@ -425,16 +416,15 @@ static void drm_vm_open_locked(struct vm_area_struct *vma)
         vma_entry = drm_alloc(sizeof(*vma_entry), DRM_MEM_VMAS);
         if (vma_entry) {
                 vma_entry->vma = vma;
-                vma_entry->next = dev->vmalist;
                 vma_entry->pid = current->pid;
-                dev->vmalist = vma_entry;
+                list_add(&vma_entry->head, &dev->vmalist);
         }
 }
 
 static void drm_vm_open(struct vm_area_struct *vma)
 {
-        drm_file_t *priv = vma->vm_file->private_data;
-        drm_device_t *dev = priv->head->dev;
+        struct drm_file *priv = vma->vm_file->private_data;
+        struct drm_device *dev = priv->head->dev;
 
         mutex_lock(&dev->struct_mutex);
         drm_vm_open_locked(vma);
@@ -451,22 +441,18 @@ static void drm_vm_open(struct vm_area_struct *vma)
  */
 static void drm_vm_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, *prev;
+        struct drm_file *priv = vma->vm_file->private_data;
+        struct drm_device *dev = priv->head->dev;
+        struct drm_vma_entry *pt, *temp;
 
         DRM_DEBUG("0x%08lx,0x%08lx\n",
                   vma->vm_start, vma->vm_end - vma->vm_start);
         atomic_dec(&dev->vma_count);
 
         mutex_lock(&dev->struct_mutex);
-        for (pt = dev->vmalist, prev = NULL; pt; prev = pt, pt = pt->next) {
+        list_for_each_entry_safe(pt, temp, &dev->vmalist, head) {
                 if (pt->vma == vma) {
-                        if (prev) {
-                                prev->next = pt->next;
-                        } else {
-                                dev->vmalist = pt->next;
-                        }
+                        list_del(&pt->head);
                         drm_free(pt, sizeof(*pt), DRM_MEM_VMAS);
                         break;
                 }
@@ -486,9 +472,9 @@ static void drm_vm_close(struct vm_area_struct *vma)
  */
 static int drm_mmap_dma(struct file *filp, struct vm_area_struct *vma)
 {
-        drm_file_t *priv = filp->private_data;
-        drm_device_t *dev;
-        drm_device_dma_t *dma;
+        struct drm_file *priv = filp->private_data;
+        struct drm_device *dev;
+        struct drm_device_dma *dma;
         unsigned long length = vma->vm_end - vma->vm_start;
 
         dev = priv->head->dev;
@@ -526,7 +512,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;
 }
@@ -559,11 +545,11 @@ EXPORT_SYMBOL(drm_core_get_reg_ofs);
  */
 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_file *priv = filp->private_data;
+        struct drm_device *dev = priv->head->dev;
+        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);
@@ -588,7 +574,7 @@ static int drm_mmap_locked(struct file *filp, struct vm_area_struct *vma)
                 return -EINVAL;
         }
 
-        map = drm_hash_entry(hash, drm_map_list_t, hash)->map;
+        map = drm_hash_entry(hash, struct drm_map_list, hash)->map;
         if (!map || ((map->flags & _DRM_RESTRICTED) && !capable(CAP_SYS_ADMIN)))
                 return -EPERM;
 
@@ -677,8 +663,8 @@ static int drm_mmap_locked(struct file *filp, struct vm_area_struct *vma)
 
 int drm_mmap(struct file *filp, struct vm_area_struct *vma)
 {
-        drm_file_t *priv = filp->private_data;
-        drm_device_t *dev = priv->head->dev;
+        struct drm_file *priv = filp->private_data;
+        struct drm_device *dev = priv->head->dev;
         int ret;
 
         mutex_lock(&dev->struct_mutex);
diff --git a/drivers/char/drm/i810_dma.c b/drivers/char/drm/i810_dma.c
index 603d17fd2d69..cb449999d0ef 100644
--- a/drivers/char/drm/i810_dma.c
+++ b/drivers/char/drm/i810_dma.c
@@ -45,16 +45,16 @@
 #define I810_BUF_UNMAPPED 0
 #define I810_BUF_MAPPED   1
 
-static drm_buf_t *i810_freelist_get(drm_device_t * 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;
 
         /* Linear search might not be the best solution */
 
         for (i = 0; i < dma->buf_count; i++) {
-                drm_buf_t *buf = dma->buflist[i];
+                struct drm_buf *buf = dma->buflist[i];
                 drm_i810_buf_priv_t *buf_priv = buf->dev_private;
                 /* In use is already a pointer */
                 used = cmpxchg(buf_priv->in_use, I810_BUF_FREE,
@@ -70,7 +70,7 @@ static drm_buf_t *i810_freelist_get(drm_device_t * dev)
  * yet, the hardware updates in use for us once its on the ring buffer.
  */
 
-static int i810_freelist_put(drm_device_t * dev, drm_buf_t * buf)
+static int i810_freelist_put(struct drm_device * dev, struct drm_buf * buf)
 {
         drm_i810_buf_priv_t *buf_priv = buf->dev_private;
         int used;
@@ -87,10 +87,10 @@ static int i810_freelist_put(drm_device_t * dev, drm_buf_t * buf)
 
 static int i810_mmap_buffers(struct file *filp, struct vm_area_struct *vma)
 {
-        drm_file_t *priv = filp->private_data;
-        drm_device_t *dev;
+        struct drm_file *priv = filp->private_data;
+        struct drm_device *dev;
         drm_i810_private_t *dev_priv;
-        drm_buf_t *buf;
+        struct drm_buf *buf;
         drm_i810_buf_priv_t *buf_priv;
 
         lock_kernel();
@@ -120,10 +120,10 @@ static const struct file_operations i810_buffer_fops = {
         .fasync = drm_fasync,
 };
 
-static int i810_map_buffer(drm_buf_t * buf, struct file *filp)
+static int i810_map_buffer(struct drm_buf * buf, struct file *filp)
 {
-        drm_file_t *priv = filp->private_data;
-        drm_device_t *dev = priv->head->dev;
+        struct drm_file *priv = filp->private_data;
+        struct drm_device *dev = priv->head->dev;
         drm_i810_buf_priv_t *buf_priv = buf->dev_private;
         drm_i810_private_t *dev_priv = dev->dev_private;
         const struct file_operations *old_fops;
@@ -152,7 +152,7 @@ static int i810_map_buffer(drm_buf_t * buf, struct file *filp)
         return retcode;
 }
 
-static int i810_unmap_buffer(drm_buf_t * buf)
+static int i810_unmap_buffer(struct drm_buf * buf)
 {
         drm_i810_buf_priv_t *buf_priv = buf->dev_private;
         int retcode = 0;
@@ -172,10 +172,10 @@ static int i810_unmap_buffer(drm_buf_t * buf)
         return retcode;
 }
 
-static int i810_dma_get_buffer(drm_device_t * dev, drm_i810_dma_t * d,
+static int i810_dma_get_buffer(struct drm_device * dev, drm_i810_dma_t * d,
                                struct file *filp)
 {
-        drm_buf_t *buf;
+        struct drm_buf *buf;
         drm_i810_buf_priv_t *buf_priv;
         int retcode = 0;
 
@@ -202,9 +202,9 @@ static int i810_dma_get_buffer(drm_device_t * dev, drm_i810_dma_t * d,
         return retcode;
 }
 
-static int i810_dma_cleanup(drm_device_t * dev)
+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
@@ -233,7 +233,7 @@ static int i810_dma_cleanup(drm_device_t * dev)
                 dev->dev_private = NULL;
 
                 for (i = 0; i < dma->buf_count; i++) {
-                        drm_buf_t *buf = dma->buflist[i];
+                        struct drm_buf *buf = dma->buflist[i];
                         drm_i810_buf_priv_t *buf_priv = buf->dev_private;
 
                         if (buf_priv->kernel_virtual && buf->total)
@@ -243,7 +243,7 @@ static int i810_dma_cleanup(drm_device_t * dev)
         return 0;
 }
 
-static int i810_wait_ring(drm_device_t * dev, int n)
+static int i810_wait_ring(struct drm_device * dev, int n)
 {
         drm_i810_private_t *dev_priv = dev->dev_private;
         drm_i810_ring_buffer_t *ring = &(dev_priv->ring);
@@ -276,7 +276,7 @@ static int i810_wait_ring(drm_device_t * dev, int n)
         return iters;
 }
 
-static void i810_kernel_lost_context(drm_device_t * dev)
+static void i810_kernel_lost_context(struct drm_device * dev)
 {
         drm_i810_private_t *dev_priv = dev->dev_private;
         drm_i810_ring_buffer_t *ring = &(dev_priv->ring);
@@ -288,9 +288,9 @@ static void i810_kernel_lost_context(drm_device_t * dev)
                 ring->space += ring->Size;
 }
 
-static int i810_freelist_init(drm_device_t * dev, drm_i810_private_t * dev_priv)
+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;
@@ -301,7 +301,7 @@ static int i810_freelist_init(drm_device_t * dev, drm_i810_private_t * dev_priv)
         }
 
         for (i = 0; i < dma->buf_count; i++) {
-                drm_buf_t *buf = dma->buflist[i];
+                struct drm_buf *buf = dma->buflist[i];
                 drm_i810_buf_priv_t *buf_priv = buf->dev_private;
 
                 buf_priv->in_use = hw_status++;
@@ -323,16 +323,14 @@ static int i810_freelist_init(drm_device_t * dev, drm_i810_private_t * dev_priv)
         return 0;
 }
 
-static int i810_dma_initialize(drm_device_t * dev,
+static int i810_dma_initialize(struct drm_device * dev,
                                drm_i810_private_t * dev_priv,
                                drm_i810_init_t * init)
 {
-        struct list_head *list;
-
+        struct drm_map_list *r_list;
         memset(dev_priv, 0, sizeof(drm_i810_private_t));
 
-        list_for_each(list, &dev->maplist->head) {
-                drm_map_list_t *r_list = list_entry(list, drm_map_list_t, head);
+        list_for_each_entry(r_list, &dev->maplist, head) {
                 if (r_list->map &&
                     r_list->map->type == _DRM_SHM &&
                     r_list->map->flags & _DRM_CONTAINS_LOCK) {
@@ -478,8 +476,8 @@ static int i810_dma_init_compat(drm_i810_init_t * init, unsigned long arg)
 static int i810_dma_init(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;
+        struct drm_file *priv = filp->private_data;
+        struct drm_device *dev = priv->head->dev;
         drm_i810_private_t *dev_priv;
         drm_i810_init_t init;
         int retcode = 0;
@@ -536,7 +534,7 @@ static int i810_dma_init(struct inode *inode, struct file *filp,
  * Use 'volatile' & local var tmp to force the emitted values to be
  * identical to the verified ones.
  */
-static void i810EmitContextVerified(drm_device_t * dev,
+static void i810EmitContextVerified(struct drm_device * dev,
                                     volatile unsigned int *code)
 {
         drm_i810_private_t *dev_priv = dev->dev_private;
@@ -569,7 +567,7 @@ static void i810EmitContextVerified(drm_device_t * dev,
         ADVANCE_LP_RING();
 }
 
-static void i810EmitTexVerified(drm_device_t * dev, volatile unsigned int *code)
+static void i810EmitTexVerified(struct drm_device * dev, volatile unsigned int *code)
 {
         drm_i810_private_t *dev_priv = dev->dev_private;
         int i, j = 0;
@@ -602,7 +600,7 @@ static void i810EmitTexVerified(drm_device_t * dev, volatile unsigned int *code)
 
 /* Need to do some additional checking when setting the dest buffer.
  */
-static void i810EmitDestVerified(drm_device_t * dev,
+static void i810EmitDestVerified(struct drm_device * dev,
                                  volatile unsigned int *code)
 {
         drm_i810_private_t *dev_priv = dev->dev_private;
@@ -637,7 +635,7 @@ static void i810EmitDestVerified(drm_device_t * dev,
         ADVANCE_LP_RING();
 }
 
-static void i810EmitState(drm_device_t * dev)
+static void i810EmitState(struct drm_device * dev)
 {
         drm_i810_private_t *dev_priv = dev->dev_private;
         drm_i810_sarea_t *sarea_priv = dev_priv->sarea_priv;
@@ -668,14 +666,14 @@ static void i810EmitState(drm_device_t * dev)
 
 /* need to verify
  */
-static void i810_dma_dispatch_clear(drm_device_t * dev, int flags,
+static void i810_dma_dispatch_clear(struct drm_device * dev, int flags,
                                     unsigned int clear_color,
                                     unsigned int clear_zval)
 {
         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;
@@ -743,12 +741,12 @@ static void i810_dma_dispatch_clear(drm_device_t * dev, int flags,
         }
 }
 
-static void i810_dma_dispatch_swap(drm_device_t * dev)
+static void i810_dma_dispatch_swap(struct drm_device * 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;
@@ -789,13 +787,13 @@ static void i810_dma_dispatch_swap(drm_device_t * dev)
         }
 }
 
-static void i810_dma_dispatch_vertex(drm_device_t * dev,
-                                     drm_buf_t * buf, int discard, int used)
+static void i810_dma_dispatch_vertex(struct drm_device * dev,
+                                     struct drm_buf * buf, int discard, int used)
 {
         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;
@@ -869,7 +867,7 @@ static void i810_dma_dispatch_vertex(drm_device_t * dev,
         }
 }
 
-static void i810_dma_dispatch_flip(drm_device_t * dev)
+static void i810_dma_dispatch_flip(struct drm_device * dev)
 {
         drm_i810_private_t *dev_priv = dev->dev_private;
         int pitch = dev_priv->pitch;
@@ -916,7 +914,7 @@ static void i810_dma_dispatch_flip(drm_device_t * dev)
 
 }
 
-static void i810_dma_quiescent(drm_device_t * dev)
+static void i810_dma_quiescent(struct drm_device * dev)
 {
         drm_i810_private_t *dev_priv = dev->dev_private;
         RING_LOCALS;
@@ -935,10 +933,10 @@ static void i810_dma_quiescent(drm_device_t * dev)
         i810_wait_ring(dev, dev_priv->ring.Size - 8);
 }
 
-static int i810_flush_queue(drm_device_t * dev)
+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;
 
@@ -954,7 +952,7 @@ static int i810_flush_queue(drm_device_t * dev)
         i810_wait_ring(dev, dev_priv->ring.Size - 8);
 
         for (i = 0; i < dma->buf_count; i++) {
-                drm_buf_t *buf = dma->buflist[i];
+                struct drm_buf *buf = dma->buflist[i];
                 drm_i810_buf_priv_t *buf_priv = buf->dev_private;
 
                 int used = cmpxchg(buf_priv->in_use, I810_BUF_HARDWARE,
@@ -970,9 +968,9 @@ static int i810_flush_queue(drm_device_t * dev)
 }
 
 /* Must be called with the lock held */
-static void i810_reclaim_buffers(drm_device_t * dev, struct file *filp)
+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)
@@ -985,7 +983,7 @@ static void i810_reclaim_buffers(drm_device_t * dev, struct file *filp)
         i810_flush_queue(dev);
 
         for (i = 0; i < dma->buf_count; i++) {
-                drm_buf_t *buf = dma->buflist[i];
+                struct drm_buf *buf = dma->buflist[i];
                 drm_i810_buf_priv_t *buf_priv = buf->dev_private;
 
                 if (buf->filp == filp && buf_priv) {
@@ -1003,8 +1001,8 @@ static void i810_reclaim_buffers(drm_device_t * dev, struct file *filp)
 static int i810_flush_ioctl(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;
+        struct drm_file *priv = filp->private_data;
+        struct drm_device *dev = priv->head->dev;
 
         LOCK_TEST_WITH_RETURN(dev, filp);
 
@@ -1015,9 +1013,9 @@ static int i810_flush_ioctl(struct inode *inode, struct file *filp,
 static int i810_dma_vertex(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_device_dma_t *dma = dev->dma;
+        struct drm_file *priv = filp->private_data;
+        struct drm_device *dev = priv->head->dev;
+        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 *)
@@ -1051,8 +1049,8 @@ static int i810_dma_vertex(struct inode *inode, struct file *filp,
 static int i810_clear_bufs(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;
+        struct drm_file *priv = filp->private_data;
+        struct drm_device *dev = priv->head->dev;
         drm_i810_clear_t clear;
 
         if (copy_from_user
@@ -1074,8 +1072,8 @@ static int i810_clear_bufs(struct inode *inode, struct file *filp,
 static int i810_swap_bufs(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;
+        struct drm_file *priv = filp->private_data;
+        struct drm_device *dev = priv->head->dev;
 
         DRM_DEBUG("i810_swap_bufs\n");
 
@@ -1088,8 +1086,8 @@ static int i810_swap_bufs(struct inode *inode, struct file *filp,
 static int i810_getage(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;
+        struct drm_file *priv = filp->private_data;
+        struct drm_device *dev = priv->head->dev;
         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 *)
@@ -1102,8 +1100,8 @@ static int i810_getage(struct inode *inode, struct file *filp, unsigned int cmd,
 static int i810_getbuf(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;
+        struct drm_file *priv = filp->private_data;
+        struct drm_device *dev = priv->head->dev;
         int retcode = 0;
         drm_i810_dma_t d;
         drm_i810_private_t *dev_priv = (drm_i810_private_t *) dev->dev_private;
@@ -1123,7 +1121,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];
 
@@ -1144,7 +1142,7 @@ static int i810_docopy(struct inode *inode, struct file *filp, unsigned int cmd,
         return 0;
 }
 
-static void i810_dma_dispatch_mc(drm_device_t * dev, drm_buf_t * buf, int used,
+static void i810_dma_dispatch_mc(struct drm_device * dev, struct drm_buf * buf, int used,
                                  unsigned int last_render)
 {
         drm_i810_private_t *dev_priv = dev->dev_private;
@@ -1207,9 +1205,9 @@ static void i810_dma_dispatch_mc(drm_device_t * dev, drm_buf_t * buf, int used,
 static int i810_dma_mc(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_device_dma_t *dma = dev->dma;
+        struct drm_file *priv = filp->private_data;
+        struct drm_device *dev = priv->head->dev;
+        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 *)
@@ -1238,8 +1236,8 @@ static int i810_dma_mc(struct inode *inode, struct file *filp,
 static int i810_rstatus(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;
+        struct drm_file *priv = filp->private_data;
+        struct drm_device *dev = priv->head->dev;
         drm_i810_private_t *dev_priv = (drm_i810_private_t *) dev->dev_private;
 
         return (int)(((u32 *) (dev_priv->hw_status_page))[4]);
@@ -1248,8 +1246,8 @@ static int i810_rstatus(struct inode *inode, struct file *filp,
 static int i810_ov0_info(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;
+        struct drm_file *priv = filp->private_data;
+        struct drm_device *dev = priv->head->dev;
         drm_i810_private_t *dev_priv = (drm_i810_private_t *) dev->dev_private;
         drm_i810_overlay_t data;
 
@@ -1264,8 +1262,8 @@ static int i810_ov0_info(struct inode *inode, struct file *filp,
 static int i810_fstatus(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;
+        struct drm_file *priv = filp->private_data;
+        struct drm_device *dev = priv->head->dev;
         drm_i810_private_t *dev_priv = (drm_i810_private_t *) dev->dev_private;
 
         LOCK_TEST_WITH_RETURN(dev, filp);
@@ -1276,8 +1274,8 @@ static int i810_fstatus(struct inode *inode, struct file *filp,
 static int i810_ov0_flip(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;
+        struct drm_file *priv = filp->private_data;
+        struct drm_device *dev = priv->head->dev;
         drm_i810_private_t *dev_priv = (drm_i810_private_t *) dev->dev_private;
 
         LOCK_TEST_WITH_RETURN(dev, filp);
@@ -1290,7 +1288,7 @@ static int i810_ov0_flip(struct inode *inode, struct file *filp,
 
 /* Not sure why this isn't set all the time:
  */
-static void i810_do_init_pageflip(drm_device_t * dev)
+static void i810_do_init_pageflip(struct drm_device * dev)
 {
         drm_i810_private_t *dev_priv = dev->dev_private;
 
@@ -1300,7 +1298,7 @@ static void i810_do_init_pageflip(drm_device_t * dev)
         dev_priv->sarea_priv->pf_current_page = dev_priv->current_page;
 }
 
-static int i810_do_cleanup_pageflip(drm_device_t * dev)
+static int i810_do_cleanup_pageflip(struct drm_device * dev)
 {
         drm_i810_private_t *dev_priv = dev->dev_private;
 
@@ -1315,8 +1313,8 @@ static int i810_do_cleanup_pageflip(drm_device_t * dev)
 static int i810_flip_bufs(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;
+        struct drm_file *priv = filp->private_data;
+        struct drm_device *dev = priv->head->dev;
         drm_i810_private_t *dev_priv = dev->dev_private;
 
         DRM_DEBUG("%s\n", __FUNCTION__);
@@ -1330,7 +1328,7 @@ static int i810_flip_bufs(struct inode *inode, struct file *filp,
         return 0;
 }
 
-int i810_driver_load(drm_device_t *dev, unsigned long flags)
+int i810_driver_load(struct drm_device *dev, unsigned long flags)
 {
         /* i810 has 4 more counters */
         dev->counters += 4;
@@ -1342,12 +1340,12 @@ int i810_driver_load(drm_device_t *dev, unsigned long flags)
         return 0;
 }
 
-void i810_driver_lastclose(drm_device_t * dev)
+void i810_driver_lastclose(struct drm_device * dev)
 {
         i810_dma_cleanup(dev);
 }
 
-void i810_driver_preclose(drm_device_t * dev, DRMFILE filp)
+void i810_driver_preclose(struct drm_device * dev, DRMFILE filp)
 {
         if (dev->dev_private) {
                 drm_i810_private_t *dev_priv = dev->dev_private;
@@ -1357,12 +1355,12 @@ void i810_driver_preclose(drm_device_t * dev, DRMFILE filp)
         }
 }
 
-void i810_driver_reclaim_buffers_locked(drm_device_t * dev, struct file *filp)
+void i810_driver_reclaim_buffers_locked(struct drm_device * dev, struct file *filp)
 {
         i810_reclaim_buffers(dev, filp);
 }
 
-int i810_driver_dma_quiescent(drm_device_t * dev)
+int i810_driver_dma_quiescent(struct drm_device * dev)
 {
         i810_dma_quiescent(dev);
         return 0;
@@ -1399,7 +1397,7 @@ int i810_max_ioctl = DRM_ARRAY_SIZE(i810_ioctls);
  * \returns
  * A value of 1 is always retured to indictate every i810 is AGP.
  */
-int i810_driver_device_is_agp(drm_device_t * dev)
+int i810_driver_device_is_agp(struct drm_device * dev)
 {
         return 1;
 }
diff --git a/drivers/char/drm/i810_drm.h b/drivers/char/drm/i810_drm.h
index 2deb925a94f3..614977dbce45 100644
--- a/drivers/char/drm/i810_drm.h
+++ b/drivers/char/drm/i810_drm.h
@@ -158,7 +158,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
diff --git a/drivers/char/drm/i810_drv.h b/drivers/char/drm/i810_drv.h
index e6df49f4928a..648833844c7f 100644
--- a/drivers/char/drm/i810_drv.h
+++ b/drivers/char/drm/i810_drv.h
@@ -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;
@@ -88,7 +88,7 @@ typedef struct drm_i810_private {
 
         dma_addr_t dma_status_page;
 
-        drm_buf_t *mmap_buffer;
+        struct drm_buf *mmap_buffer;
 
         u32 front_di1, back_di1, zi1;
 
@@ -115,15 +115,15 @@ typedef struct drm_i810_private {
 } drm_i810_private_t;
 
                                 /* i810_dma.c */
-extern int i810_driver_dma_quiescent(drm_device_t * dev);
-extern void i810_driver_reclaim_buffers_locked(drm_device_t * dev,
+extern int i810_driver_dma_quiescent(struct drm_device * dev);
+extern void i810_driver_reclaim_buffers_locked(struct drm_device * dev,
                                                struct file *filp);
 extern int i810_driver_load(struct drm_device *, unsigned long flags);
-extern void i810_driver_lastclose(drm_device_t * dev);
-extern void i810_driver_preclose(drm_device_t * dev, DRMFILE filp);
-extern void i810_driver_reclaim_buffers_locked(drm_device_t * dev,
+extern void i810_driver_lastclose(struct drm_device * dev);
+extern void i810_driver_preclose(struct drm_device * dev, DRMFILE filp);
+extern void i810_driver_reclaim_buffers_locked(struct drm_device * dev,
                                                struct file *filp);
-extern int i810_driver_device_is_agp(drm_device_t * dev);
+extern int i810_driver_device_is_agp(struct drm_device * dev);
 
 extern drm_ioctl_desc_t i810_ioctls[];
 extern int i810_max_ioctl;
diff --git a/drivers/char/drm/i830_dma.c b/drivers/char/drm/i830_dma.c
index 3314a9fea9e5..dc20c1a7834e 100644
--- a/drivers/char/drm/i830_dma.c
+++ b/drivers/char/drm/i830_dma.c
@@ -47,16 +47,16 @@
 #define I830_BUF_UNMAPPED 0
 #define I830_BUF_MAPPED   1
 
-static drm_buf_t *i830_freelist_get(drm_device_t * dev)
+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;
 
         /* Linear search might not be the best solution */
 
         for (i = 0; i < dma->buf_count; i++) {
-                drm_buf_t *buf = dma->buflist[i];
+                struct drm_buf *buf = dma->buflist[i];
                 drm_i830_buf_priv_t *buf_priv = buf->dev_private;
                 /* In use is already a pointer */
                 used = cmpxchg(buf_priv->in_use, I830_BUF_FREE,
@@ -72,7 +72,7 @@ static drm_buf_t *i830_freelist_get(drm_device_t * dev)
  * yet, the hardware updates in use for us once its on the ring buffer.
  */
 
-static int i830_freelist_put(drm_device_t * dev, drm_buf_t * buf)
+static int i830_freelist_put(struct drm_device * dev, struct drm_buf * buf)
 {
         drm_i830_buf_priv_t *buf_priv = buf->dev_private;
         int used;
@@ -89,10 +89,10 @@ static int i830_freelist_put(drm_device_t * dev, drm_buf_t * buf)
 
 static int i830_mmap_buffers(struct file *filp, struct vm_area_struct *vma)
 {
-        drm_file_t *priv = filp->private_data;
-        drm_device_t *dev;
+        struct drm_file *priv = filp->private_data;
+        struct drm_device *dev;
         drm_i830_private_t *dev_priv;
-        drm_buf_t *buf;
+        struct drm_buf *buf;
         drm_i830_buf_priv_t *buf_priv;
 
         lock_kernel();
@@ -122,10 +122,10 @@ static const struct file_operations i830_buffer_fops = {
         .fasync = drm_fasync,
 };
 
-static int i830_map_buffer(drm_buf_t * buf, struct file *filp)
+static int i830_map_buffer(struct drm_buf * buf, struct file *filp)
 {
-        drm_file_t *priv = filp->private_data;
-        drm_device_t *dev = priv->head->dev;
+        struct drm_file *priv = filp->private_data;
+        struct drm_device *dev = priv->head->dev;
         drm_i830_buf_priv_t *buf_priv = buf->dev_private;
         drm_i830_private_t *dev_priv = dev->dev_private;
         const struct file_operations *old_fops;
@@ -156,7 +156,7 @@ static int i830_map_buffer(drm_buf_t * buf, struct file *filp)
         return retcode;
 }
 
-static int i830_unmap_buffer(drm_buf_t * buf)
+static int i830_unmap_buffer(struct drm_buf * buf)
 {
         drm_i830_buf_priv_t *buf_priv = buf->dev_private;
         int retcode = 0;
@@ -176,10 +176,10 @@ static int i830_unmap_buffer(drm_buf_t * buf)
         return retcode;
 }
 
-static int i830_dma_get_buffer(drm_device_t * dev, drm_i830_dma_t * d,
+static int i830_dma_get_buffer(struct drm_device * dev, drm_i830_dma_t * d,
                                struct file *filp)
 {
-        drm_buf_t *buf;
+        struct drm_buf *buf;
         drm_i830_buf_priv_t *buf_priv;
         int retcode = 0;
 
@@ -206,9 +206,9 @@ static int i830_dma_get_buffer(drm_device_t * dev, drm_i830_dma_t * d,
         return retcode;
 }
 
-static int i830_dma_cleanup(drm_device_t * dev)
+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
@@ -238,7 +238,7 @@ static int i830_dma_cleanup(drm_device_t * dev)
                 dev->dev_private = NULL;
 
                 for (i = 0; i < dma->buf_count; i++) {
-                        drm_buf_t *buf = dma->buflist[i];
+                        struct drm_buf *buf = dma->buflist[i];
                         drm_i830_buf_priv_t *buf_priv = buf->dev_private;
                         if (buf_priv->kernel_virtual && buf->total)
                                 drm_core_ioremapfree(&buf_priv->map, dev);
@@ -247,7 +247,7 @@ static int i830_dma_cleanup(drm_device_t * dev)
         return 0;
 }
 
-int i830_wait_ring(drm_device_t * dev, int n, const char *caller)
+int i830_wait_ring(struct drm_device * dev, int n, const char *caller)
 {
         drm_i830_private_t *dev_priv = dev->dev_private;
         drm_i830_ring_buffer_t *ring = &(dev_priv->ring);
@@ -281,7 +281,7 @@ int i830_wait_ring(drm_device_t * dev, int n, const char *caller)
         return iters;
 }
 
-static void i830_kernel_lost_context(drm_device_t * dev)
+static void i830_kernel_lost_context(struct drm_device * dev)
 {
         drm_i830_private_t *dev_priv = dev->dev_private;
         drm_i830_ring_buffer_t *ring = &(dev_priv->ring);
@@ -296,9 +296,9 @@ static void i830_kernel_lost_context(drm_device_t * dev)
                 dev_priv->sarea_priv->perf_boxes |= I830_BOX_RING_EMPTY;
 }
 
-static int i830_freelist_init(drm_device_t * dev, drm_i830_private_t * dev_priv)
+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;
@@ -309,7 +309,7 @@ static int i830_freelist_init(drm_device_t * dev, drm_i830_private_t * dev_priv)
         }
 
         for (i = 0; i < dma->buf_count; i++) {
-                drm_buf_t *buf = dma->buflist[i];
+                struct drm_buf *buf = dma->buflist[i];
                 drm_i830_buf_priv_t *buf_priv = buf->dev_private;
 
                 buf_priv->in_use = hw_status++;
@@ -330,16 +330,15 @@ static int i830_freelist_init(drm_device_t * dev, drm_i830_private_t * dev_priv)
         return 0;
 }
 
-static int i830_dma_initialize(drm_device_t * dev,
+static int i830_dma_initialize(struct drm_device * dev,
                                drm_i830_private_t * dev_priv,
                                drm_i830_init_t * init)
 {
-        struct list_head *list;
+        struct drm_map_list *r_list;
 
         memset(dev_priv, 0, sizeof(drm_i830_private_t));
 
-        list_for_each(list, &dev->maplist->head) {
-                drm_map_list_t *r_list = list_entry(list, drm_map_list_t, head);
+        list_for_each_entry(r_list, &dev->maplist, head) {
                 if (r_list->map &&
                     r_list->map->type == _DRM_SHM &&
                     r_list->map->flags & _DRM_CONTAINS_LOCK) {
@@ -455,8 +454,8 @@ static int i830_dma_initialize(drm_device_t * dev,
 static int i830_dma_init(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;
+        struct drm_file *priv = filp->private_data;
+        struct drm_device *dev = priv->head->dev;
         drm_i830_private_t *dev_priv;
         drm_i830_init_t init;
         int retcode = 0;
@@ -490,7 +489,7 @@ static int i830_dma_init(struct inode *inode, struct file *filp,
 /* Most efficient way to verify state for the i830 is as it is
  * emitted.  Non-conformant state is silently dropped.
  */
-static void i830EmitContextVerified(drm_device_t * dev, unsigned int *code)
+static void i830EmitContextVerified(struct drm_device * dev, unsigned int *code)
 {
         drm_i830_private_t *dev_priv = dev->dev_private;
         int i, j = 0;
@@ -535,7 +534,7 @@ static void i830EmitContextVerified(drm_device_t * dev, unsigned int *code)
         ADVANCE_LP_RING();
 }
 
-static void i830EmitTexVerified(drm_device_t * dev, unsigned int *code)
+static void i830EmitTexVerified(struct drm_device * dev, unsigned int *code)
 {
         drm_i830_private_t *dev_priv = dev->dev_private;
         int i, j = 0;
@@ -569,7 +568,7 @@ static void i830EmitTexVerified(drm_device_t * dev, unsigned int *code)
                 printk("rejected packet %x\n", code[0]);
 }
 
-static void i830EmitTexBlendVerified(drm_device_t * dev,
+static void i830EmitTexBlendVerified(struct drm_device * dev,
                                      unsigned int *code, unsigned int num)
 {
         drm_i830_private_t *dev_priv = dev->dev_private;
@@ -594,7 +593,7 @@ static void i830EmitTexBlendVerified(drm_device_t * dev,
         ADVANCE_LP_RING();
 }
 
-static void i830EmitTexPalette(drm_device_t * dev,
+static void i830EmitTexPalette(struct drm_device * dev,
                                unsigned int *palette, int number, int is_shared)
 {
         drm_i830_private_t *dev_priv = dev->dev_private;
@@ -621,7 +620,7 @@ static void i830EmitTexPalette(drm_device_t * dev,
 
 /* Need to do some additional checking when setting the dest buffer.
  */
-static void i830EmitDestVerified(drm_device_t * dev, unsigned int *code)
+static void i830EmitDestVerified(struct drm_device * dev, unsigned int *code)
 {
         drm_i830_private_t *dev_priv = dev->dev_private;
         unsigned int tmp;
@@ -682,7 +681,7 @@ static void i830EmitDestVerified(drm_device_t * dev, unsigned int *code)
         ADVANCE_LP_RING();
 }
 
-static void i830EmitStippleVerified(drm_device_t * dev, unsigned int *code)
+static void i830EmitStippleVerified(struct drm_device * dev, unsigned int *code)
 {
         drm_i830_private_t *dev_priv = dev->dev_private;
         RING_LOCALS;
@@ -693,7 +692,7 @@ static void i830EmitStippleVerified(drm_device_t * dev, unsigned int *code)
         ADVANCE_LP_RING();
 }
 
-static void i830EmitState(drm_device_t * dev)
+static void i830EmitState(struct drm_device * dev)
 {
         drm_i830_private_t *dev_priv = dev->dev_private;
         drm_i830_sarea_t *sarea_priv = dev_priv->sarea_priv;
@@ -796,7 +795,7 @@ static void i830EmitState(drm_device_t * dev)
  * Performance monitoring functions
  */
 
-static void i830_fill_box(drm_device_t * dev,
+static void i830_fill_box(struct drm_device * dev,
                           int x, int y, int w, int h, int r, int g, int b)
 {
         drm_i830_private_t *dev_priv = dev->dev_private;
@@ -834,7 +833,7 @@ static void i830_fill_box(drm_device_t * dev,
         ADVANCE_LP_RING();
 }
 
-static void i830_cp_performance_boxes(drm_device_t * dev)
+static void i830_cp_performance_boxes(struct drm_device * dev)
 {
         drm_i830_private_t *dev_priv = dev->dev_private;
 
@@ -879,7 +878,7 @@ static void i830_cp_performance_boxes(drm_device_t * dev)
         dev_priv->sarea_priv->perf_boxes = 0;
 }
 
-static void i830_dma_dispatch_clear(drm_device_t * dev, int flags,
+static void i830_dma_dispatch_clear(struct drm_device * dev, int flags,
                                     unsigned int clear_color,
                                     unsigned int clear_zval,
                                     unsigned int clear_depthmask)
@@ -887,7 +886,7 @@ static void i830_dma_dispatch_clear(drm_device_t * dev, int flags,
         drm_i830_private_t *dev_priv = dev->dev_private;
         drm_i830_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 = dev_priv->cpp;
         int i;
@@ -974,12 +973,12 @@ static void i830_dma_dispatch_clear(drm_device_t * dev, int flags,
         }
 }
 
-static void i830_dma_dispatch_swap(drm_device_t * dev)
+static void i830_dma_dispatch_swap(struct drm_device * dev)
 {
         drm_i830_private_t *dev_priv = dev->dev_private;
         drm_i830_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 = dev_priv->cpp;
         int i;
@@ -1044,7 +1043,7 @@ static void i830_dma_dispatch_swap(drm_device_t * dev)
         }
 }
 
-static void i830_dma_dispatch_flip(drm_device_t * dev)
+static void i830_dma_dispatch_flip(struct drm_device * dev)
 {
         drm_i830_private_t *dev_priv = dev->dev_private;
         RING_LOCALS;
@@ -1087,13 +1086,13 @@ static void i830_dma_dispatch_flip(drm_device_t * dev)
         dev_priv->sarea_priv->pf_current_page = dev_priv->current_page;
 }
 
-static void i830_dma_dispatch_vertex(drm_device_t * dev,
-                                     drm_buf_t * buf, int discard, int used)
+static void i830_dma_dispatch_vertex(struct drm_device * dev,
+                                     struct drm_buf * buf, int discard, int used)
 {
         drm_i830_private_t *dev_priv = dev->dev_private;
         drm_i830_buf_priv_t *buf_priv = buf->dev_private;
         drm_i830_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;
@@ -1199,7 +1198,7 @@ static void i830_dma_dispatch_vertex(drm_device_t * dev,
         }
 }
 
-static void i830_dma_quiescent(drm_device_t * dev)
+static void i830_dma_quiescent(struct drm_device * dev)
 {
         drm_i830_private_t *dev_priv = dev->dev_private;
         RING_LOCALS;
@@ -1216,10 +1215,10 @@ static void i830_dma_quiescent(drm_device_t * dev)
         i830_wait_ring(dev, dev_priv->ring.Size - 8, __FUNCTION__);
 }
 
-static int i830_flush_queue(drm_device_t * dev)
+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;
 
@@ -1233,7 +1232,7 @@ static int i830_flush_queue(drm_device_t * dev)
         i830_wait_ring(dev, dev_priv->ring.Size - 8, __FUNCTION__);
 
         for (i = 0; i < dma->buf_count; i++) {
-                drm_buf_t *buf = dma->buflist[i];
+                struct drm_buf *buf = dma->buflist[i];
                 drm_i830_buf_priv_t *buf_priv = buf->dev_private;
 
                 int used = cmpxchg(buf_priv->in_use, I830_BUF_HARDWARE,
@@ -1249,9 +1248,9 @@ static int i830_flush_queue(drm_device_t * dev)
 }
 
 /* Must be called with the lock held */
-static void i830_reclaim_buffers(drm_device_t * dev, struct file *filp)
+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)
@@ -1264,7 +1263,7 @@ static void i830_reclaim_buffers(drm_device_t * dev, struct file *filp)
         i830_flush_queue(dev);
 
         for (i = 0; i < dma->buf_count; i++) {
-                drm_buf_t *buf = dma->buflist[i];
+                struct drm_buf *buf = dma->buflist[i];
                 drm_i830_buf_priv_t *buf_priv = buf->dev_private;
 
                 if (buf->filp == filp && buf_priv) {
@@ -1282,8 +1281,8 @@ static void i830_reclaim_buffers(drm_device_t * dev, struct file *filp)
 static int i830_flush_ioctl(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;
+        struct drm_file *priv = filp->private_data;
+        struct drm_device *dev = priv->head->dev;
 
         LOCK_TEST_WITH_RETURN(dev, filp);
 
@@ -1294,9 +1293,9 @@ static int i830_flush_ioctl(struct inode *inode, struct file *filp,
 static int i830_dma_vertex(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_device_dma_t *dma = dev->dma;
+        struct drm_file *priv = filp->private_data;
+        struct drm_device *dev = priv->head->dev;
+        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 *)
@@ -1328,8 +1327,8 @@ static int i830_dma_vertex(struct inode *inode, struct file *filp,
 static int i830_clear_bufs(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;
+        struct drm_file *priv = filp->private_data;
+        struct drm_device *dev = priv->head->dev;
         drm_i830_clear_t clear;
 
         if (copy_from_user
@@ -1352,8 +1351,8 @@ static int i830_clear_bufs(struct inode *inode, struct file *filp,
 static int i830_swap_bufs(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;
+        struct drm_file *priv = filp->private_data;
+        struct drm_device *dev = priv->head->dev;
 
         DRM_DEBUG("i830_swap_bufs\n");
 
@@ -1365,7 +1364,7 @@ static int i830_swap_bufs(struct inode *inode, struct file *filp,
 
 /* Not sure why this isn't set all the time:
  */
-static void i830_do_init_pageflip(drm_device_t * dev)
+static void i830_do_init_pageflip(struct drm_device * dev)
 {
         drm_i830_private_t *dev_priv = dev->dev_private;
 
@@ -1375,7 +1374,7 @@ static void i830_do_init_pageflip(drm_device_t * dev)
         dev_priv->sarea_priv->pf_current_page = dev_priv->current_page;
 }
 
-static int i830_do_cleanup_pageflip(drm_device_t * dev)
+static int i830_do_cleanup_pageflip(struct drm_device * dev)
 {
         drm_i830_private_t *dev_priv = dev->dev_private;
 
@@ -1390,8 +1389,8 @@ static int i830_do_cleanup_pageflip(drm_device_t * dev)
 static int i830_flip_bufs(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;
+        struct drm_file *priv = filp->private_data;
+        struct drm_device *dev = priv->head->dev;
         drm_i830_private_t *dev_priv = dev->dev_private;
 
         DRM_DEBUG("%s\n", __FUNCTION__);
@@ -1408,8 +1407,8 @@ static int i830_flip_bufs(struct inode *inode, struct file *filp,
 static int i830_getage(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;
+        struct drm_file *priv = filp->private_data;
+        struct drm_device *dev = priv->head->dev;
         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 *)
@@ -1422,8 +1421,8 @@ static int i830_getage(struct inode *inode, struct file *filp, unsigned int cmd,
 static int i830_getbuf(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;
+        struct drm_file *priv = filp->private_data;
+        struct drm_device *dev = priv->head->dev;
         int retcode = 0;
         drm_i830_dma_t d;
         drm_i830_private_t *dev_priv = (drm_i830_private_t *) dev->dev_private;
@@ -1444,7 +1443,7 @@ static int i830_getbuf(struct inode *inode, struct file *filp, unsigned int cmd,
         DRM_DEBUG("i830_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];
 
@@ -1467,8 +1466,8 @@ static int i830_docopy(struct inode *inode, struct file *filp, unsigned int cmd,
 static int i830_getparam(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;
+        struct drm_file *priv = filp->private_data;
+        struct drm_device *dev = priv->head->dev;
         drm_i830_private_t *dev_priv = dev->dev_private;
         drm_i830_getparam_t param;
         int value;
@@ -1501,8 +1500,8 @@ static int i830_getparam(struct inode *inode, struct file *filp,
 static int i830_setparam(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;
+        struct drm_file *priv = filp->private_data;
+        struct drm_device *dev = priv->head->dev;
         drm_i830_private_t *dev_priv = dev->dev_private;
         drm_i830_setparam_t param;
 
@@ -1526,7 +1525,7 @@ static int i830_setparam(struct inode *inode, struct file *filp,
         return 0;
 }
 
-int i830_driver_load(drm_device_t *dev, unsigned long flags)
+int i830_driver_load(struct drm_device *dev, unsigned long flags)
 {
         /* i830 has 4 more counters */
         dev->counters += 4;
@@ -1538,12 +1537,12 @@ int i830_driver_load(drm_device_t *dev, unsigned long flags)
         return 0;
 }
 
-void i830_driver_lastclose(drm_device_t * dev)
+void i830_driver_lastclose(struct drm_device * dev)
 {
         i830_dma_cleanup(dev);
 }
 
-void i830_driver_preclose(drm_device_t * dev, DRMFILE filp)
+void i830_driver_preclose(struct drm_device * dev, DRMFILE filp)
 {
         if (dev->dev_private) {
                 drm_i830_private_t *dev_priv = dev->dev_private;
@@ -1553,12 +1552,12 @@ void i830_driver_preclose(drm_device_t * dev, DRMFILE filp)
         }
 }
 
-void i830_driver_reclaim_buffers_locked(drm_device_t * dev, struct file *filp)
+void i830_driver_reclaim_buffers_locked(struct drm_device * dev, struct file *filp)
 {
         i830_reclaim_buffers(dev, filp);
 }
 
-int i830_driver_dma_quiescent(drm_device_t * dev)
+int i830_driver_dma_quiescent(struct drm_device * dev)
 {
         i830_dma_quiescent(dev);
         return 0;
@@ -1594,7 +1593,7 @@ int i830_max_ioctl = DRM_ARRAY_SIZE(i830_ioctls);
  * \returns
  * A value of 1 is always retured to indictate every i8xx is AGP.
  */
-int i830_driver_device_is_agp(drm_device_t * dev)
+int i830_driver_device_is_agp(struct drm_device * dev)
 {
         return 1;
 }
diff --git a/drivers/char/drm/i830_drm.h b/drivers/char/drm/i830_drm.h
index 66dd75027967..968a6d9f9dcb 100644
--- a/drivers/char/drm/i830_drm.h
+++ b/drivers/char/drm/i830_drm.h
@@ -191,7 +191,7 @@ typedef struct _drm_i830_sarea {
         unsigned int dirty;
 
         unsigned int nbox;
-        drm_clip_rect_t boxes[I830_NR_SAREA_CLIPRECTS];
+        struct drm_clip_rect boxes[I830_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
diff --git a/drivers/char/drm/i830_drv.h b/drivers/char/drm/i830_drv.h
index e91f94afb4bb..ddda67956dea 100644
--- a/drivers/char/drm/i830_drv.h
+++ b/drivers/char/drm/i830_drv.h
@@ -84,8 +84,8 @@ typedef struct _drm_i830_ring_buffer {
 } drm_i830_ring_buffer_t;
 
 typedef struct drm_i830_private {
-        drm_map_t *sarea_map;
-        drm_map_t *mmio_map;
+        struct drm_map *sarea_map;
+        struct drm_map *mmio_map;
 
         drm_i830_sarea_t *sarea_priv;
         drm_i830_ring_buffer_t ring;
@@ -95,7 +95,7 @@ typedef struct drm_i830_private {
 
         dma_addr_t dma_status_page;
 
-        drm_buf_t *mmap_buffer;
+        struct drm_buf *mmap_buffer;
 
         u32 front_di1, back_di1, zi1;
 
@@ -132,16 +132,16 @@ extern int i830_irq_wait(struct inode *inode, struct file *filp,
                          unsigned int cmd, unsigned long arg);
 
 extern irqreturn_t i830_driver_irq_handler(DRM_IRQ_ARGS);
-extern void i830_driver_irq_preinstall(drm_device_t * dev);
-extern void i830_driver_irq_postinstall(drm_device_t * dev);
-extern void i830_driver_irq_uninstall(drm_device_t * dev);
+extern void i830_driver_irq_preinstall(struct drm_device * dev);
+extern void i830_driver_irq_postinstall(struct drm_device * dev);
+extern void i830_driver_irq_uninstall(struct drm_device * dev);
 extern int i830_driver_load(struct drm_device *, unsigned long flags);
-extern void i830_driver_preclose(drm_device_t * dev, DRMFILE filp);
-extern void i830_driver_lastclose(drm_device_t * dev);
-extern void i830_driver_reclaim_buffers_locked(drm_device_t * dev,
+extern void i830_driver_preclose(struct drm_device * dev, DRMFILE filp);
+extern void i830_driver_lastclose(struct drm_device * dev);
+extern void i830_driver_reclaim_buffers_locked(struct drm_device * dev,
                                                struct file *filp);
-extern int i830_driver_dma_quiescent(drm_device_t * dev);
-extern int i830_driver_device_is_agp(drm_device_t * dev);
+extern int i830_driver_dma_quiescent(struct drm_device * dev);
+extern int i830_driver_device_is_agp(struct drm_device * dev);
 
 #define I830_READ(reg)          DRM_READ32(dev_priv->mmio_map, reg)
 #define I830_WRITE(reg,val)     DRM_WRITE32(dev_priv->mmio_map, reg, val)
@@ -180,7 +180,7 @@ extern int i830_driver_device_is_agp(drm_device_t * dev);
         I830_WRITE(LP_RING + RING_TAIL, outring);                       \
 } while(0)
 
-extern int i830_wait_ring(drm_device_t * dev, int n, const char *caller);
+extern int i830_wait_ring(struct drm_device * dev, int n, const char *caller);
 
 #define GFX_OP_USER_INTERRUPT           ((0<<29)|(2<<23))
 #define GFX_OP_BREAKPOINT_INTERRUPT     ((0<<29)|(1<<23))
diff --git a/drivers/char/drm/i830_irq.c b/drivers/char/drm/i830_irq.c
index 5841f7674956..a1b5c63c3c3e 100644
--- a/drivers/char/drm/i830_irq.c
+++ b/drivers/char/drm/i830_irq.c
@@ -35,7 +35,7 @@
 
 irqreturn_t i830_driver_irq_handler(DRM_IRQ_ARGS)
 {
-        drm_device_t *dev = (drm_device_t *) arg;
+        struct drm_device *dev = (struct drm_device *) arg;
         drm_i830_private_t *dev_priv = (drm_i830_private_t *) dev->dev_private;
         u16 temp;
 
@@ -53,7 +53,7 @@ irqreturn_t i830_driver_irq_handler(DRM_IRQ_ARGS)
         return IRQ_HANDLED;
 }
 
-static int i830_emit_irq(drm_device_t * dev)
+static int i830_emit_irq(struct drm_device * dev)
 {
         drm_i830_private_t *dev_priv = dev->dev_private;
         RING_LOCALS;
@@ -70,7 +70,7 @@ static int i830_emit_irq(drm_device_t * dev)
         return atomic_read(&dev_priv->irq_emitted);
 }
 
-static int i830_wait_irq(drm_device_t * dev, int irq_nr)
+static int i830_wait_irq(struct drm_device * dev, int irq_nr)
 {
         drm_i830_private_t *dev_priv = (drm_i830_private_t *) dev->dev_private;
         DECLARE_WAITQUEUE(entry, current);
@@ -117,8 +117,8 @@ static int i830_wait_irq(drm_device_t * dev, int irq_nr)
 int i830_irq_emit(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;
+        struct drm_file *priv = filp->private_data;
+        struct drm_device *dev = priv->head->dev;
         drm_i830_private_t *dev_priv = dev->dev_private;
         drm_i830_irq_emit_t emit;
         int result;
@@ -149,8 +149,8 @@ int i830_irq_emit(struct inode *inode, struct file *filp, unsigned int cmd,
 int i830_irq_wait(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;
+        struct drm_file *priv = filp->private_data;
+        struct drm_device *dev = priv->head->dev;
         drm_i830_private_t *dev_priv = dev->dev_private;
         drm_i830_irq_wait_t irqwait;
 
@@ -168,7 +168,7 @@ int i830_irq_wait(struct inode *inode, struct file *filp, unsigned int cmd,
 
 /* drm_dma.h hooks
 */
-void i830_driver_irq_preinstall(drm_device_t * dev)
+void i830_driver_irq_preinstall(struct drm_device * dev)
 {
         drm_i830_private_t *dev_priv = (drm_i830_private_t *) dev->dev_private;
 
@@ -180,14 +180,14 @@ void i830_driver_irq_preinstall(drm_device_t * dev)
         init_waitqueue_head(&dev_priv->irq_queue);
 }
 
-void i830_driver_irq_postinstall(drm_device_t * dev)
+void i830_driver_irq_postinstall(struct drm_device * dev)
 {
         drm_i830_private_t *dev_priv = (drm_i830_private_t *) dev->dev_private;
 
         I830_WRITE16(I830REG_INT_ENABLE_R, 0x2);
 }
 
-void i830_driver_irq_uninstall(drm_device_t * dev)
+void i830_driver_irq_uninstall(struct drm_device * dev)
 {
         drm_i830_private_t *dev_priv = (drm_i830_private_t *) dev->dev_private;
         if (!dev_priv)
diff --git a/drivers/char/drm/i915_dma.c b/drivers/char/drm/i915_dma.c
index ea52740af4f6..3359cc2b9736 100644
--- a/drivers/char/drm/i915_dma.c
+++ b/drivers/char/drm/i915_dma.c
@@ -47,7 +47,7 @@
  * the head pointer changes, so that EBUSY only happens if the ring
  * actually stalls for (eg) 3 seconds.
  */
-int i915_wait_ring(drm_device_t * dev, int n, const char *caller)
+int i915_wait_ring(struct drm_device * dev, int n, const char *caller)
 {
         drm_i915_private_t *dev_priv = dev->dev_private;
         drm_i915_ring_buffer_t *ring = &(dev_priv->ring);
@@ -73,7 +73,7 @@ int i915_wait_ring(drm_device_t * dev, int n, const char *caller)
         return DRM_ERR(EBUSY);
 }
 
-void i915_kernel_lost_context(drm_device_t * dev)
+void i915_kernel_lost_context(struct drm_device * dev)
 {
         drm_i915_private_t *dev_priv = dev->dev_private;
         drm_i915_ring_buffer_t *ring = &(dev_priv->ring);
@@ -88,7 +88,7 @@ void i915_kernel_lost_context(drm_device_t * dev)
                 dev_priv->sarea_priv->perf_boxes |= I915_BOX_RING_EMPTY;
 }
 
-static int i915_dma_cleanup(drm_device_t * dev)
+static int i915_dma_cleanup(struct drm_device * dev)
 {
         /* Make sure interrupts are disabled here because the uninstall ioctl
          * may not have been called from userspace and after dev_private
@@ -126,13 +126,13 @@ static int i915_dma_cleanup(drm_device_t * dev)
         return 0;
 }
 
-static int i915_initialize(drm_device_t * dev,
+static int i915_initialize(struct drm_device * dev,
                            drm_i915_private_t * dev_priv,
                            drm_i915_init_t * init)
 {
         memset(dev_priv, 0, sizeof(drm_i915_private_t));
 
-        DRM_GETSAREA();
+        dev_priv->sarea = drm_getsarea(dev);
         if (!dev_priv->sarea) {
                 DRM_ERROR("can not find sarea!\n");
                 dev->dev_private = (void *)dev_priv;
@@ -211,7 +211,7 @@ static int i915_initialize(drm_device_t * dev,
         return 0;
 }
 
-static int i915_dma_resume(drm_device_t * dev)
+static int i915_dma_resume(struct drm_device * dev)
 {
         drm_i915_private_t *dev_priv = (drm_i915_private_t *) dev->dev_private;
 
@@ -357,7 +357,7 @@ static int validate_cmd(int cmd)
         return ret;
 }
 
-static int i915_emit_cmds(drm_device_t * dev, int __user * buffer, int dwords)
+static int i915_emit_cmds(struct drm_device * dev, int __user * buffer, int dwords)
 {
         drm_i915_private_t *dev_priv = dev->dev_private;
         int i;
@@ -396,12 +396,12 @@ static int i915_emit_cmds(drm_device_t * dev, int __user * buffer, int dwords)
         return 0;
 }
 
-static int i915_emit_box(drm_device_t * dev,
-                         drm_clip_rect_t __user * boxes,
+static int i915_emit_box(struct drm_device * dev,
+                         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))) {
@@ -439,7 +439,7 @@ static int i915_emit_box(drm_device_t * dev,
  * emit. For now, do it in both places:
  */
 
-static void i915_emit_breadcrumb(drm_device_t *dev)
+static void i915_emit_breadcrumb(struct drm_device *dev)
 {
         drm_i915_private_t *dev_priv = dev->dev_private;
         RING_LOCALS;
@@ -457,7 +457,7 @@ static void i915_emit_breadcrumb(drm_device_t *dev)
         ADVANCE_LP_RING();
 }
 
-static int i915_dispatch_cmdbuffer(drm_device_t * dev,
+static int i915_dispatch_cmdbuffer(struct drm_device * dev,
                                    drm_i915_cmdbuffer_t * cmd)
 {
         int nbox = cmd->num_cliprects;
@@ -489,11 +489,11 @@ static int i915_dispatch_cmdbuffer(drm_device_t * dev,
         return 0;
 }
 
-static int i915_dispatch_batchbuffer(drm_device_t * dev,
+static int i915_dispatch_batchbuffer(struct drm_device * 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;
@@ -535,7 +535,7 @@ static int i915_dispatch_batchbuffer(drm_device_t * dev,
         return 0;
 }
 
-static int i915_dispatch_flip(drm_device_t * dev)
+static int i915_dispatch_flip(struct drm_device * dev)
 {
         drm_i915_private_t *dev_priv = dev->dev_private;
         RING_LOCALS;
@@ -583,7 +583,7 @@ static int i915_dispatch_flip(drm_device_t * dev)
         return 0;
 }
 
-static int i915_quiescent(drm_device_t * dev)
+static int i915_quiescent(struct drm_device * dev)
 {
         drm_i915_private_t *dev_priv = dev->dev_private;
 
@@ -625,7 +625,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);
@@ -655,7 +655,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);
         }
@@ -792,7 +792,7 @@ static int i915_set_status_page(DRM_IOCTL_ARGS)
         return 0;
 }
 
-int i915_driver_load(drm_device_t *dev, unsigned long flags)
+int i915_driver_load(struct drm_device *dev, unsigned long flags)
 {
         /* i915 has 4 more counters */
         dev->counters += 4;
@@ -804,7 +804,7 @@ int i915_driver_load(drm_device_t *dev, unsigned long flags)
         return 0;
 }
 
-void i915_driver_lastclose(drm_device_t * dev)
+void i915_driver_lastclose(struct drm_device * dev)
 {
         if (dev->dev_private) {
                 drm_i915_private_t *dev_priv = dev->dev_private;
@@ -813,7 +813,7 @@ void i915_driver_lastclose(drm_device_t * dev)
         i915_dma_cleanup(dev);
 }
 
-void i915_driver_preclose(drm_device_t * dev, DRMFILE filp)
+void i915_driver_preclose(struct drm_device * dev, DRMFILE filp)
 {
         if (dev->dev_private) {
                 drm_i915_private_t *dev_priv = dev->dev_private;
@@ -854,7 +854,7 @@ int i915_max_ioctl = DRM_ARRAY_SIZE(i915_ioctls);
  * \returns
  * A value of 1 is always retured to indictate every i9x5 is AGP.
  */
-int i915_driver_device_is_agp(drm_device_t * dev)
+int i915_driver_device_is_agp(struct drm_device * dev)
 {
         return 1;
 }
diff --git a/drivers/char/drm/i915_drm.h b/drivers/char/drm/i915_drm.h
index 7b7b68b96f31..05c66cf03a9e 100644
--- a/drivers/char/drm/i915_drm.h
+++ b/drivers/char/drm/i915_drm.h
@@ -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 */
@@ -170,7 +170,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
@@ -182,7 +182,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:
@@ -259,7 +259,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;
 
diff --git a/drivers/char/drm/i915_drv.h b/drivers/char/drm/i915_drv.h
index 85e323acb95d..fd918565f4e5 100644
--- a/drivers/char/drm/i915_drv.h
+++ b/drivers/char/drm/i915_drv.h
@@ -120,11 +120,11 @@ extern drm_ioctl_desc_t i915_ioctls[];
 extern int i915_max_ioctl;
 
                                 /* i915_dma.c */
-extern void i915_kernel_lost_context(drm_device_t * dev);
+extern void i915_kernel_lost_context(struct drm_device * dev);
 extern int i915_driver_load(struct drm_device *, unsigned long flags);
-extern void i915_driver_lastclose(drm_device_t * dev);
-extern void i915_driver_preclose(drm_device_t * dev, DRMFILE filp);
-extern int i915_driver_device_is_agp(drm_device_t * dev);
+extern void i915_driver_lastclose(struct drm_device * dev);
+extern void i915_driver_preclose(struct drm_device * dev, DRMFILE filp);
+extern int i915_driver_device_is_agp(struct drm_device * dev);
 extern long i915_compat_ioctl(struct file *filp, unsigned int cmd,
                               unsigned long arg);
 
@@ -132,12 +132,12 @@ extern long i915_compat_ioctl(struct file *filp, unsigned int cmd,
 extern int i915_irq_emit(DRM_IOCTL_ARGS);
 extern int i915_irq_wait(DRM_IOCTL_ARGS);
 
-extern int i915_driver_vblank_wait(drm_device_t *dev, unsigned int *sequence);
-extern int i915_driver_vblank_wait2(drm_device_t *dev, unsigned int *sequence);
+extern int i915_driver_vblank_wait(struct drm_device *dev, unsigned int *sequence);
+extern int i915_driver_vblank_wait2(struct drm_device *dev, unsigned int *sequence);
 extern irqreturn_t i915_driver_irq_handler(DRM_IRQ_ARGS);
-extern void i915_driver_irq_preinstall(drm_device_t * dev);
-extern void i915_driver_irq_postinstall(drm_device_t * dev);
-extern void i915_driver_irq_uninstall(drm_device_t * dev);
+extern void i915_driver_irq_preinstall(struct drm_device * dev);
+extern void i915_driver_irq_postinstall(struct drm_device * dev);
+extern void i915_driver_irq_uninstall(struct drm_device * dev);
 extern int i915_vblank_pipe_set(DRM_IOCTL_ARGS);
 extern int i915_vblank_pipe_get(DRM_IOCTL_ARGS);
 extern int i915_vblank_swap(DRM_IOCTL_ARGS);
@@ -148,7 +148,7 @@ extern int i915_mem_free(DRM_IOCTL_ARGS);
 extern int i915_mem_init_heap(DRM_IOCTL_ARGS);
 extern int i915_mem_destroy_heap(DRM_IOCTL_ARGS);
 extern void i915_mem_takedown(struct mem_block **heap);
-extern void i915_mem_release(drm_device_t * dev,
+extern void i915_mem_release(struct drm_device * dev,
                              DRMFILE filp, struct mem_block *heap);
 
 #define I915_READ(reg)          DRM_READ32(dev_priv->mmio_map, (reg))
@@ -188,7 +188,7 @@ extern void i915_mem_release(drm_device_t * dev,
         I915_WRITE(LP_RING + RING_TAIL, outring);                       \
 } while(0)
 
-extern int i915_wait_ring(drm_device_t * dev, int n, const char *caller);
+extern int i915_wait_ring(struct drm_device * dev, int n, const char *caller);
 
 #define GFX_OP_USER_INTERRUPT           ((0<<29)|(2<<23))
 #define GFX_OP_BREAKPOINT_INTERRUPT     ((0<<29)|(1<<23))
diff --git a/drivers/char/drm/i915_irq.c b/drivers/char/drm/i915_irq.c
index b92062a239f1..4b4b2ce89863 100644
--- a/drivers/char/drm/i915_irq.c
+++ b/drivers/char/drm/i915_irq.c
@@ -42,7 +42,7 @@
  *
  * This function will be called with the HW lock held.
  */
-static void i915_vblank_tasklet(drm_device_t *dev)
+static void i915_vblank_tasklet(struct drm_device *dev)
 {
         drm_i915_private_t *dev_priv = (drm_i915_private_t *) dev->dev_private;
         unsigned long irqflags;
@@ -50,7 +50,7 @@ static void i915_vblank_tasklet(drm_device_t *dev)
         int nhits, nrects, slice[2], upper[2], lower[2], i;
         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;
         u32 cmd = (cpp == 4) ? (XY_SRC_COPY_BLT_CMD |
@@ -95,7 +95,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 &&
@@ -160,7 +160,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;
                         unsigned short top, bottom;
 
@@ -211,7 +211,7 @@ static void i915_vblank_tasklet(drm_device_t *dev)
 
 irqreturn_t i915_driver_irq_handler(DRM_IRQ_ARGS)
 {
-        drm_device_t *dev = (drm_device_t *) arg;
+        struct drm_device *dev = (struct drm_device *) arg;
         drm_i915_private_t *dev_priv = (drm_i915_private_t *) dev->dev_private;
         u16 temp;
 
@@ -257,7 +257,7 @@ irqreturn_t i915_driver_irq_handler(DRM_IRQ_ARGS)
         return IRQ_HANDLED;
 }
 
-static int i915_emit_irq(drm_device_t * dev)
+static int i915_emit_irq(struct drm_device * dev)
 {
         drm_i915_private_t *dev_priv = dev->dev_private;
         RING_LOCALS;
@@ -283,7 +283,7 @@ static int i915_emit_irq(drm_device_t * dev)
         return dev_priv->counter;
 }
 
-static int i915_wait_irq(drm_device_t * dev, int irq_nr)
+static int i915_wait_irq(struct drm_device * dev, int irq_nr)
 {
         drm_i915_private_t *dev_priv = (drm_i915_private_t *) dev->dev_private;
         int ret = 0;
@@ -309,7 +309,7 @@ static int i915_wait_irq(drm_device_t * dev, int irq_nr)
         return ret;
 }
 
-static int i915_driver_vblank_do_wait(drm_device_t *dev, unsigned int *sequence,
+static int i915_driver_vblank_do_wait(struct drm_device *dev, unsigned int *sequence,
                                       atomic_t *counter)
 {
         drm_i915_private_t *dev_priv = dev->dev_private;
@@ -331,12 +331,12 @@ static int i915_driver_vblank_do_wait(drm_device_t *dev, unsigned int *sequence,
 }
 
 
-int i915_driver_vblank_wait(drm_device_t *dev, unsigned int *sequence)
+int i915_driver_vblank_wait(struct drm_device *dev, unsigned int *sequence)
 {
         return i915_driver_vblank_do_wait(dev, sequence, &dev->vbl_received);
 }
 
-int i915_driver_vblank_wait2(drm_device_t *dev, unsigned int *sequence)
+int i915_driver_vblank_wait2(struct drm_device *dev, unsigned int *sequence)
 {
         return i915_driver_vblank_do_wait(dev, sequence, &dev->vbl_received2);
 }
@@ -389,7 +389,7 @@ int i915_irq_wait(DRM_IOCTL_ARGS)
         return i915_wait_irq(dev, irqwait.irq_seq);
 }
 
-static void i915_enable_interrupt (drm_device_t *dev)
+static void i915_enable_interrupt (struct drm_device *dev)
 {
         drm_i915_private_t *dev_priv = (drm_i915_private_t *) dev->dev_private;
         u16 flag;
@@ -569,7 +569,7 @@ int i915_vblank_swap(DRM_IOCTL_ARGS)
 
 /* drm_dma.h hooks
 */
-void i915_driver_irq_preinstall(drm_device_t * dev)
+void i915_driver_irq_preinstall(struct drm_device * dev)
 {
         drm_i915_private_t *dev_priv = (drm_i915_private_t *) dev->dev_private;
 
@@ -578,7 +578,7 @@ void i915_driver_irq_preinstall(drm_device_t * dev)
         I915_WRITE16(I915REG_INT_ENABLE_R, 0x0);
 }
 
-void i915_driver_irq_postinstall(drm_device_t * dev)
+void i915_driver_irq_postinstall(struct drm_device * dev)
 {
         drm_i915_private_t *dev_priv = (drm_i915_private_t *) dev->dev_private;
 
@@ -592,7 +592,7 @@ void i915_driver_irq_postinstall(drm_device_t * dev)
         DRM_INIT_WAITQUEUE(&dev_priv->irq_queue);
 }
 
-void i915_driver_irq_uninstall(drm_device_t * dev)
+void i915_driver_irq_uninstall(struct drm_device * dev)
 {
         drm_i915_private_t *dev_priv = (drm_i915_private_t *) dev->dev_private;
         u16 temp;
diff --git a/drivers/char/drm/i915_mem.c b/drivers/char/drm/i915_mem.c
index 52c67324df58..50b4bacef0e0 100644
--- a/drivers/char/drm/i915_mem.c
+++ b/drivers/char/drm/i915_mem.c
@@ -43,11 +43,11 @@
  * block to allocate, and the ring is drained prior to allocations --
  * in other words allocation is expensive.
  */
-static void mark_block(drm_device_t * dev, struct mem_block *p, int in_use)
+static void mark_block(struct drm_device * 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;
@@ -208,7 +208,7 @@ static int init_heap(struct mem_block **heap, int start, int size)
 
 /* Free all blocks associated with the releasing file.
  */
-void i915_mem_release(drm_device_t * dev, DRMFILE filp, struct mem_block *heap)
+void i915_mem_release(struct drm_device * dev, DRMFILE filp, struct mem_block *heap)
 {
         struct mem_block *p;
 
diff --git a/drivers/char/drm/mga_dma.c b/drivers/char/drm/mga_dma.c
index c2a4bac14521..9c73a6e3861b 100644
--- a/drivers/char/drm/mga_dma.c
+++ b/drivers/char/drm/mga_dma.c
@@ -46,7 +46,7 @@
 
 #define MINIMAL_CLEANUP 0
 #define FULL_CLEANUP 1
-static int mga_do_cleanup_dma(drm_device_t *dev, int full_cleanup);
+static int mga_do_cleanup_dma(struct drm_device *dev, int full_cleanup);
 
 /* ================================================================
  * Engine control
@@ -224,7 +224,7 @@ void mga_do_dma_wrap_end(drm_mga_private_t * dev_priv)
 #define MGA_BUFFER_FREE         0
 
 #if MGA_FREELIST_DEBUG
-static void mga_freelist_print(drm_device_t * dev)
+static void mga_freelist_print(struct drm_device * dev)
 {
         drm_mga_private_t *dev_priv = dev->dev_private;
         drm_mga_freelist_t *entry;
@@ -245,10 +245,10 @@ static void mga_freelist_print(drm_device_t * dev)
 }
 #endif
 
-static int mga_freelist_init(drm_device_t * dev, drm_mga_private_t * dev_priv)
+static int mga_freelist_init(struct drm_device * dev, drm_mga_private_t * dev_priv)
 {
-        drm_device_dma_t *dma = dev->dma;
-        drm_buf_t *buf;
+        struct drm_device_dma *dma = dev->dma;
+        struct drm_buf *buf;
         drm_mga_buf_priv_t *buf_priv;
         drm_mga_freelist_t *entry;
         int i;
@@ -291,7 +291,7 @@ static int mga_freelist_init(drm_device_t * dev, drm_mga_private_t * dev_priv)
         return 0;
 }
 
-static void mga_freelist_cleanup(drm_device_t * dev)
+static void mga_freelist_cleanup(struct drm_device * dev)
 {
         drm_mga_private_t *dev_priv = dev->dev_private;
         drm_mga_freelist_t *entry;
@@ -311,10 +311,10 @@ static void mga_freelist_cleanup(drm_device_t * dev)
 #if 0
 /* FIXME: Still needed?
  */
-static void mga_freelist_reset(drm_device_t * dev)
+static void mga_freelist_reset(struct drm_device * dev)
 {
-        drm_device_dma_t *dma = dev->dma;
-        drm_buf_t *buf;
+        struct drm_device_dma *dma = dev->dma;
+        struct drm_buf *buf;
         drm_mga_buf_priv_t *buf_priv;
         int i;
 
@@ -326,7 +326,7 @@ static void mga_freelist_reset(drm_device_t * dev)
 }
 #endif
 
-static drm_buf_t *mga_freelist_get(drm_device_t * dev)
+static struct drm_buf *mga_freelist_get(struct drm_device * dev)
 {
         drm_mga_private_t *dev_priv = dev->dev_private;
         drm_mga_freelist_t *next;
@@ -359,7 +359,7 @@ static drm_buf_t *mga_freelist_get(drm_device_t * dev)
         return NULL;
 }
 
-int mga_freelist_put(drm_device_t * dev, drm_buf_t * buf)
+int mga_freelist_put(struct drm_device * dev, struct drm_buf * buf)
 {
         drm_mga_private_t *dev_priv = dev->dev_private;
         drm_mga_buf_priv_t *buf_priv = buf->dev_private;
@@ -393,7 +393,7 @@ int mga_freelist_put(drm_device_t * dev, drm_buf_t * buf)
  * DMA initialization, cleanup
  */
 
-int mga_driver_load(drm_device_t * dev, unsigned long flags)
+int mga_driver_load(struct drm_device * dev, unsigned long flags)
 {
         drm_mga_private_t *dev_priv;
 
@@ -434,7 +434,7 @@ int mga_driver_load(drm_device_t * dev, unsigned long flags)
  *
  * \sa mga_do_dma_bootstrap, mga_do_pci_dma_bootstrap
  */
-static int mga_do_agp_dma_bootstrap(drm_device_t * dev,
+static int mga_do_agp_dma_bootstrap(struct drm_device * dev,
                                     drm_mga_dma_bootstrap_t * dma_bs)
 {
         drm_mga_private_t *const dev_priv =
@@ -445,11 +445,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);
@@ -548,10 +548,10 @@ static int mga_do_agp_dma_bootstrap(drm_device_t * dev,
         }
 
         {
-                drm_map_list_t *_entry;
+                struct drm_map_list *_entry;
                 unsigned long agp_token = 0;
                 
-                list_for_each_entry(_entry, &dev->maplist->head, head) {
+                list_for_each_entry(_entry, &dev->maplist, head) {
                         if (_entry->map == dev->agp_buffer_map)
                                 agp_token = _entry->user_token;
                 }
@@ -588,7 +588,7 @@ static int mga_do_agp_dma_bootstrap(drm_device_t * dev,
         return 0;
 }
 #else
-static int mga_do_agp_dma_bootstrap(drm_device_t * dev,
+static int mga_do_agp_dma_bootstrap(struct drm_device * dev,
                                     drm_mga_dma_bootstrap_t * dma_bs)
 {
         return -EINVAL;
@@ -609,7 +609,7 @@ static int mga_do_agp_dma_bootstrap(drm_device_t * dev,
  *
  * \sa mga_do_dma_bootstrap, mga_do_agp_dma_bootstrap
  */
-static int mga_do_pci_dma_bootstrap(drm_device_t * dev,
+static int mga_do_pci_dma_bootstrap(struct drm_device * dev,
                                     drm_mga_dma_bootstrap_t * dma_bs)
 {
         drm_mga_private_t *const dev_priv =
@@ -618,7 +618,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) {
                 DRM_ERROR("dev->dma is NULL\n");
@@ -699,7 +699,7 @@ static int mga_do_pci_dma_bootstrap(drm_device_t * dev,
         return 0;
 }
 
-static int mga_do_dma_bootstrap(drm_device_t * dev,
+static int mga_do_dma_bootstrap(struct drm_device * dev,
                                 drm_mga_dma_bootstrap_t * dma_bs)
 {
         const int is_agp = (dma_bs->agp_mode != 0) && drm_device_is_agp(dev);
@@ -793,7 +793,7 @@ int mga_dma_bootstrap(DRM_IOCTL_ARGS)
         return err;
 }
 
-static int mga_do_init_dma(drm_device_t * dev, drm_mga_init_t * init)
+static int mga_do_init_dma(struct drm_device * dev, drm_mga_init_t * init)
 {
         drm_mga_private_t *dev_priv;
         int ret;
@@ -823,8 +823,7 @@ static int mga_do_init_dma(drm_device_t * dev, drm_mga_init_t * init)
         dev_priv->texture_offset = init->texture_offset[0];
         dev_priv->texture_size = init->texture_size[0];
 
-        DRM_GETSAREA();
-
+        dev_priv->sarea = drm_getsarea(dev);
         if (!dev_priv->sarea) {
                 DRM_ERROR("failed to find sarea!\n");
                 return DRM_ERR(EINVAL);
@@ -934,7 +933,7 @@ static int mga_do_init_dma(drm_device_t * dev, drm_mga_init_t * init)
         return 0;
 }
 
-static int mga_do_cleanup_dma(drm_device_t *dev, int full_cleanup)
+static int mga_do_cleanup_dma(struct drm_device *dev, int full_cleanup)
 {
         int err = 0;
         DRM_DEBUG("\n");
@@ -963,8 +962,8 @@ static int mga_do_cleanup_dma(drm_device_t *dev, int full_cleanup)
                 if (dev_priv->used_new_dma_init) {
 #if __OS_HAS_AGP
                         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);
@@ -1041,11 +1040,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",
@@ -1087,9 +1086,9 @@ 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, struct drm_device * dev, struct drm_dma * d)
 {
-        drm_buf_t *buf;
+        struct drm_buf *buf;
         int i;
 
         for (i = d->granted_count; i < d->request_count; i++) {
@@ -1114,10 +1113,10 @@ static int mga_dma_get_buffers(DRMFILE filp, drm_device_t * dev, drm_dma_t * d)
 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;
-        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);
@@ -1156,7 +1155,7 @@ int mga_dma_buffers(DRM_IOCTL_ARGS)
 /**
  * Called just before the module is unloaded.
  */
-int mga_driver_unload(drm_device_t * dev)
+int mga_driver_unload(struct drm_device * dev)
 {
         drm_free(dev->dev_private, sizeof(drm_mga_private_t), DRM_MEM_DRIVER);
         dev->dev_private = NULL;
@@ -1167,12 +1166,12 @@ int mga_driver_unload(drm_device_t * dev)
 /**
  * Called when the last opener of the device is closed.
  */
-void mga_driver_lastclose(drm_device_t * dev)
+void mga_driver_lastclose(struct drm_device * dev)
 {
         mga_do_cleanup_dma(dev, FULL_CLEANUP);
 }
 
-int mga_driver_dma_quiescent(drm_device_t * dev)
+int mga_driver_dma_quiescent(struct drm_device * dev)
 {
         drm_mga_private_t *dev_priv = dev->dev_private;
         return mga_do_wait_for_idle(dev_priv);
diff --git a/drivers/char/drm/mga_drm.h b/drivers/char/drm/mga_drm.h
index 44d1293e2947..944b50a5ff24 100644
--- a/drivers/char/drm/mga_drm.h
+++ b/drivers/char/drm/mga_drm.h
@@ -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.
diff --git a/drivers/char/drm/mga_drv.c b/drivers/char/drm/mga_drv.c
index be49dbb9ec3f..5572939fc7d1 100644
--- a/drivers/char/drm/mga_drv.c
+++ b/drivers/char/drm/mga_drv.c
@@ -36,7 +36,7 @@
 
 #include "drm_pciids.h"
 
-static int mga_driver_device_is_agp(drm_device_t * dev);
+static int mga_driver_device_is_agp(struct drm_device * dev);
 
 static struct pci_device_id pciidlist[] = {
         mga_PCI_IDS
@@ -118,7 +118,7 @@ MODULE_LICENSE("GPL and additional rights");
  * \returns
  * If the device is a PCI G450, zero is returned.  Otherwise 2 is returned.
  */
-static int mga_driver_device_is_agp(drm_device_t * dev)
+static int mga_driver_device_is_agp(struct drm_device * dev)
 {
         const struct pci_dev *const pdev = dev->pdev;
 
diff --git a/drivers/char/drm/mga_drv.h b/drivers/char/drm/mga_drv.h
index 6b0c53193506..49253affa475 100644
--- a/drivers/char/drm/mga_drv.h
+++ b/drivers/char/drm/mga_drv.h
@@ -65,7 +65,7 @@ typedef struct drm_mga_freelist {
         struct drm_mga_freelist *next;
         struct drm_mga_freelist *prev;
         drm_mga_age_t age;
-        drm_buf_t *buf;
+        struct drm_buf *buf;
 } drm_mga_freelist_t;
 
 typedef struct {
@@ -157,10 +157,10 @@ extern int mga_dma_init(DRM_IOCTL_ARGS);
 extern int mga_dma_flush(DRM_IOCTL_ARGS);
 extern int mga_dma_reset(DRM_IOCTL_ARGS);
 extern int mga_dma_buffers(DRM_IOCTL_ARGS);
-extern int mga_driver_load(drm_device_t *dev, unsigned long flags);
-extern int mga_driver_unload(drm_device_t * dev);
-extern void mga_driver_lastclose(drm_device_t * dev);
-extern int mga_driver_dma_quiescent(drm_device_t * dev);
+extern int mga_driver_load(struct drm_device *dev, unsigned long flags);
+extern int mga_driver_unload(struct drm_device * dev);
+extern void mga_driver_lastclose(struct drm_device * dev);
+extern int mga_driver_dma_quiescent(struct drm_device * dev);
 
 extern int mga_do_wait_for_idle(drm_mga_private_t * dev_priv);
 
@@ -168,7 +168,7 @@ extern void mga_do_dma_flush(drm_mga_private_t * dev_priv);
 extern void mga_do_dma_wrap_start(drm_mga_private_t * dev_priv);
 extern void mga_do_dma_wrap_end(drm_mga_private_t * dev_priv);
 
-extern int mga_freelist_put(drm_device_t * dev, drm_buf_t * buf);
+extern int mga_freelist_put(struct drm_device * dev, struct drm_buf * buf);
 
                                 /* mga_warp.c */
 extern unsigned int mga_warp_microcode_size(const drm_mga_private_t * dev_priv);
@@ -176,12 +176,12 @@ extern int mga_warp_install_microcode(drm_mga_private_t * dev_priv);
 extern int mga_warp_init(drm_mga_private_t * dev_priv);
 
                                 /* mga_irq.c */
-extern int mga_driver_fence_wait(drm_device_t * dev, unsigned int *sequence);
-extern int mga_driver_vblank_wait(drm_device_t * dev, unsigned int *sequence);
+extern int mga_driver_fence_wait(struct drm_device * dev, unsigned int *sequence);
+extern int mga_driver_vblank_wait(struct drm_device * dev, unsigned int *sequence);
 extern irqreturn_t mga_driver_irq_handler(DRM_IRQ_ARGS);
-extern void mga_driver_irq_preinstall(drm_device_t * dev);
-extern void mga_driver_irq_postinstall(drm_device_t * dev);
-extern void mga_driver_irq_uninstall(drm_device_t * dev);
+extern void mga_driver_irq_preinstall(struct drm_device * dev);
+extern void mga_driver_irq_postinstall(struct drm_device * dev);
+extern void mga_driver_irq_uninstall(struct drm_device * dev);
 extern long mga_compat_ioctl(struct file *filp, unsigned int cmd,
                              unsigned long arg);
 
diff --git a/drivers/char/drm/mga_irq.c b/drivers/char/drm/mga_irq.c
index eb9644024172..9302cb8f0f83 100644
--- a/drivers/char/drm/mga_irq.c
+++ b/drivers/char/drm/mga_irq.c
@@ -37,7 +37,7 @@
 
 irqreturn_t mga_driver_irq_handler(DRM_IRQ_ARGS)
 {
-        drm_device_t *dev = (drm_device_t *) arg;
+        struct drm_device *dev = (struct drm_device *) arg;
         drm_mga_private_t *dev_priv = (drm_mga_private_t *) dev->dev_private;
         int status;
         int handled = 0;
@@ -78,7 +78,7 @@ irqreturn_t mga_driver_irq_handler(DRM_IRQ_ARGS)
         return IRQ_NONE;
 }
 
-int mga_driver_vblank_wait(drm_device_t * dev, unsigned int *sequence)
+int mga_driver_vblank_wait(struct drm_device * dev, unsigned int *sequence)
 {
         unsigned int cur_vblank;
         int ret = 0;
@@ -96,7 +96,7 @@ int mga_driver_vblank_wait(drm_device_t * dev, unsigned int *sequence)
         return ret;
 }
 
-int mga_driver_fence_wait(drm_device_t * dev, unsigned int *sequence)
+int mga_driver_fence_wait(struct drm_device * dev, unsigned int *sequence)
 {
         drm_mga_private_t *dev_priv = (drm_mga_private_t *) dev->dev_private;
         unsigned int cur_fence;
@@ -115,7 +115,7 @@ int mga_driver_fence_wait(drm_device_t * dev, unsigned int *sequence)
         return ret;
 }
 
-void mga_driver_irq_preinstall(drm_device_t * dev)
+void mga_driver_irq_preinstall(struct drm_device * dev)
 {
         drm_mga_private_t *dev_priv = (drm_mga_private_t *) dev->dev_private;
 
@@ -125,7 +125,7 @@ void mga_driver_irq_preinstall(drm_device_t * dev)
         MGA_WRITE(MGA_ICLEAR, ~0);
 }
 
-void mga_driver_irq_postinstall(drm_device_t * dev)
+void mga_driver_irq_postinstall(struct drm_device * dev)
 {
         drm_mga_private_t *dev_priv = (drm_mga_private_t *) dev->dev_private;
 
@@ -135,7 +135,7 @@ void mga_driver_irq_postinstall(drm_device_t * dev)
         MGA_WRITE(MGA_IEN, MGA_VLINEIEN | MGA_SOFTRAPEN);
 }
 
-void mga_driver_irq_uninstall(drm_device_t * dev)
+void mga_driver_irq_uninstall(struct drm_device * dev)
 {
         drm_mga_private_t *dev_priv = (drm_mga_private_t *) dev->dev_private;
         if (!dev_priv)
diff --git a/drivers/char/drm/mga_state.c b/drivers/char/drm/mga_state.c
index 2837e669183a..d448b0aef33c 100644
--- a/drivers/char/drm/mga_state.c
+++ b/drivers/char/drm/mga_state.c
@@ -42,7 +42,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;
@@ -480,12 +480,12 @@ static int mga_verify_blit(drm_mga_private_t * dev_priv,
  *
  */
 
-static void mga_dma_dispatch_clear(drm_device_t * dev, drm_mga_clear_t * clear)
+static void mga_dma_dispatch_clear(struct drm_device * 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;
@@ -500,7 +500,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",
@@ -568,12 +568,12 @@ static void mga_dma_dispatch_clear(drm_device_t * dev, drm_mga_clear_t * clear)
         FLUSH_DMA();
 }
 
-static void mga_dma_dispatch_swap(drm_device_t * dev)
+static void mga_dma_dispatch_swap(struct drm_device * 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;
@@ -598,7 +598,7 @@ static void mga_dma_dispatch_swap(drm_device_t * dev)
                   MGA_PLNWT, 0xffffffff, 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;
 
@@ -622,7 +622,7 @@ static void mga_dma_dispatch_swap(drm_device_t * dev)
         DRM_DEBUG("%s... done.\n", __FUNCTION__);
 }
 
-static void mga_dma_dispatch_vertex(drm_device_t * dev, drm_buf_t * buf)
+static void mga_dma_dispatch_vertex(struct drm_device * dev, struct drm_buf * buf)
 {
         drm_mga_private_t *dev_priv = dev->dev_private;
         drm_mga_buf_priv_t *buf_priv = buf->dev_private;
@@ -669,7 +669,7 @@ static void mga_dma_dispatch_vertex(drm_device_t * dev, drm_buf_t * buf)
         FLUSH_DMA();
 }
 
-static void mga_dma_dispatch_indices(drm_device_t * dev, drm_buf_t * buf,
+static void mga_dma_dispatch_indices(struct drm_device * dev, struct drm_buf * buf,
                                      unsigned int start, unsigned int end)
 {
         drm_mga_private_t *dev_priv = dev->dev_private;
@@ -718,7 +718,7 @@ static void mga_dma_dispatch_indices(drm_device_t * dev, drm_buf_t * buf,
 /* This copies a 64 byte aligned agp region to the frambuffer with a
  * standard blit, the ioctl needs to do checking.
  */
-static void mga_dma_dispatch_iload(drm_device_t * dev, drm_buf_t * buf,
+static void mga_dma_dispatch_iload(struct drm_device * dev, struct drm_buf * buf,
                                    unsigned int dstorg, unsigned int length)
 {
         drm_mga_private_t *dev_priv = dev->dev_private;
@@ -766,12 +766,12 @@ static void mga_dma_dispatch_iload(drm_device_t * dev, drm_buf_t * buf,
         FLUSH_DMA();
 }
 
-static void mga_dma_dispatch_blit(drm_device_t * dev, drm_mga_blit_t * blit)
+static void mga_dma_dispatch_blit(struct drm_device * 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;
@@ -880,8 +880,8 @@ static int mga_dma_vertex(DRM_IOCTL_ARGS)
 {
         DRM_DEVICE;
         drm_mga_private_t *dev_priv = dev->dev_private;
-        drm_device_dma_t *dma = dev->dma;
-        drm_buf_t *buf;
+        struct drm_device_dma *dma = dev->dma;
+        struct drm_buf *buf;
         drm_mga_buf_priv_t *buf_priv;
         drm_mga_vertex_t vertex;
 
@@ -920,8 +920,8 @@ static int mga_dma_indices(DRM_IOCTL_ARGS)
 {
         DRM_DEVICE;
         drm_mga_private_t *dev_priv = dev->dev_private;
-        drm_device_dma_t *dma = dev->dma;
-        drm_buf_t *buf;
+        struct drm_device_dma *dma = dev->dma;
+        struct drm_buf *buf;
         drm_mga_buf_priv_t *buf_priv;
         drm_mga_indices_t indices;
 
@@ -959,9 +959,9 @@ static int mga_dma_indices(DRM_IOCTL_ARGS)
 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;
-        drm_buf_t *buf;
+        struct drm_buf *buf;
         drm_mga_buf_priv_t *buf_priv;
         drm_mga_iload_t iload;
         DRM_DEBUG("\n");
diff --git a/drivers/char/drm/r128_cce.c b/drivers/char/drm/r128_cce.c
index 1014602c43a7..b163ed09bd81 100644
--- a/drivers/char/drm/r128_cce.c
+++ b/drivers/char/drm/r128_cce.c
@@ -81,7 +81,7 @@ static u32 r128_cce_microcode[] = {
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
 };
 
-static int R128_READ_PLL(drm_device_t * dev, int addr)
+static int R128_READ_PLL(struct drm_device * dev, int addr)
 {
         drm_r128_private_t *dev_priv = dev->dev_private;
 
@@ -271,7 +271,7 @@ static void r128_do_cce_stop(drm_r128_private_t * dev_priv)
 
 /* Reset the engine.  This will stop the CCE if it is running.
  */
-static int r128_do_engine_reset(drm_device_t * dev)
+static int r128_do_engine_reset(struct drm_device * dev)
 {
         drm_r128_private_t *dev_priv = dev->dev_private;
         u32 clock_cntl_index, mclk_cntl, gen_reset_cntl;
@@ -308,7 +308,7 @@ static int r128_do_engine_reset(drm_device_t * dev)
         return 0;
 }
 
-static void r128_cce_init_ring_buffer(drm_device_t * dev,
+static void r128_cce_init_ring_buffer(struct drm_device * dev,
                                       drm_r128_private_t * dev_priv)
 {
         u32 ring_start;
@@ -347,7 +347,7 @@ static void r128_cce_init_ring_buffer(drm_device_t * dev,
         R128_WRITE(R128_BUS_CNTL, tmp);
 }
 
-static int r128_do_init_cce(drm_device_t * dev, drm_r128_init_t * init)
+static int r128_do_init_cce(struct drm_device * dev, drm_r128_init_t * init)
 {
         drm_r128_private_t *dev_priv;
 
@@ -456,8 +456,7 @@ static int r128_do_init_cce(drm_device_t * dev, drm_r128_init_t * init)
         dev_priv->span_pitch_offset_c = (((dev_priv->depth_pitch / 8) << 21) |
                                          (dev_priv->span_offset >> 5));
 
-        DRM_GETSAREA();
-
+        dev_priv->sarea = drm_getsarea(dev);
         if (!dev_priv->sarea) {
                 DRM_ERROR("could not find sarea!\n");
                 dev->dev_private = (void *)dev_priv;
@@ -585,7 +584,7 @@ static int r128_do_init_cce(drm_device_t * dev, drm_r128_init_t * init)
         return 0;
 }
 
-int r128_do_cleanup_cce(drm_device_t * dev)
+int r128_do_cleanup_cce(struct drm_device * dev)
 {
 
         /* Make sure interrupts are disabled here because the uninstall ioctl
@@ -770,11 +769,11 @@ int r128_fullscreen(DRM_IOCTL_ARGS)
 #define R128_BUFFER_FREE        0
 
 #if 0
-static int r128_freelist_init(drm_device_t * dev)
+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;
-        drm_buf_t *buf;
+        struct drm_buf *buf;
         drm_r128_buf_priv_t *buf_priv;
         drm_r128_freelist_t *entry;
         int i;
@@ -816,12 +815,12 @@ static int r128_freelist_init(drm_device_t * dev)
 }
 #endif
 
-static drm_buf_t *r128_freelist_get(drm_device_t * dev)
+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;
-        drm_buf_t *buf;
+        struct drm_buf *buf;
         int i, t;
 
         /* FIXME: Optimize -- use freelist code */
@@ -854,13 +853,13 @@ static drm_buf_t *r128_freelist_get(drm_device_t * dev)
         return NULL;
 }
 
-void r128_freelist_reset(drm_device_t * dev)
+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++) {
-                drm_buf_t *buf = dma->buflist[i];
+                struct drm_buf *buf = dma->buflist[i];
                 drm_r128_buf_priv_t *buf_priv = buf->dev_private;
                 buf_priv->age = 0;
         }
@@ -887,10 +886,10 @@ 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, struct drm_device * dev, struct drm_dma * d)
 {
         int i;
-        drm_buf_t *buf;
+        struct drm_buf *buf;
 
         for (i = d->granted_count; i < d->request_count; i++) {
                 buf = r128_freelist_get(dev);
@@ -914,10 +913,10 @@ static int r128_cce_get_buffers(DRMFILE filp, drm_device_t * dev, drm_dma_t * d)
 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;
-        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);
 
diff --git a/drivers/char/drm/r128_drm.h b/drivers/char/drm/r128_drm.h
index 6e8af313f2b4..e94a39c6e327 100644
--- a/drivers/char/drm/r128_drm.h
+++ b/drivers/char/drm/r128_drm.h
@@ -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) */
diff --git a/drivers/char/drm/r128_drv.h b/drivers/char/drm/r128_drv.h
index 9086835686dc..72249fb2fd1c 100644
--- a/drivers/char/drm/r128_drv.h
+++ b/drivers/char/drm/r128_drv.h
@@ -57,7 +57,7 @@
 
 typedef struct drm_r128_freelist {
         unsigned int age;
-        drm_buf_t *buf;
+        struct drm_buf *buf;
         struct drm_r128_freelist *next;
         struct drm_r128_freelist *prev;
 } drm_r128_freelist_t;
@@ -118,7 +118,7 @@ typedef struct drm_r128_private {
         drm_local_map_t *cce_ring;
         drm_local_map_t *ring_rptr;
         drm_local_map_t *agp_textures;
-        drm_ati_pcigart_info gart_info;
+        struct drm_ati_pcigart_info gart_info;
 } drm_r128_private_t;
 
 typedef struct drm_r128_buf_priv {
@@ -142,21 +142,21 @@ extern int r128_engine_reset(DRM_IOCTL_ARGS);
 extern int r128_fullscreen(DRM_IOCTL_ARGS);
 extern int r128_cce_buffers(DRM_IOCTL_ARGS);
 
-extern void r128_freelist_reset(drm_device_t * dev);
+extern void r128_freelist_reset(struct drm_device * dev);
 
 extern int r128_wait_ring(drm_r128_private_t * dev_priv, int n);
 
 extern int r128_do_cce_idle(drm_r128_private_t * dev_priv);
-extern int r128_do_cleanup_cce(drm_device_t * dev);
+extern int r128_do_cleanup_cce(struct drm_device * dev);
 
-extern int r128_driver_vblank_wait(drm_device_t * dev, unsigned int *sequence);
+extern int r128_driver_vblank_wait(struct drm_device * dev, unsigned int *sequence);
 
 extern irqreturn_t r128_driver_irq_handler(DRM_IRQ_ARGS);
-extern void r128_driver_irq_preinstall(drm_device_t * dev);
-extern void r128_driver_irq_postinstall(drm_device_t * dev);
-extern void r128_driver_irq_uninstall(drm_device_t * dev);
-extern void r128_driver_lastclose(drm_device_t * dev);
-extern void r128_driver_preclose(drm_device_t * dev, DRMFILE filp);
+extern void r128_driver_irq_preinstall(struct drm_device * dev);
+extern void r128_driver_irq_postinstall(struct drm_device * dev);
+extern void r128_driver_irq_uninstall(struct drm_device * dev);
+extern void r128_driver_lastclose(struct drm_device * dev);
+extern void r128_driver_preclose(struct drm_device * dev, DRMFILE filp);
 
 extern long r128_compat_ioctl(struct file *filp, unsigned int cmd,
                               unsigned long arg);
diff --git a/drivers/char/drm/r128_irq.c b/drivers/char/drm/r128_irq.c
index 87f8ca2b0685..c76fdca7662d 100644
--- a/drivers/char/drm/r128_irq.c
+++ b/drivers/char/drm/r128_irq.c
@@ -37,7 +37,7 @@
 
 irqreturn_t r128_driver_irq_handler(DRM_IRQ_ARGS)
 {
-        drm_device_t *dev = (drm_device_t *) arg;
+        struct drm_device *dev = (struct drm_device *) arg;
         drm_r128_private_t *dev_priv = (drm_r128_private_t *) dev->dev_private;
         int status;
 
@@ -54,7 +54,7 @@ irqreturn_t r128_driver_irq_handler(DRM_IRQ_ARGS)
         return IRQ_NONE;
 }
 
-int r128_driver_vblank_wait(drm_device_t * dev, unsigned int *sequence)
+int r128_driver_vblank_wait(struct drm_device * dev, unsigned int *sequence)
 {
         unsigned int cur_vblank;
         int ret = 0;
@@ -72,7 +72,7 @@ int r128_driver_vblank_wait(drm_device_t * dev, unsigned int *sequence)
         return ret;
 }
 
-void r128_driver_irq_preinstall(drm_device_t * dev)
+void r128_driver_irq_preinstall(struct drm_device * dev)
 {
         drm_r128_private_t *dev_priv = (drm_r128_private_t *) dev->dev_private;
 
@@ -82,7 +82,7 @@ void r128_driver_irq_preinstall(drm_device_t * dev)
         R128_WRITE(R128_GEN_INT_STATUS, R128_CRTC_VBLANK_INT_AK);
 }
 
-void r128_driver_irq_postinstall(drm_device_t * dev)
+void r128_driver_irq_postinstall(struct drm_device * dev)
 {
         drm_r128_private_t *dev_priv = (drm_r128_private_t *) dev->dev_private;
 
@@ -90,7 +90,7 @@ void r128_driver_irq_postinstall(drm_device_t * dev)
         R128_WRITE(R128_GEN_INT_CNTL, R128_CRTC_VBLANK_INT_EN);
 }
 
-void r128_driver_irq_uninstall(drm_device_t * dev)
+void r128_driver_irq_uninstall(struct drm_device * dev)
 {
         drm_r128_private_t *dev_priv = (drm_r128_private_t *) dev->dev_private;
         if (!dev_priv)
diff --git a/drivers/char/drm/r128_state.c b/drivers/char/drm/r128_state.c
index 17b11e7d8f32..7b334fb7d649 100644
--- a/drivers/char/drm/r128_state.c
+++ b/drivers/char/drm/r128_state.c
@@ -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;
@@ -352,13 +352,13 @@ static void r128_print_dirty(const char *msg, unsigned int flags)
                  (flags & R128_REQUIRE_QUIESCENCE) ? "quiescence, " : "");
 }
 
-static void r128_cce_dispatch_clear(drm_device_t * dev,
+static void r128_cce_dispatch_clear(struct drm_device * dev,
                                     drm_r128_clear_t * clear)
 {
         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;
@@ -458,12 +458,12 @@ static void r128_cce_dispatch_clear(drm_device_t * dev,
         }
 }
 
-static void r128_cce_dispatch_swap(drm_device_t * dev)
+static void r128_cce_dispatch_swap(struct drm_device * 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__);
@@ -524,7 +524,7 @@ static void r128_cce_dispatch_swap(drm_device_t * dev)
         ADVANCE_RING();
 }
 
-static void r128_cce_dispatch_flip(drm_device_t * dev)
+static void r128_cce_dispatch_flip(struct drm_device * dev)
 {
         drm_r128_private_t *dev_priv = dev->dev_private;
         RING_LOCALS;
@@ -567,7 +567,7 @@ static void r128_cce_dispatch_flip(drm_device_t * dev)
         ADVANCE_RING();
 }
 
-static void r128_cce_dispatch_vertex(drm_device_t * dev, drm_buf_t * buf)
+static void r128_cce_dispatch_vertex(struct drm_device * dev, struct drm_buf * buf)
 {
         drm_r128_private_t *dev_priv = dev->dev_private;
         drm_r128_buf_priv_t *buf_priv = buf->dev_private;
@@ -637,8 +637,8 @@ static void r128_cce_dispatch_vertex(drm_device_t * dev, drm_buf_t * buf)
         sarea_priv->nbox = 0;
 }
 
-static void r128_cce_dispatch_indirect(drm_device_t * dev,
-                                       drm_buf_t * buf, int start, int end)
+static void r128_cce_dispatch_indirect(struct drm_device * dev,
+                                       struct drm_buf * buf, int start, int end)
 {
         drm_r128_private_t *dev_priv = dev->dev_private;
         drm_r128_buf_priv_t *buf_priv = buf->dev_private;
@@ -692,8 +692,8 @@ static void r128_cce_dispatch_indirect(drm_device_t * dev,
         dev_priv->sarea_priv->last_dispatch++;
 }
 
-static void r128_cce_dispatch_indices(drm_device_t * dev,
-                                      drm_buf_t * buf,
+static void r128_cce_dispatch_indices(struct drm_device * dev,
+                                      struct drm_buf * buf,
                                       int start, int end, int count)
 {
         drm_r128_private_t *dev_priv = dev->dev_private;
@@ -777,11 +777,11 @@ static void r128_cce_dispatch_indices(drm_device_t * dev,
 }
 
 static int r128_cce_dispatch_blit(DRMFILE filp,
-                                  drm_device_t * dev, drm_r128_blit_t * blit)
+                                  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;
-        drm_buf_t *buf;
+        struct drm_device_dma *dma = dev->dma;
+        struct drm_buf *buf;
         drm_r128_buf_priv_t *buf_priv;
         u32 *data;
         int dword_shift, dwords;
@@ -887,7 +887,7 @@ static int r128_cce_dispatch_blit(DRMFILE filp,
  * have hardware stencil support.
  */
 
-static int r128_cce_dispatch_write_span(drm_device_t * dev,
+static int r128_cce_dispatch_write_span(struct drm_device * dev,
                                         drm_r128_depth_t * depth)
 {
         drm_r128_private_t *dev_priv = dev->dev_private;
@@ -983,7 +983,7 @@ static int r128_cce_dispatch_write_span(drm_device_t * dev,
         return 0;
 }
 
-static int r128_cce_dispatch_write_pixels(drm_device_t * dev,
+static int r128_cce_dispatch_write_pixels(struct drm_device * dev,
                                           drm_r128_depth_t * depth)
 {
         drm_r128_private_t *dev_priv = dev->dev_private;
@@ -1105,7 +1105,7 @@ static int r128_cce_dispatch_write_pixels(drm_device_t * dev,
         return 0;
 }
 
-static int r128_cce_dispatch_read_span(drm_device_t * dev,
+static int r128_cce_dispatch_read_span(struct drm_device * dev,
                                        drm_r128_depth_t * depth)
 {
         drm_r128_private_t *dev_priv = dev->dev_private;
@@ -1148,7 +1148,7 @@ static int r128_cce_dispatch_read_span(drm_device_t * dev,
         return 0;
 }
 
-static int r128_cce_dispatch_read_pixels(drm_device_t * dev,
+static int r128_cce_dispatch_read_pixels(struct drm_device * dev,
                                          drm_r128_depth_t * depth)
 {
         drm_r128_private_t *dev_priv = dev->dev_private;
@@ -1220,7 +1220,7 @@ static int r128_cce_dispatch_read_pixels(drm_device_t * dev,
  * Polygon stipple
  */
 
-static void r128_cce_dispatch_stipple(drm_device_t * dev, u32 * stipple)
+static void r128_cce_dispatch_stipple(struct drm_device * dev, u32 * stipple)
 {
         drm_r128_private_t *dev_priv = dev->dev_private;
         int i;
@@ -1269,7 +1269,7 @@ static int r128_cce_clear(DRM_IOCTL_ARGS)
         return 0;
 }
 
-static int r128_do_init_pageflip(drm_device_t * dev)
+static int r128_do_init_pageflip(struct drm_device * dev)
 {
         drm_r128_private_t *dev_priv = dev->dev_private;
         DRM_DEBUG("\n");
@@ -1288,7 +1288,7 @@ static int r128_do_init_pageflip(drm_device_t * dev)
         return 0;
 }
 
-static int r128_do_cleanup_pageflip(drm_device_t * dev)
+static int r128_do_cleanup_pageflip(struct drm_device * dev)
 {
         drm_r128_private_t *dev_priv = dev->dev_private;
         DRM_DEBUG("\n");
@@ -1354,8 +1354,8 @@ static int r128_cce_vertex(DRM_IOCTL_ARGS)
 {
         DRM_DEVICE;
         drm_r128_private_t *dev_priv = dev->dev_private;
-        drm_device_dma_t *dma = dev->dma;
-        drm_buf_t *buf;
+        struct drm_device_dma *dma = dev->dma;
+        struct drm_buf *buf;
         drm_r128_buf_priv_t *buf_priv;
         drm_r128_vertex_t vertex;
 
@@ -1413,8 +1413,8 @@ static int r128_cce_indices(DRM_IOCTL_ARGS)
 {
         DRM_DEVICE;
         drm_r128_private_t *dev_priv = dev->dev_private;
-        drm_device_dma_t *dma = dev->dma;
-        drm_buf_t *buf;
+        struct drm_device_dma *dma = dev->dma;
+        struct drm_buf *buf;
         drm_r128_buf_priv_t *buf_priv;
         drm_r128_indices_t elts;
         int count;
@@ -1483,7 +1483,7 @@ static int r128_cce_indices(DRM_IOCTL_ARGS)
 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;
@@ -1571,8 +1571,8 @@ static int r128_cce_indirect(DRM_IOCTL_ARGS)
 {
         DRM_DEVICE;
         drm_r128_private_t *dev_priv = dev->dev_private;
-        drm_device_dma_t *dma = dev->dma;
-        drm_buf_t *buf;
+        struct drm_device_dma *dma = dev->dma;
+        struct drm_buf *buf;
         drm_r128_buf_priv_t *buf_priv;
         drm_r128_indirect_t indirect;
 #if 0
@@ -1675,7 +1675,7 @@ static int r128_getparam(DRM_IOCTL_ARGS)
         return 0;
 }
 
-void r128_driver_preclose(drm_device_t * dev, DRMFILE filp)
+void r128_driver_preclose(struct drm_device * dev, DRMFILE filp)
 {
         if (dev->dev_private) {
                 drm_r128_private_t *dev_priv = dev->dev_private;
@@ -1685,7 +1685,7 @@ void r128_driver_preclose(drm_device_t * dev, DRMFILE filp)
         }
 }
 
-void r128_driver_lastclose(drm_device_t * dev)
+void r128_driver_lastclose(struct drm_device * dev)
 {
         r128_do_cleanup_cce(dev);
 }
diff --git a/drivers/char/drm/r300_cmdbuf.c b/drivers/char/drm/r300_cmdbuf.c
index 032a022ec6a8..4e5aca6ba59a 100644
--- a/drivers/char/drm/r300_cmdbuf.c
+++ b/drivers/char/drm/r300_cmdbuf.c
@@ -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;
@@ -148,15 +148,16 @@ void r300_init_reg_flags(void)
 
         /* these match cmducs() command in r300_driver/r300/r300_cmdbuf.c */
         ADD_RANGE(R300_SE_VPORT_XSCALE, 6);
-        ADD_RANGE(0x2080, 1);
+        ADD_RANGE(R300_VAP_CNTL, 1);
         ADD_RANGE(R300_SE_VTE_CNTL, 2);
         ADD_RANGE(0x2134, 2);
-        ADD_RANGE(0x2140, 1);
+        ADD_RANGE(R300_VAP_CNTL_STATUS, 1);
         ADD_RANGE(R300_VAP_INPUT_CNTL_0, 2);
         ADD_RANGE(0x21DC, 1);
-        ADD_RANGE(0x221C, 1);
-        ADD_RANGE(0x2220, 4);
-        ADD_RANGE(0x2288, 1);
+        ADD_RANGE(R300_VAP_UNKNOWN_221C, 1);
+        ADD_RANGE(R300_VAP_CLIP_X_0, 4);
+        ADD_RANGE(R300_VAP_PVS_WAITIDLE, 1);
+        ADD_RANGE(R300_VAP_UNKNOWN_2288, 1);
         ADD_RANGE(R300_VAP_OUTPUT_VTX_FMT_0, 2);
         ADD_RANGE(R300_VAP_PVS_CNTL_1, 3);
         ADD_RANGE(R300_GB_ENABLE, 1);
@@ -168,13 +169,13 @@ void r300_init_reg_flags(void)
         ADD_RANGE(R300_RE_POINTSIZE, 1);
         ADD_RANGE(0x4230, 3);
         ADD_RANGE(R300_RE_LINE_CNT, 1);
-        ADD_RANGE(0x4238, 1);
+        ADD_RANGE(R300_RE_UNK4238, 1);
         ADD_RANGE(0x4260, 3);
-        ADD_RANGE(0x4274, 4);
-        ADD_RANGE(0x4288, 5);
-        ADD_RANGE(0x42A0, 1);
+        ADD_RANGE(R300_RE_SHADE, 4);
+        ADD_RANGE(R300_RE_POLYGON_MODE, 5);
+        ADD_RANGE(R300_RE_ZBIAS_CNTL, 1);
         ADD_RANGE(R300_RE_ZBIAS_T_FACTOR, 4);
-        ADD_RANGE(0x42B4, 1);
+        ADD_RANGE(R300_RE_OCCLUSION_CNTL, 1);
         ADD_RANGE(R300_RE_CULL_CNTL, 1);
         ADD_RANGE(0x42C0, 2);
         ADD_RANGE(R300_RS_CNTL_0, 2);
@@ -190,22 +191,22 @@ void r300_init_reg_flags(void)
         ADD_RANGE(R300_PFS_INSTR1_0, 64);
         ADD_RANGE(R300_PFS_INSTR2_0, 64);
         ADD_RANGE(R300_PFS_INSTR3_0, 64);
-        ADD_RANGE(0x4BC0, 1);
-        ADD_RANGE(0x4BC8, 3);
+        ADD_RANGE(R300_RE_FOG_STATE, 1);
+        ADD_RANGE(R300_FOG_COLOR_R, 3);
         ADD_RANGE(R300_PP_ALPHA_TEST, 2);
         ADD_RANGE(0x4BD8, 1);
         ADD_RANGE(R300_PFS_PARAM_0_X, 64);
         ADD_RANGE(0x4E00, 1);
         ADD_RANGE(R300_RB3D_CBLEND, 2);
         ADD_RANGE(R300_RB3D_COLORMASK, 1);
-        ADD_RANGE(0x4E10, 3);
+        ADD_RANGE(R300_RB3D_BLEND_COLOR, 3);
         ADD_RANGE_MARK(R300_RB3D_COLOROFFSET0, 1, MARK_CHECK_OFFSET);   /* check offset */
         ADD_RANGE(R300_RB3D_COLORPITCH0, 1);
         ADD_RANGE(0x4E50, 9);
         ADD_RANGE(0x4E88, 1);
         ADD_RANGE(0x4EA0, 2);
         ADD_RANGE(R300_RB3D_ZSTENCIL_CNTL_0, 3);
-        ADD_RANGE(0x4F10, 4);
+        ADD_RANGE(R300_RB3D_ZSTENCIL_FORMAT, 4);
         ADD_RANGE_MARK(R300_RB3D_DEPTHOFFSET, 1, MARK_CHECK_OFFSET);    /* check offset */
         ADD_RANGE(R300_RB3D_DEPTHPITCH, 1);
         ADD_RANGE(0x4F28, 1);
@@ -224,7 +225,7 @@ void r300_init_reg_flags(void)
         ADD_RANGE(R300_TX_BORDER_COLOR_0, 16);
 
         /* Sporadic registers used as primitives are emitted */
-        ADD_RANGE(0x4f18, 1);
+        ADD_RANGE(R300_RB3D_ZCACHE_CTLSTAT, 1);
         ADD_RANGE(R300_RB3D_DSTCACHE_CTLSTAT, 1);
         ADD_RANGE(R300_VAP_INPUT_ROUTE_0_0, 8);
         ADD_RANGE(R300_VAP_INPUT_ROUTE_1_0, 8);
@@ -692,9 +693,9 @@ static __inline__ void r300_pacify(drm_radeon_private_t *dev_priv)
 
         BEGIN_RING(6);
         OUT_RING(CP_PACKET0(R300_RB3D_DSTCACHE_CTLSTAT, 0));
-        OUT_RING(0xa);
-        OUT_RING(CP_PACKET0(0x4f18, 0));
-        OUT_RING(0x3);
+        OUT_RING(R300_RB3D_DSTCACHE_UNKNOWN_0A);
+        OUT_RING(CP_PACKET0(R300_RB3D_ZCACHE_CTLSTAT, 0));
+        OUT_RING(R300_RB3D_ZCACHE_UNKNOWN_03);
         OUT_RING(CP_PACKET3(RADEON_CP_NOP, 0));
         OUT_RING(0x0);
         ADVANCE_RING();
@@ -705,7 +706,7 @@ static __inline__ void r300_pacify(drm_radeon_private_t *dev_priv)
  * The actual age emit is done by r300_do_cp_cmdbuf, which is why you must
  * be careful about how this function is called.
  */
-static void r300_discard_buffer(drm_device_t * dev, drm_buf_t * buf)
+static void r300_discard_buffer(struct drm_device * dev, struct drm_buf * buf)
 {
         drm_radeon_private_t *dev_priv = dev->dev_private;
         drm_radeon_buf_priv_t *buf_priv = buf->dev_private;
@@ -766,8 +767,8 @@ static int r300_scratch(drm_radeon_private_t *dev_priv,
         }
         
         BEGIN_RING(2);
-        OUT_RING(CP_PACKET0(RADEON_SCRATCH_REG0 + header.scratch.reg * 4, 0));
-        OUT_RING(dev_priv->scratch_ages[header.scratch.reg]);
+        OUT_RING( CP_PACKET0( RADEON_SCRATCH_REG0 + header.scratch.reg * 4, 0 ) );
+        OUT_RING( dev_priv->scratch_ages[header.scratch.reg] );
         ADVANCE_RING();
         
         return 0;
@@ -778,14 +779,14 @@ static int r300_scratch(drm_radeon_private_t *dev_priv,
  * commands on the DMA ring buffer.
  * Called by the ioctl handler function radeon_cp_cmdbuf.
  */
-int r300_do_cp_cmdbuf(drm_device_t *dev,
+int r300_do_cp_cmdbuf(struct drm_device *dev,
                       DRMFILE filp,
-                      drm_file_t *filp_priv,
+                      struct drm_file *filp_priv,
                       drm_radeon_kcmd_buffer_t *cmdbuf)
 {
         drm_radeon_private_t *dev_priv = dev->dev_private;
-        drm_device_dma_t *dma = dev->dma;
-        drm_buf_t *buf = NULL;
+        struct drm_device_dma *dma = dev->dma;
+        struct drm_buf *buf = NULL;
         int emit_dispatch_age = 0;
         int ret = 0;
 
diff --git a/drivers/char/drm/r300_reg.h b/drivers/char/drm/r300_reg.h
index ecda760ae8c0..3ae57ecc7afd 100644
--- a/drivers/char/drm/r300_reg.h
+++ b/drivers/char/drm/r300_reg.h
@@ -47,12 +47,12 @@ USE OR OTHER DEALINGS IN THE SOFTWARE.
 #       define R300_MC_MISC__MC_GLOBW_FULL_LAT_SHIFT    28
 
 /*
-This file contains registers and constants for the R300. They have been
-found mostly by examining command buffers captured using glxtest, as well
-as by extrapolating some known registers and constants from the R200.
-
-I am fairly certain that they are correct unless stated otherwise in comments.
-*/
+ * This file contains registers and constants for the R300. They have been
+ * found mostly by examining command buffers captured using glxtest, as well
+ * as by extrapolating some known registers and constants from the R200.
+ * I am fairly certain that they are correct unless stated otherwise
+ * in comments.
+ */
 
 #define R300_SE_VPORT_XSCALE                0x1D98
 #define R300_SE_VPORT_XOFFSET               0x1D9C
@@ -61,49 +61,60 @@ I am fairly certain that they are correct unless stated otherwise in comments.
 #define R300_SE_VPORT_ZSCALE                0x1DA8
 #define R300_SE_VPORT_ZOFFSET               0x1DAC
 
-/* This register is written directly and also starts data section in many 3d CP_PACKET3's */
-#define R300_VAP_VF_CNTL        0x2084
 
-#       define  R300_VAP_VF_CNTL__PRIM_TYPE__SHIFT                       0
-#       define  R300_VAP_VF_CNTL__PRIM_NONE                              (0<<0)
-#       define  R300_VAP_VF_CNTL__PRIM_POINTS                            (1<<0)
-#       define  R300_VAP_VF_CNTL__PRIM_LINES                             (2<<0)
-#       define  R300_VAP_VF_CNTL__PRIM_LINE_STRIP                        (3<<0)
-#       define  R300_VAP_VF_CNTL__PRIM_TRIANGLES                         (4<<0)
-#       define  R300_VAP_VF_CNTL__PRIM_TRIANGLE_FAN                      (5<<0)
-#       define  R300_VAP_VF_CNTL__PRIM_TRIANGLE_STRIP                    (6<<0)
-#       define  R300_VAP_VF_CNTL__PRIM_LINE_LOOP                         (12<<0)
-#       define  R300_VAP_VF_CNTL__PRIM_QUADS                             (13<<0)
-#       define  R300_VAP_VF_CNTL__PRIM_QUAD_STRIP                        (14<<0)
-#       define  R300_VAP_VF_CNTL__PRIM_POLYGON                           (15<<0)
-
-#       define  R300_VAP_VF_CNTL__PRIM_WALK__SHIFT                       4
-        /* State based - direct writes to registers trigger vertex generation */
-#       define  R300_VAP_VF_CNTL__PRIM_WALK_STATE_BASED                      (0<<4)
-#       define  R300_VAP_VF_CNTL__PRIM_WALK_INDICES                          (1<<4)
-#       define  R300_VAP_VF_CNTL__PRIM_WALK_VERTEX_LIST                      (2<<4)
-#       define  R300_VAP_VF_CNTL__PRIM_WALK_VERTEX_EMBEDDED                  (3<<4)
-
-                /* I don't think I saw these three used.. */
-#       define  R300_VAP_VF_CNTL__COLOR_ORDER__SHIFT                     6
-#       define  R300_VAP_VF_CNTL__TCL_OUTPUT_CTL_ENA__SHIFT              9
-#       define  R300_VAP_VF_CNTL__PROG_STREAM_ENA__SHIFT                 10
-
-                /* index size - when not set the indices are assumed to be 16 bit */
-#       define  R300_VAP_VF_CNTL__INDEX_SIZE_32bit                      (1<<11)
-                /* number of vertices */
-#       define  R300_VAP_VF_CNTL__NUM_VERTICES__SHIFT                    16
+/*
+ * Vertex Array Processing (VAP) Control
+ * Stolen from r200 code from Christoph Brill (It's a guess!)
+ */
+#define R300_VAP_CNTL   0x2080
+
+/* This register is written directly and also starts data section
+ * in many 3d CP_PACKET3's
+ */
+#define R300_VAP_VF_CNTL        0x2084
+#       define  R300_VAP_VF_CNTL__PRIM_TYPE__SHIFT              0
+#       define  R300_VAP_VF_CNTL__PRIM_NONE                     (0<<0)
+#       define  R300_VAP_VF_CNTL__PRIM_POINTS                   (1<<0)
+#       define  R300_VAP_VF_CNTL__PRIM_LINES                    (2<<0)
+#       define  R300_VAP_VF_CNTL__PRIM_LINE_STRIP               (3<<0)
+#       define  R300_VAP_VF_CNTL__PRIM_TRIANGLES                (4<<0)
+#       define  R300_VAP_VF_CNTL__PRIM_TRIANGLE_FAN             (5<<0)
+#       define  R300_VAP_VF_CNTL__PRIM_TRIANGLE_STRIP           (6<<0)
+#       define  R300_VAP_VF_CNTL__PRIM_LINE_LOOP                (12<<0)
+#       define  R300_VAP_VF_CNTL__PRIM_QUADS                    (13<<0)
+#       define  R300_VAP_VF_CNTL__PRIM_QUAD_STRIP               (14<<0)
+#       define  R300_VAP_VF_CNTL__PRIM_POLYGON                  (15<<0)
+
+#       define  R300_VAP_VF_CNTL__PRIM_WALK__SHIFT              4
+        /* State based - direct writes to registers trigger vertex
+           generation */
+#       define  R300_VAP_VF_CNTL__PRIM_WALK_STATE_BASED         (0<<4)
+#       define  R300_VAP_VF_CNTL__PRIM_WALK_INDICES             (1<<4)
+#       define  R300_VAP_VF_CNTL__PRIM_WALK_VERTEX_LIST         (2<<4)
+#       define  R300_VAP_VF_CNTL__PRIM_WALK_VERTEX_EMBEDDED     (3<<4)
+
+        /* I don't think I saw these three used.. */
+#       define  R300_VAP_VF_CNTL__COLOR_ORDER__SHIFT            6
+#       define  R300_VAP_VF_CNTL__TCL_OUTPUT_CTL_ENA__SHIFT     9
+#       define  R300_VAP_VF_CNTL__PROG_STREAM_ENA__SHIFT        10
+
+        /* index size - when not set the indices are assumed to be 16 bit */
+#       define  R300_VAP_VF_CNTL__INDEX_SIZE_32bit              (1<<11)
+        /* number of vertices */
+#       define  R300_VAP_VF_CNTL__NUM_VERTICES__SHIFT           16
 
 /* BEGIN: Wild guesses */
 #define R300_VAP_OUTPUT_VTX_FMT_0           0x2090
 #       define R300_VAP_OUTPUT_VTX_FMT_0__POS_PRESENT     (1<<0)
 #       define R300_VAP_OUTPUT_VTX_FMT_0__COLOR_PRESENT   (1<<1)
-#       define R300_VAP_OUTPUT_VTX_FMT_0__COLOR_1_PRESENT (1<<2)        /* GUESS */
-#       define R300_VAP_OUTPUT_VTX_FMT_0__COLOR_2_PRESENT (1<<3)        /* GUESS */
-#       define R300_VAP_OUTPUT_VTX_FMT_0__COLOR_3_PRESENT (1<<4)        /* GUESS */
-#       define R300_VAP_OUTPUT_VTX_FMT_0__PT_SIZE_PRESENT (1<<16)       /* GUESS */
+#       define R300_VAP_OUTPUT_VTX_FMT_0__COLOR_1_PRESENT (1<<2)  /* GUESS */
+#       define R300_VAP_OUTPUT_VTX_FMT_0__COLOR_2_PRESENT (1<<3)  /* GUESS */
+#       define R300_VAP_OUTPUT_VTX_FMT_0__COLOR_3_PRESENT (1<<4)  /* GUESS */
+#       define R300_VAP_OUTPUT_VTX_FMT_0__PT_SIZE_PRESENT (1<<16) /* GUESS */
 
 #define R300_VAP_OUTPUT_VTX_FMT_1           0x2094
+        /* each of the following is 3 bits wide, specifies number
+           of components */
 #       define R300_VAP_OUTPUT_VTX_FMT_1__TEX_0_COMP_CNT_SHIFT 0
 #       define R300_VAP_OUTPUT_VTX_FMT_1__TEX_1_COMP_CNT_SHIFT 3
 #       define R300_VAP_OUTPUT_VTX_FMT_1__TEX_2_COMP_CNT_SHIFT 6
@@ -112,7 +123,7 @@ I am fairly certain that they are correct unless stated otherwise in comments.
 #       define R300_VAP_OUTPUT_VTX_FMT_1__TEX_5_COMP_CNT_SHIFT 15
 #       define R300_VAP_OUTPUT_VTX_FMT_1__TEX_6_COMP_CNT_SHIFT 18
 #       define R300_VAP_OUTPUT_VTX_FMT_1__TEX_7_COMP_CNT_SHIFT 21
-/* END */
+/* END: Wild guesses */
 
 #define R300_SE_VTE_CNTL                  0x20b0
 #       define     R300_VPORT_X_SCALE_ENA                0x00000001
@@ -128,43 +139,54 @@ I am fairly certain that they are correct unless stated otherwise in comments.
 #       define     R300_VTX_ST_DENORMALIZED              0x00001000
 
 /* BEGIN: Vertex data assembly - lots of uncertainties */
+
+/* gap */
+
+#define R300_VAP_CNTL_STATUS              0x2140
+#       define R300_VC_NO_SWAP                  (0 << 0)
+#       define R300_VC_16BIT_SWAP               (1 << 0)
+#       define R300_VC_32BIT_SWAP               (2 << 0)
+#       define R300_VAP_TCL_BYPASS              (1 << 8)
+
 /* gap */
+
 /* Where do we get our vertex data?
-//
-// Vertex data either comes either from immediate mode registers or from
-// vertex arrays.
-// There appears to be no mixed mode (though we can force the pitch of
-// vertex arrays to 0, effectively reusing the same element over and over
-// again).
-//
-// Immediate mode is controlled by the INPUT_CNTL registers. I am not sure
-// if these registers influence vertex array processing.
-//
-// Vertex arrays are controlled via the 3D_LOAD_VBPNTR packet3.
-//
-// In both cases, vertex attributes are then passed through INPUT_ROUTE.
-
-// Beginning with INPUT_ROUTE_0_0 is a list of WORDs that route vertex data
-// into the vertex processor's input registers.
-// The first word routes the first input, the second word the second, etc.
-// The corresponding input is routed into the register with the given index.
-// The list is ended by a word with INPUT_ROUTE_END set.
-//
-// Always set COMPONENTS_4 in immediate mode. */
+ *
+ * Vertex data either comes either from immediate mode registers or from
+ * vertex arrays.
+ * There appears to be no mixed mode (though we can force the pitch of
+ * vertex arrays to 0, effectively reusing the same element over and over
+ * again).
+ *
+ * Immediate mode is controlled by the INPUT_CNTL registers. I am not sure
+ * if these registers influence vertex array processing.
+ *
+ * Vertex arrays are controlled via the 3D_LOAD_VBPNTR packet3.
+ *
+ * In both cases, vertex attributes are then passed through INPUT_ROUTE.
+ *
+ * Beginning with INPUT_ROUTE_0_0 is a list of WORDs that route vertex data
+ * into the vertex processor's input registers.
+ * The first word routes the first input, the second word the second, etc.
+ * The corresponding input is routed into the register with the given index.
+ * The list is ended by a word with INPUT_ROUTE_END set.
+ *
+ * Always set COMPONENTS_4 in immediate mode.
+ */
 
 #define R300_VAP_INPUT_ROUTE_0_0            0x2150
 #       define R300_INPUT_ROUTE_COMPONENTS_1     (0 << 0)
 #       define R300_INPUT_ROUTE_COMPONENTS_2     (1 << 0)
 #       define R300_INPUT_ROUTE_COMPONENTS_3     (2 << 0)
 #       define R300_INPUT_ROUTE_COMPONENTS_4     (3 << 0)
-#       define R300_INPUT_ROUTE_COMPONENTS_RGBA  (4 << 0)       /* GUESS */
+#       define R300_INPUT_ROUTE_COMPONENTS_RGBA  (4 << 0) /* GUESS */
 #       define R300_VAP_INPUT_ROUTE_IDX_SHIFT    8
-#       define R300_VAP_INPUT_ROUTE_IDX_MASK     (31 << 8)      /* GUESS */
+#       define R300_VAP_INPUT_ROUTE_IDX_MASK     (31 << 8) /* GUESS */
 #       define R300_VAP_INPUT_ROUTE_END          (1 << 13)
-#       define R300_INPUT_ROUTE_IMMEDIATE_MODE   (0 << 14)      /* GUESS */
-#       define R300_INPUT_ROUTE_FLOAT            (1 << 14)      /* GUESS */
-#       define R300_INPUT_ROUTE_UNSIGNED_BYTE    (2 << 14)      /* GUESS */
-#       define R300_INPUT_ROUTE_FLOAT_COLOR      (3 << 14)      /* GUESS */
+#       define R300_INPUT_ROUTE_IMMEDIATE_MODE   (0 << 14) /* GUESS */
+#       define R300_INPUT_ROUTE_FLOAT            (1 << 14) /* GUESS */
+#       define R300_INPUT_ROUTE_UNSIGNED_BYTE    (2 << 14) /* GUESS */
+#       define R300_INPUT_ROUTE_FLOAT_COLOR      (3 << 14) /* GUESS */
 #define R300_VAP_INPUT_ROUTE_0_1            0x2154
 #define R300_VAP_INPUT_ROUTE_0_2            0x2158
 #define R300_VAP_INPUT_ROUTE_0_3            0x215C
@@ -174,10 +196,12 @@ I am fairly certain that they are correct unless stated otherwise in comments.
 #define R300_VAP_INPUT_ROUTE_0_7            0x216C
 
 /* gap */
+
 /* Notes:
-//  - always set up to produce at least two attributes:
-//    if vertex program uses only position, fglrx will set normal, too
-//  - INPUT_CNTL_0_COLOR and INPUT_CNTL_COLOR bits are always equal */
+ *  - always set up to produce at least two attributes:
+ *    if vertex program uses only position, fglrx will set normal, too
+ *  - INPUT_CNTL_0_COLOR and INPUT_CNTL_COLOR bits are always equal.
+ */
 #define R300_VAP_INPUT_CNTL_0               0x2180
 #       define R300_INPUT_CNTL_0_COLOR           0x00000001
 #define R300_VAP_INPUT_CNTL_1               0x2184
@@ -186,20 +210,22 @@ I am fairly certain that they are correct unless stated otherwise in comments.
 #       define R300_INPUT_CNTL_COLOR             0x00000004
 #       define R300_INPUT_CNTL_TC0               0x00000400
 #       define R300_INPUT_CNTL_TC1               0x00000800
-#       define R300_INPUT_CNTL_TC2               0x00001000     /* GUESS */
-#       define R300_INPUT_CNTL_TC3               0x00002000     /* GUESS */
-#       define R300_INPUT_CNTL_TC4               0x00004000     /* GUESS */
-#       define R300_INPUT_CNTL_TC5               0x00008000     /* GUESS */
-#       define R300_INPUT_CNTL_TC6               0x00010000     /* GUESS */
-#       define R300_INPUT_CNTL_TC7               0x00020000     /* GUESS */
+#       define R300_INPUT_CNTL_TC2               0x00001000 /* GUESS */
+#       define R300_INPUT_CNTL_TC3               0x00002000 /* GUESS */
+#       define R300_INPUT_CNTL_TC4               0x00004000 /* GUESS */
+#       define R300_INPUT_CNTL_TC5               0x00008000 /* GUESS */
+#       define R300_INPUT_CNTL_TC6               0x00010000 /* GUESS */
+#       define R300_INPUT_CNTL_TC7               0x00020000 /* GUESS */
 
 /* gap */
+
 /* Words parallel to INPUT_ROUTE_0; All words that are active in INPUT_ROUTE_0
-// are set to a swizzling bit pattern, other words are 0.
-//
-// In immediate mode, the pattern is always set to xyzw. In vertex array
-// mode, the swizzling pattern is e.g. used to set zw components in texture
-// coordinates with only tweo components. */
+ * are set to a swizzling bit pattern, other words are 0.
+ *
+ * In immediate mode, the pattern is always set to xyzw. In vertex array
+ * mode, the swizzling pattern is e.g. used to set zw components in texture
+ * coordinates with only tweo components.
+ */
 #define R300_VAP_INPUT_ROUTE_1_0            0x21E0
 #       define R300_INPUT_ROUTE_SELECT_X    0
 #       define R300_INPUT_ROUTE_SELECT_Y    1
@@ -208,11 +234,11 @@ I am fairly certain that they are correct unless stated otherwise in comments.
 #       define R300_INPUT_ROUTE_SELECT_ZERO 4
 #       define R300_INPUT_ROUTE_SELECT_ONE  5
 #       define R300_INPUT_ROUTE_SELECT_MASK 7
-#       define R300_INPUT_ROUTE_X_SHIFT          0
-#       define R300_INPUT_ROUTE_Y_SHIFT          3
-#       define R300_INPUT_ROUTE_Z_SHIFT          6
-#       define R300_INPUT_ROUTE_W_SHIFT          9
-#       define R300_INPUT_ROUTE_ENABLE           (15 << 12)
+#       define R300_INPUT_ROUTE_X_SHIFT     0
+#       define R300_INPUT_ROUTE_Y_SHIFT     3
+#       define R300_INPUT_ROUTE_Z_SHIFT     6
+#       define R300_INPUT_ROUTE_W_SHIFT     9
+#       define R300_INPUT_ROUTE_ENABLE      (15 << 12)
 #define R300_VAP_INPUT_ROUTE_1_1            0x21E4
 #define R300_VAP_INPUT_ROUTE_1_2            0x21E8
 #define R300_VAP_INPUT_ROUTE_1_3            0x21EC
@@ -221,79 +247,107 @@ I am fairly certain that they are correct unless stated otherwise in comments.
 #define R300_VAP_INPUT_ROUTE_1_6            0x21F8
 #define R300_VAP_INPUT_ROUTE_1_7            0x21FC
 
-/* END */
+/* END: Vertex data assembly */
 
 /* gap */
-/* BEGIN: Upload vertex program and data
-// The programmable vertex shader unit has a memory bank of unknown size
-// that can be written to in 16 byte units by writing the address into
-// UPLOAD_ADDRESS, followed by data in UPLOAD_DATA (multiples of 4 DWORDs).
-//
-// Pointers into the memory bank are always in multiples of 16 bytes.
-//
-// The memory bank is divided into areas with fixed meaning.
-//
-// Starting at address UPLOAD_PROGRAM: Vertex program instructions.
-// Native limits reported by drivers from ATI suggest size 256 (i.e. 4KB),
-// whereas the difference between known addresses suggests size 512.
-//
-// Starting at address UPLOAD_PARAMETERS: Vertex program parameters.
-// Native reported limits and the VPI layout suggest size 256, whereas
-// difference between known addresses suggests size 512.
-//
-// At address UPLOAD_POINTSIZE is a vector (0, 0, ps, 0), where ps is the
-// floating point pointsize. The exact purpose of this state is uncertain,
-// as there is also the R300_RE_POINTSIZE register.
-//
-// Multiple vertex programs and parameter sets can be loaded at once,
-// which could explain the size discrepancy. */
+
+/* BEGIN: Upload vertex program and data */
+
+/*
+ * The programmable vertex shader unit has a memory bank of unknown size
+ * that can be written to in 16 byte units by writing the address into
+ * UPLOAD_ADDRESS, followed by data in UPLOAD_DATA (multiples of 4 DWORDs).
+ *
+ * Pointers into the memory bank are always in multiples of 16 bytes.
+ *
+ * The memory bank is divided into areas with fixed meaning.
+ *
+ * Starting at address UPLOAD_PROGRAM: Vertex program instructions.
+ * Native limits reported by drivers from ATI suggest size 256 (i.e. 4KB),
+ * whereas the difference between known addresses suggests size 512.
+ *
+ * Starting at address UPLOAD_PARAMETERS: Vertex program parameters.
+ * Native reported limits and the VPI layout suggest size 256, whereas
+ * difference between known addresses suggests size 512.
+ *
+ * At address UPLOAD_POINTSIZE is a vector (0, 0, ps, 0), where ps is the
+ * floating point pointsize. The exact purpose of this state is uncertain,
+ * as there is also the R300_RE_POINTSIZE register.
+ *
+ * Multiple vertex programs and parameter sets can be loaded at once,
+ * which could explain the size discrepancy.
+ */
 #define R300_VAP_PVS_UPLOAD_ADDRESS         0x2200
 #       define R300_PVS_UPLOAD_PROGRAM           0x00000000
 #       define R300_PVS_UPLOAD_PARAMETERS        0x00000200
 #       define R300_PVS_UPLOAD_POINTSIZE         0x00000406
+
 /* gap */
+
 #define R300_VAP_PVS_UPLOAD_DATA            0x2208
-/* END */
+
+/* END: Upload vertex program and data */
 
 /* gap */
+
 /* I do not know the purpose of this register. However, I do know that
-// it is set to 221C_CLEAR for clear operations and to 221C_NORMAL
-// for normal rendering. */
+ * it is set to 221C_CLEAR for clear operations and to 221C_NORMAL
+ * for normal rendering.
+ */
 #define R300_VAP_UNKNOWN_221C               0x221C
 #       define R300_221C_NORMAL                  0x00000000
 #       define R300_221C_CLEAR                   0x0001C000
 
+/* These seem to be per-pixel and per-vertex X and Y clipping planes. The first
+ * plane is per-pixel and the second plane is per-vertex.
+ *
+ * This was determined by experimentation alone but I believe it is correct.
+ *
+ * These registers are called X_QUAD0_1_FL to X_QUAD0_4_FL by glxtest.
+ */
+#define R300_VAP_CLIP_X_0                   0x2220
+#define R300_VAP_CLIP_X_1                   0x2224
+#define R300_VAP_CLIP_Y_0                   0x2228
+#define R300_VAP_CLIP_Y_1                   0x2230
+
 /* gap */
+
 /* Sometimes, END_OF_PKT and 0x2284=0 are the only commands sent between
-// rendering commands and overwriting vertex program parameters.
-// Therefore, I suspect writing zero to 0x2284 synchronizes the engine and
-// avoids bugs caused by still running shaders reading bad data from memory. */
-#define R300_VAP_PVS_WAITIDLE               0x2284      /* GUESS */
+ * rendering commands and overwriting vertex program parameters.
+ * Therefore, I suspect writing zero to 0x2284 synchronizes the engine and
+ * avoids bugs caused by still running shaders reading bad data from memory.
+ */
+#define R300_VAP_PVS_WAITIDLE               0x2284 /* GUESS */
 
 /* Absolutely no clue what this register is about. */
 #define R300_VAP_UNKNOWN_2288               0x2288
-#       define R300_2288_R300                    0x00750000     /* -- nh */
-#       define R300_2288_RV350                   0x0000FFFF     /* -- Vladimir */
+#       define R300_2288_R300                    0x00750000 /* -- nh */
+#       define R300_2288_RV350                   0x0000FFFF /* -- Vladimir */
 
 /* gap */
+
 /* Addresses are relative to the vertex program instruction area of the
-// memory bank. PROGRAM_END points to the last instruction of the active
-// program
-//
-// The meaning of the two UNKNOWN fields is obviously not known. However,
-// experiments so far have shown that both *must* point to an instruction
-// inside the vertex program, otherwise the GPU locks up.
-// fglrx usually sets CNTL_3_UNKNOWN to the end of the program and
-// CNTL_1_UNKNOWN points to instruction where last write to position takes place.
-// Most likely this is used to ignore rest of the program in cases where group of verts arent visible.
-// For some reason this "section" is sometimes accepted other instruction that have
-// no relationship with position calculations.
-*/
+ * memory bank. PROGRAM_END points to the last instruction of the active
+ * program
+ *
+ * The meaning of the two UNKNOWN fields is obviously not known. However,
+ * experiments so far have shown that both *must* point to an instruction
+ * inside the vertex program, otherwise the GPU locks up.
+ *
+ * fglrx usually sets CNTL_3_UNKNOWN to the end of the program and
+ * R300_PVS_CNTL_1_POS_END_SHIFT points to instruction where last write to
+ * position takes place.
+ *
+ * Most likely this is used to ignore rest of the program in cases
+ * where group of verts arent visible. For some reason this "section"
+ * is sometimes accepted other instruction that have no relationship with
+ * position calculations.
+ */
 #define R300_VAP_PVS_CNTL_1                 0x22D0
 #       define R300_PVS_CNTL_1_PROGRAM_START_SHIFT   0
 #       define R300_PVS_CNTL_1_POS_END_SHIFT         10
 #       define R300_PVS_CNTL_1_PROGRAM_END_SHIFT     20
-/* Addresses are relative to the vertex program parameters area. */
+/* Addresses are relative the the vertex program parameters area. */
 #define R300_VAP_PVS_CNTL_2                 0x22D4
 #       define R300_PVS_CNTL_2_PARAM_OFFSET_SHIFT 0
 #       define R300_PVS_CNTL_2_PARAM_COUNT_SHIFT  16
@@ -302,23 +356,26 @@ I am fairly certain that they are correct unless stated otherwise in comments.
 #       define R300_PVS_CNTL_3_PROGRAM_UNKNOWN2_SHIFT 0
 
 /* The entire range from 0x2300 to 0x2AC inclusive seems to be used for
-// immediate vertices */
+ * immediate vertices
+ */
 #define R300_VAP_VTX_COLOR_R                0x2464
 #define R300_VAP_VTX_COLOR_G                0x2468
 #define R300_VAP_VTX_COLOR_B                0x246C
-#define R300_VAP_VTX_POS_0_X_1              0x2490      /* used for glVertex2*() */
+#define R300_VAP_VTX_POS_0_X_1              0x2490 /* used for glVertex2*() */
 #define R300_VAP_VTX_POS_0_Y_1              0x2494
-#define R300_VAP_VTX_COLOR_PKD              0x249C      /* RGBA */
-#define R300_VAP_VTX_POS_0_X_2              0x24A0      /* used for glVertex3*() */
+#define R300_VAP_VTX_COLOR_PKD              0x249C /* RGBA */
+#define R300_VAP_VTX_POS_0_X_2              0x24A0 /* used for glVertex3*() */
 #define R300_VAP_VTX_POS_0_Y_2              0x24A4
 #define R300_VAP_VTX_POS_0_Z_2              0x24A8
-#define R300_VAP_VTX_END_OF_PKT             0x24AC      /* write 0 to indicate end of packet? */
+/* write 0 to indicate end of packet? */
+#define R300_VAP_VTX_END_OF_PKT             0x24AC
 
 /* gap */
 
 /* These are values from r300_reg/r300_reg.h - they are known to be correct
-   and are here so we can use one register file instead of several
-   - Vladimir */
+ * and are here so we can use one register file instead of several
+ * - Vladimir
+ */
 #define R300_GB_VAP_RASTER_VTX_FMT_0    0x4000
 #       define R300_GB_VAP_RASTER_VTX_FMT_0__POS_PRESENT        (1<<0)
 #       define R300_GB_VAP_RASTER_VTX_FMT_0__COLOR_0_PRESENT    (1<<1)
@@ -341,14 +398,16 @@ I am fairly certain that they are correct unless stated otherwise in comments.
 #       define R300_GB_VAP_RASTER_VTX_FMT_1__TEX_7_COMP_CNT_SHIFT       21
 
 /* UNK30 seems to enables point to quad transformation on textures
-   (or something closely related to that).
-   This bit is rather fatal at the time being due to lackings at pixel shader side */
+ * (or something closely related to that).
+ * This bit is rather fatal at the time being due to lackings at pixel
+ * shader side
+ */
 #define R300_GB_ENABLE  0x4008
 #       define R300_GB_POINT_STUFF_ENABLE       (1<<0)
 #       define R300_GB_LINE_STUFF_ENABLE        (1<<1)
 #       define R300_GB_TRIANGLE_STUFF_ENABLE    (1<<2)
 #       define R300_GB_STENCIL_AUTO_ENABLE      (1<<4)
-#       define R300_GB_UNK30                    (1<<30)
+#       define R300_GB_UNK31                    (1<<31)
         /* each of the following is 2 bits wide */
 #define R300_GB_TEX_REPLICATE   0
 #define R300_GB_TEX_ST          1
@@ -383,11 +442,13 @@ I am fairly certain that they are correct unless stated otherwise in comments.
 #       define R300_GB_MSPOS1__MS_Y5_SHIFT      20
 #       define R300_GB_MSPOS1__MSBD1            24
 
+
 #define R300_GB_TILE_CONFIG     0x4018
 #       define R300_GB_TILE_ENABLE      (1<<0)
 #       define R300_GB_TILE_PIPE_COUNT_RV300    0
 #       define R300_GB_TILE_PIPE_COUNT_R300     (3<<1)
 #       define R300_GB_TILE_PIPE_COUNT_R420     (7<<1)
+#       define R300_GB_TILE_PIPE_COUNT_RV410    (3<<1)
 #       define R300_GB_TILE_SIZE_8              0
 #       define R300_GB_TILE_SIZE_16             (1<<4)
 #       define R300_GB_TILE_SIZE_32             (2<<4)
@@ -442,17 +503,18 @@ I am fairly certain that they are correct unless stated otherwise in comments.
 #       define R300_GB_W_SELECT_1               (1<<4)
 
 #define R300_GB_AA_CONFIG               0x4020
+#       define R300_AA_DISABLE                  0x00
 #       define R300_AA_ENABLE                   0x01
 #       define R300_AA_SUBSAMPLES_2             0
 #       define R300_AA_SUBSAMPLES_3             (1<<1)
 #       define R300_AA_SUBSAMPLES_4             (2<<1)
 #       define R300_AA_SUBSAMPLES_6             (3<<1)
 
-/* END */
-
 /* gap */
+
 /* Zero to flush caches. */
 #define R300_TX_CNTL                        0x4100
+#define R300_TX_FLUSH                       0x0
 
 /* The upper enable bits are guessed, based on fglrx reported limits. */
 #define R300_TX_ENABLE                      0x4104
@@ -474,24 +536,25 @@ I am fairly certain that they are correct unless stated otherwise in comments.
 #       define R300_TX_ENABLE_15                 (1 << 15)
 
 /* The pointsize is given in multiples of 6. The pointsize can be
-// enormous: Clear() renders a single point that fills the entire
-// framebuffer. */
+ * enormous: Clear() renders a single point that fills the entire
+ * framebuffer.
+ */
 #define R300_RE_POINTSIZE                   0x421C
 #       define R300_POINTSIZE_Y_SHIFT            0
-#       define R300_POINTSIZE_Y_MASK             (0xFFFF << 0)  /* GUESS */
+#       define R300_POINTSIZE_Y_MASK             (0xFFFF << 0) /* GUESS */
 #       define R300_POINTSIZE_X_SHIFT            16
-#       define R300_POINTSIZE_X_MASK             (0xFFFF << 16) /* GUESS */
+#       define R300_POINTSIZE_X_MASK             (0xFFFF << 16) /* GUESS */
 #       define R300_POINTSIZE_MAX             (R300_POINTSIZE_Y_MASK / 6)
 
 /* The line width is given in multiples of 6.
-   In default mode lines are classified as vertical lines.
-   HO: horizontal
-   VE: vertical or horizontal
-   HO & VE: no classification
-*/
+ * In default mode lines are classified as vertical lines.
+ * HO: horizontal
+ * VE: vertical or horizontal
+ * HO & VE: no classification
+ */
 #define R300_RE_LINE_CNT                      0x4234
 #       define R300_LINESIZE_SHIFT            0
-#       define R300_LINESIZE_MASK             (0xFFFF << 0)     /* GUESS */
+#       define R300_LINESIZE_MASK             (0xFFFF << 0) /* GUESS */
 #       define R300_LINESIZE_MAX             (R300_LINESIZE_MASK / 6)
 #       define R300_LINE_CNT_HO               (1 << 16)
 #       define R300_LINE_CNT_VE               (1 << 17)
@@ -499,6 +562,9 @@ I am fairly certain that they are correct unless stated otherwise in comments.
 /* Some sort of scale or clamp value for texcoordless textures. */
 #define R300_RE_UNK4238                       0x4238
 
+/* Something shade related */
+#define R300_RE_SHADE                         0x4274
+
 #define R300_RE_SHADE_MODEL                   0x4278
 #       define R300_RE_SHADE_MODEL_SMOOTH     0x3aaaa
 #       define R300_RE_SHADE_MODEL_FLAT       0x39595
@@ -513,24 +579,31 @@ I am fairly certain that they are correct unless stated otherwise in comments.
 #       define R300_PM_BACK_LINE              (1 << 7)
 #       define R300_PM_BACK_FILL              (1 << 8)
 
+/* Fog parameters */
+#define R300_RE_FOG_SCALE                     0x4294
+#define R300_RE_FOG_START                     0x4298
+
 /* Not sure why there are duplicate of factor and constant values.
-   My best guess so far is that there are seperate zbiases for test and write.
-   Ordering might be wrong.
-   Some of the tests indicate that fgl has a fallback implementation of zbias
-   via pixel shaders. */
+ * My best guess so far is that there are seperate zbiases for test and write.
+ * Ordering might be wrong.
+ * Some of the tests indicate that fgl has a fallback implementation of zbias
+ * via pixel shaders.
+ */
+#define R300_RE_ZBIAS_CNTL                    0x42A0 /* GUESS */
 #define R300_RE_ZBIAS_T_FACTOR                0x42A4
 #define R300_RE_ZBIAS_T_CONSTANT              0x42A8
 #define R300_RE_ZBIAS_W_FACTOR                0x42AC
 #define R300_RE_ZBIAS_W_CONSTANT              0x42B0
 
 /* This register needs to be set to (1<<1) for RV350 to correctly
-   perform depth test (see --vb-triangles in r300_demo)
-   Don't know about other chips. - Vladimir
-   This is set to 3 when GL_POLYGON_OFFSET_FILL is on.
-   My guess is that there are two bits for each zbias primitive (FILL, LINE, POINT).
-   One to enable depth test and one for depth write.
-   Yet this doesnt explain why depth writes work ...
-    */
+ * perform depth test (see --vb-triangles in r300_demo)
+ * Don't know about other chips. - Vladimir
+ * This is set to 3 when GL_POLYGON_OFFSET_FILL is on.
+ * My guess is that there are two bits for each zbias primitive
+ * (FILL, LINE, POINT).
+ *  One to enable depth test and one for depth write.
+ * Yet this doesnt explain why depth writes work ...
+ */
 #define R300_RE_OCCLUSION_CNTL              0x42B4
 #       define R300_OCCLUSION_ON                (1<<1)
 
@@ -540,30 +613,38 @@ I am fairly certain that they are correct unless stated otherwise in comments.
 #       define R300_FRONT_FACE_CCW               (0 << 2)
 #       define R300_FRONT_FACE_CW                (1 << 2)
 
-/* BEGIN: Rasterization / Interpolators - many guesses
-// 0_UNKNOWN_18 has always been set except for clear operations.
-// TC_CNT is the number of incoming texture coordinate sets (i.e. it depends
-// on the vertex program, *not* the fragment program) */
+
+/* BEGIN: Rasterization / Interpolators - many guesses */
+
+/* 0_UNKNOWN_18 has always been set except for clear operations.
+ * TC_CNT is the number of incoming texture coordinate sets (i.e. it depends
+ * on the vertex program, *not* the fragment program)
+ */
 #define R300_RS_CNTL_0                      0x4300
 #       define R300_RS_CNTL_TC_CNT_SHIFT         2
 #       define R300_RS_CNTL_TC_CNT_MASK          (7 << 2)
-#               define R300_RS_CNTL_CI_CNT_SHIFT         7      /* number of color interpolators used */
+        /* number of color interpolators used */
+#       define R300_RS_CNTL_CI_CNT_SHIFT         7
 #       define R300_RS_CNTL_0_UNKNOWN_18         (1 << 18)
-/* Guess: RS_CNTL_1 holds the index of the highest used RS_ROUTE_n register. */
+        /* Guess: RS_CNTL_1 holds the index of the highest used RS_ROUTE_n
+           register. */
 #define R300_RS_CNTL_1                      0x4304
 
 /* gap */
+
 /* Only used for texture coordinates.
-// Use the source field to route texture coordinate input from the vertex program
-// to the desired interpolator. Note that the source field is relative to the
-// outputs the vertex program *actually* writes. If a vertex program only writes
-// texcoord[1], this will be source index 0.
-// Set INTERP_USED on all interpolators that produce data used by the
-// fragment program. INTERP_USED looks like a swizzling mask, but
-// I haven't seen it used that way.
-//
-// Note: The _UNKNOWN constants are always set in their respective register.
-// I don't know if this is necessary. */
+ * Use the source field to route texture coordinate input from the
+ * vertex program to the desired interpolator. Note that the source
+ * field is relative to the outputs the vertex program *actually*
+ * writes. If a vertex program only writes texcoord[1], this will
+ * be source index 0.
+ * Set INTERP_USED on all interpolators that produce data used by
+ * the fragment program. INTERP_USED looks like a swizzling mask,
+ * but I haven't seen it used that way.
+ *
+ * Note: The _UNKNOWN constants are always set in their respective
+ * register. I don't know if this is necessary.
+ */
 #define R300_RS_INTERP_0                    0x4310
 #define R300_RS_INTERP_1                    0x4314
 #       define R300_RS_INTERP_1_UNKNOWN          0x40
@@ -580,54 +661,63 @@ I am fairly certain that they are correct unless stated otherwise in comments.
 #       define R300_RS_INTERP_USED               0x00D10000
 
 /* These DWORDs control how vertex data is routed into fragment program
-// registers, after interpolators. */
+ * registers, after interpolators.
+ */
 #define R300_RS_ROUTE_0                     0x4330
 #define R300_RS_ROUTE_1                     0x4334
 #define R300_RS_ROUTE_2                     0x4338
-#define R300_RS_ROUTE_3                     0x433C      /* GUESS */
-#define R300_RS_ROUTE_4                     0x4340      /* GUESS */
-#define R300_RS_ROUTE_5                     0x4344      /* GUESS */
-#define R300_RS_ROUTE_6                     0x4348      /* GUESS */
-#define R300_RS_ROUTE_7                     0x434C      /* GUESS */
+#define R300_RS_ROUTE_3                     0x433C /* GUESS */
+#define R300_RS_ROUTE_4                     0x4340 /* GUESS */
+#define R300_RS_ROUTE_5                     0x4344 /* GUESS */
+#define R300_RS_ROUTE_6                     0x4348 /* GUESS */
+#define R300_RS_ROUTE_7                     0x434C /* GUESS */
 #       define R300_RS_ROUTE_SOURCE_INTERP_0     0
 #       define R300_RS_ROUTE_SOURCE_INTERP_1     1
 #       define R300_RS_ROUTE_SOURCE_INTERP_2     2
 #       define R300_RS_ROUTE_SOURCE_INTERP_3     3
 #       define R300_RS_ROUTE_SOURCE_INTERP_4     4
-#       define R300_RS_ROUTE_SOURCE_INTERP_5     5      /* GUESS */
-#       define R300_RS_ROUTE_SOURCE_INTERP_6     6      /* GUESS */
-#       define R300_RS_ROUTE_SOURCE_INTERP_7     7      /* GUESS */
-#       define R300_RS_ROUTE_ENABLE              (1 << 3)       /* GUESS */
+#       define R300_RS_ROUTE_SOURCE_INTERP_5     5 /* GUESS */
+#       define R300_RS_ROUTE_SOURCE_INTERP_6     6 /* GUESS */
+#       define R300_RS_ROUTE_SOURCE_INTERP_7     7 /* GUESS */
+#       define R300_RS_ROUTE_ENABLE              (1 << 3) /* GUESS */
 #       define R300_RS_ROUTE_DEST_SHIFT          6
-#       define R300_RS_ROUTE_DEST_MASK           (31 << 6)      /* GUESS */
+#       define R300_RS_ROUTE_DEST_MASK           (31 << 6) /* GUESS */
 
 /* Special handling for color: When the fragment program uses color,
-// the ROUTE_0_COLOR bit is set and ROUTE_0_COLOR_DEST contains the
-// color register index. */
+ * the ROUTE_0_COLOR bit is set and ROUTE_0_COLOR_DEST contains the
+ * color register index.
+ *
+ * Apperently you may set the R300_RS_ROUTE_0_COLOR bit, but not provide any
+ * R300_RS_ROUTE_0_COLOR_DEST value; this setup is used for clearing the state.
+ * See r300_ioctl.c:r300EmitClearState. I'm not sure if this setup is strictly
+ * correct or not. - Oliver.
+ */
 #       define R300_RS_ROUTE_0_COLOR             (1 << 14)
 #       define R300_RS_ROUTE_0_COLOR_DEST_SHIFT  17
-#       define R300_RS_ROUTE_0_COLOR_DEST_MASK   (31 << 17)     /* GUESS */
+#       define R300_RS_ROUTE_0_COLOR_DEST_MASK   (31 << 17) /* GUESS */
 /* As above, but for secondary color */
 #               define R300_RS_ROUTE_1_COLOR1            (1 << 14)
 #               define R300_RS_ROUTE_1_COLOR1_DEST_SHIFT 17
 #               define R300_RS_ROUTE_1_COLOR1_DEST_MASK  (31 << 17)
 #               define R300_RS_ROUTE_1_UNKNOWN11         (1 << 11)
-/* END */
-
-/* BEGIN: Scissors and cliprects
-// There are four clipping rectangles. Their corner coordinates are inclusive.
-// Every pixel is assigned a number from 0 and 15 by setting bits 0-3 depending
-// on whether the pixel is inside cliprects 0-3, respectively. For example,
-// if a pixel is inside cliprects 0 and 1, but outside 2 and 3, it is assigned
-// the number 3 (binary 0011).
-// Iff the bit corresponding to the pixel's number in RE_CLIPRECT_CNTL is set,
-// the pixel is rasterized.
-//
-// In addition to this, there is a scissors rectangle. Only pixels inside the
-// scissors rectangle are drawn. (coordinates are inclusive)
-//
-// For some reason, the top-left corner of the framebuffer is at (1440, 1440)
-// for the purpose of clipping and scissors. */
+/* END: Rasterization / Interpolators - many guesses */
+
+/* BEGIN: Scissors and cliprects */
+
+/* There are four clipping rectangles. Their corner coordinates are inclusive.
+ * Every pixel is assigned a number from 0 and 15 by setting bits 0-3 depending
+ * on whether the pixel is inside cliprects 0-3, respectively. For example,
+ * if a pixel is inside cliprects 0 and 1, but outside 2 and 3, it is assigned
+ * the number 3 (binary 0011).
+ * Iff the bit corresponding to the pixel's number in RE_CLIPRECT_CNTL is set,
+ * the pixel is rasterized.
+ *
+ * In addition to this, there is a scissors rectangle. Only pixels inside the
+ * scissors rectangle are drawn. (coordinates are inclusive)
+ *
+ * For some reason, the top-left corner of the framebuffer is at (1440, 1440)
+ * for the purpose of clipping and scissors.
+ */
 #define R300_RE_CLIPRECT_TL_0               0x43B0
 #define R300_RE_CLIPRECT_BR_0               0x43B4
 #define R300_RE_CLIPRECT_TL_1               0x43B8
@@ -661,6 +751,7 @@ I am fairly certain that they are correct unless stated otherwise in comments.
 #       define R300_CLIP_3210                    (1 << 15)
 
 /* gap */
+
 #define R300_RE_SCISSORS_TL                 0x43E0
 #define R300_RE_SCISSORS_BR                 0x43E4
 #       define R300_SCISSORS_OFFSET              1440
@@ -668,12 +759,15 @@ I am fairly certain that they are correct unless stated otherwise in comments.
 #       define R300_SCISSORS_X_MASK              (0x1FFF << 0)
 #       define R300_SCISSORS_Y_SHIFT             13
 #       define R300_SCISSORS_Y_MASK              (0x1FFF << 13)
-/* END */
+/* END: Scissors and cliprects */
 
-/* BEGIN: Texture specification
-// The texture specification dwords are grouped by meaning and not by texture unit.
-// This means that e.g. the offset for texture image unit N is found in register
-// TX_OFFSET_0 + (4*N) */
+/* BEGIN: Texture specification */
+
+/*
+ * The texture specification dwords are grouped by meaning and not by texture
+ * unit. This means that e.g. the offset for texture image unit N is found in
+ * register TX_OFFSET_0 + (4*N)
+ */
 #define R300_TX_FILTER_0                    0x4400
 #       define R300_TX_REPEAT                    0
 #       define R300_TX_MIRRORED                  1
@@ -697,13 +791,14 @@ I am fairly certain that they are correct unless stated otherwise in comments.
 #       define R300_TX_MIN_FILTER_LINEAR_MIP_LINEAR         (10 <<  11)
 
 /* NOTE: NEAREST doesnt seem to exist.
-   Im not seting MAG_FILTER_MASK and (3 << 11) on for all
-   anisotropy modes because that would void selected mag filter */
-#       define R300_TX_MIN_FILTER_ANISO_NEAREST             ((0 << 13) /*|R300_TX_MAG_FILTER_MASK|(3<<11)*/)
-#       define R300_TX_MIN_FILTER_ANISO_LINEAR              ((0 << 13) /*|R300_TX_MAG_FILTER_MASK|(3<<11)*/)
-#       define R300_TX_MIN_FILTER_ANISO_NEAREST_MIP_NEAREST ((1 << 13) /*|R300_TX_MAG_FILTER_MASK|(3<<11)*/)
-#       define R300_TX_MIN_FILTER_ANISO_NEAREST_MIP_LINEAR  ((2 << 13) /*|R300_TX_MAG_FILTER_MASK|(3<<11)*/)
-#       define R300_TX_MIN_FILTER_MASK           ( (15 << 11) | (3 << 13) )
+ * Im not seting MAG_FILTER_MASK and (3 << 11) on for all
+ * anisotropy modes because that would void selected mag filter
+ */
+#       define R300_TX_MIN_FILTER_ANISO_NEAREST             (0 << 13)
+#       define R300_TX_MIN_FILTER_ANISO_LINEAR              (0 << 13)
+#       define R300_TX_MIN_FILTER_ANISO_NEAREST_MIP_NEAREST (1 << 13)
+#       define R300_TX_MIN_FILTER_ANISO_NEAREST_MIP_LINEAR  (2 << 13)
+#       define R300_TX_MIN_FILTER_MASK   ( (15 << 11) | (3 << 13) )
 #       define R300_TX_MAX_ANISO_1_TO_1  (0 << 21)
 #       define R300_TX_MAX_ANISO_2_TO_1  (2 << 21)
 #       define R300_TX_MAX_ANISO_4_TO_1  (4 << 21)
@@ -734,10 +829,10 @@ I am fairly certain that they are correct unless stated otherwise in comments.
 #       define R300_TX_HEIGHTMASK_SHIFT          11
 #       define R300_TX_HEIGHTMASK_MASK           (2047 << 11)
 #       define R300_TX_UNK23                     (1 << 23)
-#       define R300_TX_SIZE_SHIFT                26     /* largest of width, height */
-#       define R300_TX_SIZE_MASK                 (15 << 26)
-#       define R300_TX_SIZE_PROJECTED                     (1<<30)
-#       define R300_TX_SIZE_TXPITCH_EN                     (1<<31)
+#       define R300_TX_MAX_MIP_LEVEL_SHIFT       26
+#       define R300_TX_MAX_MIP_LEVEL_MASK        (0xf << 26)
+#       define R300_TX_SIZE_PROJECTED            (1<<30)
+#       define R300_TX_SIZE_TXPITCH_EN           (1<<31)
 #define R300_TX_FORMAT_0                    0x44C0
         /* The interpretation of the format word by Wladimir van der Laan */
         /* The X, Y, Z and W refer to the layout of the components.
@@ -761,11 +856,11 @@ I am fairly certain that they are correct unless stated otherwise in comments.
 #       define R300_TX_FORMAT_DXT1                  0xF
 #       define R300_TX_FORMAT_DXT3                  0x10
 #       define R300_TX_FORMAT_DXT5                  0x11
-#       define R300_TX_FORMAT_D3DMFT_CxV8U8         0x12        /* no swizzle */
-#       define R300_TX_FORMAT_A8R8G8B8              0x13        /* no swizzle */
-#       define R300_TX_FORMAT_B8G8_B8G8             0x14        /* no swizzle */
-#       define R300_TX_FORMAT_G8R8_G8B8             0x15        /* no swizzle */
-                                                  /* 0x16 - some 16 bit green format.. ?? */
+#       define R300_TX_FORMAT_D3DMFT_CxV8U8         0x12     /* no swizzle */
+#       define R300_TX_FORMAT_A8R8G8B8              0x13     /* no swizzle */
+#       define R300_TX_FORMAT_B8G8_B8G8             0x14     /* no swizzle */
+#       define R300_TX_FORMAT_G8R8_G8B8             0x15     /* no swizzle */
+        /* 0x16 - some 16 bit green format.. ?? */
 #       define R300_TX_FORMAT_UNK25                (1 << 25) /* no swizzle */
 #       define R300_TX_FORMAT_CUBIC_MAP            (1 << 26)
 
@@ -793,23 +888,26 @@ I am fairly certain that they are correct unless stated otherwise in comments.
 #       define R300_TX_FORMAT_W         3
 #       define R300_TX_FORMAT_ZERO      4
 #       define R300_TX_FORMAT_ONE       5
-#       define R300_TX_FORMAT_CUT_Z     6       /* 2.0*Z, everything above 1.0 is set to 0.0 */
-#       define R300_TX_FORMAT_CUT_W     7       /* 2.0*W, everything above 1.0 is set to 0.0 */
+        /* 2.0*Z, everything above 1.0 is set to 0.0 */
+#       define R300_TX_FORMAT_CUT_Z     6
+        /* 2.0*W, everything above 1.0 is set to 0.0 */
+#       define R300_TX_FORMAT_CUT_W     7
 
 #       define R300_TX_FORMAT_B_SHIFT   18
 #       define R300_TX_FORMAT_G_SHIFT   15
 #       define R300_TX_FORMAT_R_SHIFT   12
 #       define R300_TX_FORMAT_A_SHIFT   9
         /* Convenience macro to take care of layout and swizzling */
-#       define R300_EASY_TX_FORMAT(B, G, R, A, FMT)     (\
-          ((R300_TX_FORMAT_##B)<<R300_TX_FORMAT_B_SHIFT) \
-        | ((R300_TX_FORMAT_##G)<<R300_TX_FORMAT_G_SHIFT) \
-        | ((R300_TX_FORMAT_##R)<<R300_TX_FORMAT_R_SHIFT) \
-        | ((R300_TX_FORMAT_##A)<<R300_TX_FORMAT_A_SHIFT) \
-        | (R300_TX_FORMAT_##FMT) \
-          )
-        /* These can be ORed with result of R300_EASY_TX_FORMAT() */
-        /* We don't really know what they do. Take values from a constant color ? */
+#       define R300_EASY_TX_FORMAT(B, G, R, A, FMT)     (               \
+                ((R300_TX_FORMAT_##B)<<R300_TX_FORMAT_B_SHIFT)          \
+                | ((R300_TX_FORMAT_##G)<<R300_TX_FORMAT_G_SHIFT)        \
+                | ((R300_TX_FORMAT_##R)<<R300_TX_FORMAT_R_SHIFT)        \
+                | ((R300_TX_FORMAT_##A)<<R300_TX_FORMAT_A_SHIFT)        \
+                | (R300_TX_FORMAT_##FMT)                                \
+                )
+        /* These can be ORed with result of R300_EASY_TX_FORMAT()
+           We don't really know what they do. Take values from a
+           constant color ? */
 #       define R300_TX_FORMAT_CONST_X           (1<<5)
 #       define R300_TX_FORMAT_CONST_Y           (2<<5)
 #       define R300_TX_FORMAT_CONST_Z           (4<<5)
@@ -819,7 +917,7 @@ I am fairly certain that they are correct unless stated otherwise in comments.
 
 #define R300_TX_PITCH_0                     0x4500 /* obvious missing in gap */
 #define R300_TX_OFFSET_0                    0x4540
-/* BEGIN: Guess from R200 */
+        /* BEGIN: Guess from R200 */
 #       define R300_TXO_ENDIAN_NO_SWAP           (0 << 0)
 #       define R300_TXO_ENDIAN_BYTE_SWAP         (1 << 0)
 #       define R300_TXO_ENDIAN_WORD_SWAP         (2 << 0)
@@ -828,53 +926,61 @@ I am fairly certain that they are correct unless stated otherwise in comments.
 #       define R300_TXO_MICRO_TILE               (1 << 3)
 #       define R300_TXO_OFFSET_MASK              0xffffffe0
 #       define R300_TXO_OFFSET_SHIFT             5
-/* END */
-#define R300_TX_CHROMA_KEY_0                      0x4580 /* 32 bit chroma key */
-#define R300_TX_BORDER_COLOR_0              0x45C0 //ff00ff00 == { 0, 1.0, 0, 1.0 }
-
-/* END */
-
-/* BEGIN: Fragment program instruction set
-// Fragment programs are written directly into register space.
-// There are separate instruction streams for texture instructions and ALU
-// instructions.
-// In order to synchronize these streams, the program is divided into up
-// to 4 nodes. Each node begins with a number of TEX operations, followed
-// by a number of ALU operations.
-// The first node can have zero TEX ops, all subsequent nodes must have at least
-// one TEX ops.
-// All nodes must have at least one ALU op.
-//
-// The index of the last node is stored in PFS_CNTL_0: A value of 0 means
-// 1 node, a value of 3 means 4 nodes.
-// The total amount of instructions is defined in PFS_CNTL_2. The offsets are
-// offsets into the respective instruction streams, while *_END points to the
-// last instruction relative to this offset. */
+        /* END: Guess from R200 */
+
+/* 32 bit chroma key */
+#define R300_TX_CHROMA_KEY_0                      0x4580
+/* ff00ff00 == { 0, 1.0, 0, 1.0 } */
+#define R300_TX_BORDER_COLOR_0              0x45C0
+
+/* END: Texture specification */
+
+/* BEGIN: Fragment program instruction set */
+
+/* Fragment programs are written directly into register space.
+ * There are separate instruction streams for texture instructions and ALU
+ * instructions.
+ * In order to synchronize these streams, the program is divided into up
+ * to 4 nodes. Each node begins with a number of TEX operations, followed
+ * by a number of ALU operations.
+ * The first node can have zero TEX ops, all subsequent nodes must have at
+ * least
+ * one TEX ops.
+ * All nodes must have at least one ALU op.
+ *
+ * The index of the last node is stored in PFS_CNTL_0: A value of 0 means
+ * 1 node, a value of 3 means 4 nodes.
+ * The total amount of instructions is defined in PFS_CNTL_2. The offsets are
+ * offsets into the respective instruction streams, while *_END points to the
+ * last instruction relative to this offset.
+ */
 #define R300_PFS_CNTL_0                     0x4600
 #       define R300_PFS_CNTL_LAST_NODES_SHIFT    0
 #       define R300_PFS_CNTL_LAST_NODES_MASK     (3 << 0)
 #       define R300_PFS_CNTL_FIRST_NODE_HAS_TEX  (1 << 3)
 #define R300_PFS_CNTL_1                     0x4604
 /* There is an unshifted value here which has so far always been equal to the
-// index of the highest used temporary register. */
+ * index of the highest used temporary register.
+ */
 #define R300_PFS_CNTL_2                     0x4608
 #       define R300_PFS_CNTL_ALU_OFFSET_SHIFT    0
 #       define R300_PFS_CNTL_ALU_OFFSET_MASK     (63 << 0)
 #       define R300_PFS_CNTL_ALU_END_SHIFT       6
-#       define R300_PFS_CNTL_ALU_END_MASK        (63 << 0)
+#       define R300_PFS_CNTL_ALU_END_MASK        (63 << 6)
 #       define R300_PFS_CNTL_TEX_OFFSET_SHIFT    12
-#       define R300_PFS_CNTL_TEX_OFFSET_MASK     (31 << 12)     /* GUESS */
+#       define R300_PFS_CNTL_TEX_OFFSET_MASK     (31 << 12) /* GUESS */
 #       define R300_PFS_CNTL_TEX_END_SHIFT       18
-#       define R300_PFS_CNTL_TEX_END_MASK        (31 << 18)     /* GUESS */
+#       define R300_PFS_CNTL_TEX_END_MASK        (31 << 18) /* GUESS */
 
 /* gap */
+
 /* Nodes are stored backwards. The last active node is always stored in
-// PFS_NODE_3.
-// Example: In a 2-node program, NODE_0 and NODE_1 are set to 0. The
-// first node is stored in NODE_2, the second node is stored in NODE_3.
-//
-// Offsets are relative to the master offset from PFS_CNTL_2.
-// LAST_NODE is set for the last node, and only for the last node. */
+ * PFS_NODE_3.
+ * Example: In a 2-node program, NODE_0 and NODE_1 are set to 0. The
+ * first node is stored in NODE_2, the second node is stored in NODE_3.
+ *
+ * Offsets are relative to the master offset from PFS_CNTL_2.
+ */
 #define R300_PFS_NODE_0                     0x4610
 #define R300_PFS_NODE_1                     0x4614
 #define R300_PFS_NODE_2                     0x4618
@@ -887,91 +993,98 @@ I am fairly certain that they are correct unless stated otherwise in comments.
 #       define R300_PFS_NODE_TEX_OFFSET_MASK     (31 << 12)
 #       define R300_PFS_NODE_TEX_END_SHIFT       17
 #       define R300_PFS_NODE_TEX_END_MASK        (31 << 17)
-/*#       define R300_PFS_NODE_LAST_NODE           (1 << 22) */
 #               define R300_PFS_NODE_OUTPUT_COLOR        (1 << 22)
 #               define R300_PFS_NODE_OUTPUT_DEPTH        (1 << 23)
 
 /* TEX
-// As far as I can tell, texture instructions cannot write into output
-// registers directly. A subsequent ALU instruction is always necessary,
-// even if it's just MAD o0, r0, 1, 0 */
+ * As far as I can tell, texture instructions cannot write into output
+ * registers directly. A subsequent ALU instruction is always necessary,
+ * even if it's just MAD o0, r0, 1, 0
+ */
 #define R300_PFS_TEXI_0                     0x4620
-#       define R300_FPITX_SRC_SHIFT              0
-#       define R300_FPITX_SRC_MASK               (31 << 0)
-#       define R300_FPITX_SRC_CONST              (1 << 5)       /* GUESS */
-#       define R300_FPITX_DST_SHIFT              6
-#       define R300_FPITX_DST_MASK               (31 << 6)
-#       define R300_FPITX_IMAGE_SHIFT            11
-#       define R300_FPITX_IMAGE_MASK             (15 << 11)     /* GUESS based on layout and native limits */
+#       define R300_FPITX_SRC_SHIFT              0
+#       define R300_FPITX_SRC_MASK               (31 << 0)
+        /* GUESS */
+#       define R300_FPITX_SRC_CONST              (1 << 5)
+#       define R300_FPITX_DST_SHIFT              6
+#       define R300_FPITX_DST_MASK               (31 << 6)
+#       define R300_FPITX_IMAGE_SHIFT            11
+        /* GUESS based on layout and native limits */
+#       define R300_FPITX_IMAGE_MASK             (15 << 11)
 /* Unsure if these are opcodes, or some kind of bitfield, but this is how
  * they were set when I checked
  */
-#               define R300_FPITX_OPCODE_SHIFT                  15
-#                       define R300_FPITX_OP_TEX                        1
-#                       define R300_FPITX_OP_KIL                        2
-#                       define R300_FPITX_OP_TXP                        3
-#                       define R300_FPITX_OP_TXB                        4
+#       define R300_FPITX_OPCODE_SHIFT          15
+#               define R300_FPITX_OP_TEX        1
+#               define R300_FPITX_OP_KIL        2
+#               define R300_FPITX_OP_TXP        3
+#               define R300_FPITX_OP_TXB        4
+#       define R300_FPITX_OPCODE_MASK           (7 << 15)
 
 /* ALU
-// The ALU instructions register blocks are enumerated according to the order
-// in which fglrx. I assume there is space for 64 instructions, since
-// each block has space for a maximum of 64 DWORDs, and this matches reported
-// native limits.
-//
-// The basic functional block seems to be one MAD for each color and alpha,
-// and an adder that adds all components after the MUL.
-//  - ADD, MUL, MAD etc.: use MAD with appropriate neutral operands
-//  - DP4: Use OUTC_DP4, OUTA_DP4
-//  - DP3: Use OUTC_DP3, OUTA_DP4, appropriate alpha operands
-//  - DPH: Use OUTC_DP4, OUTA_DP4, appropriate alpha operands
-//  - CMP: If ARG2 < 0, return ARG1, else return ARG0
-//  - FLR: use FRC+MAD
-//  - XPD: use MAD+MAD
-//  - SGE, SLT: use MAD+CMP
-//  - RSQ: use ABS modifier for argument
-//  - Use OUTC_REPL_ALPHA to write results of an alpha-only operation (e.g. RCP)
-//    into color register
-//  - apparently, there's no quick DST operation
-//  - fglrx set FPI2_UNKNOWN_31 on a "MAD fragment.color, tmp0, tmp1, tmp2"
-//  - fglrx set FPI2_UNKNOWN_31 on a "MAX r2, r1, c0"
-//  - fglrx once set FPI0_UNKNOWN_31 on a "FRC r1, r1"
-//
-// Operand selection
-// First stage selects three sources from the available registers and
-// constant parameters. This is defined in INSTR1 (color) and INSTR3 (alpha).
-// fglrx sorts the three source fields: Registers before constants,
-// lower indices before higher indices; I do not know whether this is necessary.
-// fglrx fills unused sources with "read constant 0"
-// According to specs, you cannot select more than two different constants.
-//
-// Second stage selects the operands from the sources. This is defined in
-// INSTR0 (color) and INSTR2 (alpha). You can also select the special constants
-// zero and one.
-// Swizzling and negation happens in this stage, as well.
-//
-// Important: Color and alpha seem to be mostly separate, i.e. their sources
-// selection appears to be fully independent (the register storage is probably
-// physically split into a color and an alpha section).
-// However (because of the apparent physical split), there is some interaction
-// WRT swizzling. If, for example, you want to load an R component into an
-// Alpha operand, this R component is taken from a *color* source, not from
-// an alpha source. The corresponding register doesn't even have to appear in
-// the alpha sources list. (I hope this alll makes sense to you)
-//
-// Destination selection
-// The destination register index is in FPI1 (color) and FPI3 (alpha) together
-// with enable bits.
-// There are separate enable bits for writing into temporary registers
-// (DSTC_REG_* /DSTA_REG) and and program output registers (DSTC_OUTPUT_* /DSTA_OUTPUT).
-// You can write to both at once, or not write at all (the same index
-// must be used for both).
-//
-// Note: There is a special form for LRP
-//  - Argument order is the same as in ARB_fragment_program.
-//  - Operation is MAD
-//  - ARG1 is set to ARGC_SRC1C_LRP/ARGC_SRC1A_LRP
-//  - Set FPI0/FPI2_SPECIAL_LRP
-// Arbitrary LRP (including support for swizzling) requires vanilla MAD+MAD */
+ * The ALU instructions register blocks are enumerated according to the order
+ * in which fglrx. I assume there is space for 64 instructions, since
+ * each block has space for a maximum of 64 DWORDs, and this matches reported
+ * native limits.
+ *
+ * The basic functional block seems to be one MAD for each color and alpha,
+ * and an adder that adds all components after the MUL.
+ *  - ADD, MUL, MAD etc.: use MAD with appropriate neutral operands
+ *  - DP4: Use OUTC_DP4, OUTA_DP4
+ *  - DP3: Use OUTC_DP3, OUTA_DP4, appropriate alpha operands
+ *  - DPH: Use OUTC_DP4, OUTA_DP4, appropriate alpha operands
+ *  - CMPH: If ARG2 > 0.5, return ARG0, else return ARG1
+ *  - CMP: If ARG2 < 0, return ARG1, else return ARG0
+ *  - FLR: use FRC+MAD
+ *  - XPD: use MAD+MAD
+ *  - SGE, SLT: use MAD+CMP
+ *  - RSQ: use ABS modifier for argument
+ *  - Use OUTC_REPL_ALPHA to write results of an alpha-only operation
+ *    (e.g. RCP) into color register
+ *  - apparently, there's no quick DST operation
+ *  - fglrx set FPI2_UNKNOWN_31 on a "MAD fragment.color, tmp0, tmp1, tmp2"
+ *  - fglrx set FPI2_UNKNOWN_31 on a "MAX r2, r1, c0"
+ *  - fglrx once set FPI0_UNKNOWN_31 on a "FRC r1, r1"
+ *
+ * Operand selection
+ * First stage selects three sources from the available registers and
+ * constant parameters. This is defined in INSTR1 (color) and INSTR3 (alpha).
+ * fglrx sorts the three source fields: Registers before constants,
+ * lower indices before higher indices; I do not know whether this is
+ * necessary.
+ *
+ * fglrx fills unused sources with "read constant 0"
+ * According to specs, you cannot select more than two different constants.
+ *
+ * Second stage selects the operands from the sources. This is defined in
+ * INSTR0 (color) and INSTR2 (alpha). You can also select the special constants
+ * zero and one.
+ * Swizzling and negation happens in this stage, as well.
+ *
+ * Important: Color and alpha seem to be mostly separate, i.e. their sources
+ * selection appears to be fully independent (the register storage is probably
+ * physically split into a color and an alpha section).
+ * However (because of the apparent physical split), there is some interaction
+ * WRT swizzling. If, for example, you want to load an R component into an
+ * Alpha operand, this R component is taken from a *color* source, not from
+ * an alpha source. The corresponding register doesn't even have to appear in
+ * the alpha sources list. (I hope this all makes sense to you)
+ *
+ * Destination selection
+ * The destination register index is in FPI1 (color) and FPI3 (alpha)
+ * together with enable bits.
+ * There are separate enable bits for writing into temporary registers
+ * (DSTC_REG_* /DSTA_REG) and and program output registers (DSTC_OUTPUT_*
+ * /DSTA_OUTPUT). You can write to both at once, or not write at all (the
+ * same index must be used for both).
+ *
+ * Note: There is a special form for LRP
+ *  - Argument order is the same as in ARB_fragment_program.
+ *  - Operation is MAD
+ *  - ARG1 is set to ARGC_SRC1C_LRP/ARGC_SRC1A_LRP
+ *  - Set FPI0/FPI2_SPECIAL_LRP
+ * Arbitrary LRP (including support for swizzling) requires vanilla MAD+MAD
+ */
 #define R300_PFS_INSTR1_0                   0x46C0
 #       define R300_FPI1_SRC0C_SHIFT             0
 #       define R300_FPI1_SRC0C_MASK              (31 << 0)
@@ -982,6 +1095,7 @@ I am fairly certain that they are correct unless stated otherwise in comments.
 #       define R300_FPI1_SRC2C_SHIFT             12
 #       define R300_FPI1_SRC2C_MASK              (31 << 12)
 #       define R300_FPI1_SRC2C_CONST             (1 << 17)
+#       define R300_FPI1_SRC_MASK                0x0003ffff
 #       define R300_FPI1_DSTC_SHIFT              18
 #       define R300_FPI1_DSTC_MASK               (31 << 18)
 #               define R300_FPI1_DSTC_REG_MASK_SHIFT     23
@@ -1003,6 +1117,7 @@ I am fairly certain that they are correct unless stated otherwise in comments.
 #       define R300_FPI3_SRC2A_SHIFT             12
 #       define R300_FPI3_SRC2A_MASK              (31 << 12)
 #       define R300_FPI3_SRC2A_CONST             (1 << 17)
+#       define R300_FPI3_SRC_MASK                0x0003ffff
 #       define R300_FPI3_DSTA_SHIFT              18
 #       define R300_FPI3_DSTA_MASK               (31 << 18)
 #       define R300_FPI3_DSTA_REG                (1 << 23)
@@ -1028,7 +1143,8 @@ I am fairly certain that they are correct unless stated otherwise in comments.
 #       define R300_FPI0_ARGC_SRC1C_LRP          15
 #       define R300_FPI0_ARGC_ZERO               20
 #       define R300_FPI0_ARGC_ONE                21
-#       define R300_FPI0_ARGC_HALF               22     /* GUESS */
+        /* GUESS */
+#       define R300_FPI0_ARGC_HALF               22
 #       define R300_FPI0_ARGC_SRC0C_YZX          23
 #       define R300_FPI0_ARGC_SRC1C_YZX          24
 #       define R300_FPI0_ARGC_SRC2C_YZX          25
@@ -1057,6 +1173,7 @@ I am fairly certain that they are correct unless stated otherwise in comments.
 #       define R300_FPI0_OUTC_DP4                (2 << 23)
 #       define R300_FPI0_OUTC_MIN                (4 << 23)
 #       define R300_FPI0_OUTC_MAX                (5 << 23)
+#       define R300_FPI0_OUTC_CMPH               (7 << 23)
 #       define R300_FPI0_OUTC_CMP                (8 << 23)
 #       define R300_FPI0_OUTC_FRC                (9 << 23)
 #       define R300_FPI0_OUTC_REPL_ALPHA         (10 << 23)
@@ -1079,20 +1196,23 @@ I am fairly certain that they are correct unless stated otherwise in comments.
 #       define R300_FPI2_ARGA_SRC1A_LRP          15
 #       define R300_FPI2_ARGA_ZERO               16
 #       define R300_FPI2_ARGA_ONE                17
-#       define R300_FPI2_ARGA_HALF               18     /* GUESS */
-
+        /* GUESS */
+#       define R300_FPI2_ARGA_HALF               18
 #       define R300_FPI2_ARG0A_SHIFT             0
 #       define R300_FPI2_ARG0A_MASK              (31 << 0)
 #       define R300_FPI2_ARG0A_NEG               (1 << 5)
-#               define R300_FPI2_ARG0A_ABS                               (1 << 6)       /* GUESS */
+        /* GUESS */
+#       define R300_FPI2_ARG0A_ABS               (1 << 6)
 #       define R300_FPI2_ARG1A_SHIFT             7
 #       define R300_FPI2_ARG1A_MASK              (31 << 7)
 #       define R300_FPI2_ARG1A_NEG               (1 << 12)
-#               define R300_FPI2_ARG1A_ABS                               (1 << 13)      /* GUESS */
+        /* GUESS */
+#       define R300_FPI2_ARG1A_ABS               (1 << 13)
 #       define R300_FPI2_ARG2A_SHIFT             14
 #       define R300_FPI2_ARG2A_MASK              (31 << 14)
 #       define R300_FPI2_ARG2A_NEG               (1 << 19)
-#               define R300_FPI2_ARG2A_ABS                               (1 << 20)      /* GUESS */
+        /* GUESS */
+#       define R300_FPI2_ARG2A_ABS               (1 << 20)
 #       define R300_FPI2_SPECIAL_LRP             (1 << 21)
 #       define R300_FPI2_OUTA_MAD                (0 << 23)
 #       define R300_FPI2_OUTA_DP4                (1 << 23)
@@ -1106,9 +1226,19 @@ I am fairly certain that they are correct unless stated otherwise in comments.
 #       define R300_FPI2_OUTA_RSQ                (11 << 23)
 #       define R300_FPI2_OUTA_SAT                (1 << 30)
 #       define R300_FPI2_UNKNOWN_31              (1 << 31)
-/* END */
+/* END: Fragment program instruction set */
+
+/* Fog state and color */
+#define R300_RE_FOG_STATE                   0x4BC0
+#       define R300_FOG_ENABLE                   (1 << 0)
+#       define R300_FOG_MODE_LINEAR              (0 << 1)
+#       define R300_FOG_MODE_EXP                 (1 << 1)
+#       define R300_FOG_MODE_EXP2                (2 << 1)
+#       define R300_FOG_MODE_MASK                (3 << 1)
+#define R300_FOG_COLOR_R                    0x4BC8
+#define R300_FOG_COLOR_G                    0x4BCC
+#define R300_FOG_COLOR_B                    0x4BD0
 
-/* gap */
 #define R300_PP_ALPHA_TEST                  0x4BD4
 #       define R300_REF_ALPHA_MASK               0x000000ff
 #       define R300_ALPHA_TEST_FAIL              (0 << 8)
@@ -1123,6 +1253,7 @@ I am fairly certain that they are correct unless stated otherwise in comments.
 #       define R300_ALPHA_TEST_ENABLE            (1 << 11)
 
 /* gap */
+
 /* Fragment program parameters in 7.16 floating point */
 #define R300_PFS_PARAM_0_X                  0x4C00
 #define R300_PFS_PARAM_0_Y                  0x4C04
@@ -1135,45 +1266,48 @@ I am fairly certain that they are correct unless stated otherwise in comments.
 #define R300_PFS_PARAM_31_W                 0x4DFC
 
 /* Notes:
-// - AFAIK fglrx always sets BLEND_UNKNOWN when blending is used in the application
-// - AFAIK fglrx always sets BLEND_NO_SEPARATE when CBLEND and ABLEND are set to the same
-//   function (both registers are always set up completely in any case)
-// - Most blend flags are simply copied from R200 and not tested yet */
+ * - AFAIK fglrx always sets BLEND_UNKNOWN when blending is used in
+ *   the application
+ * - AFAIK fglrx always sets BLEND_NO_SEPARATE when CBLEND and ABLEND
+ *    are set to the same
+ *   function (both registers are always set up completely in any case)
+ * - Most blend flags are simply copied from R200 and not tested yet
+ */
 #define R300_RB3D_CBLEND                    0x4E04
 #define R300_RB3D_ABLEND                    0x4E08
- /* the following only appear in CBLEND */
+/* the following only appear in CBLEND */
 #       define R300_BLEND_ENABLE                     (1 << 0)
 #       define R300_BLEND_UNKNOWN                    (3 << 1)
 #       define R300_BLEND_NO_SEPARATE                (1 << 3)
- /* the following are shared between CBLEND and ABLEND */
+/* the following are shared between CBLEND and ABLEND */
 #       define R300_FCN_MASK                         (3  << 12)
 #       define R300_COMB_FCN_ADD_CLAMP               (0  << 12)
 #       define R300_COMB_FCN_ADD_NOCLAMP             (1  << 12)
 #       define R300_COMB_FCN_SUB_CLAMP               (2  << 12)
 #       define R300_COMB_FCN_SUB_NOCLAMP             (3  << 12)
-#       define R300_SRC_BLEND_GL_ZERO                (32 << 16)
-#       define R300_SRC_BLEND_GL_ONE                 (33 << 16)
-#       define R300_SRC_BLEND_GL_SRC_COLOR           (34 << 16)
-#       define R300_SRC_BLEND_GL_ONE_MINUS_SRC_COLOR (35 << 16)
-#       define R300_SRC_BLEND_GL_DST_COLOR           (36 << 16)
-#       define R300_SRC_BLEND_GL_ONE_MINUS_DST_COLOR (37 << 16)
-#       define R300_SRC_BLEND_GL_SRC_ALPHA           (38 << 16)
-#       define R300_SRC_BLEND_GL_ONE_MINUS_SRC_ALPHA (39 << 16)
-#       define R300_SRC_BLEND_GL_DST_ALPHA           (40 << 16)
-#       define R300_SRC_BLEND_GL_ONE_MINUS_DST_ALPHA (41 << 16)
-#       define R300_SRC_BLEND_GL_SRC_ALPHA_SATURATE  (42 << 16)
-#       define R300_SRC_BLEND_MASK                   (63 << 16)
-#       define R300_DST_BLEND_GL_ZERO                (32 << 24)
-#       define R300_DST_BLEND_GL_ONE                 (33 << 24)
-#       define R300_DST_BLEND_GL_SRC_COLOR           (34 << 24)
-#       define R300_DST_BLEND_GL_ONE_MINUS_SRC_COLOR (35 << 24)
-#       define R300_DST_BLEND_GL_DST_COLOR           (36 << 24)
-#       define R300_DST_BLEND_GL_ONE_MINUS_DST_COLOR (37 << 24)
-#       define R300_DST_BLEND_GL_SRC_ALPHA           (38 << 24)
-#       define R300_DST_BLEND_GL_ONE_MINUS_SRC_ALPHA (39 << 24)
-#       define R300_DST_BLEND_GL_DST_ALPHA           (40 << 24)
-#       define R300_DST_BLEND_GL_ONE_MINUS_DST_ALPHA (41 << 24)
-#       define R300_DST_BLEND_MASK                   (63 << 24)
+#       define R300_COMB_FCN_MIN                     (4  << 12)
+#       define R300_COMB_FCN_MAX                     (5  << 12)
+#       define R300_COMB_FCN_RSUB_CLAMP              (6  << 12)
+#       define R300_COMB_FCN_RSUB_NOCLAMP            (7  << 12)
+#       define R300_BLEND_GL_ZERO                    (32)
+#       define R300_BLEND_GL_ONE                     (33)
+#       define R300_BLEND_GL_SRC_COLOR               (34)
+#       define R300_BLEND_GL_ONE_MINUS_SRC_COLOR     (35)
+#       define R300_BLEND_GL_DST_COLOR               (36)
+#       define R300_BLEND_GL_ONE_MINUS_DST_COLOR     (37)
+#       define R300_BLEND_GL_SRC_ALPHA               (38)
+#       define R300_BLEND_GL_ONE_MINUS_SRC_ALPHA     (39)
+#       define R300_BLEND_GL_DST_ALPHA               (40)
+#       define R300_BLEND_GL_ONE_MINUS_DST_ALPHA     (41)
+#       define R300_BLEND_GL_SRC_ALPHA_SATURATE      (42)
+#       define R300_BLEND_GL_CONST_COLOR             (43)
+#       define R300_BLEND_GL_ONE_MINUS_CONST_COLOR   (44)
+#       define R300_BLEND_GL_CONST_ALPHA             (45)
+#       define R300_BLEND_GL_ONE_MINUS_CONST_ALPHA   (46)
+#       define R300_BLEND_MASK                       (63)
+#       define R300_SRC_BLEND_SHIFT                  (16)
+#       define R300_DST_BLEND_SHIFT                  (24)
+#define R300_RB3D_BLEND_COLOR               0x4E10
 #define R300_RB3D_COLORMASK                 0x4E0C
 #       define R300_COLORMASK0_B                 (1<<0)
 #       define R300_COLORMASK0_G                 (1<<1)
@@ -1181,41 +1315,49 @@ I am fairly certain that they are correct unless stated otherwise in comments.
 #       define R300_COLORMASK0_A                 (1<<3)
 
 /* gap */
+
 #define R300_RB3D_COLOROFFSET0              0x4E28
-#       define R300_COLOROFFSET_MASK             0xFFFFFFF0     /* GUESS */
-#define R300_RB3D_COLOROFFSET1              0x4E2C      /* GUESS */
-#define R300_RB3D_COLOROFFSET2              0x4E30      /* GUESS */
-#define R300_RB3D_COLOROFFSET3              0x4E34      /* GUESS */
+#       define R300_COLOROFFSET_MASK             0xFFFFFFF0 /* GUESS */
+#define R300_RB3D_COLOROFFSET1              0x4E2C /* GUESS */
+#define R300_RB3D_COLOROFFSET2              0x4E30 /* GUESS */
+#define R300_RB3D_COLOROFFSET3              0x4E34 /* GUESS */
+
 /* gap */
+
 /* Bit 16: Larger tiles
-// Bit 17: 4x2 tiles
-// Bit 18: Extremely weird tile like, but some pixels duplicated? */
+ * Bit 17: 4x2 tiles
+ * Bit 18: Extremely weird tile like, but some pixels duplicated?
+ */
 #define R300_RB3D_COLORPITCH0               0x4E38
-#       define R300_COLORPITCH_MASK              0x00001FF8     /* GUESS */
-#       define R300_COLOR_TILE_ENABLE            (1 << 16)      /* GUESS */
-#       define R300_COLOR_MICROTILE_ENABLE       (1 << 17)      /* GUESS */
-#       define R300_COLOR_ENDIAN_NO_SWAP         (0 << 18)      /* GUESS */
-#       define R300_COLOR_ENDIAN_WORD_SWAP       (1 << 18)      /* GUESS */
-#       define R300_COLOR_ENDIAN_DWORD_SWAP      (2 << 18)      /* GUESS */
+#       define R300_COLORPITCH_MASK              0x00001FF8 /* GUESS */
+#       define R300_COLOR_TILE_ENABLE            (1 << 16) /* GUESS */
+#       define R300_COLOR_MICROTILE_ENABLE       (1 << 17) /* GUESS */
+#       define R300_COLOR_ENDIAN_NO_SWAP         (0 << 18) /* GUESS */
+#       define R300_COLOR_ENDIAN_WORD_SWAP       (1 << 18) /* GUESS */
+#       define R300_COLOR_ENDIAN_DWORD_SWAP      (2 << 18) /* GUESS */
 #       define R300_COLOR_FORMAT_RGB565          (2 << 22)
 #       define R300_COLOR_FORMAT_ARGB8888        (3 << 22)
-#define R300_RB3D_COLORPITCH1               0x4E3C      /* GUESS */
-#define R300_RB3D_COLORPITCH2               0x4E40      /* GUESS */
-#define R300_RB3D_COLORPITCH3               0x4E44      /* GUESS */
+#define R300_RB3D_COLORPITCH1               0x4E3C /* GUESS */
+#define R300_RB3D_COLORPITCH2               0x4E40 /* GUESS */
+#define R300_RB3D_COLORPITCH3               0x4E44 /* GUESS */
 
 /* gap */
+
 /* Guess by Vladimir.
-// Set to 0A before 3D operations, set to 02 afterwards. */
+ * Set to 0A before 3D operations, set to 02 afterwards.
+ */
 #define R300_RB3D_DSTCACHE_CTLSTAT          0x4E4C
-#       define R300_RB3D_DSTCACHE_02             0x00000002
-#       define R300_RB3D_DSTCACHE_0A             0x0000000A
+#       define R300_RB3D_DSTCACHE_UNKNOWN_02             0x00000002
+#       define R300_RB3D_DSTCACHE_UNKNOWN_0A             0x0000000A
 
 /* gap */
-/* There seems to be no "write only" setting, so use Z-test = ALWAYS for this. */
-/* Bit (1<<8) is the "test" bit. so plain write is 6  - vd */
+/* There seems to be no "write only" setting, so use Z-test = ALWAYS
+ * for this.
+ * Bit (1<<8) is the "test" bit. so plain write is 6  - vd
+ */
 #define R300_RB3D_ZSTENCIL_CNTL_0                   0x4F00
-#       define R300_RB3D_Z_DISABLED_1            0x00000010     /* GUESS */
-#       define R300_RB3D_Z_DISABLED_2            0x00000014     /* GUESS */
+#       define R300_RB3D_Z_DISABLED_1            0x00000010
+#       define R300_RB3D_Z_DISABLED_2            0x00000014
 #       define R300_RB3D_Z_TEST                  0x00000012
 #       define R300_RB3D_Z_TEST_AND_WRITE        0x00000016
 #       define R300_RB3D_Z_WRITE_ONLY            0x00000006
@@ -1226,7 +1368,7 @@ I am fairly certain that they are correct unless stated otherwise in comments.
 #       define R300_RB3D_STENCIL_ENABLE          0x00000001
 
 #define R300_RB3D_ZSTENCIL_CNTL_1                   0x4F04
-                /* functions */
+        /* functions */
 #       define R300_ZS_NEVER                    0
 #       define R300_ZS_LESS                     1
 #       define R300_ZS_LEQUAL                   2
@@ -1236,7 +1378,7 @@ I am fairly certain that they are correct unless stated otherwise in comments.
 #       define R300_ZS_NOTEQUAL                 6
 #       define R300_ZS_ALWAYS                   7
 #       define R300_ZS_MASK                     7
-                /* operations */
+        /* operations */
 #       define R300_ZS_KEEP                     0
 #       define R300_ZS_ZERO                     1
 #       define R300_ZS_REPLACE                  2
@@ -1245,9 +1387,8 @@ I am fairly certain that they are correct unless stated otherwise in comments.
 #       define R300_ZS_INVERT                   5
 #       define R300_ZS_INCR_WRAP                6
 #       define R300_ZS_DECR_WRAP                7
-
-       /* front and back refer to operations done for front
-          and back faces, i.e. separate stencil function support */
+        /* front and back refer to operations done for front
+           and back faces, i.e. separate stencil function support */
 #       define R300_RB3D_ZS1_DEPTH_FUNC_SHIFT           0
 #       define R300_RB3D_ZS1_FRONT_FUNC_SHIFT           3
 #       define R300_RB3D_ZS1_FRONT_FAIL_OP_SHIFT        6
@@ -1269,45 +1410,64 @@ I am fairly certain that they are correct unless stated otherwise in comments.
 #define R300_RB3D_ZSTENCIL_FORMAT                   0x4F10
 #       define R300_DEPTH_FORMAT_16BIT_INT_Z     (0 << 0)
 #       define R300_DEPTH_FORMAT_24BIT_INT_Z     (2 << 0)
+        /* 16 bit format or some aditional bit ? */
+#       define R300_DEPTH_FORMAT_UNK32          (32 << 0)
+
+#define R300_RB3D_EARLY_Z                           0x4F14
+#       define R300_EARLY_Z_DISABLE              (0 << 0)
+#       define R300_EARLY_Z_ENABLE               (1 << 0)
+
+/* gap */
+
+#define R300_RB3D_ZCACHE_CTLSTAT            0x4F18 /* GUESS */
+#       define R300_RB3D_ZCACHE_UNKNOWN_01  0x1
+#       define R300_RB3D_ZCACHE_UNKNOWN_03  0x3
 
 /* gap */
+
 #define R300_RB3D_DEPTHOFFSET               0x4F20
 #define R300_RB3D_DEPTHPITCH                0x4F24
-#       define R300_DEPTHPITCH_MASK              0x00001FF8     /* GUESS */
-#       define R300_DEPTH_TILE_ENABLE            (1 << 16)      /* GUESS */
-#       define R300_DEPTH_MICROTILE_ENABLE       (1 << 17)      /* GUESS */
-#       define R300_DEPTH_ENDIAN_NO_SWAP         (0 << 18)      /* GUESS */
-#       define R300_DEPTH_ENDIAN_WORD_SWAP       (1 << 18)      /* GUESS */
-#       define R300_DEPTH_ENDIAN_DWORD_SWAP      (2 << 18)      /* GUESS */
-
-/* BEGIN: Vertex program instruction set
-// Every instruction is four dwords long:
-//  DWORD 0: output and opcode
-//  DWORD 1: first argument
-//  DWORD 2: second argument
-//  DWORD 3: third argument
-//
-// Notes:
-//  - ABS r, a is implemented as MAX r, a, -a
-//  - MOV is implemented as ADD to zero
-//  - XPD is implemented as MUL + MAD
-//  - FLR is implemented as FRC + ADD
-//  - apparently, fglrx tries to schedule instructions so that there is at least
-//    one instruction between the write to a temporary and the first read
-//    from said temporary; however, violations of this scheduling are allowed
-//  - register indices seem to be unrelated with OpenGL aliasing to conventional state
-//  - only one attribute and one parameter can be loaded at a time; however, the
-//    same attribute/parameter can be used for more than one argument
-//  - the second software argument for POW is the third hardware argument (no idea why)
-//  - MAD with only temporaries as input seems to use VPI_OUT_SELECT_MAD_2
-//
-// There is some magic surrounding LIT:
-//  The single argument is replicated across all three inputs, but swizzled:
-//   First argument: xyzy
-//   Second argument: xyzx
-//   Third argument: xyzw
-//  Whenever the result is used later in the fragment program, fglrx forces x and w
-//  to be 1.0 in the input selection; I don't know whether this is strictly necessary */
+#       define R300_DEPTHPITCH_MASK              0x00001FF8 /* GUESS */
+#       define R300_DEPTH_TILE_ENABLE            (1 << 16) /* GUESS */
+#       define R300_DEPTH_MICROTILE_ENABLE       (1 << 17) /* GUESS */
+#       define R300_DEPTH_ENDIAN_NO_SWAP         (0 << 18) /* GUESS */
+#       define R300_DEPTH_ENDIAN_WORD_SWAP       (1 << 18) /* GUESS */
+#       define R300_DEPTH_ENDIAN_DWORD_SWAP      (2 << 18) /* GUESS */
+
+/* BEGIN: Vertex program instruction set */
+
+/* Every instruction is four dwords long:
+ *  DWORD 0: output and opcode
+ *  DWORD 1: first argument
+ *  DWORD 2: second argument
+ *  DWORD 3: third argument
+ *
+ * Notes:
+ *  - ABS r, a is implemented as MAX r, a, -a
+ *  - MOV is implemented as ADD to zero
+ *  - XPD is implemented as MUL + MAD
+ *  - FLR is implemented as FRC + ADD
+ *  - apparently, fglrx tries to schedule instructions so that there is at
+ *    least one instruction between the write to a temporary and the first
+ *    read from said temporary; however, violations of this scheduling are
+ *    allowed
+ *  - register indices seem to be unrelated with OpenGL aliasing to
+ *    conventional state
+ *  - only one attribute and one parameter can be loaded at a time; however,
+ *    the same attribute/parameter can be used for more than one argument
+ *  - the second software argument for POW is the third hardware argument
+ *    (no idea why)
+ *  - MAD with only temporaries as input seems to use VPI_OUT_SELECT_MAD_2
+ *
+ * There is some magic surrounding LIT:
+ *   The single argument is replicated across all three inputs, but swizzled:
+ *     First argument: xyzy
+ *     Second argument: xyzx
+ *     Third argument: xyzw
+ *   Whenever the result is used later in the fragment program, fglrx forces
+ *   x and w to be 1.0 in the input selection; I don't know whether this is
+ *   strictly necessary
+ */
 #define R300_VPI_OUT_OP_DOT                     (1 << 0)
 #define R300_VPI_OUT_OP_MUL                     (2 << 0)
 #define R300_VPI_OUT_OP_ADD                     (3 << 0)
@@ -1318,26 +1478,33 @@ I am fairly certain that they are correct unless stated otherwise in comments.
 #define R300_VPI_OUT_OP_MIN                     (8 << 0)
 #define R300_VPI_OUT_OP_SGE                     (9 << 0)
 #define R300_VPI_OUT_OP_SLT                     (10 << 0)
-#define R300_VPI_OUT_OP_UNK12                   (12 << 0)       /* Used in GL_POINT_DISTANCE_ATTENUATION_ARB, vector(scalar, vector) */
+        /* Used in GL_POINT_DISTANCE_ATTENUATION_ARB, vector(scalar, vector) */
+#define R300_VPI_OUT_OP_UNK12                   (12 << 0)
+#define R300_VPI_OUT_OP_ARL                     (13 << 0)
 #define R300_VPI_OUT_OP_EXP                     (65 << 0)
 #define R300_VPI_OUT_OP_LOG                     (66 << 0)
-#define R300_VPI_OUT_OP_UNK67                   (67 << 0)       /* Used in fog computations, scalar(scalar) */
+        /* Used in fog computations, scalar(scalar) */
+#define R300_VPI_OUT_OP_UNK67                   (67 << 0)
 #define R300_VPI_OUT_OP_LIT                     (68 << 0)
 #define R300_VPI_OUT_OP_POW                     (69 << 0)
 #define R300_VPI_OUT_OP_RCP                     (70 << 0)
 #define R300_VPI_OUT_OP_RSQ                     (72 << 0)
-#define R300_VPI_OUT_OP_UNK73                   (73 << 0)       /* Used in GL_POINT_DISTANCE_ATTENUATION_ARB, scalar(scalar) */
+        /* Used in GL_POINT_DISTANCE_ATTENUATION_ARB, scalar(scalar) */
+#define R300_VPI_OUT_OP_UNK73                   (73 << 0)
 #define R300_VPI_OUT_OP_EX2                     (75 << 0)
 #define R300_VPI_OUT_OP_LG2                     (76 << 0)
 #define R300_VPI_OUT_OP_MAD_2                   (128 << 0)
-#define R300_VPI_OUT_OP_UNK129                  (129 << 0)      /* all temps, vector(scalar, vector, vector) */
+        /* all temps, vector(scalar, vector, vector) */
+#define R300_VPI_OUT_OP_UNK129                  (129 << 0)
 
 #define R300_VPI_OUT_REG_CLASS_TEMPORARY        (0 << 8)
+#define R300_VPI_OUT_REG_CLASS_ADDR             (1 << 8)
 #define R300_VPI_OUT_REG_CLASS_RESULT           (2 << 8)
 #define R300_VPI_OUT_REG_CLASS_MASK             (31 << 8)
 
 #define R300_VPI_OUT_REG_INDEX_SHIFT            13
-#define R300_VPI_OUT_REG_INDEX_MASK             (31 << 13)      /* GUESS based on fglrx native limits */
+        /* GUESS based on fglrx native limits */
+#define R300_VPI_OUT_REG_INDEX_MASK             (31 << 13)
 
 #define R300_VPI_OUT_WRITE_X                    (1 << 20)
 #define R300_VPI_OUT_WRITE_Y                    (1 << 21)
@@ -1348,14 +1515,16 @@ I am fairly certain that they are correct unless stated otherwise in comments.
 #define R300_VPI_IN_REG_CLASS_ATTRIBUTE         (1 << 0)
 #define R300_VPI_IN_REG_CLASS_PARAMETER         (2 << 0)
 #define R300_VPI_IN_REG_CLASS_NONE              (9 << 0)
-#define R300_VPI_IN_REG_CLASS_MASK              (31 << 0)       /* GUESS */
+#define R300_VPI_IN_REG_CLASS_MASK              (31 << 0)
 
 #define R300_VPI_IN_REG_INDEX_SHIFT             5
-#define R300_VPI_IN_REG_INDEX_MASK              (255 << 5)      /* GUESS based on fglrx native limits */
+        /* GUESS based on fglrx native limits */
+#define R300_VPI_IN_REG_INDEX_MASK              (255 << 5)
 
 /* The R300 can select components from the input register arbitrarily.
-// Use the following constants, shifted by the component shift you
-// want to select */
+ * Use the following constants, shifted by the component shift you
+ * want to select
+ */
 #define R300_VPI_IN_SELECT_X    0
 #define R300_VPI_IN_SELECT_Y    1
 #define R300_VPI_IN_SELECT_Z    2
@@ -1373,11 +1542,11 @@ I am fairly certain that they are correct unless stated otherwise in comments.
 #define R300_VPI_IN_NEG_Y                       (1 << 26)
 #define R300_VPI_IN_NEG_Z                       (1 << 27)
 #define R300_VPI_IN_NEG_W                       (1 << 28)
-/* END */
+/* END: Vertex program instruction set */
 
-//BEGIN: Packet 3 commands
+/* BEGIN: Packet 3 commands */
 
-// A primitive emission dword.
+/* A primitive emission dword. */
 #define R300_PRIM_TYPE_NONE                     (0 << 0)
 #define R300_PRIM_TYPE_POINT                    (1 << 0)
 #define R300_PRIM_TYPE_LINE                     (2 << 0)
@@ -1389,7 +1558,8 @@ I am fairly certain that they are correct unless stated otherwise in comments.
 #define R300_PRIM_TYPE_RECT_LIST                (8 << 0)
 #define R300_PRIM_TYPE_3VRT_POINT_LIST          (9 << 0)
 #define R300_PRIM_TYPE_3VRT_LINE_LIST           (10 << 0)
-#define R300_PRIM_TYPE_POINT_SPRITES            (11 << 0)       // GUESS (based on r200)
+        /* GUESS (based on r200) */
+#define R300_PRIM_TYPE_POINT_SPRITES            (11 << 0)
 #define R300_PRIM_TYPE_LINE_LOOP                (12 << 0)
 #define R300_PRIM_TYPE_QUADS                    (13 << 0)
 #define R300_PRIM_TYPE_QUAD_STRIP               (14 << 0)
@@ -1399,37 +1569,58 @@ I am fairly certain that they are correct unless stated otherwise in comments.
 #define R300_PRIM_WALK_LIST                     (2 << 4)
 #define R300_PRIM_WALK_RING                     (3 << 4)
 #define R300_PRIM_WALK_MASK                     (3 << 4)
-#define R300_PRIM_COLOR_ORDER_BGRA              (0 << 6)        // GUESS (based on r200)
-#define R300_PRIM_COLOR_ORDER_RGBA              (1 << 6)        // GUESS
+        /* GUESS (based on r200) */
+#define R300_PRIM_COLOR_ORDER_BGRA              (0 << 6)
+#define R300_PRIM_COLOR_ORDER_RGBA              (1 << 6)
 #define R300_PRIM_NUM_VERTICES_SHIFT            16
+#define R300_PRIM_NUM_VERTICES_MASK             0xffff
 
-// Draw a primitive from vertex data in arrays loaded via 3D_LOAD_VBPNTR.
-// Two parameter dwords:
-// 0. The first parameter appears to be always 0
-// 1. The second parameter is a standard primitive emission dword.
+/* Draw a primitive from vertex data in arrays loaded via 3D_LOAD_VBPNTR.
+ * Two parameter dwords:
+ * 0. The first parameter appears to be always 0
+ * 1. The second parameter is a standard primitive emission dword.
+ */
 #define R300_PACKET3_3D_DRAW_VBUF           0x00002800
 
-// Specify the full set of vertex arrays as (address, stride).
-// The first parameter is the number of vertex arrays specified.
-// The rest of the command is a variable length list of blocks, where
-// each block is three dwords long and specifies two arrays.
-// The first dword of a block is split into two words, the lower significant
-// word refers to the first array, the more significant word to the second
-// array in the block.
-// The low byte of each word contains the size of an array entry in dwords,
-// the high byte contains the stride of the array.
-// The second dword of a block contains the pointer to the first array,
-// the third dword of a block contains the pointer to the second array.
-// Note that if the total number of arrays is odd, the third dword of
-// the last block is omitted.
+/* Specify the full set of vertex arrays as (address, stride).
+ * The first parameter is the number of vertex arrays specified.
+ * The rest of the command is a variable length list of blocks, where
+ * each block is three dwords long and specifies two arrays.
+ * The first dword of a block is split into two words, the lower significant
+ * word refers to the first array, the more significant word to the second
+ * array in the block.
+ * The low byte of each word contains the size of an array entry in dwords,
+ * the high byte contains the stride of the array.
+ * The second dword of a block contains the pointer to the first array,
+ * the third dword of a block contains the pointer to the second array.
+ * Note that if the total number of arrays is odd, the third dword of
+ * the last block is omitted.
+ */
 #define R300_PACKET3_3D_LOAD_VBPNTR         0x00002F00
 
 #define R300_PACKET3_INDX_BUFFER            0x00003300
 #    define R300_EB_UNK1_SHIFT                      24
 #    define R300_EB_UNK1                    (0x80<<24)
 #    define R300_EB_UNK2                        0x0810
+#define R300_PACKET3_3D_DRAW_VBUF_2         0x00003400
 #define R300_PACKET3_3D_DRAW_INDX_2         0x00003600
 
-//END
+/* END: Packet 3 commands */
+
+
+/* Color formats for 2d packets
+ */
+#define R300_CP_COLOR_FORMAT_CI8        2
+#define R300_CP_COLOR_FORMAT_ARGB1555   3
+#define R300_CP_COLOR_FORMAT_RGB565     4
+#define R300_CP_COLOR_FORMAT_ARGB8888   6
+#define R300_CP_COLOR_FORMAT_RGB332     7
+#define R300_CP_COLOR_FORMAT_RGB8       9
+#define R300_CP_COLOR_FORMAT_ARGB4444   15
+
+/*
+ * CP type-3 packets
+ */
+#define R300_CP_CMD_BITBLT_MULTI        0xC0009B00
 
-#endif                          /* _R300_REG_H */
+#endif /* _R300_REG_H */
diff --git a/drivers/char/drm/radeon_cp.c b/drivers/char/drm/radeon_cp.c
index 68338389d836..af5790f8fd53 100644
--- a/drivers/char/drm/radeon_cp.c
+++ b/drivers/char/drm/radeon_cp.c
@@ -36,7 +36,7 @@
 
 #define RADEON_FIFO_DEBUG       0
 
-static int radeon_do_cleanup_cp(drm_device_t * dev);
+static int radeon_do_cleanup_cp(struct drm_device * dev);
 
 /* CP microcode (from ATI) */
 static const u32 R200_cp_microcode[][2] = {
@@ -816,7 +816,7 @@ static const u32 R300_cp_microcode[][2] = {
         {0000000000, 0000000000},
 };
 
-static int RADEON_READ_PLL(drm_device_t * dev, int addr)
+static int RADEON_READ_PLL(struct drm_device * dev, int addr)
 {
         drm_radeon_private_t *dev_priv = dev->dev_private;
 
@@ -1066,7 +1066,7 @@ static void radeon_do_cp_stop(drm_radeon_private_t * dev_priv)
 
 /* Reset the engine.  This will stop the CP if it is running.
  */
-static int radeon_do_engine_reset(drm_device_t * dev)
+static int radeon_do_engine_reset(struct drm_device * dev)
 {
         drm_radeon_private_t *dev_priv = dev->dev_private;
         u32 clock_cntl_index, mclk_cntl, rbbm_soft_reset;
@@ -1122,7 +1122,7 @@ static int radeon_do_engine_reset(drm_device_t * dev)
         return 0;
 }
 
-static void radeon_cp_init_ring_buffer(drm_device_t * dev,
+static void radeon_cp_init_ring_buffer(struct drm_device * dev,
                                        drm_radeon_private_t * dev_priv)
 {
         u32 ring_start, cur_read_ptr;
@@ -1174,7 +1174,7 @@ static void radeon_cp_init_ring_buffer(drm_device_t * dev,
         } else
 #endif
         {
-                drm_sg_mem_t *entry = dev->sg;
+                struct drm_sg_mem *entry = dev->sg;
                 unsigned long tmp_ofs, page_ofs;
 
                 tmp_ofs = dev_priv->ring_rptr->offset -
@@ -1384,7 +1384,7 @@ static void radeon_set_pcigart(drm_radeon_private_t * dev_priv, int on)
         }
 }
 
-static int radeon_do_init_cp(drm_device_t * dev, drm_radeon_init_t * init)
+static int radeon_do_init_cp(struct drm_device * dev, drm_radeon_init_t * init)
 {
         drm_radeon_private_t *dev_priv = dev->dev_private;
 
@@ -1420,6 +1420,10 @@ static int radeon_do_init_cp(drm_device_t * dev, drm_radeon_init_t * init)
                 return DRM_ERR(EINVAL);
         }
 
+        /* Enable vblank on CRTC1 for older X servers
+         */
+        dev_priv->vblank_crtc = DRM_RADEON_VBLANK_CRTC1;
+
         switch(init->func) {
         case RADEON_INIT_R200_CP:
                 dev_priv->microcode_version = UCODE_R200;
@@ -1501,13 +1505,13 @@ static int radeon_do_init_cp(drm_device_t * dev, drm_radeon_init_t * init)
                                          RADEON_ROUND_MODE_TRUNC |
                                          RADEON_ROUND_PREC_8TH_PIX);
 
-        DRM_GETSAREA();
 
         dev_priv->ring_offset = init->ring_offset;
         dev_priv->ring_rptr_offset = init->ring_rptr_offset;
         dev_priv->buffers_offset = init->buffers_offset;
         dev_priv->gart_textures_offset = init->gart_textures_offset;
 
+        dev_priv->sarea = drm_getsarea(dev);
         if (!dev_priv->sarea) {
                 DRM_ERROR("could not find sarea!\n");
                 radeon_do_cleanup_cp(dev);
@@ -1731,7 +1735,7 @@ static int radeon_do_init_cp(drm_device_t * dev, drm_radeon_init_t * init)
         return 0;
 }
 
-static int radeon_do_cleanup_cp(drm_device_t * dev)
+static int radeon_do_cleanup_cp(struct drm_device * dev)
 {
         drm_radeon_private_t *dev_priv = dev->dev_private;
         DRM_DEBUG("\n");
@@ -1787,7 +1791,7 @@ static int radeon_do_cleanup_cp(drm_device_t * dev)
  *
  * Charl P. Botha <http://cpbotha.net>
  */
-static int radeon_do_resume_cp(drm_device_t * dev)
+static int radeon_do_resume_cp(struct drm_device * dev)
 {
         drm_radeon_private_t *dev_priv = dev->dev_private;
 
@@ -1914,7 +1918,7 @@ int radeon_cp_stop(DRM_IOCTL_ARGS)
         return 0;
 }
 
-void radeon_do_release(drm_device_t * dev)
+void radeon_do_release(struct drm_device * dev)
 {
         drm_radeon_private_t *dev_priv = dev->dev_private;
         int i, ret;
@@ -2042,12 +2046,12 @@ int radeon_fullscreen(DRM_IOCTL_ARGS)
  * they can't get the lock.
  */
 
-drm_buf_t *radeon_freelist_get(drm_device_t * dev)
+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;
-        drm_buf_t *buf;
+        struct drm_buf *buf;
         int i, t;
         int start;
 
@@ -2082,12 +2086,12 @@ drm_buf_t *radeon_freelist_get(drm_device_t * dev)
 }
 
 #if 0
-drm_buf_t *radeon_freelist_get(drm_device_t * dev)
+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;
-        drm_buf_t *buf;
+        struct drm_buf *buf;
         int i, t;
         int start;
         u32 done_age = DRM_READ32(dev_priv->ring_rptr, RADEON_SCRATCHOFF(1));
@@ -2116,15 +2120,15 @@ drm_buf_t *radeon_freelist_get(drm_device_t * dev)
 }
 #endif
 
-void radeon_freelist_reset(drm_device_t * dev)
+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;
 
         dev_priv->last_buf = 0;
         for (i = 0; i < dma->buf_count; i++) {
-                drm_buf_t *buf = dma->buflist[i];
+                struct drm_buf *buf = dma->buflist[i];
                 drm_radeon_buf_priv_t *buf_priv = buf->dev_private;
                 buf_priv->age = 0;
         }
@@ -2166,11 +2170,11 @@ int radeon_wait_ring(drm_radeon_private_t * dev_priv, int n)
         return DRM_ERR(EBUSY);
 }
 
-static int radeon_cp_get_buffers(DRMFILE filp, drm_device_t * dev,
-                                 drm_dma_t * d)
+static int radeon_cp_get_buffers(DRMFILE filp, struct drm_device * dev,
+                                 struct drm_dma * d)
 {
         int i;
-        drm_buf_t *buf;
+        struct drm_buf *buf;
 
         for (i = d->granted_count; i < d->request_count; i++) {
                 buf = radeon_freelist_get(dev);
@@ -2194,10 +2198,10 @@ static int radeon_cp_get_buffers(DRMFILE filp, drm_device_t * dev,
 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;
-        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);
 
diff --git a/drivers/char/drm/radeon_drm.h b/drivers/char/drm/radeon_drm.h
index 66c4b6fed04f..5a8e23f916fc 100644
--- a/drivers/char/drm/radeon_drm.h
+++ b/drivers/char/drm/radeon_drm.h
@@ -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 {
@@ -655,6 +655,7 @@ typedef struct drm_radeon_indirect {
 #define RADEON_PARAM_GART_TEX_HANDLE       10
 #define RADEON_PARAM_SCRATCH_OFFSET        11
 #define RADEON_PARAM_CARD_TYPE             12
+#define RADEON_PARAM_VBLANK_CRTC           13   /* VBLANK CRTC */
 
 typedef struct drm_radeon_getparam {
         int param;
@@ -708,7 +709,7 @@ typedef struct drm_radeon_setparam {
 #define RADEON_SETPARAM_PCIGART_LOCATION 3      /* PCI Gart Location */
 #define RADEON_SETPARAM_NEW_MEMMAP 4            /* Use new memory map */
 #define RADEON_SETPARAM_PCIGART_TABLE_SIZE 5    /* PCI GART Table Size */
-
+#define RADEON_SETPARAM_VBLANK_CRTC 6           /* VBLANK CRTC */
 /* 1.14: Clients can allocate/free a surface
  */
 typedef struct drm_radeon_surface_alloc {
@@ -721,4 +722,7 @@ typedef struct drm_radeon_surface_free {
         unsigned int address;
 } drm_radeon_surface_free_t;
 
+#define DRM_RADEON_VBLANK_CRTC1         1
+#define DRM_RADEON_VBLANK_CRTC2         2
+
 #endif
diff --git a/drivers/char/drm/radeon_drv.c b/drivers/char/drm/radeon_drv.c
index 2eb652ec6745..349ac3d3b848 100644
--- a/drivers/char/drm/radeon_drv.c
+++ b/drivers/char/drm/radeon_drv.c
@@ -60,7 +60,7 @@ static struct drm_driver driver = {
         .driver_features =
             DRIVER_USE_AGP | DRIVER_USE_MTRR | DRIVER_PCI_DMA | DRIVER_SG |
             DRIVER_HAVE_IRQ | DRIVER_HAVE_DMA | DRIVER_IRQ_SHARED |
-            DRIVER_IRQ_VBL,
+            DRIVER_IRQ_VBL | DRIVER_IRQ_VBL2,
         .dev_priv_size = sizeof(drm_radeon_buf_priv_t),
         .load = radeon_driver_load,
         .firstopen = radeon_driver_firstopen,
@@ -70,6 +70,7 @@ static struct drm_driver driver = {
         .lastclose = radeon_driver_lastclose,
         .unload = radeon_driver_unload,
         .vblank_wait = radeon_driver_vblank_wait,
+        .vblank_wait2 = radeon_driver_vblank_wait2,
         .dri_library_name = dri_library_name,
         .irq_preinstall = radeon_driver_irq_preinstall,
         .irq_postinstall = radeon_driver_irq_postinstall,
diff --git a/drivers/char/drm/radeon_drv.h b/drivers/char/drm/radeon_drv.h
index 54f49ef4bef0..3b3d9357201c 100644
--- a/drivers/char/drm/radeon_drv.h
+++ b/drivers/char/drm/radeon_drv.h
@@ -97,9 +97,10 @@
  *       new packet type)
  * 1.26- Add support for variable size PCI(E) gart aperture
  * 1.27- Add support for IGP GART
+ * 1.28- Add support for VBL on CRTC2
  */
 #define DRIVER_MAJOR            1
-#define DRIVER_MINOR            27
+#define DRIVER_MINOR            28
 #define DRIVER_PATCHLEVEL       0
 
 /*
@@ -154,7 +155,7 @@ enum radeon_chip_flags {
 
 typedef struct drm_radeon_freelist {
         unsigned int age;
-        drm_buf_t *buf;
+        struct drm_buf *buf;
         struct drm_radeon_freelist *next;
         struct drm_radeon_freelist *prev;
 } drm_radeon_freelist_t;
@@ -277,13 +278,16 @@ typedef struct drm_radeon_private {
         /* SW interrupt */
         wait_queue_head_t swi_queue;
         atomic_t swi_emitted;
+        int vblank_crtc;
+        uint32_t irq_enable_reg;
+        int irq_enabled;
 
         struct radeon_surface surfaces[RADEON_MAX_SURFACES];
         struct radeon_virt_surface virt_surfaces[2 * RADEON_MAX_SURFACES];
 
         unsigned long pcigart_offset;
         unsigned int pcigart_offset_set;
-        drm_ati_pcigart_info gart_info;
+        struct drm_ati_pcigart_info gart_info;
 
         u32 scratch_ages[5];
 
@@ -299,7 +303,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;
@@ -332,8 +336,8 @@ extern int radeon_engine_reset(DRM_IOCTL_ARGS);
 extern int radeon_fullscreen(DRM_IOCTL_ARGS);
 extern int radeon_cp_buffers(DRM_IOCTL_ARGS);
 
-extern void radeon_freelist_reset(drm_device_t * dev);
-extern drm_buf_t *radeon_freelist_get(drm_device_t * dev);
+extern void radeon_freelist_reset(struct drm_device * dev);
+extern struct drm_buf *radeon_freelist_get(struct drm_device * dev);
 
 extern int radeon_wait_ring(drm_radeon_private_t * dev_priv, int n);
 
@@ -353,29 +357,33 @@ extern void radeon_mem_release(DRMFILE filp, struct mem_block *heap);
 extern int radeon_irq_emit(DRM_IOCTL_ARGS);
 extern int radeon_irq_wait(DRM_IOCTL_ARGS);
 
-extern void radeon_do_release(drm_device_t * dev);
-extern int radeon_driver_vblank_wait(drm_device_t * dev,
+extern void radeon_do_release(struct drm_device * dev);
+extern int radeon_driver_vblank_wait(struct drm_device * dev,
                                      unsigned int *sequence);
+extern int radeon_driver_vblank_wait2(struct drm_device * dev,
+                                      unsigned int *sequence);
 extern irqreturn_t radeon_driver_irq_handler(DRM_IRQ_ARGS);
-extern void radeon_driver_irq_preinstall(drm_device_t * dev);
-extern void radeon_driver_irq_postinstall(drm_device_t * dev);
-extern void radeon_driver_irq_uninstall(drm_device_t * dev);
+extern void radeon_driver_irq_preinstall(struct drm_device * dev);
+extern void radeon_driver_irq_postinstall(struct drm_device * dev);
+extern void radeon_driver_irq_uninstall(struct drm_device * dev);
+extern int radeon_vblank_crtc_get(struct drm_device *dev);
+extern int radeon_vblank_crtc_set(struct drm_device *dev, int64_t value);
 
 extern int radeon_driver_load(struct drm_device *dev, unsigned long flags);
 extern int radeon_driver_unload(struct drm_device *dev);
 extern int radeon_driver_firstopen(struct drm_device *dev);
-extern void radeon_driver_preclose(drm_device_t * dev, DRMFILE filp);
-extern void radeon_driver_postclose(drm_device_t * dev, drm_file_t * filp);
-extern void radeon_driver_lastclose(drm_device_t * dev);
-extern int radeon_driver_open(drm_device_t * dev, drm_file_t * filp_priv);
+extern void radeon_driver_preclose(struct drm_device * dev, DRMFILE filp);
+extern void radeon_driver_postclose(struct drm_device * dev, struct drm_file * filp);
+extern void radeon_driver_lastclose(struct drm_device * dev);
+extern int radeon_driver_open(struct drm_device * dev, struct drm_file * filp_priv);
 extern long radeon_compat_ioctl(struct file *filp, unsigned int cmd,
                                 unsigned long arg);
 
 /* r300_cmdbuf.c */
 extern void r300_init_reg_flags(void);
 
-extern int r300_do_cp_cmdbuf(drm_device_t * dev, DRMFILE filp,
-                             drm_file_t * filp_priv,
+extern int r300_do_cp_cmdbuf(struct drm_device * dev, DRMFILE filp,
+                             struct drm_file * filp_priv,
                              drm_radeon_kcmd_buffer_t * cmdbuf);
 
 /* Flags for stats.boxes
@@ -496,12 +504,15 @@ extern int r300_do_cp_cmdbuf(drm_device_t * dev, DRMFILE filp,
 
 #define RADEON_GEN_INT_CNTL             0x0040
 #       define RADEON_CRTC_VBLANK_MASK          (1 << 0)
+#       define RADEON_CRTC2_VBLANK_MASK         (1 << 9)
 #       define RADEON_GUI_IDLE_INT_ENABLE       (1 << 19)
 #       define RADEON_SW_INT_ENABLE             (1 << 25)
 
 #define RADEON_GEN_INT_STATUS           0x0044
 #       define RADEON_CRTC_VBLANK_STAT          (1 << 0)
 #       define RADEON_CRTC_VBLANK_STAT_ACK      (1 << 0)
+#       define RADEON_CRTC2_VBLANK_STAT         (1 << 9)
+#       define RADEON_CRTC2_VBLANK_STAT_ACK     (1 << 9)
 #       define RADEON_GUI_IDLE_INT_TEST_ACK     (1 << 19)
 #       define RADEON_SW_INT_TEST               (1 << 25)
 #       define RADEON_SW_INT_TEST_ACK           (1 << 25)
diff --git a/drivers/char/drm/radeon_irq.c b/drivers/char/drm/radeon_irq.c
index 3ff0baa2fbfa..ad8a0ac7182e 100644
--- a/drivers/char/drm/radeon_irq.c
+++ b/drivers/char/drm/radeon_irq.c
@@ -64,7 +64,7 @@ static __inline__ u32 radeon_acknowledge_irqs(drm_radeon_private_t * dev_priv,
 
 irqreturn_t radeon_driver_irq_handler(DRM_IRQ_ARGS)
 {
-        drm_device_t *dev = (drm_device_t *) arg;
+        struct drm_device *dev = (struct drm_device *) arg;
         drm_radeon_private_t *dev_priv =
             (drm_radeon_private_t *) dev->dev_private;
         u32 stat;
@@ -73,18 +73,35 @@ irqreturn_t radeon_driver_irq_handler(DRM_IRQ_ARGS)
          * outside the DRM
          */
         stat = radeon_acknowledge_irqs(dev_priv, (RADEON_SW_INT_TEST_ACK |
-                                                  RADEON_CRTC_VBLANK_STAT));
+                                                  RADEON_CRTC_VBLANK_STAT |
+                                                  RADEON_CRTC2_VBLANK_STAT));
         if (!stat)
                 return IRQ_NONE;
 
+        stat &= dev_priv->irq_enable_reg;
+
         /* SW interrupt */
         if (stat & RADEON_SW_INT_TEST) {
                 DRM_WAKEUP(&dev_priv->swi_queue);
         }
 
         /* VBLANK interrupt */
-        if (stat & RADEON_CRTC_VBLANK_STAT) {
-                atomic_inc(&dev->vbl_received);
+        if (stat & (RADEON_CRTC_VBLANK_STAT|RADEON_CRTC2_VBLANK_STAT)) {
+                int vblank_crtc = dev_priv->vblank_crtc;
+
+                if ((vblank_crtc &
+                     (DRM_RADEON_VBLANK_CRTC1 | DRM_RADEON_VBLANK_CRTC2)) ==
+                    (DRM_RADEON_VBLANK_CRTC1 | DRM_RADEON_VBLANK_CRTC2)) {
+                        if (stat & RADEON_CRTC_VBLANK_STAT)
+                                atomic_inc(&dev->vbl_received);
+                        if (stat & RADEON_CRTC2_VBLANK_STAT)
+                                atomic_inc(&dev->vbl_received2);
+                } else if (((stat & RADEON_CRTC_VBLANK_STAT) &&
+                           (vblank_crtc & DRM_RADEON_VBLANK_CRTC1)) ||
+                           ((stat & RADEON_CRTC2_VBLANK_STAT) &&
+                            (vblank_crtc & DRM_RADEON_VBLANK_CRTC2)))
+                        atomic_inc(&dev->vbl_received);
+
                 DRM_WAKEUP(&dev->vbl_queue);
                 drm_vbl_send_signals(dev);
         }
@@ -92,7 +109,7 @@ irqreturn_t radeon_driver_irq_handler(DRM_IRQ_ARGS)
         return IRQ_HANDLED;
 }
 
-static int radeon_emit_irq(drm_device_t * dev)
+static int radeon_emit_irq(struct drm_device * dev)
 {
         drm_radeon_private_t *dev_priv = dev->dev_private;
         unsigned int ret;
@@ -110,7 +127,7 @@ static int radeon_emit_irq(drm_device_t * dev)
         return ret;
 }
 
-static int radeon_wait_irq(drm_device_t * dev, int swi_nr)
+static int radeon_wait_irq(struct drm_device * dev, int swi_nr)
 {
         drm_radeon_private_t *dev_priv =
             (drm_radeon_private_t *) dev->dev_private;
@@ -127,19 +144,30 @@ static int radeon_wait_irq(drm_device_t * dev, int swi_nr)
         return ret;
 }
 
-int radeon_driver_vblank_wait(drm_device_t * dev, unsigned int *sequence)
+int radeon_driver_vblank_do_wait(struct drm_device * dev, unsigned int *sequence,
+                                 int crtc)
 {
         drm_radeon_private_t *dev_priv =
             (drm_radeon_private_t *) dev->dev_private;
         unsigned int cur_vblank;
         int ret = 0;
-
+        int ack = 0;
+        atomic_t *counter;
         if (!dev_priv) {
                 DRM_ERROR("%s called with no initialization\n", __FUNCTION__);
                 return DRM_ERR(EINVAL);
         }
 
-        radeon_acknowledge_irqs(dev_priv, RADEON_CRTC_VBLANK_STAT);
+        if (crtc == DRM_RADEON_VBLANK_CRTC1) {
+                counter = &dev->vbl_received;
+                ack |= RADEON_CRTC_VBLANK_STAT;
+        } else if (crtc == DRM_RADEON_VBLANK_CRTC2) {
+                counter = &dev->vbl_received2;
+                ack |= RADEON_CRTC2_VBLANK_STAT;
+        } else
+                return DRM_ERR(EINVAL);
+
+        radeon_acknowledge_irqs(dev_priv, ack);
 
         dev_priv->stats.boxes |= RADEON_BOX_WAIT_IDLE;
 
@@ -148,7 +176,7 @@ int radeon_driver_vblank_wait(drm_device_t * dev, unsigned int *sequence)
          * using vertical blanks...
          */
         DRM_WAIT_ON(ret, dev->vbl_queue, 3 * DRM_HZ,
-                    (((cur_vblank = atomic_read(&dev->vbl_received))
+                    (((cur_vblank = atomic_read(counter))
                       - *sequence) <= (1 << 23)));
 
         *sequence = cur_vblank;
@@ -156,6 +184,16 @@ int radeon_driver_vblank_wait(drm_device_t * dev, unsigned int *sequence)
         return ret;
 }
 
+int radeon_driver_vblank_wait(struct drm_device *dev, unsigned int *sequence)
+{
+        return radeon_driver_vblank_do_wait(dev, sequence, DRM_RADEON_VBLANK_CRTC1);
+}
+
+int radeon_driver_vblank_wait2(struct drm_device *dev, unsigned int *sequence)
+{
+        return radeon_driver_vblank_do_wait(dev, sequence, DRM_RADEON_VBLANK_CRTC2);
+}
+
 /* Needs the lock as it touches the ring.
  */
 int radeon_irq_emit(DRM_IOCTL_ARGS)
@@ -204,9 +242,24 @@ int radeon_irq_wait(DRM_IOCTL_ARGS)
         return radeon_wait_irq(dev, irqwait.irq_seq);
 }
 
+static void radeon_enable_interrupt(struct drm_device *dev)
+{
+        drm_radeon_private_t *dev_priv = (drm_radeon_private_t *) dev->dev_private;
+
+        dev_priv->irq_enable_reg = RADEON_SW_INT_ENABLE;
+        if (dev_priv->vblank_crtc & DRM_RADEON_VBLANK_CRTC1)
+                dev_priv->irq_enable_reg |= RADEON_CRTC_VBLANK_MASK;
+
+        if (dev_priv->vblank_crtc & DRM_RADEON_VBLANK_CRTC2)
+                dev_priv->irq_enable_reg |= RADEON_CRTC2_VBLANK_MASK;
+
+        RADEON_WRITE(RADEON_GEN_INT_CNTL, dev_priv->irq_enable_reg);
+        dev_priv->irq_enabled = 1;
+}
+
 /* drm_dma.h hooks
 */
-void radeon_driver_irq_preinstall(drm_device_t * dev)
+void radeon_driver_irq_preinstall(struct drm_device * dev)
 {
         drm_radeon_private_t *dev_priv =
             (drm_radeon_private_t *) dev->dev_private;
@@ -216,10 +269,11 @@ void radeon_driver_irq_preinstall(drm_device_t * dev)
 
         /* Clear bits if they're already high */
         radeon_acknowledge_irqs(dev_priv, (RADEON_SW_INT_TEST_ACK |
-                                           RADEON_CRTC_VBLANK_STAT));
+                                           RADEON_CRTC_VBLANK_STAT |
+                                           RADEON_CRTC2_VBLANK_STAT));
 }
 
-void radeon_driver_irq_postinstall(drm_device_t * dev)
+void radeon_driver_irq_postinstall(struct drm_device * dev)
 {
         drm_radeon_private_t *dev_priv =
             (drm_radeon_private_t *) dev->dev_private;
@@ -227,18 +281,48 @@ void radeon_driver_irq_postinstall(drm_device_t * dev)
         atomic_set(&dev_priv->swi_emitted, 0);
         DRM_INIT_WAITQUEUE(&dev_priv->swi_queue);
 
-        /* Turn on SW and VBL ints */
-        RADEON_WRITE(RADEON_GEN_INT_CNTL,
-                     RADEON_CRTC_VBLANK_MASK | RADEON_SW_INT_ENABLE);
+        radeon_enable_interrupt(dev);
 }
 
-void radeon_driver_irq_uninstall(drm_device_t * dev)
+void radeon_driver_irq_uninstall(struct drm_device * dev)
 {
         drm_radeon_private_t *dev_priv =
             (drm_radeon_private_t *) dev->dev_private;
         if (!dev_priv)
                 return;
 
+        dev_priv->irq_enabled = 0;
+
         /* Disable *all* interrupts */
         RADEON_WRITE(RADEON_GEN_INT_CNTL, 0);
 }
+
+
+int radeon_vblank_crtc_get(struct drm_device *dev)
+{
+        drm_radeon_private_t *dev_priv = (drm_radeon_private_t *) dev->dev_private;
+        u32 flag;
+        u32 value;
+
+        flag = RADEON_READ(RADEON_GEN_INT_CNTL);
+        value = 0;
+
+        if (flag & RADEON_CRTC_VBLANK_MASK)
+                value |= DRM_RADEON_VBLANK_CRTC1;
+
+        if (flag & RADEON_CRTC2_VBLANK_MASK)
+                value |= DRM_RADEON_VBLANK_CRTC2;
+        return value;
+}
+
+int radeon_vblank_crtc_set(struct drm_device *dev, int64_t value)
+{
+        drm_radeon_private_t *dev_priv = (drm_radeon_private_t *) dev->dev_private;
+        if (value & ~(DRM_RADEON_VBLANK_CRTC1 | DRM_RADEON_VBLANK_CRTC2)) {
+                DRM_ERROR("called with invalid crtc 0x%x\n", (unsigned int)value);
+                return DRM_ERR(EINVAL);
+        }
+        dev_priv->vblank_crtc = (unsigned int)value;
+        radeon_enable_interrupt(dev);
+        return 0;
+}
diff --git a/drivers/char/drm/radeon_state.c b/drivers/char/drm/radeon_state.c
index 98c5f1d3a8e7..3ddf86f2abf0 100644
--- a/drivers/char/drm/radeon_state.c
+++ b/drivers/char/drm/radeon_state.c
@@ -39,7 +39,7 @@
 
 static __inline__ int radeon_check_and_fixup_offset(drm_radeon_private_t *
                                                     dev_priv,
-                                                    drm_file_t * filp_priv,
+                                                    struct drm_file * filp_priv,
                                                     u32 *offset)
 {
         u64 off = *offset;
@@ -90,7 +90,7 @@ static __inline__ int radeon_check_and_fixup_offset(drm_radeon_private_t *
 
 static __inline__ int radeon_check_and_fixup_packets(drm_radeon_private_t *
                                                      dev_priv,
-                                                     drm_file_t * filp_priv,
+                                                     struct drm_file * filp_priv,
                                                      int id, u32 *data)
 {
         switch (id) {
@@ -264,7 +264,7 @@ static __inline__ int radeon_check_and_fixup_packets(drm_radeon_private_t *
 
 static __inline__ int radeon_check_and_fixup_packet3(drm_radeon_private_t *
                                                      dev_priv,
-                                                     drm_file_t *filp_priv,
+                                                     struct drm_file *filp_priv,
                                                      drm_radeon_kcmd_buffer_t *
                                                      cmdbuf,
                                                      unsigned int *cmdsz)
@@ -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;
 
@@ -439,7 +439,7 @@ static __inline__ void radeon_emit_clip_rect(drm_radeon_private_t * dev_priv,
 /* Emit 1.1 state
  */
 static int radeon_emit_state(drm_radeon_private_t * dev_priv,
-                             drm_file_t * filp_priv,
+                             struct drm_file * filp_priv,
                              drm_radeon_context_regs_t * ctx,
                              drm_radeon_texture_regs_t * tex,
                              unsigned int dirty)
@@ -608,7 +608,7 @@ static int radeon_emit_state(drm_radeon_private_t * dev_priv,
 /* Emit 1.2 state
  */
 static int radeon_emit_state2(drm_radeon_private_t * dev_priv,
-                              drm_file_t * filp_priv,
+                              struct drm_file * filp_priv,
                               drm_radeon_state_t * state)
 {
         RING_LOCALS;
@@ -844,7 +844,7 @@ static void radeon_cp_performance_boxes(drm_radeon_private_t * dev_priv)
  * CP command dispatch functions
  */
 
-static void radeon_cp_dispatch_clear(drm_device_t * dev,
+static void radeon_cp_dispatch_clear(struct drm_device * dev,
                                      drm_radeon_clear_t * clear,
                                      drm_radeon_clear_rect_t * depth_boxes)
 {
@@ -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;
@@ -1335,12 +1335,12 @@ static void radeon_cp_dispatch_clear(drm_device_t * dev,
         ADVANCE_RING();
 }
 
-static void radeon_cp_dispatch_swap(drm_device_t * dev)
+static void radeon_cp_dispatch_swap(struct drm_device * 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");
@@ -1412,10 +1412,10 @@ static void radeon_cp_dispatch_swap(drm_device_t * dev)
         ADVANCE_RING();
 }
 
-static void radeon_cp_dispatch_flip(drm_device_t * dev)
+static void radeon_cp_dispatch_flip(struct drm_device * 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;
@@ -1491,8 +1491,8 @@ typedef struct {
         unsigned int vc_format;
 } drm_radeon_tcl_prim_t;
 
-static void radeon_cp_dispatch_vertex(drm_device_t * dev,
-                                      drm_buf_t * buf,
+static void radeon_cp_dispatch_vertex(struct drm_device * dev,
+                                      struct drm_buf * buf,
                                       drm_radeon_tcl_prim_t * prim)
 {
         drm_radeon_private_t *dev_priv = dev->dev_private;
@@ -1537,7 +1537,7 @@ static void radeon_cp_dispatch_vertex(drm_device_t * dev,
         } while (i < nbox);
 }
 
-static void radeon_cp_discard_buffer(drm_device_t * dev, drm_buf_t * buf)
+static void radeon_cp_discard_buffer(struct drm_device * dev, struct drm_buf * buf)
 {
         drm_radeon_private_t *dev_priv = dev->dev_private;
         drm_radeon_buf_priv_t *buf_priv = buf->dev_private;
@@ -1554,8 +1554,8 @@ static void radeon_cp_discard_buffer(drm_device_t * dev, drm_buf_t * buf)
         buf->used = 0;
 }
 
-static void radeon_cp_dispatch_indirect(drm_device_t * dev,
-                                        drm_buf_t * buf, int start, int end)
+static void radeon_cp_dispatch_indirect(struct drm_device * dev,
+                                        struct drm_buf * buf, int start, int end)
 {
         drm_radeon_private_t *dev_priv = dev->dev_private;
         RING_LOCALS;
@@ -1588,8 +1588,8 @@ static void radeon_cp_dispatch_indirect(drm_device_t * dev,
         }
 }
 
-static void radeon_cp_dispatch_indices(drm_device_t * dev,
-                                       drm_buf_t * elt_buf,
+static void radeon_cp_dispatch_indices(struct drm_device * dev,
+                                       struct drm_buf * elt_buf,
                                        drm_radeon_tcl_prim_t * prim)
 {
         drm_radeon_private_t *dev_priv = dev->dev_private;
@@ -1647,13 +1647,13 @@ static void radeon_cp_dispatch_indices(drm_device_t * dev,
 #define RADEON_MAX_TEXTURE_SIZE RADEON_BUFFER_SIZE
 
 static int radeon_cp_dispatch_texture(DRMFILE filp,
-                                      drm_device_t * dev,
+                                      struct drm_device * dev,
                                       drm_radeon_texture_t * tex,
                                       drm_radeon_tex_image_t * image)
 {
         drm_radeon_private_t *dev_priv = dev->dev_private;
-        drm_file_t *filp_priv;
-        drm_buf_t *buf;
+        struct drm_file *filp_priv;
+        struct drm_buf *buf;
         u32 format;
         u32 *buffer;
         const u8 __user *data;
@@ -1881,7 +1881,7 @@ static int radeon_cp_dispatch_texture(DRMFILE filp,
         return 0;
 }
 
-static void radeon_cp_dispatch_stipple(drm_device_t * dev, u32 * stipple)
+static void radeon_cp_dispatch_stipple(struct drm_device * dev, u32 * stipple)
 {
         drm_radeon_private_t *dev_priv = dev->dev_private;
         int i;
@@ -2134,7 +2134,7 @@ static int radeon_cp_clear(DRM_IOCTL_ARGS)
 
 /* Not sure why this isn't set all the time:
  */
-static int radeon_do_init_pageflip(drm_device_t * dev)
+static int radeon_do_init_pageflip(struct drm_device * dev)
 {
         drm_radeon_private_t *dev_priv = dev->dev_private;
         RING_LOCALS;
@@ -2206,10 +2206,10 @@ static int radeon_cp_vertex(DRM_IOCTL_ARGS)
 {
         DRM_DEVICE;
         drm_radeon_private_t *dev_priv = dev->dev_private;
-        drm_file_t *filp_priv;
+        struct drm_file *filp_priv;
         drm_radeon_sarea_t *sarea_priv = dev_priv->sarea_priv;
-        drm_device_dma_t *dma = dev->dma;
-        drm_buf_t *buf;
+        struct drm_device_dma *dma = dev->dma;
+        struct drm_buf *buf;
         drm_radeon_vertex_t vertex;
         drm_radeon_tcl_prim_t prim;
 
@@ -2289,10 +2289,10 @@ static int radeon_cp_indices(DRM_IOCTL_ARGS)
 {
         DRM_DEVICE;
         drm_radeon_private_t *dev_priv = dev->dev_private;
-        drm_file_t *filp_priv;
+        struct drm_file *filp_priv;
         drm_radeon_sarea_t *sarea_priv = dev_priv->sarea_priv;
-        drm_device_dma_t *dma = dev->dma;
-        drm_buf_t *buf;
+        struct drm_device_dma *dma = dev->dma;
+        struct drm_buf *buf;
         drm_radeon_indices_t elts;
         drm_radeon_tcl_prim_t prim;
         int count;
@@ -2438,8 +2438,8 @@ static int radeon_cp_indirect(DRM_IOCTL_ARGS)
 {
         DRM_DEVICE;
         drm_radeon_private_t *dev_priv = dev->dev_private;
-        drm_device_dma_t *dma = dev->dma;
-        drm_buf_t *buf;
+        struct drm_device_dma *dma = dev->dma;
+        struct drm_buf *buf;
         drm_radeon_indirect_t indirect;
         RING_LOCALS;
 
@@ -2507,10 +2507,10 @@ static int radeon_cp_vertex2(DRM_IOCTL_ARGS)
 {
         DRM_DEVICE;
         drm_radeon_private_t *dev_priv = dev->dev_private;
-        drm_file_t *filp_priv;
+        struct drm_file *filp_priv;
         drm_radeon_sarea_t *sarea_priv = dev_priv->sarea_priv;
-        drm_device_dma_t *dma = dev->dma;
-        drm_buf_t *buf;
+        struct drm_device_dma *dma = dev->dma;
+        struct drm_buf *buf;
         drm_radeon_vertex2_t vertex;
         int i;
         unsigned char laststate;
@@ -2603,7 +2603,7 @@ static int radeon_cp_vertex2(DRM_IOCTL_ARGS)
 }
 
 static int radeon_emit_packets(drm_radeon_private_t * dev_priv,
-                               drm_file_t * filp_priv,
+                               struct drm_file * filp_priv,
                                drm_radeon_cmd_header_t header,
                                drm_radeon_kcmd_buffer_t *cmdbuf)
 {
@@ -2728,8 +2728,8 @@ static __inline__ int radeon_emit_veclinear(drm_radeon_private_t *dev_priv,
         return 0;
 }
 
-static int radeon_emit_packet3(drm_device_t * dev,
-                               drm_file_t * filp_priv,
+static int radeon_emit_packet3(struct drm_device * dev,
+                               struct drm_file * filp_priv,
                                drm_radeon_kcmd_buffer_t *cmdbuf)
 {
         drm_radeon_private_t *dev_priv = dev->dev_private;
@@ -2754,16 +2754,16 @@ static int radeon_emit_packet3(drm_device_t * dev,
         return 0;
 }
 
-static int radeon_emit_packet3_cliprect(drm_device_t *dev,
-                                        drm_file_t *filp_priv,
+static int radeon_emit_packet3_cliprect(struct drm_device *dev,
+                                        struct drm_file *filp_priv,
                                         drm_radeon_kcmd_buffer_t *cmdbuf,
                                         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;
 
@@ -2816,7 +2816,7 @@ static int radeon_emit_packet3_cliprect(drm_device_t *dev,
         return 0;
 }
 
-static int radeon_emit_wait(drm_device_t * dev, int flags)
+static int radeon_emit_wait(struct drm_device * dev, int flags)
 {
         drm_radeon_private_t *dev_priv = dev->dev_private;
         RING_LOCALS;
@@ -2849,9 +2849,9 @@ static int radeon_cp_cmdbuf(DRM_IOCTL_ARGS)
 {
         DRM_DEVICE;
         drm_radeon_private_t *dev_priv = dev->dev_private;
-        drm_file_t *filp_priv;
-        drm_device_dma_t *dma = dev->dma;
-        drm_buf_t *buf = NULL;
+        struct drm_file *filp_priv;
+        struct drm_device_dma *dma = dev->dma;
+        struct drm_buf *buf = NULL;
         int idx;
         drm_radeon_kcmd_buffer_t cmdbuf;
         drm_radeon_cmd_header_t header;
@@ -3085,6 +3085,9 @@ static int radeon_cp_getparam(DRM_IOCTL_ARGS)
                 else
                         value = RADEON_CARD_PCI;
                 break;
+        case RADEON_PARAM_VBLANK_CRTC:
+                value = radeon_vblank_crtc_get(dev);
+                break;
         default:
                 DRM_DEBUG("Invalid parameter %d\n", param.param);
                 return DRM_ERR(EINVAL);
@@ -3102,7 +3105,7 @@ static int radeon_cp_setparam(DRM_IOCTL_ARGS)
 {
         DRM_DEVICE;
         drm_radeon_private_t *dev_priv = dev->dev_private;
-        drm_file_t *filp_priv;
+        struct drm_file *filp_priv;
         drm_radeon_setparam_t sp;
         struct drm_radeon_driver_file_fields *radeon_priv;
 
@@ -3141,6 +3144,9 @@ static int radeon_cp_setparam(DRM_IOCTL_ARGS)
                 if (dev_priv->gart_info.table_size < RADEON_PCIGART_TABLE_SIZE)
                         dev_priv->gart_info.table_size = RADEON_PCIGART_TABLE_SIZE;
                 break;
+        case RADEON_SETPARAM_VBLANK_CRTC:
+                return radeon_vblank_crtc_set(dev, sp.value);
+                break;
         default:
                 DRM_DEBUG("Invalid parameter %d\n", sp.param);
                 return DRM_ERR(EINVAL);
@@ -3156,7 +3162,7 @@ static int radeon_cp_setparam(DRM_IOCTL_ARGS)
  *
  * DRM infrastructure takes care of reclaiming dma buffers.
  */
-void radeon_driver_preclose(drm_device_t * dev, DRMFILE filp)
+void radeon_driver_preclose(struct drm_device *dev, DRMFILE filp)
 {
         if (dev->dev_private) {
                 drm_radeon_private_t *dev_priv = dev->dev_private;
@@ -3167,7 +3173,7 @@ void radeon_driver_preclose(drm_device_t * dev, DRMFILE filp)
         }
 }
 
-void radeon_driver_lastclose(drm_device_t * dev)
+void radeon_driver_lastclose(struct drm_device *dev)
 {
         if (dev->dev_private) {
                 drm_radeon_private_t *dev_priv = dev->dev_private;
@@ -3180,7 +3186,7 @@ void radeon_driver_lastclose(drm_device_t * dev)
         radeon_do_release(dev);
 }
 
-int radeon_driver_open(drm_device_t * dev, drm_file_t * filp_priv)
+int radeon_driver_open(struct drm_device *dev, struct drm_file *filp_priv)
 {
         drm_radeon_private_t *dev_priv = dev->dev_private;
         struct drm_radeon_driver_file_fields *radeon_priv;
@@ -3202,7 +3208,7 @@ int radeon_driver_open(drm_device_t * dev, drm_file_t * filp_priv)
         return 0;
 }
 
-void radeon_driver_postclose(drm_device_t * dev, drm_file_t * filp_priv)
+void radeon_driver_postclose(struct drm_device *dev, struct drm_file *filp_priv)
 {
         struct drm_radeon_driver_file_fields *radeon_priv =
             filp_priv->driver_priv;
diff --git a/drivers/char/drm/savage_bci.c b/drivers/char/drm/savage_bci.c
index b94fab556809..18c7235f6b73 100644
--- a/drivers/char/drm/savage_bci.c
+++ b/drivers/char/drm/savage_bci.c
@@ -32,7 +32,7 @@
 #define SAVAGE_EVENT_USEC_TIMEOUT       5000000 /* 5s */
 #define SAVAGE_FREELIST_DEBUG           0
 
-static int savage_do_cleanup_bci(drm_device_t *dev);
+static int savage_do_cleanup_bci(struct drm_device *dev);
 
 static int
 savage_bci_wait_fifo_shadow(drm_savage_private_t * dev_priv, unsigned int n)
@@ -203,11 +203,11 @@ uint16_t savage_bci_emit_event(drm_savage_private_t * dev_priv,
 /*
  * Freelist management
  */
-static int savage_freelist_init(drm_device_t * dev)
+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;
-        drm_buf_t *buf;
+        struct drm_device_dma *dma = dev->dma;
+        struct drm_buf *buf;
         drm_savage_buf_priv_t *entry;
         int i;
         DRM_DEBUG("count=%d\n", dma->buf_count);
@@ -236,7 +236,7 @@ static int savage_freelist_init(drm_device_t * dev)
         return 0;
 }
 
-static drm_buf_t *savage_freelist_get(drm_device_t * dev)
+static struct drm_buf *savage_freelist_get(struct drm_device * dev)
 {
         drm_savage_private_t *dev_priv = dev->dev_private;
         drm_savage_buf_priv_t *tail = dev_priv->tail.prev;
@@ -269,7 +269,7 @@ static drm_buf_t *savage_freelist_get(drm_device_t * dev)
         return NULL;
 }
 
-void savage_freelist_put(drm_device_t * dev, drm_buf_t * buf)
+void savage_freelist_put(struct drm_device * dev, struct drm_buf * buf)
 {
         drm_savage_private_t *dev_priv = dev->dev_private;
         drm_savage_buf_priv_t *entry = buf->dev_private, *prev, *next;
@@ -535,7 +535,7 @@ static void savage_fake_dma_flush(drm_savage_private_t * dev_priv)
         dev_priv->first_dma_page = dev_priv->current_dma_page = 0;
 }
 
-int savage_driver_load(drm_device_t *dev, unsigned long chipset)
+int savage_driver_load(struct drm_device *dev, unsigned long chipset)
 {
         drm_savage_private_t *dev_priv;
 
@@ -558,7 +558,7 @@ int savage_driver_load(drm_device_t *dev, unsigned long chipset)
  * in drm_addmap. Therefore we add them manually before the maps are
  * initialized, and tear them down on last close.
  */
-int savage_driver_firstopen(drm_device_t *dev)
+int savage_driver_firstopen(struct drm_device *dev)
 {
         drm_savage_private_t *dev_priv = dev->dev_private;
         unsigned long mmio_base, fb_base, fb_size, aperture_base;
@@ -655,7 +655,7 @@ int savage_driver_firstopen(drm_device_t *dev)
 /*
  * Delete MTRRs and free device-private data.
  */
-void savage_driver_lastclose(drm_device_t *dev)
+void savage_driver_lastclose(struct drm_device *dev)
 {
         drm_savage_private_t *dev_priv = dev->dev_private;
         int i;
@@ -667,7 +667,7 @@ void savage_driver_lastclose(drm_device_t *dev)
                                  dev_priv->mtrr[i].size, DRM_MTRR_WC);
 }
 
-int savage_driver_unload(drm_device_t *dev)
+int savage_driver_unload(struct drm_device *dev)
 {
         drm_savage_private_t *dev_priv = dev->dev_private;
 
@@ -676,7 +676,7 @@ int savage_driver_unload(drm_device_t *dev)
         return 0;
 }
 
-static int savage_do_init_bci(drm_device_t * dev, drm_savage_init_t * init)
+static int savage_do_init_bci(struct drm_device * dev, drm_savage_init_t * init)
 {
         drm_savage_private_t *dev_priv = dev->dev_private;
 
@@ -711,7 +711,7 @@ static int savage_do_init_bci(drm_device_t * dev, drm_savage_init_t * init)
         dev_priv->texture_offset = init->texture_offset;
         dev_priv->texture_size = init->texture_size;
 
-        DRM_GETSAREA();
+        dev_priv->sarea = drm_getsarea(dev);
         if (!dev_priv->sarea) {
                 DRM_ERROR("could not find sarea!\n");
                 savage_do_cleanup_bci(dev);
@@ -898,7 +898,7 @@ static int savage_do_init_bci(drm_device_t * dev, drm_savage_init_t * init)
         return 0;
 }
 
-static int savage_do_cleanup_bci(drm_device_t * dev)
+static int savage_do_cleanup_bci(struct drm_device * dev)
 {
         drm_savage_private_t *dev_priv = dev->dev_private;
 
@@ -1007,9 +1007,9 @@ 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, struct drm_device *dev, struct drm_dma *d)
 {
-        drm_buf_t *buf;
+        struct drm_buf *buf;
         int i;
 
         for (i = d->granted_count; i < d->request_count; i++) {
@@ -1034,13 +1034,13 @@ static int savage_bci_get_buffers(DRMFILE filp, drm_device_t *dev, drm_dma_t *d)
 int savage_bci_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 __user *) data, sizeof(d));
+        DRM_COPY_FROM_USER_IOCTL(d, (struct drm_dma __user *) data, sizeof(d));
 
         /* Please don't send us buffers.
          */
@@ -1064,14 +1064,14 @@ 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;
 }
 
-void savage_reclaim_buffers(drm_device_t *dev, DRMFILE filp)
+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;
 
@@ -1085,7 +1085,7 @@ void savage_reclaim_buffers(drm_device_t *dev, DRMFILE filp)
         /*i830_flush_queue(dev); */
 
         for (i = 0; i < dma->buf_count; i++) {
-                drm_buf_t *buf = dma->buflist[i];
+                struct drm_buf *buf = dma->buflist[i];
                 drm_savage_buf_priv_t *buf_priv = buf->dev_private;
 
                 if (buf->filp == filp && buf_priv &&
diff --git a/drivers/char/drm/savage_drm.h b/drivers/char/drm/savage_drm.h
index e1148e8e7994..8a576ef01821 100644
--- a/drivers/char/drm/savage_drm.h
+++ b/drivers/char/drm/savage_drm.h
@@ -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 +
+        struct drm_tex_region texList[SAVAGE_NR_TEX_HEAPS][SAVAGE_NR_TEX_REGIONS +
                                                       1];
         unsigned int texAge[SAVAGE_NR_TEX_HEAPS];
 
@@ -113,7 +113,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;
 
diff --git a/drivers/char/drm/savage_drv.h b/drivers/char/drm/savage_drv.h
index 8f04b3d82292..5fd54de4280e 100644
--- a/drivers/char/drm/savage_drv.h
+++ b/drivers/char/drm/savage_drv.h
@@ -58,7 +58,7 @@ typedef struct drm_savage_buf_priv {
         struct drm_savage_buf_priv *next;
         struct drm_savage_buf_priv *prev;
         drm_savage_age_t age;
-        drm_buf_t *buf;
+        struct drm_buf *buf;
 } drm_savage_buf_priv_t;
 
 typedef struct drm_savage_dma_page {
@@ -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;
 
@@ -203,22 +203,22 @@ extern int savage_bci_buffers(DRM_IOCTL_ARGS);
 /* BCI functions */
 extern uint16_t savage_bci_emit_event(drm_savage_private_t * dev_priv,
                                       unsigned int flags);
-extern void savage_freelist_put(drm_device_t * dev, drm_buf_t * buf);
+extern void savage_freelist_put(struct drm_device * dev, struct drm_buf * buf);
 extern void savage_dma_reset(drm_savage_private_t * dev_priv);
 extern void savage_dma_wait(drm_savage_private_t * dev_priv, unsigned int page);
 extern uint32_t *savage_dma_alloc(drm_savage_private_t * dev_priv,
                                   unsigned int n);
-extern int savage_driver_load(drm_device_t *dev, unsigned long chipset);
-extern int savage_driver_firstopen(drm_device_t *dev);
-extern void savage_driver_lastclose(drm_device_t *dev);
-extern int savage_driver_unload(drm_device_t *dev);
-extern void savage_reclaim_buffers(drm_device_t * dev, DRMFILE filp);
+extern int savage_driver_load(struct drm_device *dev, unsigned long chipset);
+extern int savage_driver_firstopen(struct drm_device *dev);
+extern void savage_driver_lastclose(struct drm_device *dev);
+extern int savage_driver_unload(struct drm_device *dev);
+extern void savage_reclaim_buffers(struct drm_device * 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 */
diff --git a/drivers/char/drm/savage_state.c b/drivers/char/drm/savage_state.c
index 1ca1e9cb5a33..77497841478a 100644
--- a/drivers/char/drm/savage_state.c
+++ b/drivers/char/drm/savage_state.c
@@ -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;
@@ -277,7 +277,7 @@ static int savage_dispatch_state(drm_savage_private_t * dev_priv,
 
 static int savage_dispatch_dma_prim(drm_savage_private_t * dev_priv,
                                     const drm_savage_cmd_header_t * cmd_header,
-                                    const drm_buf_t * dmabuf)
+                                    const struct drm_buf * dmabuf)
 {
         unsigned char reorder = 0;
         unsigned int prim = cmd_header->prim.prim;
@@ -536,7 +536,7 @@ static int savage_dispatch_vb_prim(drm_savage_private_t * dev_priv,
 static int savage_dispatch_dma_idx(drm_savage_private_t * dev_priv,
                                    const drm_savage_cmd_header_t * cmd_header,
                                    const uint16_t *idx,
-                                   const drm_buf_t * dmabuf)
+                                   const struct drm_buf * dmabuf)
 {
         unsigned char reorder = 0;
         unsigned int prim = cmd_header->idx.prim;
@@ -792,7 +792,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;
@@ -861,7 +861,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;
@@ -892,11 +892,11 @@ static int savage_dispatch_swap(drm_savage_private_t * dev_priv,
 static int savage_dispatch_draw(drm_savage_private_t * dev_priv,
                                 const drm_savage_cmd_header_t *start,
                                 const drm_savage_cmd_header_t *end,
-                                const drm_buf_t * dmabuf,
+                                const struct drm_buf * dmabuf,
                                 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;
@@ -957,13 +957,13 @@ int savage_bci_cmdbuf(DRM_IOCTL_ARGS)
 {
         DRM_DEVICE;
         drm_savage_private_t *dev_priv = dev->dev_private;
-        drm_device_dma_t *dma = dev->dma;
-        drm_buf_t *dmabuf;
+        struct drm_device_dma *dma = dev->dma;
+        struct drm_buf *dmabuf;
         drm_savage_cmdbuf_t cmdbuf;
         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;
 
@@ -1019,7 +1019,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);
@@ -1027,7 +1027,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;
                 }
@@ -1158,7 +1158,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;
diff --git a/drivers/char/drm/sis_drv.c b/drivers/char/drm/sis_drv.c
index 690e0af8e7c2..1912f5857051 100644
--- a/drivers/char/drm/sis_drv.c
+++ b/drivers/char/drm/sis_drv.c
@@ -35,7 +35,7 @@ static struct pci_device_id pciidlist[] = {
         sisdrv_PCI_IDS
 };
 
-static int sis_driver_load(drm_device_t *dev, unsigned long chipset)
+static int sis_driver_load(struct drm_device *dev, unsigned long chipset)
 {
         drm_sis_private_t *dev_priv;
         int ret;
@@ -54,7 +54,7 @@ static int sis_driver_load(drm_device_t *dev, unsigned long chipset)
         return ret;
 }
 
-static int sis_driver_unload(drm_device_t *dev)
+static int sis_driver_unload(struct drm_device *dev)
 {
         drm_sis_private_t *dev_priv = dev->dev_private;
 
diff --git a/drivers/char/drm/sis_drv.h b/drivers/char/drm/sis_drv.h
index 70d4ede75fe8..5630df874353 100644
--- a/drivers/char/drm/sis_drv.h
+++ b/drivers/char/drm/sis_drv.h
@@ -46,6 +46,7 @@ enum sis_family {
 
 #include "drm_sman.h"
 
+
 #define SIS_BASE (dev_priv->mmio)
 #define SIS_READ(reg)         DRM_READ32(SIS_BASE, reg);
 #define SIS_WRITE(reg, val)   DRM_WRITE32(SIS_BASE, reg, val);
@@ -53,7 +54,7 @@ enum sis_family {
 typedef struct drm_sis_private {
         drm_local_map_t *mmio;
         unsigned int idle_fault;
-        drm_sman_t sman;
+        struct drm_sman sman;
         unsigned int chipset;
         int vram_initialized;
         int agp_initialized;
@@ -61,9 +62,9 @@ typedef struct drm_sis_private {
         unsigned long agp_offset;
 } drm_sis_private_t;
 
-extern int sis_idle(drm_device_t *dev);
-extern void sis_reclaim_buffers_locked(drm_device_t *dev, struct file *filp);
-extern void sis_lastclose(drm_device_t *dev);
+extern int sis_idle(struct drm_device *dev);
+extern void sis_reclaim_buffers_locked(struct drm_device *dev, struct file *filp);
+extern void sis_lastclose(struct drm_device *dev);
 
 extern drm_ioctl_desc_t sis_ioctls[];
 extern int sis_max_ioctl;
diff --git a/drivers/char/drm/sis_mm.c b/drivers/char/drm/sis_mm.c
index d26f5dbb7853..0580fa33cb77 100644
--- a/drivers/char/drm/sis_mm.c
+++ b/drivers/char/drm/sis_mm.c
@@ -123,14 +123,14 @@ static int sis_fb_init(DRM_IOCTL_ARGS)
         return 0;
 }
 
-static int sis_drm_alloc(drm_device_t * dev, drm_file_t * priv,
+static int sis_drm_alloc(struct drm_device *dev, struct drm_file * priv,
                          unsigned long data, int pool)
 {
         drm_sis_private_t *dev_priv = dev->dev_private;
         drm_sis_mem_t __user *argp = (drm_sis_mem_t __user *) data;
         drm_sis_mem_t mem;
         int retval = 0;
-        drm_memblock_item_t *item;
+        struct drm_memblock_item *item;
 
         DRM_COPY_FROM_USER_IOCTL(mem, argp, sizeof(mem));
 
@@ -229,12 +229,12 @@ static int sis_ioctl_agp_alloc(DRM_IOCTL_ARGS)
         return sis_drm_alloc(dev, priv, data, AGP_TYPE);
 }
 
-static drm_local_map_t *sis_reg_init(drm_device_t *dev)
+static drm_local_map_t *sis_reg_init(struct drm_device *dev)
 {
-        drm_map_list_t *entry;
+        struct drm_map_list *entry;
         drm_local_map_t *map;
 
-        list_for_each_entry(entry, &dev->maplist->head, head) {
+        list_for_each_entry(entry, &dev->maplist, head) {
                 map = entry->map;
                 if (!map)
                         continue;
@@ -245,7 +245,7 @@ static drm_local_map_t *sis_reg_init(drm_device_t *dev)
         return NULL;
 }
 
-int sis_idle(drm_device_t *dev)
+int sis_idle(struct drm_device *dev)
 {
         drm_sis_private_t *dev_priv = dev->dev_private;
         uint32_t idle_reg;
@@ -314,10 +314,10 @@ void sis_lastclose(struct drm_device *dev)
         mutex_unlock(&dev->struct_mutex);
 }
 
-void sis_reclaim_buffers_locked(drm_device_t * dev, struct file *filp)
+void sis_reclaim_buffers_locked(struct drm_device * dev, struct file *filp)
 {
         drm_sis_private_t *dev_priv = dev->dev_private;
-        drm_file_t *priv = filp->private_data;
+        struct drm_file *priv = filp->private_data;
 
         mutex_lock(&dev->struct_mutex);
         if (drm_sman_owner_clean(&dev_priv->sman, (unsigned long)priv)) {
diff --git a/drivers/char/drm/via_dma.c b/drivers/char/drm/via_dma.c
index 13a9c5ca4593..7ff2b623c2d4 100644
--- a/drivers/char/drm/via_dma.c
+++ b/drivers/char/drm/via_dma.c
@@ -151,7 +151,7 @@ static inline uint32_t *via_check_dma(drm_via_private_t * dev_priv,
         return (uint32_t *) (dev_priv->dma_ptr + dev_priv->dma_low);
 }
 
-int via_dma_cleanup(drm_device_t * dev)
+int via_dma_cleanup(struct drm_device * dev)
 {
         if (dev->dev_private) {
                 drm_via_private_t *dev_priv =
@@ -169,7 +169,7 @@ int via_dma_cleanup(drm_device_t * dev)
         return 0;
 }
 
-static int via_initialize(drm_device_t * dev,
+static int via_initialize(struct drm_device * dev,
                           drm_via_private_t * dev_priv,
                           drm_via_dma_init_t * init)
 {
@@ -262,7 +262,7 @@ static int via_dma_init(DRM_IOCTL_ARGS)
         return retcode;
 }
 
-static int via_dispatch_cmdbuffer(drm_device_t * dev, drm_via_cmdbuffer_t * cmd)
+static int via_dispatch_cmdbuffer(struct drm_device * dev, drm_via_cmdbuffer_t * cmd)
 {
         drm_via_private_t *dev_priv;
         uint32_t *vb;
@@ -316,7 +316,7 @@ static int via_dispatch_cmdbuffer(drm_device_t * dev, drm_via_cmdbuffer_t * cmd)
         return 0;
 }
 
-int via_driver_dma_quiescent(drm_device_t * dev)
+int via_driver_dma_quiescent(struct drm_device * dev)
 {
         drm_via_private_t *dev_priv = dev->dev_private;
 
@@ -356,7 +356,7 @@ static int via_cmdbuffer(DRM_IOCTL_ARGS)
         return 0;
 }
 
-static int via_dispatch_pci_cmdbuffer(drm_device_t * dev,
+static int via_dispatch_pci_cmdbuffer(struct drm_device * dev,
                                       drm_via_cmdbuffer_t * cmd)
 {
         drm_via_private_t *dev_priv = dev->dev_private;
diff --git a/drivers/char/drm/via_dmablit.c b/drivers/char/drm/via_dmablit.c
index 2881a06b6f55..fdb8609dd76f 100644
--- a/drivers/char/drm/via_dmablit.c
+++ b/drivers/char/drm/via_dmablit.c
@@ -207,7 +207,7 @@ via_free_sg_info(struct pci_dev *pdev, drm_via_sg_info_t *vsg)
  */
 
 static void
-via_fire_dmablit(drm_device_t *dev, drm_via_sg_info_t *vsg, int engine)
+via_fire_dmablit(struct drm_device *dev, drm_via_sg_info_t *vsg, int engine)
 {
         drm_via_private_t *dev_priv = (drm_via_private_t *)dev->dev_private;
 
@@ -289,7 +289,7 @@ via_alloc_desc_pages(drm_via_sg_info_t *vsg)
 }
                         
 static void
-via_abort_dmablit(drm_device_t *dev, int engine)
+via_abort_dmablit(struct drm_device *dev, int engine)
 {
         drm_via_private_t *dev_priv = (drm_via_private_t *)dev->dev_private;
 
@@ -297,7 +297,7 @@ via_abort_dmablit(drm_device_t *dev, int engine)
 }
 
 static void
-via_dmablit_engine_off(drm_device_t *dev, int engine)
+via_dmablit_engine_off(struct drm_device *dev, int engine)
 {
         drm_via_private_t *dev_priv = (drm_via_private_t *)dev->dev_private;
 
@@ -314,7 +314,7 @@ via_dmablit_engine_off(drm_device_t *dev, int engine)
  */
                 
 void
-via_dmablit_handler(drm_device_t *dev, int engine, int from_irq)
+via_dmablit_handler(struct drm_device *dev, int engine, int from_irq)
 {
         drm_via_private_t *dev_priv = (drm_via_private_t *)dev->dev_private;
         drm_via_blitq_t *blitq = dev_priv->blit_queues + engine;
@@ -433,7 +433,7 @@ via_dmablit_active(drm_via_blitq_t *blitq, int engine, uint32_t handle, wait_que
  */
 
 static int
-via_dmablit_sync(drm_device_t *dev, uint32_t handle, int engine) 
+via_dmablit_sync(struct drm_device *dev, uint32_t handle, int engine) 
 {
 
         drm_via_private_t *dev_priv = (drm_via_private_t *)dev->dev_private;
@@ -466,7 +466,7 @@ static void
 via_dmablit_timer(unsigned long data)
 {
         drm_via_blitq_t *blitq = (drm_via_blitq_t *) data;
-        drm_device_t *dev = blitq->dev;
+        struct drm_device *dev = blitq->dev;
         int engine = (int)
                 (blitq - ((drm_via_private_t *)dev->dev_private)->blit_queues);
                 
@@ -502,7 +502,7 @@ static void
 via_dmablit_workqueue(struct work_struct *work)
 {
         drm_via_blitq_t *blitq = container_of(work, drm_via_blitq_t, wq);
-        drm_device_t *dev = blitq->dev;
+        struct drm_device *dev = blitq->dev;
         unsigned long irqsave;
         drm_via_sg_info_t *cur_sg;
         int cur_released;
@@ -545,7 +545,7 @@ via_dmablit_workqueue(struct work_struct *work)
 
 
 void
-via_init_dmablit(drm_device_t *dev)
+via_init_dmablit(struct drm_device *dev)
 {
         int i,j;
         drm_via_private_t *dev_priv = (drm_via_private_t *)dev->dev_private;
@@ -582,7 +582,7 @@ via_init_dmablit(drm_device_t *dev)
                 
 
 static int
-via_build_sg_info(drm_device_t *dev, drm_via_sg_info_t *vsg, drm_via_dmablit_t *xfer)
+via_build_sg_info(struct drm_device *dev, drm_via_sg_info_t *vsg, drm_via_dmablit_t *xfer)
 {
         int draw = xfer->to_fb;
         int ret = 0;
@@ -730,7 +730,7 @@ via_dmablit_release_slot(drm_via_blitq_t *blitq)
 
 
 static int 
-via_dmablit(drm_device_t *dev, drm_via_dmablit_t *xfer)  
+via_dmablit(struct drm_device *dev, drm_via_dmablit_t *xfer)     
 {
         drm_via_private_t *dev_priv = (drm_via_private_t *)dev->dev_private;
         drm_via_sg_info_t *vsg;
diff --git a/drivers/char/drm/via_dmablit.h b/drivers/char/drm/via_dmablit.h
index f4036cd5d0e0..6f6a513d5147 100644
--- a/drivers/char/drm/via_dmablit.h
+++ b/drivers/char/drm/via_dmablit.h
@@ -59,7 +59,7 @@ typedef struct _drm_via_sg_info {
 } drm_via_sg_info_t;
 
 typedef struct _drm_via_blitq {
-        drm_device_t *dev;
+        struct drm_device *dev;
         uint32_t cur_blit_handle;
         uint32_t done_blit_handle;
         unsigned serviced;
diff --git a/drivers/char/drm/via_drm.h b/drivers/char/drm/via_drm.h
index e4ee97d7156f..8f53c76062e9 100644
--- a/drivers/char/drm/via_drm.h
+++ b/drivers/char/drm/via_drm.h
@@ -40,7 +40,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)))
@@ -182,7 +182,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 */
diff --git a/drivers/char/drm/via_drv.h b/drivers/char/drm/via_drv.h
index b46ca8e6306d..576711564a11 100644
--- a/drivers/char/drm/via_drv.h
+++ b/drivers/char/drm/via_drv.h
@@ -87,7 +87,7 @@ typedef struct drm_via_private {
         uint32_t irq_pending_mask;
         int *irq_map;
         unsigned int idle_fault;
-        drm_sman_t sman;
+        struct drm_sman sman;
         int vram_initialized;
         int agp_initialized;
         unsigned long vram_offset;
@@ -123,31 +123,31 @@ extern int via_wait_irq(DRM_IOCTL_ARGS);
 extern int via_dma_blit_sync( DRM_IOCTL_ARGS );
 extern int via_dma_blit( DRM_IOCTL_ARGS );
 
-extern int via_driver_load(drm_device_t *dev, unsigned long chipset);
-extern int via_driver_unload(drm_device_t *dev);
+extern int via_driver_load(struct drm_device *dev, unsigned long chipset);
+extern int via_driver_unload(struct drm_device *dev);
 
-extern int via_init_context(drm_device_t * dev, int context);
-extern int via_final_context(drm_device_t * dev, int context);
+extern int via_init_context(struct drm_device * dev, int context);
+extern int via_final_context(struct drm_device * dev, int context);
 
-extern int via_do_cleanup_map(drm_device_t * dev);
-extern int via_driver_vblank_wait(drm_device_t * dev, unsigned int *sequence);
+extern int via_do_cleanup_map(struct drm_device * dev);
+extern int via_driver_vblank_wait(struct drm_device * dev, unsigned int *sequence);
 
 extern irqreturn_t via_driver_irq_handler(DRM_IRQ_ARGS);
-extern void via_driver_irq_preinstall(drm_device_t * dev);
-extern void via_driver_irq_postinstall(drm_device_t * dev);
-extern void via_driver_irq_uninstall(drm_device_t * dev);
+extern void via_driver_irq_preinstall(struct drm_device * dev);
+extern void via_driver_irq_postinstall(struct drm_device * dev);
+extern void via_driver_irq_uninstall(struct drm_device * dev);
 
-extern int via_dma_cleanup(drm_device_t * dev);
+extern int via_dma_cleanup(struct drm_device * dev);
 extern void via_init_command_verifier(void);
-extern int via_driver_dma_quiescent(drm_device_t * dev);
+extern int via_driver_dma_quiescent(struct drm_device * dev);
 extern void via_init_futex(drm_via_private_t * dev_priv);
 extern void via_cleanup_futex(drm_via_private_t * dev_priv);
 extern void via_release_futex(drm_via_private_t * dev_priv, int context);
 
-extern void via_reclaim_buffers_locked(drm_device_t *dev, struct file *filp);
-extern void via_lastclose(drm_device_t *dev);
+extern void via_reclaim_buffers_locked(struct drm_device *dev, struct file *filp);
+extern void via_lastclose(struct drm_device *dev);
 
-extern void via_dmablit_handler(drm_device_t *dev, int engine, int from_irq);
-extern void via_init_dmablit(drm_device_t *dev);
+extern void via_dmablit_handler(struct drm_device *dev, int engine, int from_irq);
+extern void via_init_dmablit(struct drm_device *dev);
 
 #endif
diff --git a/drivers/char/drm/via_irq.c b/drivers/char/drm/via_irq.c
index 1ac5941ad237..8dc99b5fbab6 100644
--- a/drivers/char/drm/via_irq.c
+++ b/drivers/char/drm/via_irq.c
@@ -98,7 +98,7 @@ static unsigned time_diff(struct timeval *now, struct timeval *then)
 
 irqreturn_t via_driver_irq_handler(DRM_IRQ_ARGS)
 {
-        drm_device_t *dev = (drm_device_t *) arg;
+        struct drm_device *dev = (struct drm_device *) arg;
         drm_via_private_t *dev_priv = (drm_via_private_t *) dev->dev_private;
         u32 status;
         int handled = 0;
@@ -163,7 +163,7 @@ static __inline__ void viadrv_acknowledge_irqs(drm_via_private_t * dev_priv)
         }
 }
 
-int via_driver_vblank_wait(drm_device_t * dev, unsigned int *sequence)
+int via_driver_vblank_wait(struct drm_device * dev, unsigned int *sequence)
 {
         drm_via_private_t *dev_priv = (drm_via_private_t *) dev->dev_private;
         unsigned int cur_vblank;
@@ -191,7 +191,7 @@ int via_driver_vblank_wait(drm_device_t * dev, unsigned int *sequence)
 }
 
 static int
-via_driver_irq_wait(drm_device_t * dev, unsigned int irq, int force_sequence,
+via_driver_irq_wait(struct drm_device * dev, unsigned int irq, int force_sequence,
                     unsigned int *sequence)
 {
         drm_via_private_t *dev_priv = (drm_via_private_t *) dev->dev_private;
@@ -244,7 +244,7 @@ via_driver_irq_wait(drm_device_t * dev, unsigned int irq, int force_sequence,
  * drm_dma.h hooks
  */
 
-void via_driver_irq_preinstall(drm_device_t * dev)
+void via_driver_irq_preinstall(struct drm_device * dev)
 {
         drm_via_private_t *dev_priv = (drm_via_private_t *) dev->dev_private;
         u32 status;
@@ -293,7 +293,7 @@ void via_driver_irq_preinstall(drm_device_t * dev)
         }
 }
 
-void via_driver_irq_postinstall(drm_device_t * dev)
+void via_driver_irq_postinstall(struct drm_device * dev)
 {
         drm_via_private_t *dev_priv = (drm_via_private_t *) dev->dev_private;
         u32 status;
@@ -312,7 +312,7 @@ void via_driver_irq_postinstall(drm_device_t * dev)
         }
 }
 
-void via_driver_irq_uninstall(drm_device_t * dev)
+void via_driver_irq_uninstall(struct drm_device * dev)
 {
         drm_via_private_t *dev_priv = (drm_via_private_t *) dev->dev_private;
         u32 status;
diff --git a/drivers/char/drm/via_map.c b/drivers/char/drm/via_map.c
index 4e3fc072aa3b..7fb9d2a2cce2 100644
--- a/drivers/char/drm/via_map.c
+++ b/drivers/char/drm/via_map.c
@@ -25,13 +25,13 @@
 #include "via_drm.h"
 #include "via_drv.h"
 
-static int via_do_init_map(drm_device_t * dev, drm_via_init_t * init)
+static int via_do_init_map(struct drm_device * dev, drm_via_init_t * init)
 {
         drm_via_private_t *dev_priv = dev->dev_private;
 
         DRM_DEBUG("%s\n", __FUNCTION__);
 
-        DRM_GETSAREA();
+        dev_priv->sarea = drm_getsarea(dev);
         if (!dev_priv->sarea) {
                 DRM_ERROR("could not find sarea!\n");
                 dev->dev_private = (void *)dev_priv;
@@ -68,7 +68,7 @@ static int via_do_init_map(drm_device_t * dev, drm_via_init_t * init)
         return 0;
 }
 
-int via_do_cleanup_map(drm_device_t * dev)
+int via_do_cleanup_map(struct drm_device * dev)
 {
         via_dma_cleanup(dev);
 
@@ -95,7 +95,7 @@ int via_map_init(DRM_IOCTL_ARGS)
         return -EINVAL;
 }
 
-int via_driver_load(drm_device_t *dev, unsigned long chipset)
+int via_driver_load(struct drm_device *dev, unsigned long chipset)
 {
         drm_via_private_t *dev_priv;
         int ret = 0;
@@ -115,7 +115,7 @@ int via_driver_load(drm_device_t *dev, unsigned long chipset)
         return ret;
 }
 
-int via_driver_unload(drm_device_t *dev)
+int via_driver_unload(struct drm_device *dev)
 {
         drm_via_private_t *dev_priv = dev->dev_private;
 
diff --git a/drivers/char/drm/via_mm.c b/drivers/char/drm/via_mm.c
index 2fcf0577a7aa..85d56acd9d82 100644
--- a/drivers/char/drm/via_mm.c
+++ b/drivers/char/drm/via_mm.c
@@ -127,7 +127,7 @@ int via_mem_alloc(DRM_IOCTL_ARGS)
 
         drm_via_mem_t mem;
         int retval = 0;
-        drm_memblock_item_t *item;
+        struct drm_memblock_item *item;
         drm_via_private_t *dev_priv = (drm_via_private_t *) dev->dev_private;
         unsigned long tmpSize;
 
@@ -188,10 +188,10 @@ int via_mem_free(DRM_IOCTL_ARGS)
 }
 
 
-void via_reclaim_buffers_locked(drm_device_t * dev, struct file *filp)
+void via_reclaim_buffers_locked(struct drm_device * dev, struct file *filp)
 {
         drm_via_private_t *dev_priv = dev->dev_private;
-        drm_file_t *priv = filp->private_data;
+        struct drm_file *priv = filp->private_data;
 
         mutex_lock(&dev->struct_mutex);
         if (drm_sman_owner_clean(&dev_priv->sman, (unsigned long)priv)) {
diff --git a/drivers/char/drm/via_verifier.c b/drivers/char/drm/via_verifier.c
index 2e7e08078287..832d48356e91 100644
--- a/drivers/char/drm/via_verifier.c
+++ b/drivers/char/drm/via_verifier.c
@@ -252,10 +252,9 @@ eat_words(const uint32_t ** buf, const uint32_t * buf_end, unsigned num_words)
 static __inline__ drm_local_map_t *via_drm_lookup_agp_map(drm_via_state_t *seq,
                                                     unsigned long offset,
                                                     unsigned long size,
-                                                    drm_device_t * dev)
+                                                    struct drm_device * dev)
 {
-        struct list_head *list;
-        drm_map_list_t *r_list;
+        struct drm_map_list *r_list;
         drm_local_map_t *map = seq->map_cache;
 
         if (map && map->offset <= offset
@@ -263,8 +262,7 @@ static __inline__ drm_local_map_t *via_drm_lookup_agp_map(drm_via_state_t *seq,
                 return map;
         }
 
-        list_for_each(list, &dev->maplist->head) {
-                r_list = (drm_map_list_t *) list;
+        list_for_each_entry(r_list, &dev->maplist, head) {
                 map = r_list->map;
                 if (!map)
                         continue;
@@ -964,7 +962,7 @@ via_parse_vheader6(drm_via_private_t * dev_priv, uint32_t const **buffer,
 
 int
 via_verify_command_stream(const uint32_t * buf, unsigned int size,
-                          drm_device_t * dev, int agp)
+                          struct drm_device * dev, int agp)
 {
 
         drm_via_private_t *dev_priv = (drm_via_private_t *) dev->dev_private;
@@ -1039,7 +1037,7 @@ via_verify_command_stream(const uint32_t * buf, unsigned int size,
 }
 
 int
-via_parse_command_stream(drm_device_t * dev, const uint32_t * buf,
+via_parse_command_stream(struct drm_device * dev, const uint32_t * buf,
                          unsigned int size)
 {
 
diff --git a/drivers/char/drm/via_verifier.h b/drivers/char/drm/via_verifier.h
index b77f59df0278..28b50296a7bd 100644
--- a/drivers/char/drm/via_verifier.h
+++ b/drivers/char/drm/via_verifier.h
@@ -47,7 +47,7 @@ typedef struct {
         drm_via_sequence_t unfinished;
         int agp_texture;
         int multitex;
-        drm_device_t *dev;
+        struct drm_device *dev;
         drm_local_map_t *map_cache;
         uint32_t vertex_count;
         int agp;
@@ -55,8 +55,8 @@ typedef struct {
 } drm_via_state_t;
 
 extern int via_verify_command_stream(const uint32_t * buf, unsigned int size,
-                                     drm_device_t * dev, int agp);
-extern int via_parse_command_stream(drm_device_t *dev, const uint32_t *buf,
+                                     struct drm_device * dev, int agp);
+extern int via_parse_command_stream(struct drm_device *dev, const uint32_t *buf,
                                     unsigned int size);
 
 #endif