Pull osi into release branch

[linux-2.6] / drivers / char / drm / drm_irq.c

diff --git a/drivers/char/drm/drm_irq.c b/drivers/char/drm/drm_irq.c
index 9d00c51fe2c44790000f59551bf05947a2d829f2..871d2fde09b33ee3d1c8b48b5b6f5d74af0cdffa 100644 (file)
--- 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,13 +416,13 @@ 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);
 
        if (!dev->locked_tasklet_func ||
-           !drm_lock_take(&dev->lock.hw_lock->lock,
+           !drm_lock_take(&dev->lock,
                           DRM_KERNEL_CONTEXT)) {
                spin_unlock_irqrestore(&dev->tasklet_lock, irqflags);
                return;
@@ -435,7 +433,7 @@ static void drm_locked_tasklet_func(unsigned long data)
 
        dev->locked_tasklet_func(dev);
 
-       drm_lock_free(dev, &dev->lock.hw_lock->lock,
+       drm_lock_free(&dev->lock,
                      DRM_KERNEL_CONTEXT);
 
        dev->locked_tasklet_func = NULL;
@@ -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);