Merge branch 'upstream-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/jgarzi...

[linux-2.6-omap-h63xx.git] / drivers / char / drm / via_irq.c

diff --git a/drivers/char/drm/via_irq.c b/drivers/char/drm/via_irq.c
index c33d068cde19f459b712147f0261829a59708804..9c1d52bc92d764dc3c58169dcc5b391c5bfba290 100644 (file)
--- a/drivers/char/drm/via_irq.c
+++ b/drivers/char/drm/via_irq.c
@@ -98,7 +98,7 @@ static unsigned time_diff(struct timeval *now, struct timeval *then)
 
 irqreturn_t via_driver_irq_handler(DRM_IRQ_ARGS)
 {
-       drm_device_t *dev = (drm_device_t *) arg;
+       struct drm_device *dev = (struct drm_device *) arg;
        drm_via_private_t *dev_priv = (drm_via_private_t *) dev->dev_private;
        u32 status;
        int handled = 0;
@@ -163,7 +163,7 @@ static __inline__ void viadrv_acknowledge_irqs(drm_via_private_t * dev_priv)
        }
 }
 
-int via_driver_vblank_wait(drm_device_t * dev, unsigned int *sequence)
+int via_driver_vblank_wait(struct drm_device * dev, unsigned int *sequence)
 {
        drm_via_private_t *dev_priv = (drm_via_private_t *) dev->dev_private;
        unsigned int cur_vblank;
@@ -191,7 +191,7 @@ int via_driver_vblank_wait(drm_device_t * dev, unsigned int *sequence)
 }
 
 static int
-via_driver_irq_wait(drm_device_t * dev, unsigned int irq, int force_sequence,
+via_driver_irq_wait(struct drm_device * dev, unsigned int irq, int force_sequence,
                    unsigned int *sequence)
 {
        drm_via_private_t *dev_priv = (drm_via_private_t *) dev->dev_private;
@@ -205,13 +205,13 @@ via_driver_irq_wait(drm_device_t * dev, unsigned int irq, int force_sequence,
 
        if (!dev_priv) {
                DRM_ERROR("%s called with no initialization\n", __FUNCTION__);
-               return DRM_ERR(EINVAL);
+               return -EINVAL;
        }
 
        if (irq >= drm_via_irq_num) {
                DRM_ERROR("%s Trying to wait on unknown irq %d\n", __FUNCTION__,
                          irq);
-               return DRM_ERR(EINVAL);
+               return -EINVAL;
        }
 
        real_irq = dev_priv->irq_map[irq];
@@ -219,7 +219,7 @@ via_driver_irq_wait(drm_device_t * dev, unsigned int irq, int force_sequence,
        if (real_irq < 0) {
                DRM_ERROR("%s Video IRQ %d not available on this hardware.\n",
                          __FUNCTION__, irq);
-               return DRM_ERR(EINVAL);
+               return -EINVAL;
        }
 
        masks = dev_priv->irq_masks;
@@ -244,7 +244,7 @@ via_driver_irq_wait(drm_device_t * dev, unsigned int irq, int force_sequence,
  * drm_dma.h hooks
  */
 
-void via_driver_irq_preinstall(drm_device_t * dev)
+void via_driver_irq_preinstall(struct drm_device * dev)
 {
        drm_via_private_t *dev_priv = (drm_via_private_t *) dev->dev_private;
        u32 status;
@@ -258,12 +258,16 @@ void via_driver_irq_preinstall(drm_device_t * dev)
                dev_priv->irq_enable_mask = VIA_IRQ_VBLANK_ENABLE;
                dev_priv->irq_pending_mask = VIA_IRQ_VBLANK_PENDING;
 
-               dev_priv->irq_masks = (dev_priv->pro_group_a) ?
-                   via_pro_group_a_irqs : via_unichrome_irqs;
-               dev_priv->num_irqs = (dev_priv->pro_group_a) ?
-                   via_num_pro_group_a : via_num_unichrome;
-               dev_priv->irq_map = (dev_priv->pro_group_a) ?
-                       via_irqmap_pro_group_a : via_irqmap_unichrome;
+               if (dev_priv->chipset == VIA_PRO_GROUP_A ||
+                   dev_priv->chipset == VIA_DX9_0) {
+                       dev_priv->irq_masks = via_pro_group_a_irqs;
+                       dev_priv->num_irqs = via_num_pro_group_a;
+                       dev_priv->irq_map = via_irqmap_pro_group_a;
+               } else {
+                       dev_priv->irq_masks = via_unichrome_irqs;
+                       dev_priv->num_irqs = via_num_unichrome;
+                       dev_priv->irq_map = via_irqmap_unichrome;
+               }
 
                for (i = 0; i < dev_priv->num_irqs; ++i) {
                        atomic_set(&cur_irq->irq_received, 0);
@@ -289,7 +293,7 @@ void via_driver_irq_preinstall(drm_device_t * dev)
        }
 }
 
-void via_driver_irq_postinstall(drm_device_t * dev)
+void via_driver_irq_postinstall(struct drm_device * dev)
 {
        drm_via_private_t *dev_priv = (drm_via_private_t *) dev->dev_private;
        u32 status;
@@ -308,7 +312,7 @@ void via_driver_irq_postinstall(drm_device_t * dev)
        }
 }
 
-void via_driver_irq_uninstall(drm_device_t * dev)
+void via_driver_irq_uninstall(struct drm_device * dev)
 {
        drm_via_private_t *dev_priv = (drm_via_private_t *) dev->dev_private;
        u32 status;
@@ -327,11 +331,9 @@ void via_driver_irq_uninstall(drm_device_t * dev)
        }
 }
 
-int via_wait_irq(DRM_IOCTL_ARGS)
+int via_wait_irq(struct drm_device *dev, void *data, struct drm_file *file_priv)
 {
-       DRM_DEVICE;
-       drm_via_irqwait_t __user *argp = (void __user *)data;
-       drm_via_irqwait_t irqwait;
+       drm_via_irqwait_t *irqwait = data;
        struct timeval now;
        int ret = 0;
        drm_via_private_t *dev_priv = (drm_via_private_t *) dev->dev_private;
@@ -339,42 +341,39 @@ int via_wait_irq(DRM_IOCTL_ARGS)
        int force_sequence;
 
        if (!dev->irq)
-               return DRM_ERR(EINVAL);
+               return -EINVAL;
 
-       DRM_COPY_FROM_USER_IOCTL(irqwait, argp, sizeof(irqwait));
-       if (irqwait.request.irq >= dev_priv->num_irqs) {
+       if (irqwait->request.irq >= dev_priv->num_irqs) {
                DRM_ERROR("%s Trying to wait on unknown irq %d\n", __FUNCTION__,
-                         irqwait.request.irq);
-               return DRM_ERR(EINVAL);
+                         irqwait->request.irq);
+               return -EINVAL;
        }
 
-       cur_irq += irqwait.request.irq;
+       cur_irq += irqwait->request.irq;
 
-       switch (irqwait.request.type & ~VIA_IRQ_FLAGS_MASK) {
+       switch (irqwait->request.type & ~VIA_IRQ_FLAGS_MASK) {
        case VIA_IRQ_RELATIVE:
-               irqwait.request.sequence += atomic_read(&cur_irq->irq_received);
-               irqwait.request.type &= ~_DRM_VBLANK_RELATIVE;
+               irqwait->request.sequence += atomic_read(&cur_irq->irq_received);
+               irqwait->request.type &= ~_DRM_VBLANK_RELATIVE;
        case VIA_IRQ_ABSOLUTE:
                break;
        default:
-               return DRM_ERR(EINVAL);
+               return -EINVAL;
        }
 
-       if (irqwait.request.type & VIA_IRQ_SIGNAL) {
+       if (irqwait->request.type & VIA_IRQ_SIGNAL) {
                DRM_ERROR("%s Signals on Via IRQs not implemented yet.\n",
                          __FUNCTION__);
-               return DRM_ERR(EINVAL);
+               return -EINVAL;
        }
 
-       force_sequence = (irqwait.request.type & VIA_IRQ_FORCE_SEQUENCE);
+       force_sequence = (irqwait->request.type & VIA_IRQ_FORCE_SEQUENCE);
 
-       ret = via_driver_irq_wait(dev, irqwait.request.irq, force_sequence,
-                                 &irqwait.request.sequence);
+       ret = via_driver_irq_wait(dev, irqwait->request.irq, force_sequence,
+                                 &irqwait->request.sequence);
        do_gettimeofday(&now);
-       irqwait.reply.tval_sec = now.tv_sec;
-       irqwait.reply.tval_usec = now.tv_usec;
-
-       DRM_COPY_TO_USER_IOCTL(argp, irqwait, sizeof(irqwait));
+       irqwait->reply.tval_sec = now.tv_sec;
+       irqwait->reply.tval_usec = now.tv_usec;
 
        return ret;
 }