1 files changed, 28 insertions, 30 deletions

diff --git a/drivers/char/drm/drm_irq.c b/drivers/char/drm/drm_irq.c
index 2e75331fd83e..871d2fde09b3 100644
--- a/drivers/char/drm/drm_irq.c
+++ b/drivers/char/drm/drm_irq.c
@@ -53,10 +53,10 @@
 int drm_irq_by_busid(struct inode *inode, struct file *filp,
                      unsigned int cmd, unsigned long arg)
 {
-        drm_file_t *priv = filp->private_data;
-        drm_device_t *dev = priv->head->dev;
-        drm_irq_busid_t __user *argp = (void __user *)arg;
-        drm_irq_busid_t p;
+        struct drm_file *priv = filp->private_data;
+        struct drm_device *dev = priv->head->dev;
+        struct drm_irq_busid __user *argp = (void __user *)arg;
+        struct drm_irq_busid p;
 
         if (!drm_core_check_feature(dev, DRIVER_HAVE_IRQ))
                 return -EINVAL;
@@ -87,7 +87,7 @@ int drm_irq_by_busid(struct inode *inode, struct file *filp,
  * \c drm_driver_irq_preinstall() and \c drm_driver_irq_postinstall() functions
  * before and after the installation.
  */
-static int drm_irq_install(drm_device_t * dev)
+static int drm_irq_install(struct drm_device * dev)
 {
         int ret;
         unsigned long sh_flags = 0;
@@ -120,8 +120,8 @@ static int drm_irq_install(drm_device_t * dev)
 
                 spin_lock_init(&dev->vbl_lock);
 
-                INIT_LIST_HEAD(&dev->vbl_sigs.head);
-                INIT_LIST_HEAD(&dev->vbl_sigs2.head);
+                INIT_LIST_HEAD(&dev->vbl_sigs);
+                INIT_LIST_HEAD(&dev->vbl_sigs2);
 
                 dev->vbl_pending = 0;
         }
@@ -155,7 +155,7 @@ static int drm_irq_install(drm_device_t * dev)
  *
  * Calls the driver's \c drm_driver_irq_uninstall() function, and stops the irq.
  */
-int drm_irq_uninstall(drm_device_t * dev)
+int drm_irq_uninstall(struct drm_device * dev)
 {
         int irq_enabled;
 
@@ -197,13 +197,13 @@ EXPORT_SYMBOL(drm_irq_uninstall);
 int drm_control(struct inode *inode, struct file *filp,
                 unsigned int cmd, unsigned long arg)
 {
-        drm_file_t *priv = filp->private_data;
-        drm_device_t *dev = priv->head->dev;
-        drm_control_t ctl;
+        struct drm_file *priv = filp->private_data;
+        struct drm_device *dev = priv->head->dev;
+        struct drm_control ctl;
 
         /* if we haven't irq we fallback for compatibility reasons - this used to be a separate function in drm_dma.h */
 
-        if (copy_from_user(&ctl, (drm_control_t __user *) arg, sizeof(ctl)))
+        if (copy_from_user(&ctl, (struct drm_control __user *) arg, sizeof(ctl)))
                 return -EFAULT;
 
         switch (ctl.func) {
@@ -244,10 +244,10 @@ int drm_control(struct inode *inode, struct file *filp,
  */
 int drm_wait_vblank(DRM_IOCTL_ARGS)
 {
-        drm_file_t *priv = filp->private_data;
-        drm_device_t *dev = priv->head->dev;
-        drm_wait_vblank_t __user *argp = (void __user *)data;
-        drm_wait_vblank_t vblwait;
+        struct drm_file *priv = filp->private_data;
+        struct drm_device *dev = priv->head->dev;
+        union drm_wait_vblank __user *argp = (void __user *)data;
+        union drm_wait_vblank vblwait;
         struct timeval now;
         int ret = 0;
         unsigned int flags, seq;
@@ -292,9 +292,9 @@ int drm_wait_vblank(DRM_IOCTL_ARGS)
 
         if (flags & _DRM_VBLANK_SIGNAL) {
                 unsigned long irqflags;
-                drm_vbl_sig_t *vbl_sigs = (flags & _DRM_VBLANK_SECONDARY)
+                struct list_head *vbl_sigs = (flags & _DRM_VBLANK_SECONDARY)
                                       ? &dev->vbl_sigs2 : &dev->vbl_sigs;
-                drm_vbl_sig_t *vbl_sig;
+                struct drm_vbl_sig *vbl_sig;
 
                 spin_lock_irqsave(&dev->vbl_lock, irqflags);
 
@@ -302,7 +302,7 @@ int drm_wait_vblank(DRM_IOCTL_ARGS)
                  * for the same vblank sequence number; nothing to be done in
                  * that case
                  */
-                list_for_each_entry(vbl_sig, &vbl_sigs->head, head) {
+                list_for_each_entry(vbl_sig, vbl_sigs, head) {
                         if (vbl_sig->sequence == vblwait.request.sequence
                             && vbl_sig->info.si_signo == vblwait.request.signal
                             && vbl_sig->task == current) {
@@ -324,7 +324,7 @@ int drm_wait_vblank(DRM_IOCTL_ARGS)
 
                 if (!
                     (vbl_sig =
-                     drm_alloc(sizeof(drm_vbl_sig_t), DRM_MEM_DRIVER))) {
+                     drm_alloc(sizeof(struct drm_vbl_sig), DRM_MEM_DRIVER))) {
                         return -ENOMEM;
                 }
 
@@ -336,7 +336,7 @@ int drm_wait_vblank(DRM_IOCTL_ARGS)
 
                 spin_lock_irqsave(&dev->vbl_lock, irqflags);
 
-                list_add_tail((struct list_head *)vbl_sig, &vbl_sigs->head);
+                list_add_tail(&vbl_sig->head, vbl_sigs);
 
                 spin_unlock_irqrestore(&dev->vbl_lock, irqflags);
 
@@ -371,7 +371,7 @@ int drm_wait_vblank(DRM_IOCTL_ARGS)
  *
  * If a signal is not requested, then calls vblank_wait().
  */
-void drm_vbl_send_signals(drm_device_t * dev)
+void drm_vbl_send_signals(struct drm_device * dev)
 {
         unsigned long flags;
         int i;
@@ -379,20 +379,18 @@ void drm_vbl_send_signals(drm_device_t * dev)
         spin_lock_irqsave(&dev->vbl_lock, flags);
 
         for (i = 0; i < 2; i++) {
-                struct list_head *list, *tmp;
-                drm_vbl_sig_t *vbl_sig;
-                drm_vbl_sig_t *vbl_sigs = i ? &dev->vbl_sigs2 : &dev->vbl_sigs;
+                struct drm_vbl_sig *vbl_sig, *tmp;
+                struct list_head *vbl_sigs = i ? &dev->vbl_sigs2 : &dev->vbl_sigs;
                 unsigned int vbl_seq = atomic_read(i ? &dev->vbl_received2 :
                                                    &dev->vbl_received);
 
-                list_for_each_safe(list, tmp, &vbl_sigs->head) {
-                        vbl_sig = list_entry(list, drm_vbl_sig_t, head);
+                list_for_each_entry_safe(vbl_sig, tmp, vbl_sigs, head) {
                         if ((vbl_seq - vbl_sig->sequence) <= (1 << 23)) {
                                 vbl_sig->info.si_code = vbl_seq;
                                 send_sig_info(vbl_sig->info.si_signo,
                                               &vbl_sig->info, vbl_sig->task);
 
-                                list_del(list);
+                                list_del(&vbl_sig->head);
 
                                 drm_free(vbl_sig, sizeof(*vbl_sig),
                                          DRM_MEM_DRIVER);
@@ -418,7 +416,7 @@ EXPORT_SYMBOL(drm_vbl_send_signals);
  */
 static void drm_locked_tasklet_func(unsigned long data)
 {
-        drm_device_t *dev = (drm_device_t*)data;
+        struct drm_device *dev = (struct drm_device *)data;
         unsigned long irqflags;
 
         spin_lock_irqsave(&dev->tasklet_lock, irqflags);
@@ -455,7 +453,7 @@ static void drm_locked_tasklet_func(unsigned long data)
  * context, it must not make any assumptions about this. Also, the HW lock will
  * be held with the kernel context or any client context.
  */
-void drm_locked_tasklet(drm_device_t *dev, void (*func)(drm_device_t*))
+void drm_locked_tasklet(struct drm_device *dev, void (*func)(struct drm_device *))
 {
         unsigned long irqflags;
         static DECLARE_TASKLET(drm_tasklet, drm_locked_tasklet_func, 0);