run i915 through lindent

6 files changed, 506 insertions, 585 deletions

diff --git a/shared/i915.h b/shared/i915.h
index 5a234a18..d3ecbb76 100644
--- a/shared/i915.h
+++ b/shared/i915.h
@@ -31,7 +31,6 @@
 #define DRIVER_MINOR		1
 #define DRIVER_PATCHLEVEL	0
 
-
 #define DRIVER_IOCTLS							    \
 	[DRM_IOCTL_NR(DRM_IOCTL_I915_INIT)]   = { i915_dma_init,    1, 1 }, \
 	[DRM_IOCTL_NR(DRM_IOCTL_I915_FLUSH)]  = { i915_flush_ioctl, 1, 0 }, \
@@ -46,7 +45,6 @@
         [DRM_IOCTL_NR(DRM_IOCTL_I915_INIT_HEAP)] = { i915_mem_init_heap, 1, 1 }, \
 	[DRM_IOCTL_NR(DRM_IOCTL_I915_CMDBUFFER)] = { i915_cmdbuffer, 1, 0 }
 
-
 #define __HAVE_COUNTERS         4
 #define __HAVE_COUNTER6         _DRM_STAT_IRQ
 #define __HAVE_COUNTER7         _DRM_STAT_PRIMARY
diff --git a/shared/i915_dma.c b/shared/i915_dma.c
index 4ff78247..f99a69f4 100644
--- a/shared/i915_dma.c
+++ b/shared/i915_dma.c
@@ -13,10 +13,9 @@
 #include "i915_drm.h"
 #include "i915_drv.h"
 
-
-static inline void i915_print_status_page(drm_device_t *dev)
+static inline void i915_print_status_page(drm_device_t * dev)
 {
-      	drm_i915_private_t *dev_priv = dev->dev_private;
+	drm_i915_private_t *dev_priv = dev->dev_private;
 	u32 *temp = dev_priv->hw_status_page;
 
 	if (!temp) {
@@ -24,39 +23,37 @@ static inline void i915_print_status_page(drm_device_t *dev)
 		return;
 	}
 
-   	DRM_DEBUG(  "hw_status: Interrupt Status : %x\n", temp[0]);
-   	DRM_DEBUG(  "hw_status: LpRing Head ptr : %x\n", temp[1]);
-   	DRM_DEBUG(  "hw_status: IRing Head ptr : %x\n", temp[2]);
-      	DRM_DEBUG(  "hw_status: Reserved : %x\n", temp[3]);
-   	DRM_DEBUG(  "hw_status: Driver Counter : %d\n", temp[5]);
+	DRM_DEBUG("hw_status: Interrupt Status : %x\n", temp[0]);
+	DRM_DEBUG("hw_status: LpRing Head ptr : %x\n", temp[1]);
+	DRM_DEBUG("hw_status: IRing Head ptr : %x\n", temp[2]);
+	DRM_DEBUG("hw_status: Reserved : %x\n", temp[3]);
+	DRM_DEBUG("hw_status: Driver Counter : %d\n", temp[5]);
 
 }
 
-
-
-
 /* Really want an OS-independent resettable timer.  Would like to have
  * this loop run for (eg) 3 sec, but have the timer reset every time
  * the head pointer changes, so that EBUSY only happens if the ring
  * actually stalls for (eg) 3 seconds.
  */
-int i915_wait_ring( drm_device_t *dev, int n, const char *caller )
+int i915_wait_ring(drm_device_t * dev, int n, const char *caller)
 {
-   	drm_i915_private_t *dev_priv = dev->dev_private;
-   	drm_i915_ring_buffer_t *ring = &(dev_priv->ring);
+	drm_i915_private_t *dev_priv = dev->dev_private;
+	drm_i915_ring_buffer_t *ring = &(dev_priv->ring);
 	u32 last_head = I915_READ(LP_RING + RING_HEAD) & HEAD_ADDR;
 	int i;
 
-	for ( i = 0 ; i < 10000 ; i++ ) {
+	for (i = 0; i < 10000; i++) {
 		ring->head = I915_READ(LP_RING + RING_HEAD) & HEAD_ADDR;
-	   	ring->space = ring->head - (ring->tail+8);
-		if (ring->space < 0) ring->space += ring->Size;
-		if ( ring->space >= n )
+		ring->space = ring->head - (ring->tail + 8);
+		if (ring->space < 0)
+			ring->space += ring->Size;
+		if (ring->space >= n)
 			return 0;
-		
+
 		dev_priv->sarea_priv->perf_boxes |= I915_BOX_WAIT;
 
-		if (ring->head != last_head) 
+		if (ring->head != last_head)
 			i = 0;
 
 		last_head = ring->head;
@@ -65,78 +62,78 @@ int i915_wait_ring( drm_device_t *dev, int n, const char *caller )
 	return DRM_ERR(EBUSY);
 }
 
-void i915_kernel_lost_context(drm_device_t *dev)
+void i915_kernel_lost_context(drm_device_t * dev)
 {
-      	drm_i915_private_t *dev_priv = dev->dev_private;
-   	drm_i915_ring_buffer_t *ring = &(dev_priv->ring);
-      
-   	ring->head = I915_READ(LP_RING + RING_HEAD) & HEAD_ADDR;
-     	ring->tail = I915_READ(LP_RING + RING_TAIL) & TAIL_ADDR;
-     	ring->space = ring->head - (ring->tail+8);
-     	if (ring->space < 0) ring->space += ring->Size;
+	drm_i915_private_t *dev_priv = dev->dev_private;
+	drm_i915_ring_buffer_t *ring = &(dev_priv->ring);
+
+	ring->head = I915_READ(LP_RING + RING_HEAD) & HEAD_ADDR;
+	ring->tail = I915_READ(LP_RING + RING_TAIL) & TAIL_ADDR;
+	ring->space = ring->head - (ring->tail + 8);
+	if (ring->space < 0)
+		ring->space += ring->Size;
 
 	if (ring->head == ring->tail)
 		dev_priv->sarea_priv->perf_boxes |= I915_BOX_RING_EMPTY;
 }
 
-
-int i915_dma_cleanup(drm_device_t *dev)
+int i915_dma_cleanup(drm_device_t * dev)
 {
 	/* Make sure interrupts are disabled here because the uninstall ioctl
 	 * may not have been called from userspace and after dev_private
 	 * is freed, it's too late.
 	 */
-	if (dev->irq) DRM(irq_uninstall)(dev);
+	if (dev->irq)
+		DRM(irq_uninstall) (dev);
 
 	if (dev->dev_private) {
-	   	drm_i915_private_t *dev_priv = 
-	     		(drm_i915_private_t *) dev->dev_private;
-	   
-	   	if (dev_priv->ring.virtual_start) {
-		   	drm_core_ioremapfree( &dev_priv->ring.map, dev);
+		drm_i915_private_t *dev_priv =
+		    (drm_i915_private_t *) dev->dev_private;
+
+		if (dev_priv->ring.virtual_start) {
+			drm_core_ioremapfree(&dev_priv->ring.map, dev);
 		}
 
-	   	if (dev_priv->hw_status_page) {
+		if (dev_priv->hw_status_page) {
 #ifdef __FreeBSD__
-#if __FreeBSD_version > 500000	
-			contigfree(dev_priv->hw_status_page, PAGE_SIZE, DRM(M_DRM));
+#if __FreeBSD_version > 500000
+			contigfree(dev_priv->hw_status_page, PAGE_SIZE,
+				   DRM(M_DRM));
 #endif
 #else
 			pci_free_consistent(dev->pdev, PAGE_SIZE,
-				      dev_priv->hw_status_page,
-				      dev_priv->dma_status_page);
+					    dev_priv->hw_status_page,
+					    dev_priv->dma_status_page);
 #endif
-		   	/* Need to rewrite hardware status page */
-		   	I915_WRITE(0x02080, 0x1ffff000);
+			/* Need to rewrite hardware status page */
+			I915_WRITE(0x02080, 0x1ffff000);
 		}
 
-	   	DRM(free)(dev->dev_private, sizeof(drm_i915_private_t), 
-			 DRM_MEM_DRIVER);
+		DRM(free) (dev->dev_private, sizeof(drm_i915_private_t),
+			   DRM_MEM_DRIVER);
 
-	   	dev->dev_private = NULL;
+		dev->dev_private = NULL;
 	}
 
-   	return 0;
+	return 0;
 }
 
-
-
-static int i915_initialize(drm_device_t *dev, 
-			       drm_i915_private_t *dev_priv,
-			       drm_i915_init_t *init)
+static int i915_initialize(drm_device_t * dev,
+			   drm_i915_private_t * dev_priv,
+			   drm_i915_init_t * init)
 {
-   	memset(dev_priv, 0, sizeof(drm_i915_private_t));
+	memset(dev_priv, 0, sizeof(drm_i915_private_t));
 
 	DRM_GETSAREA();
-	if(!dev_priv->sarea) {
+	if (!dev_priv->sarea) {
 		DRM_ERROR("can not find sarea!\n");
 		dev->dev_private = (void *)dev_priv;
 		i915_dma_cleanup(dev);
 		return DRM_ERR(EINVAL);
 	}
-	
+
 	dev_priv->mmio_map = drm_core_findmap(dev, init->mmio_offset);
-	if(!dev_priv->mmio_map) {
+	if (!dev_priv->mmio_map) {
 		dev->dev_private = (void *)dev_priv;
 		i915_dma_cleanup(dev);
 		DRM_ERROR("can not find mmio map!\n");
@@ -144,32 +141,31 @@ static int i915_initialize(drm_device_t *dev,
 	}
 
 	dev_priv->sarea_priv = (drm_i915_sarea_t *)
-		((u8 *)dev_priv->sarea->handle +
-		 init->sarea_priv_offset);
-
-   	dev_priv->ring.Start = init->ring_start;
-   	dev_priv->ring.End = init->ring_end;
-   	dev_priv->ring.Size = init->ring_size;
-   	dev_priv->ring.tail_mask = dev_priv->ring.Size - 1;
-		
+	    ((u8 *) dev_priv->sarea->handle + init->sarea_priv_offset);
+
+	dev_priv->ring.Start = init->ring_start;
+	dev_priv->ring.End = init->ring_end;
+	dev_priv->ring.Size = init->ring_size;
+	dev_priv->ring.tail_mask = dev_priv->ring.Size - 1;
+
 	dev_priv->ring.map.offset = init->ring_start;
 	dev_priv->ring.map.size = init->ring_size;
 	dev_priv->ring.map.type = 0;
 	dev_priv->ring.map.flags = 0;
 	dev_priv->ring.map.mtrr = 0;
 
-	drm_core_ioremap( &dev_priv->ring.map, dev );
+	drm_core_ioremap(&dev_priv->ring.map, dev);
 
-   	if (dev_priv->ring.map.handle == NULL) {
-		dev->dev_private = (void *) dev_priv;
-	   	i915_dma_cleanup(dev);
-	   	DRM_ERROR("can not ioremap virtual address for"
+	if (dev_priv->ring.map.handle == NULL) {
+		dev->dev_private = (void *)dev_priv;
+		i915_dma_cleanup(dev);
+		DRM_ERROR("can not ioremap virtual address for"
 			  " ring buffer\n");
-	   	return DRM_ERR(ENOMEM);
+		return DRM_ERR(ENOMEM);
 	}
 
-   	dev_priv->ring.virtual_start = dev_priv->ring.map.handle;
-   
+	dev_priv->ring.virtual_start = dev_priv->ring.map.handle;
+
 	dev_priv->back_offset = init->back_offset;
 	dev_priv->front_offset = init->front_offset;
 	dev_priv->current_page = 0;
@@ -184,103 +180,100 @@ static int i915_initialize(drm_device_t *dev,
 	 */
 	dev_priv->allow_batchbuffer = 1;
 
-   	/* Program Hardware Status Page */
+	/* Program Hardware Status Page */
 #ifdef __FreeBSD__
-   	dev_priv->hw_status_page = contigmalloc(PAGE_SIZE, DRM(M_DRM), M_NOWAIT, 0ul, 0, 0, 0);
-	dev_priv->dma_status_page = vtophys(dev_priv->hw_status_page);	
+	dev_priv->hw_status_page =
+	    contigmalloc(PAGE_SIZE, DRM(M_DRM), M_NOWAIT, 0ul, 0, 0, 0);
+	dev_priv->dma_status_page = vtophys(dev_priv->hw_status_page);
 #else
-   	dev_priv->hw_status_page =
-		pci_alloc_consistent( dev->pdev, PAGE_SIZE, 
-						&dev_priv->dma_status_page );
+	dev_priv->hw_status_page =
+	    pci_alloc_consistent(dev->pdev, PAGE_SIZE,
+				 &dev_priv->dma_status_page);
 #endif
 
-   	if (!dev_priv->hw_status_page) {
+	if (!dev_priv->hw_status_page) {
 		dev->dev_private = (void *)dev_priv;
 		i915_dma_cleanup(dev);
 		DRM_ERROR("Can not allocate hardware status page\n");
 		return DRM_ERR(ENOMEM);
 	}
-   	memset(dev_priv->hw_status_page, 0, PAGE_SIZE);
+	memset(dev_priv->hw_status_page, 0, PAGE_SIZE);
 	DRM_DEBUG("hw status page @ %p\n", dev_priv->hw_status_page);
-   
-   	I915_WRITE(0x02080, dev_priv->dma_status_page);
+
+	I915_WRITE(0x02080, dev_priv->dma_status_page);
 	DRM_DEBUG("Enabled hardware status page\n");
-   
+
 	dev->dev_private = (void *)dev_priv;
 
-   	return 0;
+	return 0;
 }
 
-
-static int i915_resume(drm_device_t *dev)
+static int i915_resume(drm_device_t * dev)
 {
-	drm_i915_private_t *dev_priv = 
-		(drm_i915_private_t *) dev->dev_private;
+	drm_i915_private_t *dev_priv = (drm_i915_private_t *) dev->dev_private;
 
-	DRM_DEBUG( "%s\n", __FUNCTION__);
-		   
-	if(!dev_priv->sarea) {
+	DRM_DEBUG("%s\n", __FUNCTION__);
+
+	if (!dev_priv->sarea) {
 		DRM_ERROR("can not find sarea!\n");
 		return DRM_ERR(EINVAL);
 	}
 
-	if(!dev_priv->mmio_map) {
+	if (!dev_priv->mmio_map) {
 		DRM_ERROR("can not find mmio map!\n");
 		return DRM_ERR(EINVAL);
 	}
 
-   	if (dev_priv->ring.map.handle == NULL) {
-	   	DRM_ERROR("can not ioremap virtual address for"
+	if (dev_priv->ring.map.handle == NULL) {
+		DRM_ERROR("can not ioremap virtual address for"
 			  " ring buffer\n");
-	   	return DRM_ERR(ENOMEM);
+		return DRM_ERR(ENOMEM);
 	}
 
-   	/* Program Hardware Status Page */
-   	if (!dev_priv->hw_status_page) {
+	/* Program Hardware Status Page */
+	if (!dev_priv->hw_status_page) {
 		DRM_ERROR("Can not find hardware status page\n");
 		return DRM_ERR(EINVAL);
 	}
 	DRM_DEBUG("hw status page @ %p\n", dev_priv->hw_status_page);
-   
-   	I915_WRITE(0x02080, dev_priv->dma_status_page);
+
+	I915_WRITE(0x02080, dev_priv->dma_status_page);
 	DRM_DEBUG("Enabled hardware status page\n");
 
-   	return 0;
+	return 0;
 }
 
-
-int i915_dma_init( DRM_IOCTL_ARGS )
+int i915_dma_init(DRM_IOCTL_ARGS)
 {
 	DRM_DEVICE;
-   	drm_i915_private_t *dev_priv;
-   	drm_i915_init_t init;
-   	int retcode = 0;
-	
-  	DRM_COPY_FROM_USER_IOCTL( init, (drm_i915_init_t __user *)data, sizeof(init));
-	
-   	switch(init.func) {
-	 	case I915_INIT_DMA:
-			dev_priv = DRM(alloc)(sizeof(drm_i915_private_t), 
-					      DRM_MEM_DRIVER);
-	   		if(dev_priv == NULL) 
-				return DRM_ERR(ENOMEM);
-	   		retcode = i915_initialize(dev, dev_priv, &init);
-	   	break;
-	 	case I915_CLEANUP_DMA:
-	   		retcode = i915_dma_cleanup(dev);
-	   	break;
-		case I915_RESUME_DMA:
-			retcode = i915_resume(dev);
-	   	break;
-	 	default:
-	   		retcode = -EINVAL;
-	   	break;
-	}
-   
-   	return retcode;
-}
-
+	drm_i915_private_t *dev_priv;
+	drm_i915_init_t init;
+	int retcode = 0;
+
+	DRM_COPY_FROM_USER_IOCTL(init, (drm_i915_init_t __user *) data,
+				 sizeof(init));
+
+	switch (init.func) {
+	case I915_INIT_DMA:
+		dev_priv = DRM(alloc) (sizeof(drm_i915_private_t),
+				       DRM_MEM_DRIVER);
+		if (dev_priv == NULL)
+			return DRM_ERR(ENOMEM);
+		retcode = i915_initialize(dev, dev_priv, &init);
+		break;
+	case I915_CLEANUP_DMA:
+		retcode = i915_dma_cleanup(dev);
+		break;
+	case I915_RESUME_DMA:
+		retcode = i915_resume(dev);
+		break;
+	default:
+		retcode = -EINVAL;
+		break;
+	}
 
+	return retcode;
+}
 
 /* Implement basically the same security restrictions as hardware does
  * for MI_BATCH_NON_SECURE.  These can be made stricter at any time.
@@ -291,55 +284,55 @@ int i915_dma_init( DRM_IOCTL_ARGS )
  * instruction detected will be given a size of zero, which is a
  * signal to abort the rest of the buffer.
  */
-static int do_validate_cmd( int cmd )
+static int do_validate_cmd(int cmd)
 {
-	switch (((cmd>>29) & 0x7)) {
+	switch (((cmd >> 29) & 0x7)) {
 	case 0x0:
-		switch ((cmd>>23) & 0x3f) {
-		case 0x0: 
-			return 1; /* MI_NOOP */
-		case 0x4: 
-			return 1; /* MI_FLUSH */
-		default: 
-			return 0; /* disallow everything else */
+		switch ((cmd >> 23) & 0x3f) {
+		case 0x0:
+			return 1;	/* MI_NOOP */
+		case 0x4:
+			return 1;	/* MI_FLUSH */
+		default:
+			return 0;	/* disallow everything else */
 		}
 		break;
-	case 0x1: 
+	case 0x1:
 		return 0;	/* reserved */
-	case 0x2: 
-		return (cmd & 0xff) + 2; /* 2d commands */
+	case 0x2:
+		return (cmd & 0xff) + 2;	/* 2d commands */
 	case 0x3:
-		if (((cmd>>24) & 0x1f) <= 0x18)
+		if (((cmd >> 24) & 0x1f) <= 0x18)
 			return 1;
 
-		switch ((cmd>>24) & 0x1f) {
-		case 0x1c: 
+		switch ((cmd >> 24) & 0x1f) {
+		case 0x1c:
 			return 1;
 		case 0x1d:
-			switch ((cmd>>16)&0xff) {
-			case 0x3: 
+			switch ((cmd >> 16) & 0xff) {
+			case 0x3:
 				return (cmd & 0x1f) + 2;
-			case 0x4: 
+			case 0x4:
 				return (cmd & 0xf) + 2;
-			default:  
+			default:
 				return (cmd & 0xffff) + 2;
 			}
-		case 0x1e: 
-			if (cmd & (1<<23)) 
+		case 0x1e:
+			if (cmd & (1 << 23))
 				return (cmd & 0xffff) + 1;
 			else
 				return 1;
 		case 0x1f:
-			if ((cmd & (1<<23)) == 0) /* inline vertices */
+			if ((cmd & (1 << 23)) == 0)	/* inline vertices */
 				return (cmd & 0x1ffff) + 2;
-			else if (cmd & (1<<17)) /* indirect random */
+			else if (cmd & (1 << 17))	/* indirect random */
 				if ((cmd & 0xffff) == 0)
-					return 0; /* unknown length, too hard */
+					return 0;	/* unknown length, too hard */
 				else
 					return (((cmd & 0xffff) + 1) / 2) + 1;
 			else
-				return 2; /* indirect sequential */
-		default: 
+				return 2;	/* indirect sequential */
+		default:
 			return 0;
 		}
 	default:
@@ -349,43 +342,39 @@ static int do_validate_cmd( int cmd )
 	return 0;
 }
 
-static int validate_cmd( int cmd )
+static int validate_cmd(int cmd)
 {
-	int ret = do_validate_cmd( cmd );
-	
+	int ret = do_validate_cmd(cmd);
+
 /* 	printk("validate_cmd( %x ): %d\n", cmd, ret); */
 
 	return ret;
 }
-	
-	
 
-static int i915_emit_cmds( drm_device_t *dev,
-			   int __user *buffer,
-			   int dwords )
+static int i915_emit_cmds(drm_device_t * dev, int __user * buffer, int dwords)
 {
-   	drm_i915_private_t *dev_priv = dev->dev_private;
+	drm_i915_private_t *dev_priv = dev->dev_private;
 	int i;
 	RING_LOCALS;
 
-	for (i = 0 ; i < dwords ; ) {
+	for (i = 0; i < dwords;) {
 		int cmd, sz;
 
 		if (DRM_COPY_FROM_USER_UNCHECKED(&cmd, &buffer[i], sizeof(cmd)))
-			return DRM_ERR( EINVAL );
+			return DRM_ERR(EINVAL);
 
 /* 		printk("%d/%d ", i, dwords); */
 
-		if ((sz = validate_cmd(cmd)) == 0 || i + sz > dwords) 
-			return DRM_ERR( EINVAL );
+		if ((sz = validate_cmd(cmd)) == 0 || i + sz > dwords)
+			return DRM_ERR(EINVAL);
 
-		BEGIN_LP_RING( sz );
+		BEGIN_LP_RING(sz);
 		OUT_RING(cmd);
 
 		while (++i, --sz) {
-			if (DRM_COPY_FROM_USER_UNCHECKED( &cmd, &buffer[i], 
-							  sizeof(cmd))) {
-				return DRM_ERR( EINVAL );
+			if (DRM_COPY_FROM_USER_UNCHECKED(&cmd, &buffer[i],
+							 sizeof(cmd))) {
+				return DRM_ERR(EINVAL);
 			}
 			OUT_RING(cmd);
 		}
@@ -395,213 +384,195 @@ static int i915_emit_cmds( drm_device_t *dev,
 	return 0;
 }
 
-static int i915_emit_box( drm_device_t *dev,
-			  drm_clip_rect_t __user *boxes,
-			  int i,
-			  int DR1,
-			  int DR4)
+static int i915_emit_box(drm_device_t * dev,
+			 drm_clip_rect_t __user * boxes,
+			 int i, int DR1, int DR4)
 {
-   	drm_i915_private_t *dev_priv = dev->dev_private;
-   	drm_clip_rect_t box;
-   	RING_LOCALS;
+	drm_i915_private_t *dev_priv = dev->dev_private;
+	drm_clip_rect_t box;
+	RING_LOCALS;
 
-	if (DRM_COPY_FROM_USER_UNCHECKED( &box, &boxes[i], sizeof(box) )) {
+	if (DRM_COPY_FROM_USER_UNCHECKED(&box, &boxes[i], sizeof(box))) {
 		return EFAULT;
 	}
 
-	if (box.y2 <= box.y1 ||
-	    box.x2 <= box.x1 ||
-	    box.y2 <= 0 ||
-	    box.x2 <= 0) {
+	if (box.y2 <= box.y1 || box.x2 <= box.x1 || box.y2 <= 0 || box.x2 <= 0) {
 		DRM_ERROR("Bad box %d,%d..%d,%d\n",
 			  box.x1, box.y1, box.x2, box.y2);
 		return DRM_ERR(EINVAL);
 	}
-				
 
 	BEGIN_LP_RING(6);
-	OUT_RING( GFX_OP_DRAWRECT_INFO );
-	OUT_RING( DR1 );
-	OUT_RING( (box.x1 & 0xffff) | (box.y1<<16) );
-	OUT_RING( ((box.x2-1) & 0xffff) | ((box.y2-1)<<16) );
-	OUT_RING( DR4 );
-	OUT_RING( 0 );
+	OUT_RING(GFX_OP_DRAWRECT_INFO);
+	OUT_RING(DR1);
+	OUT_RING((box.x1 & 0xffff) | (box.y1 << 16));
+	OUT_RING(((box.x2 - 1) & 0xffff) | ((box.y2 - 1) << 16));
+	OUT_RING(DR4);
+	OUT_RING(0);
 	ADVANCE_LP_RING();
-	
+
 	return 0;
 }
 
-
-static int i915_dispatch_cmdbuffer(drm_device_t *dev, 
-				   drm_i915_cmdbuffer_t *cmd )
+static int i915_dispatch_cmdbuffer(drm_device_t * dev,
+				   drm_i915_cmdbuffer_t * cmd)
 {
-   	int nbox = cmd->num_cliprects;
+	int nbox = cmd->num_cliprects;
 	int i = 0, count, ret;
 
 	if (cmd->sz & 0x3) {
 		DRM_ERROR("alignment");
 		return DRM_ERR(EINVAL);
 	}
-		
-   	i915_kernel_lost_context(dev);
+
+	i915_kernel_lost_context(dev);
 
 	count = nbox ? nbox : 1;
 
-	for (i = 0 ; i < count ; i++) {
+	for (i = 0; i < count; i++) {
 		if (i < nbox) {
-			ret = i915_emit_box( dev, cmd->cliprects, i, 
-					     cmd->DR1, cmd->DR4);
-			if (ret) 
+			ret = i915_emit_box(dev, cmd->cliprects, i,
+					    cmd->DR1, cmd->DR4);
+			if (ret)
 				return ret;
 		}
 
-		ret = i915_emit_cmds( dev, (int __user *)cmd->buf, cmd->sz / 4 );
-		if (ret) 
+		ret = i915_emit_cmds(dev, (int __user *)cmd->buf, cmd->sz / 4);
+		if (ret)
 			return ret;
 	}
 
 	return 0;
 }
 
-
-
-
-static int i915_dispatch_batchbuffer(drm_device_t *dev, 
-				    drm_i915_batchbuffer_t *batch )
+static int i915_dispatch_batchbuffer(drm_device_t * dev,
+				     drm_i915_batchbuffer_t * batch)
 {
-   	drm_i915_private_t *dev_priv = dev->dev_private;
-   	drm_clip_rect_t __user *boxes = batch->cliprects;
-   	int nbox = batch->num_cliprects;
+	drm_i915_private_t *dev_priv = dev->dev_private;
+	drm_clip_rect_t __user *boxes = batch->cliprects;
+	int nbox = batch->num_cliprects;
 	int i = 0, count;
-   	RING_LOCALS;
+	RING_LOCALS;
 
 	if ((batch->start | batch->used) & 0x7) {
 		DRM_ERROR("alignment");
 		return DRM_ERR(EINVAL);
 	}
-		
-   	i915_kernel_lost_context(dev);
+
+	i915_kernel_lost_context(dev);
 
 	count = nbox ? nbox : 1;
 
-	for (i = 0 ; i < count ; i++) {
+	for (i = 0; i < count; i++) {
 		if (i < nbox) {
-			int ret = i915_emit_box( dev, boxes, i,
-						 batch->DR1, batch->DR4);
-			if (ret) 
+			int ret = i915_emit_box(dev, boxes, i,
+						batch->DR1, batch->DR4);
+			if (ret)
 				return ret;
 		}
 
 		if (dev_priv->use_mi_batchbuffer_start) {
 			BEGIN_LP_RING(2);
-			OUT_RING( MI_BATCH_BUFFER_START | (2<<6) );
-			OUT_RING( batch->start | MI_BATCH_NON_SECURE );
+			OUT_RING(MI_BATCH_BUFFER_START | (2 << 6));
+			OUT_RING(batch->start | MI_BATCH_NON_SECURE);
 			ADVANCE_LP_RING();
-		} 
-		else {
+		} else {
 			BEGIN_LP_RING(4);
-			OUT_RING( MI_BATCH_BUFFER );
-			OUT_RING( batch->start | MI_BATCH_NON_SECURE );
-			OUT_RING( batch->start + batch->used - 4 );
-			OUT_RING( 0 );
+			OUT_RING(MI_BATCH_BUFFER);
+			OUT_RING(batch->start | MI_BATCH_NON_SECURE);
+			OUT_RING(batch->start + batch->used - 4);
+			OUT_RING(0);
 			ADVANCE_LP_RING();
 		}
 	}
 
-	
 	dev_priv->sarea_priv->last_enqueue = dev_priv->counter++;
 
 	BEGIN_LP_RING(4);
-	OUT_RING( CMD_STORE_DWORD_IDX );
-	OUT_RING( 20 );
-	OUT_RING( dev_priv->counter );
-	OUT_RING( 0 );
+	OUT_RING(CMD_STORE_DWORD_IDX);
+	OUT_RING(20);
+	OUT_RING(dev_priv->counter);
+	OUT_RING(0);
 	ADVANCE_LP_RING();
 
 	return 0;
 }
 
-static int i915_dispatch_flip( drm_device_t *dev )
+static int i915_dispatch_flip(drm_device_t * dev)
 {
-   	drm_i915_private_t *dev_priv = dev->dev_private;
+	drm_i915_private_t *dev_priv = dev->dev_private;
 	RING_LOCALS;
 
-	DRM_DEBUG( "%s: page=%d pfCurrentPage=%d\n", 
-		   __FUNCTION__, 
-		   dev_priv->current_page,
-		   dev_priv->sarea_priv->pf_current_page);
-
-  	i915_kernel_lost_context(dev);
+	DRM_DEBUG("%s: page=%d pfCurrentPage=%d\n",
+		  __FUNCTION__,
+		  dev_priv->current_page,
+		  dev_priv->sarea_priv->pf_current_page);
 
+	i915_kernel_lost_context(dev);
 
-	BEGIN_LP_RING( 2 );
-    	OUT_RING( INST_PARSER_CLIENT | INST_OP_FLUSH | INST_FLUSH_MAP_CACHE ); 
-	OUT_RING( 0 );
+	BEGIN_LP_RING(2);
+	OUT_RING(INST_PARSER_CLIENT | INST_OP_FLUSH | INST_FLUSH_MAP_CACHE);
+	OUT_RING(0);
 	ADVANCE_LP_RING();
 
-	BEGIN_LP_RING( 6 );
-	OUT_RING( CMD_OP_DISPLAYBUFFER_INFO | ASYNC_FLIP );	
-	OUT_RING( 0 );
-	if ( dev_priv->current_page == 0 ) {
-		OUT_RING( dev_priv->back_offset );
+	BEGIN_LP_RING(6);
+	OUT_RING(CMD_OP_DISPLAYBUFFER_INFO | ASYNC_FLIP);
+	OUT_RING(0);
+	if (dev_priv->current_page == 0) {
+		OUT_RING(dev_priv->back_offset);
 		dev_priv->current_page = 1;
 	} else {
-		OUT_RING( dev_priv->front_offset );
+		OUT_RING(dev_priv->front_offset);
 		dev_priv->current_page = 0;
 	}
 	OUT_RING(0);
 	ADVANCE_LP_RING();
 
-
-	BEGIN_LP_RING( 2 );
-	OUT_RING( MI_WAIT_FOR_EVENT |
-		  MI_WAIT_FOR_PLANE_A_FLIP );
-	OUT_RING( 0 );
+	BEGIN_LP_RING(2);
+	OUT_RING(MI_WAIT_FOR_EVENT | MI_WAIT_FOR_PLANE_A_FLIP);
+	OUT_RING(0);
 	ADVANCE_LP_RING();
-	
 
 	dev_priv->sarea_priv->last_enqueue = dev_priv->counter++;
 
 	BEGIN_LP_RING(4);
-	OUT_RING( CMD_STORE_DWORD_IDX );
-	OUT_RING( 20 );
-	OUT_RING( dev_priv->counter );
-	OUT_RING( 0 );
+	OUT_RING(CMD_STORE_DWORD_IDX);
+	OUT_RING(20);
+	OUT_RING(dev_priv->counter);
+	OUT_RING(0);
 	ADVANCE_LP_RING();
 
 	dev_priv->sarea_priv->pf_current_page = dev_priv->current_page;
 	return 0;
 }
 
-
-static int i915_quiescent(drm_device_t *dev)
+static int i915_quiescent(drm_device_t * dev)
 {
-   	drm_i915_private_t *dev_priv = dev->dev_private;
+	drm_i915_private_t *dev_priv = dev->dev_private;
 
-  	i915_kernel_lost_context(dev);
-	return i915_wait_ring( dev, dev_priv->ring.Size - 8, __FUNCTION__ );
+	i915_kernel_lost_context(dev);
+	return i915_wait_ring(dev, dev_priv->ring.Size - 8, __FUNCTION__);
 }
 
-
-int i915_flush_ioctl( DRM_IOCTL_ARGS )
+int i915_flush_ioctl(DRM_IOCTL_ARGS)
 {
 	DRM_DEVICE;
 
-   	if(!_DRM_LOCK_IS_HELD(dev->lock.hw_lock->lock)) {
+	if (!_DRM_LOCK_IS_HELD(dev->lock.hw_lock->lock)) {
 		DRM_ERROR("i915_flush_ioctl called without lock held\n");
 		return DRM_ERR(EINVAL);
 	}
 
-    	return i915_quiescent(dev); 
+	return i915_quiescent(dev);
 }
 
-int i915_batchbuffer( DRM_IOCTL_ARGS )
+int i915_batchbuffer(DRM_IOCTL_ARGS)
 {
 	DRM_DEVICE;
-   	drm_i915_private_t *dev_priv = (drm_i915_private_t *)dev->dev_private;
-      	u32 *hw_status = dev_priv->hw_status_page;
-   	drm_i915_sarea_t *sarea_priv = (drm_i915_sarea_t *) 
-     					dev_priv->sarea_priv; 
+	drm_i915_private_t *dev_priv = (drm_i915_private_t *) dev->dev_private;
+	u32 *hw_status = dev_priv->hw_status_page;
+	drm_i915_sarea_t *sarea_priv = (drm_i915_sarea_t *)
+	    dev_priv->sarea_priv;
 	drm_i915_batchbuffer_t batch;
 	int ret;
 
@@ -610,113 +581,107 @@ int i915_batchbuffer( DRM_IOCTL_ARGS )
 		return DRM_ERR(EINVAL);
 	}
 
-	DRM_COPY_FROM_USER_IOCTL( batch, (drm_i915_batchbuffer_t __user *)data, 
-				  sizeof(batch) );
+	DRM_COPY_FROM_USER_IOCTL(batch, (drm_i915_batchbuffer_t __user *) data,
+				 sizeof(batch));
 
 	DRM_DEBUG("i915 batchbuffer, start %x used %d cliprects %d\n",
 		  batch.start, batch.used, batch.num_cliprects);
 
-
-   	if(!_DRM_LOCK_IS_HELD(dev->lock.hw_lock->lock)) {
+	if (!_DRM_LOCK_IS_HELD(dev->lock.hw_lock->lock)) {
 		DRM_ERROR("i915_batchbuffer called without lock held\n");
 		return DRM_ERR(EINVAL);
 	}
 
-	if (batch.num_cliprects && DRM_VERIFYAREA_READ(batch.cliprects, 
+	if (batch.num_cliprects && DRM_VERIFYAREA_READ(batch.cliprects,
 						       batch.num_cliprects *
 						       sizeof(drm_clip_rect_t)))
 		return DRM_ERR(EFAULT);
 
-	ret = i915_dispatch_batchbuffer( dev, &batch );
+	ret = i915_dispatch_batchbuffer(dev, &batch);
 
-   	sarea_priv->last_dispatch = (int) hw_status[5];   
+	sarea_priv->last_dispatch = (int)hw_status[5];
 	return ret;
 }
 
-int i915_cmdbuffer( DRM_IOCTL_ARGS )
+int i915_cmdbuffer(DRM_IOCTL_ARGS)
 {
 	DRM_DEVICE;
-   	drm_i915_private_t *dev_priv = (drm_i915_private_t *)dev->dev_private;
-      	u32 *hw_status = dev_priv->hw_status_page;
-   	drm_i915_sarea_t *sarea_priv = (drm_i915_sarea_t *) 
-		dev_priv->sarea_priv; 
+	drm_i915_private_t *dev_priv = (drm_i915_private_t *) dev->dev_private;
+	u32 *hw_status = dev_priv->hw_status_page;
+	drm_i915_sarea_t *sarea_priv = (drm_i915_sarea_t *)
+	    dev_priv->sarea_priv;
 	drm_i915_cmdbuffer_t cmdbuf;
 	int ret;
 
-	DRM_COPY_FROM_USER_IOCTL( cmdbuf, (drm_i915_cmdbuffer_t __user *)data, 
-				  sizeof(cmdbuf) );
+	DRM_COPY_FROM_USER_IOCTL(cmdbuf, (drm_i915_cmdbuffer_t __user *) data,
+				 sizeof(cmdbuf));
 
 	DRM_DEBUG("i915 cmdbuffer, buf %p sz %d cliprects %d\n",
 		  cmdbuf.buf, cmdbuf.sz, cmdbuf.num_cliprects);
 
-
-   	if(!_DRM_LOCK_IS_HELD(dev->lock.hw_lock->lock)) {
+	if (!_DRM_LOCK_IS_HELD(dev->lock.hw_lock->lock)) {
 		DRM_ERROR("i915_cmdbuffer called without lock held\n");
 		return DRM_ERR(EINVAL);
 	}
 
-	if (cmdbuf.num_cliprects && 
-	    DRM_VERIFYAREA_READ(cmdbuf.cliprects, 
+	if (cmdbuf.num_cliprects &&
+	    DRM_VERIFYAREA_READ(cmdbuf.cliprects,
 				cmdbuf.num_cliprects *
 				sizeof(drm_clip_rect_t))) {
 		DRM_ERROR("Fault accessing cliprects\n");
 		return DRM_ERR(EFAULT);
 	}
 
-	ret = i915_dispatch_cmdbuffer( dev, &cmdbuf );
+	ret = i915_dispatch_cmdbuffer(dev, &cmdbuf);
 	if (ret) {
 		DRM_ERROR("i915_dispatch_cmdbuffer failed\n");
 		return ret;
 	}
 
-   	sarea_priv->last_dispatch = (int) hw_status[5];   
+	sarea_priv->last_dispatch = (int)hw_status[5];
 	return 0;
 }
 
-
-
-int i915_do_cleanup_pageflip( drm_device_t *dev )
+int i915_do_cleanup_pageflip(drm_device_t * dev)
 {
 	drm_i915_private_t *dev_priv = dev->dev_private;
 
 	DRM_DEBUG("%s\n", __FUNCTION__);
 	if (dev_priv->current_page != 0)
-		i915_dispatch_flip( dev );
+		i915_dispatch_flip(dev);
 
 	return 0;
 }
 
-int i915_flip_bufs( DRM_IOCTL_ARGS )
+int i915_flip_bufs(DRM_IOCTL_ARGS)
 {
 	DRM_DEVICE;
 
 	DRM_DEBUG("%s\n", __FUNCTION__);
-   	if(!_DRM_LOCK_IS_HELD(dev->lock.hw_lock->lock)) {
+	if (!_DRM_LOCK_IS_HELD(dev->lock.hw_lock->lock)) {
 		DRM_ERROR("i915_flip_buf called without lock held\n");
 		return DRM_ERR(EINVAL);
 	}
 
-	return i915_dispatch_flip( dev );
+	return i915_dispatch_flip(dev);
 }
 
-
-
-int i915_getparam( DRM_IOCTL_ARGS )
+int i915_getparam(DRM_IOCTL_ARGS)
 {
 	DRM_DEVICE;
 	drm_i915_private_t *dev_priv = dev->dev_private;
 	drm_i915_getparam_t param;
 	int value;
 
-	if ( !dev_priv ) {
-		DRM_ERROR( "%s called with no initialization\n", __FUNCTION__ );
+	if (!dev_priv) {
+		DRM_ERROR("%s called with no initialization\n", __FUNCTION__);
 		return DRM_ERR(EINVAL);
 	}
 
-	DRM_COPY_FROM_USER_IOCTL(param, (drm_i915_getparam_t __user *)data, 
+	DRM_COPY_FROM_USER_IOCTL(param, (drm_i915_getparam_t __user *) data,
 				 sizeof(param));
 
-	switch( param.param ) {
+	switch (param.param) {
 	case I915_PARAM_IRQ_ACTIVE:
 		value = dev->irq ? 1 : 0;
 		break;
@@ -728,30 +693,29 @@ int i915_getparam( DRM_IOCTL_ARGS )
 		return DRM_ERR(EINVAL);
 	}
 
-	if ( DRM_COPY_TO_USER( param.value, &value, sizeof(int) ) ) {
+	if (DRM_COPY_TO_USER(param.value, &value, sizeof(int))) {
 		DRM_ERROR("DRM_COPY_TO_USER failed\n");
 		return DRM_ERR(EFAULT);
 	}
-	
+
 	return 0;
 }
 
-
-int i915_setparam( DRM_IOCTL_ARGS )
+int i915_setparam(DRM_IOCTL_ARGS)
 {
 	DRM_DEVICE;
 	drm_i915_private_t *dev_priv = dev->dev_private;
 	drm_i915_setparam_t param;
 
-	if ( !dev_priv ) {
-		DRM_ERROR( "%s called with no initialization\n", __FUNCTION__ );
+	if (!dev_priv) {
+		DRM_ERROR("%s called with no initialization\n", __FUNCTION__);
 		return DRM_ERR(EINVAL);
 	}
 
-	DRM_COPY_FROM_USER_IOCTL( param, (drm_i915_setparam_t __user *)data, 
-				  sizeof(param) );
+	DRM_COPY_FROM_USER_IOCTL(param, (drm_i915_setparam_t __user *) data,
+				 sizeof(param));
 
-	switch( param.param ) {
+	switch (param.param) {
 	case I915_SETPARAM_USE_MI_BATCHBUFFER_START:
 		dev_priv->use_mi_batchbuffer_start = param.value;
 		break;
@@ -766,30 +730,31 @@ int i915_setparam( DRM_IOCTL_ARGS )
 		return DRM_ERR(EINVAL);
 	}
 
-
 	return 0;
 }
 
-static void i915_driver_pretakedown(drm_device_t *dev)
+static void i915_driver_pretakedown(drm_device_t * dev)
 {
-	if ( dev->dev_private ) {
+	if (dev->dev_private) {
 		drm_i915_private_t *dev_priv = dev->dev_private;
-	        i915_mem_takedown( &(dev_priv->agp_heap) );
- 	}
-	i915_dma_cleanup( dev );
+		i915_mem_takedown(&(dev_priv->agp_heap));
+	}
+	i915_dma_cleanup(dev);
 }
 
-static void i915_driver_prerelease(drm_device_t *dev, DRMFILE filp)
+static void i915_driver_prerelease(drm_device_t * dev, DRMFILE filp)
 {
-	if ( dev->dev_private ) {
+	if (dev->dev_private) {
 		drm_i915_private_t *dev_priv = dev->dev_private;
-                i915_mem_release( dev, filp, dev_priv->agp_heap );
+		i915_mem_release(dev, filp, dev_priv->agp_heap);
 	}
 }
 
-void i915_driver_register_fns(drm_device_t *dev)
+void i915_driver_register_fns(drm_device_t * dev)
 {
-	dev->driver_features = DRIVER_USE_AGP | DRIVER_REQUIRE_AGP | DRIVER_USE_MTRR | DRIVER_HAVE_IRQ | DRIVER_IRQ_SHARED;
+	dev->driver_features =
+	    DRIVER_USE_AGP | DRIVER_REQUIRE_AGP | DRIVER_USE_MTRR |
+	    DRIVER_HAVE_IRQ | DRIVER_IRQ_SHARED;
 	dev->fn_tbl.pretakedown = i915_driver_pretakedown;
 	dev->fn_tbl.prerelease = i915_driver_prerelease;
 	dev->fn_tbl.irq_preinstall = i915_driver_irq_preinstall;
diff --git a/shared/i915_drm.h b/shared/i915_drm.h
index 7a69e83f..24f4cd62 100644
--- a/shared/i915_drm.h
+++ b/shared/i915_drm.h
@@ -13,7 +13,6 @@
 				 * of chars for next/prev indices */
 #define I915_LOG_MIN_TEX_REGION_SIZE 14
 
-
 typedef struct _drm_i915_init {
 	enum {
 		I915_INIT_DMA = 0x01,
@@ -35,31 +34,29 @@ typedef struct _drm_i915_init {
 	unsigned int back_pitch;
 	unsigned int depth_pitch;
 	unsigned int cpp;
-        unsigned int chipset;
+	unsigned int chipset;
 } drm_i915_init_t;
 
-
 typedef struct _drm_i915_sarea {
-	drm_tex_region_t texList[I915_NR_TEX_REGIONS+1];
-        int last_upload;	/* last time texture was uploaded */
-        int last_enqueue;	/* last time a buffer was enqueued */
+	drm_tex_region_t texList[I915_NR_TEX_REGIONS + 1];
+	int last_upload;	/* last time texture was uploaded */
+	int last_enqueue;	/* last time a buffer was enqueued */
 	int last_dispatch;	/* age of the most recently dispatched buffer */
 	int ctxOwner;		/* last context to upload state */
 	int texAge;
-        int pf_enabled;		/* is pageflipping allowed? */
-        int pf_active;               
-        int pf_current_page;	/* which buffer is being displayed? */
-        int perf_boxes;	        /* performance boxes to be displayed */   
+	int pf_enabled;		/* is pageflipping allowed? */
+	int pf_active;
+	int pf_current_page;	/* which buffer is being displayed? */
+	int perf_boxes;		/* performance boxes to be displayed */
 } drm_i915_sarea_t;
 
 /* Flags for perf_boxes
  */
-#define I915_BOX_RING_EMPTY    0x1 
-#define I915_BOX_FLIP          0x2 
-#define I915_BOX_WAIT          0x4 
-#define I915_BOX_TEXTURE_LOAD  0x8 
-#define I915_BOX_LOST_CONTEXT  0x10 
-
+#define I915_BOX_RING_EMPTY    0x1
+#define I915_BOX_FLIP          0x2
+#define I915_BOX_WAIT          0x4
+#define I915_BOX_TEXTURE_LOAD  0x8
+#define I915_BOX_LOST_CONTEXT  0x10
 
 /* I915 specific ioctls
  * The device specific ioctl range is 0x40 to 0x79.
@@ -77,32 +74,30 @@ typedef struct _drm_i915_sarea {
 #define DRM_IOCTL_I915_INIT_HEAP        DRM_IOW( 0x4a, drm_i915_mem_init_heap_t)
 #define DRM_IOCTL_I915_CMDBUFFER	DRM_IOW( 0x4b, drm_i915_cmdbuffer_t)
 
-
 /* Allow drivers to submit batchbuffers directly to hardware, relying
  * on the security mechanisms provided by hardware.
  */
 typedef struct _drm_i915_batchbuffer {
-   	int start;		/* agp offset */
+	int start;		/* agp offset */
 	int used;		/* nr bytes in use */
 	int DR1;		/* hw flags for GFX_OP_DRAWRECT_INFO */
-        int DR4;		/* window origin for GFX_OP_DRAWRECT_INFO*/
+	int DR4;		/* window origin for GFX_OP_DRAWRECT_INFO */
 	int num_cliprects;	/* mulitpass with multiple cliprects? */
-        drm_clip_rect_t __user *cliprects; /* pointer to userspace cliprects */
+	drm_clip_rect_t __user *cliprects;	/* pointer to userspace cliprects */
 } drm_i915_batchbuffer_t;
 
 /* As above, but pass a pointer to userspace buffer which can be
  * validated by the kernel prior to sending to hardware.
  */
 typedef struct _drm_i915_cmdbuffer {
-   	char __user *buf;	/* pointer to userspace command buffer */
-	int sz;		        /* nr bytes in buf */
+	char __user *buf;	/* pointer to userspace command buffer */
+	int sz;			/* nr bytes in buf */
 	int DR1;		/* hw flags for GFX_OP_DRAWRECT_INFO */
-        int DR4;		/* window origin for GFX_OP_DRAWRECT_INFO*/
+	int DR4;		/* window origin for GFX_OP_DRAWRECT_INFO */
 	int num_cliprects;	/* mulitpass with multiple cliprects? */
-        drm_clip_rect_t __user *cliprects; /* pointer to userspace cliprects */
+	drm_clip_rect_t __user *cliprects;	/* pointer to userspace cliprects */
 } drm_i915_cmdbuffer_t;
 
-
 /* Userspace can request & wait on irq's:
  */
 typedef struct drm_i915_irq_emit {
@@ -113,7 +108,6 @@ typedef struct drm_i915_irq_wait {
 	int irq_seq;
 } drm_i915_irq_wait_t;
 
-
 /* Ioctl to query kernel params:
  */
 #define I915_PARAM_IRQ_ACTIVE            1
@@ -124,7 +118,6 @@ typedef struct drm_i915_getparam {
 	int __user *value;
 } drm_i915_getparam_t;
 
-
 /* Ioctl to set kernel params:
  */
 #define I915_SETPARAM_USE_MI_BATCHBUFFER_START            1
@@ -155,8 +148,7 @@ typedef struct drm_i915_mem_free {
 typedef struct drm_i915_mem_init_heap {
 	int region;
 	int size;
-	int start;	
+	int start;
 } drm_i915_mem_init_heap_t;
 
-
-#endif /* _I915_DRM_H_ */
+#endif				/* _I915_DRM_H_ */
diff --git a/shared/i915_drv.h b/shared/i915_drv.h
index 4773d056..828c2371 100644
--- a/shared/i915_drv.h
+++ b/shared/i915_drv.h
@@ -10,8 +10,7 @@
 #ifndef _I915_DRV_H_
 #define _I915_DRV_H_
 
-
-typedef struct _drm_i915_ring_buffer{
+typedef struct _drm_i915_ring_buffer {
 	int tail_mask;
 	unsigned long Start;
 	unsigned long End;
@@ -36,23 +35,21 @@ typedef struct drm_i915_private {
 	drm_local_map_t *mmio_map;
 
 	drm_i915_sarea_t *sarea_priv;
-   	drm_i915_ring_buffer_t ring;
+	drm_i915_ring_buffer_t ring;
 
-      	void * hw_status_page;
-   	unsigned long counter;
+	void *hw_status_page;
+	unsigned long counter;
 	dma_addr_t dma_status_page;
 
-	
 	int back_offset;
 	int front_offset;
 	int current_page;
 	int page_flipping;
 	int use_mi_batchbuffer_start;
-	
 
 	wait_queue_head_t irq_queue;
-   	atomic_t irq_received;
-   	atomic_t irq_emitted;
+	atomic_t irq_received;
+	atomic_t irq_emitted;
 
 	int tex_lru_log_granularity;
 	int allow_batchbuffer;
@@ -60,42 +57,40 @@ typedef struct drm_i915_private {
 } drm_i915_private_t;
 
 				/* i915_dma.c */
-extern int i915_dma_init( DRM_IOCTL_ARGS );
-extern int i915_dma_cleanup(drm_device_t *dev);
-extern int i915_flush_ioctl( DRM_IOCTL_ARGS );
-extern int i915_batchbuffer( DRM_IOCTL_ARGS );
-extern int i915_flip_bufs( DRM_IOCTL_ARGS );
-extern int i915_getparam(  DRM_IOCTL_ARGS );
-extern int i915_setparam(  DRM_IOCTL_ARGS );
-extern int i915_cmdbuffer( DRM_IOCTL_ARGS );
-extern void i915_kernel_lost_context(drm_device_t *dev);
+extern int i915_dma_init(DRM_IOCTL_ARGS);
+extern int i915_dma_cleanup(drm_device_t * dev);
+extern int i915_flush_ioctl(DRM_IOCTL_ARGS);
+extern int i915_batchbuffer(DRM_IOCTL_ARGS);
+extern int i915_flip_bufs(DRM_IOCTL_ARGS);
+extern int i915_getparam(DRM_IOCTL_ARGS);
+extern int i915_setparam(DRM_IOCTL_ARGS);
+extern int i915_cmdbuffer(DRM_IOCTL_ARGS);
+extern void i915_kernel_lost_context(drm_device_t * dev);
 
 /* i915_irq.c */
-extern int i915_irq_emit(  DRM_IOCTL_ARGS );
-extern int i915_irq_wait(  DRM_IOCTL_ARGS );
-extern int i915_wait_irq(drm_device_t *dev, int irq_nr);
-extern int i915_emit_irq(drm_device_t *dev);
+extern int i915_irq_emit(DRM_IOCTL_ARGS);
+extern int i915_irq_wait(DRM_IOCTL_ARGS);
+extern int i915_wait_irq(drm_device_t * dev, int irq_nr);
+extern int i915_emit_irq(drm_device_t * dev);
 
-extern irqreturn_t i915_driver_irq_handler( DRM_IRQ_ARGS );
-extern void i915_driver_irq_preinstall( drm_device_t *dev );
-extern void i915_driver_irq_postinstall( drm_device_t *dev );
-extern void i915_driver_irq_uninstall( drm_device_t *dev );
+extern irqreturn_t i915_driver_irq_handler(DRM_IRQ_ARGS);
+extern void i915_driver_irq_preinstall(drm_device_t * dev);
+extern void i915_driver_irq_postinstall(drm_device_t * dev);
+extern void i915_driver_irq_uninstall(drm_device_t * dev);
 
 /* i915_mem.c */
-extern int i915_mem_alloc( DRM_IOCTL_ARGS );
-extern int i915_mem_free( DRM_IOCTL_ARGS );
-extern int i915_mem_init_heap( DRM_IOCTL_ARGS );
-extern void i915_mem_takedown( struct mem_block **heap );
-extern void i915_mem_release( drm_device_t *dev, 
-			      DRMFILE filp, struct mem_block *heap );
+extern int i915_mem_alloc(DRM_IOCTL_ARGS);
+extern int i915_mem_free(DRM_IOCTL_ARGS);
+extern int i915_mem_init_heap(DRM_IOCTL_ARGS);
+extern void i915_mem_takedown(struct mem_block **heap);
+extern void i915_mem_release(drm_device_t * dev,
+			     DRMFILE filp, struct mem_block *heap);
 
 #define I915_READ(reg)          DRM_READ32(dev_priv->mmio_map, reg)
 #define I915_WRITE(reg,val)     DRM_WRITE32(dev_priv->mmio_map, reg, val)
 #define I915_READ16(reg) 	DRM_READ16(dev_priv->mmio_map, reg)
 #define I915_WRITE16(reg,val)	DRM_WRITE16(dev_priv->mmio_map, reg, val)
 
-
-
 #define I915_VERBOSE 0
 
 #define RING_LOCALS	unsigned int outring, ringmask, outcount; \
@@ -113,7 +108,6 @@ extern void i915_mem_release( drm_device_t *dev,
 	virt = dev_priv->ring.virtual_start;		\
 } while (0)
 
-
 #define OUT_RING(n) do {					\
 	if (I915_VERBOSE) DRM_DEBUG("   OUT_RING %x\n", (int)(n));	\
 	*(volatile unsigned int *)(virt + outring) = n;		\
@@ -129,8 +123,7 @@ extern void i915_mem_release( drm_device_t *dev,
 	I915_WRITE(LP_RING + RING_TAIL, outring);			\
 } while(0)
 
-extern int i915_wait_ring(drm_device_t *dev, int n, const char *caller);
-
+extern int i915_wait_ring(drm_device_t * dev, int n, const char *caller);
 
 #define GFX_OP_USER_INTERRUPT 		((0<<29)|(2<<23))
 #define GFX_OP_BREAKPOINT_INTERRUPT	((0<<29)|(1<<23))
@@ -142,7 +135,6 @@ extern int i915_wait_ring(drm_device_t *dev, int n, const char *caller);
 #define INST_OP_FLUSH        0x02000000
 #define INST_FLUSH_MAP_CACHE 0x00000001
 
-
 #define BB1_START_ADDR_MASK   (~0x7)
 #define BB1_PROTECTED         (1<<0)
 #define BB1_UNPROTECTED       (0<<0)
@@ -180,7 +172,7 @@ extern int i915_wait_ring(drm_device_t *dev, int n, const char *caller);
 #define RING_START     		0x08
 #define START_ADDR          	0x0xFFFFF000
 #define RING_LEN       		0x0C
-#define RING_NR_PAGES       	0x001FF000 
+#define RING_NR_PAGES       	0x001FF000
 #define RING_REPORT_MASK    	0x00000006
 #define RING_REPORT_64K     	0x00000002
 #define RING_REPORT_128K    	0x00000004
@@ -208,18 +200,14 @@ extern int i915_wait_ring(drm_device_t *dev, int n, const char *caller);
 #define GFX_OP_DESTBUFFER_VARS   ((0x3<<29)|(0x1d<<24)|(0x85<<16)|0x0)
 #define GFX_OP_DRAWRECT_INFO     ((0x3<<29)|(0x1d<<24)|(0x80<<16)|(0x3))
 
-
 #define MI_BATCH_BUFFER 	((0x30<<23)|1)
 #define MI_BATCH_BUFFER_START 	(0x31<<23)
 #define MI_BATCH_BUFFER_END 	(0xA<<23)
 #define MI_BATCH_NON_SECURE	(1)
 
-
-
 #define MI_WAIT_FOR_EVENT       ((0x3<<23))
-#define MI_WAIT_FOR_PLANE_A_FLIP      (1<<2) 
-#define MI_WAIT_FOR_PLANE_A_SCANLINES (1<<1) 
-
+#define MI_WAIT_FOR_PLANE_A_FLIP      (1<<2)
+#define MI_WAIT_FOR_PLANE_A_SCANLINES (1<<1)
 
 #define MI_LOAD_SCAN_LINES_INCL  ((0x12<<23))
 
@@ -229,4 +217,3 @@ extern int i915_wait_ring(drm_device_t *dev, int n, const char *caller);
 #define CMD_OP_DESTBUFFER_INFO	 ((0x3<<29)|(0x1d<<24)|(0x8e<<16)|1)
 
 #endif
-
diff --git a/shared/i915_irq.c b/shared/i915_irq.c
index cd7cdfbd..de91aba5 100644
--- a/shared/i915_irq.c
+++ b/shared/i915_irq.c
@@ -17,156 +17,149 @@
 #define MAX_NOPID ((u32)~0)
 #define READ_BREADCRUMB(dev_priv)  (((u32*)(dev_priv->hw_status_page))[5])
 
-
-irqreturn_t i915_driver_irq_handler( DRM_IRQ_ARGS )
+irqreturn_t i915_driver_irq_handler(DRM_IRQ_ARGS)
 {
-	drm_device_t	 *dev = (drm_device_t *)arg;
-      	drm_i915_private_t *dev_priv = (drm_i915_private_t *)dev->dev_private;
-   	u16 temp;
+	drm_device_t *dev = (drm_device_t *) arg;
+	drm_i915_private_t *dev_priv = (drm_i915_private_t *) dev->dev_private;
+	u16 temp;
 
-      	temp = I915_READ16(I915REG_INT_IDENTITY_R);
+	temp = I915_READ16(I915REG_INT_IDENTITY_R);
 	temp &= USER_INT_FLAG;
-	
+
 	DRM_DEBUG("%s flag=%08x\n", __FUNCTION__, temp);
 
-   	if (temp == 0) 
+	if (temp == 0)
 		return IRQ_NONE;
 
-	I915_WRITE16(I915REG_INT_IDENTITY_R, temp); 
-	DRM_WAKEUP( &dev_priv->irq_queue ); 
+	I915_WRITE16(I915REG_INT_IDENTITY_R, temp);
+	DRM_WAKEUP(&dev_priv->irq_queue);
 
 	return IRQ_HANDLED;
 }
 
-
-int i915_emit_irq(drm_device_t *dev)
+int i915_emit_irq(drm_device_t * dev)
 {
 	drm_i915_private_t *dev_priv = dev->dev_private;
 	u32 ret;
 	RING_LOCALS;
 
-   	i915_kernel_lost_context(dev);
+	i915_kernel_lost_context(dev);
 
 	DRM_DEBUG("%s\n", __FUNCTION__);
 
 	ret = dev_priv->counter;
 
-   	BEGIN_LP_RING(2);
-      	OUT_RING( 0 );
-      	OUT_RING( GFX_OP_USER_INTERRUPT );
-      	ADVANCE_LP_RING();
+	BEGIN_LP_RING(2);
+	OUT_RING(0);
+	OUT_RING(GFX_OP_USER_INTERRUPT);
+	ADVANCE_LP_RING();
 
 	return ret;
 }
 
-
-int i915_wait_irq(drm_device_t *dev, int irq_nr)
+int i915_wait_irq(drm_device_t * dev, int irq_nr)
 {
-  	drm_i915_private_t *dev_priv = 
-	   (drm_i915_private_t *)dev->dev_private;
+	drm_i915_private_t *dev_priv = (drm_i915_private_t *) dev->dev_private;
 	int ret = 0;
 
-	DRM_DEBUG("%s irq_nr=%d breadcrumb=%d\n", __FUNCTION__, irq_nr, READ_BREADCRUMB(dev_priv));
+	DRM_DEBUG("%s irq_nr=%d breadcrumb=%d\n", __FUNCTION__, irq_nr,
+		  READ_BREADCRUMB(dev_priv));
 
- 	if (READ_BREADCRUMB(dev_priv) >= irq_nr)  
- 		return 0; 
+	if (READ_BREADCRUMB(dev_priv) >= irq_nr)
+		return 0;
 
 	dev_priv->sarea_priv->perf_boxes |= I915_BOX_WAIT;
 
-	DRM_WAIT_ON( ret, dev_priv->irq_queue, 3 * DRM_HZ,
-		     READ_BREADCRUMB(dev_priv) >= irq_nr );
+	DRM_WAIT_ON(ret, dev_priv->irq_queue, 3 * DRM_HZ,
+		    READ_BREADCRUMB(dev_priv) >= irq_nr);
 
 	if (ret == DRM_ERR(EBUSY)) {
-		DRM_ERROR("%s: EBUSY -- rec: %d emitted: %d\n", 
+		DRM_ERROR("%s: EBUSY -- rec: %d emitted: %d\n",
 			  __FUNCTION__,
-			  READ_BREADCRUMB(dev_priv),
-			  (int)dev_priv->counter);
+			  READ_BREADCRUMB(dev_priv), (int)dev_priv->counter);
 	}
 
-      	dev_priv->sarea_priv->last_dispatch = READ_BREADCRUMB(dev_priv);
+	dev_priv->sarea_priv->last_dispatch = READ_BREADCRUMB(dev_priv);
 	return ret;
 }
 
-
 /* Needs the lock as it touches the ring.
  */
-int i915_irq_emit( DRM_IOCTL_ARGS )
+int i915_irq_emit(DRM_IOCTL_ARGS)
 {
 	DRM_DEVICE;
 	drm_i915_private_t *dev_priv = dev->dev_private;
 	drm_i915_irq_emit_t emit;
 	int result;
 
-   	if(!_DRM_LOCK_IS_HELD(dev->lock.hw_lock->lock)) {
+	if (!_DRM_LOCK_IS_HELD(dev->lock.hw_lock->lock)) {
 		DRM_ERROR("i915_irq_emit called without lock held\n");
 		return DRM_ERR(EINVAL);
 	}
 
-	if ( !dev_priv ) {
-		DRM_ERROR( "%s called with no initialization\n", __FUNCTION__ );
+	if (!dev_priv) {
+		DRM_ERROR("%s called with no initialization\n", __FUNCTION__);
 		return DRM_ERR(EINVAL);
 	}
 
-	DRM_COPY_FROM_USER_IOCTL( emit, (drm_i915_irq_emit_t __user *)data,
-				  sizeof(emit) );
+	DRM_COPY_FROM_USER_IOCTL(emit, (drm_i915_irq_emit_t __user *) data,
+				 sizeof(emit));
 
-	result = i915_emit_irq( dev );
+	result = i915_emit_irq(dev);
 
-	if ( DRM_COPY_TO_USER( emit.irq_seq, &result, sizeof(int) ) ) {
-		DRM_ERROR( "copy_to_user\n" );
+	if (DRM_COPY_TO_USER(emit.irq_seq, &result, sizeof(int))) {
+		DRM_ERROR("copy_to_user\n");
 		return DRM_ERR(EFAULT);
 	}
 
 	return 0;
 }
 
-
 /* Doesn't need the hardware lock.
  */
-int i915_irq_wait( DRM_IOCTL_ARGS )
+int i915_irq_wait(DRM_IOCTL_ARGS)
 {
 	DRM_DEVICE;
 	drm_i915_private_t *dev_priv = dev->dev_private;
 	drm_i915_irq_wait_t irqwait;
 
-	if ( !dev_priv ) {
-		DRM_ERROR( "%s called with no initialization\n", __FUNCTION__ );
+	if (!dev_priv) {
+		DRM_ERROR("%s called with no initialization\n", __FUNCTION__);
 		return DRM_ERR(EINVAL);
 	}
 
-	DRM_COPY_FROM_USER_IOCTL( irqwait, (drm_i915_irq_wait_t __user *)data, 
-				  sizeof(irqwait) );
+	DRM_COPY_FROM_USER_IOCTL(irqwait, (drm_i915_irq_wait_t __user *) data,
+				 sizeof(irqwait));
 
-	return i915_wait_irq( dev, irqwait.irq_seq );
+	return i915_wait_irq(dev, irqwait.irq_seq);
 }
 
-
 /* drm_dma.h hooks
 */
-void i915_driver_irq_preinstall( drm_device_t *dev ) {
-	drm_i915_private_t *dev_priv =
-		(drm_i915_private_t *)dev->dev_private;
+void i915_driver_irq_preinstall(drm_device_t * dev)
+{
+	drm_i915_private_t *dev_priv = (drm_i915_private_t *) dev->dev_private;
 
-	I915_WRITE16( I915REG_HWSTAM, 0xfffe );
-	I915_WRITE16( I915REG_INT_MASK_R, 0x0 );
-	I915_WRITE16( I915REG_INT_ENABLE_R, 0x0 );
+	I915_WRITE16(I915REG_HWSTAM, 0xfffe);
+	I915_WRITE16(I915REG_INT_MASK_R, 0x0);
+	I915_WRITE16(I915REG_INT_ENABLE_R, 0x0);
 }
 
-void i915_driver_irq_postinstall( drm_device_t *dev ) {
-	drm_i915_private_t *dev_priv =
-		(drm_i915_private_t *)dev->dev_private;
+void i915_driver_irq_postinstall(drm_device_t * dev)
+{
+	drm_i915_private_t *dev_priv = (drm_i915_private_t *) dev->dev_private;
 
-	I915_WRITE16( I915REG_INT_ENABLE_R, USER_INT_FLAG );
+	I915_WRITE16(I915REG_INT_ENABLE_R, USER_INT_FLAG);
 	DRM_INIT_WAITQUEUE(&dev_priv->irq_queue);
 }
 
-void i915_driver_irq_uninstall( drm_device_t *dev ) {
-	drm_i915_private_t *dev_priv =
-		(drm_i915_private_t *)dev->dev_private;
+void i915_driver_irq_uninstall(drm_device_t * dev)
+{
+	drm_i915_private_t *dev_priv = (drm_i915_private_t *) dev->dev_private;
 	if (!dev_priv)
 		return;
 
-	I915_WRITE16( I915REG_HWSTAM, 0xffff );
-	I915_WRITE16( I915REG_INT_MASK_R, 0xffff );
-	I915_WRITE16( I915REG_INT_ENABLE_R, 0x0 );
+	I915_WRITE16(I915REG_HWSTAM, 0xffff);
+	I915_WRITE16(I915REG_INT_MASK_R, 0xffff);
+	I915_WRITE16(I915REG_INT_ENABLE_R, 0x0);
 }
diff --git a/shared/i915_mem.c b/shared/i915_mem.c
index 40098514..42c1e353 100644
--- a/shared/i915_mem.c
+++ b/shared/i915_mem.c
@@ -25,60 +25,58 @@
  * block to allocate, and the ring is drained prior to allocations --
  * in other words allocation is expensive.
  */
-static void mark_block( drm_device_t *dev, struct mem_block *p,
-			int in_use )
+static void mark_block(drm_device_t * dev, struct mem_block *p, int in_use)
 {
-   drm_i915_private_t *dev_priv = dev->dev_private;
-   drm_i915_sarea_t *sarea_priv = dev_priv->sarea_priv;
-   drm_tex_region_t *list;
-   unsigned   shift, nr;
-   unsigned   start;
-   unsigned   end;
-   unsigned   i;
-   int age;
-
-   shift = dev_priv->tex_lru_log_granularity;
-   nr = I915_NR_TEX_REGIONS;
-
-   start = p->start >> shift;
-   end = (p->start + p->size - 1) >> shift;
-
-   age = ++sarea_priv->texAge;
-   list = sarea_priv->texList;
-
-   /* Mark the regions with the new flag and update their age.  Move
-    * them to head of list to preserve LRU semantics.
-    */
-   for (i = start ; i <= end ; i++) {
-      list[i].in_use = in_use;
-      list[i].age = age;
-
-      /* remove_from_list(i)
-       */
-      list[(unsigned)list[i].next].prev = list[i].prev;
-      list[(unsigned)list[i].prev].next = list[i].next;
-
-      /* insert_at_head(list, i)
-       */
-      list[i].prev = nr;
-      list[i].next = list[nr].next;
-      list[(unsigned)list[nr].next].prev = i;
-      list[nr].next = i;
-   }
-}
+	drm_i915_private_t *dev_priv = dev->dev_private;
+	drm_i915_sarea_t *sarea_priv = dev_priv->sarea_priv;
+	drm_tex_region_t *list;
+	unsigned shift, nr;
+	unsigned start;
+	unsigned end;
+	unsigned i;
+	int age;
+
+	shift = dev_priv->tex_lru_log_granularity;
+	nr = I915_NR_TEX_REGIONS;
+
+	start = p->start >> shift;
+	end = (p->start + p->size - 1) >> shift;
 
+	age = ++sarea_priv->texAge;
+	list = sarea_priv->texList;
+
+	/* Mark the regions with the new flag and update their age.  Move
+	 * them to head of list to preserve LRU semantics.
+	 */
+	for (i = start; i <= end; i++) {
+		list[i].in_use = in_use;
+		list[i].age = age;
+
+		/* remove_from_list(i)
+		 */
+		list[(unsigned)list[i].next].prev = list[i].prev;
+		list[(unsigned)list[i].prev].next = list[i].next;
+
+		/* insert_at_head(list, i)
+		 */
+		list[i].prev = nr;
+		list[i].next = list[nr].next;
+		list[(unsigned)list[nr].next].prev = i;
+		list[nr].next = i;
+	}
+}
 
 /* Very simple allocator for agp memory, working on a static range
  * already mapped into each client's address space.  
  */
 
 static struct mem_block *split_block(struct mem_block *p, int start, int size,
-				     DRMFILE filp )
+				     DRMFILE filp)
 {
 	/* Maybe cut off the start of an existing block */
 	if (start > p->start) {
 		struct mem_block *newblock = DRM_MALLOC(sizeof(*newblock));
-		if (!newblock) 
+		if (!newblock)
 			goto out;
 		newblock->start = start;
 		newblock->size = p->size - (start - p->start);
@@ -90,7 +88,7 @@ static struct mem_block *split_block(struct mem_block *p, int start, int size,
 		p->size -= newblock->size;
 		p = newblock;
 	}
-   
+
 	/* Maybe cut off the end of an existing block */
 	if (size < p->size) {
 		struct mem_block *newblock = DRM_MALLOC(sizeof(*newblock));
@@ -106,40 +104,39 @@ static struct mem_block *split_block(struct mem_block *p, int start, int size,
 		p->size = size;
 	}
 
- out:
+      out:
 	/* Our block is in the middle */
 	p->filp = filp;
 	return p;
 }
 
-static struct mem_block *alloc_block( struct mem_block *heap, int size, 
-				      int align2, DRMFILE filp )
+static struct mem_block *alloc_block(struct mem_block *heap, int size,
+				     int align2, DRMFILE filp)
 {
 	struct mem_block *p;
-	int mask = (1 << align2)-1;
+	int mask = (1 << align2) - 1;
 
-	for (p = heap->next ; p != heap ; p = p->next) {
+	for (p = heap->next; p != heap; p = p->next) {
 		int start = (p->start + mask) & ~mask;
 		if (p->filp == NULL && start + size <= p->start + p->size)
-			return split_block( p, start, size, filp );
+			return split_block(p, start, size, filp);
 	}
 
 	return NULL;
 }
 
-static struct mem_block *find_block( struct mem_block *heap, int start )
+static struct mem_block *find_block(struct mem_block *heap, int start)
 {
 	struct mem_block *p;
 
-	for (p = heap->next ; p != heap ; p = p->next) 
+	for (p = heap->next; p != heap; p = p->next)
 		if (p->start == start)
 			return p;
 
 	return NULL;
 }
 
-
-static void free_block( struct mem_block *p )
+static void free_block(struct mem_block *p)
 {
 	p->filp = NULL;
 
@@ -169,12 +166,12 @@ static int init_heap(struct mem_block **heap, int start, int size)
 {
 	struct mem_block *blocks = DRM_MALLOC(sizeof(*blocks));
 
-	if (!blocks) 
+	if (!blocks)
 		return -ENOMEM;
-	
+
 	*heap = DRM_MALLOC(sizeof(**heap));
 	if (!*heap) {
-		DRM_FREE( blocks, sizeof(*blocks) );
+		DRM_FREE(blocks, sizeof(*blocks));
 		return -ENOMEM;
 	}
 
@@ -183,34 +180,32 @@ static int init_heap(struct mem_block **heap, int start, int size)
 	blocks->filp = NULL;
 	blocks->next = blocks->prev = *heap;
 
-	memset( *heap, 0, sizeof(**heap) );
-	(*heap)->filp = (DRMFILE) -1;
+	memset(*heap, 0, sizeof(**heap));
+	(*heap)->filp = (DRMFILE) - 1;
 	(*heap)->next = (*heap)->prev = blocks;
 	return 0;
 }
 
-
 /* Free all blocks associated with the releasing file.
  */
-void i915_mem_release( drm_device_t *dev, 
-		       DRMFILE filp, struct mem_block *heap )
+void i915_mem_release(drm_device_t * dev, DRMFILE filp, struct mem_block *heap)
 {
 	struct mem_block *p;
 
 	if (!heap || !heap->next)
 		return;
 
-	for (p = heap->next ; p != heap ; p = p->next) {
+	for (p = heap->next; p != heap; p = p->next) {
 		if (p->filp == filp) {
 			p->filp = NULL;
-			mark_block( dev, p, 0 );
+			mark_block(dev, p, 0);
 		}
 	}
 
 	/* Assumes a single contiguous range.  Needs a special filp in
 	 * 'heap' to stop it being subsumed.
 	 */
-	for (p = heap->next ; p != heap ; p = p->next) {
+	for (p = heap->next; p != heap; p = p->next) {
 		while (p->filp == NULL && p->next->filp == NULL) {
 			struct mem_block *q = p->next;
 			p->size += q->size;
@@ -223,139 +218,130 @@ void i915_mem_release( drm_device_t *dev,
 
 /* Shutdown.
  */
-void i915_mem_takedown( struct mem_block **heap )
+void i915_mem_takedown(struct mem_block **heap)
 {
 	struct mem_block *p;
-	
+
 	if (!*heap)
 		return;
 
-	for (p = (*heap)->next ; p != *heap ; ) {
+	for (p = (*heap)->next; p != *heap;) {
 		struct mem_block *q = p;
 		p = p->next;
 		DRM_FREE(q, sizeof(*q));
 	}
 
-	DRM_FREE( *heap, sizeof(**heap) );
+	DRM_FREE(*heap, sizeof(**heap));
 	*heap = NULL;
 }
 
-
-
-static struct mem_block **get_heap( drm_i915_private_t *dev_priv,
-				   int region )
+static struct mem_block **get_heap(drm_i915_private_t * dev_priv, int region)
 {
-	switch( region ) {
+	switch (region) {
 	case I915_MEM_REGION_AGP:
- 		return &dev_priv->agp_heap; 
+		return &dev_priv->agp_heap;
 	default:
 		return NULL;
 	}
 }
 
-
 /* IOCTL HANDLERS */
 
-int i915_mem_alloc( DRM_IOCTL_ARGS )
+int i915_mem_alloc(DRM_IOCTL_ARGS)
 {
 	DRM_DEVICE;
 	drm_i915_private_t *dev_priv = dev->dev_private;
 	drm_i915_mem_alloc_t alloc;
 	struct mem_block *block, **heap;
 
-	if ( !dev_priv ) {
-		DRM_ERROR( "%s called with no initialization\n", __FUNCTION__ );
+	if (!dev_priv) {
+		DRM_ERROR("%s called with no initialization\n", __FUNCTION__);
 		return DRM_ERR(EINVAL);
 	}
 
-	DRM_COPY_FROM_USER_IOCTL( alloc, (drm_i915_mem_alloc_t __user *)data,
-				  sizeof(alloc) );
+	DRM_COPY_FROM_USER_IOCTL(alloc, (drm_i915_mem_alloc_t __user *) data,
+				 sizeof(alloc));
 
-	heap = get_heap( dev_priv, alloc.region );
+	heap = get_heap(dev_priv, alloc.region);
 	if (!heap || !*heap)
 		return DRM_ERR(EFAULT);
-	
+
 	/* Make things easier on ourselves: all allocations at least
 	 * 4k aligned.
 	 */
 	if (alloc.alignment < 12)
 		alloc.alignment = 12;
 
-	block = alloc_block( *heap, alloc.size, alloc.alignment,
-			     filp );
+	block = alloc_block(*heap, alloc.size, alloc.alignment, filp);
 
-	if (!block) 
+	if (!block)
 		return DRM_ERR(ENOMEM);
 
-	mark_block( dev, block, 1 );
+	mark_block(dev, block, 1);
 
-	if ( DRM_COPY_TO_USER( alloc.region_offset, &block->start, 
-			       sizeof(int) ) ) {
-		DRM_ERROR( "copy_to_user\n" );
+	if (DRM_COPY_TO_USER(alloc.region_offset, &block->start, sizeof(int))) {
+		DRM_ERROR("copy_to_user\n");
 		return DRM_ERR(EFAULT);
 	}
-	
+
 	return 0;
 }
 
-
-
-int i915_mem_free( DRM_IOCTL_ARGS )
+int i915_mem_free(DRM_IOCTL_ARGS)
 {
 	DRM_DEVICE;
 	drm_i915_private_t *dev_priv = dev->dev_private;
 	drm_i915_mem_free_t memfree;
 	struct mem_block *block, **heap;
 
-	if ( !dev_priv ) {
-		DRM_ERROR( "%s called with no initialization\n", __FUNCTION__ );
+	if (!dev_priv) {
+		DRM_ERROR("%s called with no initialization\n", __FUNCTION__);
 		return DRM_ERR(EINVAL);
 	}
 
-	DRM_COPY_FROM_USER_IOCTL( memfree, (drm_i915_mem_free_t __user *)data,
-				  sizeof(memfree) );
+	DRM_COPY_FROM_USER_IOCTL(memfree, (drm_i915_mem_free_t __user *) data,
+				 sizeof(memfree));
 
-	heap = get_heap( dev_priv, memfree.region );
+	heap = get_heap(dev_priv, memfree.region);
 	if (!heap || !*heap)
 		return DRM_ERR(EFAULT);
-	
-	block = find_block( *heap, memfree.region_offset );
+
+	block = find_block(*heap, memfree.region_offset);
 	if (!block)
 		return DRM_ERR(EFAULT);
 
 	if (block->filp != filp)
 		return DRM_ERR(EPERM);
 
-	mark_block( dev, block, 0 );
-	free_block( block );	
+	mark_block(dev, block, 0);
+	free_block(block);
 	return 0;
 }
 
-int i915_mem_init_heap( DRM_IOCTL_ARGS )
+int i915_mem_init_heap(DRM_IOCTL_ARGS)
 {
 	DRM_DEVICE;
 	drm_i915_private_t *dev_priv = dev->dev_private;
 	drm_i915_mem_init_heap_t initheap;
 	struct mem_block **heap;
 
-	if ( !dev_priv ) {
-		DRM_ERROR( "%s called with no initialization\n", __FUNCTION__ );
+	if (!dev_priv) {
+		DRM_ERROR("%s called with no initialization\n", __FUNCTION__);
 		return DRM_ERR(EINVAL);
 	}
 
-	DRM_COPY_FROM_USER_IOCTL( initheap, (drm_i915_mem_init_heap_t __user *)data,
-				  sizeof(initheap) );
+	DRM_COPY_FROM_USER_IOCTL(initheap,
+				 (drm_i915_mem_init_heap_t __user *) data,
+				 sizeof(initheap));
 
-	heap = get_heap( dev_priv, initheap.region );
-	if (!heap) 
+	heap = get_heap(dev_priv, initheap.region);
+	if (!heap)
 		return DRM_ERR(EFAULT);
-	
+
 	if (*heap) {
 		DRM_ERROR("heap already initialized?");
 		return DRM_ERR(EFAULT);
 	}
-		
-	return init_heap( heap, initheap.start, initheap.size );
-}
-
 
+	return init_heap(heap, initheap.start, initheap.size);
+}