Initial import of VIA's CLE266 driver plus Alan Cox changes to bring the 3Dcle266-0-0-1-branch

    driver to version 4.3.0.

9 files changed, 1458 insertions, 0 deletions

diff --git a/linux/via.h b/linux/via.h
new file mode 100644
index 00000000..55908f04
--- /dev/null
+++ b/linux/via.h
@@ -0,0 +1,46 @@
+/*

+ * Copyright 1998-2003 VIA Technologies, Inc. All Rights Reserved.

+ * Copyright 2001-2003 S3 Graphics, Inc. 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, 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. IN NO EVENT SHALL

+ * VIA, S3 GRAPHICS, 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.

+ */

+#ifndef __VIA_H__

+#define __VIA_H__

+

+

+#define DRM(x) viadrv_##x

+

+

+#define __HAVE_AGP		1

+#define __MUST_HAVE_AGP		0

+#define __HAVE_MTRR		1

+#define __HAVE_CTX_BITMAP	1

+

+

+#define DRIVER_AGP_BUFFERS_MAP( dev )					\

+	((drm_via_private_t *)((dev)->dev_private))->buffers

+

+extern int via_init_context(int context);

+extern int via_final_context(int context);

+

+#define DRIVER_CTX_CTOR via_init_context

+#define DRIVER_CTX_DTOR via_final_context

+

+#endif

diff --git a/linux/via_drm.h b/linux/via_drm.h
new file mode 100644
index 00000000..38eb4647
--- /dev/null
+++ b/linux/via_drm.h
@@ -0,0 +1,155 @@
+/*

+ * Copyright 1998-2003 VIA Technologies, Inc. All Rights Reserved.

+ * Copyright 2001-2003 S3 Graphics, Inc. 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, 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. IN NO EVENT SHALL

+ * VIA, S3 GRAPHICS, 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.

+ */

+#ifndef _VIA_DRM_H_

+#define _VIA_DRM_H_

+

+/* WARNING: These defines must be the same as what the Xserver uses.

+ * if you change them, you must change the defines in the Xserver.

+ */

+

+#ifndef _VIA_DEFINES_

+#define _VIA_DEFINES_

+

+#define VIA_DMA_BUF_ORDER		12

+#define VIA_DMA_BUF_SZ 		        (1 << VIA_DMA_BUF_ORDER)

+#define VIA_DMA_BUF_NR 			256

+#define VIA_NR_SAREA_CLIPRECTS 		8

+

+/* Each region is a minimum of 64k, and there are at most 64 of them.

+ */

+#define VIA_NR_TEX_REGIONS 64

+#define VIA_LOG_MIN_TEX_REGION_SIZE 16

+#endif

+

+#define VIA_UPLOAD_TEX0IMAGE  0x1 /* handled clientside */

+#define VIA_UPLOAD_TEX1IMAGE  0x2 /* handled clientside */

+#define VIA_UPLOAD_CTX        0x4

+#define VIA_UPLOAD_BUFFERS    0x8

+#define VIA_UPLOAD_TEX0       0x10

+#define VIA_UPLOAD_TEX1       0x20

+#define VIA_UPLOAD_CLIPRECTS  0x40

+#define VIA_UPLOAD_ALL        0xff

+

+/* VIA specific ioctls */

+#define DRM_IOCTL_VIA_ALLOCMEM	DRM_IOWR(0x40, drm_via_mem_t)

+#define DRM_IOCTL_VIA_FREEMEM	DRM_IOW(0x41, drm_via_mem_t)

+#define DRM_IOCTL_VIA_AGP_INIT	DRM_IOWR(0x42, drm_via_agp_t)

+#define DRM_IOCTL_VIA_FB_INIT	DRM_IOWR(0x43, drm_via_fb_t)

+#define DRM_IOCTL_VIA_MAP_INIT	DRM_IOWR(0x44, drm_via_init_t)

+

+/* Indices into buf.Setup where various bits of state are mirrored per

+ * context and per buffer.  These can be fired at the card as a unit,

+ * or in a piecewise fashion as required.

+ */

+ 

+#define VIA_TEX_SETUP_SIZE 8

+

+/* Flags for clear ioctl

+ */

+#define VIA_FRONT   0x1

+#define VIA_BACK    0x2

+#define VIA_DEPTH   0x4

+#define VIA_STENCIL 0x8

+#define VIDEO 0

+#define AGP 1

+typedef struct {

+    unsigned int offset;

+    unsigned int size;

+} drm_via_agp_t;    

+

+typedef struct {

+    unsigned int offset;

+    unsigned int size;

+} drm_via_fb_t;    

+

+typedef struct {

+    unsigned int context;

+    unsigned int type;

+    unsigned int size;

+    unsigned long index;

+    unsigned long offset;

+} drm_via_mem_t;    

+

+typedef struct _drm_via_init {

+    enum {

+	VIA_INIT_MAP = 0x01,

+	VIA_CLEANUP_MAP = 0x02

+    } func;

+

+    unsigned long sarea_priv_offset;

+    unsigned long fb_offset;

+    unsigned long mmio_offset;

+    unsigned long agpAddr;

+} drm_via_init_t;

+

+/* Warning: If you change the SAREA structure you must change the Xserver

+ * structure as well */

+

+typedef struct _drm_via_tex_region {

+    unsigned char next, prev;	/* indices to form a circular LRU  */

+    unsigned char inUse;	/* owned by a client, or free? */

+    int age;			/* tracked by clients to update local LRU's */

+} drm_via_tex_region_t;

+

+typedef struct _drm_via_sarea {

+    unsigned int dirty;

+    unsigned int nbox;

+    drm_clip_rect_t boxes[VIA_NR_SAREA_CLIPRECTS];   

+    drm_via_tex_region_t texList[VIA_NR_TEX_REGIONS + 1]; 

+    int texAge;			/* last time texture was uploaded */

+    int ctxOwner;		/* last context to upload state */

+    int vertexPrim;

+} drm_via_sarea_t;

+

+typedef struct _drm_via_flush_agp {

+    unsigned int offset;

+    unsigned int size;

+    unsigned int index;		

+    int discard;	/* client is finished with the buffer? */

+} drm_via_flush_agp_t;

+

+typedef struct _drm_via_flush_sys {

+    unsigned int offset;

+    unsigned int size;

+    unsigned long index;		

+    int discard;	/* client is finished with the buffer? */

+} drm_via_flush_sys_t;

+

+#ifdef __KERNEL__

+int via_fb_init(struct inode *inode, struct file *filp, unsigned int cmd,

+		unsigned long arg);		

+int via_mem_alloc(struct inode *inode, struct file *filp, unsigned int cmd,

+  		unsigned long arg);				

+int via_mem_free(struct inode *inode, struct file *filp, unsigned int cmd,

+		unsigned long arg);		

+int via_agp_init(struct inode *inode, struct file *filp, unsigned int cmd,

+		unsigned long arg);				

+int via_dma_alloc(struct inode *inode, struct file *filp, unsigned int cmd,

+		unsigned long arg);				

+int via_dma_free(struct inode *inode, struct file *filp, unsigned int cmd,

+		unsigned long arg);				

+int via_map_init(struct inode *inode, struct file *filp, unsigned int cmd,

+		unsigned long arg);				

+#endif

+#endif /* _VIA_DRM_H_ */

diff --git a/linux/via_drv.c b/linux/via_drv.c
new file mode 100644
index 00000000..6bd1bd79
--- /dev/null
+++ b/linux/via_drv.c
@@ -0,0 +1,66 @@
+/*

+ * Copyright 1998-2003 VIA Technologies, Inc. All Rights Reserved.

+ * Copyright 2001-2003 S3 Graphics, Inc. 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, 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. IN NO EVENT SHALL

+ * VIA, S3 GRAPHICS, 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 <linux/config.h>

+#include "via.h"

+#include "drmP.h"

+#include "via_drm.h"

+#include "via_drv.h"

+

+#define DRIVER_AUTHOR	"VIA"

+

+#define DRIVER_NAME		"via"

+#define DRIVER_DESC		"VIA CLE 266"

+#define DRIVER_DATE		"20020814"

+

+#define DRIVER_MAJOR		1

+#define DRIVER_MINOR		1

+#define DRIVER_PATCHLEVEL	0

+

+

+#define DRIVER_IOCTLS \

+        [DRM_IOCTL_NR(DRM_IOCTL_VIA_ALLOCMEM)]  = { via_mem_alloc,  1, 0 }, \

+        [DRM_IOCTL_NR(DRM_IOCTL_VIA_FREEMEM)]   = { via_mem_free,	  1, 0 }, \

+        [DRM_IOCTL_NR(DRM_IOCTL_VIA_AGP_INIT)]   = { via_agp_init,	  1, 0 }, \

+	[DRM_IOCTL_NR(DRM_IOCTL_VIA_FB_INIT)]   = { via_fb_init,	  1, 0 }, \

+        [DRM_IOCTL_NR(DRM_IOCTL_VIA_MAP_INIT)]   = { via_map_init,	  1, 0 }

+

+

+#define __HAVE_COUNTERS		0

+

+#include "drm_auth.h"

+#include "drm_agpsupport.h"

+#include "drm_bufs.h"

+#include "drm_context.h"

+#include "drm_dma.h"

+#include "drm_drawable.h"

+#include "drm_drv.h"

+#include "drm_fops.h"

+#include "drm_init.h"

+#include "drm_ioctl.h"

+#include "drm_lists.h"

+#include "drm_lock.h"

+#include "drm_memory.h"

+#include "drm_proc.h"

+#include "drm_vm.h"

+#include "drm_stub.h"

diff --git a/linux/via_drv.h b/linux/via_drv.h
new file mode 100644
index 00000000..1b731437
--- /dev/null
+++ b/linux/via_drv.h
@@ -0,0 +1,149 @@
+/*

+ * Copyright 1998-2003 VIA Technologies, Inc. All Rights Reserved.

+ * Copyright 2001-2003 S3 Graphics, Inc. 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, 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. IN NO EVENT SHALL

+ * VIA, S3 GRAPHICS, 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.

+ */

+#ifndef _VIA_DRV_H_

+#define _VIA_DRV_H_

+

+typedef struct drm_via_private {

+    drm_via_sarea_t *sarea_priv;

+    drm_map_t *sarea;

+    drm_map_t *fb;

+    drm_map_t *mmio;

+    unsigned long agpAddr;

+} drm_via_private_t;

+

+extern int via_do_init_map(drm_device_t *dev, drm_via_init_t *init);

+extern int via_do_cleanup_map(drm_device_t *dev);

+extern int via_map_init(struct inode *inode, struct file *filp,

+		   unsigned int cmd, unsigned long arg);

+

+/*=* [DBG] For RedHat7.3 insert kernel module has unresolved symbol

+   cmpxchg() *=*/

+

+/* Include this here so that driver can be used with older kernels. */

+#ifndef __HAVE_ARCH_CMPXCHG 

+

+#ifdef CONFIG_SMP

+#define LOCK_PREFIX "lock ; "

+#else

+#define LOCK_PREFIX ""

+#endif		

+

+#if defined(__alpha__)

+static __inline__ unsigned long

+__cmpxchg_u32(volatile int *m, int old, int new)

+{

+	unsigned long prev, cmp;

+

+	__asm__ __volatile__(

+	"1:	ldl_l %0,%2\n"

+	"	cmpeq %0,%3,%1\n"

+	"	beq %1,2f\n"

+	"	mov %4,%1\n"

+	"	stl_c %1,%2\n"

+	"	beq %1,3f\n"

+	"2:	mb\n"

+	".subsection 2\n"

+	"3:	br 1b\n"

+	".previous"

+	: "=&r"(prev), "=&r"(cmp), "=m"(*m)

+	: "r"((long) old), "r"(new), "m"(*m));

+

+	return prev;

+}

+

+static __inline__ unsigned long

+__cmpxchg_u64(volatile long *m, unsigned long old, unsigned long new)

+{

+	unsigned long prev, cmp;

+

+	__asm__ __volatile__(

+	"1:	ldq_l %0,%2\n"

+	"	cmpeq %0,%3,%1\n"

+	"	beq %1,2f\n"

+	"	mov %4,%1\n"

+	"	stq_c %1,%2\n"

+	"	beq %1,3f\n"

+	"2:	mb\n"

+	".subsection 2\n"

+	"3:	br 1b\n"

+	".previous"

+	: "=&r"(prev), "=&r"(cmp), "=m"(*m)

+	: "r"((long) old), "r"(new), "m"(*m));

+

+	return prev;

+}

+

+static __inline__ unsigned long

+__cmpxchg(volatile void *ptr, unsigned long old, unsigned long new, int size)

+{

+	switch (size) {

+		case 4:

+			return __cmpxchg_u32(ptr, old, new);

+		case 8:

+			return __cmpxchg_u64(ptr, old, new);

+	}

+	return old;

+}

+#define cmpxchg(ptr,o,n)						 \

+  ({									 \

+     __typeof__(*(ptr)) _o_ = (o);					 \

+     __typeof__(*(ptr)) _n_ = (n);					 \

+     (__typeof__(*(ptr))) __cmpxchg((ptr), (unsigned long)_o_,		 \

+				    (unsigned long)_n_, sizeof(*(ptr))); \

+  })

+

+#elif __i386__

+static inline unsigned long __cmpxchg(volatile void *ptr, unsigned long old,

+				      unsigned long new, int size)

+{

+	unsigned long prev;

+	switch (size) {

+	case 1:

+		__asm__ __volatile__(LOCK_PREFIX "cmpxchgb %b1,%2"

+				     : "=a"(prev)

+				     : "q"(new), "m"(*__xg(ptr)), "0"(old)

+				     : "memory");

+		return prev;

+	case 2:

+		__asm__ __volatile__(LOCK_PREFIX "cmpxchgw %w1,%2"

+				     : "=a"(prev)

+				     : "q"(new), "m"(*__xg(ptr)), "0"(old)

+				     : "memory");

+		return prev;

+	case 4:

+		__asm__ __volatile__(LOCK_PREFIX "cmpxchgl %1,%2"

+				     : "=a"(prev)

+				     : "q"(new), "m"(*__xg(ptr)), "0"(old)

+				     : "memory");

+		return prev;

+	}

+	return old;

+}

+

+#define cmpxchg(ptr,o,n)						\

+  ((__typeof__(*(ptr)))__cmpxchg((ptr),(unsigned long)(o),		\

+				 (unsigned long)(n),sizeof(*(ptr))))

+#endif /* i386 & alpha */

+#endif

+#endif

diff --git a/linux/via_ds.c b/linux/via_ds.c
new file mode 100644
index 00000000..b4541648
--- /dev/null
+++ b/linux/via_ds.c
@@ -0,0 +1,399 @@
+/*

+ * Copyright 1998-2003 VIA Technologies, Inc. All Rights Reserved.

+ * Copyright 2001-2003 S3 Graphics, Inc. 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, 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. IN NO EVENT SHALL

+ * VIA, S3 GRAPHICS, 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.

+ */

+#define __NO_VERSION__

+#include <linux/module.h>

+#include <linux/delay.h>

+#include <linux/errno.h>

+#include <linux/kernel.h>

+#include <linux/slab.h>

+#include <linux/poll.h>

+#include <asm/io.h>

+#include <linux/pci.h>

+

+#include "via_ds.h"

+extern unsigned int VIA_DEBUG;

+

+set_t *setInit(void)

+{

+    int i;

+    set_t *set;

+    set = (set_t *)MALLOC(sizeof(set_t));

+    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 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 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;

+}

+

+/* setFirst -> setAdd -> setNext is wrong */

+

+int setFirst(set_t *set, ITEM_TYPE *item)

+{

+    if (set->alloc == -1)

+	return 0;

+

+    *item = set->list[set->alloc].val;

+    set->trace = set->list[set->alloc].alloc_next; 

+

+	

+    return 1;

+}

+

+int 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;      

+

+    return 1;

+}

+

+int setDestroy(set_t *set)

+{

+    FREE(set);

+

+    return 1;

+}

+

+#define ISFREE(bptr) ((bptr)->free)

+

+#define PRINTF(fmt, arg...) do{}while(0)

+#define fprintf(fmt, arg...) do{}while(0)

+

+static void *calloc(size_t nmemb, size_t size)

+{

+    void *addr;

+    addr = kmalloc(nmemb*size, GFP_KERNEL);

+    memset(addr, 0, nmemb*size);

+    return addr;

+}

+#define free(n) kfree(n)

+           

+void 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");

+}

+

+memHeap_t *mmInit(int ofs,

+		  int size)

+{

+    PMemBlock blocks;

+  

+    if (size <= 0)

+	return 0;

+

+      

+    blocks = (TMemBlock *)calloc(1,sizeof(TMemBlock));

+   

+    if (blocks) {

+         blocks->ofs = ofs;

+        blocks->size = size;

+        blocks->free = 1;

+        return (memHeap_t *)blocks;

+    } else

+	 return 0;

+}

+

+memHeap_t *mmAddRange(memHeap_t *heap,

+		       int ofs,

+		       int size)

+{

+    PMemBlock blocks;

+    blocks = (TMemBlock *) calloc(2,sizeof(TMemBlock));

+    

+    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, 

+			     int reserved, int alignment)

+{

+    TMemBlock *newblock;

+

+    /* break left */

+    if (startofs > p->ofs) {

+	newblock = (TMemBlock*)calloc(1,sizeof(TMemBlock));

+	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*) calloc(1,sizeof(TMemBlock));

+	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 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;

+}

+

+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;

+	free(q);

+	

+	return 1;

+    }

+    

+    return 0;

+}

+

+int 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;

+}

+

+int 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 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;

+}

+

+void mmDestroy(memHeap_t *heap)

+{

+    TMemBlock *p,*q;

+

+    if (!heap)

+	return;

+    p = (TMemBlock *)heap;

+    

+    while (p) {

+	q = p->next;

+	free(p);

+	p = q;

+    }

+}

diff --git a/linux/via_ds.h b/linux/via_ds.h
new file mode 100644
index 00000000..ab4e19b7
--- /dev/null
+++ b/linux/via_ds.h
@@ -0,0 +1,133 @@
+/*

+ * Copyright 1998-2003 VIA Technologies, Inc. All Rights Reserved.

+ * Copyright 2001-2003 S3 Graphics, Inc. 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, 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. IN NO EVENT SHALL

+ * VIA, S3 GRAPHICS, 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.

+ */

+#ifndef _via_ds_h_

+#define _via_ds_h_

+

+/* Set Data Structure */

+

+#define SET_SIZE 5000

+#define MALLOC(s) kmalloc(s, GFP_KERNEL)

+#define FREE(s) kfree(s)

+

+typedef unsigned int ITEM_TYPE;

+

+typedef struct {

+    ITEM_TYPE val;

+    int alloc_next, free_next;

+} list_item_t;

+

+typedef struct {

+    int alloc;

+    int free;

+    int trace;

+    list_item_t list[SET_SIZE];

+} set_t;

+

+set_t *setInit(void);

+int setAdd(set_t *set, ITEM_TYPE item);

+int setDel(set_t *set, ITEM_TYPE item);

+int setFirst(set_t *set, ITEM_TYPE *item);

+int setNext(set_t *set, ITEM_TYPE *item);

+int setDestroy(set_t *set);

+

+#endif

+

+

+#ifndef MM_INC

+#define MM_INC

+

+struct mem_block_t {

+    struct mem_block_t *next;

+    struct mem_block_t *heap;

+    int ofs,size;

+    int align;

+    int free:1;

+    int reserved:1;

+};

+typedef struct mem_block_t TMemBlock;

+typedef struct mem_block_t *PMemBlock;

+

+/* a heap is just the first block in a chain */

+typedef struct mem_block_t memHeap_t;

+

+static __inline__ int mmBlockSize(PMemBlock b)

+{ return b->size; }

+

+static __inline__ int mmOffset(PMemBlock b)

+{ return b->ofs; }

+

+static __inline__ void mmMarkReserved(PMemBlock b)

+{ b->reserved = 1; }

+

+/* 

+ * input: total size in bytes

+ * return: a heap pointer if OK, NULL if error

+ */

+memHeap_t *mmInit(int ofs, int size);

+

+

+

+memHeap_t *mmAddRange(memHeap_t *heap,

+		       int ofs,

+		       int size);

+

+

+/*

+ * Allocate 'size' bytes with 2^align2 bytes alignment,

+ * restrict the search to free memory after 'startSearch'

+ * depth and back buffers should be in different 4mb banks

+ * to get better page hits if possible

+ * input:	size = size of block

+ *       	align2 = 2^align2 bytes alignment

+ *		startSearch = linear offset from start of heap to begin search

+ * return: pointer to the allocated block, 0 if error

+ */

+PMemBlock  mmAllocMem(memHeap_t *heap, int size, int align2, int startSearch);

+

+/*

+ * Free block starts at offset

+ * input: pointer to a block

+ * return: 0 if OK, -1 if error

+ */

+int  mmFreeMem(PMemBlock b);

+

+/*

+ * Reserve 'size' bytes block start at offset

+ * This is used to prevent allocation of memory already used

+ * by the X server for the front buffer, pixmaps, and cursor

+ * input: size, offset

+ * output: 0 if OK, -1 if error

+ */

+int mmReserveMem(memHeap_t *heap, int offset,int size);

+int mmFreeReserved(memHeap_t *heap, int offset);

+

+/*

+ * destroy MM

+ */

+void mmDestroy(memHeap_t *mmInit);

+

+/* For debuging purpose. */

+void mmDumpMemInfo(memHeap_t *mmInit);

+

+#endif

diff --git a/linux/via_map.c b/linux/via_map.c
new file mode 100644
index 00000000..9e42a0b1
--- /dev/null
+++ b/linux/via_map.c
@@ -0,0 +1,119 @@
+/*

+ * Copyright 1998-2003 VIA Technologies, Inc. All Rights Reserved.

+ * Copyright 2001-2003 S3 Graphics, Inc. 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, 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. IN NO EVENT SHALL

+ * VIA, S3 GRAPHICS, 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.

+ */

+#define __NO_VERSION__

+#include "via.h"

+#include "drmP.h"

+#include "via_drv.h"

+

+int via_do_init_map(drm_device_t *dev, drm_via_init_t *init)

+{

+	drm_via_private_t *dev_priv;

+	struct list_head *list;

+

+	DRM_DEBUG("%s\n", __FUNCTION__);

+

+	dev_priv = DRM(alloc)(sizeof(drm_via_private_t), DRM_MEM_DRIVER);

+	if (dev_priv == NULL)

+		return -ENOMEM;

+

+	memset(dev_priv, 0, sizeof(drm_via_private_t));

+	

+	list_for_each(list, &dev->maplist->head) {

+		drm_map_list_t *r_list = (drm_map_list_t *)list;

+		if ( r_list->map &&

+		    r_list->map->type == _DRM_SHM &&

+		    r_list->map->flags & _DRM_CONTAINS_LOCK) {

+			dev_priv->sarea = r_list->map;

+ 			break;

+ 		}

+ 	}

+	if (!dev_priv->sarea) {

+		DRM_ERROR("could not find sarea!\n");

+		dev->dev_private = (void *)dev_priv;

+		via_do_cleanup_map(dev);

+		return -EINVAL;

+	}

+

+	DRM_FIND_MAP(dev_priv->fb, init->fb_offset);

+	if (!dev_priv->fb) {

+		DRM_ERROR("could not find framebuffer!\n");

+		dev->dev_private = (void *)dev_priv;

+		via_do_cleanup_map(dev);

+		return -EINVAL;

+	}

+	DRM_FIND_MAP(dev_priv->mmio, init->mmio_offset);

+	if (!dev_priv->mmio) {

+		DRM_ERROR("could not find mmio region!\n");

+		dev->dev_private = (void *)dev_priv;

+		via_do_cleanup_map(dev);

+		return -EINVAL;

+	}

+	

+	dev_priv->sarea_priv =

+		(drm_via_sarea_t *)((u8 *)dev_priv->sarea->handle +

+				     init->sarea_priv_offset);

+

+	dev_priv->agpAddr = init->agpAddr;

+

+	dev->dev_private = (void *)dev_priv;

+

+	return 0;

+}

+

+int via_do_cleanup_map(drm_device_t *dev)

+{

+	if (dev->dev_private) {

+

+		drm_via_private_t *dev_priv = dev->dev_private;

+

+		DRM(free)(dev_priv, sizeof(drm_via_private_t),

+			   DRM_MEM_DRIVER);

+		dev->dev_private = NULL;

+	}

+

+	return 0;

+}

+

+int via_map_init(struct inode *inode, struct file *filp,

+		   unsigned int cmd, unsigned long arg)

+{

+	drm_file_t *priv = filp->private_data;

+	drm_device_t *dev = priv->dev;

+	drm_via_init_t init;

+

+	DRM_DEBUG("%s\n", __FUNCTION__);

+

+	if (copy_from_user(&init, (drm_via_init_t *)arg, sizeof(init)))

+		return -EFAULT;

+

+	switch (init.func) {

+	    case VIA_INIT_MAP:

+		return via_do_init_map(dev, &init);

+	    case VIA_CLEANUP_MAP:

+		return via_do_cleanup_map(dev);

+	}

+

+	return -EINVAL;

+}

+

diff --git a/linux/via_mm.c b/linux/via_mm.c
new file mode 100644
index 00000000..9bf7624d
--- /dev/null
+++ b/linux/via_mm.c
@@ -0,0 +1,346 @@
+/*

+ * Copyright 1998-2003 VIA Technologies, Inc. All Rights Reserved.

+ * Copyright 2001-2003 S3 Graphics, Inc. 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, 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. IN NO EVENT SHALL

+ * VIA, S3 GRAPHICS, 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.

+ */

+#define __NO_VERSION__

+#include "via.h"

+#include "drmP.h"

+#include "via_drm.h"

+#include "via_drv.h"

+#include "via_ds.h"

+#include "via_mm.h"

+

+#define MAX_CONTEXT 100

+

+unsigned int VIA_DEBUG = 1;

+

+typedef struct {

+  int used;

+  int context;

+  set_t *sets[2]; /* 0 for frame buffer, 1 for AGP , 2 for System*/

+} via_context_t;

+

+static via_context_t global_ppriv[MAX_CONTEXT];

+

+static int add_alloc_set(int context, int type, unsigned int val)

+{

+  int i, retval = 0;

+  

+  for (i = 0; i < MAX_CONTEXT; i++)

+ {

+    if (global_ppriv[i].used && global_ppriv[i].context == context) {

+	retval = setAdd(global_ppriv[i].sets[type], val);

+        break;

+    }

+  }

+  

+  return retval;

+}

+

+static int del_alloc_set(int context, int type, unsigned int val)

+{  

+  int i, retval = 0;

+  

+  for (i = 0; i < MAX_CONTEXT; i++)

+    if (global_ppriv[i].used && global_ppriv[i].context == context) {

+	retval = setDel(global_ppriv[i].sets[type], val);

+        break;

+    }

+  

+  return retval;

+}

+

+/* agp memory management */ 

+static memHeap_t *AgpHeap = NULL;

+

+int via_agp_init(struct inode *inode, struct file *filp, unsigned int cmd,

+		  unsigned long arg)

+{

+  drm_via_agp_t agp;

+  

+  if (copy_from_user(&agp, (drm_via_agp_t *)arg, sizeof(agp)))

+	  return -EFAULT;

+

+  AgpHeap = mmInit(agp.offset, agp.size);

+

+  DRM_DEBUG("offset = %u, size = %u", agp.offset, agp.size);

+  

+  return 0;

+}

+

+/* fb memory management */ 

+static memHeap_t *FBHeap = NULL;

+

+int via_fb_init(struct inode *inode, struct file *filp, unsigned int cmd,

+		  unsigned long arg)

+{

+  drm_via_fb_t fb;

+

+   

+  if  (copy_from_user(&fb, (drm_via_fb_t *)arg, sizeof(fb)))

+	  return -EFAULT;

+

+  FBHeap = mmInit(fb.offset, fb.size);

+

+  DRM_DEBUG("offset = %u, size = %u", fb.offset, fb.size);

+

+  return 0;

+}

+

+int via_init_context(int context)

+{

+    int i;

+    

+    for (i = 0; i < MAX_CONTEXT ; i++)

+	if (global_ppriv[i].used && (global_ppriv[i].context == context))

+	    break;

+    

+    if (i >= MAX_CONTEXT) {

+    	for (i = 0; i < MAX_CONTEXT ; i++) {

+	    if (!global_ppriv[i].used) {

+		global_ppriv[i].context = context;

+	    	global_ppriv[i].used = 1;

+	    	global_ppriv[i].sets[0] = setInit();

+	    	global_ppriv[i].sets[1] = setInit();

+	    	DRM_DEBUG("init allocation set, socket=%d, context = %d\n", 

+	                 i, context);

+		break;

+	    }

+	}

+	

+	if ((i >= MAX_CONTEXT) || (global_ppriv[i].sets[0] == NULL) ||

+	     (global_ppriv[i].sets[1] == NULL)) {

+	     return 0;

+	}

+    }

+    

+    return 1;

+}

+

+int via_final_context(int context)

+{

+    int i;

+    for (i=0; i<MAX_CONTEXT; i++)

+	if (global_ppriv[i].used && (global_ppriv[i].context == context))

+	    break;

+    

+    if (i < MAX_CONTEXT) {

+	set_t *set;

+	unsigned int item;

+	int retval;

+	  

+  	DRM_DEBUG("find socket %d, context = %d\n", i, context);

+	    

+	/* Video Memory */

+	set = global_ppriv[i].sets[0];

+	retval = setFirst(set, &item);

+	while (retval) {

+	    DRM_DEBUG("free video memory 0x%x\n", item);

+	    mmFreeMem((PMemBlock)item);

+	    retval = setNext(set, &item);

+	}

+	setDestroy(set);

+	    

+	/* AGP Memory */

+	set = global_ppriv[i].sets[1];

+	retval = setFirst(set, &item);

+	while (retval) {

+   	    DRM_DEBUG("free agp memory 0x%x\n", item);

+	    mmFreeMem((PMemBlock)item);

+	    retval = setNext(set, &item);

+	}

+	setDestroy(set);

+	

+	global_ppriv[i].used = 0;	  

+    }

+    

+    return 1;

+}

+int via_mem_alloc(struct inode *inode, struct file *filp, unsigned int cmd,

+		  unsigned long arg)

+{

+    drm_via_mem_t mem;

+    

+    if (copy_from_user(&mem, (drm_via_mem_t *)arg, sizeof(mem)))

+	return -EFAULT;

+

+    switch (mem.type) {

+	case VIDEO :

+	    if (via_fb_alloc(&mem) < 0)

+		return -EFAULT;

+	    if (copy_to_user((drm_via_mem_t *)arg, &mem, sizeof(mem))) 

+		return -EFAULT;

+	    return 0;

+	case AGP :

+	    if (via_agp_alloc(&mem) < 0)

+		return -EFAULT;

+	    if (copy_to_user((drm_via_mem_t *)arg, &mem, sizeof(mem))) 

+		return -EFAULT;

+	    return 0;

+    }

+

+    return -EFAULT;

+}

+int via_fb_alloc(drm_via_mem_t* mem)

+{

+    drm_via_mm_t fb;

+    PMemBlock block;

+    int retval = 0;

+   

+    if (!FBHeap)

+	return -1;

+

+    fb.size = mem->size;

+    fb.context = mem->context;

+  

+    block = mmAllocMem(FBHeap, fb.size, 5, 0);

+    if (block) {

+	fb.offset = block->ofs;

+	fb.free = (unsigned int)block;

+	if (!add_alloc_set(fb.context, VIDEO, fb.free)) {

+    	    DRM_DEBUG("adding to allocation set fails\n");

+    	    mmFreeMem((PMemBlock)fb.free);

+    	    retval = -1;

+	}

+    }

+    else {  

+	fb.offset = 0;

+	fb.size = 0;

+	fb.free = 0;

+    }

+   

+    mem->offset = fb.offset;

+    mem->index = fb.free;

+

+    DRM_DEBUG("alloc fb, size = %d, offset = %d\n", fb.size, (int)fb.offset);

+  

+    return retval;

+}

+int via_agp_alloc(drm_via_mem_t* mem)

+{

+    drm_via_mm_t agp;

+    PMemBlock block;

+    int retval = 0;

+

+    if (!AgpHeap)

+	return -1;

+

+    agp.size = mem->size;

+    agp.context = mem->context;

+  

+    block = mmAllocMem(AgpHeap, agp.size, 5, 0);

+    if (block) {

+	agp.offset = block->ofs;

+	agp.free = (unsigned int)block;

+	if (!add_alloc_set(agp.context, AGP, agp.free)) {

+    	    DRM_DEBUG("adding to allocation set fails\n");

+    	    mmFreeMem((PMemBlock)agp.free);

+    	     retval = -1;

+	}

+    }

+    else {  

+	agp.offset = 0;

+	agp.size = 0;

+	agp.free = 0;

+    }	

+   

+    mem->offset = agp.offset;

+    mem->index = agp.free;

+

+    DRM_DEBUG("alloc agp, size = %d, offset = %d\n", agp.size, (unsigned int)agp.offset);

+    return retval;

+}

+int via_mem_free(struct inode *inode, struct file *filp, unsigned int cmd,

+		  unsigned long arg)

+{

+    drm_via_mem_t mem;

+    

+    if (copy_from_user(&mem, (drm_via_mem_t *)arg, sizeof(mem)))

+	return -EFAULT;

+	

+    switch (mem.type) {

+

+	case VIDEO :

+	    if (via_fb_free(&mem) == 0)

+		return 0;

+	    break;

+	case AGP :

+	    if (via_agp_free(&mem) == 0)

+		return 0;

+	    break;

+    }

+    

+    return -EFAULT;

+}

+int via_fb_free(drm_via_mem_t* mem)

+{

+    drm_via_mm_t fb;

+    int retval = 0;

+

+    

+    if (!FBHeap) {

+	return -1;

+    }

+

+    fb.free = mem->index;

+    fb.context = mem->context;

+    

+    if (!fb.free)

+ {

+	return -1;

+

+    }

+

+    mmFreeMem((PMemBlock)fb.free);

+    

+    if (!del_alloc_set(fb.context, VIDEO, fb.free))

+ {

+	retval = -1;

+    }

+    

+    DRM_DEBUG("free fb, free = %d\n", fb.free);

+    

+    return retval;

+} 

+int via_agp_free(drm_via_mem_t* mem)

+{

+    drm_via_mm_t agp;

+  

+    int retval = 0;

+

+    agp.free = mem->index;

+    agp.context = mem->context;

+    

+    if (!agp.free)

+	return -1;

+

+    mmFreeMem((PMemBlock)agp.free);

+    

+    if (!del_alloc_set(agp.context, AGP, agp.free))

+ {

+	retval = -1;

+    }

+

+    DRM_DEBUG("free agp, free = %d\n", agp.free);

+  

+    return retval;

+}

diff --git a/linux/via_mm.h b/linux/via_mm.h
new file mode 100644
index 00000000..faa4bf7e
--- /dev/null
+++ b/linux/via_mm.h
@@ -0,0 +1,45 @@
+/*

+ * Copyright 1998-2003 VIA Technologies, Inc. All Rights Reserved.

+ * Copyright 2001-2003 S3 Graphics, Inc. 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, 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. IN NO EVENT SHALL

+ * VIA, S3 GRAPHICS, 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.

+ */

+#ifndef _via_drm_mm_h_

+#define _via_drm_mm_h_

+

+typedef struct {

+    unsigned int context;

+    unsigned int size;

+    unsigned long offset;

+    unsigned int free;

+} drm_via_mm_t;

+

+typedef struct {

+    unsigned int size;

+    unsigned long handle;

+    void *virtual;

+} drm_via_dma_t;

+

+int via_fb_alloc(drm_via_mem_t *mem);

+int via_fb_free(drm_via_mem_t *mem);

+int via_agp_alloc(drm_via_mem_t *mem);

+int via_agp_free(drm_via_mem_t *mem);

+

+#endif