From 239e81093f05e7d81f95a55527f3c9fcb8fc483a Mon Sep 17 00:00:00 2001
From: Jeremy Kolb <jkolb@brandeis.edu>
Date: Thu, 1 Nov 2007 19:04:38 -0400
Subject: nouveau: more filling in for ttm.  Change copyright since it's based
 off of radeon code.

---
 linux-core/nouveau_buffer.c | 94 +++++++++++++++++++++++++++++++++++++++++----
 1 file changed, 86 insertions(+), 8 deletions(-)

(limited to 'linux-core')

diff --git a/linux-core/nouveau_buffer.c b/linux-core/nouveau_buffer.c
index e9f09eb3..bb9f6f41 100644
--- a/linux-core/nouveau_buffer.c
+++ b/linux-core/nouveau_buffer.c
@@ -1,5 +1,5 @@
 /*
- * Copyright 2005 Stephane Marchesin.
+ * Copyright 2007 Dave Airlied
  * All Rights Reserved.
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
@@ -22,7 +22,8 @@
  * OTHER DEALINGS IN THE SOFTWARE.
  */
 /*
- * Authors: Jeremy Kolb <jkolb@brandeis.edu>
+ * Authors: Dave Airlied <airlied@linux.ie>
+ *	    Jeremy Kolb <jkolb@brandeis.edu>
  */
 
 #include "drmP.h"
@@ -33,8 +34,6 @@
 
 struct drm_ttm_backend *nouveau_create_ttm_backend_entry(struct drm_device * dev)
 {
-	struct drm_nouveau_private *dev_priv = dev->dev_private;
-
 	return drm_agp_init_ttm(dev);
 }
 
@@ -61,8 +60,6 @@ int nouveau_init_mem_type(struct drm_device *dev,
 			  uint32_t type,
 			  struct drm_mem_type_manager *man)
 {
-	struct drm_nouveau_private *dev_priv = dev->dev_private;
-
 	switch (type) {
 		case DRM_BO_MEM_LOCAL:
 			man->flags = _DRM_FLAG_MEMTYPE_MAPPABLE |
@@ -119,6 +116,82 @@ uint32_t nouveau_evict_mask(struct drm_buffer_object *bo)
 
 }
 
+static void nouveau_emit_copy_blit(struct drm_device * dev,
+				   uint32_t src_offset,
+				   uint32_t dst_offset,
+				   uint32_t pages, int direction)
+{
+	return;
+}
+
+static int nouveau_move_blit(struct drm_buffer_object *bo,
+			     int evict,
+			     int no_wait,
+			     struct drm_bo_mem_reg *new_mem)
+{
+	struct drm_bo_mem_reg *old_mem = &bo->mem;
+	int dir = 0;
+
+	if ((old_mem->mem_type == new_mem->mem_type) &&
+	    (new_mem->mm_node->start < 
+	     old_mem->mm_node->start + old_mem->mm_node->size)) {
+		dir = 1;
+	}
+
+	nouveau_emit_copy_blit(bo->dev,
+			       old_mem->mm_node->start << PAGE_SHIFT,
+			       new_mem->mm_node->start << PAGE_SHIFT,
+			       new_mem->num_pages, dir);
+	
+	/* we don't need to cleanup out mess because our fences
+	 * are from userland. so this cleanup call is probably wrong.
+	 */
+	return drm_bo_move_accel_cleanup(bo, evict, no_wait, 0,
+					 DRM_FENCE_TYPE_EXE,
+					 0,
+					 new_mem);
+	
+}
+
+static int nouveau_move_flip(struct drm_buffer_object *bo,
+			     int evict,
+			     int no_wait,
+			     struct drm_bo_mem_reg *new_mem)
+{
+	struct drm_device *dev = bo->dev;
+	struct drm_bo_mem_reg tmp_mem;
+	int ret;
+
+	tmp_mem = *new_mem;
+	tmp_mem.mm_node = NULL;
+	tmp_mem.mask = DRM_BO_FLAG_MEM_TT |
+		DRM_BO_FLAG_CACHED | DRM_BO_FLAG_FORCE_CACHING;
+
+	ret = drm_bo_mem_space(bo, &tmp_mem, no_wait);
+	if (ret)
+		return ret;
+
+	ret = drm_bind_ttm(bo->ttm, tmp_mem.mm_node->start);
+	if (ret)
+		goto out_cleanup;
+
+	ret = nouveau_move_blit(bo, 1, no_wait, &tmp_mem);
+	if (ret)
+		goto out_cleanup;
+
+	ret = drm_bo_move_ttm(bo, evict, no_wait, new_mem);
+
+out_cleanup:
+	if (tmp_mem.mm_node) {
+		mutex_lock(&dev->struct_mutex);
+		if (tmp_mem.mm_node != bo->pinned_node)
+			drm_mm_put_block(tmp_mem.mm_node);
+		tmp_mem.mm_node = NULL;
+		mutex_unlock(&dev->struct_mutex);
+	}
+	return ret;
+}
+
 int nouveau_move(struct drm_buffer_object *bo,
 		 int evict,
 		 int no_wait,
@@ -127,12 +200,17 @@ int nouveau_move(struct drm_buffer_object *bo,
 	struct drm_bo_mem_reg *old_mem = &bo->mem;
 
 	if (old_mem->mem_type == DRM_BO_MEM_LOCAL) {
+		/* local to VRAM */
 		return drm_bo_move_memcpy(bo, evict, no_wait, new_mem);
+	}
 	else if (new_mem->mem_type == DRM_BO_MEM_LOCAL) {
-		return drm_bo_move_memcpy(bo, evict, no_wait, new_mem);
+		/* VRAM to local */
+		/*if (nouveau_move_flip(bo, evict, no_wait, new_mem))*/
+			return drm_bo_move_memcpy(bo, evict, no_wait, new_mem);
 	}
 	else {
-		return drm_bo_move_memcpy(bo, evict, no_wait, new_mem);
+		/*if (nouveau_move_blit(bo, evict, no_wait, new_mem))*/
+			return drm_bo_move_memcpy(bo, evict, no_wait, new_mem);
 	}
 	return 0;
 }
-- 
cgit v1.2.3


From 2c6cbea7dedc0b06114117b4c4ce2a23f74c54f6 Mon Sep 17 00:00:00 2001
From: Jeremy Kolb <jkolb@brandeis.edu>
Date: Thu, 1 Nov 2007 23:35:46 -0400
Subject: nouveau: incorporate darktama's buffer object work.

---
 linux-core/nouveau_buffer.c | 257 +++++++++++++++++++++++---------------------
 linux-core/nouveau_drv.c    |  21 ++--
 2 files changed, 147 insertions(+), 131 deletions(-)

(limited to 'linux-core')

diff --git a/linux-core/nouveau_buffer.c b/linux-core/nouveau_buffer.c
index bb9f6f41..41c50748 100644
--- a/linux-core/nouveau_buffer.c
+++ b/linux-core/nouveau_buffer.c
@@ -24,17 +24,29 @@
 /*
  * Authors: Dave Airlied <airlied@linux.ie>
  *	    Jeremy Kolb <jkolb@brandeis.edu>
+ *	    Ben Skeggs
  */
 
 #include "drmP.h"
 #include "nouveau_drm.h"
 #include "nouveau_drv.h"
-
-#ifdef NOUVEAU_HAVE_BUFFER
+#include "nouveau_dma.h"
 
 struct drm_ttm_backend *nouveau_create_ttm_backend_entry(struct drm_device * dev)
 {
-	return drm_agp_init_ttm(dev);
+        struct drm_nouveau_private *dev_priv = dev->dev_private;
+
+        switch (dev_priv->gart_info.type) {
+                case NOUVEAU_GART_AGP:
+                        return drm_agp_init_ttm(dev);
+                case NOUVEAU_GART_SGDMA:
+                        return nouveau_sgdma_init_ttm(dev);
+                default:
+                        DRM_ERROR("Unknown GART type %d\n", dev_priv->gart_info.type);
+                        break;
+        }
+
+        return NULL;
 }
 
 int nouveau_fence_types(struct drm_buffer_object *bo,
@@ -57,46 +69,67 @@ int nouveau_invalidate_caches(struct drm_device *dev, uint64_t buffer_flags)
 }
 
 int nouveau_init_mem_type(struct drm_device *dev,
-			  uint32_t type,
-			  struct drm_mem_type_manager *man)
+                          uint32_t type,
+                          struct drm_mem_type_manager *man)
 {
-	switch (type) {
-		case DRM_BO_MEM_LOCAL:
-			man->flags = _DRM_FLAG_MEMTYPE_MAPPABLE |
-				_DRM_FLAG_MEMTYPE_CACHED;
-			man->drm_bus_maptype = 0;
-			break;
-
-		case DRM_BO_MEM_VRAM:
-			man->flags = _DRM_FLAG_MEMTYPE_FIXED |
-				_DRM_FLAG_MEMTYPE_MAPPABLE |
-				_DRM_FLAG_NEEDS_IOREMAP;
-			man->io_addr = NULL;
-			man->drm_bus_maptype = _DRM_FRAME_BUFFER;
-			man->io_offset = drm_get_resource_start(dev, 0);
-			man->io_size = drm_get_resource_len(dev, 0);
-			break;
-
-		case DRM_BO_MEM_TT:
-			if (!(drm_core_has_AGP(dev) && dev->agp)) {
-				DRM_ERROR("AGP is not enabled for memory type %u\n",
-						(unsigned)type);
-				return -EINVAL;
-			}
-
-			man->io_offset = dev->agp->agp_info.aper_base;
-			man->io_size = dev->agp->agp_info.aper_size * 1024 * 1024;
-			man->io_addr = NULL;
-			man->flags = _DRM_FLAG_MEMTYPE_MAPPABLE |
-				_DRM_FLAG_MEMTYPE_CSELECT | _DRM_FLAG_NEEDS_IOREMAP;
-			man->drm_bus_maptype = _DRM_AGP;
-			break;
-
-		default:
-			DRM_ERROR("Unsupported memory type %u\n", (unsigned)type);
-			return -EINVAL;
-	}
-	return 0;
+        struct drm_nouveau_private *dev_priv = dev->dev_private;
+
+        switch (type) {
+                case DRM_BO_MEM_LOCAL:
+                        man->flags = _DRM_FLAG_MEMTYPE_MAPPABLE |
+                                     _DRM_FLAG_MEMTYPE_CACHED;
+                        man->drm_bus_maptype = 0;
+                        break;
+
+                case DRM_BO_MEM_VRAM:
+                        man->flags = _DRM_FLAG_MEMTYPE_FIXED |
+                                     _DRM_FLAG_MEMTYPE_MAPPABLE |
+                                     _DRM_FLAG_NEEDS_IOREMAP;
+                        man->io_addr = NULL;
+                        man->drm_bus_maptype = _DRM_FRAME_BUFFER;
+                        man->io_offset = drm_get_resource_start(dev, 0);
+                        man->io_size = drm_get_resource_len(dev, 0);
+                        break;
+
+                case DRM_BO_MEM_PRIV0:
+                        /* Unmappable VRAM */                   
+                        man->flags = _DRM_FLAG_MEMTYPE_CMA;
+                        man->drm_bus_maptype = 0;
+                        break;
+
+                case DRM_BO_MEM_TT:
+                        switch (dev_priv->gart_info.type) {
+                                case NOUVEAU_GART_AGP:
+                                        man->flags = _DRM_FLAG_MEMTYPE_MAPPABLE |
+                                                     _DRM_FLAG_MEMTYPE_CSELECT |
+                                                     _DRM_FLAG_NEEDS_IOREMAP;
+                                        man->drm_bus_maptype = _DRM_AGP;
+                                        break;
+
+                                case NOUVEAU_GART_SGDMA:
+                                        man->flags = _DRM_FLAG_MEMTYPE_MAPPABLE |
+                                                     _DRM_FLAG_MEMTYPE_CSELECT |
+                                                     _DRM_FLAG_MEMTYPE_CMA;
+                                        man->drm_bus_maptype = _DRM_SCATTER_GATHER;
+                                        break;
+
+                                default:
+                                        DRM_ERROR("Unknown GART type: %d\n",
+                                                        dev_priv->gart_info.type);
+                                        return -EINVAL;
+                        }
+
+                        man->io_offset  = dev_priv->gart_info.aper_base;
+                        man->io_size    = dev_priv->gart_info.aper_size;
+                        man->io_addr   = NULL;
+                        break;
+
+
+                default:
+                        DRM_ERROR("Unsupported memory type %u\n", (unsigned)type);
+                        return -EINVAL;
+        }
+        return 0;
 }
 
 uint32_t nouveau_evict_mask(struct drm_buffer_object *bo)
@@ -105,91 +138,63 @@ uint32_t nouveau_evict_mask(struct drm_buffer_object *bo)
 		case DRM_BO_MEM_LOCAL:
 		case DRM_BO_MEM_TT:
 			return DRM_BO_FLAG_MEM_LOCAL;
-		case DRM_BO_MEM_VRAM:
-			if (bo->mem.num_pages > 128)
-				return DRM_BO_MEM_TT;
-			else
-				return DRM_BO_MEM_LOCAL;
 		default:
 			return DRM_BO_FLAG_MEM_TT | DRM_BO_FLAG_CACHED;
 	}
-
-}
-
-static void nouveau_emit_copy_blit(struct drm_device * dev,
-				   uint32_t src_offset,
-				   uint32_t dst_offset,
-				   uint32_t pages, int direction)
-{
-	return;
+	return 0;
 }
 
-static int nouveau_move_blit(struct drm_buffer_object *bo,
-			     int evict,
-			     int no_wait,
-			     struct drm_bo_mem_reg *new_mem)
+/* GPU-assisted copy using NV_MEMORY_TO_MEMORY_FORMAT, can access
+ * DRM_BO_MEM_{VRAM,PRIV0,TT} directly.
+ */
+static int
+nouveau_bo_move_m2mf(struct drm_buffer_object *bo, int evict, int no_wait,
+		struct drm_bo_mem_reg *new_mem)
 {
+	struct drm_device *dev = bo->dev;
+	struct drm_nouveau_private *dev_priv = dev->dev_private;
+	struct nouveau_drm_channel *dchan = &dev_priv->channel;
 	struct drm_bo_mem_reg *old_mem = &bo->mem;
-	int dir = 0;
+	uint32_t srch, dsth, page_count;
+
+	/* Can happen during init/takedown */
+	if (!dchan->chan)
+		return -EINVAL;
+
+	srch = old_mem->mem_type == DRM_BO_MEM_TT ? NvDmaTT : NvDmaFB;
+	dsth = new_mem->mem_type == DRM_BO_MEM_TT ? NvDmaTT : NvDmaFB;
+	if (srch != dchan->m2mf_dma_source || dsth != dchan->m2mf_dma_destin) {
+		dchan->m2mf_dma_source = srch;
+		dchan->m2mf_dma_destin = dsth;
+
+		BEGIN_RING(NvSubM2MF,
+				NV_MEMORY_TO_MEMORY_FORMAT_SET_DMA_SOURCE, 2);
+		OUT_RING  (dchan->m2mf_dma_source);
+		OUT_RING  (dchan->m2mf_dma_destin);
+	}
 
-	if ((old_mem->mem_type == new_mem->mem_type) &&
-	    (new_mem->mm_node->start < 
-	     old_mem->mm_node->start + old_mem->mm_node->size)) {
-		dir = 1;
+	page_count = new_mem->num_pages;
+	while (page_count) {
+		int line_count = (page_count > 2047) ? 2047 : page_count;
+
+		BEGIN_RING(NvSubM2MF, NV_MEMORY_TO_MEMORY_FORMAT_OFFSET_IN, 8);
+		OUT_RING  (old_mem->mm_node->start << PAGE_SHIFT);
+		OUT_RING  (new_mem->mm_node->start << PAGE_SHIFT);
+		OUT_RING  (PAGE_SIZE); /* src_pitch */
+		OUT_RING  (PAGE_SIZE); /* dst_pitch */
+		OUT_RING  (PAGE_SIZE); /* line_length */
+		OUT_RING  (line_count);
+		OUT_RING  ((1<<8)|(1<<0));
+		OUT_RING  (0);
+		BEGIN_RING(NvSubM2MF, NV_MEMORY_TO_MEMORY_FORMAT_NOP, 1);
+		OUT_RING  (0);
+
+		page_count -= line_count;
 	}
 
-	nouveau_emit_copy_blit(bo->dev,
-			       old_mem->mm_node->start << PAGE_SHIFT,
-			       new_mem->mm_node->start << PAGE_SHIFT,
-			       new_mem->num_pages, dir);
-	
-	/* we don't need to cleanup out mess because our fences
-	 * are from userland. so this cleanup call is probably wrong.
-	 */
 	return drm_bo_move_accel_cleanup(bo, evict, no_wait, 0,
-					 DRM_FENCE_TYPE_EXE,
-					 0,
-					 new_mem);
-	
-}
-
-static int nouveau_move_flip(struct drm_buffer_object *bo,
-			     int evict,
-			     int no_wait,
-			     struct drm_bo_mem_reg *new_mem)
-{
-	struct drm_device *dev = bo->dev;
-	struct drm_bo_mem_reg tmp_mem;
-	int ret;
-
-	tmp_mem = *new_mem;
-	tmp_mem.mm_node = NULL;
-	tmp_mem.mask = DRM_BO_FLAG_MEM_TT |
-		DRM_BO_FLAG_CACHED | DRM_BO_FLAG_FORCE_CACHING;
-
-	ret = drm_bo_mem_space(bo, &tmp_mem, no_wait);
-	if (ret)
-		return ret;
-
-	ret = drm_bind_ttm(bo->ttm, tmp_mem.mm_node->start);
-	if (ret)
-		goto out_cleanup;
-
-	ret = nouveau_move_blit(bo, 1, no_wait, &tmp_mem);
-	if (ret)
-		goto out_cleanup;
-
-	ret = drm_bo_move_ttm(bo, evict, no_wait, new_mem);
-
-out_cleanup:
-	if (tmp_mem.mm_node) {
-		mutex_lock(&dev->struct_mutex);
-		if (tmp_mem.mm_node != bo->pinned_node)
-			drm_mm_put_block(tmp_mem.mm_node);
-		tmp_mem.mm_node = NULL;
-		mutex_unlock(&dev->struct_mutex);
-	}
-	return ret;
+			DRM_FENCE_TYPE_EXE,
+			0, new_mem);
 }
 
 int nouveau_move(struct drm_buffer_object *bo,
@@ -199,17 +204,22 @@ int nouveau_move(struct drm_buffer_object *bo,
 {
 	struct drm_bo_mem_reg *old_mem = &bo->mem;
 
-	if (old_mem->mem_type == DRM_BO_MEM_LOCAL) {
-		/* local to VRAM */
-		return drm_bo_move_memcpy(bo, evict, no_wait, new_mem);
+	if (new_mem->mem_type == DRM_BO_MEM_LOCAL) {
+		if (old_mem->mem_type == DRM_BO_MEM_LOCAL)
+			return drm_bo_move_memcpy(bo, evict, no_wait, new_mem);
+#if 0
+		if (!nouveau_bo_move_flipd(bo, evict, no_wait, new_mem))
+#endif
+			return drm_bo_move_memcpy(bo, evict, no_wait, new_mem);
 	}
-	else if (new_mem->mem_type == DRM_BO_MEM_LOCAL) {
-		/* VRAM to local */
-		/*if (nouveau_move_flip(bo, evict, no_wait, new_mem))*/
+	else if (old_mem->mem_type == DRM_BO_MEM_LOCAL) {
+#if 0
+		if (nouveau_bo_move_flips(bo, evict, no_wait, new_mem))
+#endif
 			return drm_bo_move_memcpy(bo, evict, no_wait, new_mem);
 	}
 	else {
-		/*if (nouveau_move_blit(bo, evict, no_wait, new_mem))*/
+		if (nouveau_bo_move_m2mf(bo, evict, no_wait, new_mem))
 			return drm_bo_move_memcpy(bo, evict, no_wait, new_mem);
 	}
 	return 0;
@@ -220,4 +230,3 @@ void nouveau_flush_ttm(struct drm_ttm *ttm)
 
 }
 
-#endif
diff --git a/linux-core/nouveau_drv.c b/linux-core/nouveau_drv.c
index 9e6c8f41..1bd8d977 100644
--- a/linux-core/nouveau_drv.c
+++ b/linux-core/nouveau_drv.c
@@ -41,9 +41,18 @@ static struct pci_device_id pciidlist[] = {
 	}
 };
 
-#ifdef NOUVEAU_HAVE_BUFFER
-static uint32_t nouveau_mem_prios[]  = { DRM_BO_MEM_VRAM, DRM_BO_MEM_TT, DRM_BO_MEM_LOCAL };
-static uint32_t nouveau_busy_prios[] = { DRM_BO_MEM_TT, DRM_BO_MEM_LOCAL };
+static uint32_t nouveau_mem_prios[]  = {
+        DRM_BO_MEM_PRIV0,
+        DRM_BO_MEM_VRAM,
+        DRM_BO_MEM_TT,
+        DRM_BO_MEM_LOCAL
+};
+static uint32_t nouveau_busy_prios[] = {
+        DRM_BO_MEM_TT,
+        DRM_BO_MEM_PRIV0,
+        DRM_BO_MEM_VRAM,
+        DRM_BO_MEM_LOCAL
+};
 
 static struct drm_bo_driver nouveau_bo_driver = {
 	.mem_type_prio = nouveau_mem_prios,
@@ -58,7 +67,6 @@ static struct drm_bo_driver nouveau_bo_driver = {
 	.move = nouveau_move,
 	.ttm_cache_flush= nouveau_flush_ttm
 };
-#endif
 
 extern struct drm_ioctl_desc nouveau_ioctls[];
 extern int nouveau_max_ioctl;
@@ -99,9 +107,8 @@ static struct drm_driver driver = {
 		.probe = probe,
 		.remove = __devexit_p(drm_cleanup_pci),
 	},
-#ifdef NOUVEAU_HAVE_BUFFER
-	.bo_driver = &nouveau_bo_driver,
-#endif
+        
+        .bo_driver = &nouveau_bo_driver,
 
 	.name = DRIVER_NAME,
 	.desc = DRIVER_DESC,
-- 
cgit v1.2.3


From c1aa08106e0a7190c7a303ec8a9b6b5339251137 Mon Sep 17 00:00:00 2001
From: Jeremy Kolb <jkolb@brandeis.edu>
Date: Fri, 2 Nov 2007 19:43:53 -0400
Subject: nouveau:  Add darktama's fencing code.  Restructure some stuff.

---
 linux-core/nouveau_fence.c | 129 +++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 129 insertions(+)
 create mode 100644 linux-core/nouveau_fence.c

(limited to 'linux-core')

diff --git a/linux-core/nouveau_fence.c b/linux-core/nouveau_fence.c
new file mode 100644
index 00000000..e510aec7
--- /dev/null
+++ b/linux-core/nouveau_fence.c
@@ -0,0 +1,129 @@
+/*
+ * Copyright (C) 2007 Ben Skeggs.
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial
+ * portions of the Software.
+ *
+ * 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 NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE COPYRIGHT OWNER(S) 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.
+ *
+ */
+
+#include "drmP.h"
+#include "drm.h"
+#include "nouveau_drv.h"
+#include "nouveau_dma.h"
+
+static int
+nouveau_fence_has_irq(struct drm_device *dev, uint32_t class, uint32_t flags)
+{
+	struct drm_nouveau_private *dev_priv = dev->dev_private;
+
+	DRM_DEBUG("class=%d, flags=0x%08x\n", class, flags);
+
+	/* DRM's channel always uses IRQs to signal fences */
+	if (class == dev_priv->channel.chan->id)
+		return 1;
+
+	/* Other channels don't use IRQs at all yet */
+	return 0;
+}
+
+static int
+nouveau_fence_emit(struct drm_device *dev, uint32_t class, uint32_t flags,
+		   uint32_t *breadcrumb, uint32_t *native_type)
+{
+	struct drm_nouveau_private *dev_priv = dev->dev_private;
+	struct nouveau_channel *chan = dev_priv->fifos[class];
+	struct nouveau_drm_channel *dchan = &dev_priv->channel;
+
+	DRM_DEBUG("class=%d, flags=0x%08x\n", class, flags);
+
+	/* We can't emit fences on client channels */
+	if (chan != dchan->chan)
+		return 0;
+
+	*breadcrumb  = ++dchan->next_sequence;
+	*native_type = DRM_FENCE_TYPE_EXE;
+
+	BEGIN_RING(NvSubM2MF, NV_MEMORY_TO_MEMORY_FORMAT_SET_REF, 1);
+	OUT_RING  (*breadcrumb);
+	BEGIN_RING(NvSubM2MF, NV_MEMORY_TO_MEMORY_FORMAT_NOTIFY, 1);
+	OUT_RING  (NV_MEMORY_TO_MEMORY_FORMAT_NOTIFY_STYLE_WRITE_LE_AWAKEN);
+	BEGIN_RING(NvSubM2MF, NV_MEMORY_TO_MEMORY_FORMAT_NOP, 1);
+	OUT_RING  (0);
+	FIRE_RING ();
+
+	return 0;
+}
+
+static void
+nouveau_fence_perform_flush(struct drm_device *dev, uint32_t class)
+{
+	struct drm_nouveau_private *dev_priv = dev->dev_private;
+	struct drm_fence_class_manager *fc = &dev->fm.fence_class[class];
+	uint32_t pending_types = 0;
+
+	DRM_DEBUG("class=%d\n", class);
+
+	pending_types = fc->pending_flush |
+			((fc->pending_exe_flush) ? DRM_FENCE_TYPE_EXE : 0);
+
+	if (pending_types) {
+		uint32_t sequence = NV_READ(NV03_FIFO_REGS(class) + 0x48);
+
+		drm_fence_handler(dev, class, sequence, pending_types, 0);
+	}
+}
+
+static void
+nouveau_fence_poke_flush(struct drm_device *dev, uint32_t class)
+{
+	struct drm_fence_manager *fm = &dev->fm;
+	unsigned long flags;
+
+	DRM_DEBUG("class=%d\n", class);
+
+	write_lock_irqsave(&fm->lock, flags);
+	nouveau_fence_perform_flush(dev, class);
+	write_unlock_irqrestore(&fm->lock, flags);
+}
+
+void
+nouveau_fence_handler(struct drm_device *dev, int channel)
+{
+	struct drm_fence_manager *fm = &dev->fm;
+
+	DRM_DEBUG("class=%d\n", channel);
+
+	write_lock(&fm->lock);
+	nouveau_fence_perform_flush(dev, channel);
+	write_unlock(&fm->lock);
+}
+
+struct drm_fence_driver nouveau_fence_driver = {
+	.num_classes	= 8,
+	.wrap_diff	= (1 << 30),
+	.flush_diff	= (1 << 29),
+	.sequence_mask	= 0xffffffffU,
+	.lazy_capable	= 1,
+	.has_irq	= nouveau_fence_has_irq,
+	.emit		= nouveau_fence_emit,
+	.poke_flush	= nouveau_fence_poke_flush
+};
+
-- 
cgit v1.2.3


From 2dc2ee7a5aed18b82a1125d8e56a7ef92be18532 Mon Sep 17 00:00:00 2001
From: Jeremy Kolb <jkolb@brandeis.edu>
Date: Fri, 2 Nov 2007 19:44:30 -0400
Subject: nouveau: put it all together.

---
 linux-core/Makefile.kernel  |  2 +-
 linux-core/nouveau_buffer.c | 27 +++++++++++++++++++++++++++
 linux-core/nouveau_drv.c    | 28 +---------------------------
 3 files changed, 29 insertions(+), 28 deletions(-)

(limited to 'linux-core')

diff --git a/linux-core/Makefile.kernel b/linux-core/Makefile.kernel
index bcbd78f2..d1f3bb7b 100644
--- a/linux-core/Makefile.kernel
+++ b/linux-core/Makefile.kernel
@@ -22,7 +22,7 @@ i915-objs   := i915_drv.o i915_dma.o i915_irq.o i915_mem.o i915_fence.o \
 		i915_buffer.o i915_compat.o
 nouveau-objs := nouveau_drv.o nouveau_state.o nouveau_fifo.o nouveau_mem.o \
 		nouveau_object.o nouveau_irq.o nouveau_notifier.o nouveau_swmthd.o \
-		nouveau_sgdma.o nouveau_dma.o nouveau_buffer.o \
+		nouveau_sgdma.o nouveau_dma.o nouveau_buffer.o nouveau_fence.o \
 		nv04_timer.o \
 		nv04_mc.o nv40_mc.o nv50_mc.o \
 		nv04_fb.o nv10_fb.o nv40_fb.o \
diff --git a/linux-core/nouveau_buffer.c b/linux-core/nouveau_buffer.c
index 41c50748..1a210e49 100644
--- a/linux-core/nouveau_buffer.c
+++ b/linux-core/nouveau_buffer.c
@@ -230,3 +230,30 @@ void nouveau_flush_ttm(struct drm_ttm *ttm)
 
 }
 
+static uint32_t nouveau_mem_prios[]  = {
+        DRM_BO_MEM_PRIV0,
+        DRM_BO_MEM_VRAM,
+        DRM_BO_MEM_TT,
+        DRM_BO_MEM_LOCAL
+};
+static uint32_t nouveau_busy_prios[] = {
+        DRM_BO_MEM_TT,
+        DRM_BO_MEM_PRIV0,
+        DRM_BO_MEM_VRAM,
+        DRM_BO_MEM_LOCAL
+};
+
+struct drm_bo_driver nouveau_bo_driver = {
+	.mem_type_prio = nouveau_mem_prios,
+	.mem_busy_prio = nouveau_busy_prios,
+	.num_mem_type_prio = sizeof(nouveau_mem_prios)/sizeof(uint32_t),
+	.num_mem_busy_prio = sizeof(nouveau_busy_prios)/sizeof(uint32_t),
+	.create_ttm_backend_entry = nouveau_create_ttm_backend_entry,
+	.fence_type = nouveau_fence_types,
+	.invalidate_caches = nouveau_invalidate_caches,
+	.init_mem_type = nouveau_init_mem_type,
+	.evict_mask = nouveau_evict_mask,
+	.move = nouveau_move,
+	.ttm_cache_flush= nouveau_flush_ttm
+};
+
diff --git a/linux-core/nouveau_drv.c b/linux-core/nouveau_drv.c
index 1bd8d977..ac70d7ae 100644
--- a/linux-core/nouveau_drv.c
+++ b/linux-core/nouveau_drv.c
@@ -41,33 +41,6 @@ static struct pci_device_id pciidlist[] = {
 	}
 };
 
-static uint32_t nouveau_mem_prios[]  = {
-        DRM_BO_MEM_PRIV0,
-        DRM_BO_MEM_VRAM,
-        DRM_BO_MEM_TT,
-        DRM_BO_MEM_LOCAL
-};
-static uint32_t nouveau_busy_prios[] = {
-        DRM_BO_MEM_TT,
-        DRM_BO_MEM_PRIV0,
-        DRM_BO_MEM_VRAM,
-        DRM_BO_MEM_LOCAL
-};
-
-static struct drm_bo_driver nouveau_bo_driver = {
-	.mem_type_prio = nouveau_mem_prios,
-	.mem_busy_prio = nouveau_busy_prios,
-	.num_mem_type_prio = sizeof(nouveau_mem_prios)/sizeof(uint32_t),
-	.num_mem_busy_prio = sizeof(nouveau_busy_prios)/sizeof(uint32_t),
-	.create_ttm_backend_entry = nouveau_create_ttm_backend_entry,
-	.fence_type = nouveau_fence_types,
-	.invalidate_caches = nouveau_invalidate_caches,
-	.init_mem_type = nouveau_init_mem_type,
-	.evict_mask = nouveau_evict_mask,
-	.move = nouveau_move,
-	.ttm_cache_flush= nouveau_flush_ttm
-};
-
 extern struct drm_ioctl_desc nouveau_ioctls[];
 extern int nouveau_max_ioctl;
 
@@ -109,6 +82,7 @@ static struct drm_driver driver = {
 	},
         
         .bo_driver = &nouveau_bo_driver,
+        .fence_driver = &nouveau_fence_driver,
 
 	.name = DRIVER_NAME,
 	.desc = DRIVER_DESC,
-- 
cgit v1.2.3


From 998d120a47cab85e985b24932fe8f4682f5f78e9 Mon Sep 17 00:00:00 2001
From: Jeremy Kolb <jkolb@brandeis.edu>
Date: Fri, 2 Nov 2007 19:46:27 -0400
Subject: nouveau: add darktama's email address to authors section.

---
 linux-core/nouveau_buffer.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'linux-core')

diff --git a/linux-core/nouveau_buffer.c b/linux-core/nouveau_buffer.c
index 1a210e49..799731a2 100644
--- a/linux-core/nouveau_buffer.c
+++ b/linux-core/nouveau_buffer.c
@@ -23,8 +23,8 @@
  */
 /*
  * Authors: Dave Airlied <airlied@linux.ie>
- *	    Jeremy Kolb <jkolb@brandeis.edu>
- *	    Ben Skeggs
+ *	    Ben Skeggs   <darktama@iinet.net.au>
+ *	    Jeremy Kolb  <jkolb@brandeis.edu>
  */
 
 #include "drmP.h"
-- 
cgit v1.2.3


From a2e8e294d8e5d7cf179cb562745c1b613ff60e52 Mon Sep 17 00:00:00 2001
From: Dave Airlie <airlied@linux.ie>
Date: Sun, 4 Nov 2007 11:01:27 +1100
Subject: drm: fix oops since user objects..

---
 linux-core/drm_bo.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'linux-core')

diff --git a/linux-core/drm_bo.c b/linux-core/drm_bo.c
index ea680a17..4f95f236 100644
--- a/linux-core/drm_bo.c
+++ b/linux-core/drm_bo.c
@@ -2213,7 +2213,6 @@ int drm_bo_driver_finish(struct drm_device * dev)
 	if (list_empty(&bm->unfenced)) {
 		DRM_DEBUG("Unfenced list was clean\n");
 	}
-      out:
 
 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,15))
 	unlock_page(bm->dummy_read_page);
@@ -2221,6 +2220,8 @@ int drm_bo_driver_finish(struct drm_device * dev)
 	ClearPageReserved(bm->dummy_read_page);
 #endif
 	__free_page(bm->dummy_read_page);
+
+out:
 	mutex_unlock(&dev->struct_mutex);
 	return ret;
 }
-- 
cgit v1.2.3


From 173a5be28f4ed59e27d7a719f62bc275959b5b70 Mon Sep 17 00:00:00 2001
From: Ben Skeggs <skeggsb@gmail.com>
Date: Mon, 5 Nov 2007 02:20:35 +1100
Subject: nouveau: hook up an inital fence irq handler

---
 linux-core/nouveau_buffer.c | 47 ++++++++++++++++++++++++---------------------
 1 file changed, 25 insertions(+), 22 deletions(-)

(limited to 'linux-core')

diff --git a/linux-core/nouveau_buffer.c b/linux-core/nouveau_buffer.c
index 799731a2..6771df85 100644
--- a/linux-core/nouveau_buffer.c
+++ b/linux-core/nouveau_buffer.c
@@ -32,7 +32,8 @@
 #include "nouveau_drv.h"
 #include "nouveau_dma.h"
 
-struct drm_ttm_backend *nouveau_create_ttm_backend_entry(struct drm_device * dev)
+static struct drm_ttm_backend *
+nouveau_bo_create_ttm_backend_entry(struct drm_device * dev)
 {
         struct drm_nouveau_private *dev_priv = dev->dev_private;
 
@@ -49,9 +50,9 @@ struct drm_ttm_backend *nouveau_create_ttm_backend_entry(struct drm_device * dev
         return NULL;
 }
 
-int nouveau_fence_types(struct drm_buffer_object *bo,
-			uint32_t *fclass,
-			uint32_t *type)
+static int
+nouveau_bo_fence_type(struct drm_buffer_object *bo,
+		      uint32_t *fclass, uint32_t *type)
 {
 	*fclass = 0;
 
@@ -62,15 +63,17 @@ int nouveau_fence_types(struct drm_buffer_object *bo,
 	return 0;
 
 }
-int nouveau_invalidate_caches(struct drm_device *dev, uint64_t buffer_flags)
+
+static int
+nouveau_bo_invalidate_caches(struct drm_device *dev, uint64_t buffer_flags)
 {
 	/* We'll do this from user space. */
 	return 0;
 }
 
-int nouveau_init_mem_type(struct drm_device *dev,
-                          uint32_t type,
-                          struct drm_mem_type_manager *man)
+static int
+nouveau_bo_init_mem_type(struct drm_device *dev, uint32_t type,
+			 struct drm_mem_type_manager *man)
 {
         struct drm_nouveau_private *dev_priv = dev->dev_private;
 
@@ -132,7 +135,8 @@ int nouveau_init_mem_type(struct drm_device *dev,
         return 0;
 }
 
-uint32_t nouveau_evict_mask(struct drm_buffer_object *bo)
+static uint32_t
+nouveau_bo_evict_mask(struct drm_buffer_object *bo)
 {
 	switch (bo->mem.mem_type) {
 		case DRM_BO_MEM_LOCAL:
@@ -197,10 +201,9 @@ nouveau_bo_move_m2mf(struct drm_buffer_object *bo, int evict, int no_wait,
 			0, new_mem);
 }
 
-int nouveau_move(struct drm_buffer_object *bo,
-		 int evict,
-		 int no_wait,
-		 struct drm_bo_mem_reg *new_mem)
+static int
+nouveau_bo_move(struct drm_buffer_object *bo, int evict, int no_wait,
+		struct drm_bo_mem_reg *new_mem)
 {
 	struct drm_bo_mem_reg *old_mem = &bo->mem;
 
@@ -225,9 +228,9 @@ int nouveau_move(struct drm_buffer_object *bo,
 	return 0;
 }
 
-void nouveau_flush_ttm(struct drm_ttm *ttm)
+static void
+nouveau_bo_flush_ttm(struct drm_ttm *ttm)
 {
-
 }
 
 static uint32_t nouveau_mem_prios[]  = {
@@ -248,12 +251,12 @@ struct drm_bo_driver nouveau_bo_driver = {
 	.mem_busy_prio = nouveau_busy_prios,
 	.num_mem_type_prio = sizeof(nouveau_mem_prios)/sizeof(uint32_t),
 	.num_mem_busy_prio = sizeof(nouveau_busy_prios)/sizeof(uint32_t),
-	.create_ttm_backend_entry = nouveau_create_ttm_backend_entry,
-	.fence_type = nouveau_fence_types,
-	.invalidate_caches = nouveau_invalidate_caches,
-	.init_mem_type = nouveau_init_mem_type,
-	.evict_mask = nouveau_evict_mask,
-	.move = nouveau_move,
-	.ttm_cache_flush= nouveau_flush_ttm
+	.create_ttm_backend_entry = nouveau_bo_create_ttm_backend_entry,
+	.fence_type = nouveau_bo_fence_type,
+	.invalidate_caches = nouveau_bo_invalidate_caches,
+	.init_mem_type = nouveau_bo_init_mem_type,
+	.evict_mask = nouveau_bo_evict_mask,
+	.move = nouveau_bo_move,
+	.ttm_cache_flush= nouveau_bo_flush_ttm
 };
 
-- 
cgit v1.2.3


From dfa449cf9a7ce5de9cbd571f604ae7c3c778dabd Mon Sep 17 00:00:00 2001
From: Ben Skeggs <skeggsb@gmail.com>
Date: Mon, 5 Nov 2007 02:32:46 +1100
Subject: nouveau: vram is bar1

---
 linux-core/nouveau_buffer.c | 160 +++++++++++++++++++++-----------------------
 1 file changed, 78 insertions(+), 82 deletions(-)

(limited to 'linux-core')

diff --git a/linux-core/nouveau_buffer.c b/linux-core/nouveau_buffer.c
index 6771df85..82093468 100644
--- a/linux-core/nouveau_buffer.c
+++ b/linux-core/nouveau_buffer.c
@@ -35,19 +35,19 @@
 static struct drm_ttm_backend *
 nouveau_bo_create_ttm_backend_entry(struct drm_device * dev)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
+	struct drm_nouveau_private *dev_priv = dev->dev_private;
 
-        switch (dev_priv->gart_info.type) {
-                case NOUVEAU_GART_AGP:
-                        return drm_agp_init_ttm(dev);
-                case NOUVEAU_GART_SGDMA:
-                        return nouveau_sgdma_init_ttm(dev);
-                default:
-                        DRM_ERROR("Unknown GART type %d\n", dev_priv->gart_info.type);
-                        break;
-        }
+	switch (dev_priv->gart_info.type) {
+	case NOUVEAU_GART_AGP:
+		return drm_agp_init_ttm(dev);
+	case NOUVEAU_GART_SGDMA:
+		return nouveau_sgdma_init_ttm(dev);
+	default:
+		DRM_ERROR("Unknown GART type %d\n", dev_priv->gart_info.type);
+		break;
+	}
 
-        return NULL;
+	return NULL;
 }
 
 static int
@@ -75,75 +75,70 @@ static int
 nouveau_bo_init_mem_type(struct drm_device *dev, uint32_t type,
 			 struct drm_mem_type_manager *man)
 {
-        struct drm_nouveau_private *dev_priv = dev->dev_private;
-
-        switch (type) {
-                case DRM_BO_MEM_LOCAL:
-                        man->flags = _DRM_FLAG_MEMTYPE_MAPPABLE |
-                                     _DRM_FLAG_MEMTYPE_CACHED;
-                        man->drm_bus_maptype = 0;
-                        break;
-
-                case DRM_BO_MEM_VRAM:
-                        man->flags = _DRM_FLAG_MEMTYPE_FIXED |
-                                     _DRM_FLAG_MEMTYPE_MAPPABLE |
-                                     _DRM_FLAG_NEEDS_IOREMAP;
-                        man->io_addr = NULL;
-                        man->drm_bus_maptype = _DRM_FRAME_BUFFER;
-                        man->io_offset = drm_get_resource_start(dev, 0);
-                        man->io_size = drm_get_resource_len(dev, 0);
-                        break;
-
-                case DRM_BO_MEM_PRIV0:
-                        /* Unmappable VRAM */                   
-                        man->flags = _DRM_FLAG_MEMTYPE_CMA;
-                        man->drm_bus_maptype = 0;
-                        break;
-
-                case DRM_BO_MEM_TT:
-                        switch (dev_priv->gart_info.type) {
-                                case NOUVEAU_GART_AGP:
-                                        man->flags = _DRM_FLAG_MEMTYPE_MAPPABLE |
-                                                     _DRM_FLAG_MEMTYPE_CSELECT |
-                                                     _DRM_FLAG_NEEDS_IOREMAP;
-                                        man->drm_bus_maptype = _DRM_AGP;
-                                        break;
-
-                                case NOUVEAU_GART_SGDMA:
-                                        man->flags = _DRM_FLAG_MEMTYPE_MAPPABLE |
-                                                     _DRM_FLAG_MEMTYPE_CSELECT |
-                                                     _DRM_FLAG_MEMTYPE_CMA;
-                                        man->drm_bus_maptype = _DRM_SCATTER_GATHER;
-                                        break;
-
-                                default:
-                                        DRM_ERROR("Unknown GART type: %d\n",
-                                                        dev_priv->gart_info.type);
-                                        return -EINVAL;
-                        }
-
-                        man->io_offset  = dev_priv->gart_info.aper_base;
-                        man->io_size    = dev_priv->gart_info.aper_size;
-                        man->io_addr   = NULL;
-                        break;
-
+	struct drm_nouveau_private *dev_priv = dev->dev_private;
 
-                default:
-                        DRM_ERROR("Unsupported memory type %u\n", (unsigned)type);
-                        return -EINVAL;
-        }
-        return 0;
+	switch (type) {
+	case DRM_BO_MEM_LOCAL:
+		man->flags = _DRM_FLAG_MEMTYPE_MAPPABLE |
+			     _DRM_FLAG_MEMTYPE_CACHED;
+		man->drm_bus_maptype = 0;
+		break;
+	case DRM_BO_MEM_VRAM:
+		man->flags = _DRM_FLAG_MEMTYPE_FIXED |
+			     _DRM_FLAG_MEMTYPE_MAPPABLE |
+			     _DRM_FLAG_NEEDS_IOREMAP;
+		man->io_addr = NULL;
+		man->drm_bus_maptype = _DRM_FRAME_BUFFER;
+		man->io_offset = drm_get_resource_start(dev, 1);
+		man->io_size = drm_get_resource_len(dev, 1);
+		if (man->io_size > nouveau_mem_fb_amount(dev))
+			man->io_size = nouveau_mem_fb_amount(dev);
+		break;
+	case DRM_BO_MEM_PRIV0:
+		/* Unmappable VRAM */		   
+		man->flags = _DRM_FLAG_MEMTYPE_CMA;
+		man->drm_bus_maptype = 0;
+		break;
+	case DRM_BO_MEM_TT:
+		switch (dev_priv->gart_info.type) {
+		case NOUVEAU_GART_AGP:
+			man->flags = _DRM_FLAG_MEMTYPE_MAPPABLE |
+				     _DRM_FLAG_MEMTYPE_CSELECT |
+				     _DRM_FLAG_NEEDS_IOREMAP;
+			man->drm_bus_maptype = _DRM_AGP;
+			break;
+		case NOUVEAU_GART_SGDMA:
+			man->flags = _DRM_FLAG_MEMTYPE_MAPPABLE |
+				     _DRM_FLAG_MEMTYPE_CSELECT |
+				     _DRM_FLAG_MEMTYPE_CMA;
+			man->drm_bus_maptype = _DRM_SCATTER_GATHER;
+			break;
+		default:
+			DRM_ERROR("Unknown GART type: %d\n",
+				  dev_priv->gart_info.type);
+			return -EINVAL;
+		}
+
+		man->io_offset  = dev_priv->gart_info.aper_base;
+		man->io_size    = dev_priv->gart_info.aper_size;
+		man->io_addr   = NULL;
+		break;
+	default:
+		DRM_ERROR("Unsupported memory type %u\n", (unsigned)type);
+		return -EINVAL;
+	}
+	return 0;
 }
 
 static uint32_t
 nouveau_bo_evict_mask(struct drm_buffer_object *bo)
 {
 	switch (bo->mem.mem_type) {
-		case DRM_BO_MEM_LOCAL:
-		case DRM_BO_MEM_TT:
-			return DRM_BO_FLAG_MEM_LOCAL;
-		default:
-			return DRM_BO_FLAG_MEM_TT | DRM_BO_FLAG_CACHED;
+	case DRM_BO_MEM_LOCAL:
+	case DRM_BO_MEM_TT:
+		return DRM_BO_FLAG_MEM_LOCAL;
+	default:
+		return DRM_BO_FLAG_MEM_TT | DRM_BO_FLAG_CACHED;
 	}
 	return 0;
 }
@@ -215,7 +210,8 @@ nouveau_bo_move(struct drm_buffer_object *bo, int evict, int no_wait,
 #endif
 			return drm_bo_move_memcpy(bo, evict, no_wait, new_mem);
 	}
-	else if (old_mem->mem_type == DRM_BO_MEM_LOCAL) {
+	else
+	if (old_mem->mem_type == DRM_BO_MEM_LOCAL) {
 #if 0
 		if (nouveau_bo_move_flips(bo, evict, no_wait, new_mem))
 #endif
@@ -234,16 +230,16 @@ nouveau_bo_flush_ttm(struct drm_ttm *ttm)
 }
 
 static uint32_t nouveau_mem_prios[]  = {
-        DRM_BO_MEM_PRIV0,
-        DRM_BO_MEM_VRAM,
-        DRM_BO_MEM_TT,
-        DRM_BO_MEM_LOCAL
+	DRM_BO_MEM_PRIV0,
+	DRM_BO_MEM_VRAM,
+	DRM_BO_MEM_TT,
+	DRM_BO_MEM_LOCAL
 };
 static uint32_t nouveau_busy_prios[] = {
-        DRM_BO_MEM_TT,
-        DRM_BO_MEM_PRIV0,
-        DRM_BO_MEM_VRAM,
-        DRM_BO_MEM_LOCAL
+	DRM_BO_MEM_TT,
+	DRM_BO_MEM_PRIV0,
+	DRM_BO_MEM_VRAM,
+	DRM_BO_MEM_LOCAL
 };
 
 struct drm_bo_driver nouveau_bo_driver = {
-- 
cgit v1.2.3


From 0a2ab1a9003f132195fe70c145a78b4079a3fb7f Mon Sep 17 00:00:00 2001
From: Ben Skeggs <skeggsb@gmail.com>
Date: Mon, 5 Nov 2007 03:53:46 +1100
Subject: nouveau: cleanups

---
 linux-core/nouveau_buffer.c |  8 +++-----
 linux-core/nouveau_fence.c  | 17 ++++++++++++-----
 2 files changed, 15 insertions(+), 10 deletions(-)

(limited to 'linux-core')

diff --git a/linux-core/nouveau_buffer.c b/linux-core/nouveau_buffer.c
index 82093468..7683defb 100644
--- a/linux-core/nouveau_buffer.c
+++ b/linux-core/nouveau_buffer.c
@@ -55,7 +55,6 @@ nouveau_bo_fence_type(struct drm_buffer_object *bo,
 		      uint32_t *fclass, uint32_t *type)
 {
 	*fclass = 0;
-
 	if (bo->mem.mask & (DRM_BO_FLAG_READ | DRM_BO_FLAG_WRITE))
 		*type = 3;
 	else
@@ -167,7 +166,7 @@ nouveau_bo_move_m2mf(struct drm_buffer_object *bo, int evict, int no_wait,
 		dchan->m2mf_dma_destin = dsth;
 
 		BEGIN_RING(NvSubM2MF,
-				NV_MEMORY_TO_MEMORY_FORMAT_SET_DMA_SOURCE, 2);
+			   NV_MEMORY_TO_MEMORY_FORMAT_SET_DMA_SOURCE, 2);
 		OUT_RING  (dchan->m2mf_dma_source);
 		OUT_RING  (dchan->m2mf_dma_destin);
 	}
@@ -191,9 +190,8 @@ nouveau_bo_move_m2mf(struct drm_buffer_object *bo, int evict, int no_wait,
 		page_count -= line_count;
 	}
 
-	return drm_bo_move_accel_cleanup(bo, evict, no_wait, 0,
-			DRM_FENCE_TYPE_EXE,
-			0, new_mem);
+	return drm_bo_move_accel_cleanup(bo, evict, no_wait, dchan->chan->id,
+					 DRM_FENCE_TYPE_EXE, 0, new_mem);
 }
 
 static int
diff --git a/linux-core/nouveau_fence.c b/linux-core/nouveau_fence.c
index e510aec7..f0e62861 100644
--- a/linux-core/nouveau_fence.c
+++ b/linux-core/nouveau_fence.c
@@ -54,13 +54,17 @@ nouveau_fence_emit(struct drm_device *dev, uint32_t class, uint32_t flags,
 
 	DRM_DEBUG("class=%d, flags=0x%08x\n", class, flags);
 
-	/* We can't emit fences on client channels */
-	if (chan != dchan->chan)
-		return 0;
-
-	*breadcrumb  = ++dchan->next_sequence;
+	/* We can't emit fences on client channels, update sequence number
+	 * and userspace will emit the fence
+	 */
+	*breadcrumb  = ++chan->next_sequence;
 	*native_type = DRM_FENCE_TYPE_EXE;
+	if (chan != dchan->chan) {
+		DRM_DEBUG("user fence 0x%08x\n", *breadcrumb);
+		return 0;
+	}
 
+	DRM_DEBUG("emit 0x%08x\n", *breadcrumb);
 	BEGIN_RING(NvSubM2MF, NV_MEMORY_TO_MEMORY_FORMAT_SET_REF, 1);
 	OUT_RING  (*breadcrumb);
 	BEGIN_RING(NvSubM2MF, NV_MEMORY_TO_MEMORY_FORMAT_NOTIFY, 1);
@@ -83,10 +87,13 @@ nouveau_fence_perform_flush(struct drm_device *dev, uint32_t class)
 
 	pending_types = fc->pending_flush |
 			((fc->pending_exe_flush) ? DRM_FENCE_TYPE_EXE : 0);
+	DRM_DEBUG("pending: 0x%08x 0x%08x\n", pending_types,
+					      fc->pending_flush);
 
 	if (pending_types) {
 		uint32_t sequence = NV_READ(NV03_FIFO_REGS(class) + 0x48);
 
+		DRM_DEBUG("got 0x%08x\n", sequence);
 		drm_fence_handler(dev, class, sequence, pending_types, 0);
 	}
 }
-- 
cgit v1.2.3


From 9096d50df7ac99f44d043556420f9f9f54e59b3f Mon Sep 17 00:00:00 2001
From: Ben Skeggs <skeggsb@gmail.com>
Date: Mon, 5 Nov 2007 05:15:32 +1100
Subject: nouveau: disable m2mf buffer move for the moment

---
 linux-core/nouveau_buffer.c | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

(limited to 'linux-core')

diff --git a/linux-core/nouveau_buffer.c b/linux-core/nouveau_buffer.c
index 7683defb..80ba1759 100644
--- a/linux-core/nouveau_buffer.c
+++ b/linux-core/nouveau_buffer.c
@@ -54,7 +54,8 @@ static int
 nouveau_bo_fence_type(struct drm_buffer_object *bo,
 		      uint32_t *fclass, uint32_t *type)
 {
-	*fclass = 0;
+	/* When we get called, *fclass is set to the requested fence class */
+
 	if (bo->mem.mask & (DRM_BO_FLAG_READ | DRM_BO_FLAG_WRITE))
 		*type = 3;
 	else
@@ -216,7 +217,7 @@ nouveau_bo_move(struct drm_buffer_object *bo, int evict, int no_wait,
 			return drm_bo_move_memcpy(bo, evict, no_wait, new_mem);
 	}
 	else {
-		if (nouveau_bo_move_m2mf(bo, evict, no_wait, new_mem))
+//		if (nouveau_bo_move_m2mf(bo, evict, no_wait, new_mem))
 			return drm_bo_move_memcpy(bo, evict, no_wait, new_mem);
 	}
 	return 0;
-- 
cgit v1.2.3


From 5092865601ccaae1409abfa083147276916d6c25 Mon Sep 17 00:00:00 2001
From: Ben Skeggs <skeggsb@gmail.com>
Date: Mon, 5 Nov 2007 05:42:08 +1100
Subject: nouveau: Use a sw method instead of notify interrupt to signal fence
 completion.

---
 linux-core/nouveau_fence.c | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

(limited to 'linux-core')

diff --git a/linux-core/nouveau_fence.c b/linux-core/nouveau_fence.c
index f0e62861..6f3259f0 100644
--- a/linux-core/nouveau_fence.c
+++ b/linux-core/nouveau_fence.c
@@ -67,9 +67,7 @@ nouveau_fence_emit(struct drm_device *dev, uint32_t class, uint32_t flags,
 	DRM_DEBUG("emit 0x%08x\n", *breadcrumb);
 	BEGIN_RING(NvSubM2MF, NV_MEMORY_TO_MEMORY_FORMAT_SET_REF, 1);
 	OUT_RING  (*breadcrumb);
-	BEGIN_RING(NvSubM2MF, NV_MEMORY_TO_MEMORY_FORMAT_NOTIFY, 1);
-	OUT_RING  (NV_MEMORY_TO_MEMORY_FORMAT_NOTIFY_STYLE_WRITE_LE_AWAKEN);
-	BEGIN_RING(NvSubM2MF, NV_MEMORY_TO_MEMORY_FORMAT_NOP, 1);
+	BEGIN_RING(NvSubM2MF, 0x0150, 1);
 	OUT_RING  (0);
 	FIRE_RING ();
 
-- 
cgit v1.2.3


From 3664de73955aafe912318c91717ff9ecc1027af2 Mon Sep 17 00:00:00 2001
From: Dave Airlie <airlied@linux.ie>
Date: Mon, 5 Nov 2007 12:10:52 +1000
Subject: drm: move some of the OS stuff into the OS header

---
 linux-core/drmP.h         | 14 --------------
 linux-core/drm_os_linux.h | 15 +++++++++++++++
 2 files changed, 15 insertions(+), 14 deletions(-)

(limited to 'linux-core')

diff --git a/linux-core/drmP.h b/linux-core/drmP.h
index c014eddf..759d2575 100644
--- a/linux-core/drmP.h
+++ b/linux-core/drmP.h
@@ -1288,19 +1288,5 @@ static inline void drm_ctl_free(void *pt, size_t size, int area)
 
 /*@}*/
 
-/** Type for the OS's non-sleepable mutex lock */
-#define DRM_SPINTYPE		spinlock_t
-/**
- * Initialize the lock for use.  name is an optional string describing the
- * lock
- */
-#define DRM_SPININIT(l,name)	spin_lock_init(l)
-#define DRM_SPINUNINIT(l)
-#define DRM_SPINLOCK(l)		spin_lock(l)
-#define DRM_SPINUNLOCK(l)	spin_unlock(l)
-#define DRM_SPINLOCK_IRQSAVE(l, _flags)	spin_lock_irqsave(l, _flags);
-#define DRM_SPINUNLOCK_IRQRESTORE(l, _flags) spin_unlock_irqrestore(l, _flags);
-#define DRM_SPINLOCK_ASSERT(l)		do {} while (0) 
-
 #endif				/* __KERNEL__ */
 #endif
diff --git a/linux-core/drm_os_linux.h b/linux-core/drm_os_linux.h
index 2688479a..84c294e1 100644
--- a/linux-core/drm_os_linux.h
+++ b/linux-core/drm_os_linux.h
@@ -129,3 +129,18 @@ do {								\
 
 #define DRM_WAKEUP( queue ) wake_up_interruptible( queue )
 #define DRM_INIT_WAITQUEUE( queue ) init_waitqueue_head( queue )
+
+/** Type for the OS's non-sleepable mutex lock */
+#define DRM_SPINTYPE		spinlock_t
+/**
+ * Initialize the lock for use.  name is an optional string describing the
+ * lock
+ */
+#define DRM_SPININIT(l,name)	spin_lock_init(l)
+#define DRM_SPINUNINIT(l)
+#define DRM_SPINLOCK(l)		spin_lock(l)
+#define DRM_SPINUNLOCK(l)	spin_unlock(l)
+#define DRM_SPINLOCK_IRQSAVE(l, _flags)	spin_lock_irqsave(l, _flags);
+#define DRM_SPINUNLOCK_IRQRESTORE(l, _flags) spin_unlock_irqrestore(l, _flags);
+#define DRM_SPINLOCK_ASSERT(l)		do {} while (0)
+
-- 
cgit v1.2.3


From 7f6bf84c238a1859ffd409c0ef1f1ca7eb5e6e72 Mon Sep 17 00:00:00 2001
From: Dave Airlie <airlied@linux.ie>
Date: Mon, 5 Nov 2007 12:42:22 +1000
Subject: drm: remove lots of spurious whitespace.

Kernel "cleanfile" script run.
---
 linux-core/drm_agpsupport.c |  10 +--
 linux-core/drm_bo.c         |  34 ++++-----
 linux-core/drm_bo_lock.c    |  12 +--
 linux-core/drm_bo_move.c    |  20 ++---
 linux-core/drm_bufs.c       |  16 ++--
 linux-core/drm_compat.c     |  58 +++++++--------
 linux-core/drm_compat.h     |  24 +++---
 linux-core/drm_context.c    |   4 +-
 linux-core/drm_drv.c        |  22 +++---
 linux-core/drm_fence.c      |   6 +-
 linux-core/drm_fops.c       |   1 -
 linux-core/drm_hashtab.c    |   2 +-
 linux-core/drm_hashtab.h    |   1 -
 linux-core/drm_mm.c         |   4 +-
 linux-core/drm_objects.h    |   6 +-
 linux-core/drm_os_linux.h   |   5 +-
 linux-core/drm_scatter.c    |   2 +-
 linux-core/drm_stub.c       |   2 +-
 linux-core/ffb_drv.h        |   4 +-
 linux-core/i810_dma.c       |   6 +-
 linux-core/i810_drv.h       |  48 ++++++------
 linux-core/i915_buffer.c    |  18 ++---
 linux-core/i915_compat.c    |   2 +-
 linux-core/i915_drv.c       |  14 ++--
 linux-core/i915_fence.c     |  16 ++--
 linux-core/i915_ioc32.c     |  16 ++--
 linux-core/mga_drv.c        |   2 +-
 linux-core/mga_ioc32.c      |  32 ++++----
 linux-core/nouveau_buffer.c |   3 +-
 linux-core/nouveau_drv.c    |   2 +-
 linux-core/nouveau_fence.c  |   1 -
 linux-core/nouveau_sgdma.c  |   3 +-
 linux-core/r128_ioc32.c     |   6 +-
 linux-core/radeon_drv.c     |   2 +-
 linux-core/sis_mm.c         |   2 +-
 linux-core/via_buffer.c     |  14 ++--
 linux-core/via_dmablit.c    | 178 ++++++++++++++++++++++----------------------
 linux-core/via_dmablit.h    |  84 ++++++++++-----------
 linux-core/via_mm.c         |   2 +-
 linux-core/xgi_cmdlist.c    |  14 ++--
 linux-core/xgi_drv.c        |   6 +-
 linux-core/xgi_fb.c         |   6 +-
 linux-core/xgi_fence.c      |   2 +-
 linux-core/xgi_ioc32.c      |   2 +-
 linux-core/xgi_misc.c       |  12 +--
 linux-core/xgi_misc.h       |   2 +-
 linux-core/xgi_regs.h       |   2 +-
 47 files changed, 361 insertions(+), 369 deletions(-)

(limited to 'linux-core')

diff --git a/linux-core/drm_agpsupport.c b/linux-core/drm_agpsupport.c
index 7c50f411..08ea7c48 100644
--- a/linux-core/drm_agpsupport.c
+++ b/linux-core/drm_agpsupport.c
@@ -506,7 +506,7 @@ static int drm_agp_needs_unbind_cache_adjust(struct drm_ttm_backend *backend) {
 static int drm_agp_populate(struct drm_ttm_backend *backend, unsigned long num_pages,
 			    struct page **pages) {
 
-	struct drm_agp_ttm_backend *agp_be = 
+	struct drm_agp_ttm_backend *agp_be =
 		container_of(backend, struct drm_agp_ttm_backend, backend);
 	struct page **cur_page, **last_page = pages + num_pages;
 	DRM_AGP_MEM *mem;
@@ -562,7 +562,7 @@ static int drm_agp_bind_ttm(struct drm_ttm_backend *backend,
 
 static int drm_agp_unbind_ttm(struct drm_ttm_backend *backend) {
 
-	struct drm_agp_ttm_backend *agp_be = 
+	struct drm_agp_ttm_backend *agp_be =
 		container_of(backend, struct drm_agp_ttm_backend, backend);
 
 	DRM_DEBUG("drm_agp_unbind_ttm\n");
@@ -574,7 +574,7 @@ static int drm_agp_unbind_ttm(struct drm_ttm_backend *backend) {
 
 static void drm_agp_clear_ttm(struct drm_ttm_backend *backend) {
 
-	struct drm_agp_ttm_backend *agp_be = 
+	struct drm_agp_ttm_backend *agp_be =
 		container_of(backend, struct drm_agp_ttm_backend, backend);
 	DRM_AGP_MEM *mem = agp_be->mem;
 
@@ -604,7 +604,7 @@ static void drm_agp_destroy_ttm(struct drm_ttm_backend *backend) {
 	}
 }
 
-static struct drm_ttm_backend_func agp_ttm_backend = 
+static struct drm_ttm_backend_func agp_ttm_backend =
 {
 	.needs_ub_cache_adjust = drm_agp_needs_unbind_cache_adjust,
 	.populate = drm_agp_populate,
@@ -637,7 +637,7 @@ struct drm_ttm_backend *drm_agp_init_ttm(struct drm_device *dev)
 		return NULL;
 	}
 
-	
+
 	agp_be = drm_ctl_calloc(1, sizeof(*agp_be), DRM_MEM_TTM);
 	if (!agp_be)
 		return NULL;
diff --git a/linux-core/drm_bo.c b/linux-core/drm_bo.c
index 4f95f236..4cdf8891 100644
--- a/linux-core/drm_bo.c
+++ b/linux-core/drm_bo.c
@@ -1537,7 +1537,7 @@ EXPORT_SYMBOL(drm_bo_do_validate);
 
 int drm_bo_handle_validate(struct drm_file * file_priv, uint32_t handle,
 			   uint32_t fence_class,
-			   uint64_t flags, uint64_t mask, 
+			   uint64_t flags, uint64_t mask,
 			   uint32_t hint,
 			   int use_old_fence_class,
 			   struct drm_bo_info_rep * rep,
@@ -1552,7 +1552,7 @@ int drm_bo_handle_validate(struct drm_file * file_priv, uint32_t handle,
 	bo = drm_lookup_buffer_object(file_priv, handle, 1);
 	mutex_unlock(&dev->struct_mutex);
 
-	if (!bo) 
+	if (!bo)
 		return -EINVAL;
 
 	if (use_old_fence_class)
@@ -1562,10 +1562,10 @@ int drm_bo_handle_validate(struct drm_file * file_priv, uint32_t handle,
 	 * Only allow creator to change shared buffer mask.
 	 */
 
-	if (bo->base.owner != file_priv) 
+	if (bo->base.owner != file_priv)
 		mask &= ~(DRM_BO_FLAG_NO_EVICT | DRM_BO_FLAG_NO_MOVE);
 
-		
+
 	ret = drm_bo_do_validate(bo, flags, mask, hint, fence_class,
 				 no_wait, rep);
 
@@ -1764,14 +1764,14 @@ int drm_bo_create_ioctl(struct drm_device *dev, void *data, struct drm_file *fil
 				       req->buffer_start, &entry);
 	if (ret)
 		goto out;
-	
+
 	ret = drm_bo_add_user_object(file_priv, entry,
 				     req->mask & DRM_BO_FLAG_SHAREABLE);
 	if (ret) {
 		drm_bo_usage_deref_unlocked(&entry);
 		goto out;
 	}
-	
+
 	mutex_lock(&entry->mutex);
 	drm_bo_fill_rep_arg(entry, rep);
 	mutex_unlock(&entry->mutex);
@@ -1780,7 +1780,7 @@ out:
 	return ret;
 }
 
-int drm_bo_setstatus_ioctl(struct drm_device *dev, 
+int drm_bo_setstatus_ioctl(struct drm_device *dev,
 			   void *data, struct drm_file *file_priv)
 {
 	struct drm_bo_map_wait_idle_arg *arg = data;
@@ -1861,7 +1861,7 @@ int drm_bo_reference_ioctl(struct drm_device *dev, void *data, struct drm_file *
 				  drm_buffer_type, &uo);
 	if (ret)
 		return ret;
-	
+
 	ret = drm_bo_handle_info(file_priv, req->handle, rep);
 	if (ret)
 		return ret;
@@ -2165,7 +2165,7 @@ EXPORT_SYMBOL(drm_bo_init_mm);
 /*
  * This function is intended to be called on drm driver unload.
  * If you decide to call it from lastclose, you must protect the call
- * from a potentially racing drm_bo_driver_init in firstopen. 
+ * from a potentially racing drm_bo_driver_init in firstopen.
  * (This may happen on X server restart).
  */
 
@@ -2229,7 +2229,7 @@ out:
 /*
  * This function is intended to be called on drm driver load.
  * If you decide to call it from firstopen, you must protect the call
- * from a potentially racing drm_bo_driver_finish in lastclose. 
+ * from a potentially racing drm_bo_driver_finish in lastclose.
  * (This may happen on X server restart).
  */
 
@@ -2390,13 +2390,13 @@ int drm_mm_lock_ioctl(struct drm_device *dev, void *data, struct drm_file *file_
 		DRM_ERROR("Lock flag DRM_BO_LOCK_IGNORE_NO_EVICT not supported yet.\n");
 		return -EINVAL;
 	}
-		
+
 	if (arg->lock_flags & DRM_BO_LOCK_UNLOCK_BM) {
 		ret = drm_bo_write_lock(&dev->bm.bm_lock, file_priv);
 		if (ret)
 			return ret;
 	}
-		
+
 	mutex_lock(&dev->struct_mutex);
 	ret = drm_bo_lock_mm(dev, arg->mem_type);
 	mutex_unlock(&dev->struct_mutex);
@@ -2408,8 +2408,8 @@ int drm_mm_lock_ioctl(struct drm_device *dev, void *data, struct drm_file *file_
 	return 0;
 }
 
-int drm_mm_unlock_ioctl(struct drm_device *dev, 
-			void *data, 
+int drm_mm_unlock_ioctl(struct drm_device *dev,
+			void *data,
 			struct drm_file *file_priv)
 {
 	struct drm_mm_type_arg *arg = data;
@@ -2426,7 +2426,7 @@ int drm_mm_unlock_ioctl(struct drm_device *dev,
 		if (ret)
 			return ret;
 	}
-		
+
 	return 0;
 }
 
@@ -2580,11 +2580,11 @@ static int drm_bo_setup_vm_locked(struct drm_buffer_object * bo)
 	return 0;
 }
 
-int drm_bo_version_ioctl(struct drm_device *dev, void *data, 
+int drm_bo_version_ioctl(struct drm_device *dev, void *data,
 			 struct drm_file *file_priv)
 {
 	struct drm_bo_version_arg *arg = (struct drm_bo_version_arg *)data;
-	
+
 	arg->major = DRM_BO_INIT_MAJOR;
 	arg->minor = DRM_BO_INIT_MINOR;
 	arg->patchlevel = DRM_BO_INIT_PATCH;
diff --git a/linux-core/drm_bo_lock.c b/linux-core/drm_bo_lock.c
index e5a86826..46318f6a 100644
--- a/linux-core/drm_bo_lock.c
+++ b/linux-core/drm_bo_lock.c
@@ -31,19 +31,19 @@
 /*
  * This file implements a simple replacement for the buffer manager use
  * of the heavyweight hardware lock.
- * The lock is a read-write lock. Taking it in read mode is fast, and 
+ * The lock is a read-write lock. Taking it in read mode is fast, and
  * intended for in-kernel use only.
  * Taking it in write mode is slow.
  *
- * The write mode is used only when there is a need to block all 
- * user-space processes from allocating a 
+ * The write mode is used only when there is a need to block all
+ * user-space processes from allocating a
  * new memory area.
  * Typical use in write mode is X server VT switching, and it's allowed
  * to leave kernel space with the write lock held. If a user-space process
  * dies while having the write-lock, it will be released during the file
  * descriptor release.
  *
- * The read lock is typically placed at the start of an IOCTL- or 
+ * The read lock is typically placed at the start of an IOCTL- or
  * user-space callable function that may end up allocating a memory area.
  * This includes setstatus, super-ioctls and no_pfn; the latter may move
  * unmappable regions to mappable. It's a bug to leave kernel space with the
@@ -53,7 +53,7 @@
  * latency. The locking functions will return -EAGAIN if interrupted by a
  * signal.
  *
- * Locking order: The lock should be taken BEFORE any kernel mutexes 
+ * Locking order: The lock should be taken BEFORE any kernel mutexes
  * or spinlocks.
  */
 
@@ -140,7 +140,7 @@ int drm_bo_write_lock(struct drm_bo_lock *lock, struct drm_file *file_priv)
 
 	/*
 	 * Add a dummy user-object, the destructor of which will
-	 * make sure the lock is released if the client dies 
+	 * make sure the lock is released if the client dies
 	 * while holding it.
 	 */
 
diff --git a/linux-core/drm_bo_move.c b/linux-core/drm_bo_move.c
index 7c86c4aa..9ab28b03 100644
--- a/linux-core/drm_bo_move.c
+++ b/linux-core/drm_bo_move.c
@@ -1,8 +1,8 @@
 /**************************************************************************
- * 
+ *
  * Copyright (c) 2007 Tungsten Graphics, Inc., Cedar Park, TX., USA
  * All Rights Reserved.
- * 
+ *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the
  * "Software"), to deal in the Software without restriction, including
@@ -10,7 +10,7 @@
  * distribute, sub license, and/or sell copies of the Software, and to
  * permit persons to whom the Software is furnished to do so, subject to
  * the following conditions:
- * 
+ *
  * The above copyright notice and this permission notice (including the
  * next paragraph) shall be included in all copies or substantial portions
  * of the Software.
@@ -19,8 +19,8 @@
  * 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 
+ * 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.
  *
  **************************************************************************/
@@ -90,13 +90,13 @@ EXPORT_SYMBOL(drm_bo_move_ttm);
  *
  * \param bo The buffer object.
  * \return Failure indication.
- * 
+ *
  * Returns -EINVAL if the buffer object is currently not mappable.
  * Returns -ENOMEM if the ioremap operation failed.
  * Otherwise returns zero.
- * 
+ *
  * After a successfull call, bo->iomap contains the virtual address, or NULL
- * if the buffer object content is not accessible through PCI space. 
+ * if the buffer object content is not accessible through PCI space.
  * Call bo->mutex locked.
  */
 
@@ -349,11 +349,11 @@ int drm_bo_move_accel_cleanup(struct drm_buffer_object * bo,
 #ifdef DRM_ODD_MM_COMPAT
 	/*
 	 * In this mode, we don't allow pipelining a copy blit,
-	 * since the buffer will be accessible from user space 
+	 * since the buffer will be accessible from user space
 	 * the moment we return and rebuild the page tables.
 	 *
 	 * With normal vm operation, page tables are rebuilt
-	 * on demand using fault(), which waits for buffer idle. 
+	 * on demand using fault(), which waits for buffer idle.
 	 */
 	if (1)
 #else
diff --git a/linux-core/drm_bufs.c b/linux-core/drm_bufs.c
index 60eca60c..65818c6f 100644
--- a/linux-core/drm_bufs.c
+++ b/linux-core/drm_bufs.c
@@ -53,7 +53,7 @@ struct drm_map_list *drm_find_matching_map(struct drm_device *dev, drm_local_map
 	struct drm_map_list *entry;
 	list_for_each_entry(entry, &dev->maplist, head) {
 		if (entry->map && map->type == entry->map->type &&
-		    ((entry->map->offset == map->offset) || 
+		    ((entry->map->offset == map->offset) ||
 		     (map->type == _DRM_SHM && map->flags==_DRM_CONTAINS_LOCK))) {
 			return entry;
 		}
@@ -80,10 +80,10 @@ static int drm_map_handle(struct drm_device *dev, struct drm_hash_item *hash,
 		int ret;
 		hash->key = user_token >> PAGE_SHIFT;
 		ret = drm_ht_insert_item(&dev->map_hash, hash);
-		if (ret != -EINVAL) 
+		if (ret != -EINVAL)
 			return ret;
 	}
-	return drm_ht_just_insert_please(&dev->map_hash, hash, 
+	return drm_ht_just_insert_please(&dev->map_hash, hash,
 					 user_token, 32 - PAGE_SHIFT - 3,
 					 0, DRM_MAP_HASH_OFFSET >> PAGE_SHIFT);
 }
@@ -297,7 +297,7 @@ static int drm_addmap_core(struct drm_device *dev, unsigned int offset,
 
 	/* Assign a 32-bit handle */
 
-	user_token = (map->type == _DRM_SHM) ? (unsigned long) map->handle : 
+	user_token = (map->type == _DRM_SHM) ? (unsigned long) map->handle :
 		map->offset;
 	ret = drm_map_handle(dev, &list->hash, user_token, 0);
 
@@ -379,7 +379,7 @@ int drm_rmmap_locked(struct drm_device *dev, drm_local_map_t *map)
 	list_for_each_entry_safe(r_list, list_t, &dev->maplist, head) {
 		if (r_list->map == map) {
 			list_del(&r_list->head);
-			drm_ht_remove_key(&dev->map_hash, 
+			drm_ht_remove_key(&dev->map_hash,
 					  r_list->user_token >> PAGE_SHIFT);
 			drm_free(r_list, sizeof(*r_list), DRM_MEM_MAPS);
 			found = 1;
@@ -821,9 +821,9 @@ int drm_addbufs_pci(struct drm_device *dev, struct drm_buf_desc * request)
 	page_count = 0;
 
 	while (entry->buf_count < count) {
-		
+
 		dmah = drm_pci_alloc(dev, PAGE_SIZE << page_order, 0x1000, 0xfffffffful);
-		
+
 		if (!dmah) {
 			/* Set count correctly so we free the proper amount. */
 			entry->buf_count = count;
@@ -1600,5 +1600,3 @@ int drm_order(unsigned long size)
 	return order;
 }
 EXPORT_SYMBOL(drm_order);
-
-
diff --git a/linux-core/drm_compat.c b/linux-core/drm_compat.c
index ae44e500..67c8c998 100644
--- a/linux-core/drm_compat.c
+++ b/linux-core/drm_compat.c
@@ -1,5 +1,5 @@
 /**************************************************************************
- * 
+ *
  * This kernel module is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License as
  * published by the Free Software Foundation; either version 2 of the
@@ -13,7 +13,7 @@
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- * 
+ *
  **************************************************************************/
 /*
  * This code provides access to unexported mm kernel features. It is necessary
@@ -21,7 +21,7 @@
  * directly.
  *
  * Authors: Thomas Hellstrom <thomas-at-tungstengraphics-dot-com>
- *          Linux kernel mm subsystem authors. 
+ *          Linux kernel mm subsystem authors.
  *          (Most code taken from there).
  */
 
@@ -50,7 +50,7 @@ int drm_unmap_page_from_agp(struct page *page)
          * performance reasons */
         return i;
 }
-#endif 
+#endif
 
 
 #if  (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,19))
@@ -80,22 +80,22 @@ pgprot_t vm_get_page_prot(unsigned long vm_flags)
 
 /*
  * vm code for kernels below 2.6.15 in which version a major vm write
- * occured. This implement a simple straightforward 
+ * occured. This implement a simple straightforward
  * version similar to what's going to be
  * in kernel 2.6.19+
  * Kernels below 2.6.15 use nopage whereas 2.6.19 and upwards use
  * nopfn.
- */ 
+ */
 
 static struct {
 	spinlock_t lock;
 	struct page *dummy_page;
 	atomic_t present;
-} drm_np_retry = 
+} drm_np_retry =
 {SPIN_LOCK_UNLOCKED, NOPAGE_OOM, ATOMIC_INIT(0)};
 
 
-static struct page *drm_bo_vm_fault(struct vm_area_struct *vma, 
+static struct page *drm_bo_vm_fault(struct vm_area_struct *vma,
 				    struct fault_data *data);
 
 
@@ -126,7 +126,7 @@ void free_nopage_retry(void)
 }
 
 struct page *drm_bo_vm_nopage(struct vm_area_struct *vma,
-			       unsigned long address, 
+			       unsigned long address,
 			       int *type)
 {
 	struct fault_data data;
@@ -204,14 +204,14 @@ static struct page *drm_bo_vm_fault(struct vm_area_struct *vma,
 	struct drm_buffer_object *bo = (struct drm_buffer_object *) vma->vm_private_data;
 	unsigned long page_offset;
 	struct page *page = NULL;
-	struct drm_ttm *ttm; 
+	struct drm_ttm *ttm;
 	struct drm_device *dev;
 	unsigned long pfn;
 	int err;
 	unsigned long bus_base;
 	unsigned long bus_offset;
 	unsigned long bus_size;
-	
+
 	dev = bo->dev;
 	while(drm_bo_read_lock(&dev->bm.bm_lock));
 
@@ -219,12 +219,12 @@ static struct page *drm_bo_vm_fault(struct vm_area_struct *vma,
 
 	err = drm_bo_wait(bo, 0, 1, 0);
 	if (err) {
-		data->type = (err == -EAGAIN) ? 
+		data->type = (err == -EAGAIN) ?
 			VM_FAULT_MINOR : VM_FAULT_SIGBUS;
 		goto out_unlock;
 	}
-	
-	
+
+
 	/*
 	 * If buffer happens to be in a non-mappable location,
 	 * move it to a mappable.
@@ -253,7 +253,7 @@ static struct page *drm_bo_vm_fault(struct vm_area_struct *vma,
 	}
 
 	dev = bo->dev;
-	err = drm_bo_pci_offset(dev, &bo->mem, &bus_base, &bus_offset, 
+	err = drm_bo_pci_offset(dev, &bo->mem, &bus_base, &bus_offset,
 				&bus_size);
 
 	if (err) {
@@ -286,7 +286,7 @@ static struct page *drm_bo_vm_fault(struct vm_area_struct *vma,
 	err = vm_insert_pfn(vma, address, pfn);
 
 	if (!err || err == -EBUSY)
-		data->type = VM_FAULT_MINOR; 
+		data->type = VM_FAULT_MINOR;
 	else
 		data->type = VM_FAULT_OOM;
 out_unlock:
@@ -330,7 +330,7 @@ unsigned long drm_bo_vm_nopfn(struct vm_area_struct * vma,
  * VM compatibility code for 2.6.15-2.6.18. This code implements a complicated
  * workaround for a single BUG statement in do_no_page in these versions. The
  * tricky thing is that we need to take the mmap_sem in exclusive mode for _all_
- * vmas mapping the ttm, before dev->struct_mutex is taken. The way we do this is to 
+ * vmas mapping the ttm, before dev->struct_mutex is taken. The way we do this is to
  * check first take the dev->struct_mutex, and then trylock all mmap_sems. If this
  * fails for a single mmap_sem, we have to release all sems and the dev->struct_mutex,
  * release the cpu and retry. We also need to keep track of all vmas mapping the ttm.
@@ -351,13 +351,13 @@ typedef struct vma_entry {
 
 
 struct page *drm_bo_vm_nopage(struct vm_area_struct *vma,
-			       unsigned long address, 
+			       unsigned long address,
 			       int *type)
 {
 	struct drm_buffer_object *bo = (struct drm_buffer_object *) vma->vm_private_data;
 	unsigned long page_offset;
 	struct page *page;
-	struct drm_ttm *ttm; 
+	struct drm_ttm *ttm;
 	struct drm_device *dev;
 
 	mutex_lock(&bo->mutex);
@@ -369,7 +369,7 @@ struct page *drm_bo_vm_nopage(struct vm_area_struct *vma,
 		page = NOPAGE_SIGBUS;
 		goto out_unlock;
 	}
-	
+
 	dev = bo->dev;
 
 	if (drm_mem_reg_is_pci(dev, &bo->mem)) {
@@ -403,8 +403,8 @@ int drm_bo_map_bound(struct vm_area_struct *vma)
 	unsigned long bus_base;
 	unsigned long bus_offset;
 	unsigned long bus_size;
-	
-	ret = drm_bo_pci_offset(bo->dev, &bo->mem, &bus_base, 
+
+	ret = drm_bo_pci_offset(bo->dev, &bo->mem, &bus_base,
 				&bus_offset, &bus_size);
 	BUG_ON(ret);
 
@@ -419,7 +419,7 @@ int drm_bo_map_bound(struct vm_area_struct *vma)
 
 	return ret;
 }
-	
+
 
 int drm_bo_add_vma(struct drm_buffer_object * bo, struct vm_area_struct *vma)
 {
@@ -493,7 +493,7 @@ int drm_bo_lock_kmm(struct drm_buffer_object * bo)
 {
 	p_mm_entry_t *entry;
 	int lock_ok = 1;
-	
+
 	list_for_each_entry(entry, &bo->p_mm_list, head) {
 		BUG_ON(entry->locked);
 		if (!down_write_trylock(&entry->mm->mmap_sem)) {
@@ -507,7 +507,7 @@ int drm_bo_lock_kmm(struct drm_buffer_object * bo)
 		return 0;
 
 	list_for_each_entry(entry, &bo->p_mm_list, head) {
-		if (!entry->locked) 
+		if (!entry->locked)
 			break;
 		up_write(&entry->mm->mmap_sem);
 		entry->locked = 0;
@@ -524,7 +524,7 @@ int drm_bo_lock_kmm(struct drm_buffer_object * bo)
 void drm_bo_unlock_kmm(struct drm_buffer_object * bo)
 {
 	p_mm_entry_t *entry;
-	
+
 	list_for_each_entry(entry, &bo->p_mm_list, head) {
 		BUG_ON(!entry->locked);
 		up_write(&entry->mm->mmap_sem);
@@ -532,7 +532,7 @@ void drm_bo_unlock_kmm(struct drm_buffer_object * bo)
 	}
 }
 
-int drm_bo_remap_bound(struct drm_buffer_object *bo) 
+int drm_bo_remap_bound(struct drm_buffer_object *bo)
 {
 	vma_entry_t *v_entry;
 	int ret = 0;
@@ -553,9 +553,9 @@ void drm_bo_finish_unmap(struct drm_buffer_object *bo)
 	vma_entry_t *v_entry;
 
 	list_for_each_entry(v_entry, &bo->vma_list, head) {
-		v_entry->vma->vm_flags &= ~VM_PFNMAP; 
+		v_entry->vma->vm_flags &= ~VM_PFNMAP;
 	}
-}	
+}
 
 #endif
 
diff --git a/linux-core/drm_compat.h b/linux-core/drm_compat.h
index f74f4bc2..f8933e0c 100644
--- a/linux-core/drm_compat.h
+++ b/linux-core/drm_compat.h
@@ -89,7 +89,7 @@
 #define __user
 #endif
 
-#if !defined(__put_page) 
+#if !defined(__put_page)
 #define __put_page(p)           atomic_dec(&(p)->count)
 #endif
 
@@ -104,7 +104,7 @@
 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,10)
 static inline int remap_pfn_range(struct vm_area_struct *vma, unsigned long from, unsigned long pfn, unsigned long size, pgprot_t pgprot)
 {
-  return remap_page_range(vma, from, 
+  return remap_page_range(vma, from,
 			  pfn << PAGE_SHIFT,
 			  size,
 			  pgprot);
@@ -178,7 +178,7 @@ static __inline__ void *kcalloc(size_t nmemb, size_t size, int flags)
 
 
 /*
- * Flush relevant caches and clear a VMA structure so that page references 
+ * Flush relevant caches and clear a VMA structure so that page references
  * will cause a page fault. Don't flush tlbs.
  */
 
@@ -186,7 +186,7 @@ extern void drm_clear_vma(struct vm_area_struct *vma,
 			  unsigned long addr, unsigned long end);
 
 /*
- * Return the PTE protection map entries for the VMA flags given by 
+ * Return the PTE protection map entries for the VMA flags given by
  * flags. This is a functional interface to the kernel's protection map.
  */
 
@@ -223,7 +223,7 @@ extern void free_nopage_retry(void);
 #ifndef DRM_FULL_MM_COMPAT
 
 /*
- * For now, just return a dummy page that we've allocated out of 
+ * For now, just return a dummy page that we've allocated out of
  * static space. The page will be put by do_nopage() since we've already
  * filled out the pte.
  */
@@ -233,13 +233,13 @@ struct fault_data {
 	unsigned long address;
 	pgoff_t pgoff;
 	unsigned int flags;
-	
+
 	int type;
 };
 
 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,19))
 extern struct page *drm_bo_vm_nopage(struct vm_area_struct *vma,
-				     unsigned long address, 
+				     unsigned long address,
 				     int *type);
 #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,19)) && \
   !defined(DRM_FULL_MM_COMPAT)
@@ -254,22 +254,22 @@ struct drm_buffer_object;
 
 
 /*
- * Add a vma to the ttm vma list, and the 
+ * Add a vma to the ttm vma list, and the
  * process mm pointer to the ttm mm list. Needs the ttm mutex.
  */
 
-extern int drm_bo_add_vma(struct drm_buffer_object * bo, 
+extern int drm_bo_add_vma(struct drm_buffer_object * bo,
 			   struct vm_area_struct *vma);
 /*
  * Delete a vma and the corresponding mm pointer from the
  * ttm lists. Needs the ttm mutex.
  */
-extern void drm_bo_delete_vma(struct drm_buffer_object * bo, 
+extern void drm_bo_delete_vma(struct drm_buffer_object * bo,
 			      struct vm_area_struct *vma);
 
 /*
  * Attempts to lock all relevant mmap_sems for a ttm, while
- * not releasing the ttm mutex. May return -EAGAIN to avoid 
+ * not releasing the ttm mutex. May return -EAGAIN to avoid
  * deadlocks. In that case the caller shall release the ttm mutex,
  * schedule() and try again.
  */
@@ -292,7 +292,7 @@ extern void drm_bo_unlock_kmm(struct drm_buffer_object * bo);
 extern void drm_bo_finish_unmap(struct drm_buffer_object *bo);
 
 /*
- * Remap all vmas of this ttm using io_remap_pfn_range. We cannot 
+ * Remap all vmas of this ttm using io_remap_pfn_range. We cannot
  * fault these pfns in, because the first one will set the vma VM_PFNMAP
  * flag, which will make the next fault bug in do_nopage(). The function
  * releases the mmap_sems for this ttm.
diff --git a/linux-core/drm_context.c b/linux-core/drm_context.c
index 7854e89c..83ad291e 100644
--- a/linux-core/drm_context.c
+++ b/linux-core/drm_context.c
@@ -89,7 +89,7 @@ again:
 		mutex_unlock(&dev->struct_mutex);
 		goto again;
 	}
-	
+
 	mutex_unlock(&dev->struct_mutex);
 	return new_id;
 }
@@ -160,7 +160,7 @@ int drm_getsareactx(struct drm_device *dev, void *data,
 	request->handle = NULL;
 	list_for_each_entry(_entry, &dev->maplist, head) {
 		if (_entry->map == map) {
-			request->handle = 
+			request->handle =
 			    (void *)(unsigned long)_entry->user_token;
 			break;
 		}
diff --git a/linux-core/drm_drv.c b/linux-core/drm_drv.c
index 47d17651..bba84143 100644
--- a/linux-core/drm_drv.c
+++ b/linux-core/drm_drv.c
@@ -123,13 +123,13 @@ static struct drm_ioctl_desc drm_ioctls[] = {
 	DRM_IOCTL_DEF(DRM_IOCTL_UPDATE_DRAW, drm_update_drawable_info, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
 
 
-	DRM_IOCTL_DEF(DRM_IOCTL_MM_INIT, drm_mm_init_ioctl, 
+	DRM_IOCTL_DEF(DRM_IOCTL_MM_INIT, drm_mm_init_ioctl,
 		      DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
-	DRM_IOCTL_DEF(DRM_IOCTL_MM_TAKEDOWN, drm_mm_takedown_ioctl, 
+	DRM_IOCTL_DEF(DRM_IOCTL_MM_TAKEDOWN, drm_mm_takedown_ioctl,
 		      DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
-	DRM_IOCTL_DEF(DRM_IOCTL_MM_LOCK, drm_mm_lock_ioctl, 
+	DRM_IOCTL_DEF(DRM_IOCTL_MM_LOCK, drm_mm_lock_ioctl,
 		      DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
-	DRM_IOCTL_DEF(DRM_IOCTL_MM_UNLOCK, drm_mm_unlock_ioctl, 
+	DRM_IOCTL_DEF(DRM_IOCTL_MM_UNLOCK, drm_mm_unlock_ioctl,
 		      DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
 
 	DRM_IOCTL_DEF(DRM_IOCTL_FENCE_CREATE, drm_fence_create_ioctl, DRM_AUTH),
@@ -244,7 +244,7 @@ int drm_lastclose(struct drm_device * dev)
 		list_del(&vma->head);
 		drm_ctl_free(vma, sizeof(*vma), DRM_MEM_VMAS);
 	}
-	
+
 	list_for_each_entry_safe(r_list, list_t, &dev->maplist, head) {
 		drm_rmmap_locked(dev, r_list->map);
 		r_list = NULL;
@@ -324,7 +324,7 @@ int drm_init(struct drm_driver *driver,
 			pci_get_subsys(pid->vendor, pid->device, pid->subvendor,
 				       pid->subdevice, pdev))) {
 			/* Are there device class requirements? */
-			if ((pid->class != 0) 
+			if ((pid->class != 0)
 				&& ((pdev->class & pid->class_mask) != pid->class)) {
 				continue;
 			}
@@ -355,7 +355,7 @@ int drm_init(struct drm_driver *driver,
 					       pid->subvendor, pid->subdevice,
 					       pdev))) {
 				/* Are there device class requirements? */
-				if ((pid->class != 0) 
+				if ((pid->class != 0)
 					&& ((pdev->class & pid->class_mask) != pid->class)) {
 					continue;
 				}
@@ -469,19 +469,19 @@ static int __init drm_core_init(void)
 	unsigned long max_memctl_mem;
 
 	si_meminfo(&si);
-	
+
 	/*
 	 * AGP only allows low / DMA32 memory ATM.
 	 */
 
 	avail_memctl_mem = si.totalram - si.totalhigh;
 
-	/* 
-	 * Avoid overflows 
+	/*
+	 * Avoid overflows
 	 */
 
 	max_memctl_mem = 1UL << (32 - PAGE_SHIFT);
-	max_memctl_mem = (max_memctl_mem / si.mem_unit) * PAGE_SIZE; 
+	max_memctl_mem = (max_memctl_mem / si.mem_unit) * PAGE_SIZE;
 
 	if (avail_memctl_mem >= max_memctl_mem)
 		avail_memctl_mem = max_memctl_mem;
diff --git a/linux-core/drm_fence.c b/linux-core/drm_fence.c
index e696b42d..d09efeb4 100644
--- a/linux-core/drm_fence.c
+++ b/linux-core/drm_fence.c
@@ -127,7 +127,7 @@ void drm_fence_handler(struct drm_device * dev, uint32_t fence_class,
 		list_for_each_entry(fence, head, ring) {
 			if (&fence->ring == &fc->ring)
 				break;
-	    		diff = (fc->last_exe_flush - fence->sequence) &
+			diff = (fc->last_exe_flush - fence->sequence) &
 				driver->sequence_mask;
 			if (diff > driver->wrap_diff)
 				break;
@@ -497,7 +497,7 @@ static int drm_fence_object_init(struct drm_device * dev, uint32_t fence_class,
 	write_lock_irqsave(&fm->lock, flags);
 	INIT_LIST_HEAD(&fence->ring);
 
-	/* 
+	/*
 	 *  Avoid hitting BUG() for kernel-only fence objects.
 	 */
 
@@ -656,7 +656,7 @@ int drm_fence_create_ioctl(struct drm_device *dev, void *data, struct drm_file *
 		drm_fence_usage_deref_unlocked(&fence);
 		return ret;
 	}
-	
+
 	/*
 	 * usage > 0. No need to lock dev->struct_mutex;
 	 */
diff --git a/linux-core/drm_fops.c b/linux-core/drm_fops.c
index 0ccaed5b..4d0d6be0 100644
--- a/linux-core/drm_fops.c
+++ b/linux-core/drm_fops.c
@@ -528,4 +528,3 @@ unsigned int drm_poll(struct file *filp, struct poll_table_struct *wait)
 	return 0;
 }
 EXPORT_SYMBOL(drm_poll);
-
diff --git a/linux-core/drm_hashtab.c b/linux-core/drm_hashtab.c
index a8ec8468..dacc83be 100644
--- a/linux-core/drm_hashtab.c
+++ b/linux-core/drm_hashtab.c
@@ -128,7 +128,7 @@ int drm_ht_insert_item(struct drm_open_hash * ht, struct drm_hash_item * item)
 }
 
 /*
- * Just insert an item and return any "bits" bit key that hasn't been 
+ * Just insert an item and return any "bits" bit key that hasn't been
  * used before.
  */
 int drm_ht_just_insert_please(struct drm_open_hash * ht, struct drm_hash_item * item,
diff --git a/linux-core/drm_hashtab.h b/linux-core/drm_hashtab.h
index 0f137677..c090677b 100644
--- a/linux-core/drm_hashtab.h
+++ b/linux-core/drm_hashtab.h
@@ -65,4 +65,3 @@ extern void drm_ht_remove(struct drm_open_hash *ht);
 
 
 #endif
-
diff --git a/linux-core/drm_mm.c b/linux-core/drm_mm.c
index cf0d92fa..59110293 100644
--- a/linux-core/drm_mm.c
+++ b/linux-core/drm_mm.c
@@ -235,12 +235,12 @@ struct drm_mm_node *drm_mm_search_free(const struct drm_mm * mm,
 		entry = list_entry(list, struct drm_mm_node, fl_entry);
 		wasted = 0;
 
-		if (entry->size < size) 
+		if (entry->size < size)
 			continue;
 
 		if (alignment) {
 			register unsigned tmp = entry->start % alignment;
-			if (tmp) 
+			if (tmp)
 				wasted += alignment - tmp;
 		}
 
diff --git a/linux-core/drm_objects.h b/linux-core/drm_objects.h
index 0a05e5fe..c9c1fdb8 100644
--- a/linux-core/drm_objects.h
+++ b/linux-core/drm_objects.h
@@ -628,7 +628,7 @@ extern void drm_regs_init(struct drm_reg_manager *manager,
 			  void (*reg_destroy)(struct drm_reg *));
 
 /*
- * drm_bo_lock.c 
+ * drm_bo_lock.c
  * Simple replacement for the hardware lock on buffer manager init and clean.
  */
 
@@ -636,10 +636,10 @@ extern void drm_regs_init(struct drm_reg_manager *manager,
 extern void drm_bo_init_lock(struct drm_bo_lock *lock);
 extern void drm_bo_read_unlock(struct drm_bo_lock *lock);
 extern int drm_bo_read_lock(struct drm_bo_lock *lock);
-extern int drm_bo_write_lock(struct drm_bo_lock *lock, 
+extern int drm_bo_write_lock(struct drm_bo_lock *lock,
 			     struct drm_file *file_priv);
 
-extern int drm_bo_write_unlock(struct drm_bo_lock *lock, 
+extern int drm_bo_write_unlock(struct drm_bo_lock *lock,
 			       struct drm_file *file_priv);
 
 #ifdef CONFIG_DEBUG_MUTEXES
diff --git a/linux-core/drm_os_linux.h b/linux-core/drm_os_linux.h
index 84c294e1..8921944e 100644
--- a/linux-core/drm_os_linux.h
+++ b/linux-core/drm_os_linux.h
@@ -92,9 +92,9 @@ static __inline__ int mtrr_del(int reg, unsigned long base, unsigned long size)
 #define DRM_COPY_TO_USER(arg1, arg2, arg3)		\
 	copy_to_user(arg1, arg2, arg3)
 /* Macros for copyfrom user, but checking readability only once */
-#define DRM_VERIFYAREA_READ( uaddr, size ) 		\
+#define DRM_VERIFYAREA_READ( uaddr, size )		\
 	(access_ok( VERIFY_READ, uaddr, size) ? 0 : -EFAULT)
-#define DRM_COPY_FROM_USER_UNCHECKED(arg1, arg2, arg3) 	\
+#define DRM_COPY_FROM_USER_UNCHECKED(arg1, arg2, arg3)	\
 	__copy_from_user(arg1, arg2, arg3)
 #define DRM_COPY_TO_USER_UNCHECKED(arg1, arg2, arg3)	\
 	__copy_to_user(arg1, arg2, arg3)
@@ -143,4 +143,3 @@ do {								\
 #define DRM_SPINLOCK_IRQSAVE(l, _flags)	spin_lock_irqsave(l, _flags);
 #define DRM_SPINUNLOCK_IRQRESTORE(l, _flags) spin_unlock_irqrestore(l, _flags);
 #define DRM_SPINLOCK_ASSERT(l)		do {} while (0)
-
diff --git a/linux-core/drm_scatter.c b/linux-core/drm_scatter.c
index 3c0f672e..920b11c8 100644
--- a/linux-core/drm_scatter.c
+++ b/linux-core/drm_scatter.c
@@ -126,7 +126,7 @@ int drm_sg_alloc(struct drm_device *dev, struct drm_scatter_gather * request)
 	DRM_DEBUG("sg alloc handle  = %08lx\n", entry->handle);
 	DRM_DEBUG("sg alloc virtual = %p\n", entry->virtual);
 
-	for (i = (unsigned long)entry->virtual, j = 0; j < pages; 
+	for (i = (unsigned long)entry->virtual, j = 0; j < pages;
 	     i += PAGE_SIZE, j++) {
 		entry->pagelist[j] = vmalloc_to_page((void *)i);
 		if (!entry->pagelist[j])
diff --git a/linux-core/drm_stub.c b/linux-core/drm_stub.c
index dabd174b..401704f7 100644
--- a/linux-core/drm_stub.c
+++ b/linux-core/drm_stub.c
@@ -75,7 +75,7 @@ static int drm_fill_in_dev(struct drm_device * dev, struct pci_dev *pdev,
 	mutex_init(&dev->bm.evict_mutex);
 
 	idr_init(&dev->drw_idr);
-	
+
 	dev->pdev = pdev;
 	dev->pci_device = pdev->device;
 	dev->pci_vendor = pdev->vendor;
diff --git a/linux-core/ffb_drv.h b/linux-core/ffb_drv.h
index bad3c94d..f961ba47 100644
--- a/linux-core/ffb_drv.h
+++ b/linux-core/ffb_drv.h
@@ -124,7 +124,7 @@ typedef struct _ffb_fbc {
 /*294*/	volatile unsigned int	xpmask;		/* X PlaneMask				*/
 /*298*/	volatile unsigned int	ypmask;		/* Y PlaneMask				*/
 /*29c*/	volatile unsigned int	zpmask;		/* Z PlaneMask				*/
-/*2a0*/	ffb_auxclip		auxclip[4]; 	/* Auxilliary Viewport Clip		*/
+/*2a0*/	ffb_auxclip		auxclip[4];	/* Auxilliary Viewport Clip		*/
 
 	/* New 3dRAM III support regs */
 /*2c0*/	volatile unsigned int	rawblend2;
@@ -266,7 +266,7 @@ typedef struct ffb_dev_priv {
 	int			prom_node;
 	enum ffb_chip_type	ffb_type;
 	u64			card_phys_base;
-	struct miscdevice 	miscdev;
+	struct miscdevice	miscdev;
 
 	/* Controller registers. */
 	ffb_fbcPtr		regs;
diff --git a/linux-core/i810_dma.c b/linux-core/i810_dma.c
index 7c37b4bb..949355aa 100644
--- a/linux-core/i810_dma.c
+++ b/linux-core/i810_dma.c
@@ -41,7 +41,7 @@
 
 #define I810_BUF_FREE		2
 #define I810_BUF_CLIENT		1
-#define I810_BUF_HARDWARE      	0
+#define I810_BUF_HARDWARE	0
 
 #define I810_BUF_UNMAPPED 0
 #define I810_BUF_MAPPED   1
@@ -867,7 +867,7 @@ static void i810_dma_quiescent(struct drm_device * dev)
 	drm_i810_private_t *dev_priv = dev->dev_private;
 	RING_LOCALS;
 
-/*  	printk("%s\n", __FUNCTION__); */
+/*	printk("%s\n", __FUNCTION__); */
 
 	i810_kernel_lost_context(dev);
 
@@ -888,7 +888,7 @@ static int i810_flush_queue(struct drm_device * dev)
 	int i, ret = 0;
 	RING_LOCALS;
 
-/*  	printk("%s\n", __FUNCTION__); */
+/*	printk("%s\n", __FUNCTION__); */
 
 	i810_kernel_lost_context(dev);
 
diff --git a/linux-core/i810_drv.h b/linux-core/i810_drv.h
index c525e165..86278e3d 100644
--- a/linux-core/i810_drv.h
+++ b/linux-core/i810_drv.h
@@ -25,7 +25,7 @@
  * DEALINGS IN THE SOFTWARE.
  *
  * Authors: Rickard E. (Rik) Faith <faith@valinux.com>
- * 	    Jeff Hartmann <jhartmann@valinux.com>
+ *	    Jeff Hartmann <jhartmann@valinux.com>
  *
  */
 
@@ -134,7 +134,7 @@ extern int i810_max_ioctl;
 #define I810_ADDR(reg)		(I810_BASE(reg) + reg)
 #define I810_DEREF(reg)		*(__volatile__ int *)I810_ADDR(reg)
 #define I810_READ(reg)		I810_DEREF(reg)
-#define I810_WRITE(reg,val) 	do { I810_DEREF(reg) = val; } while (0)
+#define I810_WRITE(reg,val)	do { I810_DEREF(reg) = val; } while (0)
 #define I810_DEREF16(reg)	*(__volatile__ u16 *)I810_ADDR(reg)
 #define I810_READ16(reg)	I810_DEREF16(reg)
 #define I810_WRITE16(reg,val)	do { I810_DEREF16(reg) = val; } while (0)
@@ -155,19 +155,19 @@ extern int i810_max_ioctl;
 } while (0)
 
 #define ADVANCE_LP_RING() do {					\
-	if (I810_VERBOSE) DRM_DEBUG("ADVANCE_LP_RING\n");    	\
+	if (I810_VERBOSE) DRM_DEBUG("ADVANCE_LP_RING\n");	\
 	dev_priv->ring.tail = outring;				\
 	I810_WRITE(LP_RING + RING_TAIL, outring);		\
 } while(0)
 
-#define OUT_RING(n) do {  						\
+#define OUT_RING(n) do {						\
 	if (I810_VERBOSE) DRM_DEBUG("   OUT_RING %x\n", (int)(n));	\
 	*(volatile unsigned int *)(virt + outring) = n;			\
 	outring += 4;							\
 	outring &= ringmask;						\
 } while (0)
 
-#define GFX_OP_USER_INTERRUPT 		((0<<29)|(2<<23))
+#define GFX_OP_USER_INTERRUPT		((0<<29)|(2<<23))
 #define GFX_OP_BREAKPOINT_INTERRUPT	((0<<29)|(1<<23))
 #define CMD_REPORT_HEAD			(7<<23)
 #define CMD_STORE_DWORD_IDX		((0x21<<23) | 0x1)
@@ -184,28 +184,28 @@ extern int i810_max_ioctl;
 
 #define I810REG_HWSTAM		0x02098
 #define I810REG_INT_IDENTITY_R	0x020a4
-#define I810REG_INT_MASK_R 	0x020a8
+#define I810REG_INT_MASK_R	0x020a8
 #define I810REG_INT_ENABLE_R	0x020a0
 
-#define LP_RING     		0x2030
-#define HP_RING     		0x2040
-#define RING_TAIL      		0x00
+#define LP_RING			0x2030
+#define HP_RING			0x2040
+#define RING_TAIL		0x00
 #define TAIL_ADDR		0x000FFFF8
-#define RING_HEAD      		0x04
-#define HEAD_WRAP_COUNT     	0xFFE00000
-#define HEAD_WRAP_ONE       	0x00200000
-#define HEAD_ADDR           	0x001FFFFC
-#define RING_START     		0x08
-#define START_ADDR        	0x00FFFFF8
-#define RING_LEN       		0x0C
-#define RING_NR_PAGES       	0x000FF000
-#define RING_REPORT_MASK    	0x00000006
-#define RING_REPORT_64K     	0x00000002
-#define RING_REPORT_128K    	0x00000004
-#define RING_NO_REPORT      	0x00000000
-#define RING_VALID_MASK     	0x00000001
-#define RING_VALID          	0x00000001
-#define RING_INVALID        	0x00000000
+#define RING_HEAD		0x04
+#define HEAD_WRAP_COUNT		0xFFE00000
+#define HEAD_WRAP_ONE		0x00200000
+#define HEAD_ADDR		0x001FFFFC
+#define RING_START		0x08
+#define START_ADDR		0x00FFFFF8
+#define RING_LEN		0x0C
+#define RING_NR_PAGES		0x000FF000
+#define RING_REPORT_MASK	0x00000006
+#define RING_REPORT_64K		0x00000002
+#define RING_REPORT_128K	0x00000004
+#define RING_NO_REPORT		0x00000000
+#define RING_VALID_MASK		0x00000001
+#define RING_VALID		0x00000001
+#define RING_INVALID		0x00000000
 
 #define GFX_OP_SCISSOR         ((0x3<<29)|(0x1c<<24)|(0x10<<19))
 #define SC_UPDATE_SCISSOR       (0x1<<1)
diff --git a/linux-core/i915_buffer.c b/linux-core/i915_buffer.c
index bbc7e1db..1f88a513 100644
--- a/linux-core/i915_buffer.c
+++ b/linux-core/i915_buffer.c
@@ -1,8 +1,8 @@
 /**************************************************************************
- * 
+ *
  * Copyright 2006 Tungsten Graphics, Inc., Bismarck, ND., USA
  * All Rights Reserved.
- * 
+ *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the
  * "Software"), to deal in the Software without restriction, including
@@ -10,20 +10,20 @@
  * distribute, sub license, and/or sell copies of the Software, and to
  * permit persons to whom the Software is furnished to do so, subject to
  * the following conditions:
- * 
+ *
  * 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 
+ * 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.
  *
  * The above copyright notice and this permission notice (including the
  * next paragraph) shall be included in all copies or substantial portions
  * of the Software.
- * 
- * 
+ *
+ *
  **************************************************************************/
 /*
  * Authors: Thomas Hellström <thomas-at-tungstengraphics-dot-com>
@@ -183,7 +183,7 @@ static int i915_move_blit(struct drm_buffer_object * bo,
 }
 
 /*
- * Flip destination ttm into cached-coherent AGP, 
+ * Flip destination ttm into cached-coherent AGP,
  * then blit and subsequently move out again.
  */
 
@@ -258,7 +258,7 @@ static inline void clflush(volatile void *__p)
 #endif
 
 static inline void drm_cache_flush_addr(void *virt)
-{ 
+{
         int i;
 
 	for (i = 0; i < PAGE_SIZE; i += boot_cpu_data.x86_clflush_size)
diff --git a/linux-core/i915_compat.c b/linux-core/i915_compat.c
index 969d5977..3a437a1c 100644
--- a/linux-core/i915_compat.c
+++ b/linux-core/i915_compat.c
@@ -91,7 +91,7 @@ static void intel_i965_g33_setup_chipset_flush(struct pci_dev *pdev)
 		pci_write_config_dword(pdev, I965_IFPADDR, (intel_private.ifp_resource.start & 0xffffffff) | 0x1);
 	} else {
 		u64 l64;
-		
+
 		temp_lo &= ~0x1;
 		l64 = ((u64)temp_hi << 32) | temp_lo;
 
diff --git a/linux-core/i915_drv.c b/linux-core/i915_drv.c
index 124db68f..798491ae 100644
--- a/linux-core/i915_drv.c
+++ b/linux-core/i915_drv.c
@@ -1,10 +1,10 @@
 /* i915_drv.c -- i830,i845,i855,i865,i915 driver -*- linux-c -*-
  */
 /*
- * 
+ *
  * Copyright 2003 Tungsten Graphics, Inc., Cedar Park, Texas.
  * All Rights Reserved.
- * 
+ *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the
  * "Software"), to deal in the Software without restriction, including
@@ -12,11 +12,11 @@
  * distribute, sub license, and/or sell copies of the Software, and to
  * permit persons to whom the Software is furnished to do so, subject to
  * the following conditions:
- * 
+ *
  * The above copyright notice and this permission notice (including the
  * next paragraph) shall be included in all copies or substantial portions
  * of the Software.
- * 
+ *
  * 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.
@@ -24,7 +24,7 @@
  * 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.
- * 
+ *
  */
 
 #include "drmP.h"
@@ -420,7 +420,7 @@ static int i915_resume(struct drm_device *dev)
 	I915_WRITE(VBLANK_A, dev_priv->saveVBLANK_A);
 	I915_WRITE(VSYNC_A, dev_priv->saveVSYNC_A);
 	I915_WRITE(BCLRPAT_A, dev_priv->saveBCLRPAT_A);
-   
+
 	/* Restore plane info */
 	I915_WRITE(DSPASIZE, dev_priv->saveDSPASIZE);
 	I915_WRITE(DSPAPOS, dev_priv->saveDSPAPOS);
@@ -451,7 +451,7 @@ static int i915_resume(struct drm_device *dev)
 	if (IS_I965G(dev))
 		I915_WRITE(DPLL_B_MD, dev_priv->saveDPLL_B_MD);
 	udelay(150);
-   
+
 	/* Restore mode */
 	I915_WRITE(HTOTAL_B, dev_priv->saveHTOTAL_B);
 	I915_WRITE(HBLANK_B, dev_priv->saveHBLANK_B);
diff --git a/linux-core/i915_fence.c b/linux-core/i915_fence.c
index a0f22785..f2c29828 100644
--- a/linux-core/i915_fence.c
+++ b/linux-core/i915_fence.c
@@ -1,8 +1,8 @@
 /**************************************************************************
- * 
+ *
  * Copyright 2006 Tungsten Graphics, Inc., Bismarck, ND., USA
  * All Rights Reserved.
- * 
+ *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the
  * "Software"), to deal in the Software without restriction, including
@@ -10,20 +10,20 @@
  * distribute, sub license, and/or sell copies of the Software, and to
  * permit persons to whom the Software is furnished to do so, subject to
  * the following conditions:
- * 
+ *
  * 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 
+ * 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.
  *
  * The above copyright notice and this permission notice (including the
  * next paragraph) shall be included in all copies or substantial portions
  * of the Software.
- * 
- * 
+ *
+ *
  **************************************************************************/
 /*
  * Authors: Thomas Hellström <thomas-at-tungstengraphics-dot-com>
@@ -70,7 +70,7 @@ static void i915_perform_flush(struct drm_device * dev)
 		if (dev_priv->fence_irq_on && !fc->pending_exe_flush) {
 			i915_user_irq_off(dev_priv);
 			dev_priv->fence_irq_on = 0;
-		} else if (!dev_priv->fence_irq_on && fc->pending_exe_flush) { 
+		} else if (!dev_priv->fence_irq_on && fc->pending_exe_flush) {
 			i915_user_irq_on(dev_priv);
 			dev_priv->fence_irq_on = 1;
 		}
diff --git a/linux-core/i915_ioc32.c b/linux-core/i915_ioc32.c
index c1e776b7..7e733d33 100644
--- a/linux-core/i915_ioc32.c
+++ b/linux-core/i915_ioc32.c
@@ -3,7 +3,7 @@
  *
  * 32-bit ioctl compatibility routines for the i915 DRM.
  *
- * \author Alan Hourihane <alanh@fairlite.demon.co.uk> 
+ * \author Alan Hourihane <alanh@fairlite.demon.co.uk>
  *
  *
  * Copyright (C) Paul Mackerras 2005
@@ -49,11 +49,11 @@ static int compat_i915_batchbuffer(struct file *file, unsigned int cmd,
 {
 	drm_i915_batchbuffer32_t batchbuffer32;
 	drm_i915_batchbuffer_t __user *batchbuffer;
-	
+
 	if (copy_from_user
 	    (&batchbuffer32, (void __user *)arg, sizeof(batchbuffer32)))
 		return -EFAULT;
-	
+
 	batchbuffer = compat_alloc_user_space(sizeof(*batchbuffer));
 	if (!access_ok(VERIFY_WRITE, batchbuffer, sizeof(*batchbuffer))
 	    || __put_user(batchbuffer32.start, &batchbuffer->start)
@@ -65,7 +65,7 @@ static int compat_i915_batchbuffer(struct file *file, unsigned int cmd,
 	    || __put_user((int __user *)(unsigned long)batchbuffer32.cliprects,
 			  &batchbuffer->cliprects))
 		return -EFAULT;
-	
+
 	return drm_ioctl(file->f_dentry->d_inode, file,
 			 DRM_IOCTL_I915_BATCHBUFFER,
 			 (unsigned long) batchbuffer);
@@ -85,11 +85,11 @@ static int compat_i915_cmdbuffer(struct file *file, unsigned int cmd,
 {
 	drm_i915_cmdbuffer32_t cmdbuffer32;
 	drm_i915_cmdbuffer_t __user *cmdbuffer;
-	
+
 	if (copy_from_user
 	    (&cmdbuffer32, (void __user *)arg, sizeof(cmdbuffer32)))
 		return -EFAULT;
-	
+
 	cmdbuffer = compat_alloc_user_space(sizeof(*cmdbuffer));
 	if (!access_ok(VERIFY_WRITE, cmdbuffer, sizeof(*cmdbuffer))
 	    || __put_user((int __user *)(unsigned long)cmdbuffer32.buf,
@@ -101,7 +101,7 @@ static int compat_i915_cmdbuffer(struct file *file, unsigned int cmd,
 	    || __put_user((int __user *)(unsigned long)cmdbuffer32.cliprects,
 			  &cmdbuffer->cliprects))
 		return -EFAULT;
-	
+
 	return drm_ioctl(file->f_dentry->d_inode, file,
 			 DRM_IOCTL_I915_CMDBUFFER, (unsigned long) cmdbuffer);
 }
@@ -208,7 +208,7 @@ long i915_compat_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
 
 	if (nr < DRM_COMMAND_BASE)
 		return drm_compat_ioctl(filp, cmd, arg);
-	
+
 	if (nr < DRM_COMMAND_BASE + DRM_ARRAY_SIZE(i915_compat_ioctls))
 		fn = i915_compat_ioctls[nr - DRM_COMMAND_BASE];
 
diff --git a/linux-core/mga_drv.c b/linux-core/mga_drv.c
index 1eb6d9e6..e3d26a08 100644
--- a/linux-core/mga_drv.c
+++ b/linux-core/mga_drv.c
@@ -140,7 +140,7 @@ static int mga_driver_device_is_agp(struct drm_device * dev)
 	 * device is 0x0021 (HB6 Universal PCI-PCI bridge), we reject the
 	 * device.
 	 */
-	
+
 	if ((pdev->device == 0x0525) && pdev->bus->self
 	     && (pdev->bus->self->vendor == 0x3388)
 	     && (pdev->bus->self->device == 0x0021) ) {
diff --git a/linux-core/mga_ioc32.c b/linux-core/mga_ioc32.c
index 75f2a231..e3df567e 100644
--- a/linux-core/mga_ioc32.c
+++ b/linux-core/mga_ioc32.c
@@ -39,17 +39,17 @@
 
 typedef struct drm32_mga_init {
 	int func;
-   	u32 sarea_priv_offset;
+	u32 sarea_priv_offset;
 	int chipset;
-   	int sgram;
+	int sgram;
 	unsigned int maccess;
-   	unsigned int fb_cpp;
+	unsigned int fb_cpp;
 	unsigned int front_offset, front_pitch;
-   	unsigned int back_offset, back_pitch;
-   	unsigned int depth_cpp;
-   	unsigned int depth_offset, depth_pitch;
-   	unsigned int texture_offset[MGA_NR_TEX_HEAPS];
-   	unsigned int texture_size[MGA_NR_TEX_HEAPS];
+	unsigned int back_offset, back_pitch;
+	unsigned int depth_cpp;
+	unsigned int depth_offset, depth_pitch;
+	unsigned int texture_offset[MGA_NR_TEX_HEAPS];
+	unsigned int texture_size[MGA_NR_TEX_HEAPS];
 	u32 fb_offset;
 	u32 mmio_offset;
 	u32 status_offset;
@@ -64,10 +64,10 @@ static int compat_mga_init(struct file *file, unsigned int cmd,
 	drm_mga_init32_t init32;
 	drm_mga_init_t __user *init;
 	int err = 0, i;
-	
+
 	if (copy_from_user(&init32, (void __user *)arg, sizeof(init32)))
 		return -EFAULT;
-	
+
 	init = compat_alloc_user_space(sizeof(*init));
 	if (!access_ok(VERIFY_WRITE, init, sizeof(*init))
 	    || __put_user(init32.func, &init->func)
@@ -90,7 +90,7 @@ static int compat_mga_init(struct file *file, unsigned int cmd,
 	    || __put_user(init32.primary_offset, &init->primary_offset)
 	    || __put_user(init32.buffers_offset, &init->buffers_offset))
 		return -EFAULT;
-	
+
 	for (i=0; i<MGA_NR_TEX_HEAPS; i++)
 	{
 		err |= __put_user(init32.texture_offset[i], &init->texture_offset[i]);
@@ -98,7 +98,7 @@ static int compat_mga_init(struct file *file, unsigned int cmd,
 	}
 	if (err)
 		return -EFAULT;
-	
+
 	return drm_ioctl(file->f_dentry->d_inode, file,
 			 DRM_IOCTL_MGA_INIT, (unsigned long) init);
 }
@@ -115,7 +115,7 @@ static int compat_mga_getparam(struct file *file, unsigned int cmd,
 {
 	drm_mga_getparam32_t getparam32;
 	drm_mga_getparam_t __user *getparam;
-	
+
 	if (copy_from_user(&getparam32, (void __user *)arg, sizeof(getparam32)))
 		return -EFAULT;
 
@@ -125,7 +125,7 @@ static int compat_mga_getparam(struct file *file, unsigned int cmd,
 	    || __put_user((void __user *)(unsigned long)getparam32.value, &getparam->value))
 		return -EFAULT;
 
-	return drm_ioctl(file->f_dentry->d_inode, file, 
+	return drm_ioctl(file->f_dentry->d_inode, file,
 			 DRM_IOCTL_MGA_GETPARAM, (unsigned long)getparam);
 }
 
@@ -189,7 +189,7 @@ static int compat_mga_dma_bootstrap(struct file *file, unsigned int cmd,
 		return -EFAULT;
 
 	if (copy_to_user((void __user *)arg, &dma_bootstrap32,
-	    		 sizeof(dma_bootstrap32)))
+			 sizeof(dma_bootstrap32)))
 		return -EFAULT;
 
 	return 0;
@@ -219,7 +219,7 @@ long mga_compat_ioctl(struct file *filp, unsigned int cmd,
 
 	if (nr < DRM_COMMAND_BASE)
 		return drm_compat_ioctl(filp, cmd, arg);
-	
+
 	if (nr < DRM_COMMAND_BASE + DRM_ARRAY_SIZE(mga_compat_ioctls))
 		fn = mga_compat_ioctls[nr - DRM_COMMAND_BASE];
 
diff --git a/linux-core/nouveau_buffer.c b/linux-core/nouveau_buffer.c
index 80ba1759..c40dff6b 100644
--- a/linux-core/nouveau_buffer.c
+++ b/linux-core/nouveau_buffer.c
@@ -95,7 +95,7 @@ nouveau_bo_init_mem_type(struct drm_device *dev, uint32_t type,
 			man->io_size = nouveau_mem_fb_amount(dev);
 		break;
 	case DRM_BO_MEM_PRIV0:
-		/* Unmappable VRAM */		   
+		/* Unmappable VRAM */
 		man->flags = _DRM_FLAG_MEMTYPE_CMA;
 		man->drm_bus_maptype = 0;
 		break;
@@ -254,4 +254,3 @@ struct drm_bo_driver nouveau_bo_driver = {
 	.move = nouveau_bo_move,
 	.ttm_cache_flush= nouveau_bo_flush_ttm
 };
-
diff --git a/linux-core/nouveau_drv.c b/linux-core/nouveau_drv.c
index ac70d7ae..e9623eb1 100644
--- a/linux-core/nouveau_drv.c
+++ b/linux-core/nouveau_drv.c
@@ -80,7 +80,7 @@ static struct drm_driver driver = {
 		.probe = probe,
 		.remove = __devexit_p(drm_cleanup_pci),
 	},
-        
+
         .bo_driver = &nouveau_bo_driver,
         .fence_driver = &nouveau_fence_driver,
 
diff --git a/linux-core/nouveau_fence.c b/linux-core/nouveau_fence.c
index 6f3259f0..b3e81a89 100644
--- a/linux-core/nouveau_fence.c
+++ b/linux-core/nouveau_fence.c
@@ -131,4 +131,3 @@ struct drm_fence_driver nouveau_fence_driver = {
 	.emit		= nouveau_fence_emit,
 	.poke_flush	= nouveau_fence_poke_flush
 };
-
diff --git a/linux-core/nouveau_sgdma.c b/linux-core/nouveau_sgdma.c
index b86c5d7c..f3bf5341 100644
--- a/linux-core/nouveau_sgdma.c
+++ b/linux-core/nouveau_sgdma.c
@@ -128,7 +128,7 @@ nouveau_sgdma_unbind(struct drm_ttm_backend *be)
 	if (nvbe->is_bound) {
 		struct nouveau_gpuobj *gpuobj = dev_priv->gart_info.sg_ctxdma;
 		unsigned int pte;
-		
+
 		pte = nvbe->pte_start;
 		while (pte < (nvbe->pte_start + nvbe->pages)) {
 			uint64_t pteval = dev_priv->gart_info.sg_dummy_bus;
@@ -336,4 +336,3 @@ nouveau_sgdma_get_page(struct drm_device *dev, uint32_t offset, uint32_t *page)
 	DRM_ERROR("Unimplemented on NV50\n");
 	return -EINVAL;
 }
-
diff --git a/linux-core/r128_ioc32.c b/linux-core/r128_ioc32.c
index 6b757576..64b16798 100644
--- a/linux-core/r128_ioc32.c
+++ b/linux-core/r128_ioc32.c
@@ -64,10 +64,10 @@ static int compat_r128_init(struct file *file, unsigned int cmd,
 {
 	drm_r128_init32_t init32;
 	drm_r128_init_t __user *init;
-	
+
 	if (copy_from_user(&init32, (void __user *)arg, sizeof(init32)))
 		return -EFAULT;
-	
+
 	init = compat_alloc_user_space(sizeof(*init));
 	if (!access_ok(VERIFY_WRITE, init, sizeof(*init))
 	    || __put_user(init32.func, &init->func)
@@ -94,7 +94,7 @@ static int compat_r128_init(struct file *file, unsigned int cmd,
 	    || __put_user(init32.agp_textures_offset,
 			  &init->agp_textures_offset))
 		return -EFAULT;
-	
+
 	return drm_ioctl(file->f_dentry->d_inode, file,
 			 DRM_IOCTL_R128_INIT, (unsigned long)init);
 }
diff --git a/linux-core/radeon_drv.c b/linux-core/radeon_drv.c
index 327a6a97..d847f3cd 100644
--- a/linux-core/radeon_drv.c
+++ b/linux-core/radeon_drv.c
@@ -49,7 +49,7 @@ static int dri_library_name(struct drm_device * dev, char * buf)
 	return snprintf(buf, PAGE_SIZE, "%s\n",
 		(family < CHIP_R200) ? "radeon" :
 		((family < CHIP_R300) ? "r200" :
- 		"r300"));
+		"r300"));
 }
 
 static struct pci_device_id pciidlist[] = {
diff --git a/linux-core/sis_mm.c b/linux-core/sis_mm.c
index 9222b08d..2225ec80 100644
--- a/linux-core/sis_mm.c
+++ b/linux-core/sis_mm.c
@@ -249,7 +249,7 @@ sis_idle(struct drm_device *dev)
 			return 0;
 		}
 	}
-	
+
 	/*
 	 * Implement a device switch here if needed
 	 */
diff --git a/linux-core/via_buffer.c b/linux-core/via_buffer.c
index a6c59832..ea755247 100644
--- a/linux-core/via_buffer.c
+++ b/linux-core/via_buffer.c
@@ -94,9 +94,9 @@ int via_init_mem_type(struct drm_device * dev, uint32_t type,
 		man->drm_bus_maptype = 0;
 		break;
 
-	case DRM_BO_MEM_TT: 
+	case DRM_BO_MEM_TT:
 		/* Dynamic agpgart memory */
-		
+
 		if (!(drm_core_has_AGP(dev) && dev->agp)) {
 			DRM_ERROR("AGP is not enabled for memory type %u\n",
 				  (unsigned)type);
@@ -109,21 +109,21 @@ int via_init_mem_type(struct drm_device * dev, uint32_t type,
 
 		/* Only to get pte protection right. */
 
-		man->drm_bus_maptype = _DRM_AGP; 
+		man->drm_bus_maptype = _DRM_AGP;
 		break;
 
-	case DRM_BO_MEM_VRAM: 
+	case DRM_BO_MEM_VRAM:
 		/* "On-card" video ram */
-		
+
 		man->flags = _DRM_FLAG_MEMTYPE_MAPPABLE | _DRM_FLAG_NEEDS_IOREMAP;
 		man->drm_bus_maptype = _DRM_FRAME_BUFFER;
 		man->io_addr = NULL;
 		return via_vram_info(dev, &man->io_offset, &man->io_size);
 		break;
 
-	case DRM_BO_MEM_PRIV0: 
+	case DRM_BO_MEM_PRIV0:
 		/* Pre-bound agpgart memory */
-		
+
 		if (!(drm_core_has_AGP(dev) && dev->agp)) {
 			DRM_ERROR("AGP is not enabled for memory type %u\n",
 				  (unsigned)type);
diff --git a/linux-core/via_dmablit.c b/linux-core/via_dmablit.c
index d44c26f4..e285ca7b 100644
--- a/linux-core/via_dmablit.c
+++ b/linux-core/via_dmablit.c
@@ -1,5 +1,5 @@
 /* via_dmablit.c -- PCI DMA BitBlt support for the VIA Unichrome/Pro
- * 
+ *
  * Copyright (C) 2005 Thomas Hellstrom, All Rights Reserved.
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
@@ -16,22 +16,22 @@
  * 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: 
+ * Authors:
  *    Thomas Hellstrom.
  *    Partially based on code obtained from Digeo Inc.
  */
 
 
 /*
- * Unmaps the DMA mappings. 
- * FIXME: Is this a NoOp on x86? Also 
- * FIXME: What happens if this one is called and a pending blit has previously done 
- * the same DMA mappings? 
+ * Unmaps the DMA mappings.
+ * FIXME: Is this a NoOp on x86? Also
+ * FIXME: What happens if this one is called and a pending blit has previously done
+ * the same DMA mappings?
  */
 
 #include "drmP.h"
@@ -65,7 +65,7 @@ via_unmap_blit_from_device(struct pci_dev *pdev, drm_via_sg_info_t *vsg)
 	int num_desc = vsg->num_desc;
 	unsigned cur_descriptor_page = num_desc / vsg->descriptors_per_page;
 	unsigned descriptor_this_page = num_desc % vsg->descriptors_per_page;
-	drm_via_descriptor_t *desc_ptr = vsg->desc_pages[cur_descriptor_page] + 
+	drm_via_descriptor_t *desc_ptr = vsg->desc_pages[cur_descriptor_page] +
 		descriptor_this_page;
 	dma_addr_t next = vsg->chain_start;
 
@@ -73,7 +73,7 @@ via_unmap_blit_from_device(struct pci_dev *pdev, drm_via_sg_info_t *vsg)
 		if (descriptor_this_page-- == 0) {
 			cur_descriptor_page--;
 			descriptor_this_page = vsg->descriptors_per_page - 1;
-			desc_ptr = vsg->desc_pages[cur_descriptor_page] + 
+			desc_ptr = vsg->desc_pages[cur_descriptor_page] +
 				descriptor_this_page;
 		}
 		dma_unmap_single(&pdev->dev, next, sizeof(*desc_ptr), DMA_TO_DEVICE);
@@ -93,7 +93,7 @@ via_unmap_blit_from_device(struct pci_dev *pdev, drm_via_sg_info_t *vsg)
 static void
 via_map_blit_for_device(struct pci_dev *pdev,
 		   const drm_via_dmablit_t *xfer,
-		   drm_via_sg_info_t *vsg, 
+		   drm_via_sg_info_t *vsg,
 		   int mode)
 {
 	unsigned cur_descriptor_page = 0;
@@ -110,7 +110,7 @@ via_map_blit_for_device(struct pci_dev *pdev,
 	dma_addr_t next = 0 | VIA_DMA_DPR_EC;
 	drm_via_descriptor_t *desc_ptr = NULL;
 
-	if (mode == 1) 
+	if (mode == 1)
 		desc_ptr = vsg->desc_pages[cur_descriptor_page];
 
 	for (cur_line = 0; cur_line < xfer->num_lines; ++cur_line) {
@@ -118,7 +118,7 @@ via_map_blit_for_device(struct pci_dev *pdev,
 		line_len = xfer->line_length;
 		cur_fb = fb_addr;
 		cur_mem = mem_addr;
-		
+
 		while (line_len > 0) {
 
 			remaining_len = min(PAGE_SIZE-VIA_PGOFF(cur_mem), line_len);
@@ -131,10 +131,10 @@ via_map_blit_for_device(struct pci_dev *pdev,
 					VIA_PGOFF(cur_mem), remaining_len,
 					vsg->direction);
 				desc_ptr->dev_addr = cur_fb;
-				
+
 				desc_ptr->size = remaining_len;
 				desc_ptr->next = (uint32_t) next;
-				next = dma_map_single(&pdev->dev, desc_ptr, sizeof(*desc_ptr), 
+				next = dma_map_single(&pdev->dev, desc_ptr, sizeof(*desc_ptr),
 						      DMA_TO_DEVICE);
 				desc_ptr++;
 				if (++num_descriptors_this_page >= vsg->descriptors_per_page) {
@@ -142,12 +142,12 @@ via_map_blit_for_device(struct pci_dev *pdev,
 					desc_ptr = vsg->desc_pages[++cur_descriptor_page];
 				}
 			}
-			
+
 			num_desc++;
 			cur_mem += remaining_len;
 			cur_fb += remaining_len;
 		}
-		
+
 		mem_addr += xfer->mem_stride;
 		fb_addr += xfer->fb_stride;
 	}
@@ -160,14 +160,14 @@ via_map_blit_for_device(struct pci_dev *pdev,
 }
 
 /*
- * Function that frees up all resources for a blit. It is usable even if the 
+ * Function that frees up all resources for a blit. It is usable even if the
  * blit info has only been partially built as long as the status enum is consistent
  * with the actual status of the used resources.
  */
 
 
 static void
-via_free_sg_info(struct pci_dev *pdev, drm_via_sg_info_t *vsg) 
+via_free_sg_info(struct pci_dev *pdev, drm_via_sg_info_t *vsg)
 {
 	struct page *page;
 	int i;
@@ -184,7 +184,7 @@ via_free_sg_info(struct pci_dev *pdev, drm_via_sg_info_t *vsg)
 	case dr_via_pages_locked:
 		for (i=0; i<vsg->num_pages; ++i) {
 			if ( NULL != (page = vsg->pages[i])) {
-				if (! PageReserved(page) && (DMA_FROM_DEVICE == vsg->direction)) 
+				if (! PageReserved(page) && (DMA_FROM_DEVICE == vsg->direction))
 					SetPageDirty(page);
 				page_cache_release(page);
 			}
@@ -199,7 +199,7 @@ via_free_sg_info(struct pci_dev *pdev, drm_via_sg_info_t *vsg)
 		vsg->bounce_buffer = NULL;
 	}
 	vsg->free_on_sequence = 0;
-}		
+}
 
 /*
  * Fire a blit engine.
@@ -212,7 +212,7 @@ via_fire_dmablit(struct drm_device *dev, drm_via_sg_info_t *vsg, int engine)
 
 	VIA_WRITE(VIA_PCI_DMA_MAR0 + engine*0x10, 0);
 	VIA_WRITE(VIA_PCI_DMA_DAR0 + engine*0x10, 0);
-	VIA_WRITE(VIA_PCI_DMA_CSR0 + engine*0x04, VIA_DMA_CSR_DD | VIA_DMA_CSR_TD | 
+	VIA_WRITE(VIA_PCI_DMA_CSR0 + engine*0x04, VIA_DMA_CSR_DD | VIA_DMA_CSR_TD |
 		  VIA_DMA_CSR_DE);
 	VIA_WRITE(VIA_PCI_DMA_MR0  + engine*0x04, VIA_DMA_MR_CM | VIA_DMA_MR_TDIE);
 	VIA_WRITE(VIA_PCI_DMA_BCR0 + engine*0x10, 0);
@@ -232,20 +232,20 @@ via_lock_all_dma_pages(drm_via_sg_info_t *vsg,  drm_via_dmablit_t *xfer)
 {
 	int ret;
 	unsigned long first_pfn = VIA_PFN(xfer->mem_addr);
-	vsg->num_pages = VIA_PFN(xfer->mem_addr + (xfer->num_lines * xfer->mem_stride -1)) - 
+	vsg->num_pages = VIA_PFN(xfer->mem_addr + (xfer->num_lines * xfer->mem_stride -1)) -
 		first_pfn + 1;
-	
+
 	if (NULL == (vsg->pages = vmalloc(sizeof(struct page *) * vsg->num_pages)))
 		return -ENOMEM;
 	memset(vsg->pages, 0, sizeof(struct page *) * vsg->num_pages);
 	down_read(&current->mm->mmap_sem);
 	ret = get_user_pages(current, current->mm, (unsigned long) xfer->mem_addr,
-			     vsg->num_pages, (vsg->direction == DMA_FROM_DEVICE), 
+			     vsg->num_pages, (vsg->direction == DMA_FROM_DEVICE),
 			     0, vsg->pages, NULL);
 
 	up_read(&current->mm->mmap_sem);
 	if (ret != vsg->num_pages) {
-		if (ret < 0) 
+		if (ret < 0)
 			return ret;
 		vsg->state = dr_via_pages_locked;
 		return -EINVAL;
@@ -261,22 +261,22 @@ via_lock_all_dma_pages(drm_via_sg_info_t *vsg,  drm_via_dmablit_t *xfer)
  * quite large for some blits, and pages don't need to be contingous.
  */
 
-static int 
+static int
 via_alloc_desc_pages(drm_via_sg_info_t *vsg)
 {
 	int i;
-	
+
 	vsg->descriptors_per_page = PAGE_SIZE / sizeof( drm_via_descriptor_t);
-	vsg->num_desc_pages = (vsg->num_desc + vsg->descriptors_per_page - 1) / 
+	vsg->num_desc_pages = (vsg->num_desc + vsg->descriptors_per_page - 1) /
 		vsg->descriptors_per_page;
 
-	if (NULL ==  (vsg->desc_pages = kmalloc(sizeof(void *) * vsg->num_desc_pages, GFP_KERNEL))) 
+	if (NULL ==  (vsg->desc_pages = kmalloc(sizeof(void *) * vsg->num_desc_pages, GFP_KERNEL)))
 		return -ENOMEM;
-	
+
 	memset(vsg->desc_pages, 0, sizeof(void *) * vsg->num_desc_pages);
 	vsg->state = dr_via_desc_pages_alloc;
 	for (i=0; i<vsg->num_desc_pages; ++i) {
-		if (NULL == (vsg->desc_pages[i] = 
+		if (NULL == (vsg->desc_pages[i] =
 			     (drm_via_descriptor_t *) __get_free_page(GFP_KERNEL)))
 			return -ENOMEM;
 	}
@@ -284,7 +284,7 @@ via_alloc_desc_pages(drm_via_sg_info_t *vsg)
 		  vsg->num_desc);
 	return 0;
 }
-			
+
 static void
 via_abort_dmablit(struct drm_device *dev, int engine)
 {
@@ -298,7 +298,7 @@ via_dmablit_engine_off(struct drm_device *dev, int engine)
 {
 	drm_via_private_t *dev_priv = (drm_via_private_t *)dev->dev_private;
 
-	VIA_WRITE(VIA_PCI_DMA_CSR0 + engine*0x04, VIA_DMA_CSR_TD | VIA_DMA_CSR_DD); 
+	VIA_WRITE(VIA_PCI_DMA_CSR0 + engine*0x04, VIA_DMA_CSR_TD | VIA_DMA_CSR_DD);
 }
 
 
@@ -309,7 +309,7 @@ via_dmablit_engine_off(struct drm_device *dev, int engine)
  * task. Basically the task of the interrupt handler is to submit a new blit to the engine, while
  * the workqueue task takes care of processing associated with the old blit.
  */
-		
+
 void
 via_dmablit_handler(struct drm_device *dev, int engine, int from_irq)
 {
@@ -329,19 +329,19 @@ via_dmablit_handler(struct drm_device *dev, int engine, int from_irq)
 		spin_lock_irqsave(&blitq->blit_lock, irqsave);
 	}
 
-	done_transfer = blitq->is_active && 
+	done_transfer = blitq->is_active &&
 	  (( status = VIA_READ(VIA_PCI_DMA_CSR0 + engine*0x04)) & VIA_DMA_CSR_TD);
-	done_transfer = done_transfer || ( blitq->aborting && !(status & VIA_DMA_CSR_DE)); 
+	done_transfer = done_transfer || ( blitq->aborting && !(status & VIA_DMA_CSR_DE));
 
 	cur = blitq->cur;
 	if (done_transfer) {
 
 		blitq->blits[cur]->aborted = blitq->aborting;
 		blitq->done_blit_handle++;
-		DRM_WAKEUP(blitq->blit_queue + cur);		
+		DRM_WAKEUP(blitq->blit_queue + cur);
 
 		cur++;
-		if (cur >= VIA_NUM_BLIT_SLOTS) 
+		if (cur >= VIA_NUM_BLIT_SLOTS)
 			cur = 0;
 		blitq->cur = cur;
 
@@ -353,7 +353,7 @@ via_dmablit_handler(struct drm_device *dev, int engine, int from_irq)
 
 		blitq->is_active = 0;
 		blitq->aborting = 0;
-		schedule_work(&blitq->wq);	
+		schedule_work(&blitq->wq);
 
 	} else if (blitq->is_active && time_after_eq(jiffies, blitq->end)) {
 
@@ -365,7 +365,7 @@ via_dmablit_handler(struct drm_device *dev, int engine, int from_irq)
 		blitq->aborting = 1;
 		blitq->end = jiffies + DRM_HZ;
 	}
-	  		
+
 	if (!blitq->is_active) {
 		if (blitq->num_outstanding) {
 			via_fire_dmablit(dev, blitq->blits[cur], engine);
@@ -383,14 +383,14 @@ via_dmablit_handler(struct drm_device *dev, int engine, int from_irq)
 			}
 			via_dmablit_engine_off(dev, engine);
 		}
-	}		
+	}
 
 	if (from_irq) {
 		spin_unlock(&blitq->blit_lock);
 	} else {
 		spin_unlock_irqrestore(&blitq->blit_lock, irqsave);
 	}
-} 
+}
 
 
 
@@ -426,13 +426,13 @@ via_dmablit_active(drm_via_blitq_t *blitq, int engine, uint32_t handle, wait_que
 
 	return active;
 }
-	
+
 /*
  * Sync. Wait for at least three seconds for the blit to be performed.
  */
 
 static int
-via_dmablit_sync(struct drm_device *dev, uint32_t handle, int engine) 
+via_dmablit_sync(struct drm_device *dev, uint32_t handle, int engine)
 {
 
 	drm_via_private_t *dev_priv = (drm_via_private_t *)dev->dev_private;
@@ -441,12 +441,12 @@ via_dmablit_sync(struct drm_device *dev, uint32_t handle, int engine)
 	int ret = 0;
 
 	if (via_dmablit_active(blitq, engine, handle, &queue)) {
-		DRM_WAIT_ON(ret, *queue, 3 * DRM_HZ, 
+		DRM_WAIT_ON(ret, *queue, 3 * DRM_HZ,
 			    !via_dmablit_active(blitq, engine, handle, NULL));
 	}
 	DRM_DEBUG("DMA blit sync handle 0x%x engine %d returned %d\n",
 		  handle, engine, ret);
-	
+
 	return ret;
 }
 
@@ -468,12 +468,12 @@ via_dmablit_timer(unsigned long data)
 	struct drm_device *dev = blitq->dev;
 	int engine = (int)
 		(blitq - ((drm_via_private_t *)dev->dev_private)->blit_queues);
-		
-	DRM_DEBUG("Polling timer called for engine %d, jiffies %lu\n", engine, 
+
+	DRM_DEBUG("Polling timer called for engine %d, jiffies %lu\n", engine,
 		  (unsigned long) jiffies);
 
 	via_dmablit_handler(dev, engine, 0);
-	
+
 	if (!timer_pending(&blitq->poll_timer)) {
 		blitq->poll_timer.expires = jiffies+1;
 		add_timer(&blitq->poll_timer);
@@ -497,7 +497,7 @@ via_dmablit_timer(unsigned long data)
  */
 
 
-static void 
+static void
 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20)
 via_dmablit_workqueue(void *data)
 #else
@@ -513,38 +513,38 @@ via_dmablit_workqueue(struct work_struct *work)
 	unsigned long irqsave;
 	drm_via_sg_info_t *cur_sg;
 	int cur_released;
-	
-	
-	DRM_DEBUG("Workqueue task called for blit engine %ld\n",(unsigned long) 
+
+
+	DRM_DEBUG("Workqueue task called for blit engine %ld\n",(unsigned long)
 		  (blitq - ((drm_via_private_t *)dev->dev_private)->blit_queues));
 
 	spin_lock_irqsave(&blitq->blit_lock, irqsave);
-	
+
 	while(blitq->serviced != blitq->cur) {
 
 		cur_released = blitq->serviced++;
 
 		DRM_DEBUG("Releasing blit slot %d\n", cur_released);
 
-		if (blitq->serviced >= VIA_NUM_BLIT_SLOTS) 
+		if (blitq->serviced >= VIA_NUM_BLIT_SLOTS)
 			blitq->serviced = 0;
-		
+
 		cur_sg = blitq->blits[cur_released];
 		blitq->num_free++;
-				
+
 		spin_unlock_irqrestore(&blitq->blit_lock, irqsave);
-		
+
 		DRM_WAKEUP(&blitq->busy_queue);
-		
+
 		via_free_sg_info(dev->pdev, cur_sg);
 		kfree(cur_sg);
-		
+
 		spin_lock_irqsave(&blitq->blit_lock, irqsave);
 	}
 
 	spin_unlock_irqrestore(&blitq->blit_lock, irqsave);
 }
-	
+
 
 /*
  * Init all blit engines. Currently we use two, but some hardware have 4.
@@ -558,8 +558,8 @@ via_init_dmablit(struct drm_device *dev)
 	drm_via_private_t *dev_priv = (drm_via_private_t *)dev->dev_private;
 	drm_via_blitq_t *blitq;
 
-	pci_set_master(dev->pdev);	
-	
+	pci_set_master(dev->pdev);
+
 	for (i=0; i< VIA_NUM_BLIT_ENGINES; ++i) {
 		blitq = dev_priv->blit_queues + i;
 		blitq->dev = dev;
@@ -585,20 +585,20 @@ via_init_dmablit(struct drm_device *dev)
 		init_timer(&blitq->poll_timer);
 		blitq->poll_timer.function = &via_dmablit_timer;
 		blitq->poll_timer.data = (unsigned long) blitq;
-	}	
+	}
 }
 
 /*
  * Build all info and do all mappings required for a blit.
  */
-		
+
 
 static int
 via_build_sg_info(struct drm_device *dev, drm_via_sg_info_t *vsg, drm_via_dmablit_t *xfer)
 {
 	int draw = xfer->to_fb;
 	int ret = 0;
-	
+
 	vsg->direction = (draw) ? DMA_TO_DEVICE : DMA_FROM_DEVICE;
 	vsg->bounce_buffer = NULL;
 
@@ -612,7 +612,7 @@ via_build_sg_info(struct drm_device *dev, drm_via_sg_info_t *vsg, drm_via_dmabli
 	/*
 	 * Below check is a driver limitation, not a hardware one. We
 	 * don't want to lock unused pages, and don't want to incoporate the
-	 * extra logic of avoiding them. Make sure there are no. 
+	 * extra logic of avoiding them. Make sure there are no.
 	 * (Not a big limitation anyway.)
 	 */
 
@@ -638,11 +638,11 @@ via_build_sg_info(struct drm_device *dev, drm_via_sg_info_t *vsg, drm_via_dmabli
 	if (xfer->num_lines > 2048 || (xfer->num_lines*xfer->mem_stride > (2048*2048*4))) {
 		DRM_ERROR("Too large PCI DMA bitblt.\n");
 		return -EINVAL;
-	}		
+	}
 
-	/* 
+	/*
 	 * we allow a negative fb stride to allow flipping of images in
-	 * transfer. 
+	 * transfer.
 	 */
 
 	if (xfer->mem_stride < xfer->line_length ||
@@ -668,7 +668,7 @@ via_build_sg_info(struct drm_device *dev, drm_via_sg_info_t *vsg, drm_via_dmabli
 	    ((xfer->num_lines > 1) && ((xfer->mem_stride & 15) || (xfer->fb_stride & 3)))) {
 		DRM_ERROR("Invalid DRM bitblt alignment.\n");
 		return -EINVAL;
-	}	
+	}
 #endif
 
 	if (0 != (ret = via_lock_all_dma_pages(vsg, xfer))) {
@@ -684,17 +684,17 @@ via_build_sg_info(struct drm_device *dev, drm_via_sg_info_t *vsg, drm_via_dmabli
 		return ret;
 	}
 	via_map_blit_for_device(dev->pdev, xfer, vsg, 1);
-	
+
 	return 0;
 }
-	
+
 
 /*
  * Reserve one free slot in the blit queue. Will wait for one second for one
  * to become available. Otherwise -EBUSY is returned.
  */
 
-static int 
+static int
 via_dmablit_grab_slot(drm_via_blitq_t *blitq, int engine)
 {
 	int ret=0;
@@ -709,10 +709,10 @@ via_dmablit_grab_slot(drm_via_blitq_t *blitq, int engine)
 		if (ret) {
 			return (-EINTR == ret) ? -EAGAIN : ret;
 		}
-		
+
 		spin_lock_irqsave(&blitq->blit_lock, irqsave);
 	}
-	
+
 	blitq->num_free--;
 	spin_unlock_irqrestore(&blitq->blit_lock, irqsave);
 
@@ -723,7 +723,7 @@ via_dmablit_grab_slot(drm_via_blitq_t *blitq, int engine)
  * Hand back a free slot if we changed our mind.
  */
 
-static void 
+static void
 via_dmablit_release_slot(drm_via_blitq_t *blitq)
 {
 	unsigned long irqsave;
@@ -739,8 +739,8 @@ via_dmablit_release_slot(drm_via_blitq_t *blitq)
  */
 
 
-static int 
-via_dmablit(struct drm_device *dev, drm_via_dmablit_t *xfer)	 
+static int
+via_dmablit(struct drm_device *dev, drm_via_dmablit_t *xfer)
 {
 	drm_via_private_t *dev_priv = (drm_via_private_t *)dev->dev_private;
 	drm_via_sg_info_t *vsg;
@@ -771,15 +771,15 @@ via_dmablit(struct drm_device *dev, drm_via_dmablit_t *xfer)
 	spin_lock_irqsave(&blitq->blit_lock, irqsave);
 
 	blitq->blits[blitq->head++] = vsg;
-	if (blitq->head >= VIA_NUM_BLIT_SLOTS) 
+	if (blitq->head >= VIA_NUM_BLIT_SLOTS)
 		blitq->head = 0;
 	blitq->num_outstanding++;
-	xfer->sync.sync_handle = ++blitq->cur_blit_handle; 
+	xfer->sync.sync_handle = ++blitq->cur_blit_handle;
 
 	spin_unlock_irqrestore(&blitq->blit_lock, irqsave);
 	xfer->sync.engine = engine;
 
-       	via_dmablit_handler(dev, engine, 0);
+	via_dmablit_handler(dev, engine, 0);
 
 	return 0;
 }
@@ -787,7 +787,7 @@ via_dmablit(struct drm_device *dev, drm_via_dmablit_t *xfer)
 /*
  * Sync on a previously submitted blit. Note that the X server use signals extensively, and
  * that there is a very big probability that this IOCTL will be interrupted by a signal. In that
- * case it returns with -EAGAIN for the signal to be delivered. 
+ * case it returns with -EAGAIN for the signal to be delivered.
  * The caller should then reissue the IOCTL. This is similar to what is being done for drmGetLock().
  */
 
@@ -797,7 +797,7 @@ via_dma_blit_sync( struct drm_device *dev, void *data, struct drm_file *file_pri
 	drm_via_blitsync_t *sync = data;
 	int err;
 
-	if (sync->engine >= VIA_NUM_BLIT_ENGINES) 
+	if (sync->engine >= VIA_NUM_BLIT_ENGINES)
 		return -EINVAL;
 
 	err = via_dmablit_sync(dev, sync->sync_handle, sync->engine);
@@ -807,15 +807,15 @@ via_dma_blit_sync( struct drm_device *dev, void *data, struct drm_file *file_pri
 
 	return err;
 }
-	
+
 
 /*
  * Queue a blit and hand back a handle to be used for sync. This IOCTL may be interrupted by a signal
- * while waiting for a free slot in the blit queue. In that case it returns with -EAGAIN and should 
+ * while waiting for a free slot in the blit queue. In that case it returns with -EAGAIN and should
  * be reissued. See the above IOCTL code.
  */
 
-int 
+int
 via_dma_blit( struct drm_device *dev, void *data, struct drm_file *file_priv )
 {
 	drm_via_dmablit_t *xfer = data;
diff --git a/linux-core/via_dmablit.h b/linux-core/via_dmablit.h
index 726ad25d..9b662a32 100644
--- a/linux-core/via_dmablit.h
+++ b/linux-core/via_dmablit.h
@@ -1,5 +1,5 @@
 /* via_dmablit.h -- PCI DMA BitBlt support for the VIA Unichrome/Pro
- * 
+ *
  * Copyright 2005 Thomas Hellstrom.
  * All Rights Reserved.
  *
@@ -17,12 +17,12 @@
  * 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: 
+ * Authors:
  *    Thomas Hellstrom.
  *    Register info from Digeo Inc.
  */
@@ -67,7 +67,7 @@ typedef struct _drm_via_blitq {
 	unsigned cur;
 	unsigned num_free;
 	unsigned num_outstanding;
-	unsigned long end;  
+	unsigned long end;
 	int aborting;
 	int is_active;
 	drm_via_sg_info_t *blits[VIA_NUM_BLIT_SLOTS];
@@ -77,46 +77,46 @@ typedef struct _drm_via_blitq {
 	struct work_struct wq;
 	struct timer_list poll_timer;
 } drm_via_blitq_t;
-	
 
-/* 
+
+/*
  *  PCI DMA Registers
  *  Channels 2 & 3 don't seem to be implemented in hardware.
  */
- 
-#define VIA_PCI_DMA_MAR0            0xE40   /* Memory Address Register of Channel 0 */ 
-#define VIA_PCI_DMA_DAR0            0xE44   /* Device Address Register of Channel 0 */ 
-#define VIA_PCI_DMA_BCR0            0xE48   /* Byte Count Register of Channel 0 */ 
-#define VIA_PCI_DMA_DPR0            0xE4C   /* Descriptor Pointer Register of Channel 0 */ 
-
-#define VIA_PCI_DMA_MAR1            0xE50   /* Memory Address Register of Channel 1 */ 
-#define VIA_PCI_DMA_DAR1            0xE54   /* Device Address Register of Channel 1 */ 
-#define VIA_PCI_DMA_BCR1            0xE58   /* Byte Count Register of Channel 1 */ 
-#define VIA_PCI_DMA_DPR1            0xE5C   /* Descriptor Pointer Register of Channel 1 */ 
-
-#define VIA_PCI_DMA_MAR2            0xE60   /* Memory Address Register of Channel 2 */ 
-#define VIA_PCI_DMA_DAR2            0xE64   /* Device Address Register of Channel 2 */ 
-#define VIA_PCI_DMA_BCR2            0xE68   /* Byte Count Register of Channel 2 */ 
-#define VIA_PCI_DMA_DPR2            0xE6C   /* Descriptor Pointer Register of Channel 2 */ 
-
-#define VIA_PCI_DMA_MAR3            0xE70   /* Memory Address Register of Channel 3 */ 
-#define VIA_PCI_DMA_DAR3            0xE74   /* Device Address Register of Channel 3 */ 
-#define VIA_PCI_DMA_BCR3            0xE78   /* Byte Count Register of Channel 3 */ 
-#define VIA_PCI_DMA_DPR3            0xE7C   /* Descriptor Pointer Register of Channel 3 */ 
-
-#define VIA_PCI_DMA_MR0             0xE80   /* Mode Register of Channel 0 */ 
-#define VIA_PCI_DMA_MR1             0xE84   /* Mode Register of Channel 1 */ 
-#define VIA_PCI_DMA_MR2             0xE88   /* Mode Register of Channel 2 */ 
-#define VIA_PCI_DMA_MR3             0xE8C   /* Mode Register of Channel 3 */ 
-
-#define VIA_PCI_DMA_CSR0            0xE90   /* Command/Status Register of Channel 0 */ 
-#define VIA_PCI_DMA_CSR1            0xE94   /* Command/Status Register of Channel 1 */ 
-#define VIA_PCI_DMA_CSR2            0xE98   /* Command/Status Register of Channel 2 */ 
-#define VIA_PCI_DMA_CSR3            0xE9C   /* Command/Status Register of Channel 3 */ 
-
-#define VIA_PCI_DMA_PTR             0xEA0   /* Priority Type Register */ 
-
-/* Define for DMA engine */ 
+
+#define VIA_PCI_DMA_MAR0            0xE40   /* Memory Address Register of Channel 0 */
+#define VIA_PCI_DMA_DAR0            0xE44   /* Device Address Register of Channel 0 */
+#define VIA_PCI_DMA_BCR0            0xE48   /* Byte Count Register of Channel 0 */
+#define VIA_PCI_DMA_DPR0            0xE4C   /* Descriptor Pointer Register of Channel 0 */
+
+#define VIA_PCI_DMA_MAR1            0xE50   /* Memory Address Register of Channel 1 */
+#define VIA_PCI_DMA_DAR1            0xE54   /* Device Address Register of Channel 1 */
+#define VIA_PCI_DMA_BCR1            0xE58   /* Byte Count Register of Channel 1 */
+#define VIA_PCI_DMA_DPR1            0xE5C   /* Descriptor Pointer Register of Channel 1 */
+
+#define VIA_PCI_DMA_MAR2            0xE60   /* Memory Address Register of Channel 2 */
+#define VIA_PCI_DMA_DAR2            0xE64   /* Device Address Register of Channel 2 */
+#define VIA_PCI_DMA_BCR2            0xE68   /* Byte Count Register of Channel 2 */
+#define VIA_PCI_DMA_DPR2            0xE6C   /* Descriptor Pointer Register of Channel 2 */
+
+#define VIA_PCI_DMA_MAR3            0xE70   /* Memory Address Register of Channel 3 */
+#define VIA_PCI_DMA_DAR3            0xE74   /* Device Address Register of Channel 3 */
+#define VIA_PCI_DMA_BCR3            0xE78   /* Byte Count Register of Channel 3 */
+#define VIA_PCI_DMA_DPR3            0xE7C   /* Descriptor Pointer Register of Channel 3 */
+
+#define VIA_PCI_DMA_MR0             0xE80   /* Mode Register of Channel 0 */
+#define VIA_PCI_DMA_MR1             0xE84   /* Mode Register of Channel 1 */
+#define VIA_PCI_DMA_MR2             0xE88   /* Mode Register of Channel 2 */
+#define VIA_PCI_DMA_MR3             0xE8C   /* Mode Register of Channel 3 */
+
+#define VIA_PCI_DMA_CSR0            0xE90   /* Command/Status Register of Channel 0 */
+#define VIA_PCI_DMA_CSR1            0xE94   /* Command/Status Register of Channel 1 */
+#define VIA_PCI_DMA_CSR2            0xE98   /* Command/Status Register of Channel 2 */
+#define VIA_PCI_DMA_CSR3            0xE9C   /* Command/Status Register of Channel 3 */
+
+#define VIA_PCI_DMA_PTR             0xEA0   /* Priority Type Register */
+
+/* Define for DMA engine */
 /* DPR */
 #define VIA_DMA_DPR_EC		(1<<1)	/* end of chain */
 #define VIA_DMA_DPR_DDIE	(1<<2)	/* descriptor done interrupt enable */
diff --git a/linux-core/via_mm.c b/linux-core/via_mm.c
index 35ca6bfc..270eac15 100644
--- a/linux-core/via_mm.c
+++ b/linux-core/via_mm.c
@@ -115,7 +115,7 @@ void via_lastclose(struct drm_device *dev)
 	dev_priv->vram_initialized = 0;
 	dev_priv->agp_initialized = 0;
 	mutex_unlock(&dev->struct_mutex);
-}	
+}
 
 int via_mem_alloc(struct drm_device *dev, void *data,
 		  struct drm_file *file_priv)
diff --git a/linux-core/xgi_cmdlist.c b/linux-core/xgi_cmdlist.c
index d7b23c89..64401ae5 100644
--- a/linux-core/xgi_cmdlist.c
+++ b/linux-core/xgi_cmdlist.c
@@ -78,7 +78,7 @@ int xgi_cmdlist_initialize(struct xgi_info * info, size_t size,
  * @type: Type of the current batch
  *
  * See section 3.2.2 "Begin" (page 15) of the 3D SPG.
- * 
+ *
  * This function assumes that @type is on the range [0,3].
  */
 unsigned int get_batch_command(enum xgi_batch_type type)
@@ -86,7 +86,7 @@ unsigned int get_batch_command(enum xgi_batch_type type)
 	static const unsigned int ports[4] = {
 		0x30 >> 2, 0x40 >> 2, 0x50 >> 2, 0x20 >> 2
 	};
-	
+
 	return ports[type];
 }
 
@@ -159,7 +159,7 @@ int xgi_submit_cmdlist(struct drm_device * dev, void * data,
                 2 - fb
                 3 - logout
 */
-int xgi_state_change(struct xgi_info * info, unsigned int to, 
+int xgi_state_change(struct xgi_info * info, unsigned int to,
 		     unsigned int from)
 {
 #define STATE_CONSOLE   0
@@ -219,7 +219,7 @@ void xgi_cmdlist_cleanup(struct xgi_info * info)
 		}
 
 		xgi_waitfor_pci_idle(info);
-		
+
 		(void) memset(&info->cmdring, 0, sizeof(info->cmdring));
 	}
 }
@@ -243,7 +243,7 @@ static void triggerHWCommandList(struct xgi_info * info)
 void xgi_emit_flush(struct xgi_info * info, bool stop)
 {
 	const u32 flush_command[8] = {
-		((0x10 << 24) 
+		((0x10 << 24)
 		 | (BEGIN_BEGIN_IDENTIFICATION_MASK & info->next_sequence)),
 		BEGIN_LINK_ENABLE_MASK | (0x00004),
 		0x00000000, 0x00000000,
@@ -266,9 +266,9 @@ void xgi_emit_flush(struct xgi_info * info, bool stop)
 		info->cmdring.ring_offset = 0;
 	}
 
-	hw_addr = info->cmdring.ring_hw_base 
+	hw_addr = info->cmdring.ring_hw_base
 		+ info->cmdring.ring_offset;
-	batch_addr = info->cmdring.ptr 
+	batch_addr = info->cmdring.ptr
 		+ (info->cmdring.ring_offset / 4);
 
 	for (i = 0; i < (flush_size / 4); i++) {
diff --git a/linux-core/xgi_drv.c b/linux-core/xgi_drv.c
index 4e66197e..4f0b4ed0 100644
--- a/linux-core/xgi_drv.c
+++ b/linux-core/xgi_drv.c
@@ -352,7 +352,7 @@ irqreturn_t xgi_kern_isr(DRM_IRQ_ARGS)
 	struct drm_device *dev = (struct drm_device *) arg;
 	struct xgi_info *info = dev->dev_private;
 	const u32 irq_bits = le32_to_cpu(DRM_READ32(info->mmio_map,
-					(0x2800 
+					(0x2800
 					 + M2REG_AUTO_LINK_STATUS_ADDRESS)))
 		& (M2REG_ACTIVE_TIMER_INTERRUPT_MASK
 		   | M2REG_ACTIVE_INTERRUPT_0_MASK
@@ -361,7 +361,7 @@ irqreturn_t xgi_kern_isr(DRM_IRQ_ARGS)
 
 
 	if (irq_bits != 0) {
-		DRM_WRITE32(info->mmio_map, 
+		DRM_WRITE32(info->mmio_map,
 			    0x2800 + M2REG_AUTO_LINK_SETTING_ADDRESS,
 			    cpu_to_le32(M2REG_AUTO_LINK_SETTING_COMMAND | irq_bits));
 		xgi_fence_handler(dev);
@@ -413,7 +413,7 @@ int xgi_driver_load(struct drm_device *dev, unsigned long flags)
 
 
 	return 0;
-	
+
 fail:
 	drm_free(info, sizeof(*info), DRM_MEM_DRIVER);
 	return err;
diff --git a/linux-core/xgi_fb.c b/linux-core/xgi_fb.c
index 2e2d0094..3f50fe8f 100644
--- a/linux-core/xgi_fb.c
+++ b/linux-core/xgi_fb.c
@@ -32,7 +32,7 @@ int xgi_alloc(struct xgi_info * info, struct xgi_mem_alloc * alloc,
 	      struct drm_file * filp)
 {
 	struct drm_memblock_item *block;
-	const char *const mem_name = (alloc->location == XGI_MEMLOC_LOCAL) 
+	const char *const mem_name = (alloc->location == XGI_MEMLOC_LOCAL)
 		? "on-card" : "GART";
 
 
@@ -43,7 +43,7 @@ int xgi_alloc(struct xgi_info * info, struct xgi_mem_alloc * alloc,
 		return -EINVAL;
 	}
 
-	if ((alloc->location == XGI_MEMLOC_LOCAL) 
+	if ((alloc->location == XGI_MEMLOC_LOCAL)
 	    ? !info->fb_heap_initialized : !info->pcie_heap_initialized) {
 		DRM_ERROR("Attempt to allocate from uninitialized memory "
 			  "pool (0x%08x).\n", alloc->location);
@@ -118,7 +118,7 @@ int xgi_free_ioctl(struct drm_device * dev, void * data,
 int xgi_fb_heap_init(struct xgi_info * info)
 {
 	int err;
-	
+
 	mutex_lock(&info->dev->struct_mutex);
 	err = drm_sman_set_range(&info->sman, XGI_MEMLOC_LOCAL,
 				 XGI_FB_HEAP_START,
diff --git a/linux-core/xgi_fence.c b/linux-core/xgi_fence.c
index 526bc5db..9a75581a 100644
--- a/linux-core/xgi_fence.c
+++ b/linux-core/xgi_fence.c
@@ -72,7 +72,7 @@ static uint32_t xgi_do_flush(struct drm_device * dev, uint32_t class)
 
 
 int xgi_fence_emit_sequence(struct drm_device * dev, uint32_t class,
-			    uint32_t flags, uint32_t * sequence, 
+			    uint32_t flags, uint32_t * sequence,
 			    uint32_t * native_type)
 {
 	struct xgi_info * info = dev->dev_private;
diff --git a/linux-core/xgi_ioc32.c b/linux-core/xgi_ioc32.c
index c54044fa..e4338417 100644
--- a/linux-core/xgi_ioc32.c
+++ b/linux-core/xgi_ioc32.c
@@ -43,7 +43,7 @@ struct drm_map32 {
 	u32 handle;		/**< User-space: "Handle" to pass to mmap() */
 	int mtrr;		/**< MTRR slot used */
 };
-	
+
 struct drm32_xgi_bootstrap {
 	struct drm_map32 gart;
 };
diff --git a/linux-core/xgi_misc.c b/linux-core/xgi_misc.c
index 4a4a9844..2b3a1788 100644
--- a/linux-core/xgi_misc.c
+++ b/linux-core/xgi_misc.c
@@ -90,7 +90,7 @@ static void xgi_ge_hang_reset(struct drm_map * map)
 
 	DRM_WRITE8(map, 0xb057, 8);
 	while (0 != le32_to_cpu(DRM_READ32(map, 0x2800) & 0xf0000000)) {
-		while (0 != ((--time_out) & 0xfff)) 
+		while (0 != ((--time_out) & 0xfff))
 			/* empty */ ;
 
 		if (0 == time_out) {
@@ -117,8 +117,8 @@ static void xgi_ge_hang_reset(struct drm_map * map)
 			DRM_WRITE8(map, 0x3d4, 0x36);
 			old_36 = DRM_READ8(map, 0x3d5);
 			DRM_WRITE8(map, 0x3d5, old_36 | 0x10);
-			
-			while (0 != ((--time_out) & 0xfff)) 
+
+			while (0 != ((--time_out) & 0xfff))
 				/* empty */ ;
 
 			DRM_WRITE8(map, 0x3d5, old_36);
@@ -134,7 +134,7 @@ static void xgi_ge_hang_reset(struct drm_map * map)
 	DRM_WRITE8(map, 0xb057, 0);
 }
 
-	
+
 bool xgi_ge_irq_handler(struct xgi_info * info)
 {
 	const u32 int_status = le32_to_cpu(DRM_READ32(info->mmio_map, 0x2810));
@@ -143,7 +143,7 @@ bool xgi_ge_irq_handler(struct xgi_info * info)
 	/* Check GE on/off */
 	if (0 == (0xffffc0f0 & int_status)) {
 		if (0 != (0x1000 & int_status)) {
-			/* We got GE stall interrupt. 
+			/* We got GE stall interrupt.
 			 */
 			DRM_WRITE32(info->mmio_map, 0x2810,
 				    cpu_to_le32(int_status | 0x04000000));
@@ -289,7 +289,7 @@ static void dump_reg(struct xgi_info * info, unsigned regbase, unsigned range)
 		printk("%1x ", i);
 
 		for (j = 0; j < 0x10; j++) {
-			u8 temp = DRM_READ8(info->mmio_map, 
+			u8 temp = DRM_READ8(info->mmio_map,
 					    regbase + (i * 0x10) + j);
 			printk("%3x", temp);
 		}
diff --git a/linux-core/xgi_misc.h b/linux-core/xgi_misc.h
index af19a11a..5f9e4f09 100644
--- a/linux-core/xgi_misc.h
+++ b/linux-core/xgi_misc.h
@@ -1,5 +1,5 @@
 /****************************************************************************
- * Copyright (C) 2003-2006 by XGI Technology, Taiwan.			
+ * Copyright (C) 2003-2006 by XGI Technology, Taiwan.
  *
  * All Rights Reserved.
  *
diff --git a/linux-core/xgi_regs.h b/linux-core/xgi_regs.h
index 5c0100a0..a897fd8a 100644
--- a/linux-core/xgi_regs.h
+++ b/linux-core/xgi_regs.h
@@ -4,7 +4,7 @@
  * All Rights Reserved.
  *
  * Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files (the	
+ * a copy of this software and associated documentation files (the
  * "Software"), to deal in the Software without restriction, including
  * without limitation on the rights to use, copy, modify, merge,
  * publish, distribute, sublicense, and/or sell copies of the Software,
-- 
cgit v1.2.3


From 78fe88baee9271ceaf6187019633e4cccfebb776 Mon Sep 17 00:00:00 2001
From: Li Zefan <lizf@cn.fujitsu.com>
Date: Mon, 5 Nov 2007 18:48:27 +1000
Subject: drm: fix memset size error

The size passing to memset is wrong.

Signed-off-by: Li Zefan <lizf@cn.fujitsu.com>
---
 linux-core/drm_ioctl.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'linux-core')

diff --git a/linux-core/drm_ioctl.c b/linux-core/drm_ioctl.c
index 9d52fd8a..395f7b4e 100644
--- a/linux-core/drm_ioctl.c
+++ b/linux-core/drm_ioctl.c
@@ -264,7 +264,7 @@ int drm_getstats(struct drm_device *dev, void *data,
 	struct drm_stats *stats = data;
 	int i;
 
-	memset(stats, 0, sizeof(stats));
+	memset(stats, 0, sizeof(*stats));
 
 	mutex_lock(&dev->struct_mutex);
 
-- 
cgit v1.2.3


From 3b43ed51cca4cf4b03d74ee403b8a72b919f87c8 Mon Sep 17 00:00:00 2001
From: Dave Airlie <airlied@linux.ie>
Date: Mon, 5 Nov 2007 18:56:46 +1000
Subject: drm: fix the the typo

---
 linux-core/drm_dma.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'linux-core')

diff --git a/linux-core/drm_dma.c b/linux-core/drm_dma.c
index 7cc44193..c4c4c694 100644
--- a/linux-core/drm_dma.c
+++ b/linux-core/drm_dma.c
@@ -65,7 +65,7 @@ int drm_dma_setup(struct drm_device * dev)
  * \param dev DRM device.
  *
  * Free all pages associated with DMA buffers, the buffers and pages lists, and
- * finally the the drm_device::dma structure itself.
+ * finally the drm_device::dma structure itself.
  */
 void drm_dma_takedown(struct drm_device * dev)
 {
-- 
cgit v1.2.3


From 7ad38907075852e347b5b4432c96d199387f5ce8 Mon Sep 17 00:00:00 2001
From: Dave Airlie <airlied@linux.ie>
Date: Mon, 5 Nov 2007 19:05:32 +1000
Subject: drm/ttm: kernel coding style for bo.c and objects.h

---
 linux-core/drm_bo.c      | 218 ++++++++++++++++++++++-------------------------
 linux-core/drm_objects.h | 195 +++++++++++++++++++++---------------------
 2 files changed, 202 insertions(+), 211 deletions(-)

(limited to 'linux-core')

diff --git a/linux-core/drm_bo.c b/linux-core/drm_bo.c
index 4cdf8891..91bc0c79 100644
--- a/linux-core/drm_bo.c
+++ b/linux-core/drm_bo.c
@@ -36,23 +36,23 @@
  * The buffer usage atomic_t needs to be protected by dev->struct_mutex
  * when there is a chance that it can be zero before or after the operation.
  *
- * dev->struct_mutex also protects all lists and list heads. Hash tables and hash
- * heads.
+ * dev->struct_mutex also protects all lists and list heads,
+ * Hash tables and hash heads.
  *
  * bo->mutex protects the buffer object itself excluding the usage field.
- * bo->mutex does also protect the buffer list heads, so to manipulate those, we need
- * both the bo->mutex and the dev->struct_mutex.
+ * bo->mutex does also protect the buffer list heads, so to manipulate those,
+ * we need both the bo->mutex and the dev->struct_mutex.
  *
- * Locking order is bo->mutex, dev->struct_mutex. Therefore list traversal is a bit
- * complicated. When dev->struct_mutex is released to grab bo->mutex, the list
- * traversal will, in general, need to be restarted.
+ * Locking order is bo->mutex, dev->struct_mutex. Therefore list traversal
+ * is a bit complicated. When dev->struct_mutex is released to grab bo->mutex,
+ * the list traversal will, in general, need to be restarted.
  *
  */
 
-static void drm_bo_destroy_locked(struct drm_buffer_object * bo);
-static int drm_bo_setup_vm_locked(struct drm_buffer_object * bo);
-static void drm_bo_takedown_vm_locked(struct drm_buffer_object * bo);
-static void drm_bo_unmap_virtual(struct drm_buffer_object * bo);
+static void drm_bo_destroy_locked(struct drm_buffer_object *bo);
+static int drm_bo_setup_vm_locked(struct drm_buffer_object *bo);
+static void drm_bo_takedown_vm_locked(struct drm_buffer_object *bo);
+static void drm_bo_unmap_virtual(struct drm_buffer_object *bo);
 
 static inline uint64_t drm_bo_type_flags(unsigned type)
 {
@@ -63,7 +63,7 @@ static inline uint64_t drm_bo_type_flags(unsigned type)
  * bo locked. dev->struct_mutex locked.
  */
 
-void drm_bo_add_to_pinned_lru(struct drm_buffer_object * bo)
+void drm_bo_add_to_pinned_lru(struct drm_buffer_object *bo)
 {
 	struct drm_mem_type_manager *man;
 
@@ -74,7 +74,7 @@ void drm_bo_add_to_pinned_lru(struct drm_buffer_object * bo)
 	list_add_tail(&bo->pinned_lru, &man->pinned);
 }
 
-void drm_bo_add_to_lru(struct drm_buffer_object * bo)
+void drm_bo_add_to_lru(struct drm_buffer_object *bo)
 {
 	struct drm_mem_type_manager *man;
 
@@ -89,7 +89,7 @@ void drm_bo_add_to_lru(struct drm_buffer_object * bo)
 	}
 }
 
-static int drm_bo_vm_pre_move(struct drm_buffer_object * bo, int old_is_pci)
+static int drm_bo_vm_pre_move(struct drm_buffer_object *bo, int old_is_pci)
 {
 #ifdef DRM_ODD_MM_COMPAT
 	int ret;
@@ -112,7 +112,7 @@ static int drm_bo_vm_pre_move(struct drm_buffer_object * bo, int old_is_pci)
 	return 0;
 }
 
-static void drm_bo_vm_post_move(struct drm_buffer_object * bo)
+static void drm_bo_vm_post_move(struct drm_buffer_object *bo)
 {
 #ifdef DRM_ODD_MM_COMPAT
 	int ret;
@@ -133,7 +133,7 @@ static void drm_bo_vm_post_move(struct drm_buffer_object * bo)
  * Call bo->mutex locked.
  */
 
-static int drm_bo_add_ttm(struct drm_buffer_object * bo)
+static int drm_bo_add_ttm(struct drm_buffer_object *bo)
 {
 	struct drm_device *dev = bo->dev;
 	int ret = 0;
@@ -171,8 +171,8 @@ static int drm_bo_add_ttm(struct drm_buffer_object * bo)
 	return ret;
 }
 
-static int drm_bo_handle_move_mem(struct drm_buffer_object * bo,
-				  struct drm_bo_mem_reg * mem,
+static int drm_bo_handle_move_mem(struct drm_buffer_object *bo,
+				  struct drm_bo_mem_reg *mem,
 				  int evict, int no_wait)
 {
 	struct drm_device *dev = bo->dev;
@@ -255,7 +255,7 @@ static int drm_bo_handle_move_mem(struct drm_buffer_object * bo,
 
 	return 0;
 
-      out_err:
+out_err:
 	if (old_is_pci || new_is_pci)
 		drm_bo_vm_post_move(bo);
 
@@ -274,7 +274,7 @@ static int drm_bo_handle_move_mem(struct drm_buffer_object * bo,
  * Wait until the buffer is idle.
  */
 
-int drm_bo_wait(struct drm_buffer_object * bo, int lazy, int ignore_signals,
+int drm_bo_wait(struct drm_buffer_object *bo, int lazy, int ignore_signals,
 		int no_wait)
 {
 	int ret;
@@ -286,11 +286,10 @@ int drm_bo_wait(struct drm_buffer_object * bo, int lazy, int ignore_signals,
 			drm_fence_usage_deref_unlocked(&bo->fence);
 			return 0;
 		}
-		if (no_wait) {
+		if (no_wait)
 			return -EBUSY;
-		}
-		ret =
-		    drm_fence_object_wait(bo->fence, lazy, ignore_signals,
+
+		ret = drm_fence_object_wait(bo->fence, lazy, ignore_signals,
 					  bo->fence_type);
 		if (ret)
 			return ret;
@@ -301,7 +300,7 @@ int drm_bo_wait(struct drm_buffer_object * bo, int lazy, int ignore_signals,
 }
 EXPORT_SYMBOL(drm_bo_wait);
 
-static int drm_bo_expire_fence(struct drm_buffer_object * bo, int allow_errors)
+static int drm_bo_expire_fence(struct drm_buffer_object *bo, int allow_errors)
 {
 	struct drm_device *dev = bo->dev;
 	struct drm_buffer_manager *bm = &dev->bm;
@@ -336,7 +335,7 @@ static int drm_bo_expire_fence(struct drm_buffer_object * bo, int allow_errors)
  * fence object and removing from lru lists and memory managers.
  */
 
-static void drm_bo_cleanup_refs(struct drm_buffer_object * bo, int remove_all)
+static void drm_bo_cleanup_refs(struct drm_buffer_object *bo, int remove_all)
 {
 	struct drm_device *dev = bo->dev;
 	struct drm_buffer_manager *bm = &dev->bm;
@@ -358,9 +357,8 @@ static void drm_bo_cleanup_refs(struct drm_buffer_object * bo, int remove_all)
 
 	mutex_lock(&dev->struct_mutex);
 
-	if (!atomic_dec_and_test(&bo->usage)) {
+	if (!atomic_dec_and_test(&bo->usage))
 		goto out;
-	}
 
 	if (!bo->fence) {
 		list_del_init(&bo->lru);
@@ -388,7 +386,7 @@ static void drm_bo_cleanup_refs(struct drm_buffer_object * bo, int remove_all)
 				      ((DRM_HZ / 100) < 1) ? 1 : DRM_HZ / 100);
 	}
 
-      out:
+out:
 	mutex_unlock(&bo->mutex);
 	return;
 }
@@ -398,7 +396,7 @@ static void drm_bo_cleanup_refs(struct drm_buffer_object * bo, int remove_all)
  * to the buffer object. Then destroy it.
  */
 
-static void drm_bo_destroy_locked(struct drm_buffer_object * bo)
+static void drm_bo_destroy_locked(struct drm_buffer_object *bo)
 {
 	struct drm_device *dev = bo->dev;
 	struct drm_buffer_manager *bm = &dev->bm;
@@ -427,7 +425,6 @@ static void drm_bo_destroy_locked(struct drm_buffer_object * bo)
 
 		atomic_dec(&bm->count);
 
-		//		BUG_ON(!list_empty(&bo->base.list));
 		drm_ctl_free(bo, sizeof(*bo), DRM_MEM_BUFOBJ);
 
 		return;
@@ -447,7 +444,7 @@ static void drm_bo_destroy_locked(struct drm_buffer_object * bo)
  * Call dev->struct_mutex locked.
  */
 
-static void drm_bo_delayed_delete(struct drm_device * dev, int remove_all)
+static void drm_bo_delayed_delete(struct drm_device *dev, int remove_all)
 {
 	struct drm_buffer_manager *bm = &dev->bm;
 
@@ -466,9 +463,8 @@ static void drm_bo_delayed_delete(struct drm_device * dev, int remove_all)
 
 		drm_bo_cleanup_refs(entry, remove_all);
 
-		if (nentry) {
+		if (nentry)
 			atomic_dec(&nentry->usage);
-		}
 	}
 }
 
@@ -502,21 +498,20 @@ static void drm_bo_delayed_workqueue(struct work_struct *work)
 	mutex_unlock(&dev->struct_mutex);
 }
 
-void drm_bo_usage_deref_locked(struct drm_buffer_object ** bo)
+void drm_bo_usage_deref_locked(struct drm_buffer_object **bo)
 {
-        struct drm_buffer_object *tmp_bo = *bo;
+	struct drm_buffer_object *tmp_bo = *bo;
 	bo = NULL;
 
 	DRM_ASSERT_LOCKED(&tmp_bo->dev->struct_mutex);
 
-	if (atomic_dec_and_test(&tmp_bo->usage)) {
+	if (atomic_dec_and_test(&tmp_bo->usage))
 		drm_bo_destroy_locked(tmp_bo);
-	}
 }
 EXPORT_SYMBOL(drm_bo_usage_deref_locked);
 
-static void drm_bo_base_deref_locked(struct drm_file * file_priv,
-				     struct drm_user_object * uo)
+static void drm_bo_base_deref_locked(struct drm_file *file_priv,
+				     struct drm_user_object *uo)
 {
 	struct drm_buffer_object *bo =
 	    drm_user_object_entry(uo, struct drm_buffer_object, base);
@@ -527,7 +522,7 @@ static void drm_bo_base_deref_locked(struct drm_file * file_priv,
 	drm_bo_usage_deref_locked(&bo);
 }
 
-void drm_bo_usage_deref_unlocked(struct drm_buffer_object ** bo)
+void drm_bo_usage_deref_unlocked(struct drm_buffer_object **bo)
 {
 	struct drm_buffer_object *tmp_bo = *bo;
 	struct drm_device *dev = tmp_bo->dev;
@@ -583,8 +578,8 @@ EXPORT_SYMBOL(drm_putback_buffer_objects);
 int drm_fence_buffer_objects(struct drm_device *dev,
 			     struct list_head *list,
 			     uint32_t fence_flags,
-			     struct drm_fence_object * fence,
-			     struct drm_fence_object ** used_fence)
+			     struct drm_fence_object *fence,
+			     struct drm_fence_object **used_fence)
 {
 	struct drm_buffer_manager *bm = &dev->bm;
 	struct drm_buffer_object *entry;
@@ -668,7 +663,7 @@ int drm_fence_buffer_objects(struct drm_device *dev,
 		l = list->next;
 	}
 	DRM_DEBUG("Fenced %d buffers\n", count);
-      out:
+out:
 	mutex_unlock(&dev->struct_mutex);
 	*used_fence = fence;
 	return ret;
@@ -679,7 +674,7 @@ EXPORT_SYMBOL(drm_fence_buffer_objects);
  * bo->mutex locked
  */
 
-static int drm_bo_evict(struct drm_buffer_object * bo, unsigned mem_type,
+static int drm_bo_evict(struct drm_buffer_object *bo, unsigned mem_type,
 			int no_wait)
 {
 	int ret = 0;
@@ -687,7 +682,8 @@ static int drm_bo_evict(struct drm_buffer_object * bo, unsigned mem_type,
 	struct drm_bo_mem_reg evict_mem;
 
 	/*
-	 * Someone might have modified the buffer before we took the buffer mutex.
+	 * Someone might have modified the buffer before we took the
+	 * buffer mutex.
 	 */
 
 	if (bo->priv_flags & _DRM_BO_FLAG_UNFENCED)
@@ -738,7 +734,7 @@ static int drm_bo_evict(struct drm_buffer_object * bo, unsigned mem_type,
 	DRM_FLAG_MASKED(bo->priv_flags, _DRM_BO_FLAG_EVICTED,
 			_DRM_BO_FLAG_EVICTED);
 
-      out:
+out:
 	return ret;
 }
 
@@ -746,8 +742,8 @@ static int drm_bo_evict(struct drm_buffer_object * bo, unsigned mem_type,
  * Repeatedly evict memory from the LRU for @mem_type until we create enough
  * space, or we've evicted everything and there isn't enough space.
  */
-static int drm_bo_mem_force_space(struct drm_device * dev,
-				  struct drm_bo_mem_reg * mem,
+static int drm_bo_mem_force_space(struct drm_device *dev,
+				  struct drm_bo_mem_reg *mem,
 				  uint32_t mem_type, int no_wait)
 {
 	struct drm_mm_node *node;
@@ -795,10 +791,10 @@ static int drm_bo_mem_force_space(struct drm_device * dev,
 	return 0;
 }
 
-static int drm_bo_mt_compatible(struct drm_mem_type_manager * man,
+static int drm_bo_mt_compatible(struct drm_mem_type_manager *man,
 				int disallow_fixed,
 				uint32_t mem_type,
-				uint64_t mask, uint32_t * res_mask)
+				uint64_t mask, uint32_t *res_mask)
 {
 	uint64_t cur_flags = drm_bo_type_flags(mem_type);
 	uint64_t flag_diff;
@@ -831,7 +827,7 @@ static int drm_bo_mt_compatible(struct drm_mem_type_manager * man,
 
 	if ((flag_diff & DRM_BO_FLAG_MAPPABLE) &&
 	    ((mask & DRM_BO_FLAG_MAPPABLE) ||
-	     (mask & DRM_BO_FLAG_FORCE_MAPPABLE)) )
+	     (mask & DRM_BO_FLAG_FORCE_MAPPABLE)))
 		return 0;
 
 	*res_mask = cur_flags;
@@ -846,8 +842,8 @@ static int drm_bo_mt_compatible(struct drm_mem_type_manager * man,
  * drm_bo_mem_force_space is attempted in priority order to evict and find
  * space.
  */
-int drm_bo_mem_space(struct drm_buffer_object * bo,
-		     struct drm_bo_mem_reg * mem, int no_wait)
+int drm_bo_mem_space(struct drm_buffer_object *bo,
+		     struct drm_bo_mem_reg *mem, int no_wait)
 {
 	struct drm_device *dev = bo->dev;
 	struct drm_buffer_manager *bm = &dev->bm;
@@ -941,10 +937,9 @@ int drm_bo_mem_space(struct drm_buffer_object * bo,
 	ret = (has_eagain) ? -EAGAIN : -ENOMEM;
 	return ret;
 }
-
 EXPORT_SYMBOL(drm_bo_mem_space);
 
-static int drm_bo_new_mask(struct drm_buffer_object * bo,
+static int drm_bo_new_mask(struct drm_buffer_object *bo,
 			   uint64_t new_flags, uint64_t used_mask)
 {
 	uint32_t new_props;
@@ -957,15 +952,12 @@ static int drm_bo_new_mask(struct drm_buffer_object * bo,
 	}
 
 	if ((used_mask & DRM_BO_FLAG_NO_EVICT) && !DRM_SUSER(DRM_CURPROC)) {
-		DRM_ERROR
-		    ("DRM_BO_FLAG_NO_EVICT is only available to priviliged "
-		     "processes.\n");
+		DRM_ERROR("DRM_BO_FLAG_NO_EVICT is only available to priviliged processes.\n");
 		return -EPERM;
 	}
 
 	if ((new_flags & DRM_BO_FLAG_NO_MOVE)) {
-		DRM_ERROR
-			("DRM_BO_FLAG_NO_MOVE is not properly implemented yet.\n");
+		DRM_ERROR("DRM_BO_FLAG_NO_MOVE is not properly implemented yet.\n");
 		return -EPERM;
 	}
 
@@ -1015,7 +1007,7 @@ EXPORT_SYMBOL(drm_lookup_buffer_object);
  * Doesn't do any fence flushing as opposed to the drm_bo_busy function.
  */
 
-static int drm_bo_quick_busy(struct drm_buffer_object * bo)
+static int drm_bo_quick_busy(struct drm_buffer_object *bo)
 {
 	struct drm_fence_object *fence = bo->fence;
 
@@ -1035,7 +1027,7 @@ static int drm_bo_quick_busy(struct drm_buffer_object * bo)
  * Returns 1 if the buffer is currently rendered to or from. 0 otherwise.
  */
 
-static int drm_bo_busy(struct drm_buffer_object * bo)
+static int drm_bo_busy(struct drm_buffer_object *bo)
 {
 	struct drm_fence_object *fence = bo->fence;
 
@@ -1055,7 +1047,7 @@ static int drm_bo_busy(struct drm_buffer_object * bo)
 	return 0;
 }
 
-static int drm_bo_evict_cached(struct drm_buffer_object * bo)
+static int drm_bo_evict_cached(struct drm_buffer_object *bo)
 {
 	int ret = 0;
 
@@ -1069,7 +1061,7 @@ static int drm_bo_evict_cached(struct drm_buffer_object * bo)
  * Wait until a buffer is unmapped.
  */
 
-static int drm_bo_wait_unmapped(struct drm_buffer_object * bo, int no_wait)
+static int drm_bo_wait_unmapped(struct drm_buffer_object *bo, int no_wait)
 {
 	int ret = 0;
 
@@ -1085,7 +1077,7 @@ static int drm_bo_wait_unmapped(struct drm_buffer_object * bo, int no_wait)
 	return ret;
 }
 
-static int drm_bo_check_unfenced(struct drm_buffer_object * bo)
+static int drm_bo_check_unfenced(struct drm_buffer_object *bo)
 {
 	int ret;
 
@@ -1100,7 +1092,7 @@ static int drm_bo_check_unfenced(struct drm_buffer_object * bo)
  * Until then, we cannot really do anything with it except delete it.
  */
 
-static int drm_bo_wait_unfenced(struct drm_buffer_object * bo, int no_wait,
+static int drm_bo_wait_unfenced(struct drm_buffer_object *bo, int no_wait,
 				int eagain_if_wait)
 {
 	int ret = (bo->priv_flags & _DRM_BO_FLAG_UNFENCED);
@@ -1133,7 +1125,7 @@ static int drm_bo_wait_unfenced(struct drm_buffer_object * bo, int no_wait,
  * Bo locked.
  */
 
-static void drm_bo_fill_rep_arg(struct drm_buffer_object * bo,
+static void drm_bo_fill_rep_arg(struct drm_buffer_object *bo,
 				struct drm_bo_info_rep *rep)
 {
 	if (!rep)
@@ -1237,7 +1229,7 @@ static int drm_buffer_object_map(struct drm_file *file_priv, uint32_t handle,
 
 	} else
 		drm_bo_fill_rep_arg(bo, rep);
-      out:
+out:
 	mutex_unlock(&bo->mutex);
 	drm_bo_usage_deref_unlocked(&bo);
 	return ret;
@@ -1266,7 +1258,7 @@ static int drm_buffer_object_unmap(struct drm_file *file_priv, uint32_t handle)
 
 	drm_remove_ref_object(file_priv, ro);
 	drm_bo_usage_deref_locked(&bo);
-      out:
+out:
 	mutex_unlock(&dev->struct_mutex);
 	return ret;
 }
@@ -1276,7 +1268,7 @@ static int drm_buffer_object_unmap(struct drm_file *file_priv, uint32_t handle)
  */
 
 static void drm_buffer_user_object_unmap(struct drm_file *file_priv,
-					 struct drm_user_object * uo,
+					 struct drm_user_object *uo,
 					 enum drm_ref_type action)
 {
 	struct drm_buffer_object *bo =
@@ -1298,7 +1290,7 @@ static void drm_buffer_user_object_unmap(struct drm_file *file_priv,
  * Note that new_mem_flags are NOT transferred to the bo->mem.mask.
  */
 
-int drm_bo_move_buffer(struct drm_buffer_object * bo, uint64_t new_mem_flags,
+int drm_bo_move_buffer(struct drm_buffer_object *bo, uint64_t new_mem_flags,
 		       int no_wait, int move_unfenced)
 {
 	struct drm_device *dev = bo->dev;
@@ -1338,7 +1330,7 @@ int drm_bo_move_buffer(struct drm_buffer_object * bo, uint64_t new_mem_flags,
 
 	ret = drm_bo_handle_move_mem(bo, &mem, 0, no_wait);
 
- out_unlock:
+out_unlock:
 	if (ret || !move_unfenced) {
 		mutex_lock(&dev->struct_mutex);
 		if (mem.mm_node) {
@@ -1353,7 +1345,7 @@ int drm_bo_move_buffer(struct drm_buffer_object * bo, uint64_t new_mem_flags,
 	return ret;
 }
 
-static int drm_bo_mem_compat(struct drm_bo_mem_reg * mem)
+static int drm_bo_mem_compat(struct drm_bo_mem_reg *mem)
 {
 	uint32_t flag_diff = (mem->mask ^ mem->flags);
 
@@ -1361,9 +1353,9 @@ static int drm_bo_mem_compat(struct drm_bo_mem_reg * mem)
 		return 0;
 	if ((flag_diff & DRM_BO_FLAG_CACHED) &&
 	    (/* !(mem->mask & DRM_BO_FLAG_CACHED) ||*/
-	     (mem->mask & DRM_BO_FLAG_FORCE_CACHING))) {
-	  return 0;
-	}
+	     (mem->mask & DRM_BO_FLAG_FORCE_CACHING)))
+		return 0;
+
 	if ((flag_diff & DRM_BO_FLAG_MAPPABLE) &&
 	    ((mem->mask & DRM_BO_FLAG_MAPPABLE) ||
 	     (mem->mask & DRM_BO_FLAG_FORCE_MAPPABLE)))
@@ -1375,7 +1367,7 @@ static int drm_bo_mem_compat(struct drm_bo_mem_reg * mem)
  * bo locked.
  */
 
-static int drm_buffer_object_validate(struct drm_buffer_object * bo,
+static int drm_buffer_object_validate(struct drm_buffer_object *bo,
 				      uint32_t fence_class,
 				      int move_unfenced, int no_wait)
 {
@@ -1418,7 +1410,7 @@ static int drm_buffer_object_validate(struct drm_buffer_object * bo,
 
 	ret = drm_bo_wait_unmapped(bo, no_wait);
 	if (ret) {
-	        DRM_ERROR("Timed out waiting for buffer unmap.\n");
+		DRM_ERROR("Timed out waiting for buffer unmap.\n");
 		return ret;
 	}
 
@@ -1535,12 +1527,12 @@ out:
 EXPORT_SYMBOL(drm_bo_do_validate);
 
 
-int drm_bo_handle_validate(struct drm_file * file_priv, uint32_t handle,
+int drm_bo_handle_validate(struct drm_file *file_priv, uint32_t handle,
 			   uint32_t fence_class,
 			   uint64_t flags, uint64_t mask,
 			   uint32_t hint,
 			   int use_old_fence_class,
-			   struct drm_bo_info_rep * rep,
+			   struct drm_bo_info_rep *rep,
 			   struct drm_buffer_object **bo_rep)
 {
 	struct drm_device *dev = file_priv->head->dev;
@@ -1588,9 +1580,9 @@ static int drm_bo_handle_info(struct drm_file *file_priv, uint32_t handle,
 	bo = drm_lookup_buffer_object(file_priv, handle, 1);
 	mutex_unlock(&dev->struct_mutex);
 
-	if (!bo) {
+	if (!bo)
 		return -EINVAL;
-	}
+
 	mutex_lock(&bo->mutex);
 	if (!(bo->priv_flags & _DRM_BO_FLAG_UNFENCED))
 		(void)drm_bo_busy(bo);
@@ -1613,9 +1605,8 @@ static int drm_bo_handle_wait(struct drm_file *file_priv, uint32_t handle,
 	bo = drm_lookup_buffer_object(file_priv, handle, 1);
 	mutex_unlock(&dev->struct_mutex);
 
-	if (!bo) {
+	if (!bo)
 		return -EINVAL;
-	}
 
 	mutex_lock(&bo->mutex);
 	ret = drm_bo_wait_unfenced(bo, no_wait, 0);
@@ -1627,7 +1618,7 @@ static int drm_bo_handle_wait(struct drm_file *file_priv, uint32_t handle,
 
 	drm_bo_fill_rep_arg(bo, rep);
 
-      out:
+out:
 	mutex_unlock(&bo->mutex);
 	drm_bo_usage_deref_unlocked(&bo);
 	return ret;
@@ -1640,7 +1631,7 @@ int drm_buffer_object_create(struct drm_device *dev,
 			     uint32_t hint,
 			     uint32_t page_alignment,
 			     unsigned long buffer_start,
-			     struct drm_buffer_object ** buf_obj)
+			     struct drm_buffer_object **buf_obj)
 {
 	struct drm_buffer_manager *bm = &dev->bm;
 	struct drm_buffer_object *bo;
@@ -1706,7 +1697,7 @@ int drm_buffer_object_create(struct drm_device *dev,
 	*buf_obj = bo;
 	return 0;
 
-      out_err:
+out_err:
 	mutex_unlock(&bo->mutex);
 
 	drm_bo_usage_deref_unlocked(&bo);
@@ -1731,7 +1722,7 @@ static int drm_bo_add_user_object(struct drm_file *file_priv,
 	bo->base.ref_struct_locked = NULL;
 	bo->base.unref = drm_buffer_user_object_unmap;
 
-      out:
+out:
 	mutex_unlock(&dev->struct_mutex);
 	return ret;
 }
@@ -1921,7 +1912,7 @@ int drm_bo_wait_idle_ioctl(struct drm_device *dev, void *data, struct drm_file *
 	return 0;
 }
 
-static int drm_bo_leave_list(struct drm_buffer_object * bo,
+static int drm_bo_leave_list(struct drm_buffer_object *bo,
 			     uint32_t mem_type,
 			     int free_pinned,
 			     int allow_errors)
@@ -1967,7 +1958,7 @@ static int drm_bo_leave_list(struct drm_buffer_object * bo,
 		}
 	}
 
-      out:
+out:
 	mutex_unlock(&bo->mutex);
 	return ret;
 }
@@ -1986,7 +1977,7 @@ static struct drm_buffer_object *drm_bo_entry(struct list_head *list,
  * dev->struct_mutex locked.
  */
 
-static int drm_bo_force_list_clean(struct drm_device * dev,
+static int drm_bo_force_list_clean(struct drm_device *dev,
 				   struct list_head *head,
 				   unsigned mem_type,
 				   int free_pinned,
@@ -2051,7 +2042,7 @@ restart:
 	return 0;
 }
 
-int drm_bo_clean_mm(struct drm_device * dev, unsigned mem_type)
+int drm_bo_clean_mm(struct drm_device *dev, unsigned mem_type)
 {
 	struct drm_buffer_manager *bm = &dev->bm;
 	struct drm_mem_type_manager *man = &bm->man[mem_type];
@@ -2093,7 +2084,7 @@ EXPORT_SYMBOL(drm_bo_clean_mm);
  *point since we have the hardware lock.
  */
 
-static int drm_bo_lock_mm(struct drm_device * dev, unsigned mem_type)
+static int drm_bo_lock_mm(struct drm_device *dev, unsigned mem_type)
 {
 	int ret;
 	struct drm_buffer_manager *bm = &dev->bm;
@@ -2118,7 +2109,7 @@ static int drm_bo_lock_mm(struct drm_device * dev, unsigned mem_type)
 	return ret;
 }
 
-int drm_bo_init_mm(struct drm_device * dev,
+int drm_bo_init_mm(struct drm_device *dev,
 		   unsigned type,
 		   unsigned long p_offset, unsigned long p_size)
 {
@@ -2169,7 +2160,7 @@ EXPORT_SYMBOL(drm_bo_init_mm);
  * (This may happen on X server restart).
  */
 
-int drm_bo_driver_finish(struct drm_device * dev)
+int drm_bo_driver_finish(struct drm_device *dev)
 {
 	struct drm_buffer_manager *bm = &dev->bm;
 	int ret = 0;
@@ -2196,23 +2187,22 @@ int drm_bo_driver_finish(struct drm_device * dev)
 	}
 	mutex_unlock(&dev->struct_mutex);
 
-	if (!cancel_delayed_work(&bm->wq)) {
+	if (!cancel_delayed_work(&bm->wq))
 		flush_scheduled_work();
-	}
+
 	mutex_lock(&dev->struct_mutex);
 	drm_bo_delayed_delete(dev, 1);
-	if (list_empty(&bm->ddestroy)) {
+	if (list_empty(&bm->ddestroy))
 		DRM_DEBUG("Delayed destroy list was clean\n");
-	}
-	if (list_empty(&bm->man[0].lru)) {
+
+	if (list_empty(&bm->man[0].lru))
 		DRM_DEBUG("Swap list was clean\n");
-	}
-	if (list_empty(&bm->man[0].pinned)) {
+
+	if (list_empty(&bm->man[0].pinned))
 		DRM_DEBUG("NO_MOVE list was clean\n");
-	}
-	if (list_empty(&bm->unfenced)) {
+
+	if (list_empty(&bm->unfenced))
 		DRM_DEBUG("Unfenced list was clean\n");
-	}
 
 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,15))
 	unlock_page(bm->dummy_read_page);
@@ -2233,7 +2223,7 @@ out:
  * (This may happen on X server restart).
  */
 
-int drm_bo_driver_init(struct drm_device * dev)
+int drm_bo_driver_init(struct drm_device *dev)
 {
 	struct drm_bo_driver *driver = dev->driver->bo_driver;
 	struct drm_buffer_manager *bm = &dev->bm;
@@ -2276,11 +2266,10 @@ int drm_bo_driver_init(struct drm_device * dev)
 	bm->cur_pages = 0;
 	INIT_LIST_HEAD(&bm->unfenced);
 	INIT_LIST_HEAD(&bm->ddestroy);
-      out_unlock:
+out_unlock:
 	mutex_unlock(&dev->struct_mutex);
 	return ret;
 }
-
 EXPORT_SYMBOL(drm_bo_driver_init);
 
 int drm_mm_init_ioctl(struct drm_device *dev, void *data, struct drm_file *file_priv)
@@ -2434,7 +2423,7 @@ int drm_mm_unlock_ioctl(struct drm_device *dev,
  * buffer object vm functions.
  */
 
-int drm_mem_reg_is_pci(struct drm_device * dev, struct drm_bo_mem_reg * mem)
+int drm_mem_reg_is_pci(struct drm_device *dev, struct drm_bo_mem_reg *mem)
 {
 	struct drm_buffer_manager *bm = &dev->bm;
 	struct drm_mem_type_manager *man = &bm->man[mem->mem_type];
@@ -2451,7 +2440,6 @@ int drm_mem_reg_is_pci(struct drm_device * dev, struct drm_bo_mem_reg * mem)
 	}
 	return 1;
 }
-
 EXPORT_SYMBOL(drm_mem_reg_is_pci);
 
 /**
@@ -2497,7 +2485,7 @@ int drm_bo_pci_offset(struct drm_device *dev,
  * Call bo->mutex locked.
  */
 
-void drm_bo_unmap_virtual(struct drm_buffer_object * bo)
+void drm_bo_unmap_virtual(struct drm_buffer_object *bo)
 {
 	struct drm_device *dev = bo->dev;
 	loff_t offset = ((loff_t) bo->map_list.hash.key) << PAGE_SHIFT;
@@ -2509,9 +2497,9 @@ void drm_bo_unmap_virtual(struct drm_buffer_object * bo)
 	unmap_mapping_range(dev->dev_mapping, offset, holelen, 1);
 }
 
-static void drm_bo_takedown_vm_locked(struct drm_buffer_object * bo)
+static void drm_bo_takedown_vm_locked(struct drm_buffer_object *bo)
 {
-        struct drm_map_list *list;
+	struct drm_map_list *list;
 	drm_local_map_t *map;
 	struct drm_device *dev = bo->dev;
 
@@ -2539,7 +2527,7 @@ static void drm_bo_takedown_vm_locked(struct drm_buffer_object * bo)
 	drm_bo_usage_deref_locked(&bo);
 }
 
-static int drm_bo_setup_vm_locked(struct drm_buffer_object * bo)
+static int drm_bo_setup_vm_locked(struct drm_buffer_object *bo)
 {
 	struct drm_map_list *list = &bo->map_list;
 	drm_local_map_t *map;
diff --git a/linux-core/drm_objects.h b/linux-core/drm_objects.h
index c9c1fdb8..92c56031 100644
--- a/linux-core/drm_objects.h
+++ b/linux-core/drm_objects.h
@@ -68,12 +68,12 @@ struct drm_user_object {
 	atomic_t refcount;
 	int shareable;
 	struct drm_file *owner;
-	void (*ref_struct_locked) (struct drm_file * priv,
-				   struct drm_user_object * obj,
+	void (*ref_struct_locked) (struct drm_file *priv,
+				   struct drm_user_object *obj,
 				   enum drm_ref_type ref_action);
-	void (*unref) (struct drm_file * priv, struct drm_user_object * obj,
+	void (*unref) (struct drm_file *priv, struct drm_user_object *obj,
 		       enum drm_ref_type unref_action);
-	void (*remove) (struct drm_file * priv, struct drm_user_object * obj);
+	void (*remove) (struct drm_file *priv, struct drm_user_object *obj);
 };
 
 /*
@@ -94,29 +94,29 @@ struct drm_ref_object {
  * Must be called with the struct_mutex held.
  */
 
-extern int drm_add_user_object(struct drm_file * priv, struct drm_user_object * item,
+extern int drm_add_user_object(struct drm_file *priv, struct drm_user_object *item,
 			       int shareable);
 /**
  * Must be called with the struct_mutex held.
  */
 
-extern struct drm_user_object *drm_lookup_user_object(struct drm_file * priv,
+extern struct drm_user_object *drm_lookup_user_object(struct drm_file *priv,
 						 uint32_t key);
 
 /*
  * Must be called with the struct_mutex held. May temporarily release it.
  */
 
-extern int drm_add_ref_object(struct drm_file * priv,
-			      struct drm_user_object * referenced_object,
+extern int drm_add_ref_object(struct drm_file *priv,
+			      struct drm_user_object *referenced_object,
 			      enum drm_ref_type ref_action);
 
 /*
  * Must be called with the struct_mutex held.
  */
 
-struct drm_ref_object *drm_lookup_ref_object(struct drm_file * priv,
-					struct drm_user_object * referenced_object,
+struct drm_ref_object *drm_lookup_ref_object(struct drm_file *priv,
+					struct drm_user_object *referenced_object,
 					enum drm_ref_type ref_action);
 /*
  * Must be called with the struct_mutex held.
@@ -125,11 +125,11 @@ struct drm_ref_object *drm_lookup_ref_object(struct drm_file * priv,
  * This function may temporarily release the struct_mutex.
  */
 
-extern void drm_remove_ref_object(struct drm_file * priv, struct drm_ref_object * item);
-extern int drm_user_object_ref(struct drm_file * priv, uint32_t user_token,
+extern void drm_remove_ref_object(struct drm_file *priv, struct drm_ref_object *item);
+extern int drm_user_object_ref(struct drm_file *priv, uint32_t user_token,
 			       enum drm_object_type type,
-			       struct drm_user_object ** object);
-extern int drm_user_object_unref(struct drm_file * priv, uint32_t user_token,
+			       struct drm_user_object **object);
+extern int drm_user_object_unref(struct drm_file *priv, uint32_t user_token,
 				 enum drm_object_type type);
 
 /***************************************************
@@ -138,7 +138,7 @@ extern int drm_user_object_unref(struct drm_file * priv, uint32_t user_token,
 
 struct drm_fence_object {
 	struct drm_user_object base;
-        struct drm_device *dev;
+	struct drm_device *dev;
 	atomic_t usage;
 
 	/*
@@ -153,7 +153,7 @@ struct drm_fence_object {
 	uint32_t sequence;
 	uint32_t flush_mask;
 	uint32_t submitted_flush;
-        uint32_t error;
+	uint32_t error;
 };
 
 #define _DRM_FENCE_CLASSES 8
@@ -182,40 +182,44 @@ struct drm_fence_driver {
 	uint32_t flush_diff;
 	uint32_t sequence_mask;
 	int lazy_capable;
-	int (*has_irq) (struct drm_device * dev, uint32_t fence_class,
+	int (*has_irq) (struct drm_device *dev, uint32_t fence_class,
 			uint32_t flags);
-	int (*emit) (struct drm_device * dev, uint32_t fence_class, uint32_t flags,
-		     uint32_t * breadcrumb, uint32_t * native_type);
-	void (*poke_flush) (struct drm_device * dev, uint32_t fence_class);
+	int (*emit) (struct drm_device *dev, uint32_t fence_class,
+		     uint32_t flags, uint32_t *breadcrumb,
+		     uint32_t *native_type);
+	void (*poke_flush) (struct drm_device *dev, uint32_t fence_class);
 };
 
 extern void drm_fence_handler(struct drm_device *dev, uint32_t fence_class,
-			      uint32_t sequence, uint32_t type, uint32_t error);
+			      uint32_t sequence, uint32_t type,
+			      uint32_t error);
 extern void drm_fence_manager_init(struct drm_device *dev);
 extern void drm_fence_manager_takedown(struct drm_device *dev);
 extern void drm_fence_flush_old(struct drm_device *dev, uint32_t fence_class,
 				uint32_t sequence);
-extern int drm_fence_object_flush(struct drm_fence_object * fence, uint32_t type);
-extern int drm_fence_object_signaled(struct drm_fence_object * fence,
+extern int drm_fence_object_flush(struct drm_fence_object *fence,
+				  uint32_t type);
+extern int drm_fence_object_signaled(struct drm_fence_object *fence,
 				     uint32_t type, int flush);
-extern void drm_fence_usage_deref_locked(struct drm_fence_object ** fence);
-extern void drm_fence_usage_deref_unlocked(struct drm_fence_object ** fence);
+extern void drm_fence_usage_deref_locked(struct drm_fence_object **fence);
+extern void drm_fence_usage_deref_unlocked(struct drm_fence_object **fence);
 extern struct drm_fence_object *drm_fence_reference_locked(struct drm_fence_object *src);
 extern void drm_fence_reference_unlocked(struct drm_fence_object **dst,
 					 struct drm_fence_object *src);
-extern int drm_fence_object_wait(struct drm_fence_object * fence,
+extern int drm_fence_object_wait(struct drm_fence_object *fence,
 				 int lazy, int ignore_signals, uint32_t mask);
 extern int drm_fence_object_create(struct drm_device *dev, uint32_t type,
 				   uint32_t fence_flags, uint32_t fence_class,
-				   struct drm_fence_object ** c_fence);
-extern int drm_fence_object_emit(struct drm_fence_object * fence,
+				   struct drm_fence_object **c_fence);
+extern int drm_fence_object_emit(struct drm_fence_object *fence,
 				 uint32_t fence_flags, uint32_t class,
 				 uint32_t type);
 extern void drm_fence_fill_arg(struct drm_fence_object *fence,
 			       struct drm_fence_arg *arg);
 
-extern int drm_fence_add_user_object(struct drm_file * priv,
-				     struct drm_fence_object * fence, int shareable);
+extern int drm_fence_add_user_object(struct drm_file *priv,
+				     struct drm_fence_object *fence,
+				     int shareable);
 
 extern int drm_fence_create_ioctl(struct drm_device *dev, void *data,
 				  struct drm_file *file_priv);
@@ -242,7 +246,7 @@ extern int drm_fence_buffers_ioctl(struct drm_device *dev, void *data,
 /*
  * The ttm backend GTT interface. (In our case AGP).
  * Any similar type of device (PCIE?)
- * needs only to implement these functions to be usable with the "TTM" interface.
+ * needs only to implement these functions to be usable with the TTM interface.
  * The AGP backend implementation lives in drm_agpsupport.c
  * basically maps these calls to available functions in agpgart.
  * Each drm device driver gets an
@@ -257,25 +261,25 @@ extern int drm_fence_buffers_ioctl(struct drm_device *dev, void *data,
 
 struct drm_ttm_backend;
 struct drm_ttm_backend_func {
-	int (*needs_ub_cache_adjust) (struct drm_ttm_backend * backend);
-	int (*populate) (struct drm_ttm_backend * backend,
-			 unsigned long num_pages, struct page ** pages);
-	void (*clear) (struct drm_ttm_backend * backend);
-	int (*bind) (struct drm_ttm_backend * backend,
-		     struct drm_bo_mem_reg * bo_mem);
-	int (*unbind) (struct drm_ttm_backend * backend);
-	void (*destroy) (struct drm_ttm_backend * backend);
+	int (*needs_ub_cache_adjust) (struct drm_ttm_backend *backend);
+	int (*populate) (struct drm_ttm_backend *backend,
+			 unsigned long num_pages, struct page **pages);
+	void (*clear) (struct drm_ttm_backend *backend);
+	int (*bind) (struct drm_ttm_backend *backend,
+		     struct drm_bo_mem_reg *bo_mem);
+	int (*unbind) (struct drm_ttm_backend *backend);
+	void (*destroy) (struct drm_ttm_backend *backend);
 };
 
 
-typedef struct drm_ttm_backend {
-        struct drm_device *dev;
-        uint32_t flags;
-        struct drm_ttm_backend_func *func;
-} drm_ttm_backend_t;
+struct drm_ttm_backend {
+	struct drm_device *dev;
+	uint32_t flags;
+	struct drm_ttm_backend_func *func;
+};
 
 struct drm_ttm {
-        struct mm_struct *user_mm;
+	struct mm_struct *user_mm;
 	struct page *dummy_read_page;
 	struct page **pages;
 	uint32_t page_flags;
@@ -295,13 +299,13 @@ struct drm_ttm {
 };
 
 extern struct drm_ttm *drm_ttm_init(struct drm_device *dev, unsigned long size);
-extern int drm_bind_ttm(struct drm_ttm * ttm, struct drm_bo_mem_reg *bo_mem);
-extern void drm_ttm_unbind(struct drm_ttm * ttm);
-extern void drm_ttm_evict(struct drm_ttm * ttm);
-extern void drm_ttm_fixup_caching(struct drm_ttm * ttm);
-extern struct page *drm_ttm_get_page(struct drm_ttm * ttm, int index);
+extern int drm_bind_ttm(struct drm_ttm *ttm, struct drm_bo_mem_reg *bo_mem);
+extern void drm_ttm_unbind(struct drm_ttm *ttm);
+extern void drm_ttm_evict(struct drm_ttm *ttm);
+extern void drm_ttm_fixup_caching(struct drm_ttm *ttm);
+extern struct page *drm_ttm_get_page(struct drm_ttm *ttm, int index);
 extern void drm_ttm_cache_flush(void);
-extern int drm_ttm_populate(struct drm_ttm * ttm);
+extern int drm_ttm_populate(struct drm_ttm *ttm);
 extern int drm_ttm_set_user(struct drm_ttm *ttm,
 			    struct task_struct *tsk,
 			    int write,
@@ -310,12 +314,12 @@ extern int drm_ttm_set_user(struct drm_ttm *ttm,
 			    struct page *dummy_read_page);
 
 /*
- * Destroy a ttm. The user normally calls drmRmMap or a similar IOCTL to do this,
- * which calls this function iff there are no vmas referencing it anymore. Otherwise it is called
- * when the last vma exits.
+ * Destroy a ttm. The user normally calls drmRmMap or a similar IOCTL to do
+ * this which calls this function iff there are no vmas referencing it anymore.
+ * Otherwise it is called when the last vma exits.
  */
 
-extern int drm_destroy_ttm(struct drm_ttm * ttm);
+extern int drm_destroy_ttm(struct drm_ttm *ttm);
 
 #define DRM_FLAG_MASKED(_old, _new, _mask) {\
 (_old) ^= (((_old) ^ (_new)) & (_mask)); \
@@ -350,8 +354,8 @@ struct drm_bo_mem_reg {
 	uint32_t mem_type;
 	uint64_t flags;
 	uint64_t mask;
-        uint32_t desired_tile_stride;
-        uint32_t hw_tile_stride;
+	uint32_t desired_tile_stride;
+	uint32_t hw_tile_stride;
 };
 
 enum drm_bo_type {
@@ -381,8 +385,8 @@ struct drm_buffer_object {
 
 	uint32_t fence_type;
 	uint32_t fence_class;
-        uint32_t new_fence_type;
-        uint32_t new_fence_class;
+	uint32_t new_fence_type;
+	uint32_t new_fence_class;
 	struct drm_fence_object *fence;
 	uint32_t priv_flags;
 	wait_queue_head_t event_queue;
@@ -421,7 +425,7 @@ struct drm_mem_type_manager {
 	struct list_head pinned;
 	uint32_t flags;
 	uint32_t drm_bus_maptype;
-        unsigned long gpu_offset;
+	unsigned long gpu_offset;
 	unsigned long io_offset;
 	unsigned long io_size;
 	void *io_addr;
@@ -443,8 +447,8 @@ struct drm_bo_lock {
 #define _DRM_FLAG_MEMTYPE_CSELECT   0x00000020	/* Select caching */
 
 struct drm_buffer_manager {
-        struct drm_bo_lock bm_lock;
-        struct mutex evict_mutex;
+	struct drm_bo_lock bm_lock;
+	struct mutex evict_mutex;
 	int nice_mode;
 	int initialized;
 	struct drm_file *last_to_validate;
@@ -468,15 +472,15 @@ struct drm_bo_driver {
 	uint32_t num_mem_type_prio;
 	uint32_t num_mem_busy_prio;
 	struct drm_ttm_backend *(*create_ttm_backend_entry)
-	 (struct drm_device * dev);
+	 (struct drm_device *dev);
 	int (*fence_type) (struct drm_buffer_object *bo, uint32_t *fclass,
-		     uint32_t * type);
-	int (*invalidate_caches) (struct drm_device * dev, uint64_t flags);
-	int (*init_mem_type) (struct drm_device * dev, uint32_t type,
-			      struct drm_mem_type_manager * man);
+			   uint32_t *type);
+	int (*invalidate_caches) (struct drm_device *dev, uint64_t flags);
+	int (*init_mem_type) (struct drm_device *dev, uint32_t type,
+			      struct drm_mem_type_manager *man);
 	 uint32_t(*evict_mask) (struct drm_buffer_object *bo);
-	int (*move) (struct drm_buffer_object * bo,
-		     int evict, int no_wait, struct drm_bo_mem_reg * new_mem);
+	int (*move) (struct drm_buffer_object *bo,
+		     int evict, int no_wait, struct drm_bo_mem_reg *new_mem);
 	void (*ttm_cache_flush)(struct drm_ttm *ttm);
 };
 
@@ -501,43 +505,43 @@ extern int drm_bo_version_ioctl(struct drm_device *dev, void *data, struct drm_f
 extern int drm_bo_driver_finish(struct drm_device *dev);
 extern int drm_bo_driver_init(struct drm_device *dev);
 extern int drm_bo_pci_offset(struct drm_device *dev,
-			     struct drm_bo_mem_reg * mem,
+			     struct drm_bo_mem_reg *mem,
 			     unsigned long *bus_base,
 			     unsigned long *bus_offset,
 			     unsigned long *bus_size);
-extern int drm_mem_reg_is_pci(struct drm_device *dev, struct drm_bo_mem_reg * mem);
+extern int drm_mem_reg_is_pci(struct drm_device *dev, struct drm_bo_mem_reg *mem);
 
-extern void drm_bo_usage_deref_locked(struct drm_buffer_object ** bo);
-extern void drm_bo_usage_deref_unlocked(struct drm_buffer_object ** bo);
+extern void drm_bo_usage_deref_locked(struct drm_buffer_object **bo);
+extern void drm_bo_usage_deref_unlocked(struct drm_buffer_object **bo);
 extern void drm_putback_buffer_objects(struct drm_device *dev);
-extern int drm_fence_buffer_objects(struct drm_device * dev,
+extern int drm_fence_buffer_objects(struct drm_device *dev,
 				    struct list_head *list,
 				    uint32_t fence_flags,
-				    struct drm_fence_object * fence,
-				    struct drm_fence_object ** used_fence);
-extern void drm_bo_add_to_lru(struct drm_buffer_object * bo);
+				    struct drm_fence_object *fence,
+				    struct drm_fence_object **used_fence);
+extern void drm_bo_add_to_lru(struct drm_buffer_object *bo);
 extern int drm_buffer_object_create(struct drm_device *dev, unsigned long size,
 				    enum drm_bo_type type, uint64_t mask,
 				    uint32_t hint, uint32_t page_alignment,
 				    unsigned long buffer_start,
 				    struct drm_buffer_object **bo);
-extern int drm_bo_wait(struct drm_buffer_object * bo, int lazy, int ignore_signals,
+extern int drm_bo_wait(struct drm_buffer_object *bo, int lazy, int ignore_signals,
 		       int no_wait);
-extern int drm_bo_mem_space(struct drm_buffer_object * bo,
-			    struct drm_bo_mem_reg * mem, int no_wait);
-extern int drm_bo_move_buffer(struct drm_buffer_object * bo,
+extern int drm_bo_mem_space(struct drm_buffer_object *bo,
+			    struct drm_bo_mem_reg *mem, int no_wait);
+extern int drm_bo_move_buffer(struct drm_buffer_object *bo,
 			      uint64_t new_mem_flags,
 			      int no_wait, int move_unfenced);
-extern int drm_bo_clean_mm(struct drm_device * dev, unsigned mem_type);
-extern int drm_bo_init_mm(struct drm_device * dev, unsigned type,
+extern int drm_bo_clean_mm(struct drm_device *dev, unsigned mem_type);
+extern int drm_bo_init_mm(struct drm_device *dev, unsigned type,
 			  unsigned long p_offset, unsigned long p_size);
-extern int drm_bo_handle_validate(struct drm_file * file_priv, uint32_t handle,
+extern int drm_bo_handle_validate(struct drm_file *file_priv, uint32_t handle,
 				  uint32_t fence_class, uint64_t flags,
 				  uint64_t mask, uint32_t hint,
 				  int use_old_fence_class,
-				  struct drm_bo_info_rep * rep,
+				  struct drm_bo_info_rep *rep,
 				  struct drm_buffer_object **bo_rep);
-extern struct drm_buffer_object *drm_lookup_buffer_object(struct drm_file * file_priv,
+extern struct drm_buffer_object *drm_lookup_buffer_object(struct drm_file *file_priv,
 							  uint32_t handle,
 							  int check_owner);
 extern int drm_bo_do_validate(struct drm_buffer_object *bo,
@@ -551,18 +555,17 @@ extern int drm_bo_do_validate(struct drm_buffer_object *bo,
  * drm_bo_move.c
  */
 
-extern int drm_bo_move_ttm(struct drm_buffer_object * bo,
-			   int evict, int no_wait, struct drm_bo_mem_reg * new_mem);
-extern int drm_bo_move_memcpy(struct drm_buffer_object * bo,
+extern int drm_bo_move_ttm(struct drm_buffer_object *bo,
+			   int evict, int no_wait,
+			   struct drm_bo_mem_reg *new_mem);
+extern int drm_bo_move_memcpy(struct drm_buffer_object *bo,
 			      int evict,
-			      int no_wait, struct drm_bo_mem_reg * new_mem);
-extern int drm_bo_move_accel_cleanup(struct drm_buffer_object * bo,
-				     int evict,
-				     int no_wait,
-				     uint32_t fence_class,
-				     uint32_t fence_type,
+			      int no_wait, struct drm_bo_mem_reg *new_mem);
+extern int drm_bo_move_accel_cleanup(struct drm_buffer_object *bo,
+				     int evict, int no_wait,
+				     uint32_t fence_class, uint32_t fence_type,
 				     uint32_t fence_flags,
-				     struct drm_bo_mem_reg * new_mem);
+				     struct drm_bo_mem_reg *new_mem);
 extern int drm_bo_same_page(unsigned long offset, unsigned long offset2);
 extern unsigned long drm_bo_offset_end(unsigned long offset,
 				       unsigned long end);
-- 
cgit v1.2.3


From 6ee5412da0cc7516472235805482b8632cb374ef Mon Sep 17 00:00:00 2001
From: Dave Airlie <airlied@linux.ie>
Date: Mon, 5 Nov 2007 19:09:18 +1000
Subject: drm/ttm: apply linux kernel coding style to bo_lock/move/object/ttm.c

---
 linux-core/drm_bo_lock.c |  9 +++----
 linux-core/drm_bo_move.c | 59 +++++++++++++++++++++------------------------
 linux-core/drm_object.c  | 36 +++++++++++++--------------
 linux-core/drm_ttm.c     | 63 +++++++++++++++++++++---------------------------
 4 files changed, 76 insertions(+), 91 deletions(-)

(limited to 'linux-core')

diff --git a/linux-core/drm_bo_lock.c b/linux-core/drm_bo_lock.c
index 46318f6a..f967fb7c 100644
--- a/linux-core/drm_bo_lock.c
+++ b/linux-core/drm_bo_lock.c
@@ -73,7 +73,6 @@ void drm_bo_read_unlock(struct drm_bo_lock *lock)
 	if (atomic_read(&lock->readers) == 0)
 		wake_up_interruptible(&lock->queue);
 }
-
 EXPORT_SYMBOL(drm_bo_read_unlock);
 
 int drm_bo_read_lock(struct drm_bo_lock *lock)
@@ -95,7 +94,6 @@ int drm_bo_read_lock(struct drm_bo_lock *lock)
 	}
 	return 0;
 }
-
 EXPORT_SYMBOL(drm_bo_read_lock);
 
 static int __drm_bo_write_unlock(struct drm_bo_lock *lock)
@@ -123,9 +121,8 @@ int drm_bo_write_lock(struct drm_bo_lock *lock, struct drm_file *file_priv)
 	int ret = 0;
 	struct drm_device *dev;
 
-	if (unlikely(atomic_cmpxchg(&lock->write_lock_pending, 0, 1) != 0)) {
+	if (unlikely(atomic_cmpxchg(&lock->write_lock_pending, 0, 1) != 0))
 		return -EINVAL;
-	}
 
 	while (unlikely(atomic_cmpxchg(&lock->readers, 0, -1) != 0)) {
 		ret = wait_event_interruptible
@@ -149,9 +146,9 @@ int drm_bo_write_lock(struct drm_bo_lock *lock, struct drm_file *file_priv)
 	ret = drm_add_user_object(file_priv, &lock->base, 0);
 	lock->base.remove = &drm_bo_write_lock_remove;
 	lock->base.type = drm_lock_type;
-	if (ret) {
+	if (ret)
 		(void)__drm_bo_write_unlock(lock);
-	}
+
 	mutex_unlock(&dev->struct_mutex);
 
 	return ret;
diff --git a/linux-core/drm_bo_move.c b/linux-core/drm_bo_move.c
index 9ab28b03..2aba3271 100644
--- a/linux-core/drm_bo_move.c
+++ b/linux-core/drm_bo_move.c
@@ -35,7 +35,7 @@
  * have not been requested to free also pinned regions.
  */
 
-static void drm_bo_free_old_node(struct drm_buffer_object * bo)
+static void drm_bo_free_old_node(struct drm_buffer_object *bo)
 {
 	struct drm_bo_mem_reg *old_mem = &bo->mem;
 
@@ -48,8 +48,8 @@ static void drm_bo_free_old_node(struct drm_buffer_object * bo)
 	old_mem->mm_node = NULL;
 }
 
-int drm_bo_move_ttm(struct drm_buffer_object * bo,
-		    int evict, int no_wait, struct drm_bo_mem_reg * new_mem)
+int drm_bo_move_ttm(struct drm_buffer_object *bo,
+		    int evict, int no_wait, struct drm_bo_mem_reg *new_mem)
 {
 	struct drm_ttm *ttm = bo->ttm;
 	struct drm_bo_mem_reg *old_mem = &bo->mem;
@@ -82,7 +82,6 @@ int drm_bo_move_ttm(struct drm_buffer_object * bo,
 	DRM_FLAG_MASKED(save_flags, new_mem->flags, DRM_BO_MASK_MEMTYPE);
 	return 0;
 }
-
 EXPORT_SYMBOL(drm_bo_move_ttm);
 
 /**
@@ -100,7 +99,7 @@ EXPORT_SYMBOL(drm_bo_move_ttm);
  * Call bo->mutex locked.
  */
 
-int drm_mem_reg_ioremap(struct drm_device * dev, struct drm_bo_mem_reg * mem,
+int drm_mem_reg_ioremap(struct drm_device *dev, struct drm_bo_mem_reg *mem,
 			void **virtual)
 {
 	struct drm_buffer_manager *bm = &dev->bm;
@@ -136,7 +135,7 @@ EXPORT_SYMBOL(drm_mem_reg_ioremap);
  * Call bo->mutex locked.
  */
 
-void drm_mem_reg_iounmap(struct drm_device * dev, struct drm_bo_mem_reg * mem,
+void drm_mem_reg_iounmap(struct drm_device *dev, struct drm_bo_mem_reg *mem,
 			 void *virtual)
 {
 	struct drm_buffer_manager *bm;
@@ -145,9 +144,8 @@ void drm_mem_reg_iounmap(struct drm_device * dev, struct drm_bo_mem_reg * mem,
 	bm = &dev->bm;
 	man = &bm->man[mem->mem_type];
 
-	if (virtual && (man->flags & _DRM_FLAG_NEEDS_IOREMAP)) {
+	if (virtual && (man->flags & _DRM_FLAG_NEEDS_IOREMAP))
 		iounmap(virtual);
-	}
 }
 
 static int drm_copy_io_page(void *dst, void *src, unsigned long page)
@@ -163,7 +161,8 @@ static int drm_copy_io_page(void *dst, void *src, unsigned long page)
 	return 0;
 }
 
-static int drm_copy_io_ttm_page(struct drm_ttm * ttm, void *src, unsigned long page)
+static int drm_copy_io_ttm_page(struct drm_ttm *ttm, void *src,
+				unsigned long page)
 {
 	struct page *d = drm_ttm_get_page(ttm, page);
 	void *dst;
@@ -181,7 +180,7 @@ static int drm_copy_io_ttm_page(struct drm_ttm * ttm, void *src, unsigned long p
 	return 0;
 }
 
-static int drm_copy_ttm_io_page(struct drm_ttm * ttm, void *dst, unsigned long page)
+static int drm_copy_ttm_io_page(struct drm_ttm *ttm, void *dst, unsigned long page)
 {
 	struct page *s = drm_ttm_get_page(ttm, page);
 	void *src;
@@ -199,8 +198,8 @@ static int drm_copy_ttm_io_page(struct drm_ttm * ttm, void *dst, unsigned long p
 	return 0;
 }
 
-int drm_bo_move_memcpy(struct drm_buffer_object * bo,
-		       int evict, int no_wait, struct drm_bo_mem_reg * new_mem)
+int drm_bo_move_memcpy(struct drm_buffer_object *bo,
+		       int evict, int no_wait, struct drm_bo_mem_reg *new_mem)
 {
 	struct drm_device *dev = bo->dev;
 	struct drm_mem_type_manager *man = &dev->bm.man[new_mem->mem_type];
@@ -251,7 +250,7 @@ int drm_bo_move_memcpy(struct drm_buffer_object * bo,
 			goto out1;
 	}
 	mb();
-      out2:
+out2:
 	drm_bo_free_old_node(bo);
 
 	*old_mem = *new_mem;
@@ -265,13 +264,12 @@ int drm_bo_move_memcpy(struct drm_buffer_object * bo,
 		bo->ttm = NULL;
 	}
 
-      out1:
+out1:
 	drm_mem_reg_iounmap(dev, new_mem, new_iomap);
-      out:
+out:
 	drm_mem_reg_iounmap(dev, &old_copy, old_iomap);
 	return ret;
 }
-
 EXPORT_SYMBOL(drm_bo_move_memcpy);
 
 /*
@@ -280,8 +278,8 @@ EXPORT_SYMBOL(drm_bo_move_memcpy);
  * object. Call bo->mutex locked.
  */
 
-int drm_buffer_object_transfer(struct drm_buffer_object * bo,
-			       struct drm_buffer_object ** new_obj)
+int drm_buffer_object_transfer(struct drm_buffer_object *bo,
+			       struct drm_buffer_object **new_obj)
 {
 	struct drm_buffer_object *fbo;
 	struct drm_device *dev = bo->dev;
@@ -322,12 +320,10 @@ int drm_buffer_object_transfer(struct drm_buffer_object * bo,
  * We cannot restart until it has finished.
  */
 
-int drm_bo_move_accel_cleanup(struct drm_buffer_object * bo,
-			      int evict,
-			      int no_wait,
-			      uint32_t fence_class,
-			      uint32_t fence_type,
-			      uint32_t fence_flags, struct drm_bo_mem_reg * new_mem)
+int drm_bo_move_accel_cleanup(struct drm_buffer_object *bo,
+			      int evict, int no_wait, uint32_t fence_class,
+			      uint32_t fence_type, uint32_t fence_flags,
+			      struct drm_bo_mem_reg *new_mem)
 {
 	struct drm_device *dev = bo->dev;
 	struct drm_mem_type_manager *man = &dev->bm.man[new_mem->mem_type];
@@ -407,7 +403,6 @@ int drm_bo_move_accel_cleanup(struct drm_buffer_object * bo,
 	DRM_FLAG_MASKED(save_flags, new_mem->flags, DRM_BO_MASK_MEMTYPE);
 	return 0;
 }
-
 EXPORT_SYMBOL(drm_bo_move_accel_cleanup);
 
 int drm_bo_same_page(unsigned long offset,
@@ -420,13 +415,11 @@ EXPORT_SYMBOL(drm_bo_same_page);
 unsigned long drm_bo_offset_end(unsigned long offset,
 				unsigned long end)
 {
-
 	offset = (offset + PAGE_SIZE) & PAGE_MASK;
 	return (end < offset) ? end : offset;
 }
 EXPORT_SYMBOL(drm_bo_offset_end);
 
-
 static pgprot_t drm_kernel_io_prot(uint32_t map_type)
 {
 	pgprot_t tmp = PAGE_KERNEL;
@@ -475,8 +468,9 @@ static int drm_bo_ioremap(struct drm_buffer_object *bo, unsigned long bus_base,
 	return (!map->virtual) ? -ENOMEM : 0;
 }
 
-static int drm_bo_kmap_ttm(struct drm_buffer_object *bo, unsigned long start_page,
-			   unsigned long num_pages, struct drm_bo_kmap_obj *map)
+static int drm_bo_kmap_ttm(struct drm_buffer_object *bo,
+			   unsigned long start_page, unsigned long num_pages,
+			   struct drm_bo_kmap_obj *map)
 {
 	struct drm_device *dev = bo->dev;
 	struct drm_bo_mem_reg *mem = &bo->mem;
@@ -503,7 +497,7 @@ static int drm_bo_kmap_ttm(struct drm_buffer_object *bo, unsigned long start_pag
 		 * Populate the part we're mapping;
 		 */
 
-		for (i = start_page; i< start_page + num_pages; ++i) {
+		for (i = start_page; i < start_page + num_pages; ++i) {
 			d = drm_ttm_get_page(ttm, i);
 			if (!d)
 				return -ENOMEM;
@@ -530,7 +524,8 @@ static int drm_bo_kmap_ttm(struct drm_buffer_object *bo, unsigned long start_pag
  * and caching policy the buffer currently has.
  * Mapping multiple pages or buffers that live in io memory is a bit slow and
  * consumes vmalloc space. Be restrictive with such mappings.
- * Mapping single pages usually returns the logical kernel address, (which is fast)
+ * Mapping single pages usually returns the logical kernel address,
+ * (which is fast)
  * BUG may use slower temporary mappings for high memory pages or
  * uncached / write-combined pages.
  *
@@ -581,7 +576,7 @@ void drm_bo_kunmap(struct drm_bo_kmap_obj *map)
 	if (!map->virtual)
 		return;
 
-	switch(map->bo_kmap_type) {
+	switch (map->bo_kmap_type) {
 	case bo_map_iomap:
 		iounmap(map->virtual);
 		break;
diff --git a/linux-core/drm_object.c b/linux-core/drm_object.c
index a6d6c0d7..5cc1c8d9 100644
--- a/linux-core/drm_object.c
+++ b/linux-core/drm_object.c
@@ -30,7 +30,7 @@
 
 #include "drmP.h"
 
-int drm_add_user_object(struct drm_file * priv, struct drm_user_object * item,
+int drm_add_user_object(struct drm_file *priv, struct drm_user_object *item,
 			int shareable)
 {
 	struct drm_device *dev = priv->head->dev;
@@ -56,7 +56,7 @@ int drm_add_user_object(struct drm_file * priv, struct drm_user_object * item,
 }
 EXPORT_SYMBOL(drm_add_user_object);
 
-struct drm_user_object *drm_lookup_user_object(struct drm_file * priv, uint32_t key)
+struct drm_user_object *drm_lookup_user_object(struct drm_file *priv, uint32_t key)
 {
 	struct drm_device *dev = priv->head->dev;
 	struct drm_hash_item *hash;
@@ -66,9 +66,9 @@ struct drm_user_object *drm_lookup_user_object(struct drm_file * priv, uint32_t
 	DRM_ASSERT_LOCKED(&dev->struct_mutex);
 
 	ret = drm_ht_find_item(&dev->object_hash, key, &hash);
-	if (ret) {
+	if (ret)
 		return NULL;
-	}
+
 	item = drm_hash_entry(hash, struct drm_user_object, hash);
 
 	if (priv != item->owner) {
@@ -83,7 +83,7 @@ struct drm_user_object *drm_lookup_user_object(struct drm_file * priv, uint32_t
 }
 EXPORT_SYMBOL(drm_lookup_user_object);
 
-static void drm_deref_user_object(struct drm_file * priv, struct drm_user_object * item)
+static void drm_deref_user_object(struct drm_file *priv, struct drm_user_object *item)
 {
 	struct drm_device *dev = priv->head->dev;
 	int ret;
@@ -95,7 +95,7 @@ static void drm_deref_user_object(struct drm_file * priv, struct drm_user_object
 	}
 }
 
-static int drm_object_ref_action(struct drm_file * priv, struct drm_user_object * ro,
+static int drm_object_ref_action(struct drm_file *priv, struct drm_user_object *ro,
 				 enum drm_ref_type action)
 {
 	int ret = 0;
@@ -114,7 +114,7 @@ static int drm_object_ref_action(struct drm_file * priv, struct drm_user_object
 	return ret;
 }
 
-int drm_add_ref_object(struct drm_file * priv, struct drm_user_object * referenced_object,
+int drm_add_ref_object(struct drm_file *priv, struct drm_user_object *referenced_object,
 		       enum drm_ref_type ref_action)
 {
 	int ret = 0;
@@ -167,12 +167,12 @@ int drm_add_ref_object(struct drm_file * priv, struct drm_user_object * referenc
 
 	list_add(&item->list, &priv->refd_objects);
 	ret = drm_object_ref_action(priv, referenced_object, ref_action);
-      out:
+out:
 	return ret;
 }
 
-struct drm_ref_object *drm_lookup_ref_object(struct drm_file * priv,
-					struct drm_user_object * referenced_object,
+struct drm_ref_object *drm_lookup_ref_object(struct drm_file *priv,
+					struct drm_user_object *referenced_object,
 					enum drm_ref_type ref_action)
 {
 	struct drm_hash_item *hash;
@@ -188,8 +188,8 @@ struct drm_ref_object *drm_lookup_ref_object(struct drm_file * priv,
 }
 EXPORT_SYMBOL(drm_lookup_ref_object);
 
-static void drm_remove_other_references(struct drm_file * priv,
-					struct drm_user_object * ro)
+static void drm_remove_other_references(struct drm_file *priv,
+					struct drm_user_object *ro)
 {
 	int i;
 	struct drm_open_hash *ht;
@@ -205,7 +205,7 @@ static void drm_remove_other_references(struct drm_file * priv,
 	}
 }
 
-void drm_remove_ref_object(struct drm_file * priv, struct drm_ref_object * item)
+void drm_remove_ref_object(struct drm_file *priv, struct drm_ref_object *item)
 {
 	int ret;
 	struct drm_user_object *user_object = (struct drm_user_object *) item->hash.key;
@@ -235,8 +235,8 @@ void drm_remove_ref_object(struct drm_file * priv, struct drm_ref_object * item)
 
 }
 
-int drm_user_object_ref(struct drm_file * priv, uint32_t user_token,
-			enum drm_object_type type, struct drm_user_object ** object)
+int drm_user_object_ref(struct drm_file *priv, uint32_t user_token,
+			enum drm_object_type type, struct drm_user_object **object)
 {
 	struct drm_device *dev = priv->head->dev;
 	struct drm_user_object *uo;
@@ -260,12 +260,12 @@ int drm_user_object_ref(struct drm_file * priv, uint32_t user_token,
 	mutex_unlock(&dev->struct_mutex);
 	*object = uo;
 	return 0;
-      out_err:
+out_err:
 	mutex_unlock(&dev->struct_mutex);
 	return ret;
 }
 
-int drm_user_object_unref(struct drm_file * priv, uint32_t user_token,
+int drm_user_object_unref(struct drm_file *priv, uint32_t user_token,
 			  enum drm_object_type type)
 {
 	struct drm_device *dev = priv->head->dev;
@@ -287,7 +287,7 @@ int drm_user_object_unref(struct drm_file * priv, uint32_t user_token,
 	drm_remove_ref_object(priv, ro);
 	mutex_unlock(&dev->struct_mutex);
 	return 0;
-      out_err:
+out_err:
 	mutex_unlock(&dev->struct_mutex);
 	return ret;
 }
diff --git a/linux-core/drm_ttm.c b/linux-core/drm_ttm.c
index 4d51f9fe..8a44070d 100644
--- a/linux-core/drm_ttm.c
+++ b/linux-core/drm_ttm.c
@@ -46,7 +46,7 @@ EXPORT_SYMBOL(drm_ttm_cache_flush);
  * Use kmalloc if possible. Otherwise fall back to vmalloc.
  */
 
-static void ttm_alloc_pages(struct drm_ttm * ttm)
+static void ttm_alloc_pages(struct drm_ttm *ttm)
 {
 	unsigned long size = ttm->num_pages * sizeof(*ttm->pages);
 	ttm->pages = NULL;
@@ -54,20 +54,19 @@ static void ttm_alloc_pages(struct drm_ttm * ttm)
 	if (drm_alloc_memctl(size))
 		return;
 
-	if (size <= PAGE_SIZE) {
+	if (size <= PAGE_SIZE)
 		ttm->pages = drm_calloc(1, size, DRM_MEM_TTM);
-	}
+
 	if (!ttm->pages) {
 		ttm->pages = vmalloc_user(size);
 		if (ttm->pages)
 			ttm->page_flags |= DRM_TTM_PAGE_VMALLOC;
 	}
-	if (!ttm->pages) {
+	if (!ttm->pages)
 		drm_free_memctl(size);
-	}
 }
 
-static void ttm_free_pages(struct drm_ttm * ttm)
+static void ttm_free_pages(struct drm_ttm *ttm)
 {
 	unsigned long size = ttm->num_pages * sizeof(*ttm->pages);
 
@@ -85,9 +84,9 @@ static struct page *drm_ttm_alloc_page(void)
 {
 	struct page *page;
 
-	if (drm_alloc_memctl(PAGE_SIZE)) {
+	if (drm_alloc_memctl(PAGE_SIZE))
 		return NULL;
-	}
+
 	page = alloc_page(GFP_KERNEL | __GFP_ZERO | GFP_DMA32);
 	if (!page) {
 		drm_free_memctl(PAGE_SIZE);
@@ -106,7 +105,7 @@ static struct page *drm_ttm_alloc_page(void)
  * for range of pages in a ttm.
  */
 
-static int drm_set_caching(struct drm_ttm * ttm, int noncached)
+static int drm_set_caching(struct drm_ttm *ttm, int noncached)
 {
 	int i;
 	struct page **cur_page;
@@ -153,7 +152,7 @@ static void drm_ttm_free_user_pages(struct drm_ttm *ttm)
 	dirty = ((ttm->page_flags & DRM_TTM_PAGE_USER_DIRTY) != 0);
 
 	down_read(&mm->mmap_sem);
-	for (i=0; i<ttm->num_pages; ++i) {
+	for (i = 0; i < ttm->num_pages; ++i) {
 		page = ttm->pages[i];
 		if (page == NULL)
 			continue;
@@ -186,14 +185,10 @@ static void drm_ttm_free_alloced_pages(struct drm_ttm *ttm)
 #else
 			ClearPageReserved(*cur_page);
 #endif
-			if (page_count(*cur_page) != 1) {
-				DRM_ERROR("Erroneous page count. "
-					  "Leaking pages.\n");
-			}
-			if (page_mapped(*cur_page)) {
-				DRM_ERROR("Erroneous map count. "
-					  "Leaking page mappings.\n");
-			}
+			if (page_count(*cur_page) != 1)
+				DRM_ERROR("Erroneous page count. Leaking pages.\n");
+			if (page_mapped(*cur_page))
+				DRM_ERROR("Erroneous map count. Leaking page mappings.\n");
 			__free_page(*cur_page);
 			drm_free_memctl(PAGE_SIZE);
 			--bm->cur_pages;
@@ -205,7 +200,7 @@ static void drm_ttm_free_alloced_pages(struct drm_ttm *ttm)
  * Free all resources associated with a ttm.
  */
 
-int drm_destroy_ttm(struct drm_ttm * ttm)
+int drm_destroy_ttm(struct drm_ttm *ttm)
 {
 	struct drm_ttm_backend *be;
 
@@ -234,7 +229,7 @@ int drm_destroy_ttm(struct drm_ttm * ttm)
 	return 0;
 }
 
-struct page *drm_ttm_get_page(struct drm_ttm * ttm, int index)
+struct page *drm_ttm_get_page(struct drm_ttm *ttm, int index)
 {
 	struct page *p;
 	struct drm_buffer_manager *bm = &ttm->dev->bm;
@@ -283,10 +278,9 @@ int drm_ttm_set_user(struct drm_ttm *ttm,
 		return -ENOMEM;
 	}
 
-	for (i=0; i<num_pages; ++i) {
-		if (ttm->pages[i] == NULL) {
+	for (i = 0; i < num_pages; ++i) {
+		if (ttm->pages[i] == NULL)
 			ttm->pages[i] = ttm->dummy_read_page;
-		}
 	}
 
 	return 0;
@@ -294,7 +288,7 @@ int drm_ttm_set_user(struct drm_ttm *ttm,
 
 
 
-int drm_ttm_populate(struct drm_ttm * ttm)
+int drm_ttm_populate(struct drm_ttm *ttm)
 {
 	struct page *page;
 	unsigned long i;
@@ -318,7 +312,7 @@ int drm_ttm_populate(struct drm_ttm * ttm)
  * Initialize a ttm.
  */
 
-struct drm_ttm *drm_ttm_init(struct drm_device * dev, unsigned long size)
+struct drm_ttm *drm_ttm_init(struct drm_device *dev, unsigned long size)
 {
 	struct drm_bo_driver *bo_driver = dev->driver->bo_driver;
 	struct drm_ttm *ttm;
@@ -362,7 +356,7 @@ struct drm_ttm *drm_ttm_init(struct drm_device * dev, unsigned long size)
  * Unbind a ttm region from the aperture.
  */
 
-void drm_ttm_evict(struct drm_ttm * ttm)
+void drm_ttm_evict(struct drm_ttm *ttm)
 {
 	struct drm_ttm_backend *be = ttm->be;
 	int ret;
@@ -375,19 +369,18 @@ void drm_ttm_evict(struct drm_ttm * ttm)
 	ttm->state = ttm_evicted;
 }
 
-void drm_ttm_fixup_caching(struct drm_ttm * ttm)
+void drm_ttm_fixup_caching(struct drm_ttm *ttm)
 {
 
 	if (ttm->state == ttm_evicted) {
 		struct drm_ttm_backend *be = ttm->be;
-		if (be->func->needs_ub_cache_adjust(be)) {
+		if (be->func->needs_ub_cache_adjust(be))
 			drm_set_caching(ttm, 0);
-		}
 		ttm->state = ttm_unbound;
 	}
 }
 
-void drm_ttm_unbind(struct drm_ttm * ttm)
+void drm_ttm_unbind(struct drm_ttm *ttm)
 {
 	if (ttm->state == ttm_bound)
 		drm_ttm_evict(ttm);
@@ -395,7 +388,7 @@ void drm_ttm_unbind(struct drm_ttm * ttm)
 	drm_ttm_fixup_caching(ttm);
 }
 
-int drm_bind_ttm(struct drm_ttm * ttm, struct drm_bo_mem_reg *bo_mem)
+int drm_bind_ttm(struct drm_ttm *ttm, struct drm_bo_mem_reg *bo_mem)
 {
 	struct drm_bo_driver *bo_driver = ttm->dev->driver->bo_driver;
 	int ret = 0;
@@ -412,13 +405,14 @@ int drm_bind_ttm(struct drm_ttm * ttm, struct drm_bo_mem_reg *bo_mem)
 	if (ret)
 		return ret;
 
-	if (ttm->state == ttm_unbound && !(bo_mem->flags & DRM_BO_FLAG_CACHED)) {
+	if (ttm->state == ttm_unbound && !(bo_mem->flags & DRM_BO_FLAG_CACHED))
 		drm_set_caching(ttm, DRM_TTM_PAGE_UNCACHED);
-	} else if ((bo_mem->flags & DRM_BO_FLAG_CACHED_MAPPED) &&
+	else if ((bo_mem->flags & DRM_BO_FLAG_CACHED_MAPPED) &&
 		   bo_driver->ttm_cache_flush)
 		bo_driver->ttm_cache_flush(ttm);
 
-	if ((ret = be->func->bind(be, bo_mem))) {
+	ret = be->func->bind(be, bo_mem);
+	if (ret) {
 		ttm->state = ttm_evicted;
 		DRM_ERROR("Couldn't bind backend.\n");
 		return ret;
@@ -429,5 +423,4 @@ int drm_bind_ttm(struct drm_ttm * ttm, struct drm_bo_mem_reg *bo_mem)
 		ttm->page_flags |= DRM_TTM_PAGE_USER_DIRTY;
 	return 0;
 }
-
 EXPORT_SYMBOL(drm_bind_ttm);
-- 
cgit v1.2.3


From 82ffcbbd628fc8c07d3becbbcb86a54214e78110 Mon Sep 17 00:00:00 2001
From: Dave Airlie <airlied@linux.ie>
Date: Mon, 5 Nov 2007 19:14:23 +1000
Subject: drm: more kernel coding style cleanups

---
 linux-core/drm_fence.c | 80 ++++++++++++++++++++++++--------------------------
 linux-core/drm_fops.c  |  9 +++---
 linux-core/drm_vm.c    |  2 +-
 3 files changed, 43 insertions(+), 48 deletions(-)

(limited to 'linux-core')

diff --git a/linux-core/drm_fence.c b/linux-core/drm_fence.c
index d09efeb4..288b4db6 100644
--- a/linux-core/drm_fence.c
+++ b/linux-core/drm_fence.c
@@ -34,7 +34,7 @@
  * Typically called by the IRQ handler.
  */
 
-void drm_fence_handler(struct drm_device * dev, uint32_t fence_class,
+void drm_fence_handler(struct drm_device *dev, uint32_t fence_class,
 		       uint32_t sequence, uint32_t type, uint32_t error)
 {
 	int wake = 0;
@@ -58,9 +58,8 @@ void drm_fence_handler(struct drm_device * dev, uint32_t fence_class,
 	diff = (sequence - fc->last_exe_flush) & driver->sequence_mask;
 	ge_last_exe = diff < driver->wrap_diff;
 
-	if (is_exe && ge_last_exe) {
+	if (is_exe && ge_last_exe)
 		fc->last_exe_flush = sequence;
-	}
 
 	if (list_empty(&fc->ring))
 		return;
@@ -123,7 +122,7 @@ void drm_fence_handler(struct drm_device * dev, uint32_t fence_class,
 	 */
 
 	if ((fc->pending_flush & type) != type) {
-	        head = head->prev;
+		head = head->prev;
 		list_for_each_entry(fence, head, ring) {
 			if (&fence->ring == &fc->ring)
 				break;
@@ -141,10 +140,9 @@ void drm_fence_handler(struct drm_device * dev, uint32_t fence_class,
 		DRM_WAKEUP(&fc->fence_queue);
 	}
 }
-
 EXPORT_SYMBOL(drm_fence_handler);
 
-static void drm_fence_unring(struct drm_device * dev, struct list_head *ring)
+static void drm_fence_unring(struct drm_device *dev, struct list_head *ring)
 {
 	struct drm_fence_manager *fm = &dev->fm;
 	unsigned long flags;
@@ -154,7 +152,7 @@ static void drm_fence_unring(struct drm_device * dev, struct list_head *ring)
 	write_unlock_irqrestore(&fm->lock, flags);
 }
 
-void drm_fence_usage_deref_locked(struct drm_fence_object ** fence)
+void drm_fence_usage_deref_locked(struct drm_fence_object **fence)
 {
 	struct drm_fence_object *tmp_fence = *fence;
 	struct drm_device *dev = tmp_fence->dev;
@@ -173,7 +171,7 @@ void drm_fence_usage_deref_locked(struct drm_fence_object ** fence)
 }
 EXPORT_SYMBOL(drm_fence_usage_deref_locked);
 
-void drm_fence_usage_deref_unlocked(struct drm_fence_object ** fence)
+void drm_fence_usage_deref_unlocked(struct drm_fence_object **fence)
 {
 	struct drm_fence_object *tmp_fence = *fence;
 	struct drm_device *dev = tmp_fence->dev;
@@ -212,7 +210,8 @@ void drm_fence_reference_unlocked(struct drm_fence_object **dst,
 }
 EXPORT_SYMBOL(drm_fence_reference_unlocked);
 
-static void drm_fence_object_destroy(struct drm_file *priv, struct drm_user_object * base)
+static void drm_fence_object_destroy(struct drm_file *priv,
+				     struct drm_user_object *base)
 {
 	struct drm_fence_object *fence =
 	    drm_user_object_entry(base, struct drm_fence_object, base);
@@ -220,7 +219,7 @@ static void drm_fence_object_destroy(struct drm_file *priv, struct drm_user_obje
 	drm_fence_usage_deref_locked(&fence);
 }
 
-int drm_fence_object_signaled(struct drm_fence_object * fence,
+int drm_fence_object_signaled(struct drm_fence_object *fence,
 			      uint32_t mask, int poke_flush)
 {
 	unsigned long flags;
@@ -240,8 +239,9 @@ int drm_fence_object_signaled(struct drm_fence_object * fence,
 }
 EXPORT_SYMBOL(drm_fence_object_signaled);
 
-static void drm_fence_flush_exe(struct drm_fence_class_manager * fc,
-				struct drm_fence_driver * driver, uint32_t sequence)
+static void drm_fence_flush_exe(struct drm_fence_class_manager *fc,
+				struct drm_fence_driver *driver,
+				uint32_t sequence)
 {
 	uint32_t diff;
 
@@ -249,15 +249,13 @@ static void drm_fence_flush_exe(struct drm_fence_class_manager * fc,
 		fc->exe_flush_sequence = sequence;
 		fc->pending_exe_flush = 1;
 	} else {
-		diff =
-		    (sequence - fc->exe_flush_sequence) & driver->sequence_mask;
-		if (diff < driver->wrap_diff) {
+		diff = (sequence - fc->exe_flush_sequence) & driver->sequence_mask;
+		if (diff < driver->wrap_diff)
 			fc->exe_flush_sequence = sequence;
-		}
 	}
 }
 
-int drm_fence_object_flush(struct drm_fence_object * fence,
+int drm_fence_object_flush(struct drm_fence_object *fence,
 			   uint32_t type)
 {
 	struct drm_device *dev = fence->dev;
@@ -296,7 +294,8 @@ int drm_fence_object_flush(struct drm_fence_object * fence,
  * wrapped around and reused.
  */
 
-void drm_fence_flush_old(struct drm_device * dev, uint32_t fence_class, uint32_t sequence)
+void drm_fence_flush_old(struct drm_device *dev, uint32_t fence_class,
+			 uint32_t sequence)
 {
 	struct drm_fence_manager *fm = &dev->fm;
 	struct drm_fence_class_manager *fc = &fm->fence_class[fence_class];
@@ -328,12 +327,10 @@ void drm_fence_flush_old(struct drm_device * dev, uint32_t fence_class, uint32_t
 	mutex_unlock(&dev->struct_mutex);
 	diff = (old_sequence - fence->sequence) & driver->sequence_mask;
 	read_unlock_irqrestore(&fm->lock, flags);
-	if (diff < driver->wrap_diff) {
+	if (diff < driver->wrap_diff)
 		drm_fence_object_flush(fence, fence->type);
-	}
 	drm_fence_usage_deref_unlocked(&fence);
 }
-
 EXPORT_SYMBOL(drm_fence_flush_old);
 
 static int drm_fence_lazy_wait(struct drm_fence_object *fence,
@@ -378,7 +375,7 @@ static int drm_fence_lazy_wait(struct drm_fence_object *fence,
 	return 0;
 }
 
-int drm_fence_object_wait(struct drm_fence_object * fence,
+int drm_fence_object_wait(struct drm_fence_object *fence,
 			  int lazy, int ignore_signals, uint32_t mask)
 {
 	struct drm_device *dev = fence->dev;
@@ -431,10 +428,9 @@ int drm_fence_object_wait(struct drm_fence_object * fence,
 	/*
 	 * Avoid kernel-space busy-waits.
 	 */
-#if 1
 	if (!ignore_signals)
 		return -EAGAIN;
-#endif
+
 	do {
 		schedule();
 		signaled = drm_fence_object_signaled(fence, mask, 1);
@@ -447,9 +443,8 @@ int drm_fence_object_wait(struct drm_fence_object * fence,
 }
 EXPORT_SYMBOL(drm_fence_object_wait);
 
-
-int drm_fence_object_emit(struct drm_fence_object * fence,
-			  uint32_t fence_flags, uint32_t fence_class, uint32_t type)
+int drm_fence_object_emit(struct drm_fence_object *fence, uint32_t fence_flags,
+			  uint32_t fence_class, uint32_t type)
 {
 	struct drm_device *dev = fence->dev;
 	struct drm_fence_manager *fm = &dev->fm;
@@ -461,7 +456,8 @@ int drm_fence_object_emit(struct drm_fence_object * fence,
 	int ret;
 
 	drm_fence_unring(dev, &fence->ring);
-	ret = driver->emit(dev, fence_class, fence_flags, &sequence, &native_type);
+	ret = driver->emit(dev, fence_class, fence_flags, &sequence,
+			   &native_type);
 	if (ret)
 		return ret;
 
@@ -481,10 +477,10 @@ int drm_fence_object_emit(struct drm_fence_object * fence,
 }
 EXPORT_SYMBOL(drm_fence_object_emit);
 
-static int drm_fence_object_init(struct drm_device * dev, uint32_t fence_class,
+static int drm_fence_object_init(struct drm_device *dev, uint32_t fence_class,
 				 uint32_t type,
 				 uint32_t fence_flags,
-				 struct drm_fence_object * fence)
+				 struct drm_fence_object *fence)
 {
 	int ret = 0;
 	unsigned long flags;
@@ -517,8 +513,8 @@ static int drm_fence_object_init(struct drm_device * dev, uint32_t fence_class,
 	return ret;
 }
 
-int drm_fence_add_user_object(struct drm_file * priv, struct drm_fence_object * fence,
-			      int shareable)
+int drm_fence_add_user_object(struct drm_file *priv,
+			      struct drm_fence_object *fence, int shareable)
 {
 	struct drm_device *dev = priv->head->dev;
 	int ret;
@@ -537,8 +533,9 @@ out:
 }
 EXPORT_SYMBOL(drm_fence_add_user_object);
 
-int drm_fence_object_create(struct drm_device * dev, uint32_t fence_class, uint32_t type,
-			    unsigned flags, struct drm_fence_object ** c_fence)
+int drm_fence_object_create(struct drm_device *dev, uint32_t fence_class,
+			    uint32_t type, unsigned flags,
+			    struct drm_fence_object **c_fence)
 {
 	struct drm_fence_object *fence;
 	int ret;
@@ -557,10 +554,9 @@ int drm_fence_object_create(struct drm_device * dev, uint32_t fence_class, uint3
 
 	return 0;
 }
-
 EXPORT_SYMBOL(drm_fence_object_create);
 
-void drm_fence_manager_init(struct drm_device * dev)
+void drm_fence_manager_init(struct drm_device *dev)
 {
 	struct drm_fence_manager *fm = &dev->fm;
 	struct drm_fence_class_manager *fence_class;
@@ -578,7 +574,7 @@ void drm_fence_manager_init(struct drm_device * dev)
 	fm->num_classes = fed->num_classes;
 	BUG_ON(fm->num_classes > _DRM_FENCE_CLASSES);
 
-	for (i=0; i<fm->num_classes; ++i) {
+	for (i = 0; i < fm->num_classes; ++i) {
 	    fence_class = &fm->fence_class[i];
 
 	    INIT_LIST_HEAD(&fence_class->ring);
@@ -591,7 +587,8 @@ void drm_fence_manager_init(struct drm_device * dev)
 	write_unlock_irqrestore(&fm->lock, flags);
 }
 
-void drm_fence_fill_arg(struct drm_fence_object *fence, struct drm_fence_arg *arg)
+void drm_fence_fill_arg(struct drm_fence_object *fence,
+			struct drm_fence_arg *arg)
 {
 	struct drm_device *dev = fence->dev;
 	struct drm_fence_manager *fm = &dev->fm;
@@ -608,12 +605,12 @@ void drm_fence_fill_arg(struct drm_fence_object *fence, struct drm_fence_arg *ar
 }
 EXPORT_SYMBOL(drm_fence_fill_arg);
 
-
-void drm_fence_manager_takedown(struct drm_device * dev)
+void drm_fence_manager_takedown(struct drm_device *dev)
 {
 }
 
-struct drm_fence_object *drm_lookup_fence_object(struct drm_file * priv, uint32_t handle)
+struct drm_fence_object *drm_lookup_fence_object(struct drm_file *priv,
+						 uint32_t handle)
 {
 	struct drm_device *dev = priv->head->dev;
 	struct drm_user_object *uo;
@@ -663,7 +660,6 @@ int drm_fence_create_ioctl(struct drm_device *dev, void *data, struct drm_file *
 
 	arg->handle = fence->base.hash.key;
 
-
 	drm_fence_fill_arg(fence, arg);
 	drm_fence_usage_deref_unlocked(&fence);
 
diff --git a/linux-core/drm_fops.c b/linux-core/drm_fops.c
index 4d0d6be0..6923ce86 100644
--- a/linux-core/drm_fops.c
+++ b/linux-core/drm_fops.c
@@ -272,9 +272,8 @@ static int drm_open_helper(struct inode *inode, struct file *filp,
 	}
 
 	if (ret) {
-		for(j=0; j<i; ++j) {
+		for(j = 0; j < i; ++j)
 			drm_ht_remove(&priv->refd_object_hash[j]);
-		}
 		goto out_free;
 	}
 
@@ -333,8 +332,8 @@ int drm_fasync(int fd, struct file *filp, int on)
 }
 EXPORT_SYMBOL(drm_fasync);
 
-static void drm_object_release(struct file *filp) {
-
+static void drm_object_release(struct file *filp)
+{
 	struct drm_file *priv = filp->private_data;
 	struct list_head *head;
 	struct drm_ref_object *ref_object;
@@ -355,7 +354,7 @@ static void drm_object_release(struct file *filp) {
 		head = &priv->refd_objects;
 	}
 
-	for(i=0; i<_DRM_NO_REF_TYPES; ++i) {
+	for(i = 0; i < _DRM_NO_REF_TYPES; ++i) {
 		drm_ht_remove(&priv->refd_object_hash[i]);
 	}
 }
diff --git a/linux-core/drm_vm.c b/linux-core/drm_vm.c
index d2554f31..42e1f27a 100644
--- a/linux-core/drm_vm.c
+++ b/linux-core/drm_vm.c
@@ -166,7 +166,7 @@ static __inline__ struct page *drm_do_vm_nopage(struct vm_area_struct *vma,
  * \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
+ * Get 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,
-- 
cgit v1.2.3


From 44ad6f409d6d08163d26e20d41b1601b2fde53d7 Mon Sep 17 00:00:00 2001
From: Thomas Hellstrom <thomas-at-tungstengraphics-dot-com>
Date: Mon, 5 Nov 2007 13:20:16 +0100
Subject: Fix a user-buffer check.

---
 linux-core/drm_bo.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'linux-core')

diff --git a/linux-core/drm_bo.c b/linux-core/drm_bo.c
index 91bc0c79..6bfc6df5 100644
--- a/linux-core/drm_bo.c
+++ b/linux-core/drm_bo.c
@@ -945,7 +945,7 @@ static int drm_bo_new_mask(struct drm_buffer_object *bo,
 	uint32_t new_props;
 
 	if (bo->type == drm_bo_type_user &&
-	    ((used_mask & (DRM_BO_FLAG_CACHED | DRM_BO_FLAG_FORCE_CACHING)) !=
+	    ((new_flags & (DRM_BO_FLAG_CACHED | DRM_BO_FLAG_FORCE_CACHING)) !=
 	     (DRM_BO_FLAG_CACHED | DRM_BO_FLAG_FORCE_CACHING))) {
 		DRM_ERROR("User buffers require cache-coherent memory.\n");
 		return -EINVAL;
-- 
cgit v1.2.3


From 427cc561b3dfbd504472e284e5fc16b63acd1816 Mon Sep 17 00:00:00 2001
From: Thomas Hellstrom <thomas-at-tungstengraphics-dot-com>
Date: Mon, 5 Nov 2007 13:22:00 +0100
Subject: Export a symbol.

---
 linux-core/drm_object.c | 1 +
 1 file changed, 1 insertion(+)

(limited to 'linux-core')

diff --git a/linux-core/drm_object.c b/linux-core/drm_object.c
index 5cc1c8d9..5ade6178 100644
--- a/linux-core/drm_object.c
+++ b/linux-core/drm_object.c
@@ -234,6 +234,7 @@ void drm_remove_ref_object(struct drm_file *priv, struct drm_ref_object *item)
 	}
 
 }
+EXPORT_SYMBOL(drm_remove_ref_object);
 
 int drm_user_object_ref(struct drm_file *priv, uint32_t user_token,
 			enum drm_object_type type, struct drm_user_object **object)
-- 
cgit v1.2.3