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, 194 insertions, 175 deletions

diff --git a/drivers/char/drm/drm_vm.c b/drivers/char/drm/drm_vm.c
index a13d07f44202..e84a7876a1b3 100644
--- a/drivers/char/drm/drm_vm.c
+++ b/drivers/char/drm/drm_vm.c
@@ -1,7 +1,7 @@
 /**
- * \file drm_vm.h
+ * \file drm_vm.c
  * Memory mapping for DRM
- * 
+ *
  * \author Rickard E. (Rik) Faith <faith@valinux.com>
  * \author Gareth Hughes <gareth@valinux.com>
  */
@@ -47,32 +47,34 @@ static void drm_vm_close(struct vm_area_struct *vma);
  * \param vma virtual memory area.
  * \param address access address.
  * \return pointer to the page structure.
- * 
+ *
  * Find the right map and if it's AGP memory find the real physical page to
  * map, get the page, increment the use count and return it.
  */
 #if __OS_HAS_AGP
 static __inline__ struct page *drm_do_vm_nopage(struct vm_area_struct *vma,
-                                                 unsigned long address)
+                                                unsigned long address)
 {
-        drm_file_t *priv  = vma->vm_file->private_data;
+        drm_file_t *priv = vma->vm_file->private_data;
         drm_device_t *dev = priv->head->dev;
-        drm_map_t *map    = NULL;
-        drm_map_list_t  *r_list;
+        drm_map_t *map = NULL;
+        drm_map_list_t *r_list;
         struct list_head *list;
 
         /*
-         * Find the right map
-         */
+         * Find the right map
+         */
         if (!drm_core_has_AGP(dev))
                 goto vm_nopage_error;
 
-        if(!dev->agp || !dev->agp->cant_use_aperture) goto vm_nopage_error;
+        if (!dev->agp || !dev->agp->cant_use_aperture)
+                goto vm_nopage_error;
 
         list_for_each(list, &dev->maplist->head) {
                 r_list = list_entry(list, drm_map_list_t, head);
                 map = r_list->map;
-                if (!map) continue;
+                if (!map)
+                        continue;
                 if (r_list->user_token == VM_OFFSET(vma))
                         break;
         }
@@ -85,45 +87,47 @@ static __inline__ struct page *drm_do_vm_nopage(struct vm_area_struct *vma,
 
 #ifdef __alpha__
                 /*
-                 * Adjust to a bus-relative address
-                 */
+                 * Adjust to a bus-relative address
+                 */
                 baddr -= dev->hose->mem_space->start;
 #endif
 
                 /*
-                 * It's AGP memory - find the real physical page to map
-                 */
-                for(agpmem = dev->agp->memory; agpmem; agpmem = agpmem->next) {
+                 * It's AGP memory - find the real physical page to map
+                 */
+                for (agpmem = dev->agp->memory; agpmem; agpmem = agpmem->next) {
                         if (agpmem->bound <= baddr &&
-                            agpmem->bound + agpmem->pages * PAGE_SIZE > baddr) 
+                            agpmem->bound + agpmem->pages * PAGE_SIZE > baddr)
                                 break;
                 }
 
-                if (!agpmem) goto vm_nopage_error;
+                if (!agpmem)
+                        goto vm_nopage_error;
 
                 /*
-                 * Get the page, inc the use count, and return it
-                 */
+                 * Get the page, inc the use count, and return it
+                 */
                 offset = (baddr - agpmem->bound) >> PAGE_SHIFT;
                 page = virt_to_page(__va(agpmem->memory->memory[offset]));
                 get_page(page);
 
-                DRM_DEBUG("baddr = 0x%lx page = 0x%p, offset = 0x%lx, count=%d\n",
-                          baddr, __va(agpmem->memory->memory[offset]), offset,
-                          page_count(page));
+                DRM_DEBUG
+                    ("baddr = 0x%lx page = 0x%p, offset = 0x%lx, count=%d\n",
+                     baddr, __va(agpmem->memory->memory[offset]), offset,
+                     page_count(page));
 
                 return page;
-        }
-vm_nopage_error:
-        return NOPAGE_SIGBUS;           /* Disallow mremap */
+        }
+      vm_nopage_error:
+        return NOPAGE_SIGBUS;   /* Disallow mremap */
 }
-#else /* __OS_HAS_AGP */
+#else                           /* __OS_HAS_AGP */
 static __inline__ struct page *drm_do_vm_nopage(struct vm_area_struct *vma,
-                                                 unsigned long address)
+                                                unsigned long address)
 {
         return NOPAGE_SIGBUS;
 }
-#endif /* __OS_HAS_AGP */
+#endif                          /* __OS_HAS_AGP */
 
 /**
  * \c nopage method for shared virtual memory.
@@ -131,25 +135,27 @@ static __inline__ struct page *drm_do_vm_nopage(struct vm_area_struct *vma,
  * \param vma virtual memory area.
  * \param address access address.
  * \return pointer to the page structure.
- * 
+ *
  * Get the the mapping, find the real physical page to map, get the page, and
  * return it.
  */
 static __inline__ struct page *drm_do_vm_shm_nopage(struct vm_area_struct *vma,
-                                                     unsigned long address)
+                                                    unsigned long address)
 {
-        drm_map_t        *map    = (drm_map_t *)vma->vm_private_data;
-        unsigned long    offset;
-        unsigned long    i;
-        struct page      *page;
+        drm_map_t *map = (drm_map_t *) vma->vm_private_data;
+        unsigned long offset;
+        unsigned long i;
+        struct page *page;
 
-        if (address > vma->vm_end) return NOPAGE_SIGBUS; /* Disallow mremap */
-        if (!map)                  return NOPAGE_OOM;  /* Nothing allocated */
+        if (address > vma->vm_end)
+                return NOPAGE_SIGBUS;   /* Disallow mremap */
+        if (!map)
+                return NOPAGE_OOM;      /* Nothing allocated */
 
-        offset   = address - vma->vm_start;
+        offset = address - vma->vm_start;
         i = (unsigned long)map->handle + offset;
-        page = (map->type == _DRM_CONSISTENT) ? 
-                virt_to_page((void *)i) : vmalloc_to_page((void *)i);
+        page = (map->type == _DRM_CONSISTENT) ?
+            virt_to_page((void *)i) : vmalloc_to_page((void *)i);
         if (!page)
                 return NOPAGE_OOM;
         get_page(page);
@@ -158,19 +164,18 @@ static __inline__ struct page *drm_do_vm_shm_nopage(struct vm_area_struct *vma,
         return page;
 }
 
-
 /**
  * \c close method for shared virtual memory.
- * 
+ *
  * \param vma virtual memory area.
- * 
+ *
  * Deletes map information if we are the last
  * person to close a mapping and it's not in the global maplist.
  */
 static void drm_vm_shm_close(struct vm_area_struct *vma)
 {
-        drm_file_t      *priv   = vma->vm_file->private_data;
-        drm_device_t    *dev    = priv->head->dev;
+        drm_file_t *priv = vma->vm_file->private_data;
+        drm_device_t *dev = priv->head->dev;
         drm_vma_entry_t *pt, *prev, *next;
         drm_map_t *map;
         drm_map_list_t *r_list;
@@ -186,7 +191,8 @@ static void drm_vm_shm_close(struct vm_area_struct *vma)
         down(&dev->struct_sem);
         for (pt = dev->vmalist, prev = NULL; pt; pt = next) {
                 next = pt->next;
-                if (pt->vma->vm_private_data == map) found_maps++;
+                if (pt->vma->vm_private_data == map)
+                        found_maps++;
                 if (pt->vma == vma) {
                         if (prev) {
                                 prev->next = pt->next;
@@ -199,8 +205,7 @@ static void drm_vm_shm_close(struct vm_area_struct *vma)
                 }
         }
         /* We were the only map that was found */
-        if(found_maps == 1 &&
-           map->flags & _DRM_REMOVABLE) {
+        if (found_maps == 1 && map->flags & _DRM_REMOVABLE) {
                 /* Check to see if we are in the maplist, if we are not, then
                  * we delete this mappings information.
                  */
@@ -208,10 +213,11 @@ static void drm_vm_shm_close(struct vm_area_struct *vma)
                 list = &dev->maplist->head;
                 list_for_each(list, &dev->maplist->head) {
                         r_list = list_entry(list, drm_map_list_t, head);
-                        if (r_list->map == map) found_maps++;
+                        if (r_list->map == map)
+                                found_maps++;
                 }
 
-                if(!found_maps) {
+                if (!found_maps) {
                         drm_dma_handle_t dmah;
 
                         switch (map->type) {
@@ -251,27 +257,29 @@ static void drm_vm_shm_close(struct vm_area_struct *vma)
  * \param vma virtual memory area.
  * \param address access address.
  * \return pointer to the page structure.
- * 
+ *
  * Determine the page number from the page offset and get it from drm_device_dma::pagelist.
  */
 static __inline__ struct page *drm_do_vm_dma_nopage(struct vm_area_struct *vma,
-                                                     unsigned long address)
+                                                    unsigned long address)
 {
-        drm_file_t       *priv   = vma->vm_file->private_data;
-        drm_device_t     *dev    = priv->head->dev;
-        drm_device_dma_t *dma    = dev->dma;
-        unsigned long    offset;
-        unsigned long    page_nr;
-        struct page      *page;
-
-        if (!dma)                  return NOPAGE_SIGBUS; /* Error */
-        if (address > vma->vm_end) return NOPAGE_SIGBUS; /* Disallow mremap */
-        if (!dma->pagelist)        return NOPAGE_OOM ; /* Nothing allocated */
-
-        offset   = address - vma->vm_start; /* vm_[pg]off[set] should be 0 */
-        page_nr  = offset >> PAGE_SHIFT;
-        page = virt_to_page((dma->pagelist[page_nr] + 
-                             (offset & (~PAGE_MASK))));
+        drm_file_t *priv = vma->vm_file->private_data;
+        drm_device_t *dev = priv->head->dev;
+        drm_device_dma_t *dma = dev->dma;
+        unsigned long offset;
+        unsigned long page_nr;
+        struct page *page;
+
+        if (!dma)
+                return NOPAGE_SIGBUS;   /* Error */
+        if (address > vma->vm_end)
+                return NOPAGE_SIGBUS;   /* Disallow mremap */
+        if (!dma->pagelist)
+                return NOPAGE_OOM;      /* Nothing allocated */
+
+        offset = address - vma->vm_start;       /* vm_[pg]off[set] should be 0 */
+        page_nr = offset >> PAGE_SHIFT;
+        page = virt_to_page((dma->pagelist[page_nr] + (offset & (~PAGE_MASK))));
 
         get_page(page);
 
@@ -285,13 +293,13 @@ static __inline__ struct page *drm_do_vm_dma_nopage(struct vm_area_struct *vma,
  * \param vma virtual memory area.
  * \param address access address.
  * \return pointer to the page structure.
- * 
+ *
  * Determine the map offset from the page offset and get it from drm_sg_mem::pagelist.
  */
 static __inline__ struct page *drm_do_vm_sg_nopage(struct vm_area_struct *vma,
-                                                    unsigned long address)
+                                                   unsigned long address)
 {
-        drm_map_t        *map    = (drm_map_t *)vma->vm_private_data;
+        drm_map_t *map = (drm_map_t *) vma->vm_private_data;
         drm_file_t *priv = vma->vm_file->private_data;
         drm_device_t *dev = priv->head->dev;
         drm_sg_mem_t *entry = dev->sg;
@@ -300,10 +308,12 @@ static __inline__ struct page *drm_do_vm_sg_nopage(struct vm_area_struct *vma,
         unsigned long page_offset;
         struct page *page;
 
-        if (!entry)                return NOPAGE_SIGBUS; /* Error */
-        if (address > vma->vm_end) return NOPAGE_SIGBUS; /* Disallow mremap */
-        if (!entry->pagelist)      return NOPAGE_OOM ;  /* Nothing allocated */
-
+        if (!entry)
+                return NOPAGE_SIGBUS;   /* Error */
+        if (address > vma->vm_end)
+                return NOPAGE_SIGBUS;   /* Disallow mremap */
+        if (!entry->pagelist)
+                return NOPAGE_OOM;      /* Nothing allocated */
 
         offset = address - vma->vm_start;
         map_offset = map->offset - (unsigned long)dev->sg->virtual;
@@ -314,76 +324,78 @@ static __inline__ struct page *drm_do_vm_sg_nopage(struct vm_area_struct *vma,
         return page;
 }
 
-
 static struct page *drm_vm_nopage(struct vm_area_struct *vma,
-                                   unsigned long address,
-                                   int *type) {
-        if (type) *type = VM_FAULT_MINOR;
+                                  unsigned long address, int *type)
+{
+        if (type)
+                *type = VM_FAULT_MINOR;
         return drm_do_vm_nopage(vma, address);
 }
 
 static struct page *drm_vm_shm_nopage(struct vm_area_struct *vma,
-                                       unsigned long address,
-                                       int *type) {
-        if (type) *type = VM_FAULT_MINOR;
+                                      unsigned long address, int *type)
+{
+        if (type)
+                *type = VM_FAULT_MINOR;
         return drm_do_vm_shm_nopage(vma, address);
 }
 
 static struct page *drm_vm_dma_nopage(struct vm_area_struct *vma,
-                                       unsigned long address,
-                                       int *type) {
-        if (type) *type = VM_FAULT_MINOR;
+                                      unsigned long address, int *type)
+{
+        if (type)
+                *type = VM_FAULT_MINOR;
         return drm_do_vm_dma_nopage(vma, address);
 }
 
 static struct page *drm_vm_sg_nopage(struct vm_area_struct *vma,
-                                      unsigned long address,
-                                      int *type) {
-        if (type) *type = VM_FAULT_MINOR;
+                                     unsigned long address, int *type)
+{
+        if (type)
+                *type = VM_FAULT_MINOR;
         return drm_do_vm_sg_nopage(vma, address);
 }
 
 /** AGP virtual memory operations */
-static struct vm_operations_struct   drm_vm_ops = {
+static struct vm_operations_struct drm_vm_ops = {
         .nopage = drm_vm_nopage,
-        .open   = drm_vm_open,
-        .close  = drm_vm_close,
+        .open = drm_vm_open,
+        .close = drm_vm_close,
 };
 
 /** Shared virtual memory operations */
-static struct vm_operations_struct   drm_vm_shm_ops = {
+static struct vm_operations_struct drm_vm_shm_ops = {
         .nopage = drm_vm_shm_nopage,
-        .open   = drm_vm_open,
-        .close  = drm_vm_shm_close,
+        .open = drm_vm_open,
+        .close = drm_vm_shm_close,
 };
 
 /** DMA virtual memory operations */
-static struct vm_operations_struct   drm_vm_dma_ops = {
+static struct vm_operations_struct drm_vm_dma_ops = {
         .nopage = drm_vm_dma_nopage,
-        .open   = drm_vm_open,
-        .close  = drm_vm_close,
+        .open = drm_vm_open,
+        .close = drm_vm_close,
 };
 
 /** Scatter-gather virtual memory operations */
-static struct vm_operations_struct   drm_vm_sg_ops = {
+static struct vm_operations_struct drm_vm_sg_ops = {
         .nopage = drm_vm_sg_nopage,
-        .open   = drm_vm_open,
-        .close  = drm_vm_close,
+        .open = drm_vm_open,
+        .close = drm_vm_close,
 };
 
-
 /**
  * \c open method for shared virtual memory.
- * 
+ *
  * \param vma virtual memory area.
- * 
+ *
  * Create a new drm_vma_entry structure as the \p vma private data entry and
  * add it to drm_device::vmalist.
  */
 static void drm_vm_open(struct vm_area_struct *vma)
 {
-        drm_file_t      *priv   = vma->vm_file->private_data;
-        drm_device_t    *dev    = priv->head->dev;
+        drm_file_t *priv = vma->vm_file->private_data;
+        drm_device_t *dev = priv->head->dev;
         drm_vma_entry_t *vma_entry;
 
         DRM_DEBUG("0x%08lx,0x%08lx\n",
@@ -393,26 +405,26 @@ static void drm_vm_open(struct vm_area_struct *vma)
         vma_entry = drm_alloc(sizeof(*vma_entry), DRM_MEM_VMAS);
         if (vma_entry) {
                 down(&dev->struct_sem);
-                vma_entry->vma  = vma;
+                vma_entry->vma = vma;
                 vma_entry->next = dev->vmalist;
-                vma_entry->pid  = current->pid;
-                dev->vmalist    = vma_entry;
+                vma_entry->pid = current->pid;
+                dev->vmalist = vma_entry;
                 up(&dev->struct_sem);
         }
 }
 
 /**
  * \c close method for all virtual memory types.
- * 
+ *
  * \param vma virtual memory area.
- * 
+ *
  * Search the \p vma private data entry in drm_device::vmalist, unlink it, and
  * free it.
  */
 static void drm_vm_close(struct vm_area_struct *vma)
 {
-        drm_file_t      *priv   = vma->vm_file->private_data;
-        drm_device_t    *dev    = priv->head->dev;
+        drm_file_t *priv = vma->vm_file->private_data;
+        drm_device_t *dev = priv->head->dev;
         drm_vma_entry_t *pt, *prev;
 
         DRM_DEBUG("0x%08lx,0x%08lx\n",
@@ -440,43 +452,44 @@ static void drm_vm_close(struct vm_area_struct *vma)
  * \param filp file pointer.
  * \param vma virtual memory area.
  * \return zero on success or a negative number on failure.
- * 
+ *
  * Sets the virtual memory area operations structure to vm_dma_ops, the file
  * pointer, and calls vm_open().
  */
 static int drm_mmap_dma(struct file *filp, struct vm_area_struct *vma)
 {
-        drm_file_t       *priv   = filp->private_data;
-        drm_device_t     *dev;
+        drm_file_t *priv = filp->private_data;
+        drm_device_t *dev;
         drm_device_dma_t *dma;
-        unsigned long    length  = vma->vm_end - vma->vm_start;
+        unsigned long length = vma->vm_end - vma->vm_start;
 
         lock_kernel();
-        dev      = priv->head->dev;
-        dma      = dev->dma;
+        dev = priv->head->dev;
+        dma = dev->dma;
         DRM_DEBUG("start = 0x%lx, end = 0x%lx, offset = 0x%lx\n",
                   vma->vm_start, vma->vm_end, VM_OFFSET(vma));
 
-                                /* Length must match exact page count */
+        /* Length must match exact page count */
         if (!dma || (length >> PAGE_SHIFT) != dma->page_count) {
                 unlock_kernel();
                 return -EINVAL;
         }
         unlock_kernel();
 
-        vma->vm_ops   = &drm_vm_dma_ops;
+        vma->vm_ops = &drm_vm_dma_ops;
 
-        vma->vm_flags |= VM_RESERVED; /* Don't swap */
+        vma->vm_flags |= VM_RESERVED;   /* Don't swap */
 
-        vma->vm_file  =  filp;  /* Needed for drm_vm_open() */
+        vma->vm_file = filp;    /* Needed for drm_vm_open() */
         drm_vm_open(vma);
         return 0;
 }
 
-unsigned long drm_core_get_map_ofs(drm_map_t *map)
+unsigned long drm_core_get_map_ofs(drm_map_t * map)
 {
         return map->offset;
 }
+
 EXPORT_SYMBOL(drm_core_get_map_ofs);
 
 unsigned long drm_core_get_reg_ofs(struct drm_device *dev)
@@ -487,6 +500,7 @@ unsigned long drm_core_get_reg_ofs(struct drm_device *dev)
         return 0;
 #endif
 }
+
 EXPORT_SYMBOL(drm_core_get_reg_ofs);
 
 /**
@@ -495,7 +509,7 @@ EXPORT_SYMBOL(drm_core_get_reg_ofs);
  * \param filp file pointer.
  * \param vma virtual memory area.
  * \return zero on success or a negative number on failure.
- * 
+ *
  * If the virtual memory area has no offset associated with it then it's a DMA
  * area, so calls mmap_dma(). Otherwise searches the map in drm_device::maplist,
  * checks that the restricted flag is not set, sets the virtual memory operations
@@ -504,17 +518,18 @@ EXPORT_SYMBOL(drm_core_get_reg_ofs);
  */
 int drm_mmap(struct file *filp, struct vm_area_struct *vma)
 {
-        drm_file_t      *priv   = filp->private_data;
-        drm_device_t    *dev    = priv->head->dev;
-        drm_map_t       *map    = NULL;
-        drm_map_list_t  *r_list;
-        unsigned long   offset  = 0;
+        drm_file_t *priv = filp->private_data;
+        drm_device_t *dev = priv->head->dev;
+        drm_map_t *map = NULL;
+        drm_map_list_t *r_list;
+        unsigned long offset = 0;
         struct list_head *list;
 
         DRM_DEBUG("start = 0x%lx, end = 0x%lx, offset = 0x%lx\n",
                   vma->vm_start, vma->vm_end, VM_OFFSET(vma));
 
-        if ( !priv->authenticated ) return -EACCES;
+        if (!priv->authenticated)
+                return -EACCES;
 
         /* We check for "dma". On Apple's UniNorth, it's valid to have
          * the AGP mapped at physical address 0
@@ -522,61 +537,66 @@ int drm_mmap(struct file *filp, struct vm_area_struct *vma)
          */
         if (!VM_OFFSET(vma)
 #if __OS_HAS_AGP
-            && (!dev->agp || dev->agp->agp_info.device->vendor != PCI_VENDOR_ID_APPLE)
+            && (!dev->agp
+                || dev->agp->agp_info.device->vendor != PCI_VENDOR_ID_APPLE)
 #endif
             )
                 return drm_mmap_dma(filp, vma);
 
-                                /* A sequential search of a linked list is
-                                   fine here because: 1) there will only be
-                                   about 5-10 entries in the list and, 2) a
-                                   DRI client only has to do this mapping
-                                   once, so it doesn't have to be optimized
-                                   for performance, even if the list was a
-                                   bit longer. */
+        /* A sequential search of a linked list is
+           fine here because: 1) there will only be
+           about 5-10 entries in the list and, 2) a
+           DRI client only has to do this mapping
+           once, so it doesn't have to be optimized
+           for performance, even if the list was a
+           bit longer. */
         list_for_each(list, &dev->maplist->head) {
 
                 r_list = list_entry(list, drm_map_list_t, head);
                 map = r_list->map;
-                if (!map) continue;
+                if (!map)
+                        continue;
                 if (r_list->user_token == VM_OFFSET(vma))
                         break;
         }
 
-        if (!map || ((map->flags&_DRM_RESTRICTED) && !capable(CAP_SYS_ADMIN)))
+        if (!map || ((map->flags & _DRM_RESTRICTED) && !capable(CAP_SYS_ADMIN)))
                 return -EPERM;
 
-                                /* Check for valid size. */
-        if (map->size != vma->vm_end - vma->vm_start) return -EINVAL;
+        /* Check for valid size. */
+        if (map->size != vma->vm_end - vma->vm_start)
+                return -EINVAL;
 
         if (!capable(CAP_SYS_ADMIN) && (map->flags & _DRM_READ_ONLY)) {
                 vma->vm_flags &= ~(VM_WRITE | VM_MAYWRITE);
 #if defined(__i386__) || defined(__x86_64__)
                 pgprot_val(vma->vm_page_prot) &= ~_PAGE_RW;
 #else
-                                /* Ye gads this is ugly.  With more thought
-                                   we could move this up higher and use
-                                   `protection_map' instead.  */
-                vma->vm_page_prot = __pgprot(pte_val(pte_wrprotect(
-                        __pte(pgprot_val(vma->vm_page_prot)))));
+                /* Ye gads this is ugly.  With more thought
+                   we could move this up higher and use
+                   `protection_map' instead.  */
+                vma->vm_page_prot =
+                    __pgprot(pte_val
+                             (pte_wrprotect
+                              (__pte(pgprot_val(vma->vm_page_prot)))));
 #endif
         }
 
         switch (map->type) {
-        case _DRM_AGP:
-          if (drm_core_has_AGP(dev) && dev->agp->cant_use_aperture) {
-                /*
-                 * On some platforms we can't talk to bus dma address from the CPU, so for
-                 * memory of type DRM_AGP, we'll deal with sorting out the real physical
-                 * pages and mappings in nopage()
-                 */
+        case _DRM_AGP:
+                if (drm_core_has_AGP(dev) && dev->agp->cant_use_aperture) {
+                        /*
+                         * On some platforms we can't talk to bus dma address from the CPU, so for
+                         * memory of type DRM_AGP, we'll deal with sorting out the real physical
+                         * pages and mappings in nopage()
+                         */
 #if defined(__powerpc__)
-                pgprot_val(vma->vm_page_prot) |= _PAGE_NO_CACHE;
+                        pgprot_val(vma->vm_page_prot) |= _PAGE_NO_CACHE;
 #endif
-                vma->vm_ops = &drm_vm_ops;
-                break;
-          }
-                /* fall through to _DRM_FRAME_BUFFER... */        
+                        vma->vm_ops = &drm_vm_ops;
+                        break;
+                }
+                /* fall through to _DRM_FRAME_BUFFER... */
         case _DRM_FRAME_BUFFER:
         case _DRM_REGISTERS:
 #if defined(__i386__) || defined(__x86_64__)
@@ -591,27 +611,25 @@ int drm_mmap(struct file *filp, struct vm_area_struct *vma)
 #endif
                 vma->vm_flags |= VM_IO; /* not in core dump */
 #if defined(__ia64__)
-                if (efi_range_is_wc(vma->vm_start, vma->vm_end -
-                                    vma->vm_start))
+                if (efi_range_is_wc(vma->vm_start, vma->vm_end - vma->vm_start))
                         vma->vm_page_prot =
-                                pgprot_writecombine(vma->vm_page_prot);
+                            pgprot_writecombine(vma->vm_page_prot);
                 else
-                        vma->vm_page_prot =
-                                pgprot_noncached(vma->vm_page_prot);
+                        vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
 #endif
                 offset = dev->driver->get_reg_ofs(dev);
 #ifdef __sparc__
                 if (io_remap_pfn_range(DRM_RPR_ARG(vma) vma->vm_start,
-                                        (map->offset + offset) >> PAGE_SHIFT,
-                                        vma->vm_end - vma->vm_start,
-                                        vma->vm_page_prot))
+                                       (map->offset + offset) >> PAGE_SHIFT,
+                                       vma->vm_end - vma->vm_start,
+                                       vma->vm_page_prot))
 #else
                 if (io_remap_pfn_range(vma, vma->vm_start,
-                                     (map->offset + offset) >> PAGE_SHIFT,
-                                     vma->vm_end - vma->vm_start,
-                                     vma->vm_page_prot))
+                                       (map->offset + offset) >> PAGE_SHIFT,
+                                       vma->vm_end - vma->vm_start,
+                                       vma->vm_page_prot))
 #endif
-                                return -EAGAIN;
+                        return -EAGAIN;
                 DRM_DEBUG("   Type = %d; start = 0x%lx, end = 0x%lx,"
                           " offset = 0x%lx\n",
                           map->type,
@@ -624,22 +642,23 @@ int drm_mmap(struct file *filp, struct vm_area_struct *vma)
                  * allocate in a different way */
                 vma->vm_ops = &drm_vm_shm_ops;
                 vma->vm_private_data = (void *)map;
-                                /* Don't let this area swap.  Change when
-                                   DRM_KERNEL advisory is supported. */
+                /* Don't let this area swap.  Change when
+                   DRM_KERNEL advisory is supported. */
                 vma->vm_flags |= VM_RESERVED;
                 break;
         case _DRM_SCATTER_GATHER:
                 vma->vm_ops = &drm_vm_sg_ops;
                 vma->vm_private_data = (void *)map;
                 vma->vm_flags |= VM_RESERVED;
-                break;
+                break;
         default:
                 return -EINVAL; /* This should never happen. */
         }
-        vma->vm_flags |= VM_RESERVED; /* Don't swap */
+        vma->vm_flags |= VM_RESERVED;   /* Don't swap */
 
-        vma->vm_file  =  filp;  /* Needed for drm_vm_open() */
+        vma->vm_file = filp;    /* Needed for drm_vm_open() */
         drm_vm_open(vma);
         return 0;
 }
+
 EXPORT_SYMBOL(drm_mmap);