Lindent of core build. Drivers checked for no binary diffs. A few files

    weren't Lindent's because their comments didn't convert very well. A
    bunch of other minor clean up with no code implact included.

1 files changed, 292 insertions, 294 deletions

diff --git a/shared-core/via_ds.c b/shared-core/via_ds.c
index 71af0c9b..94478b6c 100644
--- a/shared-core/via_ds.c
+++ b/shared-core/via_ds.c
@@ -28,101 +28,100 @@
 #include <linux/kernel.h>
 #include <linux/slab.h>
 #include <linux/poll.h>
-#include <asm/io.h>
 #include <linux/pci.h>
+#include <asm/io.h>
 
 #include "via_ds.h"
 extern unsigned int VIA_DEBUG;
 
 set_t *via_setInit(void)
 {
-        int i;
-        set_t *set;
-        set = (set_t *)drm_alloc(sizeof(set_t), DRM_MEM_DRIVER);
-        for (i = 0; i < SET_SIZE; i++) {
-                set->list[i].free_next = i+1;    
-                set->list[i].alloc_next = -1;
-        }    
-        set->list[SET_SIZE-1].free_next = -1;
-        set->free = 0;
-        set->alloc = -1;
-        set->trace = -1;
-        return set;
+	int i;
+	set_t *set;
+	set = (set_t *) drm_alloc(sizeof(set_t), DRM_MEM_DRIVER);
+	for (i = 0; i < SET_SIZE; i++) {
+		set->list[i].free_next = i + 1;
+		set->list[i].alloc_next = -1;
+	}
+	set->list[SET_SIZE - 1].free_next = -1;
+	set->free = 0;
+	set->alloc = -1;
+	set->trace = -1;
+	return set;
 }
 
-int via_setAdd(set_t *set, ITEM_TYPE item)
+int via_setAdd(set_t * set, ITEM_TYPE item)
 {
-        int free = set->free;
-        if (free != -1) {
-                set->list[free].val = item;
-                set->free = set->list[free].free_next;
-        }
-        else {
-                return 0;
-        }
-        set->list[free].alloc_next = set->alloc;
-        set->alloc = free;  
-        set->list[free].free_next = -1;  
-        return 1;
+	int free = set->free;
+	if (free != -1) {
+		set->list[free].val = item;
+		set->free = set->list[free].free_next;
+	} else {
+		return 0;
+	}
+	set->list[free].alloc_next = set->alloc;
+	set->alloc = free;
+	set->list[free].free_next = -1;
+	return 1;
 }
 
-int via_setDel(set_t *set, ITEM_TYPE item)
+int via_setDel(set_t * set, ITEM_TYPE item)
 {
-        int alloc = set->alloc;
-        int prev = -1;  
-  
-        while (alloc != -1) {
-                if (set->list[alloc].val == item) {
-                        if (prev != -1)      
-                                set->list[prev].alloc_next = set->list[alloc].alloc_next; 
-                        else
-                                set->alloc = set->list[alloc].alloc_next;
-                        break;
-                }
-                prev = alloc;
-                alloc = set->list[alloc].alloc_next;      
-        }
-
-        if (alloc == -1)
-                return 0;
-  
-        set->list[alloc].free_next = set->free;
-        set->free = alloc;
-        set->list[alloc].alloc_next = -1;   
-
-        return 1;
+	int alloc = set->alloc;
+	int prev = -1;
+
+	while (alloc != -1) {
+		if (set->list[alloc].val == item) {
+			if (prev != -1)
+				set->list[prev].alloc_next =
+				    set->list[alloc].alloc_next;
+			else
+				set->alloc = set->list[alloc].alloc_next;
+			break;
+		}
+		prev = alloc;
+		alloc = set->list[alloc].alloc_next;
+	}
+
+	if (alloc == -1)
+		return 0;
+
+	set->list[alloc].free_next = set->free;
+	set->free = alloc;
+	set->list[alloc].alloc_next = -1;
+
+	return 1;
 }
 
 /* setFirst -> setAdd -> setNext is wrong */
 
-int via_setFirst(set_t *set, ITEM_TYPE *item)
+int via_setFirst(set_t * set, ITEM_TYPE * item)
 {
-        if (set->alloc == -1)
-                return 0;
+	if (set->alloc == -1)
+		return 0;
 
-        *item = set->list[set->alloc].val;
-        set->trace = set->list[set->alloc].alloc_next; 
+	*item = set->list[set->alloc].val;
+	set->trace = set->list[set->alloc].alloc_next;
 
-	
-        return 1;
+	return 1;
 }
 
-int via_setNext(set_t *set, ITEM_TYPE *item)
+int via_setNext(set_t * set, ITEM_TYPE * item)
 {
-        if (set->trace == -1)
-                return 0;
-  
-        *item = set->list[set->trace].val;
-        set->trace = set->list[set->trace].alloc_next;      
+	if (set->trace == -1)
+		return 0;
+
+	*item = set->list[set->trace].val;
+	set->trace = set->list[set->trace].alloc_next;
 
-        return 1;
+	return 1;
 }
 
-int via_setDestroy(set_t *set)
+int via_setDestroy(set_t * set)
 {
-        drm_free(set, sizeof(set_t), DRM_MEM_DRIVER);
+	drm_free(set, sizeof(set_t), DRM_MEM_DRIVER);
 
-        return 1;
+	return 1;
 }
 
 #define ISFREE(bptr) ((bptr)->free)
@@ -130,261 +129,260 @@ int via_setDestroy(set_t *set)
 #define PRINTF(fmt, arg...) do{}while(0)
 #define fprintf(fmt, arg...) do{}while(0)
 
-void via_mmDumpMemInfo( memHeap_t *heap )
+void via_mmDumpMemInfo(memHeap_t * heap)
 {
-        TMemBlock *p;
-
-        PRINTF ("Memory heap %p:\n", heap);
-    
-        if (heap == 0)
-                PRINTF ("  heap == 0\n");
-        else {
-                p = (TMemBlock *)heap;
-	
-                while (p) {
-                        PRINTF ("  Offset:%08x, Size:%08x, %c%c\n",p->ofs,p->size,
-                                p->free ? '.':'U',
-                                p->reserved ? 'R':'.');
-                        p = p->next;
-                }
-        }
-    
-        PRINTF ("End of memory blocks\n");
+	TMemBlock *p;
+
+	PRINTF("Memory heap %p:\n", heap);
+
+	if (heap == 0)
+		PRINTF("  heap == 0\n");
+	else {
+		p = (TMemBlock *) heap;
+
+		while (p) {
+			PRINTF("  Offset:%08x, Size:%08x, %c%c\n", p->ofs,
+			       p->size, p->free ? '.' : 'U',
+			       p->reserved ? 'R' : '.');
+			p = p->next;
+		}
+	}
+
+	PRINTF("End of memory blocks\n");
 }
 
-memHeap_t *via_mmInit(int ofs,
-		      int size)
+memHeap_t *via_mmInit(int ofs, int size)
 {
-        PMemBlock blocks;
-  
-        if (size <= 0)
-                return 0;
-
-      
-        blocks = (TMemBlock *)drm_calloc(1,sizeof(TMemBlock),DRM_MEM_DRIVER);
-   
-        if (blocks) {
-                blocks->ofs = ofs;
-                blocks->size = size;
-                blocks->free = 1;
-                return (memHeap_t *)blocks;
-        } else
-                return 0;
+	PMemBlock blocks;
+
+	if (size <= 0)
+		return 0;
+
+	blocks = (TMemBlock *) drm_calloc(1, sizeof(TMemBlock), DRM_MEM_DRIVER);
+
+	if (blocks) {
+		blocks->ofs = ofs;
+		blocks->size = size;
+		blocks->free = 1;
+		return (memHeap_t *) blocks;
+	} else
+		return 0;
 }
 
-memHeap_t *via_mmAddRange(memHeap_t *heap,
-			  int ofs,
-			  int size)
+memHeap_t *via_mmAddRange(memHeap_t * heap, int ofs, int size)
 {
-        PMemBlock blocks;
-        blocks = (TMemBlock *)drm_calloc(2,sizeof(TMemBlock),DRM_MEM_DRIVER);
-    
-        if (blocks) {
-                blocks[0].size = size;
-                blocks[0].free = 1;
-                blocks[0].ofs = ofs;
-                blocks[0].next = &blocks[1];
-
-                /* Discontinuity - stops JoinBlock from trying to join non-adjacent
-                 * ranges.
-                 */
-                blocks[1].size = 0;
-                blocks[1].free = 0;
-                blocks[1].ofs = ofs+size;
-                blocks[1].next = (PMemBlock) heap;      
-                return (memHeap_t *)blocks;
-        } 
-        else
-                return heap;
+	PMemBlock blocks;
+	blocks = (TMemBlock *) drm_calloc(2, sizeof(TMemBlock), DRM_MEM_DRIVER);
+
+	if (blocks) {
+		blocks[0].size = size;
+		blocks[0].free = 1;
+		blocks[0].ofs = ofs;
+		blocks[0].next = &blocks[1];
+
+		/* Discontinuity - stops JoinBlock from trying to join non-adjacent
+		 * ranges.
+		 */
+		blocks[1].size = 0;
+		blocks[1].free = 0;
+		blocks[1].ofs = ofs + size;
+		blocks[1].next = (PMemBlock) heap;
+		return (memHeap_t *) blocks;
+	} else
+		return heap;
 }
 
-static TMemBlock* SliceBlock(TMemBlock *p, 
-			     int startofs, int size, 
+static TMemBlock *SliceBlock(TMemBlock * p,
+			     int startofs, int size,
 			     int reserved, int alignment)
 {
-        TMemBlock *newblock;
-
-        /* break left */
-        if (startofs > p->ofs) {
-                newblock = (TMemBlock*)drm_calloc(1,sizeof(TMemBlock),DRM_MEM_DRIVER);
-                newblock->ofs = startofs;
-                newblock->size = p->size - (startofs - p->ofs);
-                newblock->free = 1;
-                newblock->next = p->next;
-                p->size -= newblock->size;
-                p->next = newblock;
-                p = newblock;
-        }
-
-        /* break right */
-        if (size < p->size) {
-                newblock = (TMemBlock*)drm_calloc(1,sizeof(TMemBlock),DRM_MEM_DRIVER);
-                newblock->ofs = startofs + size;
-                newblock->size = p->size - size;
-                newblock->free = 1;
-                newblock->next = p->next;
-                p->size = size;
-                p->next = newblock;
-        }
-
-        /* p = middle block */
-        p->align = alignment;
-        p->free = 0;
-        p->reserved = reserved;
-        return p;
+	TMemBlock *newblock;
+
+	/* break left */
+	if (startofs > p->ofs) {
+		newblock =
+		    (TMemBlock *) drm_calloc(1, sizeof(TMemBlock),
+					     DRM_MEM_DRIVER);
+		newblock->ofs = startofs;
+		newblock->size = p->size - (startofs - p->ofs);
+		newblock->free = 1;
+		newblock->next = p->next;
+		p->size -= newblock->size;
+		p->next = newblock;
+		p = newblock;
+	}
+
+	/* break right */
+	if (size < p->size) {
+		newblock =
+		    (TMemBlock *) drm_calloc(1, sizeof(TMemBlock),
+					     DRM_MEM_DRIVER);
+		newblock->ofs = startofs + size;
+		newblock->size = p->size - size;
+		newblock->free = 1;
+		newblock->next = p->next;
+		p->size = size;
+		p->next = newblock;
+	}
+
+	/* p = middle block */
+	p->align = alignment;
+	p->free = 0;
+	p->reserved = reserved;
+	return p;
 }
 
-PMemBlock via_mmAllocMem(memHeap_t *heap, int size, int align2, int startSearch)
+PMemBlock via_mmAllocMem(memHeap_t * heap, int size, int align2,
+			 int startSearch)
 {
-        int mask,startofs,endofs;
-        TMemBlock *p;
-
-        if (!heap || align2 < 0 || size <= 0)
-                return NULL;
-    
-        mask = (1 << align2)-1;
-        startofs = 0;
-        p = (TMemBlock *)heap;
-    
-        while (p) {
-                if (ISFREE(p)) {
-                        startofs = (p->ofs + mask) & ~mask;
-    	
-                        if ( startofs < startSearch )
-                                startofs = startSearch;
-        
-                        endofs = startofs+size;
-        
-                        if (endofs <= (p->ofs+p->size))
-                                break;
-                }
-	
-                p = p->next;
-        }
-    
-        if (!p)
-                return NULL;
-    
-        p = SliceBlock(p,startofs,size,0,mask+1);
-        p->heap = heap;
-    
-        return p;
+	int mask, startofs, endofs;
+	TMemBlock *p;
+
+	if (!heap || align2 < 0 || size <= 0)
+		return NULL;
+
+	mask = (1 << align2) - 1;
+	startofs = 0;
+	p = (TMemBlock *) heap;
+
+	while (p) {
+		if (ISFREE(p)) {
+			startofs = (p->ofs + mask) & ~mask;
+
+			if (startofs < startSearch)
+				startofs = startSearch;
+
+			endofs = startofs + size;
+
+			if (endofs <= (p->ofs + p->size))
+				break;
+		}
+
+		p = p->next;
+	}
+
+	if (!p)
+		return NULL;
+
+	p = SliceBlock(p, startofs, size, 0, mask + 1);
+	p->heap = heap;
+
+	return p;
 }
 
-static __inline__ int Join2Blocks(TMemBlock *p)
+static __inline__ int Join2Blocks(TMemBlock * p)
 {
-        if (p->free && p->next && p->next->free) {
-                TMemBlock *q = p->next;
-                p->size += q->size;
-                p->next = q->next;
-                drm_free(q,sizeof(TMemBlock),DRM_MEM_DRIVER);
-	
-                return 1;
-        }
-    
-        return 0;
+	if (p->free && p->next && p->next->free) {
+		TMemBlock *q = p->next;
+		p->size += q->size;
+		p->next = q->next;
+		drm_free(q, sizeof(TMemBlock), DRM_MEM_DRIVER);
+
+		return 1;
+	}
+
+	return 0;
 }
 
 int via_mmFreeMem(PMemBlock b)
 {
-        TMemBlock *p,*prev;
-
-        if (!b)
-                return 0;
-    
-        if (!b->heap) {
-                fprintf(stderr, "no heap\n");
-        
-                return -1;
-        }
-    
-        p = b->heap;
-        prev = NULL;
-    
-        while (p && p != b) {
-                prev = p;
-                p = p->next;
-        }
-    
-        if (!p || p->free || p->reserved) {
-                if (!p)
-                        fprintf(stderr, "block not found in heap\n");
-                else if (p->free)
-                        fprintf(stderr, "block already free\n");
-                else
-                        fprintf(stderr, "block is reserved\n");
-	
-	
-                return -1;
-        }
-    
-        p->free = 1;
-        Join2Blocks(p);
-    
-        if (prev)
-                Join2Blocks(prev);
-  
-        return 0;
+	TMemBlock *p, *prev;
+
+	if (!b)
+		return 0;
+
+	if (!b->heap) {
+		fprintf(stderr, "no heap\n");
+
+		return -1;
+	}
+
+	p = b->heap;
+	prev = NULL;
+
+	while (p && p != b) {
+		prev = p;
+		p = p->next;
+	}
+
+	if (!p || p->free || p->reserved) {
+		if (!p)
+			fprintf(stderr, "block not found in heap\n");
+		else if (p->free)
+			fprintf(stderr, "block already free\n");
+		else
+			fprintf(stderr, "block is reserved\n");
+
+		return -1;
+	}
+
+	p->free = 1;
+	Join2Blocks(p);
+
+	if (prev)
+		Join2Blocks(prev);
+
+	return 0;
 }
 
-int via_mmReserveMem(memHeap_t *heap, int offset,int size)
+int via_mmReserveMem(memHeap_t * heap, int offset, int size)
 {
-        int endofs;
-        TMemBlock *p;
-
-        if (!heap || size <= 0)
-                return -1;
-        endofs = offset+size;
-        p = (TMemBlock *)heap;
-    
-        while (p && p->ofs <= offset) {
-                if (ISFREE(p) && endofs <= (p->ofs+p->size)) {
-                        SliceBlock(p,offset,size,1,1);
-                        return 0;
-                }
-                p = p->next;
-        }
-        return -1;
+	int endofs;
+	TMemBlock *p;
+
+	if (!heap || size <= 0)
+		return -1;
+	endofs = offset + size;
+	p = (TMemBlock *) heap;
+
+	while (p && p->ofs <= offset) {
+		if (ISFREE(p) && endofs <= (p->ofs + p->size)) {
+			SliceBlock(p, offset, size, 1, 1);
+			return 0;
+		}
+		p = p->next;
+	}
+	return -1;
 }
 
-int via_mmFreeReserved(memHeap_t *heap, int offset)
+int via_mmFreeReserved(memHeap_t * heap, int offset)
 {
-        TMemBlock *p,*prev;
-
-        if (!heap)
-                return -1;
-  
-        p = (TMemBlock *)heap;
-        prev = NULL;
-    
-        while (p && p->ofs != offset) {
-                prev = p;
-                p = p->next;
-        }
-    
-        if (!p || !p->reserved)
-                return -1;
-        p->free = 1;
-        p->reserved = 0;
-        Join2Blocks(p);
-    
-        if (prev)
-                Join2Blocks(prev);
-    
-        return 0;
+	TMemBlock *p, *prev;
+
+	if (!heap)
+		return -1;
+
+	p = (TMemBlock *) heap;
+	prev = NULL;
+
+	while (p && p->ofs != offset) {
+		prev = p;
+		p = p->next;
+	}
+
+	if (!p || !p->reserved)
+		return -1;
+	p->free = 1;
+	p->reserved = 0;
+	Join2Blocks(p);
+
+	if (prev)
+		Join2Blocks(prev);
+
+	return 0;
 }
 
-void via_mmDestroy(memHeap_t *heap)
+void via_mmDestroy(memHeap_t * heap)
 {
-        TMemBlock *p,*q;
-
-        if (!heap)
-                return;
-        p = (TMemBlock *)heap;
-    
-        while (p) {
-                q = p->next;
-                drm_free(p,sizeof(TMemBlock),DRM_MEM_DRIVER);
-                p = q;
-        }
+	TMemBlock *p, *q;
+
+	if (!heap)
+		return;
+	p = (TMemBlock *) heap;
+
+	while (p) {
+		q = p->next;
+		drm_free(p, sizeof(TMemBlock), DRM_MEM_DRIVER);
+		p = q;
+	}
 }