drm: Rework vblank-wait handling to allow interrupt reduction.

Previously, drivers supporting vblank interrupt waits would run the interrupt
all the time, or all the time that any 3d client was running, preventing the
CPU from sleeping for long when the system was otherwise idle.  Now, interrupts
are disabled any time that no client is waiting on a vblank event. The new
method uses vblank counters on the chipsets when the interrupts are turned
off, rather than counting interrupts, so that we can continue to present
accurate vblank numbers.

Co-author: Michel Dänzer <michel@tungstengraphics.com>
Signed-off-by: Jesse Barnes <jbarnes@virtuousgeek.org>
Signed-off-by: Eric Anholt <eric@anholt.net>
Signed-off-by: Dave Airlie <airlied@redhat.com>

3 files changed, 83 insertions, 61 deletions

diff --git a/drivers/gpu/drm/via/via_drv.c b/drivers/gpu/drm/via/via_drv.c
index 80c01cdfa37d..0993b441fc42 100644
--- a/drivers/gpu/drm/via/via_drv.c
+++ b/drivers/gpu/drm/via/via_drv.c
@@ -40,11 +40,13 @@ static struct pci_device_id pciidlist[] = {
 static struct drm_driver driver = {
         .driver_features =
             DRIVER_USE_AGP | DRIVER_USE_MTRR | DRIVER_HAVE_IRQ |
-            DRIVER_IRQ_SHARED | DRIVER_IRQ_VBL,
+            DRIVER_IRQ_SHARED,
         .load = via_driver_load,
         .unload = via_driver_unload,
         .context_dtor = via_final_context,
-        .vblank_wait = via_driver_vblank_wait,
+        .get_vblank_counter = via_get_vblank_counter,
+        .enable_vblank = via_enable_vblank,
+        .disable_vblank = via_disable_vblank,
         .irq_preinstall = via_driver_irq_preinstall,
         .irq_postinstall = via_driver_irq_postinstall,
         .irq_uninstall = via_driver_irq_uninstall,
@@ -59,17 +61,17 @@ static struct drm_driver driver = {
         .get_reg_ofs = drm_core_get_reg_ofs,
         .ioctls = via_ioctls,
         .fops = {
-                 .owner = THIS_MODULE,
-                 .open = drm_open,
-                 .release = drm_release,
-                 .ioctl = drm_ioctl,
-                 .mmap = drm_mmap,
-                 .poll = drm_poll,
-                 .fasync = drm_fasync,
-        },
+                .owner = THIS_MODULE,
+                .open = drm_open,
+                .release = drm_release,
+                .ioctl = drm_ioctl,
+                .mmap = drm_mmap,
+                .poll = drm_poll,
+                .fasync = drm_fasync,
+                },
         .pci_driver = {
-                 .name = DRIVER_NAME,
-                 .id_table = pciidlist,
+                .name = DRIVER_NAME,
+                .id_table = pciidlist,
         },
 
         .name = DRIVER_NAME,
diff --git a/drivers/gpu/drm/via/via_drv.h b/drivers/gpu/drm/via/via_drv.h
index 2daae81874cd..cafcb844a223 100644
--- a/drivers/gpu/drm/via/via_drv.h
+++ b/drivers/gpu/drm/via/via_drv.h
@@ -75,6 +75,7 @@ typedef struct drm_via_private {
         struct timeval last_vblank;
         int last_vblank_valid;
         unsigned usec_per_vblank;
+        atomic_t vbl_received;
         drm_via_state_t hc_state;
         char pci_buf[VIA_PCI_BUF_SIZE];
         const uint32_t *fire_offsets[VIA_FIRE_BUF_SIZE];
@@ -130,21 +131,24 @@ extern int via_init_context(struct drm_device * dev, int context);
 extern int via_final_context(struct drm_device * dev, int context);
 
 extern int via_do_cleanup_map(struct drm_device * dev);
-extern int via_driver_vblank_wait(struct drm_device * dev, unsigned int *sequence);
+extern u32 via_get_vblank_counter(struct drm_device *dev, int crtc);
+extern int via_enable_vblank(struct drm_device *dev, int crtc);
+extern void via_disable_vblank(struct drm_device *dev, int crtc);
 
 extern irqreturn_t via_driver_irq_handler(DRM_IRQ_ARGS);
 extern void via_driver_irq_preinstall(struct drm_device * dev);
-extern void via_driver_irq_postinstall(struct drm_device * dev);
+extern int via_driver_irq_postinstall(struct drm_device *dev);
 extern void via_driver_irq_uninstall(struct drm_device * dev);
 
 extern int via_dma_cleanup(struct drm_device * dev);
 extern void via_init_command_verifier(void);
 extern int via_driver_dma_quiescent(struct drm_device * dev);
-extern void via_init_futex(drm_via_private_t * dev_priv);
-extern void via_cleanup_futex(drm_via_private_t * dev_priv);
-extern void via_release_futex(drm_via_private_t * dev_priv, int context);
+extern void via_init_futex(drm_via_private_t *dev_priv);
+extern void via_cleanup_futex(drm_via_private_t *dev_priv);
+extern void via_release_futex(drm_via_private_t *dev_priv, int context);
 
-extern void via_reclaim_buffers_locked(struct drm_device *dev, struct drm_file *file_priv);
+extern void via_reclaim_buffers_locked(struct drm_device *dev,
+                                       struct drm_file *file_priv);
 extern void via_lastclose(struct drm_device *dev);
 
 extern void via_dmablit_handler(struct drm_device *dev, int engine, int from_irq);
diff --git a/drivers/gpu/drm/via/via_irq.c b/drivers/gpu/drm/via/via_irq.c
index c6bb978a1106..1b966fbdb49f 100644
--- a/drivers/gpu/drm/via/via_irq.c
+++ b/drivers/gpu/drm/via/via_irq.c
@@ -43,7 +43,7 @@
 #define VIA_REG_INTERRUPT       0x200
 
 /* VIA_REG_INTERRUPT */
-#define VIA_IRQ_GLOBAL          (1 << 31)
+#define VIA_IRQ_GLOBAL    (1 << 31)
 #define VIA_IRQ_VBLANK_ENABLE   (1 << 19)
 #define VIA_IRQ_VBLANK_PENDING  (1 << 3)
 #define VIA_IRQ_HQV0_ENABLE     (1 << 11)
@@ -68,16 +68,15 @@
 
 static maskarray_t via_pro_group_a_irqs[] = {
         {VIA_IRQ_HQV0_ENABLE, VIA_IRQ_HQV0_PENDING, 0x000003D0, 0x00008010,
-         0x00000000},
+         0x00000000 },
         {VIA_IRQ_HQV1_ENABLE, VIA_IRQ_HQV1_PENDING, 0x000013D0, 0x00008010,
-         0x00000000},
+         0x00000000 },
         {VIA_IRQ_DMA0_TD_ENABLE, VIA_IRQ_DMA0_TD_PENDING, VIA_PCI_DMA_CSR0,
          VIA_DMA_CSR_TA | VIA_DMA_CSR_TD, 0x00000008},
         {VIA_IRQ_DMA1_TD_ENABLE, VIA_IRQ_DMA1_TD_PENDING, VIA_PCI_DMA_CSR1,
          VIA_DMA_CSR_TA | VIA_DMA_CSR_TD, 0x00000008},
 };
-static int via_num_pro_group_a =
-    sizeof(via_pro_group_a_irqs) / sizeof(maskarray_t);
+static int via_num_pro_group_a = ARRAY_SIZE(via_pro_group_a_irqs);
 static int via_irqmap_pro_group_a[] = {0, 1, -1, 2, -1, 3};
 
 static maskarray_t via_unichrome_irqs[] = {
@@ -86,14 +85,24 @@ static maskarray_t via_unichrome_irqs[] = {
         {VIA_IRQ_DMA1_TD_ENABLE, VIA_IRQ_DMA1_TD_PENDING, VIA_PCI_DMA_CSR1,
          VIA_DMA_CSR_TA | VIA_DMA_CSR_TD, 0x00000008}
 };
-static int via_num_unichrome = sizeof(via_unichrome_irqs) / sizeof(maskarray_t);
+static int via_num_unichrome = ARRAY_SIZE(via_unichrome_irqs);
 static int via_irqmap_unichrome[] = {-1, -1, -1, 0, -1, 1};
 
+
 static unsigned time_diff(struct timeval *now, struct timeval *then)
 {
         return (now->tv_usec >= then->tv_usec) ?
-            now->tv_usec - then->tv_usec :
-            1000000 - (then->tv_usec - now->tv_usec);
+                now->tv_usec - then->tv_usec :
+                1000000 - (then->tv_usec - now->tv_usec);
+}
+
+u32 via_get_vblank_counter(struct drm_device *dev, int crtc)
+{
+        drm_via_private_t *dev_priv = dev->dev_private;
+        if (crtc != 0)
+                return 0;
+
+        return atomic_read(&dev_priv->vbl_received);
 }
 
 irqreturn_t via_driver_irq_handler(DRM_IRQ_ARGS)
@@ -108,23 +117,22 @@ irqreturn_t via_driver_irq_handler(DRM_IRQ_ARGS)
 
         status = VIA_READ(VIA_REG_INTERRUPT);
         if (status & VIA_IRQ_VBLANK_PENDING) {
-                atomic_inc(&dev->vbl_received);
-                if (!(atomic_read(&dev->vbl_received) & 0x0F)) {
+                atomic_inc(&dev_priv->vbl_received);
+                if (!(atomic_read(&dev_priv->vbl_received) & 0x0F)) {
                         do_gettimeofday(&cur_vblank);
                         if (dev_priv->last_vblank_valid) {
                                 dev_priv->usec_per_vblank =
-                                    time_diff(&cur_vblank,
-                                              &dev_priv->last_vblank) >> 4;
+                                        time_diff(&cur_vblank,
+                                                  &dev_priv->last_vblank) >> 4;
                         }
                         dev_priv->last_vblank = cur_vblank;
                         dev_priv->last_vblank_valid = 1;
                 }
-                if (!(atomic_read(&dev->vbl_received) & 0xFF)) {
+                if (!(atomic_read(&dev_priv->vbl_received) & 0xFF)) {
                         DRM_DEBUG("US per vblank is: %u\n",
                                   dev_priv->usec_per_vblank);
                 }
-                DRM_WAKEUP(&dev->vbl_queue);
-                drm_vbl_send_signals(dev);
+                drm_handle_vblank(dev, 0);
                 handled = 1;
         }
 
@@ -145,6 +153,7 @@ irqreturn_t via_driver_irq_handler(DRM_IRQ_ARGS)
         /* Acknowlege interrupts */
         VIA_WRITE(VIA_REG_INTERRUPT, status);
 
+
         if (handled)
                 return IRQ_HANDLED;
         else
@@ -163,31 +172,34 @@ static __inline__ void viadrv_acknowledge_irqs(drm_via_private_t * dev_priv)
         }
 }
 
-int via_driver_vblank_wait(struct drm_device * dev, unsigned int *sequence)
+int via_enable_vblank(struct drm_device *dev, int crtc)
 {
-        drm_via_private_t *dev_priv = (drm_via_private_t *) dev->dev_private;
-        unsigned int cur_vblank;
-        int ret = 0;
+        drm_via_private_t *dev_priv = dev->dev_private;
+        u32 status;
 
-        DRM_DEBUG("\n");
-        if (!dev_priv) {
-                DRM_ERROR("called with no initialization\n");
+        if (crtc != 0) {
+                DRM_ERROR("%s:  bad crtc %d\n", __func__, crtc);
                 return -EINVAL;
         }
 
-        viadrv_acknowledge_irqs(dev_priv);
+        status = VIA_READ(VIA_REG_INTERRUPT);
+        VIA_WRITE(VIA_REG_INTERRUPT, status & VIA_IRQ_VBLANK_ENABLE);
+
+        VIA_WRITE8(0x83d4, 0x11);
+        VIA_WRITE8(0x83d5, VIA_READ8(0x83d5) | 0x30);
 
-        /* Assume that the user has missed the current sequence number
-         * by about a day rather than she wants to wait for years
-         * using vertical blanks...
-         */
+        return 0;
+}
 
-        DRM_WAIT_ON(ret, dev->vbl_queue, 3 * DRM_HZ,
-                    (((cur_vblank = atomic_read(&dev->vbl_received)) -
-                      *sequence) <= (1 << 23)));
+void via_disable_vblank(struct drm_device *dev, int crtc)
+{
+        drm_via_private_t *dev_priv = dev->dev_private;
 
-        *sequence = cur_vblank;
-        return ret;
+        VIA_WRITE8(0x83d4, 0x11);
+        VIA_WRITE8(0x83d5, VIA_READ8(0x83d5) & ~0x30);
+
+        if (crtc != 0)
+                DRM_ERROR("%s:  bad crtc %d\n", __func__, crtc);
 }
 
 static int
@@ -239,6 +251,7 @@ via_driver_irq_wait(struct drm_device * dev, unsigned int irq, int force_sequenc
         return ret;
 }
 
+
 /*
  * drm_dma.h hooks
  */
@@ -292,23 +305,25 @@ void via_driver_irq_preinstall(struct drm_device * dev)
         }
 }
 
-void via_driver_irq_postinstall(struct drm_device * dev)
+int via_driver_irq_postinstall(struct drm_device *dev)
 {
         drm_via_private_t *dev_priv = (drm_via_private_t *) dev->dev_private;
         u32 status;
 
-        DRM_DEBUG("\n");
-        if (dev_priv) {
-                status = VIA_READ(VIA_REG_INTERRUPT);
-                VIA_WRITE(VIA_REG_INTERRUPT, status | VIA_IRQ_GLOBAL
-                          | dev_priv->irq_enable_mask);
+        DRM_DEBUG("via_driver_irq_postinstall\n");
+        if (!dev_priv)
+                return -EINVAL;
 
-                /* Some magic, oh for some data sheets ! */
+        drm_vblank_init(dev, 1);
+        status = VIA_READ(VIA_REG_INTERRUPT);
+        VIA_WRITE(VIA_REG_INTERRUPT, status | VIA_IRQ_GLOBAL
+                  | dev_priv->irq_enable_mask);
 
-                VIA_WRITE8(0x83d4, 0x11);
-                VIA_WRITE8(0x83d5, VIA_READ8(0x83d5) | 0x30);
+        /* Some magic, oh for some data sheets ! */
+        VIA_WRITE8(0x83d4, 0x11);
+        VIA_WRITE8(0x83d5, VIA_READ8(0x83d5) | 0x30);
 
-        }
+        return 0;
 }
 
 void via_driver_irq_uninstall(struct drm_device * dev)
@@ -352,7 +367,8 @@ int via_wait_irq(struct drm_device *dev, void *data, struct drm_file *file_priv)
 
         switch (irqwait->request.type & ~VIA_IRQ_FLAGS_MASK) {
         case VIA_IRQ_RELATIVE:
-                irqwait->request.sequence += atomic_read(&cur_irq->irq_received);
+                irqwait->request.sequence +=
+                        atomic_read(&cur_irq->irq_received);
                 irqwait->request.type &= ~_DRM_VBLANK_RELATIVE;
         case VIA_IRQ_ABSOLUTE:
                 break;