drm: lindent the drm directory.

I've been threatening this for a while, so no point hanging around.
This lindents the DRM code which was always really bad in tabbing department.
I've also fixed some misnamed files in comments and removed some trailing
whitespace.

Signed-off-by: Dave Airlie <airlied@linux.ie>

1 files changed, 122 insertions, 137 deletions

diff --git a/drivers/char/drm/via_dma.c b/drivers/char/drm/via_dma.c
index 4f60f7f4193d..d4b1766608b0 100644
--- a/drivers/char/drm/via_dma.c
+++ b/drivers/char/drm/via_dma.c
@@ -1,11 +1,11 @@
 /* via_dma.c -- DMA support for the VIA Unichrome/Pro
- * 
+ *
  * Copyright 2003 Tungsten Graphics, Inc., Cedar Park, Texas.
  * All Rights Reserved.
  *
  * Copyright 2004 Digeo, Inc., Palo Alto, CA, U.S.A.
  * All Rights Reserved.
- * 
+ *
  * Copyright 2004 The Unichrome project.
  * All Rights Reserved.
  *
@@ -23,14 +23,14 @@
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
- * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, 
- * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR 
- * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE 
+ * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  * USE OR OTHER DEALINGS IN THE SOFTWARE.
  *
- * Authors: 
- *    Tungsten Graphics, 
- *    Erdi Chen, 
+ * Authors:
+ *    Tungsten Graphics,
+ *    Erdi Chen,
  *    Thomas Hellstrom.
  */
 
@@ -61,34 +61,31 @@
         dev_priv->dma_low +=8;                                  \
 }
 
-#define via_flush_write_combine() DRM_MEMORYBARRIER() 
+#define via_flush_write_combine() DRM_MEMORYBARRIER()
 
 #define VIA_OUT_RING_QW(w1,w2)                  \
         *vb++ = (w1);                           \
         *vb++ = (w2);                           \
-        dev_priv->dma_low += 8; 
+        dev_priv->dma_low += 8;
 
 static void via_cmdbuf_start(drm_via_private_t * dev_priv);
 static void via_cmdbuf_pause(drm_via_private_t * dev_priv);
 static void via_cmdbuf_reset(drm_via_private_t * dev_priv);
 static void via_cmdbuf_rewind(drm_via_private_t * dev_priv);
 static int via_wait_idle(drm_via_private_t * dev_priv);
-static void via_pad_cache(drm_via_private_t *dev_priv, int qwords);
-
+static void via_pad_cache(drm_via_private_t * dev_priv, int qwords);
 
 /*
  * Free space in command buffer.
  */
 
-static uint32_t
-via_cmdbuf_space(drm_via_private_t *dev_priv)
+static uint32_t via_cmdbuf_space(drm_via_private_t * dev_priv)
 {
-        uint32_t agp_base = dev_priv->dma_offset + 
-                (uint32_t) dev_priv->agpAddr;
+        uint32_t agp_base = dev_priv->dma_offset + (uint32_t) dev_priv->agpAddr;
         uint32_t hw_addr = *(dev_priv->hw_addr_ptr) - agp_base;
-        
-        return ((hw_addr <= dev_priv->dma_low) ? 
-                (dev_priv->dma_high + hw_addr - dev_priv->dma_low) : 
+
+        return ((hw_addr <= dev_priv->dma_low) ?
+                (dev_priv->dma_high + hw_addr - dev_priv->dma_low) :
                 (hw_addr - dev_priv->dma_low));
 }
 
@@ -96,15 +93,13 @@ via_cmdbuf_space(drm_via_private_t *dev_priv)
  * How much does the command regulator lag behind?
  */
 
-static uint32_t
-via_cmdbuf_lag(drm_via_private_t *dev_priv)
+static uint32_t via_cmdbuf_lag(drm_via_private_t * dev_priv)
 {
-        uint32_t agp_base = dev_priv->dma_offset + 
-                (uint32_t) dev_priv->agpAddr;
+        uint32_t agp_base = dev_priv->dma_offset + (uint32_t) dev_priv->agpAddr;
         uint32_t hw_addr = *(dev_priv->hw_addr_ptr) - agp_base;
-        
-        return ((hw_addr <= dev_priv->dma_low) ? 
-                (dev_priv->dma_low - hw_addr) : 
+
+        return ((hw_addr <= dev_priv->dma_low) ?
+                (dev_priv->dma_low - hw_addr) :
                 (dev_priv->dma_wrap + dev_priv->dma_low - hw_addr));
 }
 
@@ -121,20 +116,20 @@ via_cmdbuf_wait(drm_via_private_t * dev_priv, unsigned int size)
         uint32_t count;
         hw_addr_ptr = dev_priv->hw_addr_ptr;
         cur_addr = dev_priv->dma_low;
-        next_addr = cur_addr + size + 512*1024;
+        next_addr = cur_addr + size + 512 * 1024;
         count = 1000000;
         do {
-                hw_addr = *hw_addr_ptr - agp_base;
+                hw_addr = *hw_addr_ptr - agp_base;
                 if (count-- == 0) {
-                        DRM_ERROR("via_cmdbuf_wait timed out hw %x cur_addr %x next_addr %x\n",
-                                  hw_addr, cur_addr, next_addr);
+                        DRM_ERROR
+                            ("via_cmdbuf_wait timed out hw %x cur_addr %x next_addr %x\n",
+                             hw_addr, cur_addr, next_addr);
                         return -1;
                 }
         } while ((cur_addr < hw_addr) && (next_addr >= hw_addr));
         return 0;
 }
 
-
 /*
  * Checks whether buffer head has reach the end. Rewind the ring buffer
  * when necessary.
@@ -145,7 +140,8 @@ via_cmdbuf_wait(drm_via_private_t * dev_priv, unsigned int size)
 static inline uint32_t *via_check_dma(drm_via_private_t * dev_priv,
                                       unsigned int size)
 {
-        if ((dev_priv->dma_low + size + 4*CMDBUF_ALIGNMENT_SIZE) > dev_priv->dma_high) {
+        if ((dev_priv->dma_low + size + 4 * CMDBUF_ALIGNMENT_SIZE) >
+            dev_priv->dma_high) {
                 via_cmdbuf_rewind(dev_priv);
         }
         if (via_cmdbuf_wait(dev_priv, size) != 0) {
@@ -159,7 +155,7 @@ int via_dma_cleanup(drm_device_t * dev)
 {
         if (dev->dev_private) {
                 drm_via_private_t *dev_priv =
-                        (drm_via_private_t *) dev->dev_private;
+                    (drm_via_private_t *) dev->dev_private;
 
                 if (dev_priv->ring.virtual_start) {
                         via_cmdbuf_reset(dev_priv);
@@ -189,7 +185,7 @@ static int via_initialize(drm_device_t * dev,
         }
 
         if (!dev->agp || !dev->agp->base) {
-                DRM_ERROR("%s called with no agp memory available\n", 
+                DRM_ERROR("%s called with no agp memory available\n",
                           __FUNCTION__);
                 return DRM_ERR(EFAULT);
         }
@@ -247,10 +243,10 @@ int via_dma_init(DRM_IOCTL_ARGS)
                 else
                         retcode = via_dma_cleanup(dev);
                 break;
-        case VIA_DMA_INITIALIZED:
-                retcode = (dev_priv->ring.virtual_start != NULL) ? 
-                        0: DRM_ERR( EFAULT );
-                break;
+        case VIA_DMA_INITIALIZED:
+                retcode = (dev_priv->ring.virtual_start != NULL) ?
+                    0 : DRM_ERR(EFAULT);
+                break;
         default:
                 retcode = DRM_ERR(EINVAL);
                 break;
@@ -259,8 +255,6 @@ int via_dma_init(DRM_IOCTL_ARGS)
         return retcode;
 }
 
-
-
 static int via_dispatch_cmdbuffer(drm_device_t * dev, drm_via_cmdbuffer_t * cmd)
 {
         drm_via_private_t *dev_priv;
@@ -277,8 +271,7 @@ static int via_dispatch_cmdbuffer(drm_device_t * dev, drm_via_cmdbuffer_t * cmd)
 
         if (cmd->size > VIA_PCI_BUF_SIZE) {
                 return DRM_ERR(ENOMEM);
-        } 
-
+        }
 
         if (DRM_COPY_FROM_USER(dev_priv->pci_buf, cmd->buf, cmd->size))
                 return DRM_ERR(EFAULT);
@@ -289,19 +282,19 @@ static int via_dispatch_cmdbuffer(drm_device_t * dev, drm_via_cmdbuffer_t * cmd)
          * copy it to AGP memory when ready.
          */
 
-                
-        if ((ret = via_verify_command_stream((uint32_t *)dev_priv->pci_buf, cmd->size, dev, 1))) {
+        if ((ret =
+             via_verify_command_stream((uint32_t *) dev_priv->pci_buf,
+                                       cmd->size, dev, 1))) {
                 return ret;
         }
-        
-        
+
         vb = via_check_dma(dev_priv, (cmd->size < 0x100) ? 0x102 : cmd->size);
         if (vb == NULL) {
                 return DRM_ERR(EAGAIN);
         }
 
         memcpy(vb, dev_priv->pci_buf, cmd->size);
-        
+
         dev_priv->dma_low += cmd->size;
 
         /*
@@ -310,7 +303,7 @@ static int via_dispatch_cmdbuffer(drm_device_t * dev, drm_via_cmdbuffer_t * cmd)
          */
 
         if (cmd->size < 0x100)
-          via_pad_cache(dev_priv,(0x100 - cmd->size) >> 3);
+                via_pad_cache(dev_priv, (0x100 - cmd->size) >> 3);
         via_cmdbuf_pause(dev_priv);
 
         return 0;
@@ -330,7 +323,7 @@ int via_flush_ioctl(DRM_IOCTL_ARGS)
 {
         DRM_DEVICE;
 
-        LOCK_TEST_WITH_RETURN( dev, filp );
+        LOCK_TEST_WITH_RETURN(dev, filp);
 
         return via_driver_dma_quiescent(dev);
 }
@@ -341,7 +334,7 @@ int via_cmdbuffer(DRM_IOCTL_ARGS)
         drm_via_cmdbuffer_t cmdbuf;
         int ret;
 
-        LOCK_TEST_WITH_RETURN( dev, filp );
+        LOCK_TEST_WITH_RETURN(dev, filp);
 
         DRM_COPY_FROM_USER_IOCTL(cmdbuf, (drm_via_cmdbuffer_t __user *) data,
                                  sizeof(cmdbuf));
@@ -356,8 +349,9 @@ int via_cmdbuffer(DRM_IOCTL_ARGS)
         return 0;
 }
 
-extern int 
-via_parse_command_stream(drm_device_t *dev, const uint32_t * buf, unsigned int size);
+extern int
+via_parse_command_stream(drm_device_t * dev, const uint32_t * buf,
+                         unsigned int size);
 static int via_dispatch_pci_cmdbuffer(drm_device_t * dev,
                                       drm_via_cmdbuffer_t * cmd)
 {
@@ -366,15 +360,19 @@ static int via_dispatch_pci_cmdbuffer(drm_device_t * dev,
 
         if (cmd->size > VIA_PCI_BUF_SIZE) {
                 return DRM_ERR(ENOMEM);
-        } 
+        }
         if (DRM_COPY_FROM_USER(dev_priv->pci_buf, cmd->buf, cmd->size))
                 return DRM_ERR(EFAULT);
-        
-        if ((ret = via_verify_command_stream((uint32_t *)dev_priv->pci_buf, cmd->size, dev, 0))) {
+
+        if ((ret =
+             via_verify_command_stream((uint32_t *) dev_priv->pci_buf,
+                                       cmd->size, dev, 0))) {
                 return ret;
         }
-        
-        ret = via_parse_command_stream(dev, (const uint32_t *)dev_priv->pci_buf, cmd->size);
+
+        ret =
+            via_parse_command_stream(dev, (const uint32_t *)dev_priv->pci_buf,
+                                     cmd->size);
         return ret;
 }
 
@@ -384,7 +382,7 @@ int via_pci_cmdbuffer(DRM_IOCTL_ARGS)
         drm_via_cmdbuffer_t cmdbuf;
         int ret;
 
-        LOCK_TEST_WITH_RETURN( dev, filp );
+        LOCK_TEST_WITH_RETURN(dev, filp);
 
         DRM_COPY_FROM_USER_IOCTL(cmdbuf, (drm_via_cmdbuffer_t __user *) data,
                                  sizeof(cmdbuf));
@@ -400,17 +398,15 @@ int via_pci_cmdbuffer(DRM_IOCTL_ARGS)
         return 0;
 }
 
-
 static inline uint32_t *via_align_buffer(drm_via_private_t * dev_priv,
                                          uint32_t * vb, int qw_count)
 {
-        for (; qw_count > 0; --qw_count) {
+        for (; qw_count > 0; --qw_count) {
                 VIA_OUT_RING_QW(HC_DUMMY, HC_DUMMY);
         }
         return vb;
 }
 
-
 /*
  * This function is used internally by ring buffer mangement code.
  *
@@ -426,7 +422,7 @@ static inline uint32_t *via_get_dma(drm_via_private_t * dev_priv)
  * modifying the pause address stored in the buffer itself. If
  * the regulator has already paused, restart it.
  */
-static int via_hook_segment(drm_via_private_t *dev_priv,
+static int via_hook_segment(drm_via_private_t * dev_priv,
                             uint32_t pause_addr_hi, uint32_t pause_addr_lo,
                             int no_pci_fire)
 {
@@ -434,7 +430,7 @@ static int via_hook_segment(drm_via_private_t *dev_priv,
         volatile uint32_t *paused_at = dev_priv->last_pause_ptr;
 
         via_flush_write_combine();
-        while(! *(via_get_dma(dev_priv)-1));
+        while (!*(via_get_dma(dev_priv) - 1)) ;
         *dev_priv->last_pause_ptr = pause_addr_lo;
         via_flush_write_combine();
 
@@ -443,55 +439,53 @@ static int via_hook_segment(drm_via_private_t *dev_priv,
          * Not sure it is needed.
          */
 
-        while(! *dev_priv->last_pause_ptr);
+        while (!*dev_priv->last_pause_ptr) ;
         dev_priv->last_pause_ptr = via_get_dma(dev_priv) - 1;
-        while(! *dev_priv->last_pause_ptr);
-
+        while (!*dev_priv->last_pause_ptr) ;
 
         paused = 0;
-        count = 20; 
+        count = 20;
 
-        while (!(paused = (VIA_READ(0x41c) & 0x80000000)) && count--);
+        while (!(paused = (VIA_READ(0x41c) & 0x80000000)) && count--) ;
         if ((count <= 8) && (count >= 0)) {
                 uint32_t rgtr, ptr;
                 rgtr = *(dev_priv->hw_addr_ptr);
-                ptr = ((char *)dev_priv->last_pause_ptr - dev_priv->dma_ptr) + 
-                        dev_priv->dma_offset + (uint32_t) dev_priv->agpAddr + 4 - 
-                        CMDBUF_ALIGNMENT_SIZE;
+                ptr = ((char *)dev_priv->last_pause_ptr - dev_priv->dma_ptr) +
+                    dev_priv->dma_offset + (uint32_t) dev_priv->agpAddr + 4 -
+                    CMDBUF_ALIGNMENT_SIZE;
                 if (rgtr <= ptr) {
-                        DRM_ERROR("Command regulator\npaused at count %d, address %x, "
-                                  "while current pause address is %x.\n"
-                                  "Please mail this message to "
-                                  "<unichrome-devel@lists.sourceforge.net>\n",
-                                  count, rgtr, ptr);
+                        DRM_ERROR
+                            ("Command regulator\npaused at count %d, address %x, "
+                             "while current pause address is %x.\n"
+                             "Please mail this message to "
+                             "<unichrome-devel@lists.sourceforge.net>\n", count,
+                             rgtr, ptr);
                 }
         }
-                
+
         if (paused && !no_pci_fire) {
-                uint32_t rgtr,ptr;
+                uint32_t rgtr, ptr;
                 uint32_t ptr_low;
 
                 count = 1000000;
-                while ((VIA_READ(VIA_REG_STATUS) & VIA_CMD_RGTR_BUSY) && count--);
-                
+                while ((VIA_READ(VIA_REG_STATUS) & VIA_CMD_RGTR_BUSY)
+                       && count--) ;
+
                 rgtr = *(dev_priv->hw_addr_ptr);
-                ptr = ((char *)paused_at - dev_priv->dma_ptr) + 
-                        dev_priv->dma_offset + (uint32_t) dev_priv->agpAddr + 4;
-                
+                ptr = ((char *)paused_at - dev_priv->dma_ptr) +
+                    dev_priv->dma_offset + (uint32_t) dev_priv->agpAddr + 4;
 
-                ptr_low = (ptr > 3*CMDBUF_ALIGNMENT_SIZE) ? 
-                        ptr - 3*CMDBUF_ALIGNMENT_SIZE : 0;
+                ptr_low = (ptr > 3 * CMDBUF_ALIGNMENT_SIZE) ?
+                    ptr - 3 * CMDBUF_ALIGNMENT_SIZE : 0;
                 if (rgtr <= ptr && rgtr >= ptr_low) {
                         VIA_WRITE(VIA_REG_TRANSET, (HC_ParaType_PreCR << 16));
                         VIA_WRITE(VIA_REG_TRANSPACE, pause_addr_hi);
                         VIA_WRITE(VIA_REG_TRANSPACE, pause_addr_lo);
-                } 
+                }
         }
         return paused;
 }
 
-
-
 static int via_wait_idle(drm_via_private_t * dev_priv)
 {
         int count = 10000000;
@@ -502,9 +496,8 @@ static int via_wait_idle(drm_via_private_t * dev_priv)
 }
 
 static uint32_t *via_align_cmd(drm_via_private_t * dev_priv, uint32_t cmd_type,
-                               uint32_t addr, uint32_t *cmd_addr_hi, 
-                               uint32_t *cmd_addr_lo,
-                               int skip_wait)
+                               uint32_t addr, uint32_t * cmd_addr_hi,
+                               uint32_t * cmd_addr_lo, int skip_wait)
 {
         uint32_t agp_base;
         uint32_t cmd_addr, addr_lo, addr_hi;
@@ -512,31 +505,26 @@ static uint32_t *via_align_cmd(drm_via_private_t * dev_priv, uint32_t cmd_type,
         uint32_t qw_pad_count;
 
         if (!skip_wait)
-                via_cmdbuf_wait(dev_priv, 2*CMDBUF_ALIGNMENT_SIZE);
+                via_cmdbuf_wait(dev_priv, 2 * CMDBUF_ALIGNMENT_SIZE);
 
         vb = via_get_dma(dev_priv);
-        VIA_OUT_RING_QW( HC_HEADER2 | ((VIA_REG_TRANSET >> 2) << 12) |
-                         (VIA_REG_TRANSPACE >> 2), HC_ParaType_PreCR << 16); 
+        VIA_OUT_RING_QW(HC_HEADER2 | ((VIA_REG_TRANSET >> 2) << 12) |
+                        (VIA_REG_TRANSPACE >> 2), HC_ParaType_PreCR << 16);
         agp_base = dev_priv->dma_offset + (uint32_t) dev_priv->agpAddr;
         qw_pad_count = (CMDBUF_ALIGNMENT_SIZE >> 3) -
-                ((dev_priv->dma_low & CMDBUF_ALIGNMENT_MASK) >> 3);
+            ((dev_priv->dma_low & CMDBUF_ALIGNMENT_MASK) >> 3);
 
-        
-        cmd_addr = (addr) ? addr : 
-                agp_base + dev_priv->dma_low - 8 + (qw_pad_count << 3);
+        cmd_addr = (addr) ? addr :
+            agp_base + dev_priv->dma_low - 8 + (qw_pad_count << 3);
         addr_lo = ((HC_SubA_HAGPBpL << 24) | (cmd_type & HC_HAGPBpID_MASK) |
                    (cmd_addr & HC_HAGPBpL_MASK));
         addr_hi = ((HC_SubA_HAGPBpH << 24) | (cmd_addr >> 24));
 
         vb = via_align_buffer(dev_priv, vb, qw_pad_count - 1);
-        VIA_OUT_RING_QW(*cmd_addr_hi = addr_hi, 
-                        *cmd_addr_lo = addr_lo);
+        VIA_OUT_RING_QW(*cmd_addr_hi = addr_hi, *cmd_addr_lo = addr_lo);
         return vb;
 }
 
-
-
-
 static void via_cmdbuf_start(drm_via_private_t * dev_priv)
 {
         uint32_t pause_addr_lo, pause_addr_hi;
@@ -545,7 +533,6 @@ static void via_cmdbuf_start(drm_via_private_t * dev_priv)
         uint32_t command;
         uint32_t agp_base;
 
-
         dev_priv->dma_low = 0;
 
         agp_base = dev_priv->dma_offset + (uint32_t) dev_priv->agpAddr;
@@ -557,12 +544,12 @@ static void via_cmdbuf_start(drm_via_private_t * dev_priv)
         command = ((HC_SubA_HAGPCMNT << 24) | (start_addr >> 24) |
                    ((end_addr & 0xff000000) >> 16));
 
-        dev_priv->last_pause_ptr = 
-                via_align_cmd(dev_priv, HC_HAGPBpID_PAUSE, 0, 
-                              &pause_addr_hi, & pause_addr_lo, 1) - 1;
+        dev_priv->last_pause_ptr =
+            via_align_cmd(dev_priv, HC_HAGPBpID_PAUSE, 0,
+                          &pause_addr_hi, &pause_addr_lo, 1) - 1;
 
         via_flush_write_combine();
-        while(! *dev_priv->last_pause_ptr);
+        while (!*dev_priv->last_pause_ptr) ;
 
         VIA_WRITE(VIA_REG_TRANSET, (HC_ParaType_PreCR << 16));
         VIA_WRITE(VIA_REG_TRANSPACE, command);
@@ -575,14 +562,14 @@ static void via_cmdbuf_start(drm_via_private_t * dev_priv)
         VIA_WRITE(VIA_REG_TRANSPACE, command | HC_HAGPCMNT_MASK);
 }
 
-static void via_pad_cache(drm_via_private_t *dev_priv, int qwords)
+static void via_pad_cache(drm_via_private_t * dev_priv, int qwords)
 {
         uint32_t *vb;
 
         via_cmdbuf_wait(dev_priv, qwords + 2);
         vb = via_get_dma(dev_priv);
-        VIA_OUT_RING_QW( HC_HEADER2, HC_ParaType_NotTex << 16);
-        via_align_buffer(dev_priv,vb,qwords);
+        VIA_OUT_RING_QW(HC_HEADER2, HC_ParaType_NotTex << 16);
+        via_align_buffer(dev_priv, vb, qwords);
 }
 
 static inline void via_dummy_bitblt(drm_via_private_t * dev_priv)
@@ -590,10 +577,9 @@ static inline void via_dummy_bitblt(drm_via_private_t * dev_priv)
         uint32_t *vb = via_get_dma(dev_priv);
         SetReg2DAGP(0x0C, (0 | (0 << 16)));
         SetReg2DAGP(0x10, 0 | (0 << 16));
-        SetReg2DAGP(0x0, 0x1 | 0x2000 | 0xAA000000); 
+        SetReg2DAGP(0x0, 0x1 | 0x2000 | 0xAA000000);
 }
 
-
 static void via_cmdbuf_jump(drm_via_private_t * dev_priv)
 {
         uint32_t agp_base;
@@ -603,11 +589,10 @@ static void via_cmdbuf_jump(drm_via_private_t * dev_priv)
         uint32_t dma_low_save1, dma_low_save2;
 
         agp_base = dev_priv->dma_offset + (uint32_t) dev_priv->agpAddr;
-        via_align_cmd(dev_priv,  HC_HAGPBpID_JUMP, 0, &jump_addr_hi, 
+        via_align_cmd(dev_priv, HC_HAGPBpID_JUMP, 0, &jump_addr_hi,
                       &jump_addr_lo, 0);
-        
-        dev_priv->dma_wrap = dev_priv->dma_low;
 
+        dev_priv->dma_wrap = dev_priv->dma_low;
 
         /*
          * Wrap command buffer to the beginning.
@@ -619,11 +604,12 @@ static void via_cmdbuf_jump(drm_via_private_t * dev_priv)
         }
 
         via_dummy_bitblt(dev_priv);
-        via_dummy_bitblt(dev_priv); 
+        via_dummy_bitblt(dev_priv);
 
-        last_pause_ptr = via_align_cmd(dev_priv,  HC_HAGPBpID_PAUSE, 0, &pause_addr_hi, 
-                                       &pause_addr_lo, 0) -1;
-        via_align_cmd(dev_priv,  HC_HAGPBpID_PAUSE, 0, &pause_addr_hi, 
+        last_pause_ptr =
+            via_align_cmd(dev_priv, HC_HAGPBpID_PAUSE, 0, &pause_addr_hi,
+                          &pause_addr_lo, 0) - 1;
+        via_align_cmd(dev_priv, HC_HAGPBpID_PAUSE, 0, &pause_addr_hi,
                       &pause_addr_lo, 0);
 
         *last_pause_ptr = pause_addr_lo;
@@ -638,23 +624,23 @@ static void via_cmdbuf_jump(drm_via_private_t * dev_priv)
          * does not seem to get updated immediately when a jump occurs.
          */
 
-        last_pause_ptr = via_align_cmd(dev_priv,  HC_HAGPBpID_PAUSE, 0, &pause_addr_hi, 
-                                       &pause_addr_lo, 0) -1;
-        via_align_cmd(dev_priv,  HC_HAGPBpID_PAUSE, 0, &pause_addr_hi, 
+        last_pause_ptr =
+            via_align_cmd(dev_priv, HC_HAGPBpID_PAUSE, 0, &pause_addr_hi,
+                          &pause_addr_lo, 0) - 1;
+        via_align_cmd(dev_priv, HC_HAGPBpID_PAUSE, 0, &pause_addr_hi,
                       &pause_addr_lo, 0);
         *last_pause_ptr = pause_addr_lo;
 
         dma_low_save2 = dev_priv->dma_low;
-        dev_priv->dma_low = dma_low_save1;      
-        via_hook_segment( dev_priv, jump_addr_hi, jump_addr_lo, 0);
+        dev_priv->dma_low = dma_low_save1;
+        via_hook_segment(dev_priv, jump_addr_hi, jump_addr_lo, 0);
         dev_priv->dma_low = dma_low_save2;
-        via_hook_segment( dev_priv, pause_addr_hi, pause_addr_lo, 0);
+        via_hook_segment(dev_priv, pause_addr_hi, pause_addr_lo, 0);
 }
 
-
 static void via_cmdbuf_rewind(drm_via_private_t * dev_priv)
 {
-        via_cmdbuf_jump(dev_priv); 
+        via_cmdbuf_jump(dev_priv);
 }
 
 static void via_cmdbuf_flush(drm_via_private_t * dev_priv, uint32_t cmd_type)
@@ -662,10 +648,9 @@ static void via_cmdbuf_flush(drm_via_private_t * dev_priv, uint32_t cmd_type)
         uint32_t pause_addr_lo, pause_addr_hi;
 
         via_align_cmd(dev_priv, cmd_type, 0, &pause_addr_hi, &pause_addr_lo, 0);
-        via_hook_segment( dev_priv, pause_addr_hi, pause_addr_lo, 0);
+        via_hook_segment(dev_priv, pause_addr_hi, pause_addr_lo, 0);
 }
 
-
 static void via_cmdbuf_pause(drm_via_private_t * dev_priv)
 {
         via_cmdbuf_flush(dev_priv, HC_HAGPBpID_PAUSE);
@@ -681,8 +666,7 @@ static void via_cmdbuf_reset(drm_via_private_t * dev_priv)
  * User interface to the space and lag functions.
  */
 
-int 
-via_cmdbuf_size(DRM_IOCTL_ARGS)
+int via_cmdbuf_size(DRM_IOCTL_ARGS)
 {
         DRM_DEVICE;
         drm_via_cmdbuf_size_t d_siz;
@@ -691,7 +675,7 @@ via_cmdbuf_size(DRM_IOCTL_ARGS)
         drm_via_private_t *dev_priv;
 
         DRM_DEBUG("via cmdbuf_size\n");
-        LOCK_TEST_WITH_RETURN( dev, filp );
+        LOCK_TEST_WITH_RETURN(dev, filp);
 
         dev_priv = (drm_via_private_t *) dev->dev_private;
 
@@ -704,12 +688,12 @@ via_cmdbuf_size(DRM_IOCTL_ARGS)
         DRM_COPY_FROM_USER_IOCTL(d_siz, (drm_via_cmdbuf_size_t __user *) data,
                                  sizeof(d_siz));
 
-
         count = 1000000;
         tmp_size = d_siz.size;
-        switch(d_siz.func) {
+        switch (d_siz.func) {
         case VIA_CMDBUF_SPACE:
-                while (((tmp_size = via_cmdbuf_space(dev_priv)) < d_siz.size) && count--) {
+                while (((tmp_size = via_cmdbuf_space(dev_priv)) < d_siz.size)
+                       && count--) {
                         if (!d_siz.wait) {
                                 break;
                         }
@@ -720,7 +704,8 @@ via_cmdbuf_size(DRM_IOCTL_ARGS)
                 }
                 break;
         case VIA_CMDBUF_LAG:
-                while (((tmp_size = via_cmdbuf_lag(dev_priv)) > d_siz.size) && count--) {
+                while (((tmp_size = via_cmdbuf_lag(dev_priv)) > d_siz.size)
+                       && count--) {
                         if (!d_siz.wait) {
                                 break;
                         }