Merge branch 'drm-patches' of ssh://master.kernel.org/pub/scm/linux/kernel/git/airlie...
authorLinus Torvalds <torvalds@woody.linux-foundation.org>
Mon, 16 Jul 2007 19:15:50 +0000 (12:15 -0700)
committerLinus Torvalds <torvalds@woody.linux-foundation.org>
Mon, 16 Jul 2007 19:15:50 +0000 (12:15 -0700)
* '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:
drivers/char/drm/ati_pcigart.c
drivers/char/drm/drm.h
drivers/char/drm/drmP.h
drivers/char/drm/drm_agpsupport.c
drivers/char/drm/drm_auth.c
drivers/char/drm/drm_bufs.c
drivers/char/drm/drm_context.c
drivers/char/drm/drm_dma.c
drivers/char/drm/drm_drawable.c
drivers/char/drm/drm_drv.c
drivers/char/drm/drm_fops.c
drivers/char/drm/drm_hashtab.c
drivers/char/drm/drm_hashtab.h
drivers/char/drm/drm_ioc32.c
drivers/char/drm/drm_ioctl.c
drivers/char/drm/drm_irq.c
drivers/char/drm/drm_lock.c
drivers/char/drm/drm_memory.c
drivers/char/drm/drm_mm.c
drivers/char/drm/drm_os_linux.h
drivers/char/drm/drm_pci.c
drivers/char/drm/drm_proc.c
drivers/char/drm/drm_sarea.h
drivers/char/drm/drm_scatter.c
drivers/char/drm/drm_sman.c
drivers/char/drm/drm_sman.h
drivers/char/drm/drm_stub.c
drivers/char/drm/drm_sysfs.c
drivers/char/drm/drm_vm.c
drivers/char/drm/i810_dma.c
drivers/char/drm/i810_drm.h
drivers/char/drm/i810_drv.h
drivers/char/drm/i830_dma.c
drivers/char/drm/i830_drm.h
drivers/char/drm/i830_drv.h
drivers/char/drm/i830_irq.c
drivers/char/drm/i915_dma.c
drivers/char/drm/i915_drm.h
drivers/char/drm/i915_drv.h
drivers/char/drm/i915_irq.c
drivers/char/drm/i915_mem.c
drivers/char/drm/mga_dma.c
drivers/char/drm/mga_drm.h
drivers/char/drm/mga_drv.c
drivers/char/drm/mga_drv.h
drivers/char/drm/mga_irq.c
drivers/char/drm/mga_state.c
drivers/char/drm/r128_cce.c
drivers/char/drm/r128_drm.h
drivers/char/drm/r128_drv.h
drivers/char/drm/r128_irq.c
drivers/char/drm/r128_state.c
drivers/char/drm/r300_cmdbuf.c
drivers/char/drm/r300_reg.h
drivers/char/drm/radeon_cp.c
drivers/char/drm/radeon_drm.h
drivers/char/drm/radeon_drv.c
drivers/char/drm/radeon_drv.h
drivers/char/drm/radeon_irq.c
drivers/char/drm/radeon_state.c
drivers/char/drm/savage_bci.c
drivers/char/drm/savage_drm.h
drivers/char/drm/savage_drv.h
drivers/char/drm/savage_state.c
drivers/char/drm/sis_drv.c
drivers/char/drm/sis_drv.h
drivers/char/drm/sis_mm.c
drivers/char/drm/via_dma.c
drivers/char/drm/via_dmablit.c
drivers/char/drm/via_dmablit.h
drivers/char/drm/via_drm.h
drivers/char/drm/via_drv.h
drivers/char/drm/via_irq.c
drivers/char/drm/via_map.c
drivers/char/drm/via_mm.c
drivers/char/drm/via_verifier.c
drivers/char/drm/via_verifier.h

index 5b91bc04ea4e806d0bbc30e8b2845d6cdc4e2020..3345641ff904771a640e43cd4aec80674482cb0f 100644 (file)
@@ -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;
index 089198491f16757906bf3bb9235c798341034fdf..2d6f2d0bd02b8b963e19c9594aa96d1990a5a69f 100644 (file)
@@ -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
index d494315752a2c1671d8b0074b4f45e4edfc14015..1277693e9ca4168f0348faf4e6626e94c74bc9a8 100644 (file)
@@ -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__ */
index 40bfd9b01e3973e5e2865d2aef3eb280a99ff494..354f0e3674bfff3c5b586c7b5599bcf965c6922c 100644 (file)
@@ -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;
 
index c7b19d35bcd6fc059c4c41d6925221f0bc78eb0a..7f777da872cd61832db65e102e3557cc4b497c77 100644 (file)
  * 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))) {
index c11345856ffe1dd5db26763b45c9881e8ea259b5..923174c54a1cd3150d30cd06f298d130beb20e57 100644 (file)
 #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) {
index 83094c73da67abff05ab809bb76f0b0dd39c7e3f..7fc055adec251c92e42f0acdb855b65999b76a5c 100644 (file)
@@ -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);
index 32ed19c9ec1c0b1bb36c4e0f51811ca3814377e7..802fbdbfe1b342b3456800c05a8fcc1286891915 100644 (file)
@@ -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)
index b33313be25477dc3689d9253c1792e4b46164dd9..309e585a5442ee4dfb87e51eac7c4767bcb52dd2 100644 (file)
@@ -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;
 
index 8e77b7ed0f44bf2fcd860c08d7862bd821660ed0..d5cf5cfccf78952c5222e92f319a103a792042ab 100644 (file)
@@ -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);
index 3b159cab3bc807c8395f2c58d13b77a79cd225f8..7bc51bac450d70210fee213275536148ebc8654b 100644 (file)
@@ -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)
index 31acb621dcce1e4fd813b0422b8afefb339d53fe..3ad319070704ca7921b5016e35f17384ce5e19d3 100644 (file)
@@ -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)
index 613091c970af932775630b06a593ef4bfd6cab45..0f1376774168bdd8796d04780e719cfa88101a42 100644 (file)
 
 #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
index fafeb34f89d5beba40afe752c6e2c92d85cf78df..462f46f2049a4e7f15437fec760af2b885be5762 100644 (file)
@@ -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)))
index 565895547d75b2c254db4eafaab91c344d14780e..b195e102e73797b2c6a316bdbe583091ced3dabe 100644 (file)
 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)))
index 2e75331fd83e7c36bf297e06c3351fcb5d294598..871d2fde09b33ee3d1c8b48b5b6f5d74af0cdffa 100644 (file)
 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);
index befd1af19dfe0962ff7915c7cd0e1573bf7270e6..c0534b5a8b7885d59ffe738f210cc719c4c004cd 100644 (file)
@@ -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;
index 92a867082376cead936dbb818eaaba212e0f18e5..93019901bd307c21c30e992f3d7a1f14bde31636 100644 (file)
@@ -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;
 }
index 2ec1d9f2626430f7a2d84fd87b90dab73e1b0282..3e6bc14f744139c758df485a30d30568e4370142 100644 (file)
 #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) {
index 0fe7b449792797949cb7ca579a6cb39dffa19049..0b8d3433386dec992ec031aeb88058f51c4a1e78 100644 (file)
@@ -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 )          \
index 86a0f1c2209111075eb096d971271e08082f9e76..e292bb0eaca2a3c4a303b76939ed94d38dd54be3 100644 (file)
@@ -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);
index b204498d1a2887ae58579538c89c89757d4fb539..12dfea89c7f37bdba45cda2d6a35cac2869a7016 100644 (file)
@@ -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);
index e94297b751b8b9d807f886dee3a27cbca403cb16..f5466966081e9446eda11a1f0b51d2990ab7cf2d 100644 (file)
 #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_ */
index 06ef7ddbe67d7f091e7706cdb70bb21389750e5a..067d25daaf176d19e29904e33d50ba7e5b202700 100644 (file)
@@ -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;
 
index e15db6d6bea9bb2f95d7d26f01f884ae1f629107..8421a93946d864ed3e44af7d3e168f8f7a06522b 100644 (file)
 
 #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);
index ddc732a1bf2730efd5d27c31613576ca1a6945b9..39a39fefeef14784f6f4a5bbe292a692e2ae427b 100644 (file)
@@ -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
index 19408adcc7755c396f83839986013773eb0a48c9..9138b49e676e94013f93d5cafa11e074798d7168 100644 (file)
@@ -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;
 
index cc8e2ebe128c55056b6a29ec66a060cbe7372168..cf4349b00b07474f21fb6168a6bed2fa1a10a8a3 100644 (file)
@@ -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;
index b5c5b9fa84c3cd55bf7e0c8343fe6e6dc15771c3..68e36e51ba0c8cdafa9344bff9063ec018f95963 100644 (file)
@@ -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);
index 603d17fd2d6912e556250a758b7e3336b96bb3b4..cb449999d0efe7438d23b24529ca6df8b7be2c2d 100644 (file)
 #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;
 }
index 2deb925a94f354229c376659df2eb40cf824b0f5..614977dbce455d19a02ae6a586349a87ca38afcc 100644 (file)
@@ -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
index e6df49f4928a89b8e7e3187a7e523836c8206421..648833844c7fde92c92875e2938c3366d3d45b13 100644 (file)
@@ -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;
index 3314a9fea9e52471304996f251ab9093b8f2d4c9..dc20c1a7834eac3ae54d8aad4865e74fbfb59e15 100644 (file)
 #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,
                        &