First pass merge of XFree86 4.2.0 import.X_4_2_0-20020128-merge

37 files changed, 3757 insertions, 10045 deletions

diff --git a/bsd/Imakefile b/bsd/Imakefile
index 0e11ec50..d18f1873 100644
--- a/bsd/Imakefile
+++ b/bsd/Imakefile
@@ -1,28 +1,4 @@
-XCOMM $XFree86: xc/programs/Xserver/hw/xfree86/os-support/bsd/drm/kernel/Imakefile,v 1.6 2001/04/18 14:52:43 dawes Exp $
-
-#include <Server.tmpl>
-
-#if 0
-LinkSourceFile(xf86drm.c,..)
-LinkSourceFile(xf86drmHash.c,..)
-LinkSourceFile(xf86drmRandom.c,..)
-LinkSourceFile(xf86drmSL.c,..)
-LinkSourceFile(xf86drm.h,$(XF86OSSRC))
-LinkSourceFile(xf86_OSproc.h,$(XF86OSSRC))
-LinkSourceFile(sigio.c,$(XF86OSSRC)/shared)
-#endif
-
-XCOMM Try to use the Linux version of the DRM headers.  This avoids skew
-XCOMM and missing headers.  If there's a need to break them out, they
-XCOMM can be re-added later.  If not, they can be moved to somewhere more
-XCOMM OS-independent and referenced from there.
-LinkSourceFile(drm.h,$(XF86OSSRC)/linux/drm/kernel)
-LinkSourceFile(i810_drm.h,$(XF86OSSRC)/linux/drm/kernel)
-LinkSourceFile(mga_drm.h,$(XF86OSSRC)/linux/drm/kernel)
-LinkSourceFile(r128_drm.h,$(XF86OSSRC)/linux/drm/kernel)
-LinkSourceFile(radeon_drm.h,$(XF86OSSRC)/linux/drm/kernel)
-LinkSourceFile(sis_drm.h,$(XF86OSSRC)/linux/drm/kernel)
-
+XCOMM $XFree86: xc/programs/Xserver/hw/xfree86/os-support/bsd/drm/kernel/Imakefile,v 1.8 2001/12/13 00:24:45 alanh Exp $
 
 XCOMM This is a kludge until we determine how best to build the
 XCOMM kernel-specific device driver.  This allows us to continue
@@ -37,7 +13,7 @@ install::
 	$(MAKE) -f Makefile.bsd install
 #else
 all::
-	@echo 'Use "make -f Makefile.bsd" to manually build drm.o'
+	@echo 'Use "make -f Makefile.bsd" to manually build the modules'
 #endif
 
 clean::
diff --git a/bsd/Makefile b/bsd/Makefile
index 61cba175..9c87d963 100644
--- a/bsd/Makefile
+++ b/bsd/Makefile
@@ -1,5 +1,6 @@
 # $FreeBSD$
 
-SUBDIR = drm tdfx mga gamma
+# i810, i830 & sis are not complete
+SUBDIR = tdfx mga r128 radeon gamma # i810 sis i830
 
 .include <bsd.subdir.mk>
diff --git a/bsd/Makefile.bsd b/bsd/Makefile.bsd
index 61cba175..9c87d963 100644
--- a/bsd/Makefile.bsd
+++ b/bsd/Makefile.bsd
@@ -1,5 +1,6 @@
 # $FreeBSD$
 
-SUBDIR = drm tdfx mga gamma
+# i810, i830 & sis are not complete
+SUBDIR = tdfx mga r128 radeon gamma # i810 sis i830
 
 .include <bsd.subdir.mk>
diff --git a/bsd/drm.h b/bsd/drm.h
new file mode 100644
index 00000000..68876940
--- /dev/null
+++ b/bsd/drm.h
@@ -0,0 +1,501 @@
+/* drm.h -- Header for Direct Rendering Manager -*- linux-c -*-
+ * Created: Mon Jan  4 10:05:05 1999 by faith@precisioninsight.com
+ *
+ * Copyright 1999 Precision Insight, Inc., Cedar Park, Texas.
+ * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
+ * All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Authors:
+ *    Rickard E. (Rik) Faith <faith@valinux.com>
+ *
+ * Acknowledgements:
+ * Dec 1999, Richard Henderson <rth@twiddle.net>, move to generic cmpxchg.
+ *
+ */
+
+#ifndef _DRM_H_
+#define _DRM_H_
+
+#include <sys/ioccom.h>
+#define DRM_IOCTL_NR(n)	     ((n) & 0xff)
+
+#define XFREE86_VERSION(major,minor,patch,snap) \
+		((major << 16) | (minor << 8) | patch)
+
+#ifndef CONFIG_XFREE86_VERSION
+#define CONFIG_XFREE86_VERSION XFREE86_VERSION(4,1,0,0)
+#endif
+
+#if CONFIG_XFREE86_VERSION < XFREE86_VERSION(4,1,0,0)
+#define DRM_PROC_DEVICES "/proc/devices"
+#define DRM_PROC_MISC	 "/proc/misc"
+#define DRM_PROC_DRM	 "/proc/drm"
+#define DRM_DEV_DRM	 "/dev/drm"
+#define DRM_DEV_MODE	 (S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP)
+#define DRM_DEV_UID	 0
+#define DRM_DEV_GID	 0
+#endif
+
+#if CONFIG_XFREE86_VERSION >= XFREE86_VERSION(4,1,0,0)
+#define DRM_MAJOR       226
+#define DRM_MAX_MINOR   15
+#endif
+#define DRM_NAME	"drm"	  /* Name in kernel, /dev, and /proc	    */
+#define DRM_MIN_ORDER	5	  /* At least 2^5 bytes = 32 bytes	    */
+#define DRM_MAX_ORDER	22	  /* Up to 2^22 bytes = 4MB		    */
+#define DRM_RAM_PERCENT 50	  /* How much system ram can we lock?	    */
+
+#define _DRM_LOCK_HELD	0x80000000 /* Hardware lock is held		    */
+#define _DRM_LOCK_CONT	0x40000000 /* Hardware lock is contended	    */
+#define _DRM_LOCK_IS_HELD(lock)	   ((lock) & _DRM_LOCK_HELD)
+#define _DRM_LOCK_IS_CONT(lock)	   ((lock) & _DRM_LOCK_CONT)
+#define _DRM_LOCKING_CONTEXT(lock) ((lock) & ~(_DRM_LOCK_HELD|_DRM_LOCK_CONT))
+
+typedef unsigned long drm_handle_t;
+typedef unsigned int  drm_context_t;
+typedef unsigned int  drm_drawable_t;
+typedef unsigned int  drm_magic_t;
+
+/* Warning: If you change this structure, make sure you change
+ * XF86DRIClipRectRec in the server as well */
+
+typedef struct drm_clip_rect {
+	unsigned short	x1;
+	unsigned short	y1;
+	unsigned short	x2;
+	unsigned short	y2;
+} drm_clip_rect_t;
+
+typedef struct drm_tex_region {
+	unsigned char	next;
+	unsigned char	prev;
+	unsigned char	in_use;
+	unsigned char	padding;
+	unsigned int	age;
+} drm_tex_region_t;
+
+/* Seperate include files for the driver specific structures */
+#include "mga_drm.h"
+#include "i810_drm.h"
+#include "i830_drm.h"
+#include "r128_drm.h"
+#include "radeon_drm.h"
+#include "sis_drm.h"
+
+typedef struct drm_version {
+	int    version_major;	  /* Major version			    */
+	int    version_minor;	  /* Minor version			    */
+	int    version_patchlevel;/* Patch level			    */
+	size_t name_len;	  /* Length of name buffer		    */
+	char   *name;		  /* Name of driver			    */
+	size_t date_len;	  /* Length of date buffer		    */
+	char   *date;		  /* User-space buffer to hold date	    */
+	size_t desc_len;	  /* Length of desc buffer		    */
+	char   *desc;		  /* User-space buffer to hold desc	    */
+} drm_version_t;
+
+typedef struct drm_unique {
+	size_t unique_len;	  /* Length of unique			    */
+	char   *unique;		  /* Unique name for driver instantiation   */
+} drm_unique_t;
+
+typedef struct drm_list {
+	int		 count;	  /* Length of user-space structures	    */
+	drm_version_t	 *version;
+} drm_list_t;
+
+typedef struct drm_block {
+	int		 unused;
+} drm_block_t;
+
+typedef struct drm_control {
+	enum {
+		DRM_ADD_COMMAND,
+		DRM_RM_COMMAND,
+		DRM_INST_HANDLER,
+		DRM_UNINST_HANDLER
+	}		 func;
+	int		 irq;
+} drm_control_t;
+
+typedef enum drm_map_type {
+	_DRM_FRAME_BUFFER   = 0,  /* WC (no caching), no core dump	    */
+	_DRM_REGISTERS	    = 1,  /* no caching, no core dump		    */
+	_DRM_SHM	    = 2,  /* shared, cached			    */
+	_DRM_AGP            = 3,  /* AGP/GART                               */
+	_DRM_SCATTER_GATHER = 4	  /* Scatter/gather memory for PCI DMA      */
+} drm_map_type_t;
+
+typedef enum drm_map_flags {
+	_DRM_RESTRICTED	     = 0x01, /* Cannot be mapped to user-virtual    */
+	_DRM_READ_ONLY	     = 0x02,
+	_DRM_LOCKED	     = 0x04, /* shared, cached, locked		    */
+	_DRM_KERNEL	     = 0x08, /* kernel requires access		    */
+	_DRM_WRITE_COMBINING = 0x10, /* use write-combining if available    */
+	_DRM_CONTAINS_LOCK   = 0x20, /* SHM page that contains lock	    */
+	_DRM_REMOVABLE	     = 0x40  /* Removable mapping		    */
+} drm_map_flags_t;
+
+typedef struct drm_ctx_priv_map {
+	unsigned int	ctx_id;  /* Context requesting private mapping */
+	void		*handle; /* Handle of map */
+} drm_ctx_priv_map_t;
+
+typedef struct drm_map {
+	unsigned long	offset;	 /* Requested physical address (0 for SAREA)*/
+	unsigned long	size;	 /* Requested physical size (bytes)	    */
+	drm_map_type_t	type;	 /* Type of memory to map		    */
+	drm_map_flags_t flags;	 /* Flags				    */
+	void		*handle; /* User-space: "Handle" to pass to mmap    */
+				 /* Kernel-space: kernel-virtual address    */
+	int		mtrr;	 /* MTRR slot used			    */
+				 /* Private data			    */
+} drm_map_t;
+
+typedef struct drm_client {
+	int		idx;	/* Which client desired?                    */
+	int		auth;	/* Is client authenticated?                 */
+	unsigned long	pid;	/* Process id                               */
+	unsigned long	uid;	/* User id                                  */
+	unsigned long	magic;	/* Magic                                    */
+	unsigned long	iocs;	/* Ioctl count                              */
+} drm_client_t;
+
+typedef enum {
+	_DRM_STAT_LOCK,
+	_DRM_STAT_OPENS,
+	_DRM_STAT_CLOSES,
+	_DRM_STAT_IOCTLS,
+	_DRM_STAT_LOCKS,
+	_DRM_STAT_UNLOCKS,
+	_DRM_STAT_VALUE,	/* Generic value                      */
+	_DRM_STAT_BYTE,		/* Generic byte counter (1024bytes/K) */
+	_DRM_STAT_COUNT,	/* Generic non-byte counter (1000/k)  */
+
+	_DRM_STAT_IRQ,		/* IRQ */
+	_DRM_STAT_PRIMARY,	/* Primary DMA bytes */
+	_DRM_STAT_SECONDARY,	/* Secondary DMA bytes */
+	_DRM_STAT_DMA,		/* DMA */
+	_DRM_STAT_SPECIAL,	/* Special DMA (e.g., priority or polled) */
+	_DRM_STAT_MISSED	/* Missed DMA opportunity */
+
+				/* Add to the *END* of the list */
+} drm_stat_type_t;
+
+typedef struct drm_stats {
+	unsigned long count;
+	struct {
+		unsigned long   value;
+		drm_stat_type_t type;
+	} data[15];
+} drm_stats_t;
+
+typedef enum drm_lock_flags {
+	_DRM_LOCK_READY	     = 0x01, /* Wait until hardware is ready for DMA */
+	_DRM_LOCK_QUIESCENT  = 0x02, /* Wait until hardware quiescent	     */
+	_DRM_LOCK_FLUSH	     = 0x04, /* Flush this context's DMA queue first */
+	_DRM_LOCK_FLUSH_ALL  = 0x08, /* Flush all DMA queues first	     */
+				/* These *HALT* flags aren't supported yet
+				   -- they will be used to support the
+				   full-screen DGA-like mode. */
+	_DRM_HALT_ALL_QUEUES = 0x10, /* Halt all current and future queues   */
+	_DRM_HALT_CUR_QUEUES = 0x20  /* Halt all current queues		     */
+} drm_lock_flags_t;
+
+typedef struct drm_lock {
+	int		 context;
+	drm_lock_flags_t flags;
+} drm_lock_t;
+
+typedef enum drm_dma_flags {	      /* These values *MUST* match xf86drm.h */
+				      /* Flags for DMA buffer dispatch	     */
+	_DRM_DMA_BLOCK	      = 0x01, /* Block until buffer dispatched.
+					 Note, the buffer may not yet have
+					 been processed by the hardware --
+					 getting a hardware lock with the
+					 hardware quiescent will ensure
+					 that the buffer has been
+					 processed.			     */
+	_DRM_DMA_WHILE_LOCKED = 0x02, /* Dispatch while lock held	     */
+	_DRM_DMA_PRIORITY     = 0x04, /* High priority dispatch		     */
+
+				      /* Flags for DMA buffer request	     */
+	_DRM_DMA_WAIT	      = 0x10, /* Wait for free buffers		     */
+	_DRM_DMA_SMALLER_OK   = 0x20, /* Smaller-than-requested buffers ok   */
+	_DRM_DMA_LARGER_OK    = 0x40  /* Larger-than-requested buffers ok    */
+} drm_dma_flags_t;
+
+typedef struct drm_buf_desc {
+	int	      count;	 /* Number of buffers of this size	     */
+	int	      size;	 /* Size in bytes			     */
+	int	      low_mark;	 /* Low water mark			     */
+	int	      high_mark; /* High water mark			     */
+	enum {
+		_DRM_PAGE_ALIGN = 0x01, /* Align on page boundaries for DMA  */
+		_DRM_AGP_BUFFER = 0x02, /* Buffer is in agp space            */
+		_DRM_SG_BUFFER  = 0x04  /* Scatter/gather memory buffer      */
+	}	      flags;
+	unsigned long agp_start; /* Start address of where the agp buffers
+				  * are in the agp aperture */
+} drm_buf_desc_t;
+
+typedef struct drm_buf_info {
+	int	       count;	/* Entries in list			     */
+	drm_buf_desc_t *list;
+} drm_buf_info_t;
+
+typedef struct drm_buf_free {
+	int	       count;
+	int	       *list;
+} drm_buf_free_t;
+
+typedef struct drm_buf_pub {
+	int		  idx;	       /* Index into master buflist	     */
+	int		  total;       /* Buffer size			     */
+	int		  used;	       /* Amount of buffer in use (for DMA)  */
+	void		  *address;    /* Address of buffer		     */
+} drm_buf_pub_t;
+
+typedef struct drm_buf_map {
+	int	      count;	/* Length of buflist			    */
+	void	      *virtual;	/* Mmaped area in user-virtual		    */
+	drm_buf_pub_t *list;	/* Buffer information			    */
+} drm_buf_map_t;
+
+typedef struct drm_dma {
+				/* Indices here refer to the offset into
+				   buflist in drm_buf_get_t.  */
+	int		context;	  /* Context handle		    */
+	int		send_count;	  /* Number of buffers to send	    */
+	int		*send_indices;	  /* List of handles to buffers	    */
+	int		*send_sizes;	  /* Lengths of data to send	    */
+	drm_dma_flags_t flags;		  /* Flags			    */
+	int		request_count;	  /* Number of buffers requested    */
+	int		request_size;	  /* Desired size for buffers	    */
+	int		*request_indices; /* Buffer information		    */
+	int		*request_sizes;
+	int		granted_count;	  /* Number of buffers granted	    */
+} drm_dma_t;
+
+typedef enum {
+	_DRM_CONTEXT_PRESERVED = 0x01,
+	_DRM_CONTEXT_2DONLY    = 0x02
+} drm_ctx_flags_t;
+
+typedef struct drm_ctx {
+	drm_context_t	handle;
+	drm_ctx_flags_t flags;
+} drm_ctx_t;
+
+typedef struct drm_ctx_res {
+	int		count;
+	drm_ctx_t	*contexts;
+} drm_ctx_res_t;
+
+typedef struct drm_draw {
+	drm_drawable_t	handle;
+} drm_draw_t;
+
+typedef struct drm_auth {
+	drm_magic_t	magic;
+} drm_auth_t;
+
+typedef struct drm_irq_busid {
+	int irq;
+	int busnum;
+	int devnum;
+	int funcnum;
+} drm_irq_busid_t;
+
+typedef struct drm_agp_mode {
+	unsigned long mode;
+} drm_agp_mode_t;
+
+				/* For drm_agp_alloc -- allocated a buffer */
+typedef struct drm_agp_buffer {
+	unsigned long size;	/* In bytes -- will round to page boundary */
+	unsigned long handle;	/* Used for BIND/UNBIND ioctls */
+	unsigned long type;     /* Type of memory to allocate  */
+        unsigned long physical; /* Physical used by i810       */
+} drm_agp_buffer_t;
+
+				/* For drm_agp_bind */
+typedef struct drm_agp_binding {
+	unsigned long handle;   /* From drm_agp_buffer */
+	unsigned long offset;	/* In bytes -- will round to page boundary */
+} drm_agp_binding_t;
+
+typedef struct drm_agp_info {
+	int            agp_version_major;
+	int            agp_version_minor;
+	unsigned long  mode;
+	unsigned long  aperture_base;  /* physical address */
+	unsigned long  aperture_size;  /* bytes */
+	unsigned long  memory_allowed; /* bytes */
+	unsigned long  memory_used;
+
+				/* PCI information */
+	unsigned short id_vendor;
+	unsigned short id_device;
+} drm_agp_info_t;
+
+typedef struct drm_scatter_gather {
+	unsigned long size;	/* In bytes -- will round to page boundary */
+	unsigned long handle;	/* Used for mapping / unmapping */
+} drm_scatter_gather_t;
+
+#define DRM_IOCTL_BASE			'd'
+#define DRM_IO(nr)			_IO(DRM_IOCTL_BASE,nr)
+#define DRM_IOR(nr,size)		_IOR(DRM_IOCTL_BASE,nr,size)
+#define DRM_IOW(nr,size)		_IOW(DRM_IOCTL_BASE,nr,size)
+#define DRM_IOWR(nr,size)		_IOWR(DRM_IOCTL_BASE,nr,size)
+
+
+#define DRM_IOCTL_VERSION		DRM_IOWR(0x00, drm_version_t)
+#define DRM_IOCTL_GET_UNIQUE		DRM_IOWR(0x01, drm_unique_t)
+#define DRM_IOCTL_GET_MAGIC		DRM_IOR( 0x02, drm_auth_t)
+#define DRM_IOCTL_IRQ_BUSID		DRM_IOWR(0x03, drm_irq_busid_t)
+#define DRM_IOCTL_GET_MAP               DRM_IOWR(0x04, drm_map_t)
+#define DRM_IOCTL_GET_CLIENT            DRM_IOWR(0x05, drm_client_t)
+#define DRM_IOCTL_GET_STATS             DRM_IOR( 0x06, drm_stats_t)
+
+#define DRM_IOCTL_SET_UNIQUE		DRM_IOW( 0x10, drm_unique_t)
+#define DRM_IOCTL_AUTH_MAGIC		DRM_IOW( 0x11, drm_auth_t)
+#define DRM_IOCTL_BLOCK			DRM_IOWR(0x12, drm_block_t)
+#define DRM_IOCTL_UNBLOCK		DRM_IOWR(0x13, drm_block_t)
+#define DRM_IOCTL_CONTROL		DRM_IOW( 0x14, drm_control_t)
+#define DRM_IOCTL_ADD_MAP		DRM_IOWR(0x15, drm_map_t)
+#define DRM_IOCTL_ADD_BUFS		DRM_IOWR(0x16, drm_buf_desc_t)
+#define DRM_IOCTL_MARK_BUFS		DRM_IOW( 0x17, drm_buf_desc_t)
+#define DRM_IOCTL_INFO_BUFS		DRM_IOWR(0x18, drm_buf_info_t)
+#define DRM_IOCTL_MAP_BUFS		DRM_IOWR(0x19, drm_buf_map_t)
+#define DRM_IOCTL_FREE_BUFS		DRM_IOW( 0x1a, drm_buf_free_t)
+
+#define DRM_IOCTL_RM_MAP		DRM_IOW( 0x1b, drm_map_t)
+
+#define DRM_IOCTL_SET_SAREA_CTX		DRM_IOW( 0x1c, drm_ctx_priv_map_t)
+#define DRM_IOCTL_GET_SAREA_CTX 	DRM_IOWR(0x1d, drm_ctx_priv_map_t)
+
+#define DRM_IOCTL_ADD_CTX		DRM_IOWR(0x20, drm_ctx_t)
+#define DRM_IOCTL_RM_CTX		DRM_IOWR(0x21, drm_ctx_t)
+#define DRM_IOCTL_MOD_CTX		DRM_IOW( 0x22, drm_ctx_t)
+#define DRM_IOCTL_GET_CTX		DRM_IOWR(0x23, drm_ctx_t)
+#define DRM_IOCTL_SWITCH_CTX		DRM_IOW( 0x24, drm_ctx_t)
+#define DRM_IOCTL_NEW_CTX		DRM_IOW( 0x25, drm_ctx_t)
+#define DRM_IOCTL_RES_CTX		DRM_IOWR(0x26, drm_ctx_res_t)
+#define DRM_IOCTL_ADD_DRAW		DRM_IOWR(0x27, drm_draw_t)
+#define DRM_IOCTL_RM_DRAW		DRM_IOWR(0x28, drm_draw_t)
+#define DRM_IOCTL_DMA			DRM_IOWR(0x29, drm_dma_t)
+#define DRM_IOCTL_LOCK			DRM_IOW( 0x2a, drm_lock_t)
+#define DRM_IOCTL_UNLOCK		DRM_IOW( 0x2b, drm_lock_t)
+#define DRM_IOCTL_FINISH		DRM_IOW( 0x2c, drm_lock_t)
+
+#define DRM_IOCTL_AGP_ACQUIRE		DRM_IO(  0x30)
+#define DRM_IOCTL_AGP_RELEASE		DRM_IO(  0x31)
+#define DRM_IOCTL_AGP_ENABLE		DRM_IOW( 0x32, drm_agp_mode_t)
+#define DRM_IOCTL_AGP_INFO		DRM_IOR( 0x33, drm_agp_info_t)
+#define DRM_IOCTL_AGP_ALLOC		DRM_IOWR(0x34, drm_agp_buffer_t)
+#define DRM_IOCTL_AGP_FREE		DRM_IOW( 0x35, drm_agp_buffer_t)
+#define DRM_IOCTL_AGP_BIND		DRM_IOW( 0x36, drm_agp_binding_t)
+#define DRM_IOCTL_AGP_UNBIND		DRM_IOW( 0x37, drm_agp_binding_t)
+
+#define DRM_IOCTL_SG_ALLOC		DRM_IOW( 0x38, drm_scatter_gather_t)
+#define DRM_IOCTL_SG_FREE		DRM_IOW( 0x39, drm_scatter_gather_t)
+
+/* MGA specific ioctls */
+#define DRM_IOCTL_MGA_INIT		DRM_IOW( 0x40, drm_mga_init_t)
+#define DRM_IOCTL_MGA_FLUSH		DRM_IOW( 0x41, drm_lock_t)
+#define DRM_IOCTL_MGA_RESET		DRM_IO(  0x42)
+#define DRM_IOCTL_MGA_SWAP		DRM_IO(  0x43)
+#define DRM_IOCTL_MGA_CLEAR		DRM_IOW( 0x44, drm_mga_clear_t)
+#define DRM_IOCTL_MGA_VERTEX		DRM_IOW( 0x45, drm_mga_vertex_t)
+#define DRM_IOCTL_MGA_INDICES		DRM_IOW( 0x46, drm_mga_indices_t)
+#define DRM_IOCTL_MGA_ILOAD		DRM_IOW( 0x47, drm_mga_iload_t)
+#define DRM_IOCTL_MGA_BLIT		DRM_IOW( 0x48, drm_mga_blit_t)
+
+/* i810 specific ioctls */
+#define DRM_IOCTL_I810_INIT		DRM_IOW( 0x40, drm_i810_init_t)
+#define DRM_IOCTL_I810_VERTEX		DRM_IOW( 0x41, drm_i810_vertex_t)
+#define DRM_IOCTL_I810_CLEAR		DRM_IOW( 0x42, drm_i810_clear_t)
+#define DRM_IOCTL_I810_FLUSH		DRM_IO(  0x43)
+#define DRM_IOCTL_I810_GETAGE		DRM_IO(  0x44)
+#define DRM_IOCTL_I810_GETBUF		DRM_IOWR(0x45, drm_i810_dma_t)
+#define DRM_IOCTL_I810_SWAP		DRM_IO(  0x46)
+#define DRM_IOCTL_I810_COPY		DRM_IOW( 0x47, drm_i810_copy_t)
+#define DRM_IOCTL_I810_DOCOPY		DRM_IO(  0x48)
+
+/* Rage 128 specific ioctls */
+#define DRM_IOCTL_R128_INIT		DRM_IOW( 0x40, drm_r128_init_t)
+#define DRM_IOCTL_R128_CCE_START	DRM_IO(  0x41)
+#define DRM_IOCTL_R128_CCE_STOP		DRM_IOW( 0x42, drm_r128_cce_stop_t)
+#define DRM_IOCTL_R128_CCE_RESET	DRM_IO(  0x43)
+#define DRM_IOCTL_R128_CCE_IDLE		DRM_IO(  0x44)
+#define DRM_IOCTL_R128_RESET		DRM_IO(  0x46)
+#define DRM_IOCTL_R128_SWAP		DRM_IO(  0x47)
+#define DRM_IOCTL_R128_CLEAR		DRM_IOW( 0x48, drm_r128_clear_t)
+#define DRM_IOCTL_R128_VERTEX		DRM_IOW( 0x49, drm_r128_vertex_t)
+#define DRM_IOCTL_R128_INDICES		DRM_IOW( 0x4a, drm_r128_indices_t)
+#define DRM_IOCTL_R128_BLIT		DRM_IOW( 0x4b, drm_r128_blit_t)
+#define DRM_IOCTL_R128_DEPTH		DRM_IOW( 0x4c, drm_r128_depth_t)
+#define DRM_IOCTL_R128_STIPPLE		DRM_IOW( 0x4d, drm_r128_stipple_t)
+#define DRM_IOCTL_R128_INDIRECT		DRM_IOWR(0x4f, drm_r128_indirect_t)
+#define DRM_IOCTL_R128_FULLSCREEN	DRM_IOW( 0x50, drm_r128_fullscreen_t)
+
+/* Radeon specific ioctls */
+#define DRM_IOCTL_RADEON_CP_INIT	DRM_IOW( 0x40, drm_radeon_init_t)
+#define DRM_IOCTL_RADEON_CP_START	DRM_IO(  0x41)
+#define DRM_IOCTL_RADEON_CP_STOP	DRM_IOW( 0x42, drm_radeon_cp_stop_t)
+#define DRM_IOCTL_RADEON_CP_RESET	DRM_IO(  0x43)
+#define DRM_IOCTL_RADEON_CP_IDLE	DRM_IO(  0x44)
+#define DRM_IOCTL_RADEON_RESET		DRM_IO(  0x45)
+#define DRM_IOCTL_RADEON_FULLSCREEN	DRM_IOW( 0x46, drm_radeon_fullscreen_t)
+#define DRM_IOCTL_RADEON_SWAP		DRM_IO(  0x47)
+#define DRM_IOCTL_RADEON_CLEAR		DRM_IOW( 0x48, drm_radeon_clear_t)
+#define DRM_IOCTL_RADEON_VERTEX		DRM_IOW( 0x49, drm_radeon_vertex_t)
+#define DRM_IOCTL_RADEON_INDICES	DRM_IOW( 0x4a, drm_radeon_indices_t)
+#define DRM_IOCTL_RADEON_STIPPLE	DRM_IOW( 0x4c, drm_radeon_stipple_t)
+#define DRM_IOCTL_RADEON_INDIRECT	DRM_IOWR(0x4d, drm_radeon_indirect_t)
+#define DRM_IOCTL_RADEON_TEXTURE	DRM_IOWR(0x4e, drm_radeon_texture_t)
+
+/* SiS specific ioctls */
+
+#define SIS_IOCTL_FB_ALLOC		DRM_IOWR(0x44, drm_sis_mem_t)
+#define SIS_IOCTL_FB_FREE		DRM_IOW( 0x45, drm_sis_mem_t)
+#define SIS_IOCTL_AGP_INIT		DRM_IOWR(0x53, drm_sis_agp_t)
+#define SIS_IOCTL_AGP_ALLOC		DRM_IOWR(0x54, drm_sis_mem_t)
+#define SIS_IOCTL_AGP_FREE		DRM_IOW( 0x55, drm_sis_mem_t)
+#define SIS_IOCTL_FLIP			DRM_IOW( 0x48, drm_sis_flip_t)
+#define SIS_IOCTL_FLIP_INIT		DRM_IO(  0x49)
+#define SIS_IOCTL_FLIP_FINAL		DRM_IO(  0x50)
+
+/* I830 specific ioctls */
+#define DRM_IOCTL_I830_INIT		DRM_IOW( 0x40, drm_i830_init_t)
+#define DRM_IOCTL_I830_VERTEX		DRM_IOW( 0x41, drm_i830_vertex_t)
+#define DRM_IOCTL_I830_CLEAR		DRM_IOW( 0x42, drm_i830_clear_t)
+#define DRM_IOCTL_I830_FLUSH		DRM_IO ( 0x43)
+#define DRM_IOCTL_I830_GETAGE		DRM_IO ( 0x44)
+#define DRM_IOCTL_I830_GETBUF		DRM_IOWR(0x45, drm_i830_dma_t)
+#define DRM_IOCTL_I830_SWAP		DRM_IO ( 0x46)
+#define DRM_IOCTL_I830_COPY		DRM_IOW( 0x47, drm_i830_copy_t)
+#define DRM_IOCTL_I830_DOCOPY		DRM_IO ( 0x48)
+
+#endif
diff --git a/bsd/drm/Makefile b/bsd/drm/Makefile
deleted file mode 100644
index d9c4a371..00000000
--- a/bsd/drm/Makefile
+++ /dev/null
@@ -1,16 +0,0 @@
-# $FreeBSD$
-
-KMOD	= drm
-SRCS	= init.c memory.c auth.c context.c drawable.c bufs.c \
-	  lists.c lock.c ioctl.c fops.c vm.c dma.c sysctl.c  \
-	  agpsupport.c ctxbitmap.c
-SRCS   += device_if.h bus_if.h pci_if.h
-CFLAGS += ${DEBUG_FLAGS} -I..
-
-@:
-	ln -sf /sys @
-
-machine:
-	ln -sf /sys/i386/include machine
-
-.include <bsd.kmod.mk>
diff --git a/bsd/drm/agpsupport.c b/bsd/drm/agpsupport.c
deleted file mode 100644
index f399171e..00000000
--- a/bsd/drm/agpsupport.c
+++ /dev/null
@@ -1,270 +0,0 @@
-/* agpsupport.c -- DRM support for AGP/GART backend
- * Created: Mon Dec 13 09:56:45 1999 by faith@precisioninsight.com
- *
- * Copyright 1999 Precision Insight, Inc., Cedar Park, Texas.
- * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
- * All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice (including the next
- * paragraph) shall be included in all copies or substantial portions of the
- * Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * PRECISION INSIGHT 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.
- * 
- * Author: Rickard E. (Rik) Faith <faith@valinux.com>
- *
- */
-
-#define __NO_VERSION__
-#include "drmP.h"
-
-#ifdef DRM_AGP
-
-#include <pci/agpvar.h>
-
-MODULE_DEPEND(drm, agp, 1, 1, 1);
-
-int
-drm_agp_info(dev_t kdev, u_long cmd, caddr_t data,
-	     int flags, struct proc *p)
-{
-	drm_device_t	*dev	= kdev->si_drv1;
-	struct agp_info *kern;
-	drm_agp_info_t   info;
-
-	if (!dev->agp->acquired) return EINVAL;
-
-	kern                   = &dev->agp->info;
-	agp_get_info(dev->agp->agpdev, kern);
-	info.agp_version_major = 1;
-	info.agp_version_minor = 0;
-	info.mode              = kern->ai_mode;
-	info.aperture_base     = kern->ai_aperture_base;
-	info.aperture_size     = kern->ai_aperture_size;
-	info.memory_allowed    = kern->ai_memory_allowed;
-	info.memory_used       = kern->ai_memory_used;
-	info.id_vendor         = kern->ai_devid & 0xffff;
-	info.id_device         = kern->ai_devid >> 16;
-
-	*(drm_agp_info_t *) data = info;
-	return 0;
-}
-
-int
-drm_agp_acquire(dev_t kdev, u_long cmd, caddr_t data,
-		int flags, struct proc *p)
-{
-	drm_device_t *dev = kdev->si_drv1;
-	int          retcode;
-
-	if (dev->agp->acquired) return EINVAL;
-	retcode = agp_acquire(dev->agp->agpdev);
-	if (retcode) return retcode;
-	dev->agp->acquired = 1;
-	return 0;
-}
-
-int
-drm_agp_release(dev_t kdev, u_long cmd, caddr_t data,
-		int flags, struct proc *p)
-{
-	drm_device_t *dev = kdev->si_drv1;
-
-	if (!dev->agp->acquired) return EINVAL;
-	agp_release(dev->agp->agpdev);
-	dev->agp->acquired = 0;
-	return 0;
-	
-}
-
-int
-drm_agp_enable(dev_t kdev, u_long cmd, caddr_t data,
-	       int flags, struct proc *p)
-{
-	drm_device_t   *dev = kdev->si_drv1;
-	drm_agp_mode_t mode;
-
-	if (!dev->agp->acquired) return EINVAL;
-
-	mode = *(drm_agp_mode_t *) data;
-	
-	dev->agp->mode    = mode.mode;
-	agp_enable(dev->agp->agpdev, mode.mode);
-	dev->agp->base    = dev->agp->info.ai_aperture_base;
-	dev->agp->enabled = 1;
-	return 0;
-}
-
-int drm_agp_alloc(dev_t kdev, u_long cmd, caddr_t data,
-		  int flags, struct proc *p)
-{
-	drm_device_t     *dev = kdev->si_drv1;
-	drm_agp_buffer_t request;
-	drm_agp_mem_t    *entry;
-	void	         *handle;
-	unsigned long    pages;
-	u_int32_t	 type;
-	struct agp_memory_info info;
-
-	if (!dev->agp->acquired) return EINVAL;
-
-	request = *(drm_agp_buffer_t *) data;
-
-	if (!(entry = drm_alloc(sizeof(*entry), DRM_MEM_AGPLISTS)))
-		return ENOMEM;
-   
-   	memset(entry, 0, sizeof(*entry));
-
-	pages = (request.size + PAGE_SIZE - 1) / PAGE_SIZE;
-	type = (u_int32_t) request.type;
-
-	if (!(handle = drm_alloc_agp(pages, type))) {
-		drm_free(entry, sizeof(*entry), DRM_MEM_AGPLISTS);
-		return ENOMEM;
-	}
-	
-	entry->handle    = handle;
-	entry->bound     = 0;
-	entry->pages     = pages;
-	entry->prev      = NULL;
-	entry->next      = dev->agp->memory;
-	if (dev->agp->memory) dev->agp->memory->prev = entry;
-	dev->agp->memory = entry;
-
-	agp_memory_info(dev->agp->agpdev, entry->handle, &info);
-
-	request.handle   = (unsigned long) entry->handle;
-        request.physical = info.ami_physical;
-
-	*(drm_agp_buffer_t *) data = request;
-
-	return 0;
-}
-
-static drm_agp_mem_t *
-drm_agp_lookup_entry(drm_device_t *dev, void *handle)
-{
-	drm_agp_mem_t *entry;
-
-	for (entry = dev->agp->memory; entry; entry = entry->next) {
-		if (entry->handle == handle) return entry;
-	}
-	return NULL;
-}
-
-int
-drm_agp_unbind(dev_t kdev, u_long cmd, caddr_t data,
-	       int flags, struct proc *p)
-{
-	drm_device_t      *dev = kdev->si_drv1;
-	drm_agp_binding_t request;
-	drm_agp_mem_t     *entry;
-
-	if (!dev->agp->acquired) return EINVAL;
-	request = *(drm_agp_binding_t *) data;
-	if (!(entry = drm_agp_lookup_entry(dev, (void *) request.handle)))
-		return EINVAL;
-	if (!entry->bound) return EINVAL;
-	return drm_unbind_agp(entry->handle);
-}
-
-int drm_agp_bind(dev_t kdev, u_long cmd, caddr_t data,
-		 int flags, struct proc *p)
-{
-	drm_device_t      *dev = kdev->si_drv1;
-	drm_agp_binding_t request;
-	drm_agp_mem_t     *entry;
-	int               retcode;
-	int               page;
-	
-	if (!dev->agp->acquired) return EINVAL;
-	request = *(drm_agp_binding_t *) data;
-	if (!(entry = drm_agp_lookup_entry(dev, (void *) request.handle)))
-		return EINVAL;
-	if (entry->bound) return EINVAL;
-	page = (request.offset + PAGE_SIZE - 1) / PAGE_SIZE;
-	if ((retcode = drm_bind_agp(entry->handle, page))) return retcode;
-	entry->bound = dev->agp->base + (page << PAGE_SHIFT);
-	return 0;
-}
-
-int drm_agp_free(dev_t kdev, u_long cmd, caddr_t data,
-		 int flags, struct proc *p)
-{
-	drm_device_t     *dev = kdev->si_drv1;
-	drm_agp_buffer_t request;
-	drm_agp_mem_t    *entry;
-	
-	if (!dev->agp->acquired) return EINVAL;
-	request = *(drm_agp_buffer_t *) data;
-	if (!(entry = drm_agp_lookup_entry(dev, (void*) request.handle)))
-		return EINVAL;
-	if (entry->bound) drm_unbind_agp(entry->handle);
-   
-	if (entry->prev) entry->prev->next = entry->next;
-	else             dev->agp->memory  = entry->next;
-	if (entry->next) entry->next->prev = entry->prev;
-	drm_free_agp(entry->handle, entry->pages);
-	drm_free(entry, sizeof(*entry), DRM_MEM_AGPLISTS);
-	return 0;
-}
-
-drm_agp_head_t *drm_agp_init(void)
-{
-	device_t agpdev;
-	drm_agp_head_t *head   = NULL;
-	int      agp_available = 1;
-   
-	agpdev = agp_find_device();
-	if (!agpdev)
-		agp_available = 0;
-
-	DRM_DEBUG("agp_available = %d\n", agp_available);
-
-	if (agp_available) {
-		if (!(head = drm_alloc(sizeof(*head), DRM_MEM_AGPLISTS)))
-			return NULL;
-		memset((void *)head, 0, sizeof(*head));
-		head->agpdev = agpdev;
-		agp_get_info(agpdev, &head->info);
-		head->memory = NULL;
-#if 0				/* bogus */
-		switch (head->agp_info.chipset) {
-		case INTEL_GENERIC:  head->chipset = "Intel";          break;
-		case INTEL_LX:       head->chipset = "Intel 440LX";    break;
-		case INTEL_BX:       head->chipset = "Intel 440BX";    break;
-		case INTEL_GX:       head->chipset = "Intel 440GX";    break;
-		case INTEL_I810:     head->chipset = "Intel i810";     break;
-		case VIA_GENERIC:    head->chipset = "VIA";            break;
-		case VIA_VP3:        head->chipset = "VIA VP3";        break;
-		case VIA_MVP3:       head->chipset = "VIA MVP3";       break;
-		case VIA_APOLLO_PRO: head->chipset = "VIA Apollo Pro"; break;
-		case SIS_GENERIC:    head->chipset = "SiS";            break;
-		case AMD_GENERIC:    head->chipset = "AMD";            break;
-		case AMD_IRONGATE:   head->chipset = "AMD Irongate";   break;
-		case ALI_GENERIC:    head->chipset = "ALi";            break;
-		case ALI_M1541:      head->chipset = "ALi M1541";      break;
-		default:
-		}
-#endif
-		DRM_INFO("AGP at 0x%08x %dMB\n",
-			 head->info.ai_aperture_base,
-			 head->info.ai_aperture_size >> 20);
-	}
-	return head;
-}
-
-#endif /* DRM_AGP */
diff --git a/bsd/drm/auth.c b/bsd/drm/auth.c
deleted file mode 100644
index 37d17be5..00000000
--- a/bsd/drm/auth.c
+++ /dev/null
@@ -1,168 +0,0 @@
-/* auth.c -- IOCTLs for authentication -*- c -*-
- * Created: Tue Feb  2 08:37:54 1999 by faith@precisioninsight.com
- *
- * Copyright 1999 Precision Insight, Inc., Cedar Park, Texas.
- * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
- * All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice (including the next
- * paragraph) shall be included in all copies or substantial portions of the
- * Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
- * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
- * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- * 
- * Authors:
- *    Rickard E. (Rik) Faith <faith@valinux.com>
- *
- */
-
-#define __NO_VERSION__
-#include "drmP.h"
-
-static int drm_hash_magic(drm_magic_t magic)
-{
-	return magic & (DRM_HASH_SIZE-1);
-}
-
-static drm_file_t *drm_find_file(drm_device_t *dev, drm_magic_t magic)
-{
-	drm_file_t	  *retval = NULL;
-	drm_magic_entry_t *pt;
-	int		  hash	  = drm_hash_magic(magic);
-
-	lockmgr(&dev->dev_lock, LK_EXCLUSIVE, 0, curproc);
-	for (pt = dev->magiclist[hash].head; pt; pt = pt->next) {
-		if (pt->priv->authenticated) continue;
-		if (pt->magic == magic) {
-			retval = pt->priv;
-			break;
-		}
-	}
-	lockmgr(&dev->dev_lock, LK_RELEASE, 0, curproc);
-
-	return retval;
-}
-
-int drm_add_magic(drm_device_t *dev, drm_file_t *priv, drm_magic_t magic)
-{
-	int		  hash;
-	drm_magic_entry_t *entry;
-	
-	DRM_DEBUG("%d\n", magic);
-	
-	hash	     = drm_hash_magic(magic);
-	entry	     = drm_alloc(sizeof(*entry), DRM_MEM_MAGIC);
-	if (!entry) return ENOMEM;
-	entry->magic = magic;
-	entry->priv  = priv;
-	entry->next  = NULL;
-
-	lockmgr(&dev->dev_lock, LK_EXCLUSIVE, 0, curproc);
-	if (dev->magiclist[hash].tail) {
-		dev->magiclist[hash].tail->next = entry;
-		dev->magiclist[hash].tail	= entry;
-	} else {
-		dev->magiclist[hash].head	= entry;
-		dev->magiclist[hash].tail	= entry;
-	}
-	lockmgr(&dev->dev_lock, LK_RELEASE, 0, curproc);
-	
-	return 0;
-}
-
-int drm_remove_magic(drm_device_t *dev, drm_magic_t magic)
-{
-	drm_magic_entry_t *prev = NULL;
-	drm_magic_entry_t *pt;
-	int		  hash;
-	
-	DRM_DEBUG("%d\n", magic);
-	hash = drm_hash_magic(magic);
-	
-	lockmgr(&dev->dev_lock, LK_EXCLUSIVE, 0, curproc);
-	for (pt = dev->magiclist[hash].head; pt; prev = pt, pt = pt->next) {
-		if (pt->magic == magic) {
-			if (dev->magiclist[hash].head == pt) {
-				dev->magiclist[hash].head = pt->next;
-			}
-			if (dev->magiclist[hash].tail == pt) {
-				dev->magiclist[hash].tail = prev;
-			}
-			if (prev) {
-				prev->next = pt->next;
-			}
-			lockmgr(&dev->dev_lock, LK_RELEASE, 0, curproc);
-			return 0;
-		}
-	}
-	lockmgr(&dev->dev_lock, LK_RELEASE, 0, curproc);
-
-	drm_free(pt, sizeof(*pt), DRM_MEM_MAGIC);
-	
-	return EINVAL;
-}
-
-int drm_getmagic(dev_t kdev, u_long cmd, caddr_t data,
-		 int flags, struct proc *p)
-{
-	static drm_magic_t sequence = 0;
-#if 0
-	static struct simplelock lock; /* XXX */
-#endif
-	drm_device_t	   *dev = kdev->si_drv1;
-	drm_file_t	   *priv;
-	drm_auth_t	   auth;
-
-				/* Find unique magic */
-	priv = drm_find_file_by_proc(dev, p);
-	if (!priv) {
-	    DRM_DEBUG("can't find file structure\n");
-	    return EINVAL;
-	}
-	if (priv->magic) {
-		auth.magic = priv->magic;
-	} else {
-		do {
-			simple_lock(&lock);
-			if (!sequence) ++sequence; /* reserve 0 */
-			auth.magic = sequence++;
-		simple_unlock(&lock);
-		} while (drm_find_file(dev, auth.magic));
-		priv->magic = auth.magic;
-		drm_add_magic(dev, priv, auth.magic);
-	}
-	
-	DRM_DEBUG("%u\n", auth.magic);
-	*(drm_auth_t *) data = auth;
-	return 0;
-}
-
-int drm_authmagic(dev_t kdev, u_long cmd, caddr_t data,
-		  int flags, struct proc *p)
-{
-	drm_device_t	   *dev	    = kdev->si_drv1;
-	drm_auth_t	   auth;
-	drm_file_t	   *file;
-
-	auth = *(drm_auth_t *) data;
-	DRM_DEBUG("%u\n", auth.magic);
-	if ((file = drm_find_file(dev, auth.magic))) {
-		file->authenticated = 1;
-		drm_remove_magic(dev, auth.magic);
-		return 0;
-	}
-	return EINVAL;
-}
diff --git a/bsd/drm/bufs.c b/bsd/drm/bufs.c
deleted file mode 100644
index f283bab2..00000000
--- a/bsd/drm/bufs.c
+++ /dev/null
@@ -1,500 +0,0 @@
-/* bufs.c -- IOCTLs to manage buffers -*- c -*-
- * Created: Tue Feb  2 08:37:54 1999 by faith@precisioninsight.com
- *
- * Copyright 1999 Precision Insight, Inc., Cedar Park, Texas.
- * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
- * All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice (including the next
- * paragraph) shall be included in all copies or substantial portions of the
- * Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
- * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
- * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- * 
- * Authors:
- *    Rickard E. (Rik) Faith <faith@valinux.com>
- *
- */
-
-#define __NO_VERSION__
-#include "drmP.h"
-#include <sys/mman.h>
-#include <vm/vm.h>
-#include <vm/pmap.h>
-#include <vm/vm_extern.h>
-#include <vm/vm_map.h>
-
-				/* Compute order.  Can be made faster. */
-int drm_order(unsigned long size)
-{
-	int	      order;
-	unsigned long tmp;
-
-	for (order = 0, tmp = size; tmp >>= 1; ++order);
-	if (size & ~(1 << order)) ++order;
-	return order;
-}
-
-int drm_addmap(dev_t kdev, u_long cmd, caddr_t data,
-	       int flags, struct proc *p)
-{
-	drm_device_t	*dev	= kdev->si_drv1;
-	drm_map_t	*map;
-	
-	if (!(dev->flags & (FREAD|FWRITE)))
-		return EACCES; /* Require read/write */
-
-	map	     = drm_alloc(sizeof(*map), DRM_MEM_MAPS);
-	if (!map) return ENOMEM;
-	*map = *(drm_map_t *) data;
-
-	DRM_DEBUG("offset = 0x%08lx, size = 0x%08lx, type = %d\n",
-		  map->offset, map->size, map->type);
-	if ((map->offset & (PAGE_SIZE-1)) || (map->size & (PAGE_SIZE-1))) {
-		drm_free(map, sizeof(*map), DRM_MEM_MAPS);
-		DRM_DEBUG("offset or size not page aligned\n");
-		return EINVAL;
-	}
-	map->mtrr   = -1;
-	map->handle = 0;
-
-	switch (map->type) {
-	case _DRM_REGISTERS:
-	case _DRM_FRAME_BUFFER:	
-		if (map->offset + map->size < map->offset
-		    /* || map->offset < virt_to_phys(high_memory) */) {
-			drm_free(map, sizeof(*map), DRM_MEM_MAPS);
-			DRM_DEBUG("bad frame buffer size\n");
-			return EINVAL;
-		}
-#ifdef CONFIG_MTRR
-		if (map->type == _DRM_FRAME_BUFFER
-		    || (map->flags & _DRM_WRITE_COMBINING)) {
-			map->mtrr = mtrr_add(map->offset, map->size,
-					     MTRR_TYPE_WRCOMB, 1);
-		}
-#endif
-		map->handle = drm_ioremap(map->offset, map->size);
-		break;
-			
-
-	case _DRM_SHM:
-		DRM_DEBUG("%ld %d\n", map->size, drm_order(map->size));
-		map->handle = (void *)drm_alloc_pages(drm_order(map->size)
-						      - PAGE_SHIFT,
-						      DRM_MEM_SAREA);
-		if (!map->handle) {
-			drm_free(map, sizeof(*map), DRM_MEM_MAPS);
-			return ENOMEM;
-		}
-		map->offset = (unsigned long)map->handle;
-		if (map->flags & _DRM_CONTAINS_LOCK) {
-			dev->lock.hw_lock = map->handle; /* Pointer to lock */
-		}
-		break;
-#ifdef DRM_AGP
-	case _DRM_AGP:
-		map->offset = map->offset + dev->agp->base;
-		break;
-#endif
-	default:
-		drm_free(map, sizeof(*map), DRM_MEM_MAPS);
-		DRM_DEBUG("bad type\n");
-		return EINVAL;
-	}
-
-	lockmgr(&dev->dev_lock, LK_EXCLUSIVE, 0, curproc);
-	if (dev->maplist) {
-		++dev->map_count;
-		dev->maplist = drm_realloc(dev->maplist,
-					   (dev->map_count-1)
-					   * sizeof(*dev->maplist),
-					   dev->map_count
-					   * sizeof(*dev->maplist),
-					   DRM_MEM_MAPS);
-	} else {
-		dev->map_count = 1;
-		dev->maplist = drm_alloc(dev->map_count*sizeof(*dev->maplist),
-					 DRM_MEM_MAPS);
-	}
-	dev->maplist[dev->map_count-1] = map;
-	lockmgr(&dev->dev_lock, LK_RELEASE, 0, curproc);
-
-	*(drm_map_t *) data = *map;
-	if (map->type != _DRM_SHM)
-		((drm_map_t *)data)->handle = (void *) map->offset;
-
-	return 0;
-}
-
-int drm_addbufs(dev_t kdev, u_long cmd, caddr_t data,
-		int flags, struct proc *p)
-{
-	drm_device_t	 *dev	 = kdev->si_drv1;
-	drm_device_dma_t *dma	 = dev->dma;
-	drm_buf_desc_t	 request;
-	int		 count;
-	int		 order;
-	int		 size;
-	int		 total;
-	int		 page_order;
-	drm_buf_entry_t	 *entry;
-	unsigned long	 page;
-	drm_buf_t	 *buf;
-	int		 alignment;
-	unsigned long	 offset;
-	int		 i;
-	int		 byte_count;
-	int		 page_count;
-
-	if (!dma) return EINVAL;
-
-	request = *(drm_buf_desc_t *) data;
-
-	count	   = request.count;
-	order	   = drm_order(request.size);
-	size	   = 1 << order;
-	
-	DRM_DEBUG("count = %d, size = %d (%d), order = %d, queue_count = %d\n",
-		  request.count, request.size, size, order, dev->queue_count);
-
-	if (order < DRM_MIN_ORDER || order > DRM_MAX_ORDER) return EINVAL;
-	if (dev->queue_count) return EBUSY; /* Not while in use */
-
-	alignment  = (request.flags & _DRM_PAGE_ALIGN) ? round_page(size) :size;
-	page_order = order - PAGE_SHIFT > 0 ? order - PAGE_SHIFT : 0;
-	total	   = PAGE_SIZE << page_order;
-
-	simple_lock(&dev->count_lock);
-	if (dev->buf_use) {
-		simple_unlock(&dev->count_lock);
-		return EBUSY;
-	}
-	atomic_inc(&dev->buf_alloc);
-	simple_unlock(&dev->count_lock);
-	
-	lockmgr(&dev->dev_lock, LK_EXCLUSIVE, 0, curproc);
-	entry = &dma->bufs[order];
-	if (entry->buf_count) {
-		lockmgr(&dev->dev_lock, LK_RELEASE, 0, curproc);
-		atomic_dec(&dev->buf_alloc);
-		return ENOMEM;	/* May only call once for each order */
-	}
-	
-	entry->buflist = drm_alloc(count * sizeof(*entry->buflist),
-				   DRM_MEM_BUFS);
-	if (!entry->buflist) {
-		lockmgr(&dev->dev_lock, LK_RELEASE, 0, curproc);
-		atomic_dec(&dev->buf_alloc);
-		return ENOMEM;
-	}
-	memset(entry->buflist, 0, count * sizeof(*entry->buflist));
-
-	entry->seglist = drm_alloc(count * sizeof(*entry->seglist),
-				   DRM_MEM_SEGS);
-	if (!entry->seglist) {
-		drm_free(entry->buflist,
-			 count * sizeof(*entry->buflist),
-			 DRM_MEM_BUFS);
-		lockmgr(&dev->dev_lock, LK_RELEASE, 0, curproc);
-		atomic_dec(&dev->buf_alloc);
-		return ENOMEM;
-	}
-	memset(entry->seglist, 0, count * sizeof(*entry->seglist));
-
-	dma->pagelist = drm_realloc(dma->pagelist,
-				    dma->page_count * sizeof(*dma->pagelist),
-				    (dma->page_count + (count << page_order))
-				    * sizeof(*dma->pagelist),
-				    DRM_MEM_PAGES);
-	DRM_DEBUG("pagelist: %d entries\n",
-		  dma->page_count + (count << page_order));
-
-
-	entry->buf_size	  = size;
-	entry->page_order = page_order;
-	byte_count	  = 0;
-	page_count	  = 0;
-	while (entry->buf_count < count) {
-		if (!(page = drm_alloc_pages(page_order, DRM_MEM_DMA))) break;
-		entry->seglist[entry->seg_count++] = page;
-		for (i = 0; i < (1 << page_order); i++) {
-			DRM_DEBUG("page %d @ 0x%08lx\n",
-				  dma->page_count + page_count,
-				  page + PAGE_SIZE * i);
-			dma->pagelist[dma->page_count + page_count++]
-				= page + PAGE_SIZE * i;
-		}
-		for (offset = 0;
-		     offset + size <= total && entry->buf_count < count;
-		     offset += alignment, ++entry->buf_count) {
-			buf	     = &entry->buflist[entry->buf_count];
-			buf->idx     = dma->buf_count + entry->buf_count;
-			buf->total   = alignment;
-			buf->order   = order;
-			buf->used    = 0;
-			buf->offset  = (dma->byte_count + byte_count + offset);
-			buf->address = (void *)(page + offset);
-			buf->next    = NULL;
-			buf->waiting = 0;
-			buf->pending = 0;
-			buf->dma_wait = 0;
-			buf->pid     = 0;
-#if DRM_DMA_HISTOGRAM
-			timespecclear(&buf->time_queued);
-			timespecclear(&buf->time_dispatched);
-			timespecclear(&buf->time_completed);
-			timespecclear(&buf->time_freed);
-#endif
-			DRM_DEBUG("buffer %d @ %p\n",
-				  entry->buf_count, buf->address);
-		}
-		byte_count += PAGE_SIZE << page_order;
-	}
-
-	dma->buflist = drm_realloc(dma->buflist,
-				   dma->buf_count * sizeof(*dma->buflist),
-				   (dma->buf_count + entry->buf_count)
-				   * sizeof(*dma->buflist),
-				   DRM_MEM_BUFS);
-	for (i = dma->buf_count; i < dma->buf_count + entry->buf_count; i++)
-		dma->buflist[i] = &entry->buflist[i - dma->buf_count];
-
-	dma->buf_count	+= entry->buf_count;
-	dma->seg_count	+= entry->seg_count;
-	dma->page_count += entry->seg_count << page_order;
-	dma->byte_count += PAGE_SIZE * (entry->seg_count << page_order);
-	
-	drm_freelist_create(&entry->freelist, entry->buf_count);
-	for (i = 0; i < entry->buf_count; i++) {
-		drm_freelist_put(dev, &entry->freelist, &entry->buflist[i]);
-	}
-	
-	lockmgr(&dev->dev_lock, LK_RELEASE, 0, curproc);
-
-	request.count = entry->buf_count;
-	request.size  = size;
-
-	*(drm_buf_desc_t *) data = request;
-	
-	atomic_dec(&dev->buf_alloc);
-	return 0;
-}
-
-int drm_infobufs(dev_t kdev, u_long cmd, caddr_t data,
-		 int flags, struct proc *p)
-{
-	drm_device_t	 *dev	 = kdev->si_drv1;
-	drm_device_dma_t *dma	 = dev->dma;
-	drm_buf_info_t	 request;
-	int		 i;
-	int		 count;
-
-	if (!dma) return EINVAL;
-
-	simple_lock(&dev->count_lock);
-	if (atomic_read(&dev->buf_alloc)) {
-		simple_unlock(&dev->count_lock);
-		return EBUSY;
-	}
-	++dev->buf_use;		/* Can't allocate more after this call */
-	simple_unlock(&dev->count_lock);
-
-	request = *(drm_buf_info_t *) data;
-
-	for (i = 0, count = 0; i < DRM_MAX_ORDER+1; i++) {
-		if (dma->bufs[i].buf_count) ++count;
-	}
-	
-	DRM_DEBUG("count = %d\n", count);
-	
-	if (request.count >= count) {
-		for (i = 0, count = 0; i < DRM_MAX_ORDER+1; i++) {
-			if (dma->bufs[i].buf_count) {
-				int error;
-				error = copyout(&dma->bufs[i].buf_count,
-						&request.list[count].count,
-						sizeof(dma->bufs[0]
-						       .buf_count));
-				if (error) return error;
-				error = copyout(&dma->bufs[i].buf_size,
-						&request.list[count].size,
-						sizeof(dma->bufs[0].buf_size));
-				if (error) return error;
-				error = copyout(&dma->bufs[i]
-						.freelist.low_mark,
-						&request.list[count].low_mark,
-						sizeof(dma->bufs[0]
-						       .freelist.low_mark));
-				if (error) return error;
-				error = copyout(&dma->bufs[i]
-						.freelist.high_mark,
-						&request.list[count].high_mark,
-						sizeof(dma->bufs[0]
-						       .freelist.high_mark));
-				if (error) return error;
-				DRM_DEBUG("%d %d %d %d %d\n",
-					  i,
-					  dma->bufs[i].buf_count,
-					  dma->bufs[i].buf_size,
-					  dma->bufs[i].freelist.low_mark,
-					  dma->bufs[i].freelist.high_mark);
-				++count;
-			}
-		}
-	}
-	request.count = count;
-
-	*(drm_buf_info_t *) data = request;
-	
-	return 0;
-}
-
-int drm_markbufs(dev_t kdev, u_long cmd, caddr_t data,
-		 int flags, struct proc *p)
-{
-	drm_device_t	 *dev	 = kdev->si_drv1;
-	drm_device_dma_t *dma	 = dev->dma;
-	drm_buf_desc_t	 request;
-	int		 order;
-	drm_buf_entry_t	 *entry;
-
-	if (!dma) return EINVAL;
-
-	request = *(drm_buf_desc_t *) data;
-
-	DRM_DEBUG("%d, %d, %d\n",
-		  request.size, request.low_mark, request.high_mark);
-	order = drm_order(request.size);
-	if (order < DRM_MIN_ORDER || order > DRM_MAX_ORDER) return EINVAL;
-	entry = &dma->bufs[order];
-
-	if (request.low_mark < 0 || request.low_mark > entry->buf_count)
-		return EINVAL;
-	if (request.high_mark < 0 || request.high_mark > entry->buf_count)
-		return EINVAL;
-
-	entry->freelist.low_mark  = request.low_mark;
-	entry->freelist.high_mark = request.high_mark;
-	
-	return 0;
-}
-
-int drm_freebufs(dev_t kdev, u_long cmd, caddr_t data,
-		 int flags, struct proc *p)
-{
-	drm_device_t	 *dev	 = kdev->si_drv1;
-	drm_device_dma_t *dma	 = dev->dma;
-	drm_buf_free_t	 request;
-	int		 i;
-	int		 idx;
-	int		 error;
-	drm_buf_t	 *buf;
-
-	if (!dma) return EINVAL;
-
-	request = *(drm_buf_free_t *) data;
-
-	DRM_DEBUG("%d\n", request.count);
-	for (i = 0; i < request.count; i++) {
-		error = copyin(&request.list[i], &idx, sizeof(idx));
-		if (error)
-			return error;
-		if (idx < 0 || idx >= dma->buf_count) {
-			DRM_ERROR("Index %d (of %d max)\n",
-				  idx, dma->buf_count - 1);
-			return EINVAL;
-		}
-		buf = dma->buflist[idx];
-		if (buf->pid != p->p_pid) {
-			DRM_ERROR("Process %d freeing buffer owned by %d\n",
-				  p->p_pid, buf->pid);
-			return EINVAL;
-		}
-		drm_free_buffer(dev, buf);
-	}
-	
-	return 0;
-}
-
-int drm_mapbufs(dev_t kdev, u_long cmd, caddr_t data,
-		int flags, struct proc *p)
-{
-	drm_device_t	 *dev	 = kdev->si_drv1;
-	drm_device_dma_t *dma	 = dev->dma;
-	int		 retcode = 0;
-	const int	 zero	 = 0;
-	vm_offset_t	 virtual;
-	vm_offset_t	 address;
-	drm_buf_map_t	 request;
-	int		 i;
-
-	if (!dma) return EINVAL;
-	
-	DRM_DEBUG("\n");
-
-	simple_lock(&dev->count_lock);
-	if (atomic_read(&dev->buf_alloc)) {
-		simple_unlock(&dev->count_lock);
-		return EBUSY;
-	}
-	++dev->buf_use;		/* Can't allocate more after this call */
-	simple_unlock(&dev->count_lock);
-
-	request = *(drm_buf_map_t *) data;
-
-	if (request.count >= dma->buf_count) {
-		virtual = 0;
-		retcode = vm_mmap(&p->p_vmspace->vm_map,
-				  &virtual,
-				  round_page(dma->byte_count),
-				  PROT_READ|PROT_WRITE, VM_PROT_ALL,
-				  MAP_SHARED,
-				  SLIST_FIRST(&kdev->si_hlist),
-				  0);
-		if (retcode)
-			goto done;
-
-		request.virtual = (void *)virtual;
-
-		for (i = 0; i < dma->buf_count; i++) {
-			retcode = copyout(&dma->buflist[i]->idx,
-					  &request.list[i].idx,
-					  sizeof(request.list[0].idx));
-			if (retcode) goto done;
-			retcode = copyout(&dma->buflist[i]->total,
-					  &request.list[i].total,
-					  sizeof(request.list[0].total));
-			if (retcode) goto done;
-			retcode = copyout(&zero,
-					  &request.list[i].used,
-					  sizeof(request.list[0].used));
-			if (retcode) goto done;
-			address = virtual + dma->buflist[i]->offset;
-			retcode = copyout(&address,
-					  &request.list[i].address,
-					  sizeof(address));
-			if (retcode) goto done;
-		}
-	}
-done:
-	request.count = dma->buf_count;
-	DRM_DEBUG("%d buffers, retcode = %d\n", request.count, retcode);
-
-	*(drm_buf_map_t *) data = request;
-
-	return retcode;
-}
diff --git a/bsd/drm/context.c b/bsd/drm/context.c
deleted file mode 100644
index 70510f00..00000000
--- a/bsd/drm/context.c
+++ /dev/null
@@ -1,297 +0,0 @@
-/* context.c -- IOCTLs for contexts and DMA queues -*- c -*-
- * Created: Tue Feb  2 08:37:54 1999 by faith@precisioninsight.com
- *
- * Copyright 1999 Precision Insight, Inc., Cedar Park, Texas.
- * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
- * All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice (including the next
- * paragraph) shall be included in all copies or substantial portions of the
- * Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
- * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
- * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- * 
- * Authors:
- *    Rickard E. (Rik) Faith <faith@valinux.com>
- *
- */
-
-#define __NO_VERSION__
-#include "drmP.h"
-
-static int drm_init_queue(drm_device_t *dev, drm_queue_t *q, drm_ctx_t *ctx)
-{
-	DRM_DEBUG("\n");
-	
-	if (atomic_read(&q->use_count) != 1
-	    || atomic_read(&q->finalization)
-	    || atomic_read(&q->block_count)) {
-		DRM_ERROR("New queue is already in use: u%d f%d b%d\n",
-			  atomic_read(&q->use_count),
-			  atomic_read(&q->finalization),
-			  atomic_read(&q->block_count));
-	}
-		  
-	atomic_set(&q->finalization,  0);
-	atomic_set(&q->block_count,   0);
-	atomic_set(&q->block_read,    0);
-	atomic_set(&q->block_write,   0);
-	atomic_set(&q->total_queued,  0);
-	atomic_set(&q->total_flushed, 0);
-	atomic_set(&q->total_locks,   0);
-
-	q->write_queue = 0;
-	q->read_queue = 0;
-	q->flush_queue = 0;
-
-	q->flags = ctx->flags;
-
-	drm_waitlist_create(&q->waitlist, dev->dma->buf_count);
-
-	return 0;
-}
-
-
-/* drm_alloc_queue:
-PRE: 1) dev->queuelist[0..dev->queue_count] is allocated and will not
-	disappear (so all deallocation must be done after IOCTLs are off)
-     2) dev->queue_count < dev->queue_slots
-     3) dev->queuelist[i].use_count == 0 and
-	dev->queuelist[i].finalization == 0 if i not in use 
-POST: 1) dev->queuelist[i].use_count == 1
-      2) dev->queue_count < dev->queue_slots */
-		
-static int drm_alloc_queue(drm_device_t *dev)
-{
-	int	    i;
-	drm_queue_t *queue;
-	int	    oldslots;
-	int	    newslots;
-				/* Check for a free queue */
-	for (i = 0; i < dev->queue_count; i++) {
-		atomic_inc(&dev->queuelist[i]->use_count);
-		if (atomic_read(&dev->queuelist[i]->use_count) == 1
-		    && !atomic_read(&dev->queuelist[i]->finalization)) {
-			DRM_DEBUG("%d (free)\n", i);
-			return i;
-		}
-		atomic_dec(&dev->queuelist[i]->use_count);
-	}
-				/* Allocate a new queue */
-	lockmgr(&dev->dev_lock, LK_EXCLUSIVE, 0, curproc);
-	
-	queue = drm_alloc(sizeof(*queue), DRM_MEM_QUEUES);
-	memset(queue, 0, sizeof(*queue));
-	atomic_set(&queue->use_count, 1);
-	
-	++dev->queue_count;
-	if (dev->queue_count >= dev->queue_slots) {
-		oldslots = dev->queue_slots * sizeof(*dev->queuelist);
-		if (!dev->queue_slots) dev->queue_slots = 1;
-		dev->queue_slots *= 2;
-		newslots = dev->queue_slots * sizeof(*dev->queuelist);
-
-		dev->queuelist = drm_realloc(dev->queuelist,
-					     oldslots,
-					     newslots,
-					     DRM_MEM_QUEUES);
-		if (!dev->queuelist) {
-			lockmgr(&dev->dev_lock, LK_RELEASE, 0, curproc);
-			DRM_DEBUG("out of memory\n");
-			return -ENOMEM;
-		}
-	}
-	dev->queuelist[dev->queue_count-1] = queue;
-	
-	lockmgr(&dev->dev_lock, LK_RELEASE, 0, curproc);
-	DRM_DEBUG("%d (new)\n", dev->queue_count - 1);
-	return dev->queue_count - 1;
-}
-
-int drm_resctx(dev_t kdev, u_long cmd, caddr_t data, int flags, struct proc *p)
-{
-	drm_ctx_res_t	res;
-	drm_ctx_t	ctx;
-	int		i;
-	int		error;
-
-	DRM_DEBUG("%d\n", DRM_RESERVED_CONTEXTS);
-	res = *(drm_ctx_res_t *) data;
-	if (res.count >= DRM_RESERVED_CONTEXTS) {
-		memset(&ctx, 0, sizeof(ctx));
-		for (i = 0; i < DRM_RESERVED_CONTEXTS; i++) {
-			ctx.handle = i;
-			error = copyout(&i, &res.contexts[i],
-					sizeof(i));
-			if (error) return error;
-		}
-	}
-	res.count = DRM_RESERVED_CONTEXTS;
-	*(drm_ctx_res_t *) data = res;
-	return 0;
-}
-
-
-int drm_addctx(dev_t kdev, u_long cmd, caddr_t data, int flags, struct proc *p)
-{
-	drm_device_t	*dev	= kdev->si_drv1;
-	drm_ctx_t	ctx;
-
-	ctx = *(drm_ctx_t *) data;
-	if ((ctx.handle = drm_alloc_queue(dev)) == DRM_KERNEL_CONTEXT) {
-				/* Init kernel's context and get a new one. */
-		drm_init_queue(dev, dev->queuelist[ctx.handle], &ctx);
-		ctx.handle = drm_alloc_queue(dev);
-	}
-	drm_init_queue(dev, dev->queuelist[ctx.handle], &ctx);
-	DRM_DEBUG("%d\n", ctx.handle);
-	*(drm_ctx_t *) data = ctx;
-	return 0;
-}
-
-int drm_modctx(dev_t kdev, u_long cmd, caddr_t data, int flags, struct proc *p)
-{
-	drm_device_t	*dev	= kdev->si_drv1;
-	drm_ctx_t	ctx;
-	drm_queue_t	*q;
-		
-	ctx = *(drm_ctx_t *) data;
-	
-	DRM_DEBUG("%d\n", ctx.handle);
-	
-	if (ctx.handle < 0 || ctx.handle >= dev->queue_count) return -EINVAL;
-	q = dev->queuelist[ctx.handle];
-	
-	atomic_inc(&q->use_count);
-	if (atomic_read(&q->use_count) == 1) {
-				/* No longer in use */
-		atomic_dec(&q->use_count);
-		return -EINVAL;
-	}
-
-	if (DRM_BUFCOUNT(&q->waitlist)) {
-		atomic_dec(&q->use_count);
-		return -EBUSY;
-	}
-	
-	q->flags = ctx.flags;
-	
-	atomic_dec(&q->use_count);
-	return 0;
-}
-
-int drm_getctx(dev_t kdev, u_long cmd, caddr_t data, int flags, struct proc *p)
-{
-	drm_device_t	*dev	= kdev->si_drv1;
-	drm_ctx_t	ctx;
-	drm_queue_t	*q;
-		
-	ctx = *(drm_ctx_t *) data;
-	
-	DRM_DEBUG("%d\n", ctx.handle);
-	
-	if (ctx.handle >= dev->queue_count) return -EINVAL;
-	q = dev->queuelist[ctx.handle];
-	
-	atomic_inc(&q->use_count);
-	if (atomic_read(&q->use_count) == 1) {
-				/* No longer in use */
-		atomic_dec(&q->use_count);
-		return -EINVAL;
-	}
-	
-	ctx.flags = q->flags;
-	atomic_dec(&q->use_count);
-	
-	*(drm_ctx_t *) data = ctx;
-	
-	return 0;
-}
-
-int drm_switchctx(dev_t kdev, u_long cmd, caddr_t data, int flags, struct proc *p)
-{
-	drm_device_t	*dev	= kdev->si_drv1;
-	drm_ctx_t	ctx;
-
-	ctx = *(drm_ctx_t *) data;
-	DRM_DEBUG("%d\n", ctx.handle);
-	return drm_context_switch(dev, dev->last_context, ctx.handle);
-}
-
-int drm_newctx(dev_t kdev, u_long cmd, caddr_t data, int flags, struct proc *p)
-{
-	drm_device_t	*dev	= kdev->si_drv1;
-	drm_ctx_t	ctx;
-
-	ctx = *(drm_ctx_t *) data;
-	DRM_DEBUG("%d\n", ctx.handle);
-	drm_context_switch_complete(dev, ctx.handle);
-
-	return 0;
-}
-
-int drm_rmctx(dev_t kdev, u_long cmd, caddr_t data, int flags, struct proc *p)
-{
-	drm_device_t	*dev	= kdev->si_drv1;
-	drm_ctx_t	ctx;
-	drm_queue_t	*q;
-	drm_buf_t	*buf;
-
-	ctx = *(drm_ctx_t *) data;
-	DRM_DEBUG("%d\n", ctx.handle);
-	
-	if (ctx.handle >= dev->queue_count) return -EINVAL;
-	q = dev->queuelist[ctx.handle];
-	
-	atomic_inc(&q->use_count);
-	if (atomic_read(&q->use_count) == 1) {
-				/* No longer in use */
-		atomic_dec(&q->use_count);
-		return -EINVAL;
-	}
-	
-	atomic_inc(&q->finalization); /* Mark queue in finalization state */
-	atomic_sub(2, &q->use_count); /* Mark queue as unused (pending
-					 finalization) */
-
-	/* Wait while interrupt servicing is in progress */
-	while (test_and_set_bit(0, &dev->interrupt_flag)) {
-		int never;
-		int error = tsleep(&never, PZERO|PCATCH, "drmrc", 1);
-		if (error) {
-			clear_bit(0, &dev->interrupt_flag);
-			return error;
-		}
-	}
-				/* Remove queued buffers */
-	while ((buf = drm_waitlist_get(&q->waitlist))) {
-		drm_free_buffer(dev, buf);
-	}
-	clear_bit(0, &dev->interrupt_flag);
-	
-				/* Wakeup blocked processes */
-	wakeup(&q->read_queue);
-	wakeup(&q->write_queue);
-	wakeup(&q->flush_queue);
-	
-				/* Finalization over.  Queue is made
-				   available when both use_count and
-				   finalization become 0, which won't
-				   happen until all the waiting processes
-				   stop waiting. */
-	atomic_dec(&q->finalization);
-	return 0;
-}
diff --git a/bsd/drm/ctxbitmap.c b/bsd/drm/ctxbitmap.c
deleted file mode 100644
index 851b7582..00000000
--- a/bsd/drm/ctxbitmap.c
+++ /dev/null
@@ -1,85 +0,0 @@
-/* ctxbitmap.c -- Context bitmap management
- * Created: Thu Jan 6 03:56:42 2000 by jhartmann@precisioninsight.com
- * 
- * Copyright 1999 Precision Insight, Inc., Cedar Park, Texas.
- * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
- * All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice (including the next
- * paragraph) shall be included in all copies or substantial portions of the
- * Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * PRECISION INSIGHT 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.
- *
- * Author: Jeff Hartmann <jhartmann@valinux.com>
- *
- */
-
-#define __NO_VERSION__
-#include "drmP.h"
-
-void drm_ctxbitmap_free(drm_device_t *dev, int ctx_handle)
-{
-	if (ctx_handle < 0) goto failed;
-
-	if (ctx_handle < DRM_MAX_CTXBITMAP) {
-		clear_bit(ctx_handle, dev->ctx_bitmap);
-		return;
-	}
-failed:
-       	DRM_ERROR("Attempt to free invalid context handle: %d\n",
-		  ctx_handle);
-       	return;
-}
-
-int drm_ctxbitmap_next(drm_device_t *dev)
-{
-	int bit;
-
-	bit = find_first_zero_bit(dev->ctx_bitmap, DRM_MAX_CTXBITMAP);
-	if (bit < DRM_MAX_CTXBITMAP) {
-		set_bit(bit, dev->ctx_bitmap);
-	   	DRM_DEBUG("drm_ctxbitmap_next bit : %d\n", bit);
-		return bit;
-	}
-	return -1;
-}
-
-int drm_ctxbitmap_init(drm_device_t *dev)
-{
-	int i;
-   	int temp;
-
-	dev->ctx_bitmap = (u_int32_t *) drm_alloc(PAGE_SIZE, 
-						  DRM_MEM_CTXBITMAP);
-	if(dev->ctx_bitmap == NULL) {
-		return -ENOMEM;
-	}
-	memset((void *) dev->ctx_bitmap, 0, PAGE_SIZE);
-	for(i = 0; i < DRM_RESERVED_CONTEXTS; i++) {
-		temp = drm_ctxbitmap_next(dev);
-	   	DRM_DEBUG("drm_ctxbitmap_init : %d\n", temp);
-	}
-
-	return 0;
-}
-
-void drm_ctxbitmap_cleanup(drm_device_t *dev)
-{
-	drm_free((void *)dev->ctx_bitmap, PAGE_SIZE,
-		 DRM_MEM_CTXBITMAP);
-}
-
diff --git a/bsd/drm/dma.c b/bsd/drm/dma.c
deleted file mode 100644
index 93b0d0c7..00000000
--- a/bsd/drm/dma.c
+++ /dev/null
@@ -1,543 +0,0 @@
-/* dma.c -- DMA IOCTL and function support -*- c -*-
- * Created: Fri Mar 19 14:30:16 1999 by faith@precisioninsight.com
- *
- * Copyright 1999 Precision Insight, Inc., Cedar Park, Texas.
- * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
- * All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice (including the next
- * paragraph) shall be included in all copies or substantial portions of the
- * Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
- * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
- * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- * 
- * Authors:
- *    Rickard E. (Rik) Faith <faith@valinuxa.com>
- *
- */
-
-#define __NO_VERSION__
-#include "drmP.h"
-
-void drm_dma_setup(drm_device_t *dev)
-{
-	int i;
-	
-	dev->dma = drm_alloc(sizeof(*dev->dma), DRM_MEM_DRIVER);
-	memset(dev->dma, 0, sizeof(*dev->dma));
-	for (i = 0; i <= DRM_MAX_ORDER; i++)
-		memset(&dev->dma->bufs[i], 0, sizeof(dev->dma->bufs[0]));
-}
-
-void drm_dma_takedown(drm_device_t *dev)
-{
-	drm_device_dma_t  *dma = dev->dma;
-	int		  i, j;
-
-	if (!dma) return;
-	
-				/* Clear dma buffers */
-	for (i = 0; i <= DRM_MAX_ORDER; i++) {
-		if (dma->bufs[i].seg_count) {
-			DRM_DEBUG("order %d: buf_count = %d,"
-				  " seg_count = %d\n",
-				  i,
-				  dma->bufs[i].buf_count,
-				  dma->bufs[i].seg_count);
-			for (j = 0; j < dma->bufs[i].seg_count; j++) {
-				drm_free_pages(dma->bufs[i].seglist[j],
-					       dma->bufs[i].page_order,
-					       DRM_MEM_DMA);
-			}
-			drm_free(dma->bufs[i].seglist,
-				 dma->bufs[i].seg_count
-				 * sizeof(*dma->bufs[0].seglist),
-				 DRM_MEM_SEGS);
-		}
-	   	if(dma->bufs[i].buf_count) {
-		   	for(j = 0; j < dma->bufs[i].buf_count; j++) {
-			   if(dma->bufs[i].buflist[j].dev_private) {
-			      drm_free(dma->bufs[i].buflist[j].dev_private,
-				       dma->bufs[i].buflist[j].dev_priv_size,
-				       DRM_MEM_BUFS);
-			   }
-			}
-		   	drm_free(dma->bufs[i].buflist,
-				 dma->bufs[i].buf_count *
-				 sizeof(*dma->bufs[0].buflist),
-				 DRM_MEM_BUFS);
-		   	drm_freelist_destroy(&dma->bufs[i].freelist);
-		}
-	}
-	
-	if (dma->buflist) {
-		drm_free(dma->buflist,
-			 dma->buf_count * sizeof(*dma->buflist),
-			 DRM_MEM_BUFS);
-	}
-
-	if (dma->pagelist) {
-		drm_free(dma->pagelist,
-			 dma->page_count * sizeof(*dma->pagelist),
-			 DRM_MEM_PAGES);
-	}
-	drm_free(dev->dma, sizeof(*dev->dma), DRM_MEM_DRIVER);
-	dev->dma = NULL;
-}
-
-#if DRM_DMA_HISTOGRAM
-/* This is slow, but is useful for debugging. */
-int drm_histogram_slot(struct timespec *ts)
-{
-	long count = ts->tv_sec * 1000 + ts->tv_nsec / 1000000;
-	int value = DRM_DMA_HISTOGRAM_INITIAL;
-	int slot;
-
-	for (slot = 0;
-	     slot < DRM_DMA_HISTOGRAM_SLOTS;
-	     ++slot, value = DRM_DMA_HISTOGRAM_NEXT(value)) {
-		if (count < value) return slot;
-	}
-	return DRM_DMA_HISTOGRAM_SLOTS - 1;
-}
-
-void drm_histogram_compute(drm_device_t *dev, drm_buf_t *buf)
-{
-	struct timespec queued_to_dispatched;
-	struct timespec dispatched_to_completed;
-	struct timespec completed_to_freed;
-	int	 q2d, d2c, c2f, q2c, q2f;
-	
-	if (timespecisset(&buf->time_queued)) {
-		queued_to_dispatched = buf->time_dispatched;
-		timespecsub(&queued_to_dispatched, &buf->time_queued);
-		dispatched_to_completed = buf->time_completed;
-		timespecsub(&dispatched_to_completed, &buf->time_dispatched);
-		completed_to_freed = buf->time_freed;
-		timespecsub(&completed_to_freed, &buf->time_completed);
-
-		q2d = drm_histogram_slot(&queued_to_dispatched);
-		d2c = drm_histogram_slot(&dispatched_to_completed);
-		c2f = drm_histogram_slot(&completed_to_freed);
-
-		timespecadd(&queued_to_dispatched, &dispatched_to_completed);
-		q2c = drm_histogram_slot(&queued_to_dispatched);
-		timespecadd(&queued_to_dispatched, &completed_to_freed);
-		q2f = drm_histogram_slot(&queued_to_dispatched);
-		
-		atomic_inc(&dev->histo.total);
-		atomic_inc(&dev->histo.queued_to_dispatched[q2d]);
-		atomic_inc(&dev->histo.dispatched_to_completed[d2c]);
-		atomic_inc(&dev->histo.completed_to_freed[c2f]);
-		
-		atomic_inc(&dev->histo.queued_to_completed[q2c]);
-		atomic_inc(&dev->histo.queued_to_freed[q2f]);
-
-	}
-	timespecclear(&buf->time_queued);
-	timespecclear(&buf->time_dispatched);
-	timespecclear(&buf->time_completed);
-	timespecclear(&buf->time_freed);
-}
-#endif
-
-void drm_free_buffer(drm_device_t *dev, drm_buf_t *buf)
-{
-	drm_device_dma_t *dma = dev->dma;
-
-	if (!buf) return;
-	
-	buf->waiting  = 0;
-	buf->pending  = 0;
-	buf->pid      = 0;
-	buf->used     = 0;
-#if DRM_DMA_HISTOGRAMxx
-	buf->time_completed = get_cycles();
-#endif
-	if (buf->dma_wait) {
-		buf->dma_wait = 0;
-		wakeup(&buf->dma_wait);
-	} else {
-				/* If processes are waiting, the last one
-				   to wake will put the buffer on the free
-				   list.  If no processes are waiting, we
-				   put the buffer on the freelist here. */
-		drm_freelist_put(dev, &dma->bufs[buf->order].freelist, buf);
-	}
-}
-
-void drm_reclaim_buffers(drm_device_t *dev, pid_t pid)
-{
-	drm_device_dma_t *dma = dev->dma;
-	int		 i;
-
-	if (!dma) return;
-	for (i = 0; i < dma->buf_count; i++) {
-		if (dma->buflist[i]->pid == pid) {
-			switch (dma->buflist[i]->list) {
-			case DRM_LIST_NONE:
-				drm_free_buffer(dev, dma->buflist[i]);
-				break;
-			case DRM_LIST_WAIT:
-				dma->buflist[i]->list = DRM_LIST_RECLAIM;
-				break;
-			default:
-				/* Buffer already on hardware. */
-				break;
-			}
-		}
-	}
-}
-
-int drm_context_switch(drm_device_t *dev, int old, int new)
-{
-	char	    buf[64];
-	drm_queue_t *q;
-
-	atomic_inc(&dev->total_ctx);
-
-	if (test_and_set_bit(0, &dev->context_flag)) {
-		DRM_ERROR("Reentering -- FIXME\n");
-		return EBUSY;
-	}
-
-#if DRM_DMA_HISTOGRAM
-	getnanotime(&dev->ctx_start);
-#endif
-	
-	DRM_DEBUG("Context switch from %d to %d\n", old, new);
-
-	if (new >= dev->queue_count) {
-		clear_bit(0, &dev->context_flag);
-		return EINVAL;
-	}
-
-	if (new == dev->last_context) {
-		clear_bit(0, &dev->context_flag);
-		return 0;
-	}
-	
-	q = dev->queuelist[new];
-	atomic_inc(&q->use_count);
-	if (atomic_read(&q->use_count) == 1) {
-		atomic_dec(&q->use_count);
-		clear_bit(0, &dev->context_flag);
-		return EINVAL;
-	}
-
-	if (drm_flags & DRM_FLAG_NOCTX) {
-		drm_context_switch_complete(dev, new);
-	} else {
-		sprintf(buf, "C %d %d\n", old, new);
-		drm_write_string(dev, buf);
-	}
-	
-	atomic_dec(&q->use_count);
-	
-	return 0;
-}
-
-int drm_context_switch_complete(drm_device_t *dev, int new)
-{
-	drm_device_dma_t *dma = dev->dma;
-	
-	dev->last_context = new;  /* PRE/POST: This is the _only_ writer. */
-	dev->last_switch = ticks;
-	
-	if (!_DRM_LOCK_IS_HELD(dev->lock.hw_lock->lock)) {
-		DRM_ERROR("Lock isn't held after context switch\n");
-	}
-
-	if (!dma || !(dma->next_buffer && dma->next_buffer->while_locked)) {
-		if (drm_lock_free(dev, &dev->lock.hw_lock->lock,
-				  DRM_KERNEL_CONTEXT)) {
-			DRM_ERROR("Cannot free lock\n");
-		}
-	}
-	
-#if DRM_DMA_HISTOGRAM
-	{
-		struct timespec ts;
-		getnanotime(&ts);
-		timespecsub(&ts, &dev->ctx_start);
-		atomic_inc(&dev->histo.ctx[drm_histogram_slot(&ts)]);
-	}
-#endif
-	clear_bit(0, &dev->context_flag);
-	wakeup(&dev->context_wait);
-	
-	return 0;
-}
-
-void drm_clear_next_buffer(drm_device_t *dev)
-{
-	drm_device_dma_t *dma = dev->dma;
-	
-	dma->next_buffer = NULL;
-	if (dma->next_queue && !DRM_BUFCOUNT(&dma->next_queue->waitlist)) {
-		wakeup(&dma->next_queue->flush_queue);
-	}
-	dma->next_queue	 = NULL;
-}
-
-
-int drm_select_queue(drm_device_t *dev, void (*wrapper)(void *))
-{
-	int	   i;
-	int	   candidate = -1;
-	int	   j	     = ticks;
-
-	if (!dev) {
-		DRM_ERROR("No device\n");
-		return -1;
-	}
-	if (!dev->queuelist || !dev->queuelist[DRM_KERNEL_CONTEXT]) {
-				/* This only happens between the time the
-				   interrupt is initialized and the time
-				   the queues are initialized. */
-		return -1;
-	}
-
-				/* Doing "while locked" DMA? */
-	if (DRM_WAITCOUNT(dev, DRM_KERNEL_CONTEXT)) {
-		return DRM_KERNEL_CONTEXT;
-	}
-
-				/* If there are buffers on the last_context
-				   queue, and we have not been executing
-				   this context very long, continue to
-				   execute this context. */
-	if (dev->last_switch <= j
-	    && dev->last_switch + DRM_TIME_SLICE > j
-	    && DRM_WAITCOUNT(dev, dev->last_context)) {
-		return dev->last_context;
-	}
-
-				/* Otherwise, find a candidate */
-	for (i = dev->last_checked + 1; i < dev->queue_count; i++) {
-		if (DRM_WAITCOUNT(dev, i)) {
-			candidate = dev->last_checked = i;
-			break;
-		}
-	}
-
-	if (candidate < 0) {
-		for (i = 0; i < dev->queue_count; i++) {
-			if (DRM_WAITCOUNT(dev, i)) {
-				candidate = dev->last_checked = i;
-				break;
-			}
-		}
-	}
-
-	if (wrapper
-	    && candidate >= 0
-	    && candidate != dev->last_context
-	    && dev->last_switch <= j
-	    && dev->last_switch + DRM_TIME_SLICE > j) {
-		int s = splclock();
-		if (dev->timer.c_time != dev->last_switch + DRM_TIME_SLICE) {
-			callout_reset(&dev->timer,
-				      dev->last_switch + DRM_TIME_SLICE - j,
-				      wrapper,
-				      dev);
-		}
-		splx(s);
-		return -1;
-	}
-
-	return candidate;
-}
-
-
-int drm_dma_enqueue(drm_device_t *dev, drm_dma_t *d)
-{
-	int		  i;
-	drm_queue_t	  *q;
-	drm_buf_t	  *buf;
-	int		  idx;
-	int		  while_locked = 0;
-	drm_device_dma_t  *dma = dev->dma;
-	int		  error;
-
-	DRM_DEBUG("%d\n", d->send_count);
-
-	if (d->flags & _DRM_DMA_WHILE_LOCKED) {
-		int context = dev->lock.hw_lock->lock;
-		
-		if (!_DRM_LOCK_IS_HELD(context)) {
-			DRM_ERROR("No lock held during \"while locked\""
-				  " request\n");
-			return EINVAL;
-		}
-		if (d->context != _DRM_LOCKING_CONTEXT(context)
-		    && _DRM_LOCKING_CONTEXT(context) != DRM_KERNEL_CONTEXT) {
-			DRM_ERROR("Lock held by %d while %d makes"
-				  " \"while locked\" request\n",
-				  _DRM_LOCKING_CONTEXT(context),
-				  d->context);
-			return EINVAL;
-		}
-		q = dev->queuelist[DRM_KERNEL_CONTEXT];
-		while_locked = 1;
-	} else {
-		q = dev->queuelist[d->context];
-	}
-
-
-	atomic_inc(&q->use_count);
-	if (atomic_read(&q->block_write)) {
-		atomic_inc(&q->block_count);
-		for (;;) {
-			if (!atomic_read(&q->block_write)) break;
-			error = tsleep(&q->block_write, PZERO|PCATCH,
-				       "dmawr", 0);
-			if (error) {
-				atomic_dec(&q->use_count);
-				return error;
-			}
-		}
-		atomic_dec(&q->block_count);
-	}
-	
-	for (i = 0; i < d->send_count; i++) {
-		idx = d->send_indices[i];
-		if (idx < 0 || idx >= dma->buf_count) {
-			atomic_dec(&q->use_count);
-			DRM_ERROR("Index %d (of %d max)\n",
-				  d->send_indices[i], dma->buf_count - 1);
-			return EINVAL;
-		}
-		buf = dma->buflist[ idx ];
-		if (buf->pid != curproc->p_pid) {
-			atomic_dec(&q->use_count);
-			DRM_ERROR("Process %d using buffer owned by %d\n",
-				  curproc->p_pid, buf->pid);
-			return EINVAL;
-		}
-		if (buf->list != DRM_LIST_NONE) {
-			atomic_dec(&q->use_count);
-			DRM_ERROR("Process %d using buffer %d on list %d\n",
-				  curproc->p_pid, buf->idx, buf->list);
-		}
-		buf->used	  = d->send_sizes[i];
-		buf->while_locked = while_locked;
-		buf->context	  = d->context;
-		if (!buf->used) {
-			DRM_ERROR("Queueing 0 length buffer\n");
-		}
-		if (buf->pending) {
-			atomic_dec(&q->use_count);
-			DRM_ERROR("Queueing pending buffer:"
-				  " buffer %d, offset %d\n",
-				  d->send_indices[i], i);
-			return EINVAL;
-		}
-		if (buf->waiting) {
-			atomic_dec(&q->use_count);
-			DRM_ERROR("Queueing waiting buffer:"
-				  " buffer %d, offset %d\n",
-				  d->send_indices[i], i);
-			return EINVAL;
-		}
-		buf->waiting = 1;
-		if (atomic_read(&q->use_count) == 1
-		    || atomic_read(&q->finalization)) {
-			drm_free_buffer(dev, buf);
-		} else {
-			drm_waitlist_put(&q->waitlist, buf);
-			atomic_inc(&q->total_queued);
-		}
-	}
-	atomic_dec(&q->use_count);
-	
-	return 0;
-}
-
-static int drm_dma_get_buffers_of_order(drm_device_t *dev, drm_dma_t *d,
-					int order)
-{
-	int		  i;
-	int		  error;
-	drm_buf_t	  *buf;
-	drm_device_dma_t  *dma = dev->dma;
-	
-	for (i = d->granted_count; i < d->request_count; i++) {
-		buf = drm_freelist_get(&dma->bufs[order].freelist,
-				       d->flags & _DRM_DMA_WAIT);
-		if (!buf) break;
-		if (buf->pending || buf->waiting) {
-			DRM_ERROR("Free buffer %d in use by %d (w%d, p%d)\n",
-				  buf->idx,
-				  buf->pid,
-				  buf->waiting,
-				  buf->pending);
-		}
-		buf->pid     = curproc->p_pid;
-		error = copyout(&buf->idx,
-				&d->request_indices[i],
-				sizeof(buf->idx));
-		if (error)
-			return error;
-		error = copyout(&buf->total,
-				&d->request_sizes[i],
-				sizeof(buf->total));
-		if (error)
-			return error;
-		++d->granted_count;
-	}
-	return 0;
-}
-
-
-int drm_dma_get_buffers(drm_device_t *dev, drm_dma_t *dma)
-{
-	int		  order;
-	int		  retcode = 0;
-	int		  tmp_order;
-	
-	order = drm_order(dma->request_size);
-
-	dma->granted_count = 0;
-	retcode		   = drm_dma_get_buffers_of_order(dev, dma, order);
-
-	if (dma->granted_count < dma->request_count
-	    && (dma->flags & _DRM_DMA_SMALLER_OK)) {
-		for (tmp_order = order - 1;
-		     !retcode
-			     && dma->granted_count < dma->request_count
-			     && tmp_order >= DRM_MIN_ORDER;
-		     --tmp_order) {
-			
-			retcode = drm_dma_get_buffers_of_order(dev, dma,
-							       tmp_order);
-		}
-	}
-
-	if (dma->granted_count < dma->request_count
-	    && (dma->flags & _DRM_DMA_LARGER_OK)) {
-		for (tmp_order = order + 1;
-		     !retcode
-			     && dma->granted_count < dma->request_count
-			     && tmp_order <= DRM_MAX_ORDER;
-		     ++tmp_order) {
-			
-			retcode = drm_dma_get_buffers_of_order(dev, dma,
-							       tmp_order);
-		}
-	}
-	return 0;
-}
diff --git a/bsd/drm/drawable.c b/bsd/drm/drawable.c
deleted file mode 100644
index d15ea617..00000000
--- a/bsd/drm/drawable.c
+++ /dev/null
@@ -1,50 +0,0 @@
-/* drawable.c -- IOCTLs for drawables -*- c -*-
- * Created: Tue Feb  2 08:37:54 1999 by faith@precisioninsight.com
- *
- * Copyright 1999 Precision Insight, Inc., Cedar Park, Texas.
- * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
- * All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice (including the next
- * paragraph) shall be included in all copies or substantial portions of the
- * Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
- * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
- * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- * 
- * Authors:
- *    Rickard E. (Rik) Faith <faith@valinux.com>
- *
- */
-
-#define __NO_VERSION__
-#include "drmP.h"
-
-int drm_adddraw(dev_t kdev, u_long cmd, caddr_t data,
-		int flags, struct proc *p)
-{
-	drm_draw_t draw;
-
-	draw.handle = 0;	/* NOOP */
-	DRM_DEBUG("%d\n", draw.handle);
-	*(drm_draw_t *) data = draw;
-	return 0;
-}
-
-int drm_rmdraw(dev_t kdev, u_long cmd, caddr_t data,
-	       int flags, struct proc *p)
-{
-	return 0;		/* NOOP */
-}
diff --git a/bsd/drm/drmstat.c b/bsd/drm/drmstat.c
deleted file mode 100644
index 48fb1b16..00000000
--- a/bsd/drm/drmstat.c
+++ /dev/null
@@ -1,418 +0,0 @@
-/* drmstat.c -- DRM device status and testing program
- * Created: Tue Jan  5 08:19:24 1999 by faith@precisioninsight.com
- * Revised: Sun Aug  1 11:02:00 1999 by faith@precisioninsight.com
- *
- * Copyright 1999 Precision Insight, Inc., Cedar Park, Texas.
- * All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice (including the next
- * paragraph) shall be included in all copies or substantial portions of the
- * Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * PRECISION INSIGHT 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.
- * 
- * $PI: xc/programs/Xserver/hw/xfree86/os-support/linux/drm/kernel/drmstat.c,v 1.28 1999/08/04 18:12:11 faith Exp $
- * $XFree86: xc/programs/Xserver/hw/xfree86/os-support/bsd/drm/kernel/drm/drmstat.c,v 1.1 2000/06/17 00:03:30 martin Exp $
- * 
- */
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <sys/types.h>
-#include <sys/time.h>
-#include <sys/mman.h>
-#include <strings.h>
-#include <errno.h>
-#include <signal.h>
-#include <fcntl.h>
-#include "xf86drm.h"
-
-int sigio_fd;
-
-static double usec(struct timeval *end, struct timeval *start)
-{
-    double e = end->tv_sec   * 1000000 + end->tv_usec;
-    double s = start->tv_sec * 1000000 + start->tv_usec;
-
-    return e - s;
-}
-
-static void getversion(int fd)
-{
-    drmVersionPtr version;
-    
-    version = drmGetVersion(fd);
-    if (version) {
-	printf( "Name: %s\n", version->name ? version->name : "?" );
-	printf( "    Version: %d.%d.%d\n",
-		version->version_major,
-		version->version_minor,
-		version->version_patchlevel );
-	printf( "    Date: %s\n", version->date ? version->date : "?" );
-	printf( "    Desc: %s\n", version->desc ? version->desc : "?" );
-	drmFreeVersion(version);
-    } else {
-	printf( "No driver available\n" );
-    }
-}
-	
-void handler(int fd, void *oldctx, void *newctx)
-{
-    printf("Got fd %d\n", fd);
-}
-
-void process_sigio(char *device)
-{
-    int              fd;
-
-printf("%s\n", device);
-    if ((fd = open(device, 0)) < 0) {
-printf("%d\n", errno);
-	drmError(-errno, __FUNCTION__);
-	exit(1);
-    }
-
-    sigio_fd = fd;
-    drmInstallSIGIOHandler(fd, handler);
-    for (;;) sleep(60);
-}
-
-int main(int argc, char **argv)
-{
-    int            c;
-    int            r  = 0;
-    int            fd = -1;
-    drmHandle      handle;
-    void           *address;
-    char           *pt;
-    unsigned long  count;
-    unsigned long  offset;
-    unsigned long  size;
-    drmContext     context;
-    int            loops;
-    char           buf[1024];
-    int            i;
-    drmBufInfoPtr  info;
-    drmBufMapPtr   bufs;
-    drmLockPtr     lock;
-    int            secs;
-
-    while ((c = getopt(argc, argv,
-		       "lc:vo:O:f:s:w:W:b:r:R:P:L:C:XS:B:F:")) != EOF)
-	switch (c) {
-	case 'F':
-	    count  = strtoul(optarg, NULL, 0);
-	    if (!fork()) {
-		dup(fd);
-		sleep(count);
-	    }
-	    close(fd);
-	    break;
-	case 'v': getversion(fd);                                        break;
-	case 'X':
-	    if ((r = drmCreateContext(fd, &context))) {
-		drmError(r, argv[0]);
-		return 1;
-	    }
-	    printf( "Got %d\n", context);
-	    break;
-	case 'S':
-	    process_sigio(optarg);
-	    break;
-	case 'C':
-	    if ((r = drmSwitchToContext(fd, strtoul(optarg, NULL, 0)))) {
-		drmError(r, argv[0]);
-		return 1;
-	    }
-	    break;
-	case 'c':
-	    if ((r = drmSetBusid(fd,optarg))) {
-		drmError(r, argv[0]);
-		return 1;
-	    }
-	    break;
-	case 'o':
-	    if ((fd = drmOpen(optarg, NULL)) < 0) {
-		drmError(fd, argv[0]);
-		return 1;
-	    }
-	    break;
-	case 'O':
-	    if ((fd = drmOpen(NULL, optarg)) < 0) {
-		drmError(fd, argv[0]);
-		return 1;
-	    }
-	    break;
-	case 'B':		/* Test buffer allocation */
-	    count  = strtoul(optarg, &pt, 0);
-	    size   = strtoul(pt+1, &pt, 0);
-	    secs   = strtoul(pt+1, NULL, 0);
-	    {
-		drmDMAReq      dma;
-		int            *indices, *sizes;
-
-		indices = alloca(sizeof(*indices) * count);
-		sizes   = alloca(sizeof(*sizes)   * count);
-		dma.context         = context;
-		dma.send_count      = 0;
-		dma.request_count   = count;
-		dma.request_size    = size;
-		dma.request_list    = indices;
-		dma.request_sizes   = sizes;
-		dma.flags           = DRM_DMA_WAIT;
-		if ((r = drmDMA(fd, &dma))) {
-		    drmError(r, argv[0]);
-		    return 1;
-		}
-		for (i = 0; i < dma.granted_count; i++) {
-		    printf("%5d: index = %d, size = %d\n",
-			   i, dma.request_list[i], dma.request_sizes[i]);
-		}
-		sleep(secs);
-		drmFreeBufs(fd, dma.granted_count, indices);
-	    }
-	    break;
-	case 'b':
-	    count   = strtoul(optarg, &pt, 0);
-	    size    = strtoul(pt+1, NULL, 0);
-	    if ((r = drmAddBufs(fd, count, size, 0, 0)) < 0) {
-		drmError(r, argv[0]);
-		return 1;
-	    }
-	    if (!(info = drmGetBufInfo(fd))) {
-		drmError(0, argv[0]);
-		return 1;
-	    }
-	    for (i = 0; i < info->count; i++) {
-		printf("%5d buffers of size %6d (low = %d, high = %d)\n",
-		       info->list[i].count,
-		       info->list[i].size,
-		       info->list[i].low_mark,
-		       info->list[i].high_mark);
-	    }
-	    if ((r = drmMarkBufs(fd, 0.50, 0.80))) {
-		drmError(r, argv[0]);
-		return 1;
-	    }
-	    if (!(info = drmGetBufInfo(fd))) {
-		drmError(0, argv[0]);
-		return 1;
-	    }
-	    for (i = 0; i < info->count; i++) {
-		printf("%5d buffers of size %6d (low = %d, high = %d)\n",
-		       info->list[i].count,
-		       info->list[i].size,
-		       info->list[i].low_mark,
-		       info->list[i].high_mark);
-	    }
-	    printf("===== /proc/drm/1/meminfo =====\n");
-	    sprintf(buf, "cat /proc/drm/1/meminfo");
-	    system(buf);
-#if 1
-	    if (!(bufs = drmMapBufs(fd))) {
-		drmError(0, argv[0]);
-		return 1;
-	    }
-	    printf("===============================\n");
-	    printf( "%d bufs\n", bufs->count);
-	    for (i = 0; i < bufs->count; i++) {
-		printf( "  %4d: %8d bytes at %p\n",
-			i,
-			bufs->list[i].total,
-			bufs->list[i].address);
-	    }
-	    printf("===== /proc/drm/1/vmainfo =====\n");
-	    sprintf(buf, "cat /proc/drm/1/vmainfo");
-	    system(buf);
-#endif
-	    break;
-	case 'f':
-	    offset  = strtoul(optarg, &pt, 0);
-	    size    = strtoul(pt+1, NULL, 0);
-	    handle  = 0;
-	    if ((r = drmAddMap(fd, offset, size,
-			       DRM_FRAME_BUFFER, 0, &handle))) {
-		drmError(r, argv[0]);
-		return 1;
-	    }
-	    printf("0x%08lx:0x%04lx added\n", offset, size);
-	    printf("===== /proc/drm/1/meminfo =====\n");
-	    sprintf(buf, "cat /proc/drm/1/meminfo");
-	    system(buf);
-	    break;
-	case 'r':
-	case 'R':
-	    offset  = strtoul(optarg, &pt, 0);
-	    size    = strtoul(pt+1, NULL, 0);
-	    handle  = 0;
-	    if ((r = drmAddMap(fd, offset, size,
-			       DRM_REGISTERS,
-			       c == 'R' ? DRM_READ_ONLY : 0,
-			       &handle))) {
-		drmError(r, argv[0]);
-		return 1;
-	    }
-	    printf("0x%08lx:0x%04lx added\n", offset, size);
-	    printf("===== /proc/drm/1/meminfo =====\n");
-	    sprintf(buf, "cat /proc/drm/1/meminfo");
-	    system(buf);
-	    break;
-	case 's':
-	    size = strtoul(optarg, &pt, 0);
-	    handle = 0;
-	    if ((r = drmAddMap(fd, 0, size,
-			       DRM_SHM, DRM_CONTAINS_LOCK,
-			       &handle))) {
-		drmError(r, argv[0]);
-		return 1;
-	    }
-	    printf("0x%04lx byte shm added at 0x%08lx\n", size, handle);
-	    sprintf(buf, "sysctl hw.graphics.0.vm");
-	    system(buf);
-	    break;
-	case 'P':
-	    offset  = strtoul(optarg, &pt, 0);
-	    size    = strtoul(pt+1, NULL, 0);
-	    address = NULL;
-	    if ((r = drmMap(fd, offset, size, &address))) {
-		drmError(r, argv[0]);
-		return 1;
-	    }
-	    printf("0x%08lx:0x%04lx mapped at %p for pid %d\n",
-		   offset, size, address, getpid());
-	    printf("===== hw.graphics.0.vma =====\n");
-	    sprintf(buf, "sysctl hw.graphics.0.vma");
-	    system(buf);
-	    mprotect((void *)offset, size, PROT_READ);
-	    printf("===== hw.graphics.0.vma =====\n");
-	    sprintf(buf, "sysctl hw.graphics.0.vma");
-	    system(buf);
-	    break;
-	case 'w':
-	case 'W':
-	    offset  = strtoul(optarg, &pt, 0);
-	    size    = strtoul(pt+1, NULL, 0);
-	    address = NULL;
-	    if ((r = drmMap(fd, offset, size, &address))) {
-		drmError(r, argv[0]);
-		return 1;
-	    }
-	    printf("0x%08lx:0x%04lx mapped at %p for pid %d\n",
-		   offset, size, address, getpid());
-	    printf("===== /proc/%d/maps =====\n", getpid());
-	    sprintf(buf, "cat /proc/%d/maps", getpid());
-	    system(buf);
-	    printf("===== /proc/drm/1/meminfo =====\n");
-	    sprintf(buf, "cat /proc/drm/1/meminfo");
-	    system(buf);
-	    printf("===== /proc/drm/1/vmainfo =====\n");
-	    sprintf(buf, "cat /proc/drm/1/vmainfo");
-	    system(buf);
-	    printf("===== READING =====\n");
-	    for (i = 0; i < 0x10; i++)
-		printf("%02x ", (unsigned int)((unsigned char *)address)[i]);
-	    printf("\n");
-	    if (c == 'w') {
-		printf("===== WRITING =====\n");
-		for (i = 0; i < size; i+=2) {
-		    ((char *)address)[i]   = i & 0xff;
-		    ((char *)address)[i+1] = i & 0xff;
-		}
-	    }
-	    printf("===== READING =====\n");
-	    for (i = 0; i < 0x10; i++)
-		printf("%02x ", (unsigned int)((unsigned char *)address)[i]);
-	    printf("\n");
-	    printf("===== /proc/drm/1/vmainfo =====\n");
-	    sprintf(buf, "cat /proc/drm/1/vmainfo");
-	    system(buf);
-	    break;
-	case 'L':
-	    context = strtoul(optarg, &pt, 0);
-	    offset  = strtoul(pt+1, &pt, 0);
-	    size    = strtoul(pt+1, &pt, 0);
-	    loops   = strtoul(pt+1, NULL, 0);
-	    address = NULL;
-	    if ((r = drmMap(fd, offset, size, &address))) {
-		drmError(r, argv[0]);
-		return 1;
-	    }
-	    lock       = address;
-#if 1
-	    {
-		int            counter = 0;
-		struct timeval loop_start, loop_end;
-		struct timeval lock_start, lock_end;
-		double         wt;
-#define HISTOSIZE 9
-		int            histo[HISTOSIZE];
-		int            output = 0;
-		int            fast   = 0;
-
-		if (loops < 0) {
-		    loops = -loops;
-		    ++output;
-		}
-
-		for (i = 0; i < HISTOSIZE; i++) histo[i] = 0;
-
-		gettimeofday(&loop_start, NULL);
-		for (i = 0; i < loops; i++) {
-		    gettimeofday(&lock_start, NULL);
-		    DRM_LIGHT_LOCK_COUNT(fd,lock,context,fast);
-		    gettimeofday(&lock_end, NULL);
-		    DRM_UNLOCK(fd,lock,context);
-		    ++counter;
-		    wt = usec(&lock_end, &lock_start);
-		    if      (wt <=      2.5) ++histo[8];
-		    if      (wt <       5.0) ++histo[0];
-		    else if (wt <      50.0) ++histo[1];
-		    else if (wt <     500.0) ++histo[2];
-		    else if (wt <    5000.0) ++histo[3];
-		    else if (wt <   50000.0) ++histo[4];
-		    else if (wt <  500000.0) ++histo[5];
-		    else if (wt < 5000000.0) ++histo[6];
-		    else                     ++histo[7];
-		    if (output) printf( "%.2f uSec, %d fast\n", wt, fast);
-		}
-		gettimeofday(&loop_end, NULL);
-		printf( "Average wait time = %.2f usec, %d fast\n",
-			usec(&loop_end, &loop_start) /  counter, fast);
-		printf( "%9d <=     2.5 uS\n", histo[8]);
-		printf( "%9d <        5 uS\n", histo[0]);
-		printf( "%9d <       50 uS\n", histo[1]);
-		printf( "%9d <      500 uS\n", histo[2]);
-		printf( "%9d <     5000 uS\n", histo[3]);
-		printf( "%9d <    50000 uS\n", histo[4]);
-		printf( "%9d <   500000 uS\n", histo[5]);
-		printf( "%9d <  5000000 uS\n", histo[6]);
-		printf( "%9d >= 5000000 uS\n", histo[7]);
-	    }
-#else
-	    printf( "before lock: 0x%08x\n", lock->lock);
-	    printf( "lock: 0x%08x\n", lock->lock);
-	    sleep(5);
-	    printf( "unlock: 0x%08x\n", lock->lock);
-#endif
-	    break;
-	default:
-	    fprintf( stderr, "Usage: drmstat [options]\n" );
-	    return 1;
-	}
-
-    return r; 
-}
diff --git a/bsd/drm/fops.c b/bsd/drm/fops.c
deleted file mode 100644
index ad8c86a6..00000000
--- a/bsd/drm/fops.c
+++ /dev/null
@@ -1,261 +0,0 @@
-/* fops.c -- File operations for DRM -*- c -*-
- * Created: Mon Jan  4 08:58:31 1999 by faith@precisioninsight.com
- *
- * Copyright 1999 Precision Insight, Inc., Cedar Park, Texas.
- * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
- * All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice (including the next
- * paragraph) shall be included in all copies or substantial portions of the
- * Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
- * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
- * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- * 
- * Authors:
- *    Rickard E. (Rik) Faith <faith@valinux.com>
- *    Daryll Strauss <daryll@valinux.com>
- *
- */
-
-#define __NO_VERSION__
-#include "drmP.h"
-#include <sys/signalvar.h>
-#include <sys/poll.h>
-
-drm_file_t *drm_find_file_by_proc(drm_device_t *dev, struct proc *p)
-{
-	uid_t uid = p->p_cred->p_svuid;
-	pid_t pid = p->p_pid;
-	drm_file_t *priv;
-
-	TAILQ_FOREACH(priv, &dev->files, link)
-		if (priv->pid == pid && priv->uid == uid)
-			return priv;
-	return NULL;
-}
-
-
-/* drm_open is called whenever a process opens /dev/drm. */
-
-int drm_open_helper(dev_t kdev, int flags, int fmt, struct proc *p,
-		    drm_device_t *dev)
-{
-	int	     m = minor(kdev);
-	drm_file_t   *priv;
-
-	if (flags & O_EXCL)
-		return EBUSY; /* No exclusive opens */
-
-	dev->flags = flags;
-
-	DRM_DEBUG("pid = %d, device = %p, minor = %d\n",
-		  p->p_pid, dev->device, m);
-
-	priv = drm_find_file_by_proc(dev, p);
-	if (priv) {
-		priv->refs++;
-	} else {
-		priv		    = drm_alloc(sizeof(*priv), DRM_MEM_FILES);
-		memset(priv, 0, sizeof(*priv));
-		priv->uid	    = p->p_cred->p_svuid;
-		priv->pid	    = p->p_pid;
-		priv->refs          = 1;
-		priv->minor	    = m;
-		priv->devXX	    = dev;
-		priv->ioctl_count   = 0;
-		priv->authenticated = !suser(p);
-		lockmgr(&dev->dev_lock, LK_EXCLUSIVE, 0, p);
-		TAILQ_INSERT_TAIL(&dev->files, priv, link);
-		lockmgr(&dev->dev_lock, LK_RELEASE, 0, p);
-	}
-
-	kdev->si_drv1 = dev;
-	
-	return 0;
-}
-
-int drm_write(dev_t kdev, struct uio *uio, int ioflag)
-{
-	struct proc   *p      = curproc;
-	drm_device_t  *dev    = kdev->si_drv1;
-
-	DRM_DEBUG("pid = %d, device = %p, open_count = %d\n",
-		  p->p_pid, dev->device, dev->open_count);
-	return 0;
-}
-
-/* drm_release is called whenever a process closes /dev/drm*. */
-
-int drm_close(dev_t kdev, int fflag, int devtype, struct proc *p)
-{
-	drm_device_t  *dev  = kdev->si_drv1;
-	drm_file_t    *priv;
-
-	DRM_DEBUG("pid = %d, device = %p, open_count = %d\n",
-		  p->p_pid, dev->device, dev->open_count);
-
-	priv = drm_find_file_by_proc(dev, p);
-	if (!priv) {
-		DRM_DEBUG("can't find authenticator\n");
-		return EINVAL;
-	}
-
-	if (dev->lock.hw_lock && _DRM_LOCK_IS_HELD(dev->lock.hw_lock->lock)
-	    && dev->lock.pid == p->p_pid) {
-		DRM_ERROR("Process %d dead, freeing lock for context %d\n",
-			  p->p_pid,
-			  _DRM_LOCKING_CONTEXT(dev->lock.hw_lock->lock));
-		drm_lock_free(dev,
-			      &dev->lock.hw_lock->lock,
-			      _DRM_LOCKING_CONTEXT(dev->lock.hw_lock->lock));
-		
-				/* FIXME: may require heavy-handed reset of
-                                   hardware at this point, possibly
-                                   processed via a callback to the X
-                                   server. */
-	}
-	drm_reclaim_buffers(dev, priv->pid);
-
-	funsetown(dev->buf_sigio);
-
-	lockmgr(&dev->dev_lock, LK_EXCLUSIVE, 0, p);
-	priv = drm_find_file_by_proc(dev, p);
-	if (priv) {
-		priv->refs--;
-		if (!priv->refs) {
-			TAILQ_REMOVE(&dev->files, priv, link);
-			drm_free(priv, sizeof(*priv), DRM_MEM_FILES);
-		}
-	}
-	lockmgr(&dev->dev_lock, LK_RELEASE, 0, p);
-	
-	return 0;
-}
-
-/* The drm_read and drm_write_string code (especially that which manages
-   the circular buffer), is based on Alessandro Rubini's LINUX DEVICE
-   DRIVERS (Cambridge: O'Reilly, 1998), pages 111-113. */
-
-ssize_t drm_read(dev_t kdev, struct uio *uio, int ioflag)
-{
-	drm_device_t  *dev    = kdev->si_drv1;
-	int	      left;
-	int	      avail;
-	int	      send;
-	int	      cur;
-	int	      error = 0;
-
-	DRM_DEBUG("%p, %p\n", dev->buf_rp, dev->buf_wp);
-	
-	while (dev->buf_rp == dev->buf_wp) {
-		DRM_DEBUG("  sleeping\n");
-		if (dev->flags & FASYNC) {
-			return EWOULDBLOCK;
-		}
-		error = tsleep(&dev->buf_rp, PZERO|PCATCH, "drmrd", 0);
-		if (error) {
-			DRM_DEBUG("  interrupted\n");
-			return error;
-		}
-		DRM_DEBUG("  awake\n");
-	}
-
-	left  = (dev->buf_rp + DRM_BSZ - dev->buf_wp) % DRM_BSZ;
-	avail = DRM_BSZ - left;
-	send  = DRM_MIN(avail, uio->uio_resid);
-
-	while (send) {
-		if (dev->buf_wp > dev->buf_rp) {
-			cur = DRM_MIN(send, dev->buf_wp - dev->buf_rp);
-		} else {
-			cur = DRM_MIN(send, dev->buf_end - dev->buf_rp);
-		}
-		error = uiomove(dev->buf_rp, cur, uio);
-		if (error)
-			break;
-		dev->buf_rp += cur;
-		if (dev->buf_rp == dev->buf_end) dev->buf_rp = dev->buf;
-		send -= cur;
-	}
-	
-	wakeup(&dev->buf_wp);
-
-	return error;
-}
-
-int drm_write_string(drm_device_t *dev, const char *s)
-{
-	int left   = (dev->buf_rp + DRM_BSZ - dev->buf_wp) % DRM_BSZ;
-	int send   = strlen(s);
-	int count;
-
-	DRM_DEBUG("%d left, %d to send (%p, %p)\n",
-		  left, send, dev->buf_rp, dev->buf_wp);
-	
-	if (left == 1 || dev->buf_wp != dev->buf_rp) {
-		DRM_ERROR("Buffer not empty (%d left, wp = %p, rp = %p)\n",
-			  left,
-			  dev->buf_wp,
-			  dev->buf_rp);
-	}
-
-	while (send) {
-		if (dev->buf_wp >= dev->buf_rp) {
-			count = DRM_MIN(send, dev->buf_end - dev->buf_wp);
-			if (count == left) --count; /* Leave a hole */
-		} else {
-			count = DRM_MIN(send, dev->buf_rp - dev->buf_wp - 1);
-		}
-		strncpy(dev->buf_wp, s, count);
-		dev->buf_wp += count;
-		if (dev->buf_wp == dev->buf_end) dev->buf_wp = dev->buf;
-		send -= count;
-	}
-
-	if (dev->buf_selecting) {
-		dev->buf_selecting = 0;
-		selwakeup(&dev->buf_sel);
-	}
-		
-	DRM_DEBUG("dev->buf_sigio=%p\n", dev->buf_sigio);
-	if (dev->buf_sigio) {
-		DRM_DEBUG("dev->buf_sigio->sio_pgid=%d\n", dev->buf_sigio->sio_pgid);
-		pgsigio(dev->buf_sigio, SIGIO, 0);
-	}
-
-	DRM_DEBUG("waking\n");
-	wakeup(&dev->buf_rp);
-	return 0;
-}
-
-int drm_poll(dev_t kdev, int events, struct proc *p)
-{
-	drm_device_t  *dev    = kdev->si_drv1;
-	int           s;
-	int	      revents = 0;
-
-	s = spldrm();
-	if (events & (POLLIN | POLLRDNORM)) {
-		int left  = (dev->buf_rp + DRM_BSZ - dev->buf_wp) % DRM_BSZ;
-		if (left > 0)
-			revents |= events & (POLLIN | POLLRDNORM);
-		else
-			selrecord(p, &dev->buf_sel);
-	}
-	splx(s);
-
-	return revents;
-}
diff --git a/bsd/drm/init.c b/bsd/drm/init.c
deleted file mode 100644
index 99ff70c0..00000000
--- a/bsd/drm/init.c
+++ /dev/null
@@ -1,100 +0,0 @@
-/* init.c -- Setup/Cleanup for DRM -*- c -*-
- * Created: Mon Jan  4 08:58:31 1999 by faith@precisioninsight.com
- *
- * Copyright 1999 Precision Insight, Inc., Cedar Park, Texas.
- * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
- * All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice (including the next
- * paragraph) shall be included in all copies or substantial portions of the
- * Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
- * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
- * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- * 
- * Authors:
- *    Rickard E. (Rik) Faith <faith@valinux.com>
- *
- */
-
-#define __NO_VERSION__
-#include "drmP.h"
-
-MODULE_VERSION(drm, 1);
-
-int			      drm_flags		= 0;
-
-/* drm_parse_option parses a single option.  See description for
-   drm_parse_drm for details. */
-
-static void drm_parse_option(char *s)
-{
-	char *c, *r;
-	
-	DRM_DEBUG("\"%s\"\n", s);
-	if (!s || !*s) return;
-	for (c = s; *c && *c != ':'; c++); /* find : or \0 */
-	if (*c) r = c + 1; else r = NULL;  /* remember remainder */
-	*c = '\0';			   /* terminate */
-	if (!strcmp(s, "noctx")) {
-		drm_flags |= DRM_FLAG_NOCTX;
-		DRM_INFO("Server-mediated context switching OFF\n");
-		return;
-	}
-	if (!strcmp(s, "debug")) {
-		drm_flags |= DRM_FLAG_DEBUG;
-		DRM_INFO("Debug messages ON\n");
-		return;
-	}
-	DRM_ERROR("\"%s\" is not a valid option\n", s);
-	return;
-}
-
-/* drm_parse_options parse the insmod "drm=" options, or the command-line
- * options passed to the kernel via LILO.  The grammar of the format is as
- * follows:
- *
- * drm		::= 'drm=' option_list
- * option_list	::= option [ ';' option_list ]
- * option	::= 'device:' major
- *		|   'debug' 
- *		|   'noctx'
- * major	::= INTEGER
- *
- * Note that 's' contains option_list without the 'drm=' part.
- *
- * device=major,minor specifies the device number used for /dev/drm
- *	  if major == 0 then the misc device is used
- *	  if major == 0 and minor == 0 then dynamic misc allocation is used
- * debug=on specifies that debugging messages will be printk'd
- * debug=trace specifies that each function call will be logged via printk
- * debug=off turns off all debugging options
- *
- */
-
-void drm_parse_options(char *s)
-{
-	char *h, *t, *n;
-	
-	DRM_DEBUG("\"%s\"\n", s ?: "");
-	if (!s || !*s) return;
-
-	for (h = t = n = s; h && *h; h = n) {
-		for (; *t && *t != ';'; t++);	       /* find ; or \0 */
-		if (*t) n = t + 1; else n = NULL;      /* remember next */
-		*t = '\0';			       /* terminate */
-		drm_parse_option(h);		       /* parse */
-	}
-}
diff --git a/bsd/drm/ioctl.c b/bsd/drm/ioctl.c
deleted file mode 100644
index 656baffd..00000000
--- a/bsd/drm/ioctl.c
+++ /dev/null
@@ -1,120 +0,0 @@
-/* ioctl.c -- IOCTL processing for DRM -*- c -*-
- * Created: Fri Jan  8 09:01:26 1999 by faith@precisioninsight.com
- *
- * Copyright 1999 Precision Insight, Inc., Cedar Park, Texas.
- * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
- * All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice (including the next
- * paragraph) shall be included in all copies or substantial portions of the
- * Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
- * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
- * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- * 
- * Authors:
- *    Rickard E. (Rik) Faith <faith@valinux.com>
- *
- */
-
-#define __NO_VERSION__
-#include "drmP.h"
-#include <sys/bus.h>
-#include <pci/pcivar.h>
-
-int
-drm_irq_busid(dev_t kdev, u_long cmd, caddr_t data, int flags, struct proc *p)
-{
-	drm_irq_busid_t id;
-	devclass_t pci;
-	device_t bus, dev;
-	device_t *kids;
-	int error, i, num_kids;
-
-	id = *(drm_irq_busid_t *) data;
-	pci = devclass_find("pci");
-	if (!pci)
-		return ENOENT;
-	bus = devclass_get_device(pci, id.busnum);
-	if (!bus)
-		return ENOENT;
-	error = device_get_children(bus, &kids, &num_kids);
-	if (error)
-		return error;
-
-	dev = 0;
-	for (i = 0; i < num_kids; i++) {
-		dev = kids[i];
-		if (pci_get_slot(dev) == id.devnum
-		    && pci_get_function(dev) == id.funcnum)
-			break;
-	}
-
-	free(kids, M_TEMP);
-
-	if (i != num_kids)
-		id.irq = pci_get_irq(dev);
-	else
-		id.irq = 0;
-
-	DRM_DEBUG("%d:%d:%d => IRQ %d\n",
-		  id.busnum, id.devnum, id.funcnum, id.irq);
-	*(drm_irq_busid_t *) data = id;
-
-	return 0;
-}
-
-int
-drm_getunique(dev_t kdev, u_long cmd, caddr_t data, int flags, struct proc *p)
-{
-	drm_device_t	 *dev	 = kdev->si_drv1;
-	drm_unique_t	 u;
-	int		 error;
-
-	u = *(drm_unique_t *) data;
-	if (u.unique_len >= dev->unique_len) {
-		error = copyout(dev->unique, u.unique, dev->unique_len);
-		if (error)
-			return error;
-	}
-	u.unique_len = dev->unique_len;
-	*(drm_unique_t *) data = u;
-	return 0;
-}
-
-int
-drm_setunique(dev_t kdev, u_long cmd, caddr_t data, int flags, struct proc *p)
-{
-	drm_device_t	 *dev	 = kdev->si_drv1;
-	drm_unique_t	 u;
-	int		 error;
-
-	if (dev->unique_len || dev->unique) return EBUSY;
-
-	u = *(drm_unique_t *) data;
-	
-	dev->unique_len = u.unique_len;
-	dev->unique	= drm_alloc(u.unique_len + 1, DRM_MEM_DRIVER);
-	error = copyin(u.unique, dev->unique, dev->unique_len);
-	if (error)
-		return error;
-	dev->unique[dev->unique_len] = '\0';
-
-	dev->devname = drm_alloc(strlen(dev->name) + strlen(dev->unique) + 2,
-				 DRM_MEM_DRIVER);
-	sprintf(dev->devname, "%s@%s", dev->name, dev->unique);
-
-	return 0;
-}
diff --git a/bsd/drm/lists.c b/bsd/drm/lists.c
deleted file mode 100644
index b9722973..00000000
--- a/bsd/drm/lists.c
+++ /dev/null
@@ -1,278 +0,0 @@
-/* lists.c -- Buffer list handling routines -*- c -*-
- * Created: Mon Apr 19 20:54:22 1999 by faith@precisioninsight.com
- *
- * Copyright 1999 Precision Insight, Inc., Cedar Park, Texas.
- * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
- * All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice (including the next
- * paragraph) shall be included in all copies or substantial portions of the
- * Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
- * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
- * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- * 
- * Authors:
- *    Rickard E. (Rik) Faith <faith@valinux.com>
- *
- */
-
-#define __NO_VERSION__
-#include "drmP.h"
-
-int drm_waitlist_create(drm_waitlist_t *bl, int count)
-{
-	DRM_DEBUG("%d\n", count);
-	if (bl->count) return EINVAL;
-	
-	bl->count      = count;
-	bl->bufs       = drm_alloc((bl->count + 2) * sizeof(*bl->bufs),
-				   DRM_MEM_BUFLISTS);
-	bl->rp	       = bl->bufs;
-	bl->wp	       = bl->bufs;
-	bl->end	       = &bl->bufs[bl->count+1];
-	simple_lock_init(&bl->write_lock);
-	simple_lock_init(&bl->read_lock);
-	return 0;
-}
-
-int drm_waitlist_destroy(drm_waitlist_t *bl)
-{
-	DRM_DEBUG("\n");
-	if (bl->rp != bl->wp) return EINVAL;
-	if (bl->bufs) drm_free(bl->bufs,
-			       (bl->count + 2) * sizeof(*bl->bufs),
-			       DRM_MEM_BUFLISTS);
-	bl->count = 0;
-	bl->bufs  = NULL;
-	bl->rp	  = NULL;
-	bl->wp	  = NULL;
-	bl->end	  = NULL;
-	return 0;
-}
-
-int drm_waitlist_put(drm_waitlist_t *bl, drm_buf_t *buf)
-{							
-	int	      left;
-	int	      s;
-
-	left = DRM_LEFTCOUNT(bl);
-	DRM_DEBUG("put %d (%d left, rp = %p, wp = %p)\n",
-		  buf->idx, left, bl->rp, bl->wp);
-	if (!left) {
-		DRM_ERROR("Overflow while adding buffer %d from pid %d\n",
-			  buf->idx, buf->pid);
-		return EINVAL;
-	}
-#if DRM_DMA_HISTOGRAM
-	getnanotime(&buf->time_queued);
-#endif
-	buf->list	 = DRM_LIST_WAIT;
-	
-	simple_lock(&bl->write_lock);
-	s = spldrm();
-	*bl->wp = buf;
-	if (++bl->wp >= bl->end) bl->wp = bl->bufs;
-	splx(s);
-	simple_unlock(&bl->write_lock);
-	
-	return 0;
-}
-
-drm_buf_t *drm_waitlist_get(drm_waitlist_t *bl)
-{
-	drm_buf_t     *buf;
-	int	       s;
-
-	simple_lock(&bl->read_lock);
-	s = spldrm();
-	buf = *bl->rp;
-	if (bl->rp == bl->wp) {
-		splx(s);
-		simple_unlock(&bl->read_lock);
-		return NULL;
-	}				     
-	if (++bl->rp >= bl->end) bl->rp = bl->bufs;
-	splx(s);
-	simple_unlock(&bl->read_lock);
-	
-	DRM_DEBUG("get %d\n", buf->idx);
-	return buf;
-}
-
-int drm_freelist_create(drm_freelist_t *bl, int count)
-{
-	DRM_DEBUG("\n");
-	atomic_set(&bl->count, 0);
-	bl->next      = NULL;
-	bl->waiting   = 0;
-	bl->low_mark  = 0;
-	bl->high_mark = 0;
-	atomic_set(&bl->wfh,   0);
-/*	bl->lock	= SPIN_LOCK_UNLOCKED; */
-	++bl->initialized;
-	return 0;
-}
-
-int drm_freelist_destroy(drm_freelist_t *bl)
-{
-	DRM_DEBUG("\n");
-	atomic_set(&bl->count, 0);
-	bl->next = NULL;
-	return 0;
-}
-
-int drm_freelist_put(drm_device_t *dev, drm_freelist_t *bl, drm_buf_t *buf)
-{
-	unsigned int	 old;
-	unsigned int	 new;
-	char		 failed;
-	int		 count = 0;
-	drm_device_dma_t *dma = dev->dma;
-
-	if (!dma) {
-		DRM_ERROR("No DMA support\n");
-		return 1;
-	}
-
-	if (buf->waiting || buf->pending || buf->list == DRM_LIST_FREE) {
-		DRM_ERROR("Freed buffer %d: w%d, p%d, l%d\n",
-			  buf->idx, buf->waiting, buf->pending, buf->list);
-	}
-	DRM_DEBUG("%d, count = %d, wfh = %d, w%d, p%d\n",
-		  buf->idx, atomic_read(&bl->count), atomic_read(&bl->wfh),
-		  buf->waiting, buf->pending);
-	if (!bl) return 1;
-#if DRM_DMA_HISTOGRAM
-	getnanotime(&buf->time_freed);
-	drm_histogram_compute(dev, buf);
-#endif
-	buf->list	= DRM_LIST_FREE;
-/*
-	do {
-		old	  = (unsigned long)bl->next;
-		buf->next = (void *)old;
-		new	  = (unsigned long)buf;
-		_DRM_CAS(&bl->next, old, new, failed);
-		if (++count > DRM_LOOPING_LIMIT) {
-			DRM_ERROR("Looping\n");
-			return 1;
-		}
-	} while (failed);
-*/
-
-	simple_lock(&bl->lock);
-	buf->next	= bl->next;
-	bl->next	= buf;
-	simple_unlock(&bl->lock);
-
-	atomic_inc(&bl->count);
-	if (atomic_read(&bl->count) > dma->buf_count) {
-		DRM_ERROR("%d of %d buffers free after addition of %d\n",
-			  atomic_read(&bl->count), dma->buf_count, buf->idx);
-		return 1;
-	}
-				/* Check for high water mark */
-	if (atomic_read(&bl->wfh) && atomic_read(&bl->count)>=bl->high_mark) {
-		atomic_set(&bl->wfh, 0);
-		if (bl->waiting)
-			wakeup(&bl->waiting);
-	}
-	return 0;
-}
-
-static drm_buf_t *drm_freelist_try(drm_freelist_t *bl)
-{
-	unsigned int	  old;
-	unsigned int	  new;
-	char		  failed;
-	drm_buf_t	  *buf;
-	int		  count = 0;
-
-	if (!bl) return NULL;
-	
-				/* Get buffer */
-/*
-	do {
-		old = (unsigned int)bl->next;
-		if (!old) {
-			return NULL;
-		}
-		new = (unsigned long)bl->next->next;
-		_DRM_CAS(&bl->next, old, new, failed);
-		if (++count > DRM_LOOPING_LIMIT) {
-			DRM_ERROR("Looping\n");
-			return NULL;
-		}
-	} while (failed);
-	atomic_dec(&bl->count);
-	
-	buf	  = (drm_buf_t *)old;
-*/
-	simple_lock(&bl->lock);
-	if(!bl->next){
-		simple_unlock(&bl->lock);
-		return NULL;
-	}
-	buf	= bl->next;
-	bl->next = bl->next->next;
-	simple_unlock(&bl->lock);
-	atomic_dec(&bl->count);
-	buf->next = NULL;
-	buf->list = DRM_LIST_NONE;
-	DRM_DEBUG("%d, count = %d, wfh = %d, w%d, p%d\n",
-		  buf->idx, atomic_read(&bl->count), atomic_read(&bl->wfh),
-		  buf->waiting, buf->pending);
-	if (buf->waiting || buf->pending) {
-		DRM_ERROR("Free buffer %d: w%d, p%d, l%d\n",
-			  buf->idx, buf->waiting, buf->pending, buf->list);
-	}
-	
-	return buf;
-}
-
-drm_buf_t *drm_freelist_get(drm_freelist_t *bl, int block)
-{
-	drm_buf_t	  *buf	= NULL;
-	int		   error;
-
-	if (!bl || !bl->initialized) return NULL;
-	
-				/* Check for low water mark */
-	if (atomic_read(&bl->count) <= bl->low_mark) /* Became low */
-		atomic_set(&bl->wfh, 1);
-	if (atomic_read(&bl->wfh)) {
-		DRM_DEBUG("Block = %d, count = %d, wfh = %d\n",
-			  block, atomic_read(&bl->count),
-			  atomic_read(&bl->wfh));
-		if (block) {
-			atomic_inc(&bl->waiting);
-			for (;;) {
-				if (!atomic_read(&bl->wfh)
-				    && (buf = drm_freelist_try(bl))) break;
-				error = tsleep(&bl->waiting, PZERO|PCATCH,
-					       "drmfg", 0);
-				if (error)
-					break;
-			}
-			atomic_dec(&bl->waiting);
-		}
-		return buf;
-	}
-		
-	DRM_DEBUG("Count = %d, wfh = %d\n",
-		  atomic_read(&bl->count), atomic_read(&bl->wfh));
-	return drm_freelist_try(bl);
-}
diff --git a/bsd/drm/lock.c b/bsd/drm/lock.c
deleted file mode 100644
index ec295b2b..00000000
--- a/bsd/drm/lock.c
+++ /dev/null
@@ -1,223 +0,0 @@
-/* lock.c -- IOCTLs for locking -*- c -*-
- * Created: Tue Feb  2 08:37:54 1999 by faith@precisioninsight.com
- *
- * Copyright 1999 Precision Insight, Inc., Cedar Park, Texas.
- * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
- * All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice (including the next
- * paragraph) shall be included in all copies or substantial portions of the
- * Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
- * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
- * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- * 
- * Authors:
- *    Rickard E. (Rik) Faith <faith@valinux.com>
- *
- */
-
-#define __NO_VERSION__
-#include "drmP.h"
-
-int
-drm_block(dev_t kdev, u_long cmd, caddr_t data, int flags, struct proc *p)
-{
-	DRM_DEBUG("\n");
-	return 0;
-}
-
-int
-drm_unblock(dev_t kdev, u_long cmd, caddr_t data, int flags, struct proc *p)
-{
-	DRM_DEBUG("\n");
-	return 0;
-}
-
-int drm_lock_take(__volatile__ unsigned int *lock, unsigned int context)
-{
-	unsigned int old;
-	unsigned int new;
-	char	     failed;
-
-	DRM_DEBUG("%d attempts\n", context);
-	do {
-		old = *lock;
-		if (old & _DRM_LOCK_HELD) new = old | _DRM_LOCK_CONT;
-		else			  new = context | _DRM_LOCK_HELD;
-		_DRM_CAS(lock, old, new, failed);
-	} while (failed);
-	if (_DRM_LOCKING_CONTEXT(old) == context) {
-		if (old & _DRM_LOCK_HELD) {
-			if (context != DRM_KERNEL_CONTEXT) {
-				DRM_ERROR("%d holds heavyweight lock\n",
-					  context);
-			}
-			return 0;
-		}
-	}
-	if (new == (context | _DRM_LOCK_HELD)) {
-				/* Have lock */
-		DRM_DEBUG("%d\n", context);
-		return 1;
-	}
-	DRM_DEBUG("%d unable to get lock held by %d\n",
-		  context, _DRM_LOCKING_CONTEXT(old));
-	return 0;
-}
-
-/* This takes a lock forcibly and hands it to context.	Should ONLY be used
-   inside *_unlock to give lock to kernel before calling *_dma_schedule. */
-int drm_lock_transfer(drm_device_t *dev,
-		      __volatile__ unsigned int *lock, unsigned int context)
-{
-	unsigned int old;
-	unsigned int new;
-	char	     failed;
-
-	dev->lock.pid = 0;
-	do {
-		old = *lock;
-		new = context | _DRM_LOCK_HELD;
-		_DRM_CAS(lock, old, new, failed);
-	} while (failed);
-	DRM_DEBUG("%d => %d\n", _DRM_LOCKING_CONTEXT(old), context);
-	return 1;
-}
-
-int drm_lock_free(drm_device_t *dev,
-		  __volatile__ unsigned int *lock, unsigned int context)
-{
-	unsigned int old;
-	unsigned int new;
-	char	     failed;
-	pid_t        pid = dev->lock.pid;
-
-	DRM_DEBUG("%d\n", context);
-	dev->lock.pid = 0;
-	do {
-		old = *lock;
-		new = 0;
-		_DRM_CAS(lock, old, new, failed);
-	} while (failed);
-	if (_DRM_LOCK_IS_HELD(old) && _DRM_LOCKING_CONTEXT(old) != context) {
-		DRM_ERROR("%d freed heavyweight lock held by %d (pid %d)\n",
-			  context,
-			  _DRM_LOCKING_CONTEXT(old),
-			  pid);
-		return 1;
-	}
-	wakeup(&dev->lock.lock_queue);
-	return 0;
-}
-
-static int drm_flush_queue(drm_device_t *dev, int context)
-{
-	int		  ret	= 0;
-	int		  error;
-	drm_queue_t	  *q	= dev->queuelist[context];
-	
-	DRM_DEBUG("\n");
-	
-	atomic_inc(&q->use_count);
-	if (atomic_read(&q->use_count) > 1) {
-		atomic_inc(&q->block_write);
-		atomic_inc(&q->block_count);
-		for (;;) {
-			if (!DRM_BUFCOUNT(&q->waitlist)) break;
-			error = tsleep(&q->flush_queue, PCATCH|PZERO, "drmfq", 0);
-			if (error)
-				return error;
-		}
-		atomic_dec(&q->block_count);
-	}
-	atomic_dec(&q->use_count);
-	atomic_inc(&q->total_flushed);
-		
-				/* NOTE: block_write is still incremented!
-				   Use drm_flush_unlock_queue to decrement. */
-	return ret;
-}
-
-static int drm_flush_unblock_queue(drm_device_t *dev, int context)
-{
-	drm_queue_t	  *q	= dev->queuelist[context];
-	
-	DRM_DEBUG("\n");
-	
-	atomic_inc(&q->use_count);
-	if (atomic_read(&q->use_count) > 1) {
-		if (atomic_read(&q->block_write)) {
-			atomic_dec(&q->block_write);
-			wakeup(&q->write_queue);
-		}
-	}
-	atomic_dec(&q->use_count);
-	return 0;
-}
-
-int drm_flush_block_and_flush(drm_device_t *dev, int context,
-			      drm_lock_flags_t flags)
-{
-	int ret = 0;
-	int i;
-	
-	DRM_DEBUG("\n");
-	
-	if (flags & _DRM_LOCK_FLUSH) {
-		ret = drm_flush_queue(dev, DRM_KERNEL_CONTEXT);
-		if (!ret) ret = drm_flush_queue(dev, context);
-	}
-	if (flags & _DRM_LOCK_FLUSH_ALL) {
-		for (i = 0; !ret && i < dev->queue_count; i++) {
-			ret = drm_flush_queue(dev, i);
-		}
-	}
-	return ret;
-}
-
-int drm_flush_unblock(drm_device_t *dev, int context, drm_lock_flags_t flags)
-{
-	int ret = 0;
-	int i;
-	
-	DRM_DEBUG("\n");
-	
-	if (flags & _DRM_LOCK_FLUSH) {
-		ret = drm_flush_unblock_queue(dev, DRM_KERNEL_CONTEXT);
-		if (!ret) ret = drm_flush_unblock_queue(dev, context);
-	}
-	if (flags & _DRM_LOCK_FLUSH_ALL) {
-		for (i = 0; !ret && i < dev->queue_count; i++) {
-			ret = drm_flush_unblock_queue(dev, i);
-		}
-	}
-		
-	return ret;
-}
-
-int drm_finish(dev_t kdev, u_long cmd, caddr_t data, int flags, struct proc *p)
-{
-	drm_device_t	  *dev	  = kdev->si_drv1;
-	int		  ret	  = 0;
-	drm_lock_t	  lock;
-
-	DRM_DEBUG("\n");
-
-	lock = *(drm_lock_t *) data;
-	ret = drm_flush_block_and_flush(dev, lock.context, lock.flags);
-	drm_flush_unblock(dev, lock.context, lock.flags);
-	return ret;
-}
diff --git a/bsd/drm/memory.c b/bsd/drm/memory.c
deleted file mode 100644
index f60e2128..00000000
--- a/bsd/drm/memory.c
+++ /dev/null
@@ -1,458 +0,0 @@
-/* memory.c -- Memory management wrappers for DRM -*- c -*-
- * Created: Thu Feb  4 14:00:34 1999 by faith@precisioninsight.com
- *
- * Copyright 1999 Precision Insight, Inc., Cedar Park, Texas.
- * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
- * All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice (including the next
- * paragraph) shall be included in all copies or substantial portions of the
- * Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
- * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
- * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- * 
- * Authors:
- *    Rickard E. (Rik) Faith <faith@valinux.com>
- *
- */
-
-#define __NO_VERSION__
-#include "drmP.h"
-
-#include <vm/vm.h>
-#include <vm/pmap.h>
-#ifdef DRM_AGP
-#include <sys/agpio.h>
-#endif
-
-MALLOC_DEFINE(M_DRM, "drm", "DRM Data Structures");
-
-typedef struct drm_mem_stats {
-	const char	  *name;
-	int		  succeed_count;
-	int		  free_count;
-	int		  fail_count;
-	unsigned long	  bytes_allocated;
-	unsigned long	  bytes_freed;
-} drm_mem_stats_t;
-
-#ifdef SMP
-static struct simplelock  drm_mem_lock;
-#endif
-static unsigned long	  drm_ram_available = 0;
-static unsigned long	  drm_ram_used	    = 0;
-static drm_mem_stats_t	  drm_mem_stats[]   = {
-	[DRM_MEM_DMA]	    = { "dmabufs"  },
-	[DRM_MEM_SAREA]	    = { "sareas"   },
-	[DRM_MEM_DRIVER]    = { "driver"   },
-	[DRM_MEM_MAGIC]	    = { "magic"	   },
-	[DRM_MEM_IOCTLS]    = { "ioctltab" },
-	[DRM_MEM_MAPS]	    = { "maplist"  },
-	[DRM_MEM_VMAS]	    = { "vmalist"  },
-	[DRM_MEM_BUFS]	    = { "buflist"  },
-	[DRM_MEM_SEGS]	    = { "seglist"  },
-	[DRM_MEM_PAGES]	    = { "pagelist" },
-	[DRM_MEM_FILES]	    = { "files"	   },
-	[DRM_MEM_QUEUES]    = { "queues"   },
-	[DRM_MEM_CMDS]	    = { "commands" },
-	[DRM_MEM_MAPPINGS]  = { "mappings" },
-	[DRM_MEM_BUFLISTS]  = { "buflists" },
-	[DRM_MEM_AGPLISTS]  = { "agplist"  },
-	[DRM_MEM_TOTALAGP]  = { "totalagp" },
-	[DRM_MEM_BOUNDAGP]  = { "boundagp" },
-	[DRM_MEM_CTXBITMAP] = { "ctxbitmap"},
-	{ NULL, 0, }		/* Last entry must be null */
-};
-
-void drm_mem_init(void)
-{
-	drm_mem_stats_t *mem;
-	
-	for (mem = drm_mem_stats; mem->name; ++mem) {
-		mem->succeed_count   = 0;
-		mem->free_count	     = 0;
-		mem->fail_count	     = 0;
-		mem->bytes_allocated = 0;
-		mem->bytes_freed     = 0;
-	}
-	
-	drm_ram_available = 0; /* si.totalram; */
-	drm_ram_used	  = 0;
-}
-
-/* drm_mem_info is called whenever a process reads /dev/drm/mem. */
-
-static int _drm_mem_info DRM_SYSCTL_HANDLER_ARGS
-{
-	drm_mem_stats_t *pt;
-	char buf[128];
-	int error;
-
-	DRM_SYSCTL_PRINT("		  total counts			"
-		       " |    outstanding  \n");
-	DRM_SYSCTL_PRINT("type	   alloc freed fail	bytes	   freed"
-		       " | allocs      bytes\n\n");
-	DRM_SYSCTL_PRINT("%-9.9s %5d %5d %4d %10lu	    |\n",
-		       "system", 0, 0, 0, drm_ram_available);
-	DRM_SYSCTL_PRINT("%-9.9s %5d %5d %4d %10lu	    |\n",
-		       "locked", 0, 0, 0, drm_ram_used);
-	DRM_SYSCTL_PRINT("\n");
-	for (pt = drm_mem_stats; pt->name; pt++) {
-		DRM_SYSCTL_PRINT("%-9.9s %5d %5d %4d %10lu %10lu | %6d %10ld\n",
-			       pt->name,
-			       pt->succeed_count,
-			       pt->free_count,
-			       pt->fail_count,
-			       pt->bytes_allocated,
-			       pt->bytes_freed,
-			       pt->succeed_count - pt->free_count,
-			       (long)pt->bytes_allocated
-			       - (long)pt->bytes_freed);
-	}
-	SYSCTL_OUT(req, "", 1);
-	
-	return 0;
-}
-
-int drm_mem_info DRM_SYSCTL_HANDLER_ARGS
-{
-	int ret;
-	
-	simple_lock(&drm_mem_lock);
-	ret = _drm_mem_info(oidp, arg1, arg2, req);
-	simple_unlock(&drm_mem_lock);
-	return ret;
-}
-
-void *drm_alloc(size_t size, int area)
-{
-	void *pt;
-	
-	if (!size) {
-		DRM_MEM_ERROR(area, "Allocating 0 bytes\n");
-		return NULL;
-	}
-	
-	if (!(pt = malloc(size, M_DRM, M_NOWAIT))) {
-		simple_lock(&drm_mem_lock);
-		++drm_mem_stats[area].fail_count;
-		simple_unlock(&drm_mem_lock);
-		return NULL;
-	}
-	simple_lock(&drm_mem_lock);
-	++drm_mem_stats[area].succeed_count;
-	drm_mem_stats[area].bytes_allocated += size;
-	simple_unlock(&drm_mem_lock);
-	return pt;
-}
-
-void *drm_realloc(void *oldpt, size_t oldsize, size_t size, int area)
-{
-	void *pt;
-	
-	if (!(pt = drm_alloc(size, area))) return NULL;
-	if (oldpt && oldsize) {
-		memcpy(pt, oldpt, oldsize);
-		drm_free(oldpt, oldsize, area);
-	}
-	return pt;
-}
-
-char *drm_strdup(const char *s, int area)
-{
-	char *pt;
-	int	 length = s ? strlen(s) : 0;
-	
-	if (!(pt = drm_alloc(length+1, area))) return NULL;
-	strcpy(pt, s);
-	return pt;
-}
-
-void drm_strfree(char *s, int area)
-{
-	unsigned int size;
-	
-	if (!s) return;
-	
-	size = 1 + (s ? strlen(s) : 0);
-	drm_free((void *)s, size, area);
-}
-
-void drm_free(void *pt, size_t size, int area)
-{
-	int alloc_count;
-	int free_count;
-	
-	if (!pt) DRM_MEM_ERROR(area, "Attempt to free NULL pointer\n");
-	else	 free(pt, M_DRM);
-	simple_lock(&drm_mem_lock);
-	drm_mem_stats[area].bytes_freed += size;
-	free_count  = ++drm_mem_stats[area].free_count;
-	alloc_count =	drm_mem_stats[area].succeed_count;
-	simple_unlock(&drm_mem_lock);
-	if (free_count > alloc_count) {
-		DRM_MEM_ERROR(area, "Excess frees: %d frees, %d allocs\n",
-			      free_count, alloc_count);
-	}
-}
-
-unsigned long drm_alloc_pages(int order, int area)
-{
-	vm_offset_t address;
-	unsigned long bytes	  = PAGE_SIZE << order;
-	unsigned long addr;
-	unsigned int  sz;
-	
-	simple_lock(&drm_mem_lock);
-	if (drm_ram_used > +(DRM_RAM_PERCENT * drm_ram_available) / 100) {
-		simple_unlock(&drm_mem_lock);
-		return 0;
-	}
-	simple_unlock(&drm_mem_lock);
-	
-	address = (vm_offset_t) contigmalloc(1<<order, M_DRM, M_WAITOK, 0, ~0, 1, 0);
-	if (!address) {
-		simple_lock(&drm_mem_lock);
-		++drm_mem_stats[area].fail_count;
-		simple_unlock(&drm_mem_lock);
-		return 0;
-	}
-	simple_lock(&drm_mem_lock);
-	++drm_mem_stats[area].succeed_count;
-	drm_mem_stats[area].bytes_allocated += bytes;
-	drm_ram_used		            += bytes;
-	simple_unlock(&drm_mem_lock);
-	
-	
-				/* Zero outside the lock */
-	memset((void *)address, 0, bytes);
-	
-				/* Reserve */
-	for (addr = address, sz = bytes;
-	     sz > 0;
-	     addr += PAGE_SIZE, sz -= PAGE_SIZE) {
-		/* mem_map_reserve(MAP_NR(addr));*/
-	}
-	
-	return address;
-}
-
-void drm_free_pages(unsigned long address, int order, int area)
-{
-	unsigned long bytes = PAGE_SIZE << order;
-	int		  alloc_count;
-	int		  free_count;
-	unsigned long addr;
-	unsigned int  sz;
-	
-	if (!address) {
-		DRM_MEM_ERROR(area, "Attempt to free address 0\n");
-	} else {
-				/* Unreserve */
-		for (addr = address, sz = bytes;
-		     sz > 0;
-		     addr += PAGE_SIZE, sz -= PAGE_SIZE) {
-			/* mem_map_unreserve(MAP_NR(addr));*/
-		}
-		contigfree((void *) address, bytes, M_DRM);
-	}
-	
-	simple_lock(&drm_mem_lock);
-	free_count  = ++drm_mem_stats[area].free_count;
-	alloc_count =	drm_mem_stats[area].succeed_count;
-	drm_mem_stats[area].bytes_freed += bytes;
-	drm_ram_used			-= bytes;
-	simple_unlock(&drm_mem_lock);
-	if (free_count > alloc_count) {
-		DRM_MEM_ERROR(area,
-			      "Excess frees: %d frees, %d allocs\n",
-			      free_count, alloc_count);
-	}
-}
-
-void *drm_ioremap(unsigned long offset, unsigned long size)
-{
-	void *pt;
-	
-	if (!size) {
-		DRM_MEM_ERROR(DRM_MEM_MAPPINGS,
-			      "Mapping 0 bytes at 0x%08lx\n", offset);
-		return NULL;
-	}
-	
-	if (!(pt = pmap_mapdev(offset, size))) {
-		simple_lock(&drm_mem_lock);
-		++drm_mem_stats[DRM_MEM_MAPPINGS].fail_count;
-		simple_unlock(&drm_mem_lock);
-		return NULL;
-	}
-	simple_lock(&drm_mem_lock);
-	++drm_mem_stats[DRM_MEM_MAPPINGS].succeed_count;
-	drm_mem_stats[DRM_MEM_MAPPINGS].bytes_allocated += size;
-	simple_unlock(&drm_mem_lock);
-	return pt;
-}
-
-void drm_ioremapfree(void *pt, unsigned long size)
-{
-	int alloc_count;
-	int free_count;
-	
-	if (!pt)
-		DRM_MEM_ERROR(DRM_MEM_MAPPINGS,
-			      "Attempt to free NULL pointer\n");
-	else
-		pmap_unmapdev((vm_offset_t) pt, size);
-	
-	simple_lock(&drm_mem_lock);
-	drm_mem_stats[DRM_MEM_MAPPINGS].bytes_freed += size;
-	free_count  = ++drm_mem_stats[DRM_MEM_MAPPINGS].free_count;
-	alloc_count =	drm_mem_stats[DRM_MEM_MAPPINGS].succeed_count;
-	simple_unlock(&drm_mem_lock);
-	if (free_count > alloc_count) {
-		DRM_MEM_ERROR(DRM_MEM_MAPPINGS,
-			      "Excess frees: %d frees, %d allocs\n",
-			      free_count, alloc_count);
-	}
-}
-
-#ifdef DRM_AGP
-void *drm_alloc_agp(int pages, u_int32_t type)
-{
-	device_t dev = agp_find_device();
-	void *handle;
-
-	if (!dev)
-		return NULL;
-
-	if (!pages) {
-		DRM_MEM_ERROR(DRM_MEM_TOTALAGP, "Allocating 0 pages\n");
-		return NULL;
-	}
-	
-	if ((handle = agp_alloc_memory(dev, type, pages << AGP_PAGE_SHIFT))) {
-		simple_lock(&drm_mem_lock);
-		++drm_mem_stats[DRM_MEM_TOTALAGP].succeed_count;
-		drm_mem_stats[DRM_MEM_TOTALAGP].bytes_allocated
-			+= pages << PAGE_SHIFT;
-		simple_unlock(&drm_mem_lock);
-		return handle;
-	}
-	simple_lock(&drm_mem_lock);
-	++drm_mem_stats[DRM_MEM_TOTALAGP].fail_count;
-	simple_unlock(&drm_mem_lock);
-	return NULL;
-}
-
-int drm_free_agp(void *handle, int pages)
-{
-	device_t dev = agp_find_device();
-	int           alloc_count;
-	int           free_count;
-	int           retval = EINVAL;
-
-	if (!dev)
-		return EINVAL;
-
-	if (!handle) {
-		DRM_MEM_ERROR(DRM_MEM_TOTALAGP,
-			      "Attempt to free NULL AGP handle\n");
-		return retval;
-	}
-	
-	agp_free_memory(dev, handle);
-	simple_lock(&drm_mem_lock);
-	free_count  = ++drm_mem_stats[DRM_MEM_TOTALAGP].free_count;
-	alloc_count =   drm_mem_stats[DRM_MEM_TOTALAGP].succeed_count;
-	drm_mem_stats[DRM_MEM_TOTALAGP].bytes_freed
-		+= pages << PAGE_SHIFT;
-	simple_unlock(&drm_mem_lock);
-	if (free_count > alloc_count) {
-		DRM_MEM_ERROR(DRM_MEM_TOTALAGP,
-			      "Excess frees: %d frees, %d allocs\n",
-			      free_count, alloc_count);
-	}
-	return 0;
-}
-
-int drm_bind_agp(void *handle, unsigned int start)
-{
-	device_t dev = agp_find_device();
-	int retcode  = EINVAL;
-	struct agp_memory_info info;
-
-	DRM_DEBUG("drm_bind_agp called\n");
-
-	if (!dev)
-		return EINVAL;
-
-	if (!handle) {
-		DRM_MEM_ERROR(DRM_MEM_BOUNDAGP,
-			      "Attempt to bind NULL AGP handle\n");
-		return retcode;
-	}
-
-	if (!(retcode = agp_bind_memory(dev, handle,
-					start << AGP_PAGE_SHIFT))) {
-		simple_lock(&drm_mem_lock);
-		++drm_mem_stats[DRM_MEM_BOUNDAGP].succeed_count;
-		agp_memory_info(dev, handle, &info);
-		drm_mem_stats[DRM_MEM_BOUNDAGP].bytes_allocated
-			+= info.ami_size;
-		simple_unlock(&drm_mem_lock);
-		DRM_DEBUG("drm_agp.bind_memory: retcode %d\n", retcode);
-		return retcode;
-	}
-	simple_lock(&drm_mem_lock);
-	++drm_mem_stats[DRM_MEM_BOUNDAGP].fail_count;
-	simple_unlock(&drm_mem_lock);
-	return retcode;
-}
-
-int drm_unbind_agp(void *handle)
-{
-	device_t dev = agp_find_device();
-	int alloc_count;
-	int free_count;
-	int retcode = EINVAL;
-	struct agp_memory_info info;
-	
-	if (!dev)
-		return EINVAL;
-
-	if (!handle) {
-		DRM_MEM_ERROR(DRM_MEM_BOUNDAGP,
-			      "Attempt to unbind NULL AGP handle\n");
-		return retcode;
-	}
-
-	
-	agp_memory_info(dev, handle, &info);
-	if ((retcode = agp_unbind_memory(dev, handle)))
-		return retcode;
-	simple_lock(&drm_mem_lock);
-	free_count  = ++drm_mem_stats[DRM_MEM_BOUNDAGP].free_count;
-	alloc_count = drm_mem_stats[DRM_MEM_BOUNDAGP].succeed_count;
-	drm_mem_stats[DRM_MEM_BOUNDAGP].bytes_freed += info.ami_size;
-	simple_unlock(&drm_mem_lock);
-	if (free_count > alloc_count) {
-		DRM_MEM_ERROR(DRM_MEM_BOUNDAGP,
-			      "Excess frees: %d frees, %d allocs\n",
-			      free_count, alloc_count);
-	}
-	return retcode;
-}
-#endif
diff --git a/bsd/drm/proc.c b/bsd/drm/proc.c
deleted file mode 100644
index 6ca3fabc..00000000
--- a/bsd/drm/proc.c
+++ /dev/null
@@ -1,568 +0,0 @@
-/* proc.c -- /proc support for DRM -*- c -*-
- * Created: Mon Jan 11 09:48:47 1999 by faith@precisioninsight.com
- * Revised: Fri Aug 20 11:31:48 1999 by faith@precisioninsight.com
- *
- * Copyright 1999 Precision Insight, Inc., Cedar Park, Texas.
- * All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice (including the next
- * paragraph) shall be included in all copies or substantial portions of the
- * Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * PRECISION INSIGHT 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.
- * 
- * $PI: xc/programs/Xserver/hw/xfree86/os-support/linux/drm/kernel/proc.c,v 1.4 1999/08/20 15:36:46 faith Exp $
- * $XFree86: xc/programs/Xserver/hw/xfree86/os-support/bsd/drm/kernel/drm/proc.c,v 1.2 2001/03/02 02:45:38 dawes Exp $
- *
- */
-
-#define __NO_VERSION__
-#include "drmP.h"
-
-static struct proc_dir_entry *drm_root	   = NULL;
-static struct proc_dir_entry *drm_dev_root = NULL;
-static char		     drm_slot_name[64];
-
-static int	   drm_name_info(char *buf, char **start, off_t offset,
-				 int len, int *eof, void *data);
-static int	   drm_vm_info(char *buf, char **start, off_t offset,
-			       int len, int *eof, void *data);
-static int	   drm_clients_info(char *buf, char **start, off_t offset,
-				    int len, int *eof, void *data);
-static int	   drm_queues_info(char *buf, char **start, off_t offset,
-				   int len, int *eof, void *data);
-static int	   drm_bufs_info(char *buf, char **start, off_t offset,
-				 int len, int *eof, void *data);
-#if DRM_DEBUG_CODE
-static int	   drm_vma_info(char *buf, char **start, off_t offset,
-				int len, int *eof, void *data);
-#endif
-#if DRM_DMA_HISTOGRAM
-static int	   drm_histo_info(char *buf, char **start, off_t offset,
-				  int len, int *eof, void *data);
-#endif
-
-struct drm_proc_list {
-	const char *name;
-	int	   (*f)(char *, char **, off_t, int, int *, void *);
-} drm_proc_list[] = {
-	{ "name",    drm_name_info    },
-	{ "mem",     drm_mem_info     },
-	{ "vm",	     drm_vm_info      },
-	{ "clients", drm_clients_info },
-	{ "queues",  drm_queues_info  },
-	{ "bufs",    drm_bufs_info    },
-#if DRM_DEBUG_CODE
-	{ "vma",     drm_vma_info     },
-#endif
-#if DRM_DMA_HISTOGRAM
-	{ "histo",   drm_histo_info   },
-#endif
-};
-#define DRM_PROC_ENTRIES (sizeof(drm_proc_list)/sizeof(drm_proc_list[0]))
-
-int drm_proc_init(drm_device_t *dev)
-{
-	struct proc_dir_entry *ent;
-	int		      i, j;
-
-	drm_root = create_proc_entry("graphics", S_IFDIR, NULL);
-	if (!drm_root) {
-		DRM_ERROR("Cannot create /proc/graphics\n");
-		return -1;
-	}
-
-				/* Instead of doing this search, we should
-				   add some global support for /proc/graphics. */
-	for (i = 0; i < 8; i++) {
-		sprintf(drm_slot_name, "graphics/%d", i);
-		drm_dev_root = create_proc_entry(drm_slot_name, S_IFDIR, NULL);
-		if (!drm_dev_root) {
-			DRM_ERROR("Cannot create /proc/%s\n", drm_slot_name);
-			remove_proc_entry("graphics", NULL);
-		}
-		if (drm_dev_root->nlink == 2) break;
-		drm_dev_root = NULL;
-	}
-	if (!drm_dev_root) {
-		DRM_ERROR("Cannot find slot in /proc/graphics\n");
-		return -1;
-	}
-
-	for (i = 0; i < DRM_PROC_ENTRIES; i++) {
-		ent = create_proc_entry(drm_proc_list[i].name,
-					S_IFREG|S_IRUGO, drm_dev_root);
-		if (!ent) {
-			DRM_ERROR("Cannot create /proc/%s/%s\n",
-				  drm_slot_name, drm_proc_list[i].name);
-			for (j = 0; j < i; j++)
-				remove_proc_entry(drm_proc_list[i].name,
-						  drm_dev_root);
-			remove_proc_entry(drm_slot_name, NULL);
-			remove_proc_entry("graphics", NULL);
-			return -1;
-		}
-		ent->read_proc = drm_proc_list[i].f;
-		ent->data      = dev;
-	}
-
-	return 0;
-}
-
-
-int drm_proc_cleanup(void)
-{
-	int i;
-	
-	if (drm_root) {
-		if (drm_dev_root) {
-			for (i = 0; i < DRM_PROC_ENTRIES; i++) {
-				remove_proc_entry(drm_proc_list[i].name,
-						  drm_dev_root);
-			}
-			remove_proc_entry(drm_slot_name, NULL);
-		}
-		remove_proc_entry("graphics", NULL);
-		remove_proc_entry(DRM_NAME, NULL);
-	}
-	drm_root = drm_dev_root = NULL;
-	return 0;
-}
-
-static int drm_name_info(char *buf, char **start, off_t offset, int len,
-			 int *eof, void *data)
-{
-	drm_device_t *dev = (drm_device_t *)data;
-
-	if (offset > 0) return 0; /* no partial requests */
-	len  = 0;
-	*eof = 1;
-
-	if (dev->unique) {
-		DRM_PROC_PRINT("%s 0x%x %s\n",
-			       dev->name, dev->device, dev->unique);
-	} else {
-		DRM_PROC_PRINT("%s 0x%x\n", dev->name, dev->device);
-	}
-	return len;
-}
-
-static int _drm_vm_info(char *buf, char **start, off_t offset, int len,
-			int *eof, void *data)
-{
-	drm_device_t *dev = (drm_device_t *)data;
-	drm_map_t    *map;
-	const char   *types[] = { "FB", "REG", "SHM", "AGP" };
-	const char   *type;
-	int	     i;
-
-	if (offset > 0) return 0; /* no partial requests */
-	len  = 0;
-	*eof = 1;
-	DRM_PROC_PRINT("slot	 offset	      size type flags	 "
-		       "address mtrr\n\n");
-	for (i = 0; i < dev->map_count; i++) {
-		map = dev->maplist[i];
-		if (map->type < 0 || map->type > 3) type = "??";
-		else				    type = types[map->type];
-		DRM_PROC_PRINT("%4d 0x%08lx 0x%08lx %4.4s  0x%02x 0x%08lx ",
-			       i,
-			       map->offset,
-			       map->size,
-			       type,
-			       map->flags,
-			       (unsigned long)map->handle);
-		if (map->mtrr < 0) {
-			DRM_PROC_PRINT("none\n");
-		} else {
-			DRM_PROC_PRINT("%4d\n", map->mtrr);
-		}
-	}
-
-	return len;
-}
-
-static int drm_vm_info(char *buf, char **start, off_t offset, int len,
-		       int *eof, void *data)
-{
-	drm_device_t *dev = (drm_device_t *)data;
-	int	     ret;
-
-	down(&dev->struct_sem);
-	ret = _drm_vm_info(buf, start, offset, len, eof, data);
-	up(&dev->struct_sem);
-	return ret;
-}
-
-
-static int _drm_queues_info(char *buf, char **start, off_t offset, int len,
-			    int *eof, void *data)
-{
-	drm_device_t *dev = (drm_device_t *)data;
-	int	     i;
-	drm_queue_t  *q;
-
-	if (offset > 0) return 0; /* no partial requests */
-	len  = 0;
-	*eof = 1;
-	DRM_PROC_PRINT("  ctx/flags   use   fin"
-		       "   blk/rw/rwf  wait    flushed	   queued"
-		       "      locks\n\n");
-	for (i = 0; i < dev->queue_count; i++) {
-		q = dev->queuelist[i];
-		atomic_inc(&q->use_count);
-		DRM_PROC_PRINT_RET(atomic_dec(&q->use_count),
-				   "%5d/0x%03x %5d %5d"
-				   " %5d/%c%c/%c%c%c %5Zd %10d %10d %10d\n",
-				   i,
-				   q->flags,
-				   atomic_read(&q->use_count),
-				   atomic_read(&q->finalization),
-				   atomic_read(&q->block_count),
-				   atomic_read(&q->block_read) ? 'r' : '-',
-				   atomic_read(&q->block_write) ? 'w' : '-',
-				   waitqueue_active(&q->read_queue) ? 'r':'-',
-				   waitqueue_active(&q->write_queue) ? 'w':'-',
-				   waitqueue_active(&q->flush_queue) ? 'f':'-',
-				   DRM_BUFCOUNT(&q->waitlist),
-				   atomic_read(&q->total_flushed),
-				   atomic_read(&q->total_queued),
-				   atomic_read(&q->total_locks));
-		atomic_dec(&q->use_count);
-	}
-	
-	return len;
-}
-
-static int drm_queues_info(char *buf, char **start, off_t offset, int len,
-			   int *eof, void *data)
-{
-	drm_device_t *dev = (drm_device_t *)data;
-	int	     ret;
-
-	down(&dev->struct_sem);
-	ret = _drm_queues_info(buf, start, offset, len, eof, data);
-	up(&dev->struct_sem);
-	return ret;
-}
-
-/* drm_bufs_info is called whenever a process reads
-   /dev/drm/<dev>/bufs. */
-
-static int _drm_bufs_info(char *buf, char **start, off_t offset, int len,
-			  int *eof, void *data)
-{
-	drm_device_t	 *dev = (drm_device_t *)data;
-	drm_device_dma_t *dma = dev->dma;
-	int		 i;
-
-	if (!dma)	return 0;
-	if (offset > 0) return 0; /* no partial requests */
-	len  = 0;
-	*eof = 1;
-	DRM_PROC_PRINT(" o     size count  free	 segs pages    kB\n\n");
-	for (i = 0; i <= DRM_MAX_ORDER; i++) {
-		if (dma->bufs[i].buf_count)
-			DRM_PROC_PRINT("%2d %8d %5d %5d %5d %5d %5ld\n",
-				       i,
-				       dma->bufs[i].buf_size,
-				       dma->bufs[i].buf_count,
-				       atomic_read(&dma->bufs[i]
-						   .freelist.count),
-				       dma->bufs[i].seg_count,
-				       dma->bufs[i].seg_count
-				       *(1 << dma->bufs[i].page_order),
-				       (dma->bufs[i].seg_count
-					* (1 << dma->bufs[i].page_order))
-				       * PAGE_SIZE / 1024);
-	}
-	DRM_PROC_PRINT("\n");
-	for (i = 0; i < dma->buf_count; i++) {
-		if (i && !(i%32)) DRM_PROC_PRINT("\n");
-		DRM_PROC_PRINT(" %d", dma->buflist[i]->list);
-	}
-	DRM_PROC_PRINT("\n");
-
-	return len;
-}
-
-static int drm_bufs_info(char *buf, char **start, off_t offset, int len,
-			 int *eof, void *data)
-{
-	drm_device_t *dev = (drm_device_t *)data;
-	int	     ret;
-
-	down(&dev->struct_sem);
-	ret = _drm_bufs_info(buf, start, offset, len, eof, data);
-	up(&dev->struct_sem);
-	return ret;
-}
-
-
-static int _drm_clients_info(char *buf, char **start, off_t offset, int len,
-			     int *eof, void *data)
-{
-	drm_device_t *dev = (drm_device_t *)data;
-	drm_file_t   *priv;
-
-	if (offset > 0) return 0; /* no partial requests */
-	len  = 0;
-	*eof = 1;
-	DRM_PROC_PRINT("a dev	pid    uid	magic	  ioctls\n\n");
-	for (priv = dev->file_first; priv; priv = priv->next) {
-		DRM_PROC_PRINT("%c %3d %5d %5d %10u %10lu\n",
-			       priv->authenticated ? 'y' : 'n',
-			       priv->minor,
-			       priv->pid,
-			       priv->uid,
-			       priv->magic,
-			       priv->ioctl_count);
-	}
-
-	return len;
-}
-
-static int drm_clients_info(char *buf, char **start, off_t offset, int len,
-			    int *eof, void *data)
-{
-	drm_device_t *dev = (drm_device_t *)data;
-	int	     ret;
-
-	down(&dev->struct_sem);
-	ret = _drm_clients_info(buf, start, offset, len, eof, data);
-	up(&dev->struct_sem);
-	return ret;
-}
-
-#if DRM_DEBUG_CODE
-
-static int _drm_vma_info(char *buf, char **start, off_t offset, int len,
-			 int *eof, void *data)
-{
-	drm_device_t	      *dev = (drm_device_t *)data;
-	drm_vma_entry_t	      *pt;
-	pgd_t		      *pgd;
-	pmd_t		      *pmd;
-	pte_t		      *pte;
-	unsigned long	      i;
-	struct vm_area_struct *vma;
-	unsigned long	      address;
-#if defined(__i386__)
-	unsigned int	      pgprot;
-#endif
-
-	if (offset > 0) return 0; /* no partial requests */
-	len  = 0;
-	*eof = 1;
-	DRM_PROC_PRINT("vma use count: %d, high_memory = %p, 0x%08lx\n",
-		       atomic_read(&dev->vma_count),
-		       high_memory, virt_to_phys(high_memory));
-	for (pt = dev->vmalist; pt; pt = pt->next) {
-		if (!(vma = pt->vma)) continue;
-		DRM_PROC_PRINT("\n%5d 0x%08lx-0x%08lx %c%c%c%c%c%c 0x%08lx",
-			       pt->pid,
-			       vma->vm_start,
-			       vma->vm_end,
-			       vma->vm_flags & VM_READ	   ? 'r' : '-',
-			       vma->vm_flags & VM_WRITE	   ? 'w' : '-',
-			       vma->vm_flags & VM_EXEC	   ? 'x' : '-',
-			       vma->vm_flags & VM_MAYSHARE ? 's' : 'p',
-			       vma->vm_flags & VM_LOCKED   ? 'l' : '-',
-			       vma->vm_flags & VM_IO	   ? 'i' : '-',
-			       vma->vm_offset );
-#if defined(__i386__)
-		pgprot = pgprot_val(vma->vm_page_prot);
-		DRM_PROC_PRINT(" %c%c%c%c%c%c%c%c%c",
-			       pgprot & _PAGE_PRESENT  ? 'p' : '-',
-			       pgprot & _PAGE_RW       ? 'w' : 'r',
-			       pgprot & _PAGE_USER     ? 'u' : 's',
-			       pgprot & _PAGE_PWT      ? 't' : 'b',
-			       pgprot & _PAGE_PCD      ? 'u' : 'c',
-			       pgprot & _PAGE_ACCESSED ? 'a' : '-',
-			       pgprot & _PAGE_DIRTY    ? 'd' : '-',
-			       pgprot & _PAGE_4M       ? 'm' : 'k',
-			       pgprot & _PAGE_GLOBAL   ? 'g' : 'l' );
-#endif		
-		DRM_PROC_PRINT("\n");
-		for (i = vma->vm_start; i < vma->vm_end; i += PAGE_SIZE) {
-			pgd = pgd_offset(vma->vm_mm, i);
-			pmd = pmd_offset(pgd, i);
-			pte = pte_offset(pmd, i);
-			if (pte_present(*pte)) {
-				address = __pa(pte_page(*pte))
-					+ (i & (PAGE_SIZE-1));
-				DRM_PROC_PRINT("      0x%08lx -> 0x%08lx"
-					       " %c%c%c%c%c\n",
-					       i,
-					       address,
-					       pte_read(*pte)  ? 'r' : '-',
-					       pte_write(*pte) ? 'w' : '-',
-					       pte_exec(*pte)  ? 'x' : '-',
-					       pte_dirty(*pte) ? 'd' : '-',
-					       pte_young(*pte) ? 'a' : '-' );
-			} else {
-				DRM_PROC_PRINT("      0x%08lx\n", i);
-			}
-		}
-	}
-	
-	return len;
-}
-
-static int drm_vma_info(char *buf, char **start, off_t offset, int len,
-			int *eof, void *data)
-{
-	drm_device_t *dev = (drm_device_t *)data;
-	int	     ret;
-
-	down(&dev->struct_sem);
-	ret = _drm_vma_info(buf, start, offset, len, eof, data);
-	up(&dev->struct_sem);
-	return ret;
-}
-#endif
-
-
-#if DRM_DMA_HISTOGRAM
-static int _drm_histo_info(char *buf, char **start, off_t offset, int len,
-			   int *eof, void *data)
-{
-	drm_device_t	 *dev = (drm_device_t *)data;
-	drm_device_dma_t *dma = dev->dma;
-	int		 i;
-	unsigned long	 slot_value = DRM_DMA_HISTOGRAM_INITIAL;
-	unsigned long	 prev_value = 0;
-	drm_buf_t	 *buffer;
-
-	if (offset > 0) return 0; /* no partial requests */
-	len  = 0;
-	*eof = 1;
-
-	DRM_PROC_PRINT("general statistics:\n");
-	DRM_PROC_PRINT("total	 %10u\n", atomic_read(&dev->histo.total));
-	DRM_PROC_PRINT("open	 %10u\n", atomic_read(&dev->total_open));
-	DRM_PROC_PRINT("close	 %10u\n", atomic_read(&dev->total_close));
-	DRM_PROC_PRINT("ioctl	 %10u\n", atomic_read(&dev->total_ioctl));
-	DRM_PROC_PRINT("irq	 %10u\n", atomic_read(&dev->total_irq));
-	DRM_PROC_PRINT("ctx	 %10u\n", atomic_read(&dev->total_ctx));
-	
-	DRM_PROC_PRINT("\nlock statistics:\n");
-	DRM_PROC_PRINT("locks	 %10u\n", atomic_read(&dev->total_locks));
-	DRM_PROC_PRINT("unlocks	 %10u\n", atomic_read(&dev->total_unlocks));
-	DRM_PROC_PRINT("contends %10u\n", atomic_read(&dev->total_contends));
-	DRM_PROC_PRINT("sleeps	 %10u\n", atomic_read(&dev->total_sleeps));
-
-
-	if (dma) {
-		DRM_PROC_PRINT("\ndma statistics:\n");
-		DRM_PROC_PRINT("prio	 %10u\n",
-			       atomic_read(&dma->total_prio));
-		DRM_PROC_PRINT("bytes	 %10u\n",
-			       atomic_read(&dma->total_bytes));
-		DRM_PROC_PRINT("dmas	 %10u\n",
-			       atomic_read(&dma->total_dmas));
-		DRM_PROC_PRINT("missed:\n");
-		DRM_PROC_PRINT("  dma	 %10u\n",
-			       atomic_read(&dma->total_missed_dma));
-		DRM_PROC_PRINT("  lock	 %10u\n",
-			       atomic_read(&dma->total_missed_lock));
-		DRM_PROC_PRINT("  free	 %10u\n",
-			       atomic_read(&dma->total_missed_free));
-		DRM_PROC_PRINT("  sched	 %10u\n",
-			       atomic_read(&dma->total_missed_sched));
-		DRM_PROC_PRINT("tried	 %10u\n",
-			       atomic_read(&dma->total_tried));
-		DRM_PROC_PRINT("hit	 %10u\n",
-			       atomic_read(&dma->total_hit));
-		DRM_PROC_PRINT("lost	 %10u\n",
-			       atomic_read(&dma->total_lost));
-		
-		buffer = dma->next_buffer;
-		if (buffer) {
-			DRM_PROC_PRINT("next_buffer %7d\n", buffer->idx);
-		} else {
-			DRM_PROC_PRINT("next_buffer    none\n");
-		}
-		buffer = dma->this_buffer;
-		if (buffer) {
-			DRM_PROC_PRINT("this_buffer %7d\n", buffer->idx);
-		} else {
-			DRM_PROC_PRINT("this_buffer    none\n");
-		}
-	}
-	
-
-	DRM_PROC_PRINT("\nvalues:\n");
-	if (dev->lock.hw_lock) {
-		DRM_PROC_PRINT("lock	       0x%08x\n",
-			       dev->lock.hw_lock->lock);
-	} else {
-		DRM_PROC_PRINT("lock		     none\n");
-	}
-	DRM_PROC_PRINT("context_flag   0x%08x\n", dev->context_flag);
-	DRM_PROC_PRINT("interrupt_flag 0x%08x\n", dev->interrupt_flag);
-	DRM_PROC_PRINT("dma_flag       0x%08x\n", dev->dma_flag);
-
-	DRM_PROC_PRINT("queue_count    %10d\n",	 dev->queue_count);
-	DRM_PROC_PRINT("last_context   %10d\n",	 dev->last_context);
-	DRM_PROC_PRINT("last_switch    %10lu\n", dev->last_switch);
-	DRM_PROC_PRINT("last_checked   %10d\n",	 dev->last_checked);
-		
-	
-	DRM_PROC_PRINT("\n		       q2d	  d2c	     c2f"
-		       "	q2c	   q2f	      dma	 sch"
-		       "	ctx	  lacq	     lhld\n\n");
-	for (i = 0; i < DRM_DMA_HISTOGRAM_SLOTS; i++) {
-		DRM_PROC_PRINT("%s %10lu %10u %10u %10u %10u %10u"
-			       " %10u %10u %10u %10u %10u\n",
-			       i == DRM_DMA_HISTOGRAM_SLOTS - 1 ? ">=" : "< ",
-			       i == DRM_DMA_HISTOGRAM_SLOTS - 1
-			       ? prev_value : slot_value ,
-			       
-			       atomic_read(&dev->histo
-					   .queued_to_dispatched[i]),
-			       atomic_read(&dev->histo
-					   .dispatched_to_completed[i]),
-			       atomic_read(&dev->histo
-					   .completed_to_freed[i]),
-			       
-			       atomic_read(&dev->histo
-					   .queued_to_completed[i]),
-			       atomic_read(&dev->histo
-					   .queued_to_freed[i]),
-			       atomic_read(&dev->histo.dma[i]),
-			       atomic_read(&dev->histo.schedule[i]),
-			       atomic_read(&dev->histo.ctx[i]),
-			       atomic_read(&dev->histo.lacq[i]),
-			       atomic_read(&dev->histo.lhld[i]));
-		prev_value = slot_value;
-		slot_value = DRM_DMA_HISTOGRAM_NEXT(slot_value);
-	}
-	return len;
-}
-
-static int drm_histo_info(char *buf, char **start, off_t offset, int len,
-			  int *eof, void *data)
-{
-	drm_device_t *dev = (drm_device_t *)data;
-	int	     ret;
-
-	down(&dev->struct_sem);
-	ret = _drm_histo_info(buf, start, offset, len, eof, data);
-	up(&dev->struct_sem);
-	return ret;
-}
-#endif
diff --git a/bsd/drm/sysctl.c b/bsd/drm/sysctl.c
deleted file mode 100644
index 0bc04d22..00000000
--- a/bsd/drm/sysctl.c
+++ /dev/null
@@ -1,554 +0,0 @@
-/* proc.c -- /proc support for DRM -*- c -*-
- * Created: Mon Jan 11 09:48:47 1999 by faith@precisioninsight.com
- * Revised: Fri Aug 20 11:31:48 1999 by faith@precisioninsight.com
- *
- * Copyright 1999 Precision Insight, Inc., Cedar Park, Texas.
- * All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice (including the next
- * paragraph) shall be included in all copies or substantial portions of the
- * Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * PRECISION INSIGHT 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.
- * 
- * $PI$
- * $XFree86: xc/programs/Xserver/hw/xfree86/os-support/bsd/drm/kernel/drm/sysctl.c,v 1.2 2001/03/02 02:45:38 dawes Exp $
- *
- */
-
-#define __NO_VERSION__
-#include "drmP.h"
-#include <sys/sysctl.h>
-
-SYSCTL_NODE(_hw, OID_AUTO, dri, CTLFLAG_RW, 0, "DRI Graphics");
-
-static int	   drm_name_info DRM_SYSCTL_HANDLER_ARGS;
-static int	   drm_vm_info DRM_SYSCTL_HANDLER_ARGS;
-static int	   drm_clients_info DRM_SYSCTL_HANDLER_ARGS;
-static int	   drm_queues_info DRM_SYSCTL_HANDLER_ARGS;
-static int	   drm_bufs_info DRM_SYSCTL_HANDLER_ARGS;
-#if DRM_DEBUG_CODExx
-static int	   drm_vma_info DRM_SYSCTL_HANDLER_ARGS;
-#endif
-#if DRM_DMA_HISTOGRAM
-static int	   drm_histo_info DRM_SYSCTL_HANDLER_ARGS;
-#endif
-
-struct drm_sysctl_list {
-	const char *name;
-	int	   (*f) DRM_SYSCTL_HANDLER_ARGS;
-} drm_sysctl_list[] = {
-	{ "name",    drm_name_info    },
-	{ "mem",     drm_mem_info     },
-	{ "vm",	     drm_vm_info      },
-	{ "clients", drm_clients_info },
-	{ "queues",  drm_queues_info  },
-	{ "bufs",    drm_bufs_info    },
-#if DRM_DEBUG_CODExx
-	{ "vma",     drm_vma_info     },
-#endif
-#if DRM_DMA_HISTOGRAM
-	{ "histo",   drm_histo_info   },
-#endif
-};
-#define DRM_SYSCTL_ENTRIES (sizeof(drm_sysctl_list)/sizeof(drm_sysctl_list[0]))
-
-struct drm_sysctl_info {
-	struct sysctl_oid      oids[DRM_SYSCTL_ENTRIES + 1];
-	struct sysctl_oid_list list;
-	char		       name[2];
-};
-
-int drm_sysctl_init(drm_device_t *dev)
-{
-	struct drm_sysctl_info *info;
-	struct sysctl_oid *oid;
-	struct sysctl_oid *top;
-	int		  i;
-
-	/* Find the next free slot under hw.graphics */
-	i = 0;
-	SLIST_FOREACH(oid, &sysctl__hw_dri_children, oid_link) {
-		if (i <= oid->oid_arg2)
-			i = oid->oid_arg2 + 1;
-	}
-	
-	info = drm_alloc(sizeof *info, DRM_MEM_DRIVER);
-	dev->sysctl = info;
-
-	/* Construct the node under hw.graphics */
-	info->name[0] = '0' + i;
-	info->name[1] = 0;
-	oid = &info->oids[DRM_SYSCTL_ENTRIES];
-	bzero(oid, sizeof(*oid));
-	oid->oid_parent = &sysctl__hw_dri_children;
-	oid->oid_number = OID_AUTO;
-	oid->oid_kind = CTLTYPE_NODE | CTLFLAG_RW;
-	oid->oid_arg1 = &info->list;
-	oid->oid_arg2 = i;
-	oid->oid_name = info->name;
-	oid->oid_handler = 0;
-	oid->oid_fmt = "N";
-	SLIST_INIT(&info->list);
-	sysctl_register_oid(oid);
-	top = oid;
-
-	for (i = 0; i < DRM_SYSCTL_ENTRIES; i++) {
-		oid = &info->oids[i];
-		bzero(oid, sizeof(*oid));
-		oid->oid_parent = top->oid_arg1;
-		oid->oid_number = OID_AUTO;
-		oid->oid_kind = CTLTYPE_INT | CTLFLAG_RD;
-		oid->oid_arg1 = dev;
-		oid->oid_arg2 = 0;
-		oid->oid_name = drm_sysctl_list[i].name;
-		oid->oid_handler = drm_sysctl_list[i].f;
-		oid->oid_fmt = "A";
-		sysctl_register_oid(oid);
-	}
-
-	return 0;
-}
-
-int drm_sysctl_cleanup(drm_device_t *dev)
-{
-	int i;
-
-	DRM_DEBUG("dev->sysctl=%p\n", dev->sysctl);
-	for (i = 0; i < DRM_SYSCTL_ENTRIES + 1; i++)
-		sysctl_unregister_oid(&dev->sysctl->oids[i]);
-
-	drm_free(dev->sysctl, sizeof *dev->sysctl, DRM_MEM_DRIVER);
-	dev->sysctl = NULL;
-
-	return 0;
-}
-
-static int drm_name_info DRM_SYSCTL_HANDLER_ARGS
-{
-	drm_device_t *dev = arg1;
-	char buf[128];
-	int error;
-
-	if (dev->unique) {
-		DRM_SYSCTL_PRINT("%s 0x%x %s\n",
-			       dev->name, dev2udev(dev->devnode), dev->unique);
-	} else {
-		DRM_SYSCTL_PRINT("%s 0x%x\n", dev->name, dev2udev(dev->devnode));
-	}
-
-	SYSCTL_OUT(req, "", 1);
-
-	return 0;
-}
-
-static int _drm_vm_info DRM_SYSCTL_HANDLER_ARGS
-{
-	drm_device_t *dev = arg1;
-	drm_map_t    *map;
-	const char   *types[] = { "FB", "REG", "SHM", "AGP" };
-	const char   *type;
-	int	     i;
-	char         buf[128];
-	int          error;
-
-	DRM_SYSCTL_PRINT("slot	 offset	      size type flags	 "
-			 "address mtrr\n\n");
-	error = SYSCTL_OUT(req, buf, strlen(buf));
-	if (error) return error;
-
-	for (i = 0; i < dev->map_count; i++) {
-		map = dev->maplist[i];
-		if (map->type < 0 || map->type > 3) type = "??";
-		else				    type = types[map->type];
-		DRM_SYSCTL_PRINT("%4d 0x%08lx 0x%08lx %4.4s  0x%02x 0x%08lx ",
-				 i,
-				 map->offset,
-				 map->size,
-				 type,
-				 map->flags,
-				 (unsigned long)map->handle);
-		if (map->mtrr < 0) {
-			DRM_SYSCTL_PRINT("none\n");
-		} else {
-			DRM_SYSCTL_PRINT("%4d\n", map->mtrr);
-		}
-	}
-	SYSCTL_OUT(req, "", 1);
-
-	return 0;
-}
-
-static int drm_vm_info DRM_SYSCTL_HANDLER_ARGS
-{
-	drm_device_t *dev = arg1;
-	int	     ret;
-
-	lockmgr(&dev->dev_lock, LK_EXCLUSIVE, 0, curproc);
-	ret = _drm_vm_info(oidp, arg1, arg2, req);
-	lockmgr(&dev->dev_lock, LK_RELEASE, 0, curproc);
-
-	return ret;
-}
-
-
-static int _drm_queues_info DRM_SYSCTL_HANDLER_ARGS
-{
-	drm_device_t *dev = arg1;
-	int	     i;
-	drm_queue_t  *q;
-	char         buf[128];
-	int          error;
-
-	DRM_SYSCTL_PRINT("  ctx/flags   use   fin"
-			 "   blk/rw/rwf  wait    flushed	   queued"
-			 "      locks\n\n");
-	for (i = 0; i < dev->queue_count; i++) {
-		q = dev->queuelist[i];
-		atomic_inc(&q->use_count);
-		DRM_SYSCTL_PRINT_RET(atomic_dec(&q->use_count),
-				     "%5d/0x%03x %5d %5d"
-				     " %5d/%c%c/%c%c%c %5Zd %10d %10d %10d\n",
-				     i,
-				     q->flags,
-				     atomic_read(&q->use_count),
-				     atomic_read(&q->finalization),
-				     atomic_read(&q->block_count),
-				     atomic_read(&q->block_read) ? 'r' : '-',
-				     atomic_read(&q->block_write) ? 'w' : '-',
-				     q->read_queue ? 'r':'-',
-				     q->write_queue ? 'w':'-',
-				     q->flush_queue ? 'f':'-',
-				     DRM_BUFCOUNT(&q->waitlist),
-				     atomic_read(&q->total_flushed),
-				     atomic_read(&q->total_queued),
-				     atomic_read(&q->total_locks));
-		atomic_dec(&q->use_count);
-	}
-
-	SYSCTL_OUT(req, "", 1);
-	return 0;
-}
-
-static int drm_queues_info DRM_SYSCTL_HANDLER_ARGS
-{
-	drm_device_t *dev = arg1;
-	int	     ret;
-
-	lockmgr(&dev->dev_lock, LK_EXCLUSIVE, 0, curproc);
-	ret = _drm_queues_info(oidp, arg1, arg2, req);
-	lockmgr(&dev->dev_lock, LK_RELEASE, 0, curproc);
-	return ret;
-}
-
-/* drm_bufs_info is called whenever a process reads
-   hw.dri.0.bufs. */
-
-static int _drm_bufs_info DRM_SYSCTL_HANDLER_ARGS
-{
-	drm_device_t	 *dev = arg1;
-	drm_device_dma_t *dma = dev->dma;
-	int		 i;
-	char             buf[128];
-	int              error;
-
-	if (!dma)	return 0;
-	DRM_SYSCTL_PRINT(" o     size count  free	 segs pages    kB\n\n");
-	for (i = 0; i <= DRM_MAX_ORDER; i++) {
-		if (dma->bufs[i].buf_count)
-			DRM_SYSCTL_PRINT("%2d %8d %5d %5d %5d %5d %5d\n",
-				       i,
-				       dma->bufs[i].buf_size,
-				       dma->bufs[i].buf_count,
-				       atomic_read(&dma->bufs[i]
-						   .freelist.count),
-				       dma->bufs[i].seg_count,
-				       dma->bufs[i].seg_count
-				       *(1 << dma->bufs[i].page_order),
-				       (dma->bufs[i].seg_count
-					* (1 << dma->bufs[i].page_order))
-				       * PAGE_SIZE / 1024);
-	}
-	DRM_SYSCTL_PRINT("\n");
-	for (i = 0; i < dma->buf_count; i++) {
-		if (i && !(i%32)) DRM_SYSCTL_PRINT("\n");
-		DRM_SYSCTL_PRINT(" %d", dma->buflist[i]->list);
-	}
-	DRM_SYSCTL_PRINT("\n");
-
-	SYSCTL_OUT(req, "", 1);
-	return 0;
-}
-
-static int drm_bufs_info DRM_SYSCTL_HANDLER_ARGS
-{
-	drm_device_t *dev = arg1;
-	int	     ret;
-
-	lockmgr(&dev->dev_lock, LK_EXCLUSIVE, 0, curproc);
-	ret = _drm_bufs_info(oidp, arg1, arg2, req);
-	lockmgr(&dev->dev_lock, LK_RELEASE, 0, curproc);
-	return ret;
-}
-
-
-static int _drm_clients_info DRM_SYSCTL_HANDLER_ARGS
-{
-	drm_device_t *dev = arg1;
-	drm_file_t   *priv;
-	char         buf[128];
-	int          error;
-
-	DRM_SYSCTL_PRINT("a dev	pid    uid	magic	  ioctls\n\n");
-	TAILQ_FOREACH(priv, &dev->files, link) {
-		DRM_SYSCTL_PRINT("%c %3d %5d %5d %10u %10lu\n",
-			       priv->authenticated ? 'y' : 'n',
-			       priv->minor,
-			       priv->pid,
-			       priv->uid,
-			       priv->magic,
-			       priv->ioctl_count);
-	}
-
-	SYSCTL_OUT(req, "", 1);
-	return 0;
-}
-
-static int drm_clients_info DRM_SYSCTL_HANDLER_ARGS
-{
-	drm_device_t *dev = arg1;
-	int	     ret;
-
-	lockmgr(&dev->dev_lock, LK_EXCLUSIVE, 0, curproc);
-	ret = _drm_clients_info(oidp, arg1, arg2, req);
-	lockmgr(&dev->dev_lock, LK_RELEASE, 0, curproc);
-	return ret;
-}
-
-#if DRM_DEBUG_CODExx
-
-static int _drm_vma_info DRM_SYSCTL_HANDLER_ARGS
-{
-	drm_device_t	      *dev = arg1;
-	drm_vma_entry_t	      *pt;
-	pgd_t		      *pgd;
-	pmd_t		      *pmd;
-	pte_t		      *pte;
-	unsigned long	      i;
-	struct vm_area_struct *vma;
-	unsigned long	      address;
-#if defined(__i386__)
-	unsigned int	      pgprot;
-#endif
-	char		      buf[128];
-	int		      error;
-
-	DRM_SYSCTL_PRINT("vma use count: %d, high_memory = %p, 0x%08lx\n",
-		       atomic_read(&dev->vma_count),
-		       high_memory, virt_to_phys(high_memory));
-	for (pt = dev->vmalist; pt; pt = pt->next) {
-		if (!(vma = pt->vma)) continue;
-		DRM_SYSCTL_PRINT("\n%5d 0x%08lx-0x%08lx %c%c%c%c%c%c 0x%08lx",
-			       pt->pid,
-			       vma->vm_start,
-			       vma->vm_end,
-			       vma->vm_flags & VM_READ	   ? 'r' : '-',
-			       vma->vm_flags & VM_WRITE	   ? 'w' : '-',
-			       vma->vm_flags & VM_EXEC	   ? 'x' : '-',
-			       vma->vm_flags & VM_MAYSHARE ? 's' : 'p',
-			       vma->vm_flags & VM_LOCKED   ? 'l' : '-',
-			       vma->vm_flags & VM_IO	   ? 'i' : '-',
-			       vma->vm_offset );
-#if defined(__i386__)
-		pgprot = pgprot_val(vma->vm_page_prot);
-		DRM_SYSCTL_PRINT(" %c%c%c%c%c%c%c%c%c",
-			       pgprot & _PAGE_PRESENT  ? 'p' : '-',
-			       pgprot & _PAGE_RW       ? 'w' : 'r',
-			       pgprot & _PAGE_USER     ? 'u' : 's',
-			       pgprot & _PAGE_PWT      ? 't' : 'b',
-			       pgprot & _PAGE_PCD      ? 'u' : 'c',
-			       pgprot & _PAGE_ACCESSED ? 'a' : '-',
-			       pgprot & _PAGE_DIRTY    ? 'd' : '-',
-			       pgprot & _PAGE_4M       ? 'm' : 'k',
-			       pgprot & _PAGE_GLOBAL   ? 'g' : 'l' );
-#endif		
-		DRM_SYSCTL_PRINT("\n");
-		for (i = vma->vm_start; i < vma->vm_end; i += PAGE_SIZE) {
-			pgd = pgd_offset(vma->vm_mm, i);
-			pmd = pmd_offset(pgd, i);
-			pte = pte_offset(pmd, i);
-			if (pte_present(*pte)) {
-				address = __pa(pte_page(*pte))
-					+ (i & (PAGE_SIZE-1));
-				DRM_SYSCTL_PRINT("      0x%08lx -> 0x%08lx"
-					       " %c%c%c%c%c\n",
-					       i,
-					       address,
-					       pte_read(*pte)  ? 'r' : '-',
-					       pte_write(*pte) ? 'w' : '-',
-					       pte_exec(*pte)  ? 'x' : '-',
-					       pte_dirty(*pte) ? 'd' : '-',
-					       pte_young(*pte) ? 'a' : '-' );
-			} else {
-				DRM_SYSCTL_PRINT("      0x%08lx\n", i);
-			}
-		}
-	}
-	
-	SYSCTL_OUT(req, "", 1);
-	return 0;
-}
-
-static int drm_vma_info DRM_SYSCTL_HANDLER_ARGS
-{
-	drm_device_t *dev = arg1;
-	int	     ret;
-
-	lockmgr(&dev->dev_lock, LK_EXCLUSIVE, 0, curproc);
-	ret = _drm_vma_info(oidp, arg1, arg2, req);
-	lockmgr(&dev->dev_lock, LK_RELEASE, 0, curproc);
-	return ret;
-}
-#endif
-
-
-#if DRM_DMA_HISTOGRAM
-static int _drm_histo_info DRM_SYSCTL_HANDLER_ARGS
-{
-	drm_device_t	 *dev = arg1;
-	drm_device_dma_t *dma = dev->dma;
-	int		 i;
-	unsigned long	 slot_value = DRM_DMA_HISTOGRAM_INITIAL;
-	unsigned long	 prev_value = 0;
-	drm_buf_t	 *buffer;
-	char		 buf[128];
-	int              error;
-
-	DRM_SYSCTL_PRINT("general statistics:\n");
-	DRM_SYSCTL_PRINT("total	 %10u\n", atomic_read(&dev->histo.total));
-	DRM_SYSCTL_PRINT("open	 %10u\n", atomic_read(&dev->total_open));
-	DRM_SYSCTL_PRINT("close	 %10u\n", atomic_read(&dev->total_close));
-	DRM_SYSCTL_PRINT("ioctl	 %10u\n", atomic_read(&dev->total_ioctl));
-	DRM_SYSCTL_PRINT("irq	 %10u\n", atomic_read(&dev->total_irq));
-	DRM_SYSCTL_PRINT("ctx	 %10u\n", atomic_read(&dev->total_ctx));
-	
-	DRM_SYSCTL_PRINT("\nlock statistics:\n");
-	DRM_SYSCTL_PRINT("locks	 %10u\n", atomic_read(&dev->total_locks));
-	DRM_SYSCTL_PRINT("unlocks	 %10u\n", atomic_read(&dev->total_unlocks));
-	DRM_SYSCTL_PRINT("contends %10u\n", atomic_read(&dev->total_contends));
-	DRM_SYSCTL_PRINT("sleeps	 %10u\n", atomic_read(&dev->total_sleeps));
-
-
-	if (dma) {
-		DRM_SYSCTL_PRINT("\ndma statistics:\n");
-		DRM_SYSCTL_PRINT("prio	 %10u\n",
-			       atomic_read(&dma->total_prio));
-		DRM_SYSCTL_PRINT("bytes	 %10u\n",
-			       atomic_read(&dma->total_bytes));
-		DRM_SYSCTL_PRINT("dmas	 %10u\n",
-			       atomic_read(&dma->total_dmas));
-		DRM_SYSCTL_PRINT("missed:\n");
-		DRM_SYSCTL_PRINT("  dma	 %10u\n",
-			       atomic_read(&dma->total_missed_dma));
-		DRM_SYSCTL_PRINT("  lock	 %10u\n",
-			       atomic_read(&dma->total_missed_lock));
-		DRM_SYSCTL_PRINT("  free	 %10u\n",
-			       atomic_read(&dma->total_missed_free));
-		DRM_SYSCTL_PRINT("  sched	 %10u\n",
-			       atomic_read(&dma->total_missed_sched));
-		DRM_SYSCTL_PRINT("tried	 %10u\n",
-			       atomic_read(&dma->total_tried));
-		DRM_SYSCTL_PRINT("hit	 %10u\n",
-			       atomic_read(&dma->total_hit));
-		DRM_SYSCTL_PRINT("lost	 %10u\n",
-			       atomic_read(&dma->total_lost));
-		
-		buffer = dma->next_buffer;
-		if (buffer) {
-			DRM_SYSCTL_PRINT("next_buffer %7d\n", buffer->idx);
-		} else {
-			DRM_SYSCTL_PRINT("next_buffer    none\n");
-		}
-		buffer = dma->this_buffer;
-		if (buffer) {
-			DRM_SYSCTL_PRINT("this_buffer %7d\n", buffer->idx);
-		} else {
-			DRM_SYSCTL_PRINT("this_buffer    none\n");
-		}
-	}
-	
-
-	DRM_SYSCTL_PRINT("\nvalues:\n");
-	if (dev->lock.hw_lock) {
-		DRM_SYSCTL_PRINT("lock	       0x%08x\n",
-			       dev->lock.hw_lock->lock);
-	} else {
-		DRM_SYSCTL_PRINT("lock		     none\n");
-	}
-	DRM_SYSCTL_PRINT("context_flag   0x%08lx\n", dev->context_flag);
-	DRM_SYSCTL_PRINT("interrupt_flag 0x%08lx\n", dev->interrupt_flag);
-	DRM_SYSCTL_PRINT("dma_flag       0x%08lx\n", dev->dma_flag);
-
-	DRM_SYSCTL_PRINT("queue_count    %10d\n",	 dev->queue_count);
-	DRM_SYSCTL_PRINT("last_context   %10d\n",	 dev->last_context);
-	DRM_SYSCTL_PRINT("last_switch    %10u\n",	 dev->last_switch);
-	DRM_SYSCTL_PRINT("last_checked   %10d\n",	 dev->last_checked);
-		
-	
-	DRM_SYSCTL_PRINT("\n		       q2d	  d2c	     c2f"
-		       "	q2c	   q2f	      dma	 sch"
-		       "	ctx	  lacq	     lhld\n\n");
-	for (i = 0; i < DRM_DMA_HISTOGRAM_SLOTS; i++) {
-		DRM_SYSCTL_PRINT("%s %10lu %10u %10u %10u %10u %10u"
-			       " %10u %10u %10u %10u %10u\n",
-			       i == DRM_DMA_HISTOGRAM_SLOTS - 1 ? ">=" : "< ",
-			       i == DRM_DMA_HISTOGRAM_SLOTS - 1
-			       ? prev_value : slot_value ,
-			       
-			       atomic_read(&dev->histo
-					   .queued_to_dispatched[i]),
-			       atomic_read(&dev->histo
-					   .dispatched_to_completed[i]),
-			       atomic_read(&dev->histo
-					   .completed_to_freed[i]),
-			       
-			       atomic_read(&dev->histo
-					   .queued_to_completed[i]),
-			       atomic_read(&dev->histo
-					   .queued_to_freed[i]),
-			       atomic_read(&dev->histo.dma[i]),
-			       atomic_read(&dev->histo.schedule[i]),
-			       atomic_read(&dev->histo.ctx[i]),
-			       atomic_read(&dev->histo.lacq[i]),
-			       atomic_read(&dev->histo.lhld[i]));
-		prev_value = slot_value;
-		slot_value = DRM_DMA_HISTOGRAM_NEXT(slot_value);
-	}
-	SYSCTL_OUT(req, "", 1);
-	return 0;
-}
-
-static int drm_histo_info DRM_SYSCTL_HANDLER_ARGS
-{
-	drm_device_t *dev = arg1;
-	int	     ret;
-
-	lockmgr(&dev->dev_lock, LK_EXCLUSIVE, 0, curproc);
-	ret = _drm_histo_info(oidp, arg1, arg2, req);
-	lockmgr(&dev->dev_lock, LK_RELEASE, 0, curproc);
-	return ret;
-}
-#endif
diff --git a/bsd/drm/vm.c b/bsd/drm/vm.c
deleted file mode 100644
index 00e66f3e..00000000
--- a/bsd/drm/vm.c
+++ /dev/null
@@ -1,104 +0,0 @@
-/* vm.c -- Memory mapping for DRM -*- c -*-
- * Created: Mon Jan  4 08:58:31 1999 by faith@precisioninsight.com
- *
- * Copyright 1999 Precision Insight, Inc., Cedar Park, Texas.
- * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
- * All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice (including the next
- * paragraph) shall be included in all copies or substantial portions of the
- * Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
- * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
- * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- * 
- * Authors:
- *    Rickard E. (Rik) Faith <faith@valinux.com>
- *
- */
-
-#define __NO_VERSION__
-#include "drmP.h"
-
-#include <vm/vm.h>
-#include <vm/pmap.h>
-
-static int drm_dma_mmap(dev_t kdev, vm_offset_t offset, int prot)
-{
-	drm_device_t	 *dev	 = kdev->si_drv1;
-	drm_device_dma_t *dma	 = dev->dma;
-	unsigned long	 physical;
-	unsigned long	 page;
-
-	if (!dma)		   return -1; /* Error */
-	if (!dma->pagelist)	   return -1; /* Nothing allocated */
-
-	page	 = offset >> PAGE_SHIFT;
-	physical = dma->pagelist[page];
-
-	DRM_DEBUG("0x%08x (page %lu) => 0x%08lx\n", offset, page, physical);
-	return atop(physical);
-}
-
-int drm_mmap(dev_t kdev, vm_offset_t offset, int prot)
-{
-	drm_device_t	*dev	= kdev->si_drv1;
-	drm_map_t	*map	= NULL;
-	int		i;
-	
-	/* DRM_DEBUG("offset = 0x%x\n", offset); */
-
-	if (dev->dma
-	    && offset >= 0
-	    && offset < ptoa(dev->dma->page_count))
-		return drm_dma_mmap(kdev, offset, prot);
-
-				/* A sequential search of a linked list is
-				   fine here because: 1) there will only be
-				   about 5-10 entries in the list and, 2) a
-				   DRI client only has to do this mapping
-				   once, so it doesn't have to be optimized
-				   for performance, even if the list was a
-				   bit longer. */
-	for (i = 0; i < dev->map_count; i++) {
-		map = dev->maplist[i];
-		/* DRM_DEBUG("considering 0x%x..0x%x\n", map->offset, map->offset + map->size - 1); */
-		if (offset >= map->offset
-		    && offset < map->offset + map->size) break;
-	}
-	
-	if (i >= dev->map_count) {
-		DRM_DEBUG("can't find map\n");
-		return -1;
-	}
-	if (!map || ((map->flags&_DRM_RESTRICTED) && suser(curproc))) {
-		DRM_DEBUG("restricted map\n");
-		return -1;
-	}
-
-	switch (map->type) {
-	case _DRM_FRAME_BUFFER:
-	case _DRM_REGISTERS:
-	case _DRM_AGP:
-		return atop(offset);
-	case _DRM_SHM:
-		return atop(vtophys(offset));
-	default:
-		return -1;	/* This should never happen. */
-	}
-	DRM_DEBUG("bailing out\n");
-	
-	return -1;
-}
diff --git a/bsd/drmP.h b/bsd/drmP.h
index 7a1159c7..ead40f86 100644
--- a/bsd/drmP.h
+++ b/bsd/drmP.h
@@ -1,8 +1,8 @@
-/* drmP.h -- Private header for Direct Rendering Manager -*- c -*-
+/* drmP.h -- Private header for Direct Rendering Manager -*- linux-c -*-
  * Created: Mon Jan  4 10:05:05 1999 by faith@precisioninsight.com
- * Revised: Tue Oct 12 08:51:07 1999 by faith@precisioninsight.com
  *
  * Copyright 1999 Precision Insight, Inc., Cedar Park, Texas.
+ * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
  * All rights reserved.
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
@@ -11,225 +11,119 @@
  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  * and/or sell copies of the Software, and to permit persons to whom the
  * Software is furnished to do so, subject to the following conditions:
- * 
+ *
  * The above copyright notice and this permission notice (including the next
  * paragraph) shall be included in all copies or substantial portions of the
  * Software.
- * 
+ *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+ * VA LINUX SYSTEMS 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.
- * 
- * $PI: xc/programs/Xserver/hw/xfree86/os-support/linux/drm/kernel/drmP.h,v 1.58 1999/08/30 13:05:00 faith Exp $
- * $XFree86: xc/programs/Xserver/hw/xfree86/os-support/bsd/drm/kernel/drmP.h,v 1.3 2001/03/06 16:45:26 dawes Exp $
- * 
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Authors:
+ *    Rickard E. (Rik) Faith <faith@valinux.com>
+ *    Gareth Hughes <gareth@valinux.com>
  */
 
 #ifndef _DRM_P_H_
 #define _DRM_P_H_
 
-#ifdef _KERNEL
-#include <sys/param.h>
-#include <sys/queue.h>
-#include <sys/malloc.h>
-#include <sys/kernel.h>
-#include <sys/module.h>
-#include <sys/systm.h>
-#include <sys/conf.h>
-#include <sys/stat.h>
-#include <sys/proc.h>
-#include <sys/lock.h>
-#include <sys/fcntl.h>
-#include <sys/uio.h>
-#include <sys/filio.h>
-#include <sys/sysctl.h>
-#include <sys/select.h>
-#include <sys/bus.h>
-#if __FreeBSD_version >= 400005
-#include <sys/taskqueue.h>
-#endif
+#if defined(_KERNEL) || defined(__KERNEL__)
 
-#if __FreeBSD_version >= 400006
-#define DRM_AGP
+/* DRM template customization defaults
+ */
+#ifndef __HAVE_AGP
+#define __HAVE_AGP		0
 #endif
-
-#ifdef DRM_AGP
-#include <pci/agpvar.h>
+#ifndef __HAVE_MTRR
+#define __HAVE_MTRR		0
+#endif
+#ifndef __HAVE_CTX_BITMAP
+#define __HAVE_CTX_BITMAP	0
+#endif
+#ifndef __HAVE_DMA
+#define __HAVE_DMA		0
+#endif
+#ifndef __HAVE_DMA_IRQ
+#define __HAVE_DMA_IRQ		0
+#endif
+#ifndef __HAVE_DMA_WAITLIST
+#define __HAVE_DMA_WAITLIST	0
+#endif
+#ifndef __HAVE_DMA_FREELIST
+#define __HAVE_DMA_FREELIST	0
+#endif
+#ifndef __HAVE_DMA_HISTOGRAM
+#define __HAVE_DMA_HISTOGRAM	0
 #endif
 
-#include "drm.h"
+#define DRM_DEBUG_CODE 0	  /* Include debugging code (if > 1, then
+				     also include looping detection. */
 
-typedef u_int32_t atomic_t;
-typedef u_int32_t cycles_t;
-typedef u_int32_t spinlock_t;
-#define atomic_set(p, v)	(*(p) = (v))
-#define atomic_read(p)		(*(p))
-#define atomic_inc(p)		atomic_add_int(p, 1)
-#define atomic_dec(p)		atomic_subtract_int(p, 1)
-#define atomic_add(n, p)	atomic_add_int(p, n)
-#define atomic_sub(n, p)	atomic_subtract_int(p, n)
-
-/* The version number here is a guess */
-#if __FreeBSD_version >= 500010
-#define callout_init(a)		callout_init(a, 0)
-#endif
+typedef struct drm_device drm_device_t;
+typedef struct drm_file drm_file_t;
 
-/* Fake this */
-static __inline u_int32_t
-test_and_set_bit(int b, volatile u_int32_t *p)
-{
-	int s = splhigh();
-	u_int32_t m = 1<<b;
-	u_int32_t r = *p & m;
-	*p |= m;
-	splx(s);
-	return r;
-}
-
-static __inline void
-clear_bit(int b, volatile u_int32_t *p)
-{
-    atomic_clear_int(p + (b >> 5), 1 << (b & 0x1f));
-}
-
-static __inline void
-set_bit(int b, volatile u_int32_t *p)
-{
-    atomic_set_int(p + (b >> 5), 1 << (b & 0x1f));
-}
-
-static __inline int
-test_bit(int b, volatile u_int32_t *p)
-{
-    return p[b >> 5] & (1 << (b & 0x1f));
-}
-
-static __inline int
-find_first_zero_bit(volatile u_int32_t *p, int max)
-{
-    int b;
-
-    for (b = 0; b < max; b += 32) {
-	if (p[b >> 5] != ~0) {
-	    for (;;) {
-		if ((p[b >> 5] & (1 << (b & 0x1f))) == 0)
-		    return b;
-		b++;
-	    }
-	}
-    }
-    return max;
-}
-
-#define spldrm()		spltty()
-
-#define memset(p, v, s)		bzero(p, s)
-
-/*
- * Fake out the module macros for versions of FreeBSD where they don't
- * exist.
- */
-#if __FreeBSD_version < 400002
+/* There's undoubtably more of this file to go into these OS dependent ones. */
 
-#define MODULE_VERSION(a,b)		struct __hack
-#define MODULE_DEPEND(a,b,c,d,e)	struct __hack
+#include "drm_os_freebsd.h"
 
-#endif
+#include "drm.h"
 
-#define DRM_DEBUG_CODE 0	  /* Include debugging code (if > 1, then
-				     also include looping detection. */
-#define DRM_DMA_HISTOGRAM 1	  /* Make histogram of DMA latency. */
+/* Begin the DRM... */
 
 #define DRM_HASH_SIZE	      16 /* Size of key hash table		  */
 #define DRM_KERNEL_CONTEXT    0	 /* Change drm_resctx if changed	  */
 #define DRM_RESERVED_CONTEXTS 1	 /* Change drm_resctx if changed	  */
 #define DRM_LOOPING_LIMIT     5000000
 #define DRM_BSZ		      1024 /* Buffer size for /dev/drm? output	  */
-#define DRM_TIME_SLICE	      (hz/20) /* Time slice for GLXContexts       */
 #define DRM_LOCK_SLICE	      1	/* Time slice for lock, in jiffies	  */
 
 #define DRM_FLAG_DEBUG	  0x01
 #define DRM_FLAG_NOCTX	  0x02
 
-#define DRM_MEM_DMA	  0
-#define DRM_MEM_SAREA	  1
-#define DRM_MEM_DRIVER	  2
-#define DRM_MEM_MAGIC	  3
-#define DRM_MEM_IOCTLS	  4
-#define DRM_MEM_MAPS	  5
-#define DRM_MEM_VMAS	  6
-#define DRM_MEM_BUFS	  7
-#define DRM_MEM_SEGS	  8
-#define DRM_MEM_PAGES	  9
-#define DRM_MEM_FILES	 10
-#define DRM_MEM_QUEUES	 11
-#define DRM_MEM_CMDS	 12
-#define DRM_MEM_MAPPINGS 13
-#define DRM_MEM_BUFLISTS 14
+#define DRM_MEM_DMA	   0
+#define DRM_MEM_SAREA	   1
+#define DRM_MEM_DRIVER	   2
+#define DRM_MEM_MAGIC	   3
+#define DRM_MEM_IOCTLS	   4
+#define DRM_MEM_MAPS	   5
+#define DRM_MEM_VMAS	   6
+#define DRM_MEM_BUFS	   7
+#define DRM_MEM_SEGS	   8
+#define DRM_MEM_PAGES	   9
+#define DRM_MEM_FILES	  10
+#define DRM_MEM_QUEUES	  11
+#define DRM_MEM_CMDS	  12
+#define DRM_MEM_MAPPINGS  13
+#define DRM_MEM_BUFLISTS  14
 #define DRM_MEM_AGPLISTS  15
 #define DRM_MEM_TOTALAGP  16
 #define DRM_MEM_BOUNDAGP  17
 #define DRM_MEM_CTXBITMAP 18
+#define DRM_MEM_STUB      19
+#define DRM_MEM_SGLISTS   20
 
 #define DRM_MAX_CTXBITMAP (PAGE_SIZE * 8)
 
 				/* Backward compatibility section */
+				/* _PAGE_WT changed to _PAGE_PWT in 2.2.6 */
 #ifndef _PAGE_PWT
-				/* The name of _PAGE_WT was changed to
-				   _PAGE_PWT in Linux 2.2.6 */
 #define _PAGE_PWT _PAGE_WT
 #endif
 
-#define __drm_dummy_lock(lock) (*(__volatile__ unsigned int *)lock)
-#define _DRM_CAS(lock,old,new,__ret)				       \
-	do {							       \
-		int __dummy;	/* Can't mark eax as clobbered */      \
-		__asm__ __volatile__(				       \
-			"lock ; cmpxchg %4,%1\n\t"		       \
-			"setnz %0"				       \
-			: "=d" (__ret),				       \
-			  "=m" (__drm_dummy_lock(lock)),	       \
-			  "=a" (__dummy)			       \
-			: "2" (old),				       \
-			  "r" (new));				       \
-	} while (0)
-
+				/* Mapping helper macros */
+#define DRM_IOREMAP(map)						\
+	(map)->handle = DRM(ioremap)( (map)->offset, (map)->size )
 
-
-				/* Macros to make printk easier */
-#define DRM_ERROR(fmt, arg...) \
-	printf("error: " "[" DRM_NAME ":" __FUNCTION__ "] *ERROR* " fmt , ##arg)
-#define DRM_MEM_ERROR(area, fmt, arg...) \
-	printf("error: " "[" DRM_NAME ":" __FUNCTION__ ":%s] *ERROR* " fmt , \
-	       drm_mem_stats[area].name , ##arg)
-#define DRM_INFO(fmt, arg...)  printf("info: " "[" DRM_NAME "] " fmt , ##arg)
-
-#if DRM_DEBUG_CODE
-#define DRM_DEBUG(fmt, arg...)						  \
-	do {								  \
-		if (drm_flags&DRM_FLAG_DEBUG)				  \
-			printf("[" DRM_NAME ":" __FUNCTION__ "] " fmt ,	  \
-			       ##arg);					  \
+#define DRM_IOREMAPFREE(map)						\
+	do {								\
+		if ( (map)->handle && (map)->size )			\
+			DRM(ioremapfree)( (map)->handle, (map)->size );	\
 	} while (0)
-#else
-#define DRM_DEBUG(fmt, arg...)		 do { } while (0)
-#endif
-
-#define DRM_PROC_LIMIT (PAGE_SIZE-80)
-
-#define DRM_SYSCTL_PRINT(fmt, arg...)		\
-  snprintf(buf, sizeof(buf), fmt, ##arg);	\
-  error = SYSCTL_OUT(req, buf, strlen(buf));	\
-  if (error) return error;
-
-#define DRM_SYSCTL_PRINT_RET(ret, fmt, arg...)	\
-  snprintf(buf, sizeof(buf), fmt, ##arg);	\
-  error = SYSCTL_OUT(req, buf, strlen(buf));	\
-  if (error) { ret; return error; }
 
 				/* Internal types and structures */
 #define DRM_ARRAY_SIZE(x) (sizeof(x)/sizeof(x[0]))
@@ -240,15 +134,25 @@ find_first_zero_bit(volatile u_int32_t *p, int max)
 #define DRM_BUFCOUNT(x) ((x)->count - DRM_LEFTCOUNT(x))
 #define DRM_WAITCOUNT(dev,idx) DRM_BUFCOUNT(&dev->queuelist[idx]->waitlist)
 
+#define DRM_GET_PRIV_SAREA(_dev, _ctx, _map) do {	\
+	(_map) = (_dev)->context_sareas[_ctx];		\
+} while(0)
+
+
+typedef struct drm_pci_list {
+	u16 vendor;
+	u16 device;
+} drm_pci_list_t;
+
 typedef struct drm_ioctl_desc {
-	d_ioctl_t	     *func;
+	d_ioctl_t            *func;
 	int		     auth_needed;
 	int		     root_only;
 } drm_ioctl_desc_t;
 
 typedef struct drm_devstate {
 	pid_t		  owner;	/* X server pid holding x_lock */
-	
+
 } drm_devstate_t;
 
 typedef struct drm_magic_entry {
@@ -258,8 +162,8 @@ typedef struct drm_magic_entry {
 } drm_magic_entry_t;
 
 typedef struct drm_magic_head {
-       struct drm_magic_entry *head;
-       struct drm_magic_entry *tail;
+	struct drm_magic_entry *head;
+	struct drm_magic_entry *tail;
 } drm_magic_head_t;
 
 typedef struct drm_vma_entry {
@@ -279,7 +183,7 @@ typedef struct drm_buf {
 	struct drm_buf	  *next;       /* Kernel-only: used for free list    */
 	__volatile__ int  waiting;     /* On kernel DMA queue		     */
 	__volatile__ int  pending;     /* On hardware DMA queue		     */
-	int		  dma_wait;    /* Processes waiting		     */
+	wait_queue_head_t dma_wait;    /* Processes waiting		     */
 	pid_t		  pid;	       /* PID of holding process	     */
 	int		  context;     /* Kernel queue for this buffer	     */
 	int		  while_locked;/* Dispatch this buffer while locked  */
@@ -292,15 +196,15 @@ typedef struct drm_buf {
 		DRM_LIST_RECLAIM = 5
 	}		  list;	       /* Which list we're on		     */
 
-	void *dev_private;
-	int dev_priv_size;
-
 #if DRM_DMA_HISTOGRAM
-	struct timespec	  time_queued;	   /* Queued to kernel DMA queue     */
-	struct timespec	  time_dispatched; /* Dispatched to hardware	     */
-	struct timespec	  time_completed;  /* Completed by hardware	     */
-	struct timespec	  time_freed;	   /* Back on freelist		     */
+	cycles_t	  time_queued;	   /* Queued to kernel DMA queue     */
+	cycles_t	  time_dispatched; /* Dispatched to hardware	     */
+	cycles_t	  time_completed;  /* Completed by hardware	     */
+	cycles_t	  time_freed;	   /* Back on freelist		     */
 #endif
+
+	int		  dev_priv_size; /* Size of buffer private stoarge   */
+	void		  *dev_private;  /* Per-buffer private storage       */
 } drm_buf_t;
 
 #if DRM_DMA_HISTOGRAM
@@ -309,14 +213,14 @@ typedef struct drm_buf {
 #define DRM_DMA_HISTOGRAM_NEXT(current)	 ((current)*10)
 typedef struct drm_histogram {
 	atomic_t	  total;
-	
+
 	atomic_t	  queued_to_dispatched[DRM_DMA_HISTOGRAM_SLOTS];
 	atomic_t	  dispatched_to_completed[DRM_DMA_HISTOGRAM_SLOTS];
 	atomic_t	  completed_to_freed[DRM_DMA_HISTOGRAM_SLOTS];
-	
+
 	atomic_t	  queued_to_completed[DRM_DMA_HISTOGRAM_SLOTS];
 	atomic_t	  queued_to_freed[DRM_DMA_HISTOGRAM_SLOTS];
-	
+
 	atomic_t	  dma[DRM_DMA_HISTOGRAM_SLOTS];
 	atomic_t	  schedule[DRM_DMA_HISTOGRAM_SLOTS];
 	atomic_t	  ctx[DRM_DMA_HISTOGRAM_SLOTS];
@@ -332,20 +236,20 @@ typedef struct drm_waitlist {
 	drm_buf_t	  **rp;		/* Read pointer			   */
 	drm_buf_t	  **wp;		/* Write pointer		   */
 	drm_buf_t	  **end;	/* End pointer			   */
-	spinlock_t	  read_lock;
-	spinlock_t	  write_lock;
+	DRM_OS_SPINTYPE	  read_lock;
+	DRM_OS_SPINTYPE	  write_lock;
 } drm_waitlist_t;
 
 typedef struct drm_freelist {
 	int		  initialized; /* Freelist in use		   */
 	atomic_t	  count;       /* Number of free buffers	   */
 	drm_buf_t	  *next;       /* End pointer			   */
-	
-	int		  waiting;     /* Processes waiting on free bufs   */
+
+	wait_queue_head_t waiting;     /* Processes waiting on free bufs   */
 	int		  low_mark;    /* Low water mark		   */
 	int		  high_mark;   /* High water mark		   */
 	atomic_t	  wfh;	       /* If waiting for high mark	   */
-	struct simplelock	  lock;	       /* hope this doesn't need to be linux compatible */
+	DRM_OS_SPINTYPE   lock;
 } drm_freelist_t;
 
 typedef struct drm_buf_entry {
@@ -365,7 +269,7 @@ typedef struct drm_hw_lock {
 } drm_hw_lock_t;
 
 typedef TAILQ_HEAD(drm_file_list, drm_file) drm_file_list_t;
-typedef struct drm_file {
+struct drm_file {
 	TAILQ_ENTRY(drm_file) link;
 	int		  authenticated;
 	int		  minor;
@@ -375,38 +279,40 @@ typedef struct drm_file {
 	drm_magic_t	  magic;
 	unsigned long	  ioctl_count;
 	struct drm_device *devXX;
-} drm_file_t;
-
+};
 
 typedef struct drm_queue {
 	atomic_t	  use_count;	/* Outstanding uses (+1)	    */
 	atomic_t	  finalization;	/* Finalization in progress	    */
 	atomic_t	  block_count;	/* Count of processes waiting	    */
 	atomic_t	  block_read;	/* Queue blocked for reads	    */
-	int		  read_queue;	/* Processes waiting on block_read  */
+	wait_queue_head_t read_queue;	/* Processes waiting on block_read  */
 	atomic_t	  block_write;	/* Queue blocked for writes	    */
-	int		  write_queue;	/* Processes waiting on block_write */
+	wait_queue_head_t write_queue;	/* Processes waiting on block_write */
+#if 1
 	atomic_t	  total_queued;	/* Total queued statistic	    */
 	atomic_t	  total_flushed;/* Total flushes statistic	    */
 	atomic_t	  total_locks;	/* Total locks statistics	    */
+#endif
 	drm_ctx_flags_t	  flags;	/* Context preserving and 2D-only   */
 	drm_waitlist_t	  waitlist;	/* Pending buffers		    */
-	int		  flush_queue;	/* Processes waiting until flush    */
+	wait_queue_head_t flush_queue;	/* Processes waiting until flush    */
 } drm_queue_t;
 
 typedef struct drm_lock_data {
 	drm_hw_lock_t	  *hw_lock;	/* Hardware lock		   */
 	pid_t		  pid;		/* PID of lock holder (0=kernel)   */
-	int		  lock_queue;	/* Queue of blocked processes	   */
+	wait_queue_head_t lock_queue;	/* Queue of blocked processes	   */
 	unsigned long	  lock_time;	/* Time of last lock in jiffies	   */
 } drm_lock_data_t;
 
 typedef struct drm_device_dma {
+#if 0
 				/* Performance Counters */
 	atomic_t	  total_prio;	/* Total DRM_DMA_PRIORITY	   */
 	atomic_t	  total_bytes;	/* Total bytes DMA'd		   */
 	atomic_t	  total_dmas;	/* Total DMA buffers dispatched	   */
-	
+
 	atomic_t	  total_missed_dma;  /* Missed drm_do_dma	    */
 	atomic_t	  total_missed_lock; /* Missed lock in drm_do_dma   */
 	atomic_t	  total_missed_free; /* Missed drm_free_this_buffer */
@@ -415,27 +321,28 @@ typedef struct drm_device_dma {
 	atomic_t	  total_tried;	/* Tried next_buffer		    */
 	atomic_t	  total_hit;	/* Sent next_buffer		    */
 	atomic_t	  total_lost;	/* Lost interrupt		    */
+#endif
 
 	drm_buf_entry_t	  bufs[DRM_MAX_ORDER+1];
 	int		  buf_count;
 	drm_buf_t	  **buflist;	/* Vector of pointers info bufs	   */
-	int		  seg_count; 
+	int		  seg_count;
 	int		  page_count;
-	vm_offset_t	  *pagelist;
+	unsigned long	  *pagelist;
 	unsigned long	  byte_count;
 	enum {
-	   _DRM_DMA_USE_AGP = 0x01
+		_DRM_DMA_USE_AGP = 0x01,
+		_DRM_DMA_USE_SG  = 0x02
 	} flags;
 
 				/* DMA support */
 	drm_buf_t	  *this_buffer;	/* Buffer being sent		   */
 	drm_buf_t	  *next_buffer; /* Selected buffer to send	   */
 	drm_queue_t	  *next_queue;	/* Queue from which buffer selected*/
-	int		   waiting;	/* Processes waiting on free bufs  */
+	wait_queue_head_t waiting;	/* Processes waiting on free bufs  */
 } drm_device_dma_t;
 
-#ifdef DRM_AGP
-
+#if __REALLY_HAVE_AGP
 typedef struct drm_agp_mem {
 	void               *handle;
 	unsigned long      bound; /* address */
@@ -454,27 +361,45 @@ typedef struct drm_agp_head {
 	int                acquired;
 	unsigned long      base;
    	int 		   agp_mtrr;
+	int		   cant_use_aperture;
+	unsigned long	   page_mask;
 } drm_agp_head_t;
-
 #endif
 
-typedef struct drm_device {
+typedef struct drm_sg_mem {
+	unsigned long   handle;
+	void            *virtual;
+	int             pages;
+	struct page     **pagelist;
+} drm_sg_mem_t;
+
+typedef struct drm_sigdata {
+	int           context;
+	drm_hw_lock_t *lock;
+} drm_sigdata_t;
+
+typedef TAILQ_HEAD(drm_map_list, drm_map_list_entry) drm_map_list_t;
+typedef struct drm_map_list_entry {
+	TAILQ_ENTRY(drm_map_list_entry) link;
+	drm_map_t	*map;
+} drm_map_list_entry_t;
+
+struct drm_device {
 	const char	  *name;	/* Simple driver name		   */
 	char		  *unique;	/* Unique identifier: e.g., busid  */
 	int		  unique_len;	/* Length of unique field	   */
 	device_t	  device;	/* Device instance from newbus     */
 	dev_t		  devnode;	/* Device number for mknod	   */
 	char		  *devname;	/* For /proc/interrupts		   */
-	
+
 	int		  blocked;	/* Blocked due to VC switch?	   */
 	int		  flags;	/* Flags to open(2)		   */
 	int		  writable;	/* Opened with FWRITE		   */
 	struct proc_dir_entry *root;	/* Root for this device's entries  */
 
 				/* Locks */
-	struct simplelock count_lock;	/* For inuse, open_count, buf_use  */
-	struct lock	  dev_lock;	/* For others			   */
-
+	DRM_OS_SPINTYPE	  count_lock;	/* For inuse, open_count, buf_use  */
+	struct lock       dev_lock;	/* For others			   */
 				/* Usage Counters */
 	int		  open_count;	/* Outstanding files open	   */
 	atomic_t	  ioctl_count;	/* Outstanding IOCTLs pending	   */
@@ -482,26 +407,22 @@ typedef struct drm_device {
 	int		  buf_use;	/* Buffers in use -- cannot alloc  */
 	atomic_t	  buf_alloc;	/* Buffer allocation in progress   */
 
-				/* Performance Counters */
-	atomic_t	  total_open;
-	atomic_t	  total_close;
-	atomic_t	  total_ioctl;
-	atomic_t	  total_irq;	/* Total interruptions		   */
-	atomic_t	  total_ctx;	/* Total context switches	   */
-	
-	atomic_t	  total_locks;
-	atomic_t	  total_unlocks;
-	atomic_t	  total_contends;
-	atomic_t	  total_sleeps;
+				/* Performance counters */
+	unsigned long     counters;
+	drm_stat_type_t   types[15];
+	atomic_t          counts[15];
 
 				/* Authentication */
 	drm_file_list_t   files;
 	drm_magic_head_t  magiclist[DRM_HASH_SIZE];
 
 				/* Memory management */
-	drm_map_t	  **maplist;	/* Vector of pointers to regions   */
+	drm_map_list_t	  *maplist;	/* Linked list of regions	   */
 	int		  map_count;	/* Number of mappable regions	   */
 
+	drm_map_t	  **context_sareas;
+	int		  max_context;
+
 	drm_vma_entry_t	  *vmalist;	/* List of vmas (for debugging)	   */
 	drm_lock_data_t	  lock;		/* Information on hardware lock	   */
 
@@ -513,223 +434,199 @@ typedef struct drm_device {
 	drm_device_dma_t  *dma;		/* Optional pointer for DMA support */
 
 				/* Context support */
-	struct resource   *irq;		/* Interrupt used by board	   */
+	int		  irq;		/* Interrupt used by board	   */
+	struct resource   *irqr;	/* Resource for interrupt used by board	   */
 	void		  *irqh;	/* Handle from bus_setup_intr      */
-	__volatile__ long  context_flag; /* Context swapping flag	   */
-	__volatile__ long  interrupt_flag;/* Interruption handler flag	   */
-	__volatile__ long  dma_flag;	 /* DMA dispatch flag		   */
-	struct callout	  timer;	/* Timer for delaying ctx switch   */
-	int		  context_wait; /* Processes waiting on ctx switch */
+	__volatile__ long context_flag;	/* Context swapping flag	   */
+	__volatile__ long interrupt_flag; /* Interruption handler flag	   */
+	__volatile__ long dma_flag;	/* DMA dispatch flag		   */
+	struct callout    timer;	/* Timer for delaying ctx switch   */
+	wait_queue_head_t context_wait; /* Processes waiting on ctx switch */
 	int		  last_checked;	/* Last context checked for DMA	   */
 	int		  last_context;	/* Last current context		   */
-	int		  last_switch;	/* Time at last context switch  */
+	unsigned long	  last_switch;	/* jiffies at last context switch  */
 #if __FreeBSD_version >= 400005
-	struct task	  task;
+	struct task       task;
 #endif
-	struct timespec	  ctx_start;
-	struct timespec	  lck_start;
-#if DRM_DMA_HISTOGRAM
+	cycles_t	  ctx_start;
+	cycles_t	  lck_start;
+#if __HAVE_DMA_HISTOGRAM
 	drm_histogram_t	  histo;
 #endif
-	
+
 				/* Callback to X server for context switch
 				   and for heavy-handed reset. */
 	char		  buf[DRM_BSZ]; /* Output buffer		   */
 	char		  *buf_rp;	/* Read pointer			   */
 	char		  *buf_wp;	/* Write pointer		   */
 	char		  *buf_end;	/* End pointer			   */
-	struct sigio	  *buf_sigio;   /* Processes waiting for SIGIO	   */
+	struct sigio      *buf_sigio;	/* Processes waiting for SIGIO     */
 	struct selinfo    buf_sel;	/* Workspace for select/poll       */
-	int		  buf_readers;	/* Processes waiting to read	   */
-	int		  buf_writers;	/* Processes waiting to ctx switch */
-	int		  buf_selecting; /* True if poll sleeper           */
+	int               buf_selecting;/* True if poll sleeper            */
+	wait_queue_head_t buf_readers;	/* Processes waiting to read	   */
+	wait_queue_head_t buf_writers;	/* Processes waiting to ctx switch */
 
 				/* Sysctl support */
 	struct drm_sysctl_info *sysctl;
 
-#ifdef DRM_AGP
+#if __REALLY_HAVE_AGP
 	drm_agp_head_t    *agp;
 #endif
-	u_int32_t	  *ctx_bitmap;
+	struct pci_dev *pdev;
+#ifdef __alpha__
+#if LINUX_VERSION_CODE < 0x020403
+	struct pci_controler *hose;
+#else
+	struct pci_controller *hose;
+#endif
+#endif
+	drm_sg_mem_t      *sg;  /* Scatter gather memory */
+	unsigned long     *ctx_bitmap;
 	void		  *dev_private;
-} drm_device_t;
-
-
-				/* Internal function definitions */
-
-				/* Misc. support (init.c) */
-extern int	     drm_flags;
-extern void	     drm_parse_options(char *s);
-
-
-				/* Device support (fops.c) */
-extern drm_file_t *drm_find_file_by_proc(drm_device_t *dev, struct proc *p);
-extern int drm_open_helper(dev_t kdev, int flags, int fmt, struct proc *p,
-			   drm_device_t *dev);
-extern d_close_t     drm_close;
-extern d_read_t	     drm_read;
-extern d_write_t     drm_write;
-extern d_poll_t	     drm_poll;
-extern int	     drm_fsetown(dev_t kdev, u_long cmd, caddr_t data,
-				 int flags, struct proc *p);
-extern int	     drm_fgetown(dev_t kdev, u_long cmd, caddr_t data,
-				 int flags, struct proc *p);
-extern int	     drm_write_string(drm_device_t *dev, const char *s);
-
-#if 0
-				/* Mapping support (vm.c) */
-extern unsigned long drm_vm_nopage(struct vm_area_struct *vma,
-				   unsigned long address,
-				   int write_access);
-extern unsigned long drm_vm_shm_nopage(struct vm_area_struct *vma,
-				       unsigned long address,
-				       int write_access);
-extern unsigned long drm_vm_dma_nopage(struct vm_area_struct *vma,
-				       unsigned long address,
-				       int write_access);
-extern void	     drm_vm_open(struct vm_area_struct *vma);
-extern void	     drm_vm_close(struct vm_area_struct *vma);
-extern int	     drm_mmap_dma(struct file *filp,
-				  struct vm_area_struct *vma);
+	drm_sigdata_t     sigdata; /* For block_all_signals */
+	sigset_t          sigmask;
+};
+
+extern int	     DRM(flags);
+extern void	     DRM(parse_options)( char *s );
+extern int           DRM(cpu_valid)( void );
+
+				/* Authentication (drm_auth.h) */
+extern int           DRM(add_magic)(drm_device_t *dev, drm_file_t *priv, 
+				    drm_magic_t magic);
+extern int           DRM(remove_magic)(drm_device_t *dev, drm_magic_t magic);
+
+				/* Driver support (drm_drv.h) */
+extern int           DRM(version)( DRM_OS_IOCTL );
+extern int	     DRM(write_string)(drm_device_t *dev, const char *s);
+
+				/* Memory management support (drm_memory.h) */
+extern void	     DRM(mem_init)(void);
+extern void	     *DRM(alloc)(size_t size, int area);
+extern void	     *DRM(realloc)(void *oldpt, size_t oldsize, size_t size,
+				   int area);
+extern char	     *DRM(strdup)(const char *s, int area);
+extern void	     DRM(strfree)(char *s, int area);
+extern void	     DRM(free)(void *pt, size_t size, int area);
+extern unsigned long DRM(alloc_pages)(int order, int area);
+extern void	     DRM(free_pages)(unsigned long address, int order,
+				     int area);
+extern void	     *DRM(ioremap)(unsigned long offset, unsigned long size);
+extern void	     DRM(ioremapfree)(void *pt, unsigned long size);
+
+#if __REALLY_HAVE_AGP
+extern agp_memory    *DRM(alloc_agp)(int pages, u32 type);
+extern int           DRM(free_agp)(agp_memory *handle, int pages);
+extern int           DRM(bind_agp)(agp_memory *handle, unsigned int start);
+extern int           DRM(unbind_agp)(agp_memory *handle);
 #endif
-extern d_mmap_t	     drm_mmap;
 
-				/* Proc support (proc.c) */
-extern int	     drm_sysctl_init(drm_device_t *dev);
-extern int	     drm_sysctl_cleanup(drm_device_t *dev);
+extern int	     DRM(context_switch)(drm_device_t *dev, int old, int new);
+extern int	     DRM(context_switch_complete)(drm_device_t *dev, int new);
 
-				/* Memory management support (memory.c) */
-extern void	     drm_mem_init(void);
+#if __HAVE_CTX_BITMAP
+extern int	     DRM(ctxbitmap_init)( drm_device_t *dev );
+extern void	     DRM(ctxbitmap_cleanup)( drm_device_t *dev );
+extern void          DRM(ctxbitmap_free)( drm_device_t *dev, int ctx_handle );
+extern int           DRM(ctxbitmap_next)( drm_device_t *dev );
+#endif
 
-#if __FreeBSD_version < 411000
-#define DRM_SYSCTL_HANDLER_ARGS SYSCTL_HANDLER_ARGS
-#else
-#define DRM_SYSCTL_HANDLER_ARGS (SYSCTL_HANDLER_ARGS)
+				/* Locking IOCTL support (drm_lock.h) */
+extern int	     DRM(lock_take)(__volatile__ unsigned int *lock,
+				    unsigned int context);
+extern int	     DRM(lock_transfer)(drm_device_t *dev,
+					__volatile__ unsigned int *lock,
+					unsigned int context);
+extern int	     DRM(lock_free)(drm_device_t *dev,
+				    __volatile__ unsigned int *lock,
+				    unsigned int context);
+extern int	     DRM(flush_unblock)(drm_device_t *dev, int context,
+					drm_lock_flags_t flags);
+extern int	     DRM(flush_block_and_flush)(drm_device_t *dev, int context,
+						drm_lock_flags_t flags);
+extern int           DRM(notifier)(void *priv);
+
+				/* Buffer management support (drm_bufs.h) */
+extern int	     DRM(order)( unsigned long size );
+
+#if __HAVE_DMA
+				/* DMA support (drm_dma.h) */
+extern int	     DRM(dma_setup)(drm_device_t *dev);
+extern void	     DRM(dma_takedown)(drm_device_t *dev);
+extern void	     DRM(free_buffer)(drm_device_t *dev, drm_buf_t *buf);
+extern void	     DRM(reclaim_buffers)(drm_device_t *dev, pid_t pid);
+#if __HAVE_OLD_DMA
+/* GH: This is a dirty hack for now...
+ */
+extern void	     DRM(clear_next_buffer)(drm_device_t *dev);
+extern int	     DRM(select_queue)(drm_device_t *dev,
+				       void (*wrapper)(unsigned long));
+extern int	     DRM(dma_enqueue)(drm_device_t *dev, drm_dma_t *dma);
+extern int	     DRM(dma_get_buffers)(drm_device_t *dev, drm_dma_t *dma);
+#endif
+#if __HAVE_DMA_IRQ
+extern int           DRM(irq_install)( drm_device_t *dev, int irq );
+extern int           DRM(irq_uninstall)( drm_device_t *dev );
+extern void          DRM(dma_service)( DRM_OS_IRQ_ARGS );
+#if __HAVE_DMA_IRQ_BH
+extern void          DRM(dma_immediate_bh)( DRM_OS_TASKQUEUE_ARGS );
 #endif
-extern int	     drm_mem_info DRM_SYSCTL_HANDLER_ARGS;
-extern void	     *drm_alloc(size_t size, int area);
-extern void	     *drm_realloc(void *oldpt, size_t oldsize, size_t size,
-				  int area);
-extern char	     *drm_strdup(const char *s, int area);
-extern void	     drm_strfree(char *s, int area);
-extern void	     drm_free(void *pt, size_t size, int area);
-extern unsigned long drm_alloc_pages(int order, int area);
-extern void	     drm_free_pages(unsigned long address, int order,
-				    int area);
-extern void	     *drm_ioremap(unsigned long offset, unsigned long size);
-extern void	     drm_ioremapfree(void *pt, unsigned long size);
-
-#ifdef DRM_AGP
-extern void	    *drm_alloc_agp(int pages, u_int32_t type);
-extern int           drm_free_agp(void *handle, int pages);
-extern int           drm_bind_agp(void *handle, unsigned int start);
-extern int           drm_unbind_agp(void *handle);
 #endif
-
-				/* Buffer management support (bufs.c) */
-extern int	     drm_order(unsigned long size);
-extern d_ioctl_t     drm_addmap;
-extern d_ioctl_t     drm_addbufs;
-extern d_ioctl_t     drm_infobufs;
-extern d_ioctl_t     drm_markbufs;
-extern d_ioctl_t     drm_freebufs;
-extern d_ioctl_t     drm_mapbufs;
-
-
-				/* Buffer list management support (lists.c) */
-extern int	     drm_waitlist_create(drm_waitlist_t *bl, int count);
-extern int	     drm_waitlist_destroy(drm_waitlist_t *bl);
-extern int	     drm_waitlist_put(drm_waitlist_t *bl, drm_buf_t *buf);
-extern drm_buf_t     *drm_waitlist_get(drm_waitlist_t *bl);
-
-extern int	     drm_freelist_create(drm_freelist_t *bl, int count);
-extern int	     drm_freelist_destroy(drm_freelist_t *bl);
-extern int	     drm_freelist_put(drm_device_t *dev, drm_freelist_t *bl,
-				      drm_buf_t *buf);
-extern drm_buf_t     *drm_freelist_get(drm_freelist_t *bl, int block);
-
-				/* DMA support (gen_dma.c) */
-extern void	     drm_dma_setup(drm_device_t *dev);
-extern void	     drm_dma_takedown(drm_device_t *dev);
-extern void	     drm_free_buffer(drm_device_t *dev, drm_buf_t *buf);
-extern void	     drm_reclaim_buffers(drm_device_t *dev, pid_t pid);
-extern int	     drm_context_switch(drm_device_t *dev, int old, int new);
-extern int	     drm_context_switch_complete(drm_device_t *dev, int new);
-extern void	     drm_wakeup(drm_device_t *dev, drm_buf_t *buf);
-extern void	     drm_clear_next_buffer(drm_device_t *dev);
-extern int	     drm_select_queue(drm_device_t *dev,
-				      void (*wrapper)(void *));
-extern int	     drm_dma_enqueue(drm_device_t *dev, drm_dma_t *dma);
-extern int	     drm_dma_get_buffers(drm_device_t *dev, drm_dma_t *dma);
 #if DRM_DMA_HISTOGRAM
-extern int	     drm_histogram_slot(struct timespec *ts);
-extern void	     drm_histogram_compute(drm_device_t *dev, drm_buf_t *buf);
+extern int	     DRM(histogram_slot)(unsigned long count);
+extern void	     DRM(histogram_compute)(drm_device_t *dev, drm_buf_t *buf);
 #endif
 
+				/* Buffer list support (drm_lists.h) */
+#if __HAVE_DMA_WAITLIST
+extern int	     DRM(waitlist_create)(drm_waitlist_t *bl, int count);
+extern int	     DRM(waitlist_destroy)(drm_waitlist_t *bl);
+extern int	     DRM(waitlist_put)(drm_waitlist_t *bl, drm_buf_t *buf);
+extern drm_buf_t     *DRM(waitlist_get)(drm_waitlist_t *bl);
+#endif
+#if __HAVE_DMA_FREELIST
+extern int	     DRM(freelist_create)(drm_freelist_t *bl, int count);
+extern int	     DRM(freelist_destroy)(drm_freelist_t *bl);
+extern int	     DRM(freelist_put)(drm_device_t *dev, drm_freelist_t *bl,
+				       drm_buf_t *buf);
+extern drm_buf_t     *DRM(freelist_get)(drm_freelist_t *bl, int block);
+#endif
+#endif /* __HAVE_DMA */
+
+#if __REALLY_HAVE_AGP
+				/* AGP/GART support (drm_agpsupport.h) */
+extern drm_agp_head_t *DRM(agp_init)(void);
+extern void           DRM(agp_uninit)(void);
+extern void           DRM(agp_do_release)(void);
+extern agp_memory     *DRM(agp_allocate_memory)(size_t pages, u32 type);
+extern int            DRM(agp_free_memory)(agp_memory *handle);
+extern int            DRM(agp_bind_memory)(agp_memory *handle, off_t start);
+extern int            DRM(agp_unbind_memory)(agp_memory *handle);
+#endif
 
-				/* Misc. IOCTL support (ioctl.c) */
-extern d_ioctl_t     drm_irq_busid;
-extern d_ioctl_t     drm_getunique;
-extern d_ioctl_t     drm_setunique;
-
-
-				/* Context IOCTL support (context.c) */
-extern d_ioctl_t     drm_resctx;
-extern d_ioctl_t     drm_addctx;
-extern d_ioctl_t     drm_modctx;
-extern d_ioctl_t     drm_getctx;
-extern d_ioctl_t     drm_switchctx;
-extern d_ioctl_t     drm_newctx;
-extern d_ioctl_t     drm_rmctx;
-
-
-				/* Drawable IOCTL support (drawable.c) */
-extern d_ioctl_t     drm_adddraw;
-extern d_ioctl_t     drm_rmdraw;
-
-
-				/* Authentication IOCTL support (auth.c) */
-extern int	     drm_add_magic(drm_device_t *dev, drm_file_t *priv,
-				   drm_magic_t magic);
-extern int	     drm_remove_magic(drm_device_t *dev, drm_magic_t magic);
-extern d_ioctl_t     drm_getmagic;
-extern d_ioctl_t     drm_authmagic;
-
-
-				/* Locking IOCTL support (lock.c) */
-extern d_ioctl_t     drm_block;
-extern d_ioctl_t     drm_unblock;
-extern int	     drm_lock_take(__volatile__ unsigned int *lock,
-				   unsigned int context);
-extern int	     drm_lock_transfer(drm_device_t *dev,
-				       __volatile__ unsigned int *lock,
-				       unsigned int context);
-extern int	     drm_lock_free(drm_device_t *dev,
-				   __volatile__ unsigned int *lock,
-				   unsigned int context);
-extern d_ioctl_t     drm_finish;
-extern int	     drm_flush_unblock(drm_device_t *dev, int context,
-				       drm_lock_flags_t flags);
-extern int	     drm_flush_block_and_flush(drm_device_t *dev, int context,
-					       drm_lock_flags_t flags);
-
-				/* Context Bitmap support (ctxbitmap.c) */
-extern int	     drm_ctxbitmap_init(drm_device_t *dev);
-extern void	     drm_ctxbitmap_cleanup(drm_device_t *dev);
-extern int	     drm_ctxbitmap_next(drm_device_t *dev);
-extern void	     drm_ctxbitmap_free(drm_device_t *dev, int ctx_handle);
-
-#ifdef DRM_AGP
-				/* AGP/GART support (agpsupport.c) */
-extern drm_agp_head_t *drm_agp_init(void);
-extern d_ioctl_t     drm_agp_acquire;
-extern d_ioctl_t     drm_agp_release;
-extern d_ioctl_t     drm_agp_enable;
-extern d_ioctl_t     drm_agp_info;
-extern d_ioctl_t     drm_agp_alloc;
-extern d_ioctl_t     drm_agp_free;
-extern d_ioctl_t     drm_agp_unbind;
-extern d_ioctl_t     drm_agp_bind;
+				/* Proc support (drm_proc.h) */
+extern struct proc_dir_entry *DRM(proc_init)(drm_device_t *dev,
+					     int minor,
+					     struct proc_dir_entry *root,
+					     struct proc_dir_entry **dev_root);
+extern int            DRM(proc_cleanup)(int minor,
+					struct proc_dir_entry *root,
+					struct proc_dir_entry *dev_root);
+
+#if __HAVE_SG
+				/* Scatter Gather Support (drm_scatter.h) */
+extern void           DRM(sg_cleanup)(drm_sg_mem_t *entry);
 #endif
+
+#if __REALLY_HAVE_SG
+                               /* ATI PCIGART support (ati_pcigart.h) */
+extern int            DRM(ati_pcigart_init)(drm_device_t *dev,
+					    unsigned long *addr,
+					    dma_addr_t *bus_addr);
+extern int            DRM(ati_pcigart_cleanup)(drm_device_t *dev,
+					       unsigned long addr,
+					       dma_addr_t bus_addr);
 #endif
+
+#endif /* __KERNEL__ */
 #endif
diff --git a/bsd/gamma/Makefile b/bsd/gamma/Makefile
index 37f3f5e7..97bb1b69 100644
--- a/bsd/gamma/Makefile
+++ b/bsd/gamma/Makefile
@@ -1,10 +1,10 @@
 # $FreeBSD$
 
 KMOD	= gamma
+NOMAN=	YES
 SRCS    = gamma_drv.c gamma_dma.c
-SRCS   += device_if.h bus_if.h pci_if.h
+SRCS   += device_if.h bus_if.h pci_if.h opt_drm_linux.h
 CFLAGS += ${DEBUG_FLAGS} -I. -I..
-KMODDEPS = drm
 
 @:
 	ln -sf /sys @
@@ -12,4 +12,14 @@ KMODDEPS = drm
 machine:
 	ln -sf /sys/i386/include machine
 
+.if ${MACHINE_ARCH} == "i386"
+# This line enables linux ioctl handling
+# If you want support for this uncomment this line
+#TDFX_OPTS=     "\#define DRM_LINUX" 1
+.endif
+
+opt_drm_linux.h:
+	touch opt_drm_linux.h
+	echo $(TDFX_OPTS) >> opt_drm_linux.h
+
 .include <bsd.kmod.mk>
diff --git a/bsd/i810_drm.h b/bsd/i810_drm.h
new file mode 100644
index 00000000..f2114dd1
--- /dev/null
+++ b/bsd/i810_drm.h
@@ -0,0 +1,201 @@
+#ifndef _I810_DRM_H_
+#define _I810_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 _I810_DEFINES_
+#define _I810_DEFINES_
+
+#define I810_DMA_BUF_ORDER		12
+#define I810_DMA_BUF_SZ 		(1<<I810_DMA_BUF_ORDER)
+#define I810_DMA_BUF_NR 		256
+#define I810_NR_SAREA_CLIPRECTS 	8
+
+/* Each region is a minimum of 64k, and there are at most 64 of them.
+ */
+#define I810_NR_TEX_REGIONS 64
+#define I810_LOG_MIN_TEX_REGION_SIZE 16
+#endif
+
+#define I810_UPLOAD_TEX0IMAGE  0x1 /* handled clientside */
+#define I810_UPLOAD_TEX1IMAGE  0x2 /* handled clientside */
+#define I810_UPLOAD_CTX        0x4
+#define I810_UPLOAD_BUFFERS    0x8
+#define I810_UPLOAD_TEX0       0x10
+#define I810_UPLOAD_TEX1       0x20
+#define I810_UPLOAD_CLIPRECTS  0x40
+
+
+/* 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.
+ */
+
+/* Destbuffer state 
+ *    - backbuffer linear offset and pitch -- invarient in the current dri
+ *    - zbuffer linear offset and pitch -- also invarient
+ *    - drawing origin in back and depth buffers.
+ *
+ * Keep the depth/back buffer state here to acommodate private buffers
+ * in the future.
+ */
+#define I810_DESTREG_DI0  0	/* CMD_OP_DESTBUFFER_INFO (2 dwords) */
+#define I810_DESTREG_DI1  1
+#define I810_DESTREG_DV0  2	/* GFX_OP_DESTBUFFER_VARS (2 dwords) */
+#define I810_DESTREG_DV1  3
+#define I810_DESTREG_DR0  4	/* GFX_OP_DRAWRECT_INFO (4 dwords) */
+#define I810_DESTREG_DR1  5
+#define I810_DESTREG_DR2  6
+#define I810_DESTREG_DR3  7
+#define I810_DESTREG_DR4  8
+#define I810_DEST_SETUP_SIZE 10
+
+/* Context state
+ */
+#define I810_CTXREG_CF0   0	/* GFX_OP_COLOR_FACTOR */
+#define I810_CTXREG_CF1   1	
+#define I810_CTXREG_ST0   2     /* GFX_OP_STIPPLE */
+#define I810_CTXREG_ST1   3
+#define I810_CTXREG_VF    4	/* GFX_OP_VERTEX_FMT */
+#define I810_CTXREG_MT    5	/* GFX_OP_MAP_TEXELS */
+#define I810_CTXREG_MC0   6	/* GFX_OP_MAP_COLOR_STAGES - stage 0 */
+#define I810_CTXREG_MC1   7     /* GFX_OP_MAP_COLOR_STAGES - stage 1 */
+#define I810_CTXREG_MC2   8	/* GFX_OP_MAP_COLOR_STAGES - stage 2 */
+#define I810_CTXREG_MA0   9	/* GFX_OP_MAP_ALPHA_STAGES - stage 0 */
+#define I810_CTXREG_MA1   10	/* GFX_OP_MAP_ALPHA_STAGES - stage 1 */
+#define I810_CTXREG_MA2   11	/* GFX_OP_MAP_ALPHA_STAGES - stage 2 */
+#define I810_CTXREG_SDM   12	/* GFX_OP_SRC_DEST_MONO */
+#define I810_CTXREG_FOG   13	/* GFX_OP_FOG_COLOR */
+#define I810_CTXREG_B1    14	/* GFX_OP_BOOL_1 */
+#define I810_CTXREG_B2    15	/* GFX_OP_BOOL_2 */
+#define I810_CTXREG_LCS   16	/* GFX_OP_LINEWIDTH_CULL_SHADE_MODE */
+#define I810_CTXREG_PV    17	/* GFX_OP_PV_RULE -- Invarient! */
+#define I810_CTXREG_ZA    18	/* GFX_OP_ZBIAS_ALPHAFUNC */
+#define I810_CTXREG_AA    19	/* GFX_OP_ANTIALIAS */
+#define I810_CTX_SETUP_SIZE 20 
+
+/* Texture state (per tex unit)
+ */
+#define I810_TEXREG_MI0  0	/* GFX_OP_MAP_INFO (4 dwords) */
+#define I810_TEXREG_MI1  1	
+#define I810_TEXREG_MI2  2	
+#define I810_TEXREG_MI3  3	
+#define I810_TEXREG_MF   4	/* GFX_OP_MAP_FILTER */
+#define I810_TEXREG_MLC  5	/* GFX_OP_MAP_LOD_CTL */
+#define I810_TEXREG_MLL  6	/* GFX_OP_MAP_LOD_LIMITS */
+#define I810_TEXREG_MCS  7	/* GFX_OP_MAP_COORD_SETS ??? */
+#define I810_TEX_SETUP_SIZE 8
+
+#define I810_FRONT   0x1
+#define I810_BACK    0x2
+#define I810_DEPTH   0x4
+
+
+typedef struct _drm_i810_init {
+	enum {
+		I810_INIT_DMA = 0x01,
+		I810_CLEANUP_DMA = 0x02
+	} func;
+#if CONFIG_XFREE86_VERSION < XFREE86_VERSION(4,1,0,0)
+	int ring_map_idx;
+	int buffer_map_idx;
+#else
+	unsigned int mmio_offset;
+	unsigned int buffers_offset;
+#endif
+	int sarea_priv_offset;
+	unsigned int ring_start;
+	unsigned int ring_end;
+	unsigned int ring_size;
+	unsigned int front_offset;
+	unsigned int back_offset;
+	unsigned int depth_offset;
+	unsigned int overlay_offset;
+	unsigned int overlay_physical;
+	unsigned int w;
+	unsigned int h;
+	unsigned int pitch;
+	unsigned int pitch_bits; 
+} drm_i810_init_t;
+
+/* Warning: If you change the SAREA structure you must change the Xserver
+ * structure as well */
+
+typedef struct _drm_i810_tex_region {
+	unsigned char next, prev; /* indices to form a circular LRU  */
+	unsigned char in_use;	/* owned by a client, or free? */
+	int age;		/* tracked by clients to update local LRU's */
+} drm_i810_tex_region_t;
+
+typedef struct _drm_i810_sarea {
+   	unsigned int ContextState[I810_CTX_SETUP_SIZE];
+   	unsigned int BufferState[I810_DEST_SETUP_SIZE];
+   	unsigned int TexState[2][I810_TEX_SETUP_SIZE];
+   	unsigned int dirty;
+
+	unsigned int nbox;
+	drm_clip_rect_t boxes[I810_NR_SAREA_CLIPRECTS];
+
+	/* Maintain an LRU of contiguous regions of texture space.  If
+	 * you think you own a region of texture memory, and it has an
+	 * age different to the one you set, then you are mistaken and
+	 * it has been stolen by another client.  If global texAge
+	 * hasn't changed, there is no need to walk the list.
+	 *
+	 * These regions can be used as a proxy for the fine-grained
+	 * texture information of other clients - by maintaining them
+	 * in the same lru which is used to age their own textures,
+	 * clients have an approximate lru for the whole of global
+	 * texture space, and can make informed decisions as to which
+	 * areas to kick out.  There is no need to choose whether to
+	 * kick out your own texture or someone else's - simply eject
+	 * them all in LRU order.  
+	 */
+   
+	drm_i810_tex_region_t texList[I810_NR_TEX_REGIONS+1]; 
+				/* Last elt is sentinal */
+        int texAge;		/* 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 last_quiescent;     /*  */
+	int ctxOwner;		/* last context to upload state */
+
+	int vertex_prim;
+
+} drm_i810_sarea_t;
+
+typedef struct _drm_i810_clear {
+	int clear_color;
+	int clear_depth;
+	int flags;
+} drm_i810_clear_t;
+
+
+
+/* These may be placeholders if we have more cliprects than
+ * I810_NR_SAREA_CLIPRECTS.  In that case, the client sets discard to
+ * false, indicating that the buffer will be dispatched again with a
+ * new set of cliprects.
+ */
+typedef struct _drm_i810_vertex {
+   	int idx;		/* buffer index */
+	int used;		/* nr bytes in use */
+	int discard;		/* client is finished with the buffer? */
+} drm_i810_vertex_t;
+
+typedef struct _drm_i810_copy_t {
+   	int idx;		/* buffer index */
+	int used;		/* nr bytes in use */
+	void *address;		/* Address to copy from */
+} drm_i810_copy_t;
+
+typedef struct drm_i810_dma {
+	void *virtual;
+	int request_idx;
+	int request_size;
+	int granted;
+} drm_i810_dma_t;
+
+#endif /* _I810_DRM_H_ */
diff --git a/bsd/mga/mga_bufs.c b/bsd/mga/mga_bufs.c
deleted file mode 100644
index 4ae05181..00000000
--- a/bsd/mga/mga_bufs.c
+++ /dev/null
@@ -1,604 +0,0 @@
-/* mga_bufs.c -- IOCTLs to manage buffers
- * Created: Thu Jan 6 01:47:26 2000 by jhartmann@precisioninsight.com
- *
- * Copyright 1999 Precision Insight, Inc., Cedar Park, Texas.
- * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
- * All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice (including the next
- * paragraph) shall be included in all copies or substantial portions of the
- * Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
- * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
- * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- * 
- * Authors: Rickard E. (Rik) Faith <faith@valinux.com>
- *	    Jeff Hartmann <jhartmann@valinux.com>
- * 
- *
- */
-
-#define __NO_VERSION__
-#include "drmP.h"
-#include "mga_drv.h"
-#include <sys/mman.h>
-#include <vm/vm.h>
-#include <vm/pmap.h>
-#include <vm/vm_extern.h>
-#include <vm/vm_map.h>
-
-
-static int
-mga_addbufs_agp(dev_t kdev, u_long cmd, caddr_t data, int flags, struct proc *p)
-{
-        drm_device_t *dev = kdev->si_drv1;
-	drm_device_dma_t *dma = dev->dma;
-	drm_buf_desc_t request;
-	drm_buf_entry_t *entry;
-	drm_buf_t *buf;
-	unsigned long offset;
-	unsigned long agp_offset;
-	int count;
-	int order;
-	int size;
-	int alignment;
-	int page_order;
-	int total;
-	int byte_count;
-	int i;
-
-	if (!dma) return EINVAL;
-
-	request = *(drm_buf_desc_t *) data;
-
-	count = request.count;
-	order = drm_order(request.size);
-	size	= 1 << order;
-	agp_offset = request.agp_start;
-	alignment  = (request.flags & _DRM_PAGE_ALIGN) ? round_page(size) :size;
-	page_order = order - PAGE_SHIFT > 0 ? order - PAGE_SHIFT : 0;
-	total = PAGE_SIZE << page_order;
-	byte_count = 0;
-
-	DRM_DEBUG("count: %d\n", count);
-	DRM_DEBUG("order: %d\n", order);
-	DRM_DEBUG("size: %d\n", size);
-	DRM_DEBUG("agp_offset: %ld\n", agp_offset);
-	DRM_DEBUG("alignment: %d\n", alignment);
-	DRM_DEBUG("page_order: %d\n", page_order);
-	DRM_DEBUG("total: %d\n", total);
-	DRM_DEBUG("byte_count: %d\n", byte_count);
-
-	if (order < DRM_MIN_ORDER || order > DRM_MAX_ORDER) return EINVAL;
-	if (dev->queue_count) return EBUSY; /* Not while in use */
-	simple_lock(&dev->count_lock);
-	if (dev->buf_use) {
-		simple_unlock(&dev->count_lock);
-		return EBUSY;
-	}
-	atomic_inc(&dev->buf_alloc);
-	simple_unlock(&dev->count_lock);
-   
-	lockmgr(&dev->dev_lock, LK_EXCLUSIVE, 0, curproc);
-	entry = &dma->bufs[order];
-	if (entry->buf_count) {
-		lockmgr(&dev->dev_lock, LK_RELEASE, 0, curproc);
-		atomic_dec(&dev->buf_alloc);
-		return ENOMEM; /* May only call once for each order */
-	}
-   
-	entry->buflist = drm_alloc(count * sizeof(*entry->buflist),
-				   DRM_MEM_BUFS);
-	if (!entry->buflist) {
-		lockmgr(&dev->dev_lock, LK_RELEASE, 0, curproc);
-		atomic_dec(&dev->buf_alloc);
-		return ENOMEM;
-	}
-	memset(entry->buflist, 0, count * sizeof(*entry->buflist));
-   
-	entry->buf_size   = size;
-	entry->page_order = page_order;
-	offset = 0;
-
-   
-	while(entry->buf_count < count) {
-		buf = &entry->buflist[entry->buf_count];
-		buf->idx = dma->buf_count + entry->buf_count;
-		buf->total = alignment;
-		buf->order = order;
-		buf->used = 0;
-
-		DRM_DEBUG("offset : %ld\n", offset);
-
-		buf->offset = offset; /* Hrm */
-		buf->bus_address = dev->agp->base + agp_offset + offset;
-		buf->address = (void *)(agp_offset + offset + dev->agp->base);
-		buf->next = NULL;
-		buf->waiting = 0;
-		buf->pending = 0;
-		buf->dma_wait = 0;
-		buf->pid = 0;
-
-		buf->dev_private = drm_alloc(sizeof(drm_mga_buf_priv_t), DRM_MEM_BUFS);
-		buf->dev_priv_size = sizeof(drm_mga_buf_priv_t);
-
-#if DRM_DMA_HISTOGRAM
-		timespecclear(&buf->time_queued);
-		timespecclear(&buf->time_dispatched);
-		timespecclear(&buf->time_completed);
-		timespecclear(&buf->time_freed);
-#endif
-		offset = offset + alignment;
-		entry->buf_count++;
-		byte_count += PAGE_SIZE << page_order;
-      
-		DRM_DEBUG("buffer %d @ %p\n",
-			  entry->buf_count, buf->address);
-	}
-   
-	dma->buflist = drm_realloc(dma->buflist,
-				   dma->buf_count * sizeof(*dma->buflist),
-				   (dma->buf_count + entry->buf_count)
-				   * sizeof(*dma->buflist),
-				   DRM_MEM_BUFS);
-	for (i = dma->buf_count; i < dma->buf_count + entry->buf_count; i++)
-		dma->buflist[i] = &entry->buflist[i - dma->buf_count];
-   
-	dma->buf_count  += entry->buf_count;
-
-	DRM_DEBUG("dma->buf_count : %d\n", dma->buf_count);
-
-	dma->byte_count += byte_count;
-
-	DRM_DEBUG("entry->buf_count : %d\n", entry->buf_count);
-
-	drm_freelist_create(&entry->freelist, entry->buf_count);
-	for (i = 0; i < entry->buf_count; i++) {
-		drm_freelist_put(dev, &entry->freelist, &entry->buflist[i]);
-	}
-   
-	lockmgr(&dev->dev_lock, LK_RELEASE, 0, curproc);
-   
-	request.count = entry->buf_count;
-	request.size  = size;
-   
-	*(drm_buf_desc_t *) data = request;
-   
-	atomic_dec(&dev->buf_alloc);
-
-	DRM_DEBUG("count: %d\n", count);
-	DRM_DEBUG("order: %d\n", order);
-	DRM_DEBUG("size: %d\n", size);
-	DRM_DEBUG("agp_offset: %ld\n", agp_offset);
-	DRM_DEBUG("alignment: %d\n", alignment);
-	DRM_DEBUG("page_order: %d\n", page_order);
-	DRM_DEBUG("total: %d\n", total);
-	DRM_DEBUG("byte_count: %d\n", byte_count);
-
-	dma->flags = _DRM_DMA_USE_AGP;
-
-	DRM_DEBUG("dma->flags : %x\n", dma->flags);
-
-	return 0;
-}
-
-static int
-mga_addbufs_pci(dev_t kdev, u_long cmd, caddr_t data, int flags, struct proc *p)
-{
-        drm_device_t *dev = kdev->si_drv1;
-	drm_device_dma_t *dma	 = dev->dma;
-	drm_buf_desc_t	 request;
-	int		 count;
-	int		 order;
-	int		 size;
-	int		 total;
-	int		 page_order;
-	drm_buf_entry_t	 *entry;
-	unsigned long	 page;
-	drm_buf_t	 *buf;
-	int		 alignment;
-	unsigned long	 offset;
-	int		 i;
-	int		 byte_count;
-	int		 page_count;
-
-	if (!dma) return EINVAL;
-
-	request = *(drm_buf_desc_t *) data;
-
-	count	   = request.count;
-	order	   = drm_order(request.size);
-	size	   = 1 << order;
-	
-	DRM_DEBUG("count = %d, size = %d (%d), order = %d, queue_count = %d\n",
-		  request.count, request.size, size, order, dev->queue_count);
-
-	if (order < DRM_MIN_ORDER || order > DRM_MAX_ORDER) return EINVAL;
-	if (dev->queue_count) return EBUSY; /* Not while in use */
-
-	alignment  = (request.flags & _DRM_PAGE_ALIGN) ? round_page(size) :size;
-	page_order = order - PAGE_SHIFT > 0 ? order - PAGE_SHIFT : 0;
-	total	   = PAGE_SIZE << page_order;
-
-	simple_lock(&dev->count_lock);
-	if (dev->buf_use) {
-		simple_unlock(&dev->count_lock);
-		return EBUSY;
-	}
-	atomic_inc(&dev->buf_alloc);
-	simple_unlock(&dev->count_lock);
-	
-	lockmgr(&dev->dev_lock, LK_EXCLUSIVE, 0, curproc);
-	entry = &dma->bufs[order];
-	if (entry->buf_count) {
-		lockmgr(&dev->dev_lock, LK_RELEASE, 0, curproc);
-		atomic_dec(&dev->buf_alloc);
-		return ENOMEM;	/* May only call once for each order */
-	}
-	
-	entry->buflist = drm_alloc(count * sizeof(*entry->buflist),
-				   DRM_MEM_BUFS);
-	if (!entry->buflist) {
-		lockmgr(&dev->dev_lock, LK_RELEASE, 0, curproc);
-		atomic_dec(&dev->buf_alloc);
-		return ENOMEM;
-	}
-	memset(entry->buflist, 0, count * sizeof(*entry->buflist));
-
-	entry->seglist = drm_alloc(count * sizeof(*entry->seglist),
-				   DRM_MEM_SEGS);
-	if (!entry->seglist) {
-		drm_free(entry->buflist,
-			 count * sizeof(*entry->buflist),
-			 DRM_MEM_BUFS);
-		lockmgr(&dev->dev_lock, LK_RELEASE, 0, curproc);
-		atomic_dec(&dev->buf_alloc);
-		return ENOMEM;
-	}
-	memset(entry->seglist, 0, count * sizeof(*entry->seglist));
-
-	dma->pagelist = drm_realloc(dma->pagelist,
-				    dma->page_count * sizeof(*dma->pagelist),
-				    (dma->page_count + (count << page_order))
-				    * sizeof(*dma->pagelist),
-				    DRM_MEM_PAGES);
-	DRM_DEBUG("pagelist: %d entries\n",
-		  dma->page_count + (count << page_order));
-
-
-	entry->buf_size	  = size;
-	entry->page_order = page_order;
-	byte_count	  = 0;
-	page_count	  = 0;
-	while (entry->buf_count < count) {
-		if (!(page = drm_alloc_pages(page_order, DRM_MEM_DMA))) break;
-		entry->seglist[entry->seg_count++] = page;
-		for (i = 0; i < (1 << page_order); i++) {
-			DRM_DEBUG("page %d @ 0x%08lx\n",
-				  dma->page_count + page_count,
-				  page + PAGE_SIZE * i);
-			dma->pagelist[dma->page_count + page_count++]
-				= page + PAGE_SIZE * i;
-		}
-		for (offset = 0;
-		     offset + size <= total && entry->buf_count < count;
-		     offset += alignment, ++entry->buf_count) {
-			buf	     = &entry->buflist[entry->buf_count];
-			buf->idx     = dma->buf_count + entry->buf_count;
-			buf->total   = alignment;
-			buf->order   = order;
-			buf->used    = 0;
-			buf->offset  = (dma->byte_count + byte_count + offset);
-			buf->address = (void *)(page + offset);
-			buf->next    = NULL;
-			buf->waiting = 0;
-			buf->pending = 0;
-			buf->dma_wait = 0;
-			buf->pid     = 0;
-#if DRM_DMA_HISTOGRAM
-			timespecclear(&buf->time_queued);
-			timespecclear(&buf->time_dispatched);
-			timespecclear(&buf->time_completed);
-			timespecclear(&buf->time_freed);
-#endif
-			DRM_DEBUG("buffer %d @ %p\n",
-				  entry->buf_count, buf->address);
-		}
-		byte_count += PAGE_SIZE << page_order;
-	}
-
-	dma->buflist = drm_realloc(dma->buflist,
-				   dma->buf_count * sizeof(*dma->buflist),
-				   (dma->buf_count + entry->buf_count)
-				   * sizeof(*dma->buflist),
-				   DRM_MEM_BUFS);
-	for (i = dma->buf_count; i < dma->buf_count + entry->buf_count; i++)
-		dma->buflist[i] = &entry->buflist[i - dma->buf_count];
-
-	dma->buf_count	+= entry->buf_count;
-	dma->seg_count	+= entry->seg_count;
-	dma->page_count += entry->seg_count << page_order;
-	dma->byte_count += PAGE_SIZE * (entry->seg_count << page_order);
-	
-	drm_freelist_create(&entry->freelist, entry->buf_count);
-	for (i = 0; i < entry->buf_count; i++) {
-		drm_freelist_put(dev, &entry->freelist, &entry->buflist[i]);
-	}
-	
-	lockmgr(&dev->dev_lock, LK_RELEASE, 0, curproc);
-
-	request.count = entry->buf_count;
-	request.size  = size;
-
-	*(drm_buf_desc_t *) data = request;
-	
-	atomic_dec(&dev->buf_alloc);
-	return 0;
-}
-
-int
-mga_addbufs(dev_t kdev, u_long cmd, caddr_t data, int flags, struct proc *p)
-{
-	drm_buf_desc_t	 request;
-
-	request = *(drm_buf_desc_t *) data;
-
-	if(request.flags & _DRM_AGP_BUFFER)
-		return mga_addbufs_agp(kdev, cmd, data, flags, p);
-	else
-		return mga_addbufs_pci(kdev, cmd, data, flags, p);
-}
-
-int
-mga_infobufs(dev_t kdev, u_long cmd, caddr_t data, int flags, struct proc *p)
-{
-        drm_device_t     *dev    = kdev->si_drv1;
-	drm_device_dma_t *dma	 = dev->dma;
-	drm_buf_info_t	 request;
-	int		 i;
-	int		 count;
-	int		 error;
-
-	if (!dma) return EINVAL;
-
-	simple_lock(&dev->count_lock);
-	if (atomic_read(&dev->buf_alloc)) {
-		simple_unlock(&dev->count_lock);
-		return EBUSY;
-	}
-	++dev->buf_use;		/* Can't allocate more after this call */
-	simple_unlock(&dev->count_lock);
-
-	request = *(drm_buf_info_t *) data;
-
-	for (i = 0, count = 0; i < DRM_MAX_ORDER+1; i++) {
-		if (dma->bufs[i].buf_count) ++count;
-	}
-	
-	DRM_DEBUG("count = %d\n", count);
-	
-	if (request.count >= count) {
-		for (i = 0, count = 0; i < DRM_MAX_ORDER+1; i++) {
-			if (dma->bufs[i].buf_count) {
-				error = copyout(&dma->bufs[i].buf_count,
-						&request.list[count].count,
-						sizeof(dma->bufs[0]
-						       .buf_count));
-				if (error) return error;
-				error = copyout(&dma->bufs[i].buf_size,
-						&request.list[count].size,
-						sizeof(dma->bufs[0]
-						       .buf_size));
-				if (error) return error;
-				error = copyout(&dma->bufs[i]
-						.freelist.low_mark,
-						&request.list[count].low_mark,
-						sizeof(dma->bufs[0]
-						       .freelist.low_mark));
-				if (error) return error;
-				error = copyout(&dma->bufs[i]
-						.freelist.high_mark,
-						&request.list[count].high_mark,
-						sizeof(dma->bufs[0]
-						       .freelist.high_mark));
-				if (error) return error;
-				DRM_DEBUG("%d %d %d %d %d\n",
-					  i,
-					  dma->bufs[i].buf_count,
-					  dma->bufs[i].buf_size,
-					  dma->bufs[i].freelist.low_mark,
-					  dma->bufs[i].freelist.high_mark);
-				++count;
-			}
-		}
-	}
-	request.count = count;
-
-	*(drm_buf_info_t *) data = request;
-	
-	return 0;
-}
-
-int
-mga_markbufs(dev_t kdev, u_long cmd, caddr_t data, int flags, struct proc *p)
-{
-        drm_device_t     *dev    = kdev->si_drv1;
-	drm_device_dma_t *dma	 = dev->dma;
-	drm_buf_desc_t	 request;
-	int		 order;
-	drm_buf_entry_t	 *entry;
-
-	if (!dma) return EINVAL;
-
-	request = *(drm_buf_desc_t *) data;
-
-	DRM_DEBUG("%d, %d, %d\n",
-		  request.size, request.low_mark, request.high_mark);
-	order = drm_order(request.size);
-	if (order < DRM_MIN_ORDER || order > DRM_MAX_ORDER) return EINVAL;
-	entry = &dma->bufs[order];
-
-	if (request.low_mark < 0 || request.low_mark > entry->buf_count)
-		return EINVAL;
-	if (request.high_mark < 0 || request.high_mark > entry->buf_count)
-		return EINVAL;
-
-	entry->freelist.low_mark  = request.low_mark;
-	entry->freelist.high_mark = request.high_mark;
-	
-	return 0;
-}
-
-int
-mga_freebufs(dev_t kdev, u_long cmd, caddr_t data, int flags, struct proc *p)
-{
-        drm_device_t     *dev    = kdev->si_drv1;
-	drm_device_dma_t *dma	 = dev->dma;
-	drm_buf_free_t	 request;
-	int		 i;
-	int		 error;
-	int		 idx;
-	drm_buf_t	 *buf;
-
-	if (!dma) return EINVAL;
-
-	request = *(drm_buf_free_t *) data;
-
-	DRM_DEBUG("%d\n", request.count);
-	for (i = 0; i < request.count; i++) {
-		error = copyin(&request.list[i],
-			       &idx,
-			       sizeof(idx));
-		if (error) return error;
-		if (idx < 0 || idx >= dma->buf_count) {
-			DRM_ERROR("Index %d (of %d max)\n",
-				  idx, dma->buf_count - 1);
-			return EINVAL;
-		}
-		buf = dma->buflist[idx];
-		if (buf->pid != p->p_pid) {
-			DRM_ERROR("Process %d freeing buffer owned by %d\n",
-				  p->p_pid, buf->pid);
-			return EINVAL;
-		}
-		drm_free_buffer(dev, buf);
-	}
-	
-	return 0;
-}
-
-int
-mga_mapbufs(dev_t kdev, u_long cmd, caddr_t data, int flags, struct proc *p)
-{
-        drm_device_t     *dev    = kdev->si_drv1;
-	drm_device_dma_t *dma	 = dev->dma;
-	int		 retcode = 0;
-	const int	 zero	 = 0;
-	vm_offset_t	 virtual;
-	vm_offset_t	 address;
-	drm_buf_map_t	 request;
-	int		 i;
-
-	if (!dma) return EINVAL;
-	
-	DRM_DEBUG("\n");
-
-	simple_lock(&dev->count_lock);
-	if (atomic_read(&dev->buf_alloc)) {
-		simple_unlock(&dev->count_lock);
-		DRM_DEBUG("Busy\n");
-		return EBUSY;
-	}
-	++dev->buf_use;		/* Can't allocate more after this call */
-	simple_unlock(&dev->count_lock);
-
-	request = *(drm_buf_map_t *) data;
-
-	DRM_DEBUG("mga_mapbufs\n");
-   	DRM_DEBUG("dma->flags : %x\n", dma->flags);
-   
-	if (request.count >= dma->buf_count) {
-		if(dma->flags & _DRM_DMA_USE_AGP) {
-			drm_mga_private_t *dev_priv = dev->dev_private;
-			drm_map_t *map = NULL;
-	 
-			map = dev->maplist[dev_priv->buffer_map_idx];
-			if (!map) {
-				DRM_DEBUG("map is null\n");
-				retcode = EINVAL;
-				goto done;
-			}
-
-			DRM_DEBUG("map->offset : %lx\n", map->offset);
-			DRM_DEBUG("map->size : %lx\n", map->size);
-			DRM_DEBUG("map->type : %d\n", map->type);
-			DRM_DEBUG("map->flags : %x\n", map->flags);
-			DRM_DEBUG("map->handle : %p\n", map->handle);
-			DRM_DEBUG("map->mtrr : %d\n", map->mtrr);
-			virtual = 0;
-			retcode = vm_mmap(&p->p_vmspace->vm_map,
-					  &virtual,
-					  map->size,
-					  PROT_READ|PROT_WRITE, VM_PROT_ALL,
-					  MAP_SHARED,
-					  SLIST_FIRST(&kdev->si_hlist),
-					  map->offset);
-		} else {
-			virtual = 0;
-			retcode = vm_mmap(&p->p_vmspace->vm_map,
-					  &virtual,
-					  round_page(dma->byte_count),
-					  PROT_READ|PROT_WRITE, VM_PROT_ALL,
-					  MAP_SHARED,
-					  SLIST_FIRST(&kdev->si_hlist),
-					  0);
-		}
-		if (retcode) {
-			/* Real error */
-			DRM_DEBUG("mmap error\n");
-			goto done;
-		}
-		request.virtual = (void *)virtual;
-      
-		for (i = 0; i < dma->buf_count; i++) {
-			retcode = copyout(&dma->buflist[i]->idx,
-					  &request.list[i].idx,
-					  sizeof(request.list[0].idx));
-			if (retcode) goto done;
-			retcode = copyout(&dma->buflist[i]->total,
-					  &request.list[i].total,
-					  sizeof(request.list[0].total));
-			if (retcode) goto done;
-			retcode = copyout(&zero,
-					  &request.list[i].used,
-					  sizeof(request.list[0].used));
-			if (retcode) goto done;
-			address = virtual + dma->buflist[i]->offset;
-			retcode = copyout(&address,
-					  &request.list[i].address,
-					  sizeof(address));
-			if (retcode) goto done;
-		}
-	}
- done:
-	request.count = dma->buf_count;
-	DRM_DEBUG("%d buffers, retcode = %d\n", request.count, retcode);
-   
-	*(drm_buf_map_t *) data = request;
-
-	DRM_DEBUG("retcode : %d\n", retcode);
-
-	return retcode;
-}
diff --git a/bsd/mga/mga_context.c b/bsd/mga/mga_context.c
deleted file mode 100644
index 63515bab..00000000
--- a/bsd/mga/mga_context.c
+++ /dev/null
@@ -1,200 +0,0 @@
-/* mga_context.c -- IOCTLs for mga contexts
- * Created: Mon Dec 13 09:51:35 1999 by faith@precisioninsight.com
- *
- * Copyright 1999 Precision Insight, Inc., Cedar Park, Texas.
- * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
- * All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice (including the next
- * paragraph) shall be included in all copies or substantial portions of the
- * Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * PRECISION INSIGHT 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.
- * 
- * Author: Rickard E. (Rik) Faith <faith@valinux.com>
- *	   Jeff Hartmann <jhartmann@valinux.com>
- *
- */
-
-#define __NO_VERSION__
-#include "drmP.h"
-#include "mga_drv.h"
-
-static int mga_alloc_queue(drm_device_t *dev)
-{
-   	int temp = drm_ctxbitmap_next(dev);
-   	DRM_DEBUG("mga_alloc_queue: %d\n", temp);
-	return temp;
-}
-
-int mga_context_switch(drm_device_t *dev, int old, int new)
-{
-        char        buf[64];
-
-        atomic_inc(&dev->total_ctx);
-
-        if (test_and_set_bit(0, &dev->context_flag)) {
-                DRM_ERROR("Reentering -- FIXME\n");
-                return EBUSY;
-        }
-
-#if DRM_DMA_HISTOGRAM
-        getnanotime(&dev->ctx_start);
-#endif
-        
-        DRM_DEBUG("Context switch from %d to %d\n", old, new);
-
-        if (new == dev->last_context) {
-                clear_bit(0, &dev->context_flag);
-                return 0;
-        }
-        
-        if (drm_flags & DRM_FLAG_NOCTX) {
-                mga_context_switch_complete(dev, new);
-        } else {
-                sprintf(buf, "C %d %d\n", old, new);
-                drm_write_string(dev, buf);
-        }
-        
-        return 0;
-}
-
-int mga_context_switch_complete(drm_device_t *dev, int new)
-{
-        dev->last_context = new;  /* PRE/POST: This is the _only_ writer. */
-        dev->last_switch  = ticks;
-        
-        if (!_DRM_LOCK_IS_HELD(dev->lock.hw_lock->lock)) {
-                DRM_ERROR("Lock isn't held after context switch\n");
-        }
-
-				/* If a context switch is ever initiated
-                                   when the kernel holds the lock, release
-                                   that lock here. */
-#if DRM_DMA_HISTOGRAM
-	{
-	    struct timespec ts;
-	    getnanotime(&ts);
-	    timespecsub(&ts, &dev->lck_start);
-	    atomic_inc(&dev->histo.ctx[drm_histogram_slot(&ts)]);
-	}
-#endif
-        clear_bit(0, &dev->context_flag);
-        wakeup(&dev->context_wait);
-        
-        return 0;
-}
-
-int
-mga_resctx(dev_t kdev, u_long cmd, caddr_t data, int flags, struct proc *p)
-{
-	drm_ctx_res_t	res;
-	drm_ctx_t	ctx;
-	int		i, error;
-
-	DRM_DEBUG("%d\n", DRM_RESERVED_CONTEXTS);
-	res = *(drm_ctx_res_t *) data;
-	if (res.count >= DRM_RESERVED_CONTEXTS) {
-		memset(&ctx, 0, sizeof(ctx));
-		for (i = 0; i < DRM_RESERVED_CONTEXTS; i++) {
-			ctx.handle = i;
-			error = copyout(&i, &res.contexts[i], sizeof(i));
-			if (error) return error;
-		}
-	}
-	res.count = DRM_RESERVED_CONTEXTS;
-	*(drm_ctx_res_t *) data = res;
-	return 0;
-}
-
-int
-mga_addctx(dev_t kdev, u_long cmd, caddr_t data, int flags, struct proc *p)
-{
-	drm_device_t	*dev	= kdev->si_drv1;
-	drm_ctx_t	ctx;
-
-	ctx = *(drm_ctx_t *) data;
-	if ((ctx.handle = mga_alloc_queue(dev)) == DRM_KERNEL_CONTEXT) {
-				/* Skip kernel's context and get a new one. */
-		ctx.handle = mga_alloc_queue(dev);
-	}
-        if (ctx.handle == -1) {
-		DRM_DEBUG("Not enough free contexts.\n");
-				/* Should this return EBUSY instead? */
-		return ENOMEM;
-	}
-	DRM_DEBUG("%d\n", ctx.handle);
-	*(drm_ctx_t *) data = ctx;
-	return 0;
-}
-
-int
-mga_modctx(dev_t kdev, u_long cmd, caddr_t data, int flags, struct proc *p)
-{
-   	/* This does nothing for the mga */
-	return 0;
-}
-
-int mga_getctx(dev_t kdev, u_long cmd, caddr_t data, int flags, struct proc *p)
-{
-	drm_ctx_t ctx;
-
-	ctx = *(drm_ctx_t *) data;
-	/* This is 0, because we don't hanlde any context flags */
-	ctx.flags = 0;
-	*(drm_ctx_t *) data = ctx;
-	return 0;
-}
-
-int mga_switchctx(dev_t kdev, u_long cmd, caddr_t data, int flags, struct proc *p)
-{
-	drm_device_t	*dev	= kdev->si_drv1;
-	drm_ctx_t	ctx;
-
-	ctx = *(drm_ctx_t *) data;
-	DRM_DEBUG("%d\n", ctx.handle);
-	return mga_context_switch(dev, dev->last_context, ctx.handle);
-}
-
-int mga_newctx(dev_t kdev, u_long cmd, caddr_t data, int flags, struct proc *p)
-{
-	drm_device_t	*dev	= kdev->si_drv1;
-	drm_ctx_t	ctx;
-
-	ctx = *(drm_ctx_t *) data;
-	DRM_DEBUG("%d\n", ctx.handle);
-	mga_context_switch_complete(dev, ctx.handle);
-
-	return 0;
-}
-
-int mga_rmctx(dev_t kdev, u_long cmd, caddr_t data, int flags, struct proc *p)
-{
-	drm_device_t	*dev	= kdev->si_drv1;
-	drm_ctx_t	ctx;
-
-	ctx = *(drm_ctx_t *) data;
-	DRM_DEBUG("%d\n", ctx.handle);
-/*
-	if(ctx.handle == DRM_KERNEL_CONTEXT+1)
-		priv->remove_auth_on_close = 1;
-*/
-      	if(ctx.handle != DRM_KERNEL_CONTEXT ) {
-	   	drm_ctxbitmap_free(dev, ctx.handle);
-	}
-	
-	return 0;
-}
diff --git a/bsd/mga/mga_dma.c b/bsd/mga/mga_dma.c
index 85c29df7..9ed5d095 100644
--- a/bsd/mga/mga_dma.c
+++ b/bsd/mga/mga_dma.c
@@ -1,4 +1,4 @@
-/* mga_dma.c -- DMA support for mga g200/g400
+/* mga_dma.c -- DMA support for mga g200/g400 -*- linux-c -*-
  * Created: Mon Dec 13 01:50:01 1999 by jhartmann@precisioninsight.com
  *
  * Copyright 1999 Precision Insight, Inc., Cedar Park, Texas.
@@ -11,11 +11,11 @@
  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  * and/or sell copies of the Software, and to permit persons to whom the
  * Software is furnished to do so, subject to the following conditions:
- * 
+ *
  * The above copyright notice and this permission notice (including the next
  * paragraph) shall be included in all copies or substantial portions of the
  * Software.
- * 
+ *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
@@ -24,1054 +24,796 @@
  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  * DEALINGS IN THE SOFTWARE.
  *
- * Authors: Rickard E. (Rik) Faith <faith@valinux.com>
- *	    Jeff Hartmann <jhartmann@valinux.com>
- *	    Keith Whitwell <keithw@valinux.com>
+ * Authors:
+ *    Rickard E. (Rik) Faith <faith@valinux.com>
+ *    Jeff Hartmann <jhartmann@valinux.com>
+ *    Keith Whitwell <keithw@valinux.com>
  *
+ * Rewritten by:
+ *    Gareth Hughes <gareth@valinux.com>
  */
 
 #define __NO_VERSION__
+#include "mga.h"
 #include "drmP.h"
 #include "mga_drv.h"
 
-#include <machine/bus.h>
-#include <machine/resource.h>
-#include <sys/rman.h>
-#include <vm/vm.h>
-#include <vm/pmap.h>
 
-#define MGA_REG(reg)		2
-#define MGA_BASE(reg)		((unsigned long) \
-				((drm_device_t *)dev)->maplist[MGA_REG(reg)]->handle)
-#define MGA_ADDR(reg)		(MGA_BASE(reg) + reg)
-#define MGA_DEREF(reg)		*(__volatile__ int *)MGA_ADDR(reg)
-#define MGA_READ(reg)		MGA_DEREF(reg)
-#define MGA_WRITE(reg,val) 	do { MGA_DEREF(reg) = val; } while (0)
+#define MGA_DEFAULT_USEC_TIMEOUT	10000
+#define MGA_FREELIST_DEBUG		0
 
-#define PDEA_pagpxfer_enable 	     0x2
 
-static int mga_flush_queue(drm_device_t *dev);
+/* ================================================================
+ * Engine control
+ */
 
-static unsigned long mga_alloc_page(drm_device_t *dev)
+int mga_do_wait_for_idle( drm_mga_private_t *dev_priv )
 {
-	unsigned long address;
-   
-	DRM_DEBUG("%s\n", __FUNCTION__);
+	u32 status = 0;
+	int i;
+	DRM_DEBUG( "%s\n", __FUNCTION__ );
 
-	address = (unsigned long) drm_alloc(PAGE_SIZE, DRM_MEM_DMA);
-	if(address == 0UL) {
-		return 0;
+	for ( i = 0 ; i < dev_priv->usec_timeout ; i++ ) {
+		status = MGA_READ( MGA_STATUS ) & MGA_ENGINE_IDLE_MASK;
+		if ( status == MGA_ENDPRDMASTS ) {
+			MGA_WRITE8( MGA_CRTC_INDEX, 0 );
+			return 0;
+		}
+		DRM_OS_DELAY( 1 );
 	}
-   
-	return address;
+
+#if MGA_DMA_DEBUG
+	DRM_ERROR( "failed!\n" );
+	DRM_INFO( "   status=0x%08x\n", status );
+#endif
+	DRM_OS_RETURN(EBUSY);
 }
 
-static void mga_free_page(drm_device_t *dev, unsigned long page)
+int mga_do_dma_idle( drm_mga_private_t *dev_priv )
 {
-	DRM_DEBUG("%s\n", __FUNCTION__);
+	u32 status = 0;
+	int i;
+	DRM_DEBUG( "%s\n", __FUNCTION__ );
 
-	if(page == 0UL) {
-		return;
+	for ( i = 0 ; i < dev_priv->usec_timeout ; i++ ) {
+		status = MGA_READ( MGA_STATUS ) & MGA_DMA_IDLE_MASK;
+		if ( status == MGA_ENDPRDMASTS ) return 0;
+		DRM_OS_DELAY( 1 );
 	}
-	drm_free((void *) page, PAGE_SIZE, DRM_MEM_DMA);
-	return;
-}
 
-static void mga_delay(void)
-{
-   	return;
+#if MGA_DMA_DEBUG
+	DRM_ERROR( "failed! status=0x%08x\n", status );
+#endif
+	DRM_OS_RETURN(EBUSY);
 }
 
-void mga_flush_write_combine(void)
+int mga_do_dma_reset( drm_mga_private_t *dev_priv )
 {
-   	int xchangeDummy;
-	DRM_DEBUG("%s\n", __FUNCTION__);
+	drm_mga_sarea_t *sarea_priv = dev_priv->sarea_priv;
+	drm_mga_primary_buffer_t *primary = &dev_priv->prim;
 
-   	__asm__ volatile(" push %%eax ; xchg %%eax, %0 ; pop %%eax" : : "m" (xchangeDummy));
-   	__asm__ volatile(" push %%eax ; push %%ebx ; push %%ecx ; push %%edx ;"
-			 " movl $0,%%eax ; cpuid ; pop %%edx ; pop %%ecx ; pop %%ebx ;"
-			 " pop %%eax" : /* no outputs */ :  /* no inputs */ );
-}
+	DRM_DEBUG( "%s\n", __FUNCTION__ );
 
-/* These are two age tags that will never be sent to
- * the hardware */
-#define MGA_BUF_USED 	0xffffffff
-#define MGA_BUF_FREE	0
+	/* The primary DMA stream should look like new right about now.
+	 */
+	primary->tail = 0;
+	primary->space = primary->size;
+	primary->last_flush = 0;
 
-static int mga_freelist_init(drm_device_t *dev)
-{
-      	drm_device_dma_t *dma = dev->dma;
-   	drm_buf_t *buf;
-   	drm_mga_buf_priv_t *buf_priv;
-      	drm_mga_private_t *dev_priv = (drm_mga_private_t *)dev->dev_private;
-   	drm_mga_freelist_t *item;
-   	int i;
-
-	DRM_DEBUG("%s\n", __FUNCTION__);
-
-   	dev_priv->head = drm_alloc(sizeof(drm_mga_freelist_t), DRM_MEM_DRIVER);
-	if(dev_priv->head == NULL) return ENOMEM;
-   	memset(dev_priv->head, 0, sizeof(drm_mga_freelist_t));
-   	dev_priv->head->age = MGA_BUF_USED;
-   
-   	for (i = 0; i < dma->buf_count; i++) {
-	   	buf = dma->buflist[ i ];
-	        buf_priv = buf->dev_private;
-		item = drm_alloc(sizeof(drm_mga_freelist_t),
-				 DRM_MEM_DRIVER);
-	   	if(item == NULL) return ENOMEM;
-	   	memset(item, 0, sizeof(drm_mga_freelist_t));
-	  	item->age = MGA_BUF_FREE;
-	   	item->prev = dev_priv->head;
-	   	item->next = dev_priv->head->next;
-	   	if(dev_priv->head->next != NULL)
-			dev_priv->head->next->prev = item;
-	   	if(item->next == NULL) dev_priv->tail = item;
-	   	item->buf = buf;
-	   	buf_priv->my_freelist = item;
-		buf_priv->discard = 0;
-	   	dev_priv->head->next = item;
-	}
-   
-   	return 0;
-}
+	sarea_priv->last_wrap = 0;
 
-static void mga_freelist_cleanup(drm_device_t *dev)
-{
-      	drm_mga_private_t *dev_priv = (drm_mga_private_t *)dev->dev_private;
-   	drm_mga_freelist_t *item;
-   	drm_mga_freelist_t *prev;
+	/* FIXME: Reset counters, buffer ages etc...
+	 */
 
-	DRM_DEBUG("%s\n", __FUNCTION__);
+	/* FIXME: What else do we need to reinitialize?  WARP stuff?
+	 */
 
-   	item = dev_priv->head;
-   	while(item) {
-	   	prev = item;
-	   	item = item->next;
-	   	drm_free(prev, sizeof(drm_mga_freelist_t), DRM_MEM_DRIVER);
-	}
-   
-   	dev_priv->head = dev_priv->tail = NULL;
+	return 0;
 }
 
-/* Frees dispatch lock */
-static __inline void mga_dma_quiescent(drm_device_t *dev)
+int mga_do_engine_reset( drm_mga_private_t *dev_priv )
 {
-	drm_device_dma_t  *dma      = dev->dma;
-	drm_mga_private_t *dev_priv = (drm_mga_private_t *)dev->dev_private;
-	drm_mga_sarea_t *sarea_priv = dev_priv->sarea_priv;
-   	unsigned long end;
-	int i;
+	DRM_DEBUG( "%s\n", __FUNCTION__ );
 
-	DRM_DEBUG("%s\n", __FUNCTION__);
-	end = ticks + (hz*3);
-    	while(1) {
-		if(!test_and_set_bit(MGA_IN_DISPATCH, 
-				     &dev_priv->dispatch_status)) {
-			break;
-		}
-	   	if((signed)(end - ticks) <= 0) {
-			DRM_ERROR("irqs: %d wanted %d\n", 
-				  atomic_read(&dev->total_irq), 
-				  atomic_read(&dma->total_lost));
-			DRM_ERROR("lockup\n"); 
-			return;
-		}
-		for (i = 0 ; i < 2000 ; i++) mga_delay();
-	}
-	end = ticks + (hz*3);
-    	DRM_DEBUG("quiescent status : %x\n", MGA_READ(MGAREG_STATUS));
-    	while((MGA_READ(MGAREG_STATUS) & 0x00030001) != 0x00020000) {
-		if((signed)(end - ticks) <= 0) {
-			DRM_ERROR("irqs: %d wanted %d\n", 
-				  atomic_read(&dev->total_irq), 
-				  atomic_read(&dma->total_lost));
-			DRM_ERROR("lockup\n"); 
-			clear_bit(MGA_IN_DISPATCH, &dev_priv->dispatch_status);
-			return;
-		}
-		for (i = 0 ; i < 2000 ; i++) mga_delay();	  
-	}
-    	sarea_priv->dirty |= MGA_DMA_FLUSH;
+	/* Okay, so we've completely screwed up and locked the engine.
+	 * How about we clean up after ourselves?
+	 */
+	MGA_WRITE( MGA_RST, MGA_SOFTRESET );
+	DRM_OS_DELAY( 15 );		/* Wait at least 10 usecs */
+	MGA_WRITE( MGA_RST, 0 );
+
+	/* Initialize the registers that get clobbered by the soft
+	 * reset.  Many of the core register values survive a reset,
+	 * but the drawing registers are basically all gone.
+	 *
+	 * 3D clients should probably die after calling this.  The X
+	 * server should reset the engine state to known values.
+	 */
+#if 0
+	MGA_WRITE( MGA_PRIMPTR,
+		   virt_to_bus((void *)dev_priv->prim.status_page) |
+		   MGA_PRIMPTREN0 |
+		   MGA_PRIMPTREN1 );
+#endif
 
-    	clear_bit(MGA_IN_DISPATCH, &dev_priv->dispatch_status);
-	DRM_DEBUG("exit, dispatch_status = 0x%02x\n",dev_priv->dispatch_status);
-}
+	MGA_WRITE( MGA_ICLEAR, MGA_SOFTRAPICLR );
+	MGA_WRITE( MGA_IEN,    MGA_SOFTRAPIEN );
 
-static void mga_reset_freelist(drm_device_t *dev)
-{
-   	drm_device_dma_t  *dma      = dev->dma;
-   	drm_buf_t *buf;
-   	drm_mga_buf_priv_t *buf_priv;
-	int i;
+	/* The primary DMA stream should look like new right about now.
+	 */
+	mga_do_dma_reset( dev_priv );
 
-   	for (i = 0; i < dma->buf_count; i++) {
-	   	buf = dma->buflist[ i ];
-	        buf_priv = buf->dev_private;
-		buf_priv->my_freelist->age = MGA_BUF_FREE;
-	}
+	/* This bad boy will never fail.
+	 */
+	return 0;
 }
 
-/* Least recently used :
- * These operations are not atomic b/c they are protected by the 
- * hardware lock */
 
-drm_buf_t *mga_freelist_get(drm_device_t *dev)
+/* ================================================================
+ * Primary DMA stream
+ */
+
+void mga_do_dma_flush( drm_mga_private_t *dev_priv )
 {
-   	drm_mga_private_t *dev_priv = 
-     		(drm_mga_private_t *) dev->dev_private;
-	drm_mga_freelist_t *prev;
-   	drm_mga_freelist_t *next;
-	static int failed = 0;
-	int ret, s;
-
-	DRM_DEBUG("%s : tail->age : %d last_prim_age : %d\n", __FUNCTION__,
-	       dev_priv->tail->age, dev_priv->last_prim_age);
-   
-	if(failed >= 1000 && dev_priv->tail->age >= dev_priv->last_prim_age) {
-		DRM_DEBUG("I'm waiting on the freelist!!! %d\n", 
-		       dev_priv->last_prim_age);
-		s = splsofttq();
-	   	set_bit(MGA_IN_GETBUF, &dev_priv->dispatch_status);
-	   	for (;;) {
-		   	mga_dma_schedule(dev, 0);
-/*		   	if(!test_bit(MGA_IN_GETBUF, 
-				     &dev_priv->dispatch_status)) */
-			if(dev_priv->tail->age < dev_priv->last_prim_age)
-				break;
-		   	atomic_inc(&dev->total_sleeps);
-			ret = tsleep(&dev_priv->buf_queue, PZERO|PCATCH,
-				     "mgafg", 0);
-			if (ret == EINTR) {
-				clear_bit(MGA_IN_GETBUF,
-					  &dev_priv->dispatch_status);
-				break;
-			}
-		}
-		splx(s);
-		clear_bit(MGA_IN_GETBUF, &dev_priv->dispatch_status);
-		if (ret) return NULL;
-	}
-   
-   	if(dev_priv->tail->age < dev_priv->last_prim_age) {
-		prev = dev_priv->tail->prev;
-	   	next = dev_priv->tail;
-	   	prev->next = NULL;
-	   	next->prev = next->next = NULL;
-	   	dev_priv->tail = prev;
-	   	next->age = MGA_BUF_USED;
-		failed = 0;
-	   	return next->buf;
+	drm_mga_primary_buffer_t *primary = &dev_priv->prim;
+	u32 head, tail;
+	DMA_LOCALS;
+	DRM_DEBUG( "%s:\n", __FUNCTION__ );
+
+	if ( primary->tail == primary->last_flush ) {
+		DRM_DEBUG( "   bailing out...\n" );
+		return;
 	}
 
-	failed++;
-   	return NULL;
-}
+	tail = primary->tail + dev_priv->primary->offset;
 
-int mga_freelist_put(drm_device_t *dev, drm_buf_t *buf)
-{
-      	drm_mga_private_t *dev_priv = 
-     		(drm_mga_private_t *) dev->dev_private;
-   	drm_mga_buf_priv_t *buf_priv = buf->dev_private;
-	drm_mga_freelist_t *prev;
-   	drm_mga_freelist_t *head;
-   	drm_mga_freelist_t *next;
+	/* We need to pad the stream between flushes, as the card
+	 * actually (partially?) reads the first of these commands.
+	 * See page 4-16 in the G400 manual, middle of the page or so.
+	 */
+	BEGIN_DMA( 1 );
 
-	DRM_DEBUG("%s\n", __FUNCTION__);
+	DMA_BLOCK( MGA_DMAPAD,  0x00000000,
+		   MGA_DMAPAD,  0x00000000,
+		   MGA_DMAPAD,  0x00000000,
+		   MGA_DMAPAD,	0x00000000 );
 
-   	if(buf_priv->my_freelist->age == MGA_BUF_USED) {
-		/* Discarded buffer, put it on the tail */
-		next = buf_priv->my_freelist;
-		next->age = MGA_BUF_FREE;
-		prev = dev_priv->tail;
-		prev->next = next;
-		next->prev = prev;
-		next->next = NULL;
-		dev_priv->tail = next;
-		DRM_DEBUG("Discarded\n");
+	ADVANCE_DMA();
+
+	primary->last_flush = primary->tail;
+
+	head = MGA_READ( MGA_PRIMADDRESS );
+
+	if ( head <= tail ) {
+		primary->space = primary->size - primary->tail;
 	} else {
-		/* Normally aged buffer, put it on the head + 1,
-		 * as the real head is a sentinal element
-		 */
-		next = buf_priv->my_freelist;
-		head = dev_priv->head;
-		prev = head->next;
-		head->next = next;
-		prev->prev = next;
-		next->prev = head;
-		next->next = prev;
+		primary->space = head - tail;
 	}
-   
-   	return 0;
-}
 
-static int mga_init_primary_bufs(drm_device_t *dev, drm_mga_init_t *init)
-{
-   	drm_mga_private_t *dev_priv = dev->dev_private;
-	drm_mga_prim_buf_t *prim_buffer;
-   	int i, temp, size_of_buf;
-   	int offset = init->reserved_map_agpstart;
-
-	DRM_DEBUG("%s\n", __FUNCTION__);
-   	dev_priv->primary_size = ((init->primary_size + PAGE_SIZE - 1) / 
-				  PAGE_SIZE) * PAGE_SIZE;
-   	size_of_buf = dev_priv->primary_size / MGA_NUM_PRIM_BUFS;
-	dev_priv->warp_ucode_size = init->warp_ucode_size;
-   	dev_priv->prim_bufs = drm_alloc(sizeof(drm_mga_prim_buf_t *) * 
-					(MGA_NUM_PRIM_BUFS + 1), 
-					DRM_MEM_DRIVER);
-   	if(dev_priv->prim_bufs == NULL) {
-		DRM_ERROR("Unable to allocate memory for prim_buf\n");
-		return ENOMEM;
-	}
-   	memset(dev_priv->prim_bufs, 
-	       0, sizeof(drm_mga_prim_buf_t *) * (MGA_NUM_PRIM_BUFS + 1));
-   
-   	temp = init->warp_ucode_size + dev_priv->primary_size;
-	temp = ((temp + PAGE_SIZE - 1) / PAGE_SIZE) * PAGE_SIZE;
-	   
-	dev_priv->ioremap = drm_ioremap(dev->agp->base + offset, 
-					temp);
-	if(dev_priv->ioremap == NULL) {
-		DRM_DEBUG("Ioremap failed\n");
-		return ENOMEM;
-	}
-   	dev_priv->wait_queue = 0;
-   
-   	for(i = 0; i < MGA_NUM_PRIM_BUFS; i++) {
-	   	prim_buffer = drm_alloc(sizeof(drm_mga_prim_buf_t), 
-					DRM_MEM_DRIVER);
-	   	if(prim_buffer == NULL) return ENOMEM;
-	   	memset(prim_buffer, 0, sizeof(drm_mga_prim_buf_t));
-	   	prim_buffer->phys_head = offset + dev->agp->base;
-	   	prim_buffer->current_dma_ptr = 
-			prim_buffer->head = 
-			(u_int32_t *) (dev_priv->ioremap + 
-				       offset - 
-				       init->reserved_map_agpstart);
-	   	prim_buffer->num_dwords = 0;
-	   	prim_buffer->max_dwords = size_of_buf / sizeof(u_int32_t);
-	   	prim_buffer->max_dwords -= 5; /* Leave room for the softrap */
-	   	prim_buffer->sec_used = 0;
-	   	prim_buffer->idx = i;
-		prim_buffer->prim_age = i + 1;
-	   	offset = offset + size_of_buf;
-	   	dev_priv->prim_bufs[i] = prim_buffer;
-	}
-	dev_priv->current_prim_idx = 0;
-        dev_priv->next_prim = 
-		dev_priv->last_prim = 
-		dev_priv->current_prim =
-        	dev_priv->prim_bufs[0];
-	dev_priv->next_prim_age = 2;	
-	dev_priv->last_prim_age = 1;
-   	set_bit(MGA_BUF_IN_USE, &dev_priv->current_prim->buffer_status);
-   	return 0;
+	DRM_DEBUG( "   head = 0x%06lx\n", head - dev_priv->primary->offset );
+	DRM_DEBUG( "   tail = 0x%06lx\n", tail - dev_priv->primary->offset );
+	DRM_DEBUG( "  space = 0x%06x\n", primary->space );
+
+	mga_flush_write_combine();
+	MGA_WRITE( MGA_PRIMEND, tail | MGA_PAGPXFER );
+
+	DRM_DEBUG( "%s: done.\n", __FUNCTION__ );
 }
 
-static void mga_fire_primary(drm_device_t *dev, drm_mga_prim_buf_t *prim)
+void mga_do_dma_wrap_start( drm_mga_private_t *dev_priv )
 {
-       	drm_mga_private_t *dev_priv = dev->dev_private;
-      	drm_device_dma_t  *dma	    = dev->dma;
-       	drm_mga_sarea_t *sarea_priv = dev_priv->sarea_priv;
- 	int use_agp = PDEA_pagpxfer_enable;
-	unsigned long end;
-   	int i;
-   	int next_idx;
-       	PRIMLOCALS;
-
-   	DRM_DEBUG("%s\n", __FUNCTION__);
-   	dev_priv->last_prim = prim;
-   
- 	/* We never check for overflow, b/c there is always room */
-    	PRIMPTR(prim);
-   	if(num_dwords <= 0) {
-		DRM_DEBUG("num_dwords == 0 when dispatched\n");
-		goto out_prim_wait;
-	}
- 	PRIMOUTREG( MGAREG_DMAPAD, 0);
- 	PRIMOUTREG( MGAREG_DMAPAD, 0);
-       	PRIMOUTREG( MGAREG_DMAPAD, 0);
-   	PRIMOUTREG( MGAREG_SOFTRAP, 0);
-    	PRIMFINISH(prim);
-
-	end = ticks + (hz*3);
-    	if(sarea_priv->dirty & MGA_DMA_FLUSH) {
-		DRM_DEBUG("Dma top flush\n");	   
-		while((MGA_READ(MGAREG_STATUS) & 0x00030001) != 0x00020000) {
-			if((signed)(end - ticks) <= 0) {
-				DRM_ERROR("irqs: %d wanted %d\n", 
-					  atomic_read(&dev->total_irq), 
-					  atomic_read(&dma->total_lost));
-				DRM_ERROR("lockup in fire primary "
-					  "(Dma Top Flush)\n");
-				goto out_prim_wait;
-			}
-	      
-			for (i = 0 ; i < 4096 ; i++) mga_delay();
-		}
-		sarea_priv->dirty &= ~(MGA_DMA_FLUSH);
+	drm_mga_primary_buffer_t *primary = &dev_priv->prim;
+	u32 head, tail;
+	DMA_LOCALS;
+	DRM_DEBUG( "%s:\n", __FUNCTION__ );
+
+	BEGIN_DMA_WRAP();
+
+	DMA_BLOCK( MGA_DMAPAD,	0x00000000,
+		   MGA_DMAPAD,	0x00000000,
+		   MGA_DMAPAD,	0x00000000,
+		   MGA_DMAPAD,	0x00000000 );
+
+	ADVANCE_DMA();
+
+	tail = primary->tail + dev_priv->primary->offset;
+
+	primary->tail = 0;
+	primary->last_flush = 0;
+	primary->last_wrap++;
+
+	head = MGA_READ( MGA_PRIMADDRESS );
+
+	if ( head == dev_priv->primary->offset ) {
+		primary->space = primary->size;
 	} else {
-		DRM_DEBUG("Status wait\n");
-		while((MGA_READ(MGAREG_STATUS) & 0x00020001) != 0x00020000) {
-			if((signed)(end - ticks) <= 0) {
-				DRM_ERROR("irqs: %d wanted %d\n", 
-					  atomic_read(&dev->total_irq), 
-					  atomic_read(&dma->total_lost));
-				DRM_ERROR("lockup in fire primary "
-					  "(Status Wait)\n");
-				goto out_prim_wait;
-			}
-	   
-			for (i = 0 ; i < 4096 ; i++) mga_delay();
-		}
+		primary->space = head - dev_priv->primary->offset;
 	}
 
-   	mga_flush_write_combine();
-    	atomic_inc(&dev_priv->pending_bufs);
-       	MGA_WRITE(MGAREG_PRIMADDRESS, phys_head | TT_GENERAL);
- 	MGA_WRITE(MGAREG_PRIMEND, (phys_head + num_dwords * 4) | use_agp);
-   	prim->num_dwords = 0;
-	sarea_priv->last_enqueue = prim->prim_age;
-    
-   	next_idx = prim->idx + 1;
-    	if(next_idx >= MGA_NUM_PRIM_BUFS) 
-		next_idx = 0;
-
-    	dev_priv->next_prim = dev_priv->prim_bufs[next_idx];
-	return;
-
- out_prim_wait:
-	prim->num_dwords = 0;
-	prim->sec_used = 0;
-	clear_bit(MGA_BUF_IN_USE, &prim->buffer_status);
-   	wakeup(&dev_priv->wait_queue);
-	clear_bit(MGA_BUF_SWAP_PENDING, &prim->buffer_status);
-	clear_bit(MGA_IN_DISPATCH, &dev_priv->dispatch_status);
+	DRM_DEBUG( "   head = 0x%06lx\n",
+		  head - dev_priv->primary->offset );
+	DRM_DEBUG( "   tail = 0x%06x\n", primary->tail );
+	DRM_DEBUG( "   wrap = %d\n", primary->last_wrap );
+	DRM_DEBUG( "  space = 0x%06x\n", primary->space );
+
+	mga_flush_write_combine();
+	MGA_WRITE( MGA_PRIMEND, tail | MGA_PAGPXFER );
+
+	set_bit( 0, &primary->wrapped );
+	DRM_DEBUG( "%s: done.\n", __FUNCTION__ );
 }
 
-int mga_advance_primary(drm_device_t *dev)
+void mga_do_dma_wrap_end( drm_mga_private_t *dev_priv )
 {
-   	drm_mga_private_t *dev_priv = dev->dev_private;
-   	drm_mga_prim_buf_t *prim_buffer;
-   	drm_device_dma_t  *dma      = dev->dma;
-   	int		  next_prim_idx;
-   	int		  ret = 0;
-	int		  s;
-   
-   	/* This needs to reset the primary buffer if available,
-	 * we should collect stats on how many times it bites
-	 * it's tail */
-	DRM_DEBUG("%s\n", __FUNCTION__);
-   
-   	next_prim_idx = dev_priv->current_prim_idx + 1;
-   	if(next_prim_idx >= MGA_NUM_PRIM_BUFS)
-     		next_prim_idx = 0;
-   	prim_buffer = dev_priv->prim_bufs[next_prim_idx];
-	set_bit(MGA_IN_WAIT, &dev_priv->dispatch_status);
-   
-      	/* In use is cleared in interrupt handler */
-   
-	s = splsofttq();
-   	if(test_and_set_bit(MGA_BUF_IN_USE, &prim_buffer->buffer_status)) {
-	   	for (;;) {
-		   	mga_dma_schedule(dev, 0);
-		   	if(!test_and_set_bit(MGA_BUF_IN_USE, 
-					     &prim_buffer->buffer_status)) 
-				break;
-		   	atomic_inc(&dev->total_sleeps);
-		   	atomic_inc(&dma->total_missed_sched);
-			ret = tsleep(&dev_priv->wait_queue, PZERO|PCATCH,
-				     "mgaap", 0);
-			if (ret)
-				break;
-		}
-	   	if(ret) {
-			splx(s);
-			return ret;
-		}
-	}
-	clear_bit(MGA_IN_WAIT, &dev_priv->dispatch_status);
-	splx(s);
-
-   	/* This primary buffer is now free to use */
-   	prim_buffer->current_dma_ptr = prim_buffer->head;
-   	prim_buffer->num_dwords = 0;
-   	prim_buffer->sec_used = 0;
-	prim_buffer->prim_age = dev_priv->next_prim_age++;
-	if(prim_buffer->prim_age == 0 || prim_buffer->prim_age == 0xffffffff) {
-	   mga_flush_queue(dev);
-	   mga_dma_quiescent(dev);
-	   mga_reset_freelist(dev);
-	   prim_buffer->prim_age = (dev_priv->next_prim_age += 2);
-	}
+	drm_mga_primary_buffer_t *primary = &dev_priv->prim;
+	drm_mga_sarea_t *sarea_priv = dev_priv->sarea_priv;
+	u32 head = dev_priv->primary->offset;
+	DRM_DEBUG( "%s:\n", __FUNCTION__ );
+
+	sarea_priv->last_wrap++;
+	DRM_DEBUG( "   wrap = %d\n", sarea_priv->last_wrap );
 
-	/* Reset all buffer status stuff */
-	clear_bit(MGA_BUF_NEEDS_OVERFLOW, &prim_buffer->buffer_status);
-	clear_bit(MGA_BUF_FORCE_FIRE, &prim_buffer->buffer_status);
-	clear_bit(MGA_BUF_SWAP_PENDING, &prim_buffer->buffer_status);
+	mga_flush_write_combine();
+	MGA_WRITE( MGA_PRIMADDRESS, head | MGA_DMA_GENERAL );
 
-   	dev_priv->current_prim = prim_buffer;
-   	dev_priv->current_prim_idx = next_prim_idx;
-   	return 0;
+	clear_bit( 0, &primary->wrapped );
+	DRM_DEBUG( "%s: done.\n", __FUNCTION__ );
 }
 
-/* More dynamic performance decisions */
-static __inline int mga_decide_to_fire(drm_device_t *dev)
+
+/* ================================================================
+ * Freelist management
+ */
+
+#define MGA_BUFFER_USED		~0
+#define MGA_BUFFER_FREE		0
+
+#if MGA_FREELIST_DEBUG
+static void mga_freelist_print( drm_device_t *dev )
 {
-   	drm_mga_private_t *dev_priv = (drm_mga_private_t *)dev->dev_private;
+	drm_mga_private_t *dev_priv = dev->dev_private;
+	drm_mga_freelist_t *entry;
+
+	DRM_INFO( "\n" );
+	DRM_INFO( "current dispatch: last=0x%x done=0x%x\n",
+		  dev_priv->sarea_priv->last_dispatch,
+		  (unsigned int)(MGA_READ( MGA_PRIMADDRESS ) -
+				 dev_priv->primary->offset) );
+	DRM_INFO( "current freelist:\n" );
+
+	for ( entry = dev_priv->head->next ; entry ; entry = entry->next ) {
+		DRM_INFO( "   %p   idx=%2d  age=0x%x 0x%06lx\n",
+			  entry, entry->buf->idx, entry->age.head,
+			  entry->age.head - dev_priv->primary->offset );
+	}
+	DRM_INFO( "\n" );
+}
+#endif
 
-   	DRM_DEBUG("%s\n", __FUNCTION__);
+static int mga_freelist_init( drm_device_t *dev, drm_mga_private_t *dev_priv )
+{
+	drm_device_dma_t *dma = dev->dma;
+	drm_buf_t *buf;
+	drm_mga_buf_priv_t *buf_priv;
+	drm_mga_freelist_t *entry;
+	int i;
+	DRM_DEBUG( "%s: count=%d\n",
+		   __FUNCTION__, dma->buf_count );
 
-   	if(test_bit(MGA_BUF_FORCE_FIRE, &dev_priv->next_prim->buffer_status)) {
-	   	return 1;
-	}
+	dev_priv->head = DRM(alloc)( sizeof(drm_mga_freelist_t),
+				     DRM_MEM_DRIVER );
+	if ( dev_priv->head == NULL )
+		DRM_OS_RETURN(ENOMEM);
 
-	if (test_bit(MGA_IN_GETBUF, &dev_priv->dispatch_status) &&
-	    dev_priv->next_prim->num_dwords) {
-	   	return 1;
-	}
+	memset( dev_priv->head, 0, sizeof(drm_mga_freelist_t) );
+	SET_AGE( &dev_priv->head->age, MGA_BUFFER_USED, 0 );
 
-	if (test_bit(MGA_IN_FLUSH, &dev_priv->dispatch_status) &&
-	    dev_priv->next_prim->num_dwords) {
-	   	return 1;
-	}
-   
-   	if(atomic_read(&dev_priv->pending_bufs) <= MGA_NUM_PRIM_BUFS - 1) {
-		if(test_bit(MGA_BUF_SWAP_PENDING, 
-			    &dev_priv->next_prim->buffer_status)) {
-			return 1;
-		}
-	}
+	for ( i = 0 ; i < dma->buf_count ; i++ ) {
+		buf = dma->buflist[i];
+	        buf_priv = buf->dev_private;
 
-   	if(atomic_read(&dev_priv->pending_bufs) <= MGA_NUM_PRIM_BUFS / 2) {
-		if(dev_priv->next_prim->sec_used >= MGA_DMA_BUF_NR / 8) {
-			return 1;
-		}
-	}
+		entry = DRM(alloc)( sizeof(drm_mga_freelist_t),
+				    DRM_MEM_DRIVER );
+		if ( entry == NULL )
+			DRM_OS_RETURN(ENOMEM);
 
-   	if(atomic_read(&dev_priv->pending_bufs) >= MGA_NUM_PRIM_BUFS / 2) {
-		if(dev_priv->next_prim->sec_used >= MGA_DMA_BUF_NR / 4) {
-			return 1;
-		}
-	}
+		memset( entry, 0, sizeof(drm_mga_freelist_t) );
 
-   	return 0;
-}
+		entry->next = dev_priv->head->next;
+		entry->prev = dev_priv->head;
+		SET_AGE( &entry->age, MGA_BUFFER_FREE, 0 );
+		entry->buf = buf;
 
-int mga_dma_schedule(drm_device_t *dev, int locked)
-{
-      	drm_mga_private_t *dev_priv = (drm_mga_private_t *)dev->dev_private;
-	int	retval =0 ;
+		if ( dev_priv->head->next != NULL )
+			dev_priv->head->next->prev = entry;
+		if ( entry->next == NULL )
+			dev_priv->tail = entry;
 
-	if (!dev_priv) return EBUSY;
+		buf_priv->list_entry = entry;
+		buf_priv->discard = 0;
+		buf_priv->dispatched = 0;
 
-   	if (test_and_set_bit(0, &dev->dma_flag)) {
-		retval = EBUSY;
-		goto sch_out_wakeup;
-	}
-   
-	DRM_DEBUG("%s\n", __FUNCTION__);
-	if (!dev_priv) {
-		DRM_DEBUG("dev_priv is not set\n");
-		return (0);
+		dev_priv->head->next = entry;
 	}
 
-   	if(test_bit(MGA_IN_FLUSH, &dev_priv->dispatch_status) || 
-	   test_bit(MGA_IN_WAIT, &dev_priv->dispatch_status) ||
-	   test_bit(MGA_IN_GETBUF, &dev_priv->dispatch_status)) {
-		locked = 1;
-	}
-   
-   	if (!locked && 
-	    !drm_lock_take(&dev->lock.hw_lock->lock, DRM_KERNEL_CONTEXT)) {
-	   	clear_bit(0, &dev->dma_flag);
-		DRM_DEBUG("Not locked\n");
-		retval = EBUSY;
-		goto sch_out_wakeup;
-	}
+	return 0;
+}
 
-   	if(!test_and_set_bit(MGA_IN_DISPATCH, &dev_priv->dispatch_status)) {
-	   	/* Fire dma buffer */
-	   	if(mga_decide_to_fire(dev)) {
-			clear_bit(MGA_BUF_FORCE_FIRE, 
-				  &dev_priv->next_prim->buffer_status);
-		   	if(dev_priv->current_prim == dev_priv->next_prim) {
-				/* Schedule overflow for a later time */
-				set_bit(MGA_BUF_NEEDS_OVERFLOW,
-					&dev_priv->next_prim->buffer_status);
-			}
-		   	mga_fire_primary(dev, dev_priv->next_prim);
-		} else {
-			clear_bit(MGA_IN_DISPATCH, &dev_priv->dispatch_status);
-		}
-	}
-   	
-	if (!locked) {
-		if (drm_lock_free(dev, &dev->lock.hw_lock->lock,
-				  DRM_KERNEL_CONTEXT)) {
-			DRM_ERROR("\n");
-		}
-	}
-	clear_bit(0, &dev->dma_flag);
-sch_out_wakeup:
-      	if(test_bit(MGA_IN_FLUSH, &dev_priv->dispatch_status) &&
-	   atomic_read(&dev_priv->pending_bufs) == 0) {
-	   	/* Everything has been processed by the hardware */
-		clear_bit(MGA_IN_FLUSH, &dev_priv->dispatch_status);
-	   	wakeup(&dev_priv->flush_queue);
-	}
+static void mga_freelist_cleanup( drm_device_t *dev )
+{
+	drm_mga_private_t *dev_priv = dev->dev_private;
+	drm_mga_freelist_t *entry;
+	drm_mga_freelist_t *next;
+	DRM_DEBUG( "%s\n", __FUNCTION__ );
 
-	if(test_bit(MGA_IN_GETBUF, &dev_priv->dispatch_status) &&
-	   dev_priv->tail->age < dev_priv->last_prim_age) 
-		wakeup(&dev_priv->buf_queue);
+	entry = dev_priv->head;
+	while ( entry ) {
+		next = entry->next;
+		DRM(free)( entry, sizeof(drm_mga_freelist_t), DRM_MEM_DRIVER );
+		entry = next;
+	}
 
-	return retval;
+	dev_priv->head = dev_priv->tail = NULL;
 }
 
-static void mga_dma_service(void *arg)
+#if 0
+/* FIXME: Still needed?
+ */
+static void mga_freelist_reset( drm_device_t *dev )
 {
-    	drm_device_t	 *dev = (drm_device_t *)arg;
-    	drm_mga_private_t *dev_priv = (drm_mga_private_t *)dev->dev_private;
-    	drm_mga_prim_buf_t *last_prim_buffer;
-
-    	atomic_inc(&dev->total_irq);
-	if((MGA_READ(MGAREG_STATUS) & 0x00000001) != 0x00000001) return;
-      	MGA_WRITE(MGAREG_ICLEAR, 0x00000001);
-   	last_prim_buffer = dev_priv->last_prim;
-    	last_prim_buffer->num_dwords = 0;
-    	last_prim_buffer->sec_used = 0;
-	dev_priv->sarea_priv->last_dispatch = 
-		dev_priv->last_prim_age = last_prim_buffer->prim_age;
-      	clear_bit(MGA_BUF_IN_USE, &last_prim_buffer->buffer_status);
-      	clear_bit(MGA_BUF_SWAP_PENDING, &last_prim_buffer->buffer_status);
-      	clear_bit(MGA_IN_DISPATCH, &dev_priv->dispatch_status);
-      	atomic_dec(&dev_priv->pending_bufs);
-	taskqueue_enqueue(taskqueue_swi, &dev->task);
-   	wakeup(&dev_priv->wait_queue);
+	drm_device_dma_t *dma = dev->dma;
+	drm_buf_t *buf;
+	drm_mga_buf_priv_t *buf_priv;
+	int i;
+
+	for ( i = 0 ; i < dma->buf_count ; i++ ) {
+		buf = dma->buflist[i];
+	        buf_priv = buf->dev_private;
+		SET_AGE( &buf_priv->list_entry->age,
+			 MGA_BUFFER_FREE, 0 );
+	}
 }
+#endif
 
-static void mga_dma_task_queue(void *device, int pending)
+static drm_buf_t *mga_freelist_get( drm_device_t *dev )
 {
-	DRM_DEBUG("%s\n", __FUNCTION__);
-	mga_dma_schedule((drm_device_t *)device, 0);
+	drm_mga_private_t *dev_priv = dev->dev_private;
+	drm_mga_freelist_t *next;
+	drm_mga_freelist_t *prev;
+	drm_mga_freelist_t *tail = dev_priv->tail;
+	u32 head, wrap;
+	DRM_DEBUG( "%s:\n", __FUNCTION__ );
+
+	head = MGA_READ( MGA_PRIMADDRESS );
+	wrap = dev_priv->sarea_priv->last_wrap;
+
+	DRM_DEBUG( "   tail=0x%06lx %d\n",
+		   tail->age.head ?
+		   tail->age.head - dev_priv->primary->offset : 0,
+		   tail->age.wrap );
+	DRM_DEBUG( "   head=0x%06lx %d\n",
+		   head - dev_priv->primary->offset, wrap );
+
+	if ( TEST_AGE( &tail->age, head, wrap ) ) {
+		prev = dev_priv->tail->prev;
+		next = dev_priv->tail;
+		prev->next = NULL;
+		next->prev = next->next = NULL;
+		dev_priv->tail = prev;
+		SET_AGE( &next->age, MGA_BUFFER_USED, 0 );
+		return next->buf;
+	}
+
+	DRM_DEBUG( "returning NULL!\n" );
+	return NULL;
 }
 
-int mga_dma_cleanup(drm_device_t *dev)
+int mga_freelist_put( drm_device_t *dev, drm_buf_t *buf )
 {
-	DRM_DEBUG("%s\n", __FUNCTION__);
-
-	if(dev->dev_private) {
-		drm_mga_private_t *dev_priv = 
-			(drm_mga_private_t *) dev->dev_private;
-      
-		if (dev->irq) mga_flush_queue(dev);
-		mga_dma_quiescent(dev);
-		if(dev_priv->ioremap) {
-			int temp = (dev_priv->warp_ucode_size + 
-				    dev_priv->primary_size + 
-				    PAGE_SIZE - 1) / PAGE_SIZE * PAGE_SIZE;
-
-			drm_ioremapfree((void *) dev_priv->ioremap, temp);
-		}
-	   	if(dev_priv->real_status_page != 0UL) {
-		   	mga_free_page(dev, dev_priv->real_status_page);
-		}
-	   	if(dev_priv->prim_bufs != NULL) {
-		   	int i;
-		   	for(i = 0; i < MGA_NUM_PRIM_BUFS; i++) {
-			   	if(dev_priv->prim_bufs[i] != NULL) {
-			     		drm_free(dev_priv->prim_bufs[i],
-						 sizeof(drm_mga_prim_buf_t),
-						 DRM_MEM_DRIVER);
-				}
-			}
-		   	drm_free(dev_priv->prim_bufs, sizeof(void *) *
-				 (MGA_NUM_PRIM_BUFS + 1), 
-				 DRM_MEM_DRIVER);
-		}
-		if(dev_priv->head != NULL) {
-		   	mga_freelist_cleanup(dev);
-		}
+	drm_mga_private_t *dev_priv = dev->dev_private;
+	drm_mga_buf_priv_t *buf_priv = buf->dev_private;
+	drm_mga_freelist_t *head, *entry, *prev;
 
+	DRM_DEBUG( "%s: age=0x%06lx wrap=%d\n",
+		   __FUNCTION__,
+		   buf_priv->list_entry->age.head -
+		   dev_priv->primary->offset,
+		   buf_priv->list_entry->age.wrap );
 
-		drm_free(dev->dev_private, sizeof(drm_mga_private_t), 
-			 DRM_MEM_DRIVER);
-		dev->dev_private = NULL;
+	entry = buf_priv->list_entry;
+	head = dev_priv->head;
+
+	if ( buf_priv->list_entry->age.head == MGA_BUFFER_USED ) {
+		SET_AGE( &entry->age, MGA_BUFFER_FREE, 0 );
+		prev = dev_priv->tail;
+		prev->next = entry;
+		entry->prev = prev;
+		entry->next = NULL;
+	} else {
+		prev = head->next;
+		head->next = entry;
+		prev->prev = entry;
+		entry->prev = head;
+		entry->next = prev;
 	}
 
 	return 0;
 }
 
-static int mga_dma_initialize(drm_device_t *dev, drm_mga_init_t *init) {
+
+/* ================================================================
+ * DMA initialization, cleanup
+ */
+
+static int mga_do_init_dma( drm_device_t *dev, drm_mga_init_t *init )
+{
 	drm_mga_private_t *dev_priv;
-	drm_map_t *sarea_map = NULL;
+	drm_map_list_entry_t *listentry;
+	int ret;
+	DRM_DEBUG( "%s\n", __FUNCTION__ );
 
-	dev_priv = drm_alloc(sizeof(drm_mga_private_t), DRM_MEM_DRIVER);
-	if(dev_priv == NULL) return ENOMEM;
-	dev->dev_private = (void *) dev_priv;
+	dev_priv = DRM(alloc)( sizeof(drm_mga_private_t), DRM_MEM_DRIVER );
+	if ( !dev_priv )
+		DRM_OS_RETURN(ENOMEM);
 
-	memset(dev_priv, 0, sizeof(drm_mga_private_t));
+	memset( dev_priv, 0, sizeof(drm_mga_private_t) );
 
-	if((init->reserved_map_idx >= dev->map_count) ||
-	   (init->buffer_map_idx >= dev->map_count)) {
-		mga_dma_cleanup(dev);
-		DRM_DEBUG("reserved_map or buffer_map are invalid\n");
-		return EINVAL;
-	}
-   
-	dev_priv->reserved_map_idx = init->reserved_map_idx;
-	dev_priv->buffer_map_idx = init->buffer_map_idx;
-	sarea_map = dev->maplist[0];
-	dev_priv->sarea_priv = (drm_mga_sarea_t *) 
-		((u_int8_t *)sarea_map->handle + 
-		 init->sarea_priv_offset);
-
-	/* Scale primary size to the next page */
 	dev_priv->chipset = init->chipset;
-	dev_priv->frontOffset = init->frontOffset;
-	dev_priv->backOffset = init->backOffset;
-	dev_priv->depthOffset = init->depthOffset;
-	dev_priv->textureOffset = init->textureOffset;
-	dev_priv->textureSize = init->textureSize;
-	dev_priv->cpp = init->cpp;
-	dev_priv->sgram = init->sgram;
-	dev_priv->stride = init->stride;
-
-	dev_priv->mAccess = init->mAccess;
-   	dev_priv->flush_queue = 0;
-	dev_priv->WarpPipe = 0xff000000;
-	dev_priv->vertexsize = 0;
-
-   	DRM_DEBUG("chipset: %d ucode_size: %d backOffset: %x depthOffset: %x\n",
-		  dev_priv->chipset, dev_priv->warp_ucode_size, 
-		  dev_priv->backOffset, dev_priv->depthOffset);
-   	DRM_DEBUG("cpp: %d sgram: %d stride: %d maccess: %x\n",
-		  dev_priv->cpp, dev_priv->sgram, dev_priv->stride, 
-		  dev_priv->mAccess);
-   
-	memcpy(&dev_priv->WarpIndex, &init->WarpIndex, 
-	       sizeof(drm_mga_warp_index_t) * MGA_MAX_WARP_PIPES);
-
-   	if(mga_init_primary_bufs(dev, init) != 0) {
-		DRM_ERROR("Can not initialize primary buffers\n");
-		mga_dma_cleanup(dev);
-		return ENOMEM;
+
+	dev_priv->usec_timeout = MGA_DEFAULT_USEC_TIMEOUT;
+
+	if ( init->sgram ) {
+		dev_priv->clear_cmd = MGA_DWGCTL_CLEAR | MGA_ATYPE_BLK;
+	} else {
+		dev_priv->clear_cmd = MGA_DWGCTL_CLEAR | MGA_ATYPE_RSTR;
 	}
-   	dev_priv->real_status_page = mga_alloc_page(dev);
-      	if(dev_priv->real_status_page == 0UL) {
-		mga_dma_cleanup(dev);
-		DRM_ERROR("Can not allocate status page\n");
-		return ENOMEM;
+	dev_priv->maccess	= init->maccess;
+
+	dev_priv->fb_cpp	= init->fb_cpp;
+	dev_priv->front_offset	= init->front_offset;
+	dev_priv->front_pitch	= init->front_pitch;
+	dev_priv->back_offset	= init->back_offset;
+	dev_priv->back_pitch	= init->back_pitch;
+
+	dev_priv->depth_cpp	= init->depth_cpp;
+	dev_priv->depth_offset	= init->depth_offset;
+	dev_priv->depth_pitch	= init->depth_pitch;
+
+	/* FIXME: Need to support AGP textures...
+	 */
+	dev_priv->texture_offset = init->texture_offset[0];
+	dev_priv->texture_size = init->texture_size[0];
+
+	TAILQ_FOREACH(listentry, dev->maplist, link) {
+		drm_map_t *map = listentry->map;
+		if (map->type == _DRM_SHM &&
+			map->flags & _DRM_CONTAINS_LOCK) {
+			dev_priv->sarea = map;
+			break;
+		}
 	}
 
-   	dev_priv->status_page = (void*)dev_priv->real_status_page; /* XXX wants nocache */
+	if(!dev_priv->sarea) {
+		DRM_ERROR( "failed to find sarea!\n" );
+		/* Assign dev_private so we can do cleanup. */
+		dev->dev_private = (void *)dev_priv;
+		mga_do_cleanup_dma( dev );
+		DRM_OS_RETURN(EINVAL);
+	}
+
+
+	DRM_FIND_MAP( dev_priv->fb, init->fb_offset );
+	if(!dev_priv->fb) {
+		DRM_ERROR( "failed to find framebuffer!\n" );
+		/* Assign dev_private so we can do cleanup. */
+		dev->dev_private = (void *)dev_priv;
+		mga_do_cleanup_dma( dev );
+		DRM_OS_RETURN(EINVAL);
+	}
+	DRM_FIND_MAP( dev_priv->mmio, init->mmio_offset );
+	if(!dev_priv->mmio) {
+		DRM_ERROR( "failed to find mmio region!\n" );
+		/* Assign dev_private so we can do cleanup. */
+		dev->dev_private = (void *)dev_priv;
+		mga_do_cleanup_dma( dev );
+		DRM_OS_RETURN(EINVAL);
+	}
+	DRM_FIND_MAP( dev_priv->status, init->status_offset );
+	if(!dev_priv->status) {
+		DRM_ERROR( "failed to find status page!\n" );
+		/* Assign dev_private so we can do cleanup. */
+		dev->dev_private = (void *)dev_priv;
+		mga_do_cleanup_dma( dev );
+		DRM_OS_RETURN(EINVAL);
+	}
+	DRM_FIND_MAP( dev_priv->warp, init->warp_offset );
+	if(!dev_priv->warp) {
+		DRM_ERROR( "failed to find warp microcode region!\n" );
+		/* Assign dev_private so we can do cleanup. */
+		dev->dev_private = (void *)dev_priv;
+		mga_do_cleanup_dma( dev );
+		DRM_OS_RETURN(EINVAL);
+	}
+	DRM_FIND_MAP( dev_priv->primary, init->primary_offset );
+	if(!dev_priv->primary) {
+		DRM_ERROR( "failed to find primary dma region!\n" );
+		/* Assign dev_private so we can do cleanup. */
+		dev->dev_private = (void *)dev_priv;
+		mga_do_cleanup_dma( dev );
+		DRM_OS_RETURN(EINVAL);
+	}
+	DRM_FIND_MAP( dev_priv->buffers, init->buffers_offset );
+	if(!dev_priv->buffers) {
+		DRM_ERROR( "failed to find dma buffer region!\n" );
+		/* Assign dev_private so we can do cleanup. */
+		dev->dev_private = (void *)dev_priv;
+		mga_do_cleanup_dma( dev );
+		DRM_OS_RETURN(EINVAL);
+	}
+
+	dev_priv->sarea_priv =
+		(drm_mga_sarea_t *)((u8 *)dev_priv->sarea->handle +
+				    init->sarea_priv_offset);
+
+	DRM_IOREMAP( dev_priv->warp );
+	DRM_IOREMAP( dev_priv->primary );
+	DRM_IOREMAP( dev_priv->buffers );
+
+	if(!dev_priv->warp->handle ||
+	   !dev_priv->primary->handle ||
+	   !dev_priv->buffers->handle ) {
+		DRM_ERROR( "failed to ioremap agp regions!\n" );
+		/* Assign dev_private so we can do cleanup. */
+		dev->dev_private = (void *)dev_priv;
+		mga_do_cleanup_dma( dev );
+		DRM_OS_RETURN(ENOMEM);
+	}
+
+	ret = mga_warp_install_microcode( dev_priv );
+	if ( ret < 0 ) {
+		DRM_ERROR( "failed to install WARP ucode!\n" );
+		/* Assign dev_private so we can do cleanup. */
+		dev->dev_private = (void *)dev_priv;
+		mga_do_cleanup_dma( dev );
+		DRM_OS_RETURN(ret);
+	}
+
+	ret = mga_warp_init( dev_priv );
+	if ( ret < 0 ) {
+		DRM_ERROR( "failed to init WARP engine!\n" );
+		/* Assign dev_private so we can do cleanup. */
+		dev->dev_private = (void *)dev_priv;
+		mga_do_cleanup_dma( dev );
+		DRM_OS_RETURN(ret);
+	}
+
+	dev_priv->prim.status = (u32 *)dev_priv->status->handle;
+
+	mga_do_wait_for_idle( dev_priv );
+
+	/* Init the primary DMA registers.
+	 */
+	MGA_WRITE( MGA_PRIMADDRESS,
+		   dev_priv->primary->offset | MGA_DMA_GENERAL );
 #if 0
-   	dev_priv->status_page = 
-		ioremap_nocache(virt_to_bus((void *)dev_priv->real_status_page),
-				PAGE_SIZE);
-
-   	if(dev_priv->status_page == NULL) {
-		mga_dma_cleanup(dev);
-		DRM_ERROR("Can not remap status page\n");
-		return ENOMEM;
-	}
+	MGA_WRITE( MGA_PRIMPTR,
+		   virt_to_bus((void *)dev_priv->prim.status) |
+		   MGA_PRIMPTREN0 |	/* Soft trap, SECEND, SETUPEND */
+		   MGA_PRIMPTREN1 );	/* DWGSYNC */
 #endif
 
-   	/* Write status page when secend or softrap occurs */
-   	MGA_WRITE(MGAREG_PRIMPTR, 
-		  vtophys((void *)dev_priv->real_status_page) | 0x00000003);
-      
-
-	/* Private is now filled in, initialize the hardware */
-	{
-		PRIMLOCALS;
-		PRIMGETPTR( dev_priv );
-	   	   
-		PRIMOUTREG(MGAREG_DMAPAD, 0);
-		PRIMOUTREG(MGAREG_DMAPAD, 0);
-		PRIMOUTREG(MGAREG_DWGSYNC, 0x0100);
-		PRIMOUTREG(MGAREG_SOFTRAP, 0);
-		/* Poll for the first buffer to insure that
-		 * the status register will be correct
-		 */
-	   
-		mga_flush_write_combine();
-	   	MGA_WRITE(MGAREG_PRIMADDRESS, phys_head | TT_GENERAL);
-
-		MGA_WRITE(MGAREG_PRIMEND, ((phys_head + num_dwords * 4) | 
-					   PDEA_pagpxfer_enable));
-	   
-	   	while(MGA_READ(MGAREG_DWGSYNC) != 0x0100) ;
+	dev_priv->prim.start = (u8 *)dev_priv->primary->handle;
+	dev_priv->prim.end = ((u8 *)dev_priv->primary->handle
+			      + dev_priv->primary->size);
+	dev_priv->prim.size = dev_priv->primary->size;
+
+	dev_priv->prim.tail = 0;
+	dev_priv->prim.space = dev_priv->prim.size;
+	dev_priv->prim.wrapped = 0;
+
+	dev_priv->prim.last_flush = 0;
+	dev_priv->prim.last_wrap = 0;
+
+	dev_priv->prim.high_mark = 256 * DMA_BLOCK_SIZE;
+
+
+	dev_priv->prim.status[0] = dev_priv->primary->offset;
+	dev_priv->prim.status[1] = 0;
+
+	dev_priv->sarea_priv->last_wrap = 0;
+	dev_priv->sarea_priv->last_frame.head = 0;
+	dev_priv->sarea_priv->last_frame.wrap = 0;
+
+	if ( mga_freelist_init( dev, dev_priv ) < 0 ) {
+		DRM_ERROR( "could not initialize freelist\n" );
+		/* Assign dev_private so we can do cleanup. */
+		dev->dev_private = (void *)dev_priv;
+		mga_do_cleanup_dma( dev );
+		DRM_OS_RETURN(ENOMEM);
 	}
 
-	if(mga_freelist_init(dev) != 0) {
-	   	DRM_ERROR("Could not initialize freelist\n");
-	   	mga_dma_cleanup(dev);
-	   	return ENOMEM;
+	/* Make dev_private visable to others. */
+	dev->dev_private = (void *)dev_priv;
+	return 0;
+}
+
+int mga_do_cleanup_dma( drm_device_t *dev )
+{
+	DRM_DEBUG( "%s\n", __FUNCTION__ );
+
+	if ( dev->dev_private ) {
+		drm_mga_private_t *dev_priv = dev->dev_private;
+
+		DRM_IOREMAPFREE( dev_priv->warp );
+		DRM_IOREMAPFREE( dev_priv->primary );
+		DRM_IOREMAPFREE( dev_priv->buffers );
+
+		if ( dev_priv->head != NULL ) {
+			mga_freelist_cleanup( dev );
+		}
+
+		DRM(free)( dev->dev_private, sizeof(drm_mga_private_t),
+			   DRM_MEM_DRIVER );
+		dev->dev_private = NULL;
 	}
+
 	return 0;
 }
 
-int
-mga_dma_init(dev_t kdev, u_long cmd, caddr_t data, int flags, struct proc *p)
+int mga_dma_init( DRM_OS_IOCTL )
 {
-        drm_device_t *dev = kdev->si_drv1;
+	DRM_OS_DEVICE;
 	drm_mga_init_t init;
-   
-   	DRM_DEBUG("%s\n", __FUNCTION__);
 
-	init = *(drm_mga_init_t *) data;
-   
-	switch(init.func) {
+	DRM_OS_KRNFROMUSR( init, (drm_mga_init_t *) data, sizeof(init) );
+
+	switch ( init.func ) {
 	case MGA_INIT_DMA:
-		return mga_dma_initialize(dev, &init);
+		return mga_do_init_dma( dev, &init );
 	case MGA_CLEANUP_DMA:
-		return mga_dma_cleanup(dev);
+		return mga_do_cleanup_dma( dev );
 	}
 
-	return EINVAL;
+	DRM_OS_RETURN( EINVAL );
 }
 
-int mga_irq_install(drm_device_t *dev, int irq)
+
+/* ================================================================
+ * Primary DMA stream management
+ */
+
+int mga_dma_flush( DRM_OS_IOCTL )
 {
-	int rid;
-	int retcode;
+	DRM_OS_DEVICE;
+	drm_mga_private_t *dev_priv = (drm_mga_private_t *)dev->dev_private;
+	drm_lock_t lock;
 
-	if (!irq)     return EINVAL;
-	
-	lockmgr(&dev->dev_lock, LK_EXCLUSIVE, 0, curproc);
-	if (dev->irq) {
-		lockmgr(&dev->dev_lock, LK_RELEASE, 0, curproc);
-		return EBUSY;
-	}
-	lockmgr(&dev->dev_lock, LK_RELEASE, 0, curproc);
-	
-	DRM_DEBUG("install irq handler %d\n", irq);
-
-	dev->context_flag     = 0;
-	dev->interrupt_flag   = 0;
-	dev->dma_flag	      = 0;
-	dev->dma->next_buffer = NULL;
-	dev->dma->next_queue  = NULL;
-	dev->dma->this_buffer = NULL;
-	TASK_INIT(&dev->task, 0, mga_dma_task_queue, dev);
-
-				/* Before installing handler */
-	MGA_WRITE(MGAREG_IEN, 0);
-   				/* Install handler */
-	rid = 0;
-	dev->irq = bus_alloc_resource(dev->device, SYS_RES_IRQ, &rid,
-				      0, ~0, 1, RF_SHAREABLE);
-	if (!dev->irq)
-		return ENOENT;
-
-	retcode = bus_setup_intr(dev->device, dev->irq, INTR_TYPE_TTY,
-				 mga_dma_service, dev, &dev->irqh);
-	if (retcode) {
-		bus_release_resource(dev->device, SYS_RES_IRQ, 0, dev->irq);
-		dev->irq = 0;
-		return retcode;
-	}
+	LOCK_TEST_WITH_RETURN( dev );
 
-				/* After installing handler */
-   	MGA_WRITE(MGAREG_ICLEAR, 0x00000001);
-	MGA_WRITE(MGAREG_IEN, 0x00000001);
-	return 0;
-}
+	DRM_OS_KRNFROMUSR( lock, (drm_lock_t *) data, sizeof(lock) );
 
-int mga_irq_uninstall(drm_device_t *dev)
-{
-	if (!dev->irq)
-		return EINVAL;
-	
-   	DRM_DEBUG("remove irq handler %ld\n", rman_get_start(dev->irq));
-      	MGA_WRITE(MGAREG_ICLEAR, 0x00000001);
-	MGA_WRITE(MGAREG_IEN, 0);
+	DRM_DEBUG( "%s: %s%s%s\n",
+		   __FUNCTION__,
+		   (lock.flags & _DRM_LOCK_FLUSH) ?	"flush, " : "",
+		   (lock.flags & _DRM_LOCK_FLUSH_ALL) ?	"flush all, " : "",
+		   (lock.flags & _DRM_LOCK_QUIESCENT) ?	"idle, " : "" );
 
-	bus_teardown_intr(dev->device, dev->irq, dev->irqh);
-	bus_release_resource(dev->device, SYS_RES_IRQ, 0, dev->irq);
-	dev->irq = 0;
+	WRAP_WAIT_WITH_RETURN( dev_priv );
 
-	return 0;
-}
+	if ( lock.flags & (_DRM_LOCK_FLUSH | _DRM_LOCK_FLUSH_ALL) ) {
+		mga_do_dma_flush( dev_priv );
+	}
 
-int mga_control(dev_t kdev, u_long cmd, caddr_t data,
-		int flags, struct proc *p)
-{
-	drm_device_t	*dev	= kdev->si_drv1;
-	drm_control_t	ctl;
-   
-	ctl = *(drm_control_t *) data;
-
-   	DRM_DEBUG("%s\n", __FUNCTION__);
-
-	switch (ctl.func) {
-	case DRM_INST_HANDLER:
-		return mga_irq_install(dev, ctl.irq);
-	case DRM_UNINST_HANDLER:
-		return mga_irq_uninstall(dev);
-	default:
-		return EINVAL;
+	if ( lock.flags & _DRM_LOCK_QUIESCENT ) {
+#if MGA_DMA_DEBUG
+		int ret = mga_do_wait_for_idle( dev_priv );
+		if ( ret )
+			DRM_INFO( __FUNCTION__": -EBUSY\n" );
+		return ret;
+#else
+		return mga_do_wait_for_idle( dev_priv );
+#endif
+	} else {
+		return 0;
 	}
 }
 
-static int mga_flush_queue(drm_device_t *dev)
+int mga_dma_reset( DRM_OS_IOCTL )
 {
-  	drm_mga_private_t *dev_priv = (drm_mga_private_t *)dev->dev_private;
-   	int ret = 0;
-	int s;
-
-   	DRM_DEBUG("%s\n", __FUNCTION__);
-
-   	if(!dev_priv) return 0;
-   
-   	if(dev_priv->next_prim->num_dwords != 0) {
-		s = splsofttq();
-		set_bit(MGA_IN_FLUSH, &dev_priv->dispatch_status);
-   		for (;;) {
-		   	mga_dma_schedule(dev, 0);
-	   		if (!test_bit(MGA_IN_FLUSH, 
-				      &dev_priv->dispatch_status)) 
-				break;
-		   	atomic_inc(&dev->total_sleeps);
-			ret = tsleep(&dev_priv->flush_queue, PZERO|PCATCH,
-				     "mgafq", 0);
-			if (ret) {
-				clear_bit(MGA_IN_FLUSH, 
-					  &dev_priv->dispatch_status);
-		   		break;
-			}
-		}
-		splx(s);
-	}
-   	return ret;
+	DRM_OS_DEVICE;
+	drm_mga_private_t *dev_priv = (drm_mga_private_t *)dev->dev_private;
+
+	LOCK_TEST_WITH_RETURN( dev );
+
+	return mga_do_dma_reset( dev_priv );
 }
 
-/* Must be called with the lock held */
-void mga_reclaim_buffers(drm_device_t *dev, pid_t pid)
+
+/* ================================================================
+ * DMA buffer management
+ */
+
+#if 0
+static int mga_dma_get_buffers( drm_device_t *dev, drm_dma_t *d )
 {
-	drm_device_dma_t *dma = dev->dma;
-	int		 i;
+	drm_buf_t *buf;
+	int i;
 
-	if (!dma) return;
-      	if(dev->dev_private == NULL) return;
-	if(dma->buflist == NULL) return;
+	for ( i = d->granted_count ; i < d->request_count ; i++ ) {
+		buf = mga_freelist_get( dev );
+		if ( !buf )
+			DRM_OS_RETURN( EAGAIN );
 
-	DRM_DEBUG("%s\n", __FUNCTION__);
-        mga_flush_queue(dev);
+		buf->pid = current->pid;
 
-	for (i = 0; i < dma->buf_count; i++) {
-	   	drm_buf_t *buf = dma->buflist[ i ];
-	   	drm_mga_buf_priv_t *buf_priv = buf->dev_private;
+		if ( DRM_OS_COPYTOUSR( &d->request_indices[i],
+				   &buf->idx, sizeof(buf->idx) ) )
+			DRM_OS_RETURN( EFAULT );
+		if ( DRM_OS_COPYTOUSR( &d->request_sizes[i],
+				   &buf->total, sizeof(buf->total) ) )
+			DRM_OS_RETURN( EFAULT );
 
-		/* Only buffers that need to get reclaimed ever 
-		 * get set to free 
-		 */
-		if (buf->pid == pid  && buf_priv) {
-			if(buf_priv->my_freelist->age == MGA_BUF_USED) 
-		     		buf_priv->my_freelist->age = MGA_BUF_FREE;
-		}
+		d->granted_count++;
 	}
+	return 0;
 }
+#endif /* 0 */
 
-int mga_lock(dev_t kdev, u_long cmd, caddr_t data,
-	     int flags, struct proc *p)
+int mga_dma_buffers( DRM_OS_IOCTL )
 {
-	drm_device_t	  *dev	  = kdev->si_drv1;
-	int		  ret	= 0;
-	drm_lock_t	  lock;
+	DRM_OS_DEVICE;
+	drm_device_dma_t *dma = dev->dma;
+	drm_mga_private_t *dev_priv = (drm_mga_private_t *)dev->dev_private;
+	drm_dma_t d;
+	drm_buf_t *buf;
+	int i;
+	int ret = 0;
 
-	DRM_DEBUG("%s\n", __FUNCTION__);
-	lock = *(drm_lock_t *) data;
+	LOCK_TEST_WITH_RETURN( dev );
 
-	if (lock.context == DRM_KERNEL_CONTEXT) {
-		DRM_ERROR("Process %d using kernel context %d\n",
-			  p->p_pid, lock.context);
-		return EINVAL;
-	}
-   
-   	DRM_DEBUG("%d (pid %d) requests lock (0x%08x), flags = 0x%08x\n",
-	       lock.context, p->p_pid, dev->lock.hw_lock->lock,
-	       lock.flags);
+	DRM_OS_KRNFROMUSR( d, (drm_dma_t *) data, sizeof(d) );
 
-	if (lock.context < 0) {
-		return EINVAL;
-	}
-   
-	/* Only one queue:
+	/* Please don't send us buffers.
 	 */
-
-	if (!ret) {
-		atomic_inc(&dev->lock.lock_queue);
-		for (;;) {
-			if (!dev->lock.hw_lock) {
-				/* Device has been unregistered */
-				ret = EINTR;
-				break;
-			}
-			if (drm_lock_take(&dev->lock.hw_lock->lock,
-					  lock.context)) {
-				dev->lock.pid	    = p->p_pid;
-				dev->lock.lock_time = ticks;
-				atomic_inc(&dev->total_locks);
-				break;	/* Got lock */
-			}
-			
-				/* Contention */
-			atomic_inc(&dev->total_sleeps);
-			ret = tsleep(&dev->lock.lock_queue, PZERO|PCATCH,
-					 "mgal2", 0);
-			if (ret)
-				break;
-		}
-		atomic_dec(&dev->lock.lock_queue);
+	if ( d.send_count != 0 ) {
+		DRM_ERROR( "Process %d trying to send %d buffers via drmDMA\n",
+			   DRM_OS_CURRENTPID, d.send_count );
+		DRM_OS_RETURN( EINVAL );
 	}
-	
-	if (!ret) {
-		if (lock.flags & _DRM_LOCK_QUIESCENT) {
-		   DRM_DEBUG("_DRM_LOCK_QUIESCENT\n");
-		   mga_flush_queue(dev);
-		   mga_dma_quiescent(dev);
-		}
+
+	/* We'll send you buffers.
+	 */
+	if ( d.request_count < 0 || d.request_count > dma->buf_count ) {
+		DRM_ERROR( "Process %d trying to get %d buffers (of %d max)\n",
+			   DRM_OS_CURRENTPID, d.request_count, dma->buf_count );
+		DRM_OS_RETURN( EINVAL );
 	}
-   
-	if (ret) DRM_DEBUG("%d %s\n", lock.context, ret ? "interrupted" : "has lock");
-	return ret;
-}
-		
-int mga_flush_ioctl(dev_t kdev, u_long cmd, caddr_t data,
-		    int flags, struct proc *p)
-{
-	drm_device_t	  *dev	  = kdev->si_drv1;
-	drm_lock_t	  lock;
-      	drm_mga_private_t *dev_priv = (drm_mga_private_t *)dev->dev_private;
-	int		  s;
 
-   	DRM_DEBUG("%s\n", __FUNCTION__);
-	lock = *(drm_lock_t *) data;
+	WRAP_TEST_WITH_RETURN( dev_priv );
 
-	if(!_DRM_LOCK_IS_HELD(dev->lock.hw_lock->lock)) {
-		DRM_ERROR("mga_flush_ioctl called without lock held\n");
-		return EINVAL;
-	}
+	d.granted_count = 0;
 
-   	if(lock.flags & _DRM_LOCK_FLUSH || lock.flags & _DRM_LOCK_FLUSH_ALL) {
-		drm_mga_prim_buf_t *temp_buf; 
-		temp_buf = dev_priv->current_prim;
-
-			s = splsofttq();
-		if(temp_buf && temp_buf->num_dwords) {
-			set_bit(MGA_BUF_FORCE_FIRE, &temp_buf->buffer_status);
-			mga_advance_primary(dev);
- 		}
-			mga_dma_schedule(dev, 1);
-			splx(s);
-	}
-   	if(lock.flags & _DRM_LOCK_QUIESCENT) {
-		mga_flush_queue(dev);
-		mga_dma_quiescent(dev);
+	if ( d.request_count ) {
+		for ( i = d.granted_count ; i < d.request_count ; i++ ) {
+			buf = mga_freelist_get( dev );
+			if ( !buf )
+				DRM_OS_RETURN( EAGAIN );
+
+			buf->pid = DRM_OS_CURRENTPID;
+
+			if ( DRM_OS_COPYTOUSR( &d.request_indices[i],
+					   &buf->idx, sizeof(buf->idx) ) )
+				DRM_OS_RETURN( EFAULT );
+			if ( DRM_OS_COPYTOUSR( &d.request_sizes[i],
+					   &buf->total, sizeof(buf->total) ) )
+				DRM_OS_RETURN( EFAULT );
+	
+			d.granted_count++;
+		}
+		ret = 0;
 	}
 
-    	return 0;
+	DRM_OS_KRNTOUSR( (drm_dma_t *) data, d, sizeof(d) );
+
+	return ret;
 }
diff --git a/bsd/mga/mga_drv.c b/bsd/mga/mga_drv.c
index 77d7c440..206a77dc 100644
--- a/bsd/mga/mga_drv.c
+++ b/bsd/mga/mga_drv.c
@@ -1,6 +1,6 @@
-/* mga_drv.c -- Matrox g200/g400 driver
+/* mga_drv.c -- Matrox G200/G400 driver -*- linux-c -*-
  * Created: Mon Dec 13 01:56:22 1999 by jhartmann@precisioninsight.com
- * 
+ *
  * Copyright 1999 Precision Insight, Inc., Cedar Park, Texas.
  * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
  * All Rights Reserved.
@@ -11,704 +11,88 @@
  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  * and/or sell copies of the Software, and to permit persons to whom the
  * Software is furnished to do so, subject to the following conditions:
- * 
+ *
  * The above copyright notice and this permission notice (including the next
  * paragraph) shall be included in all copies or substantial portions of the
  * Software.
- * 
+ *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+ * VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
- * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- *
- * Authors: Rickard E. (Rik) Faith <faith@valinux.com>
- *	    Jeff Hartmann <jhartmann@valinux.com>
- *
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
  *
+ * Authors:
+ *    Rickard E. (Rik) Faith <faith@valinux.com>
+ *    Gareth Hughes <gareth@valinux.com>
  */
 
-#include "drmP.h"
-#include "mga_drv.h"
 
+#include <sys/types.h>
+#include <sys/bus.h>
 #include <pci/pcivar.h>
+#include <opt_drm_linux.h>
 
-MODULE_DEPEND(mga, drm, 1, 1, 1);
-MODULE_DEPEND(mga, agp, 1, 1, 1);
-
-#define MGA_NAME	 "mga"
-#define MGA_DESC	 "Matrox g200/g400"
-#define MGA_DATE	 "20000928"
-#define MGA_MAJOR	 2
-#define MGA_MINOR	 0
-#define MGA_PATCHLEVEL	 0
-
-drm_ctx_t		      mga_res_ctx;
-
-static int mga_probe(device_t dev)
-{
-	const char *s = 0;
-
-	switch (pci_get_devid(dev)) {
-	case 0x0525102b:
-		s = "Matrox MGA G400 AGP graphics accelerator";
-		break;
-
-	case 0x0521102b:
-		s = "Matrox MGA G200 AGP graphics accelerator";
-		break;
-	}
-
-	if (s) {
-		device_set_desc(dev, s);
-		return 0;
-	}
-
-	return ENXIO;
-}
-
-static int mga_attach(device_t dev)
-{
-	return mga_init(dev);
-}
-
-static int mga_detach(device_t dev)
-{
-	mga_cleanup(dev);
-	return 0;
-}
-
-static device_method_t mga_methods[] = {
-	/* Device interface */
-	DEVMETHOD(device_probe,		mga_probe),
-	DEVMETHOD(device_attach,	mga_attach),
-	DEVMETHOD(device_detach,	mga_detach),
-
-	{ 0, 0 }
-};
-
-static driver_t mga_driver = {
-	"drm",
-	mga_methods,
-	sizeof(drm_device_t),
-};
-
-static devclass_t mga_devclass;
-#define MGA_SOFTC(unit) \
-	((drm_device_t *) devclass_get_softc(mga_devclass, unit))
-
-DRIVER_MODULE(if_mga, pci, mga_driver, mga_devclass, 0, 0);
-
-#define CDEV_MAJOR	145
-				/* mga_drv.c */
-static struct cdevsw mga_cdevsw = {
-	/* open */	mga_open,
-	/* close */	mga_close,
-	/* read */	drm_read,
-	/* write */	drm_write,
-	/* ioctl */	mga_ioctl,
-	/* poll */	drm_poll,
-	/* mmap */	drm_mmap,
-	/* strategy */	nostrategy,
-	/* name */	"mga",
-	/* maj */	CDEV_MAJOR,
-	/* dump */	nodump,
-	/* psize */	nopsize,
-	/* flags */	D_TTY | D_TRACKCLOSE,
-	/* bmaj */	-1
-};
-
-static drm_ioctl_desc_t	      mga_ioctls[] = {
-	[DRM_IOCTL_NR(DRM_IOCTL_VERSION)]     = { mga_version,	  0, 0 },
-	[DRM_IOCTL_NR(DRM_IOCTL_GET_UNIQUE)]  = { drm_getunique,  0, 0 },
-	[DRM_IOCTL_NR(DRM_IOCTL_GET_MAGIC)]   = { drm_getmagic,	  0, 0 },
-	[DRM_IOCTL_NR(DRM_IOCTL_IRQ_BUSID)]   = { drm_irq_busid,  0, 1 },
-
-	[DRM_IOCTL_NR(DRM_IOCTL_SET_UNIQUE)]  = { drm_setunique,  1, 1 },
-	[DRM_IOCTL_NR(DRM_IOCTL_BLOCK)]	      = { drm_block,	  1, 1 },
-	[DRM_IOCTL_NR(DRM_IOCTL_UNBLOCK)]     = { drm_unblock,	  1, 1 },
-	[DRM_IOCTL_NR(DRM_IOCTL_CONTROL)]     = { mga_control,	  1, 1 },
-	[DRM_IOCTL_NR(DRM_IOCTL_AUTH_MAGIC)]  = { drm_authmagic,  1, 1 },
-	[DRM_IOCTL_NR(DRM_IOCTL_ADD_MAP)]     = { drm_addmap,	  1, 1 },
-	[DRM_IOCTL_NR(DRM_IOCTL_ADD_BUFS)]    = { mga_addbufs,	  1, 1 },
-	[DRM_IOCTL_NR(DRM_IOCTL_MARK_BUFS)]   = { mga_markbufs,	  1, 1 },
-	[DRM_IOCTL_NR(DRM_IOCTL_INFO_BUFS)]   = { mga_infobufs,	  1, 0 },
-	[DRM_IOCTL_NR(DRM_IOCTL_MAP_BUFS)]    = { mga_mapbufs,	  1, 0 },
-	[DRM_IOCTL_NR(DRM_IOCTL_FREE_BUFS)]   = { mga_freebufs,	  1, 0 },
+#include "mga.h"
+#include "drmP.h"
+#include "mga_drv.h"
 
-	[DRM_IOCTL_NR(DRM_IOCTL_ADD_CTX)]     = { mga_addctx,	  1, 1 },
-	[DRM_IOCTL_NR(DRM_IOCTL_RM_CTX)]      = { mga_rmctx,	  1, 1 },
-	[DRM_IOCTL_NR(DRM_IOCTL_MOD_CTX)]     = { mga_modctx,	  1, 1 },
-	[DRM_IOCTL_NR(DRM_IOCTL_GET_CTX)]     = { mga_getctx,	  1, 0 },
-	[DRM_IOCTL_NR(DRM_IOCTL_SWITCH_CTX)]  = { mga_switchctx,  1, 1 },
-	[DRM_IOCTL_NR(DRM_IOCTL_NEW_CTX)]     = { mga_newctx,	  1, 1 },
-	[DRM_IOCTL_NR(DRM_IOCTL_RES_CTX)]     = { mga_resctx,	  1, 0 },
-	[DRM_IOCTL_NR(DRM_IOCTL_ADD_DRAW)]    = { drm_adddraw,	  1, 1 },
-	[DRM_IOCTL_NR(DRM_IOCTL_RM_DRAW)]     = { drm_rmdraw,	  1, 1 },
+#define DRIVER_AUTHOR		"Gareth Hughes, VA Linux Systems Inc."
 
-	[DRM_IOCTL_NR(DRM_IOCTL_DMA)]	      = { mga_dma,	  1, 0 },
+#define DRIVER_NAME		"mga"
+#define DRIVER_DESC		"Matrox G200/G400"
+#define DRIVER_DATE		"20010321"
 
-	[DRM_IOCTL_NR(DRM_IOCTL_LOCK)]	      = { mga_lock,	  1, 0 },
-	[DRM_IOCTL_NR(DRM_IOCTL_UNLOCK)]      = { mga_unlock,	  1, 0 },
-	[DRM_IOCTL_NR(DRM_IOCTL_FINISH)]      = { drm_finish,	  1, 0 },
+#define DRIVER_MAJOR		3
+#define DRIVER_MINOR		0
+#define DRIVER_PATCHLEVEL	2
 
-	[DRM_IOCTL_NR(DRM_IOCTL_AGP_ACQUIRE)] = { drm_agp_acquire, 1, 1 },
-	[DRM_IOCTL_NR(DRM_IOCTL_AGP_RELEASE)] = { drm_agp_release, 1, 1 },
-	[DRM_IOCTL_NR(DRM_IOCTL_AGP_ENABLE)]  = { drm_agp_enable,  1, 1 },
-	[DRM_IOCTL_NR(DRM_IOCTL_AGP_INFO)]    = { drm_agp_info,    1, 0 },
-	[DRM_IOCTL_NR(DRM_IOCTL_AGP_ALLOC)]   = { drm_agp_alloc,   1, 1 },
-	[DRM_IOCTL_NR(DRM_IOCTL_AGP_FREE)]    = { drm_agp_free,    1, 1 },
-	[DRM_IOCTL_NR(DRM_IOCTL_AGP_BIND)]    = { drm_agp_bind,    1, 1 },
-	[DRM_IOCTL_NR(DRM_IOCTL_AGP_UNBIND)]  = { drm_agp_unbind,  1, 1 },
-   	[DRM_IOCTL_NR(DRM_IOCTL_MGA_INIT)]    = { mga_dma_init,    1, 1 },
-   	[DRM_IOCTL_NR(DRM_IOCTL_MGA_SWAP)]    = { mga_swap_bufs,   1, 0 },
-   	[DRM_IOCTL_NR(DRM_IOCTL_MGA_CLEAR)]   = { mga_clear_bufs,  1, 0 },
-   	[DRM_IOCTL_NR(DRM_IOCTL_MGA_ILOAD)]   = { mga_iload,       1, 0 },
-   	[DRM_IOCTL_NR(DRM_IOCTL_MGA_VERTEX)]  = { mga_vertex,      1, 0 },
-   	[DRM_IOCTL_NR(DRM_IOCTL_MGA_FLUSH)]   = { mga_flush_ioctl, 1, 0 },
-   	[DRM_IOCTL_NR(DRM_IOCTL_MGA_INDICES)] = { mga_indices,     1, 0 },
+/* List acquired from http://www.yourvote.com/pci/pcihdr.h and xc/xc/programs/Xserver/hw/xfree86/common/xf86PciInfo.h
+ * Please report to anholt@teleport.com inaccuracies or if a chip you have works that is marked unsupported here.
+ */
+drm_chipinfo_t DRM(devicelist)[] = {
+	{0x102b, 0x0520, 0, "Matrox G200 (PCI)"},
+	{0x102b, 0x0521, 1, "Matrox G200 (AGP)"},
+	{0x102b, 0x0525, 1, "Matrox G400 (AGP)"},
+	{0, 0, 0, NULL}
 };
 
-#define MGA_IOCTL_COUNT DRM_ARRAY_SIZE(mga_ioctls)
-
-static int mga_setup(drm_device_t *dev)
-{
-	int i;
-	
-	device_busy(dev->device);
-
-	atomic_set(&dev->ioctl_count, 0);
-	atomic_set(&dev->vma_count, 0);
-	dev->buf_use	  = 0;
-	atomic_set(&dev->buf_alloc, 0);
-
-	drm_dma_setup(dev);
-
-	atomic_set(&dev->total_open, 0);
-	atomic_set(&dev->total_close, 0);
-	atomic_set(&dev->total_ioctl, 0);
-	atomic_set(&dev->total_irq, 0);
-	atomic_set(&dev->total_ctx, 0);
-	atomic_set(&dev->total_locks, 0);
-	atomic_set(&dev->total_unlocks, 0);
-	atomic_set(&dev->total_contends, 0);
-	atomic_set(&dev->total_sleeps, 0);
-
-	for (i = 0; i < DRM_HASH_SIZE; i++) {
-		dev->magiclist[i].head = NULL;
-		dev->magiclist[i].tail = NULL;
-	}
-	dev->maplist	    = NULL;
-	dev->map_count	    = 0;
-	dev->vmalist	    = NULL;
-	dev->lock.hw_lock   = NULL;
-	dev->lock.lock_queue = 0;
-	dev->queue_count    = 0;
-	dev->queue_reserved = 0;
-	dev->queue_slots    = 0;
-	dev->queuelist	    = NULL;
-	dev->irq	    = 0;
-	dev->context_flag   = 0;
-	dev->interrupt_flag = 0;
-	dev->dma_flag	    = 0;
-	dev->last_context   = 0;
-	dev->last_switch    = 0;
-	dev->last_checked   = 0;
-	callout_init(&dev->timer);
-	dev->context_wait   = 0;
-
-	timespecclear(&dev->ctx_start);
-	timespecclear(&dev->lck_start);
-	
-	dev->buf_rp	  = dev->buf;
-	dev->buf_wp	  = dev->buf;
-	dev->buf_end	  = dev->buf + DRM_BSZ;
-	bzero(&dev->buf_sel, sizeof dev->buf_sel);
-	dev->buf_sigio	  = NULL;
-	dev->buf_readers  = 0;
-	dev->buf_writers  = 0;
-	dev->buf_selecting = 0;
-			
-	DRM_DEBUG("\n");
-			
-	/* The kernel's context could be created here, but is now created
-	   in drm_dma_enqueue.	This is more resource-efficient for
-	   hardware that does not do DMA, but may mean that
-	   drm_select_queue fails between the time the interrupt is
-	   initialized and the time the queues are initialized. */
-			
-	return 0;
-}
-
-
-static int mga_takedown(drm_device_t *dev)
-{
-	int		  i;
-	drm_magic_entry_t *pt, *next;
-	drm_map_t	  *map;
-	drm_vma_entry_t	  *vma, *vma_next;
-
-	DRM_DEBUG("\n");
-
-	if (dev->irq) mga_irq_uninstall(dev);
-	
-	lockmgr(&dev->dev_lock, LK_EXCLUSIVE, 0, curproc);
-	callout_stop(&dev->timer);
-	
-	if (dev->devname) {
-		drm_free(dev->devname, strlen(dev->devname)+1, DRM_MEM_DRIVER);
-		dev->devname = NULL;
-	}
-	
-	if (dev->unique) {
-		drm_free(dev->unique, strlen(dev->unique)+1, DRM_MEM_DRIVER);
-		dev->unique = NULL;
-		dev->unique_len = 0;
-	}
-				/* Clear pid list */
-	for (i = 0; i < DRM_HASH_SIZE; i++) {
-		for (pt = dev->magiclist[i].head; pt; pt = next) {
-			next = pt->next;
-			drm_free(pt, sizeof(*pt), DRM_MEM_MAGIC);
-		}
-		dev->magiclist[i].head = dev->magiclist[i].tail = NULL;
-	}
-   				/* Clear AGP information */
-	if (dev->agp) {
-		drm_agp_mem_t *entry;
-		drm_agp_mem_t *nexte;
-		
-				/* Remove AGP resources, but leave dev->agp
-                                   intact until cleanup is called. */
-		for (entry = dev->agp->memory; entry; entry = nexte) {
-			nexte = entry->next;
-			if (entry->bound) drm_unbind_agp(entry->handle);
-			drm_free_agp(entry->handle, entry->pages);
-			drm_free(entry, sizeof(*entry), DRM_MEM_AGPLISTS);
-		}
-		dev->agp->memory = NULL;
-		
-		if (dev->agp->acquired)
-			agp_release(dev->agp->agpdev);
-		
-		dev->agp->acquired = 0;
-		dev->agp->enabled  = 0;
-	}
-				/* Clear vma list (only built for debugging) */
-	if (dev->vmalist) {
-		for (vma = dev->vmalist; vma; vma = vma_next) {
-			vma_next = vma->next;
-			drm_free(vma, sizeof(*vma), DRM_MEM_VMAS);
-		}
-		dev->vmalist = NULL;
-	}
-	
-				/* Clear map area and mtrr information */
-	if (dev->maplist) {
-		for (i = 0; i < dev->map_count; i++) {
-			map = dev->maplist[i];
-			switch (map->type) {
-			case _DRM_REGISTERS:
-			case _DRM_FRAME_BUFFER:
-#ifdef CONFIG_MTRR
-				if (map->mtrr >= 0) {
-					int retcode;
-					retcode = mtrr_del(map->mtrr,
-							   map->offset,
-							   map->size);
-					DRM_DEBUG("mtrr_del = %d\n", retcode);
-				}
-#endif
-				drm_ioremapfree(map->handle, map->size);
-				break;
-			case _DRM_SHM:
-				drm_free_pages((unsigned long)map->handle,
-					       drm_order(map->size)
-					       - PAGE_SHIFT,
-					       DRM_MEM_SAREA);
-				break;
-			case _DRM_AGP:
-				break;
-			}
-			drm_free(map, sizeof(*map), DRM_MEM_MAPS);
-		}
-		drm_free(dev->maplist,
-			 dev->map_count * sizeof(*dev->maplist),
-			 DRM_MEM_MAPS);
-		dev->maplist   = NULL;
-		dev->map_count = 0;
-	}
-	
-	if (dev->queuelist) {
-		for (i = 0; i < dev->queue_count; i++) {
-			drm_waitlist_destroy(&dev->queuelist[i]->waitlist);
-			if (dev->queuelist[i]) {
-				drm_free(dev->queuelist[i],
-					 sizeof(*dev->queuelist[0]),
-					 DRM_MEM_QUEUES);
-				dev->queuelist[i] = NULL;
-			}
-		}
-		drm_free(dev->queuelist,
-			 dev->queue_slots * sizeof(*dev->queuelist),
-			 DRM_MEM_QUEUES);
-		dev->queuelist	 = NULL;
-	}
-
-	drm_dma_takedown(dev);
-
-	dev->queue_count     = 0;
-	if (dev->lock.hw_lock) {
-		dev->lock.hw_lock    = NULL; /* SHM removed */
-		dev->lock.pid	     = 0;
-		wakeup(&dev->lock.lock_queue);
-	}
-	lockmgr(&dev->dev_lock, LK_RELEASE, 0, curproc);
-	
-	return 0;
-}
-
-/* mga_init is called via mga_attach at module load time, */
-
-int
-mga_init(device_t nbdev)
-{
-	int		      retcode;
-	drm_device_t	      *dev = device_get_softc(nbdev);
-
-	DRM_DEBUG("\n");
-
-	memset((void *)dev, 0, sizeof(*dev));
-	simple_lock_init(&dev->count_lock);
-	lockinit(&dev->dev_lock, PZERO, "drmlk", 0, 0);
-	
-#if 0
-	drm_parse_options(mga);
-#endif
-	dev->device = nbdev;
-	dev->devnode = make_dev(&mga_cdevsw,
-				device_get_unit(nbdev),
-				DRM_DEV_UID,
-				DRM_DEV_GID,
-				DRM_DEV_MODE,
-				MGA_NAME);
-	dev->name   = MGA_NAME;
-
-   	DRM_DEBUG("doing mem init\n");
-	drm_mem_init();
-	DRM_DEBUG("doing proc init\n");
-	drm_sysctl_init(dev);
-	TAILQ_INIT(&dev->files);
-	DRM_DEBUG("doing agp init\n");
-	dev->agp    = drm_agp_init();
-      	if(dev->agp == NULL) {
-	   	DRM_INFO("The mga drm module requires the agp module"
-			 " to function correctly\nPlease load the agp"
-			 " module before you load the mga module\n");
-	   	drm_sysctl_cleanup(dev);
-	   	mga_takedown(dev);
-	   	return ENOMEM;
-	}
-#if 0
-   	dev->agp->agp_mtrr = mtrr_add(dev->agp->agp_info.aper_base,
-				      dev->agp->agp_info.aper_size * 1024 * 1024,
-				      MTRR_TYPE_WRCOMB,
-				      1);
-#endif
-	DRM_DEBUG("doing ctxbitmap init\n");
-	if((retcode = drm_ctxbitmap_init(dev))) {
-		DRM_ERROR("Cannot allocate memory for context bitmap.\n");
-		drm_sysctl_cleanup(dev);
-		mga_takedown(dev);
-		return retcode;
-	}
-
-	DRM_INFO("Initialized %s %d.%d.%d %s on minor %d\n",
-		 MGA_NAME,
-		 MGA_MAJOR,
-		 MGA_MINOR,
-		 MGA_PATCHLEVEL,
-		 MGA_DATE,
-		 device_get_unit(nbdev));
-
-	return 0;
-}
-
-/* mga_cleanup is called via cleanup_module at module unload time. */
-
-void mga_cleanup(device_t nbdev)
-{
-	drm_device_t	      *dev = device_get_softc(nbdev);
-
-	DRM_DEBUG("\n");
-	
-	drm_sysctl_cleanup(dev);
-	destroy_dev(dev->devnode);
-
-	DRM_INFO("Module unloaded\n");
-	drm_ctxbitmap_cleanup(dev);
-	mga_dma_cleanup(dev);
-#if 0
-   	if(dev->agp && dev->agp->agp_mtrr) {
-	   	int retval;
-	   	retval = mtrr_del(dev->agp->agp_mtrr, 
-				  dev->agp->agp_info.aper_base,
-				  dev->agp->agp_info.aper_size * 1024*1024);
-	   	DRM_DEBUG("mtrr_del = %d\n", retval);
-	}
-#endif
-
-	mga_takedown(dev);
-	if (dev->agp) {
-		drm_free(dev->agp, sizeof(*dev->agp), DRM_MEM_AGPLISTS);
-		dev->agp = NULL;
-	}
-}
-
-int
-mga_version(dev_t kdev, u_long cmd, caddr_t data, int flags, struct proc *p)
-{
-	drm_version_t version;
-	int	      len;
-
-	version = *(drm_version_t *) data;
-
-#define DRM_COPY(name,value)				\
-	len = strlen(value);				\
-	if (len > name##_len) len = name##_len;		\
-	name##_len = strlen(value);			\
-	if (len && name) {				\
-		int error = copyout(value, name, len);	\
-		if (error) return error;		\
-	}
-
-	version.version_major	   = MGA_MAJOR;
-	version.version_minor	   = MGA_MINOR;
-	version.version_patchlevel = MGA_PATCHLEVEL;
-
-	DRM_COPY(version.name, MGA_NAME);
-	DRM_COPY(version.date, MGA_DATE);
-	DRM_COPY(version.desc, MGA_DESC);
-
-	*(drm_version_t *) data = version;
-	return 0;
-}
-
-int
-mga_open(dev_t kdev, int flags, int fmt, struct proc *p)
-{
-	drm_device_t  *dev    = MGA_SOFTC(minor(kdev));
-	int	      retcode = 0;
-	
-	DRM_DEBUG("open_count = %d\n", dev->open_count);
-
-	device_busy(dev->device);
-	if (!(retcode = drm_open_helper(kdev, flags, fmt, p, dev))) {
-		atomic_inc(&dev->total_open);
-		simple_lock(&dev->count_lock);
-		if (!dev->open_count++) {
-			simple_unlock(&dev->count_lock);
-			retcode = mga_setup(dev);
-		}
-		simple_unlock(&dev->count_lock);
-	}
-	device_unbusy(dev->device);
-
-	return retcode;
-}
-
-int
-mga_close(dev_t kdev, int flags, int fmt, struct proc *p)
-{
-	drm_device_t  *dev    = kdev->si_drv1;
-	drm_file_t    *priv;
-	int	      retcode = 0;
-
-	DRM_DEBUG("pid = %d, open_count = %d\n",
-		  p->p_pid, dev->open_count);
-
-	priv = drm_find_file_by_proc(dev, p);
-	if (!priv) {
-		DRM_DEBUG("can't find authenticator\n");
-		return EINVAL;
-	}
-
-	if (dev->lock.hw_lock && _DRM_LOCK_IS_HELD(dev->lock.hw_lock->lock)
-	    && dev->lock.pid == p->p_pid) {
-	      	mga_reclaim_buffers(dev, priv->pid);
-		DRM_ERROR("Process %d dead, freeing lock for context %d\n",
-			  p->p_pid,
-			  _DRM_LOCKING_CONTEXT(dev->lock.hw_lock->lock));
-		drm_lock_free(dev,
-			      &dev->lock.hw_lock->lock,
-			      _DRM_LOCKING_CONTEXT(dev->lock.hw_lock->lock));
-		
-				/* FIXME: may require heavy-handed reset of
-                                   hardware at this point, possibly
-                                   processed via a callback to the X
-                                   server. */
-	} else if (dev->lock.hw_lock) {
-	   	/* The lock is required to reclaim buffers */
-		for (;;) {
-			if (!dev->lock.hw_lock) {
-				/* Device has been unregistered */
-				retcode = EINTR;
-				break;
-			}
-			if (drm_lock_take(&dev->lock.hw_lock->lock,
-					  DRM_KERNEL_CONTEXT)) {
-				dev->lock.pid	    = p->p_pid;
-				dev->lock.lock_time = ticks;
-				atomic_inc(&dev->total_locks);
-				break;	/* Got lock */
-			}			
-				/* Contention */
-			atomic_inc(&dev->total_sleeps);
-			retcode = tsleep(&dev->lock.lock_queue,
-					 PZERO|PCATCH,
-					 "drmlk2",
-					 0);
-			if (retcode)
-				break;
-		}
-	   	if(!retcode) {
-		   	mga_reclaim_buffers(dev, priv->pid);
-		   	drm_lock_free(dev, &dev->lock.hw_lock->lock,
-				      DRM_KERNEL_CONTEXT);
-		}
-	}
-	funsetown(dev->buf_sigio);
-
-	lockmgr(&dev->dev_lock, LK_EXCLUSIVE, 0, p);
-	priv = drm_find_file_by_proc(dev, p);
-	if (priv) {
-		priv->refs--;
-		if (!priv->refs) {
-			TAILQ_REMOVE(&dev->files, priv, link);
-			drm_free(priv, sizeof(*priv), DRM_MEM_FILES);
-		}
-	}
-	lockmgr(&dev->dev_lock, LK_RELEASE, 0, p);
-
-   	atomic_inc(&dev->total_close);
-   	simple_lock(&dev->count_lock);
-   	if (!--dev->open_count) {
-	   	if (atomic_read(&dev->ioctl_count) || dev->blocked) {
-		   	DRM_ERROR("Device busy: %d %d\n",
-				  atomic_read(&dev->ioctl_count),
-				  dev->blocked);
-		   	simple_unlock(&dev->count_lock);
-		   	return EBUSY;
-		}
-	   	simple_unlock(&dev->count_lock);
-		device_unbusy(dev->device);
-	   	return mga_takedown(dev);
-	}
-   	simple_unlock(&dev->count_lock);
-	return retcode;
-}
-
-
-/* mga_ioctl is called whenever a process performs an ioctl on /dev/drm. */
-
-int
-mga_ioctl(dev_t kdev, u_long cmd, caddr_t data, int flags, struct proc *p)
-{
-	int		 nr	 = DRM_IOCTL_NR(cmd);
-	drm_device_t	 *dev	 = kdev->si_drv1;
-	drm_file_t	 *priv;
-	int		 retcode = 0;
-	drm_ioctl_desc_t *ioctl;
-	d_ioctl_t	 *func;
-
-	DRM_DEBUG("dev=%p\n", dev);
-	priv = drm_find_file_by_proc(dev, p);
-	if (!priv) {
-		DRM_DEBUG("can't find authenticator\n");
-		return EINVAL;
-	}
-
-	atomic_inc(&dev->ioctl_count);
-	atomic_inc(&dev->total_ioctl);
-	++priv->ioctl_count;
-	
-	DRM_DEBUG("pid = %d, cmd = 0x%02lx, nr = 0x%02x, auth = %d\n",
-		  p->p_pid, cmd, nr, priv->authenticated);
-
-	switch (cmd) {
-	case FIONBIO:
-		atomic_dec(&dev->ioctl_count);
-		return 0;
-
-	case FIOASYNC:
-		atomic_dec(&dev->ioctl_count);
-		dev->flags |= FASYNC;
-		return 0;
-
-	case FIOSETOWN:
-		atomic_dec(&dev->ioctl_count);
-		return fsetown(*(int *)data, &dev->buf_sigio);
-
-	case FIOGETOWN:
-		atomic_dec(&dev->ioctl_count);
-		*(int *) data = fgetown(dev->buf_sigio);
-		return 0;
-	}
-
-	if (nr >= MGA_IOCTL_COUNT) {
-		retcode = EINVAL;
-	} else {
-		ioctl	  = &mga_ioctls[nr];
-		func	  = ioctl->func;
-
-		if (!func) {
-			DRM_DEBUG("no function\n");
-			retcode = EINVAL;
-		} else if ((ioctl->root_only && suser(p))
-			    || (ioctl->auth_needed && !priv->authenticated)) {
-			retcode = EACCES;
-		} else {
-			retcode = (func)(kdev, cmd, data, flags, p);
-		}
-	}
-	
-	atomic_dec(&dev->ioctl_count);
-	return retcode;
-}
-
-int
-mga_unlock(dev_t kdev, u_long cmd, caddr_t data, int flags, struct proc *p)
-{
-        drm_device_t      *dev    = kdev->si_drv1;
-	drm_lock_t	  lock;
-	int		  s;
-
-	lock = *(drm_lock_t *) data;
-	
-	if (lock.context == DRM_KERNEL_CONTEXT) {
-		DRM_ERROR("Process %d using kernel context %d\n",
-			  p->p_pid, lock.context);
-		return EINVAL;
-	}
-
-	DRM_DEBUG("%d frees lock (%d holds)\n",
-		  lock.context,
-		  _DRM_LOCKING_CONTEXT(dev->lock.hw_lock->lock));
-	atomic_inc(&dev->total_unlocks);
-	if (_DRM_LOCK_IS_CONT(dev->lock.hw_lock->lock))
-		atomic_inc(&dev->total_contends);
-	drm_lock_transfer(dev, &dev->lock.hw_lock->lock, DRM_KERNEL_CONTEXT);
-
-	s = splsofttq();
-	mga_dma_schedule(dev, 1);
-	splx(s);
-
-	if (drm_lock_free(dev, &dev->lock.hw_lock->lock,
-			  DRM_KERNEL_CONTEXT)) {
-	   DRM_ERROR("\n");
-	}
-
-	return 0;
-}
+#define DRIVER_IOCTLS							   \
+	[DRM_IOCTL_NR(DRM_IOCTL_DMA)]	      = { mga_dma_buffers, 1, 0 }, \
+	[DRM_IOCTL_NR(DRM_IOCTL_MGA_INIT)]    = { mga_dma_init,    1, 1 }, \
+	[DRM_IOCTL_NR(DRM_IOCTL_MGA_FLUSH)]   = { mga_dma_flush,   1, 0 }, \
+	[DRM_IOCTL_NR(DRM_IOCTL_MGA_RESET)]   = { mga_dma_reset,   1, 0 }, \
+	[DRM_IOCTL_NR(DRM_IOCTL_MGA_SWAP)]    = { mga_dma_swap,    1, 0 }, \
+	[DRM_IOCTL_NR(DRM_IOCTL_MGA_CLEAR)]   = { mga_dma_clear,   1, 0 }, \
+	[DRM_IOCTL_NR(DRM_IOCTL_MGA_VERTEX)]  = { mga_dma_vertex,  1, 0 }, \
+	[DRM_IOCTL_NR(DRM_IOCTL_MGA_INDICES)] = { mga_dma_indices, 1, 0 }, \
+	[DRM_IOCTL_NR(DRM_IOCTL_MGA_ILOAD)]   = { mga_dma_iload,   1, 0 }, \
+	[DRM_IOCTL_NR(DRM_IOCTL_MGA_BLIT)]    = { mga_dma_blit,    1, 0 },
+
+
+#define __HAVE_COUNTERS         3
+#define __HAVE_COUNTER6         _DRM_STAT_IRQ
+#define __HAVE_COUNTER7         _DRM_STAT_PRIMARY
+#define __HAVE_COUNTER8         _DRM_STAT_SECONDARY
+
+
+#include "drm_agpsupport.h"
+#include "drm_auth.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_lock.h"
+#include "drm_memory.h"
+#include "drm_vm.h"
+#include "drm_sysctl.h"
+
+DRIVER_MODULE(mga, pci, mga_driver, mga_devclass, 0, 0);
diff --git a/bsd/mga/mga_drv.h b/bsd/mga/mga_drv.h
index 9e51a20d..be207e30 100644
--- a/bsd/mga/mga_drv.h
+++ b/bsd/mga/mga_drv.h
@@ -1,4 +1,4 @@
-/* mga_drv.h -- Private header for the Matrox g200/g400 driver
+/* mga_drv.h -- Private header for the Matrox G200/G400 driver -*- linux-c -*-
  * Created: Mon Dec 13 01:50:01 1999 by jhartmann@precisioninsight.com
  *
  * Copyright 1999 Precision Insight, Inc., Cedar Park, Texas.
@@ -11,163 +11,157 @@
  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  * and/or sell copies of the Software, and to permit persons to whom the
  * Software is furnished to do so, subject to the following conditions:
- * 
+ *
  * The above copyright notice and this permission notice (including the next
  * paragraph) shall be included in all copies or substantial portions of the
  * Software.
- * 
+ *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+ * VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
- * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- *
- * Authors: Rickard E. (Rik) Faith <faith@valinux.com>
- * 	    Jeff Hartmann <jhartmann@valinux.com>
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
  *
+ * Authors:
+ *    Gareth Hughes <gareth@valinux.com>
  */
 
-#ifndef _MGA_DRV_H_
-#define _MGA_DRV_H_
+#ifndef __MGA_DRV_H__
+#define __MGA_DRV_H__
 
-#define MGA_BUF_IN_USE         0
-#define MGA_BUF_SWAP_PENDING   1
-#define MGA_BUF_FORCE_FIRE     2
-#define MGA_BUF_NEEDS_OVERFLOW 3
+#ifndef u8
+#define u8  u_int8_t
+#define u16 u_int16_t
+#define u32 u_int32_t
+#endif
 
-typedef struct {
-	u_int32_t buffer_status;
-   	int num_dwords;
-   	int max_dwords;
-   	u_int32_t *current_dma_ptr;
-   	u_int32_t *head;
-   	u_int32_t phys_head;
-	unsigned int prim_age;
-   	int sec_used;
-   	int idx;
-} drm_mga_prim_buf_t;
-
-typedef struct _drm_mga_freelist {
-   	__volatile__ unsigned int age;
+typedef struct drm_mga_primary_buffer {
+	u8 *start;
+	u8 *end;
+	int size;
+
+	u32 tail;
+	int space;
+	volatile long wrapped;
+
+	volatile u32 *status;
+
+	u32 last_flush;
+	u32 last_wrap;
+
+	u32 high_mark;
+
+	spinlock_t list_lock;
+} drm_mga_primary_buffer_t;
+
+typedef struct drm_mga_freelist {
+   	struct drm_mga_freelist *next;
+   	struct drm_mga_freelist *prev;
+	drm_mga_age_t age;
    	drm_buf_t *buf;
-   	struct _drm_mga_freelist *next;
-   	struct _drm_mga_freelist *prev;
 } drm_mga_freelist_t;
 
-#define MGA_IN_DISPATCH   0
-#define MGA_IN_FLUSH      1
-#define MGA_IN_WAIT       2
-#define MGA_IN_GETBUF	  3
-
-typedef struct _drm_mga_private {
-   	u_int32_t dispatch_status;
-	unsigned int next_prim_age;
-	__volatile__ unsigned int last_prim_age;
-   	int reserved_map_idx;
-   	int buffer_map_idx;
-   	drm_mga_sarea_t *sarea_priv;
-   	int primary_size;
-   	int warp_ucode_size;
-   	int chipset;
-   	unsigned int frontOffset;
-   	unsigned int backOffset;
-   	unsigned int depthOffset;
-   	unsigned int textureOffset;
-   	unsigned int textureSize;
-   	int cpp;
-   	unsigned int stride;
-   	int sgram;
-	int use_agp;
-   	drm_mga_warp_index_t WarpIndex[MGA_MAX_G400_PIPES];
-	unsigned int WarpPipe;
-	unsigned int vertexsize;
-   	atomic_t pending_bufs;
-   	void *status_page;
-   	unsigned long real_status_page;
-   	u_int8_t *ioremap;
-   	drm_mga_prim_buf_t **prim_bufs;
-   	drm_mga_prim_buf_t *next_prim;
-   	drm_mga_prim_buf_t *last_prim;
-   	drm_mga_prim_buf_t *current_prim;
-   	int current_prim_idx;
+typedef struct {
+   	drm_mga_freelist_t *list_entry;
+	int discard;
+	int dispatched;
+} drm_mga_buf_priv_t;
+
+typedef struct drm_mga_private {
+	drm_mga_primary_buffer_t prim;
+	drm_mga_sarea_t *sarea_priv;
+
    	drm_mga_freelist_t *head;
    	drm_mga_freelist_t *tail;
-	int flush_queue;		/* Processes waiting until flush    */
-      	int wait_queue;			/* Processes waiting until interrupt */
-	int buf_queue;			/* Processes waiting for a free buf */
-	/* Some validated register values:
-	 */	
-	u_int32_t mAccess;
-} drm_mga_private_t;
 
-				/* mga_drv.c */
-extern int  mga_init(device_t);
-extern void mga_cleanup(device_t);
-extern d_ioctl_t mga_version;
-extern d_open_t mga_open;
-extern d_close_t mga_close;
-extern d_ioctl_t mga_ioctl;
-extern d_ioctl_t mga_unlock;
+	unsigned int warp_pipe;
+	unsigned long warp_pipe_phys[MGA_MAX_WARP_PIPES];
+
+	int chipset;
+	int usec_timeout;
+
+	u32 clear_cmd;
+	u32 maccess;
+
+	unsigned int fb_cpp;
+	unsigned int front_offset;
+	unsigned int front_pitch;
+	unsigned int back_offset;
+	unsigned int back_pitch;
+
+	unsigned int depth_cpp;
+	unsigned int depth_offset;
+	unsigned int depth_pitch;
+
+	unsigned int texture_offset;
+	unsigned int texture_size;
+
+	drm_map_t *sarea;
+	drm_map_t *fb;
+	drm_map_t *mmio;
+	drm_map_t *status;
+	drm_map_t *warp;
+	drm_map_t *primary;
+	drm_map_t *buffers;
+	drm_map_t *agp_textures;
+} drm_mga_private_t;
 
 				/* mga_dma.c */
-extern int  mga_dma_schedule(drm_device_t *dev, int locked);
-extern int  mga_irq_install(drm_device_t *dev, int irq);
-extern int  mga_irq_uninstall(drm_device_t *dev);
-extern d_ioctl_t mga_dma;
-extern d_ioctl_t mga_control;
-extern d_ioctl_t mga_lock;
-
-/* mga_dma_init does init and release */
-extern int mga_dma_cleanup(drm_device_t *dev);
-extern d_ioctl_t mga_dma_init;
-extern d_ioctl_t mga_flush_ioctl;
-extern void mga_flush_write_combine(void);
-extern unsigned int mga_create_sync_tag(drm_device_t *dev);
-extern drm_buf_t *mga_freelist_get(drm_device_t *dev);
-extern int mga_freelist_put(drm_device_t *dev, drm_buf_t *buf);
-extern int mga_advance_primary(drm_device_t *dev);
-extern void mga_reclaim_buffers(drm_device_t *dev, pid_t pid);
-
-				/* mga_bufs.c */
-extern d_ioctl_t mga_addbufs;
-extern d_ioctl_t mga_infobufs;
-extern d_ioctl_t mga_markbufs;
-extern d_ioctl_t mga_freebufs;
-extern d_ioctl_t mga_mapbufs;
-extern d_ioctl_t mga_addmap;
-				/* mga_state.c */
-extern d_ioctl_t mga_clear_bufs;
-extern d_ioctl_t mga_swap_bufs;
-extern d_ioctl_t mga_iload;
-extern d_ioctl_t mga_vertex;
-extern d_ioctl_t mga_indices;
-				/* mga_context.c */
-extern d_ioctl_t mga_resctx;
-extern d_ioctl_t mga_addctx;
-extern d_ioctl_t mga_modctx;
-extern d_ioctl_t mga_getctx;
-extern d_ioctl_t mga_switchctx;
-extern d_ioctl_t mga_newctx;
-extern d_ioctl_t mga_rmctx;
-
-extern int  mga_context_switch(drm_device_t *dev, int old, int new);
-extern int  mga_context_switch_complete(drm_device_t *dev, int new);
-
-
-typedef enum {
-	TT_GENERAL,
-	TT_BLIT,
-	TT_VECTOR,
-	TT_VERTEX
-} transferType_t;
+extern int mga_dma_init( DRM_OS_IOCTL );
+extern int mga_dma_flush( DRM_OS_IOCTL );
+extern int mga_dma_reset( DRM_OS_IOCTL );
+extern int mga_dma_buffers( DRM_OS_IOCTL );
 
-typedef struct {
-   	drm_mga_freelist_t *my_freelist;
-	int discard;
-	int dispatched;
-} drm_mga_buf_priv_t;
+extern int mga_do_wait_for_idle( drm_mga_private_t *dev_priv );
+extern int mga_do_dma_idle( drm_mga_private_t *dev_priv );
+extern int mga_do_dma_reset( drm_mga_private_t *dev_priv );
+extern int mga_do_engine_reset( drm_mga_private_t *dev_priv );
+extern int mga_do_cleanup_dma( drm_device_t *dev );
+
+extern void mga_do_dma_flush( drm_mga_private_t *dev_priv );
+extern void mga_do_dma_wrap_start( drm_mga_private_t *dev_priv );
+extern void mga_do_dma_wrap_end( drm_mga_private_t *dev_priv );
+
+extern int mga_freelist_put( drm_device_t *dev, drm_buf_t *buf );
+
+				/* mga_state.c */
+extern int  mga_dma_clear( DRM_OS_IOCTL );
+extern int  mga_dma_swap( DRM_OS_IOCTL );
+extern int  mga_dma_vertex( DRM_OS_IOCTL );
+extern int  mga_dma_indices( DRM_OS_IOCTL );
+extern int  mga_dma_iload( DRM_OS_IOCTL );
+extern int  mga_dma_blit( DRM_OS_IOCTL );
+
+				/* mga_warp.c */
+extern int mga_warp_install_microcode( drm_mga_private_t *dev_priv );
+extern int mga_warp_init( drm_mga_private_t *dev_priv );
+
+#define mga_flush_write_combine()	DRM_OS_READMEMORYBARRIER
+
+#define MGA_BASE( reg )		((unsigned long)(dev_priv->mmio->handle))
+#define MGA_ADDR( reg )		(MGA_BASE(reg) + reg)
+
+#define MGA_DEREF( reg )	*(volatile u32 *)MGA_ADDR( reg )
+#define MGA_DEREF8( reg )	*(volatile u8 *)MGA_ADDR( reg )
+
+#ifdef __alpha__
+#define MGA_READ( reg )		(_MGA_READ((u32 *)MGA_ADDR(reg)))
+#define MGA_WRITE( reg, val )	do { wmb(); MGA_DEREF( reg ) = val; } while (0)
+#define MGA_WRITE8( reg, val )  do { wmb(); MGA_DEREF8( reg ) = val; } while (0)
+
+static inline u32 _MGA_READ(u32 *addr)
+{
+	mb();
+	return *(volatile u32 *)addr;
+}
+
+#else
+#define MGA_READ( reg )		MGA_DEREF( reg )
+#define MGA_WRITE( reg, val )	do { MGA_DEREF( reg ) = val; } while (0)
+#define MGA_WRITE8( reg, val )  do { MGA_DEREF8( reg ) = val; } while (0)
+#endif
 
 #define DWGREG0 	0x1c00
 #define DWGREG0_END 	0x1dff
@@ -175,322 +169,470 @@ typedef struct {
 #define DWGREG1_END	0x2dff
 
 #define ISREG0(r)	(r >= DWGREG0 && r <= DWGREG0_END)
-#define ADRINDEX0(r)	(u_int8_t)((r - DWGREG0) >> 2)
-#define ADRINDEX1(r)	(u_int8_t)(((r - DWGREG1) >> 2) | 0x80)
-#define ADRINDEX(r)	(ISREG0(r) ? ADRINDEX0(r) : ADRINDEX1(r)) 
-
-#define MGA_VERBOSE 0
-#define MGA_NUM_PRIM_BUFS 	8
-
-#define PRIMLOCALS	u_int8_t tempIndex[4]; u_int32_t *dma_ptr; u_int32_t phys_head; \
-			int outcount, num_dwords
-
-#define PRIM_OVERFLOW(dev, dev_priv, length) do {			\
-	drm_mga_prim_buf_t *tmp_buf =					\
- 		dev_priv->prim_bufs[dev_priv->current_prim_idx];	\
-	if( test_bit(MGA_BUF_NEEDS_OVERFLOW,				\
-		  &tmp_buf->buffer_status)) {				\
- 		mga_advance_primary(dev);				\
- 		mga_dma_schedule(dev, 1);				\
-		tmp_buf = dev_priv->prim_bufs[dev_priv->current_prim_idx]; \
- 	} else if( tmp_buf->max_dwords - tmp_buf->num_dwords < length ||\
- 	    tmp_buf->sec_used > MGA_DMA_BUF_NR/2) {			\
-		set_bit(MGA_BUF_FORCE_FIRE, &tmp_buf->buffer_status);	\
- 		mga_advance_primary(dev);				\
- 		mga_dma_schedule(dev, 1);				\
-		tmp_buf = dev_priv->prim_bufs[dev_priv->current_prim_idx]; \
+#define DMAREG0(r)	(u8)((r - DWGREG0) >> 2)
+#define DMAREG1(r)	(u8)(((r - DWGREG1) >> 2) | 0x80)
+#define DMAREG(r)	(ISREG0(r) ? DMAREG0(r) : DMAREG1(r))
+
+
+
+/* ================================================================
+ * Helper macross...
+ */
+
+#define MGA_EMIT_STATE( dev_priv, dirty )				\
+do {									\
+	if ( (dirty) & ~MGA_UPLOAD_CLIPRECTS ) {			\
+		if ( dev_priv->chipset == MGA_CARD_TYPE_G400 ) {	\
+			mga_g400_emit_state( dev_priv );		\
+		} else {						\
+			mga_g200_emit_state( dev_priv );		\
+		}							\
 	}								\
-	if(MGA_VERBOSE) 						\
-		DRM_DEBUG("PRIMGETPTR in %s\n", __FUNCTION__);		\
-	dma_ptr = tmp_buf->current_dma_ptr;				\
-	num_dwords = tmp_buf->num_dwords;				\
-	phys_head = tmp_buf->phys_head;					\
-	outcount = 0;							\
-} while(0)
-
-#define PRIMGETPTR(dev_priv) do {					\
-	drm_mga_prim_buf_t *tmp_buf =					\
-		dev_priv->prim_bufs[dev_priv->current_prim_idx];	\
-	if(MGA_VERBOSE)							\
-		DRM_DEBUG("PRIMGETPTR in %s\n", __FUNCTION__);		\
-	dma_ptr = tmp_buf->current_dma_ptr;				\
-	num_dwords = tmp_buf->num_dwords;				\
-	phys_head = tmp_buf->phys_head;					\
-	outcount = 0;							\
-} while(0)
-
-#define PRIMPTR(prim_buf) do {					\
-	if(MGA_VERBOSE)						\
-		DRM_DEBUG("PRIMPTR in %s\n", __FUNCTION__);	\
-	dma_ptr = prim_buf->current_dma_ptr;			\
-	num_dwords = prim_buf->num_dwords;			\
-	phys_head = prim_buf->phys_head;			\
-	outcount = 0;						\
-} while(0)
-
-#define PRIMFINISH(prim_buf) do {				\
-	if (MGA_VERBOSE) {					\
-		DRM_DEBUG( "PRIMFINISH in %s\n", __FUNCTION__);	\
-                if (outcount & 3)				\
-                      DRM_DEBUG(" --- truncation\n");	        \
-        }							\
-	prim_buf->num_dwords = num_dwords;			\
-	prim_buf->current_dma_ptr = dma_ptr;			\
-} while(0)
-
-#define PRIMADVANCE(dev_priv)	do {				\
-drm_mga_prim_buf_t *tmp_buf = 					\
-	dev_priv->prim_bufs[dev_priv->current_prim_idx];	\
-	if (MGA_VERBOSE) {					\
-		DRM_DEBUG("PRIMADVANCE in %s\n", __FUNCTION__);	\
-                if (outcount & 3)				\
-                      DRM_DEBUG(" --- truncation\n");	\
-        }							\
-	tmp_buf->num_dwords = num_dwords;      			\
-	tmp_buf->current_dma_ptr = dma_ptr;    			\
 } while (0)
 
-#define PRIMUPDATE(dev_priv)	do {					\
-	drm_mga_prim_buf_t *tmp_buf =					\
-		dev_priv->prim_bufs[dev_priv->current_prim_idx];	\
-	tmp_buf->sec_used++;						\
+#define LOCK_TEST_WITH_RETURN( dev )					\
+do {									\
+	if ( !_DRM_LOCK_IS_HELD( dev->lock.hw_lock->lock ) ||		\
+	     dev->lock.pid != DRM_OS_CURRENTPID ) {			\
+		DRM_ERROR( "%s called without lock held\n",		\
+			   __FUNCTION__ );				\
+		DRM_OS_RETURN( EINVAL );				\
+	}								\
 } while (0)
 
-#define AGEBUF(dev_priv, buf_priv)	do {				\
-	drm_mga_prim_buf_t *tmp_buf =					\
-		dev_priv->prim_bufs[dev_priv->current_prim_idx];	\
-	buf_priv->my_freelist->age = tmp_buf->prim_age;			\
+#define WRAP_TEST_WITH_RETURN( dev_priv )				\
+do {									\
+	if ( test_bit( 0, &dev_priv->prim.wrapped ) ) {			\
+		if ( mga_is_idle( dev_priv ) ) {			\
+			mga_do_dma_wrap_end( dev_priv );		\
+		} else if ( dev_priv->prim.space <			\
+			    dev_priv->prim.high_mark ) {		\
+			if ( MGA_DMA_DEBUG )				\
+				DRM_INFO( __FUNCTION__": wrap...\n" );	\
+			DRM_OS_RETURN( EBUSY);				\
+		}							\
+	}								\
 } while (0)
 
+#define WRAP_WAIT_WITH_RETURN( dev_priv )				\
+do {									\
+	if ( test_bit( 0, &dev_priv->prim.wrapped ) ) {			\
+		if ( mga_do_wait_for_idle( dev_priv ) ) {		\
+			if ( MGA_DMA_DEBUG )				\
+				DRM_INFO( __FUNCTION__": wrap...\n" );	\
+			DRM_OS_RETURN( EBUSY);			\
+		}							\
+		mga_do_dma_wrap_end( dev_priv );			\
+	}								\
+} while (0)
+
+
+/* ================================================================
+ * Primary DMA command stream
+ */
+
+#define MGA_VERBOSE	0
 
-#define PRIMOUTREG(reg, val) do {					\
-	tempIndex[outcount]=ADRINDEX(reg);				\
-	dma_ptr[1+outcount] = val;					\
-	if (MGA_VERBOSE)						\
-		DRM_DEBUG("   PRIMOUT %d: 0x%x -- 0x%x\n",		\
-		       num_dwords + 1 + outcount, ADRINDEX(reg), val);	\
-	if( ++outcount == 4) {						\
-		outcount = 0;						\
-		dma_ptr[0] = *(u_int32_t *)tempIndex;			\
-		dma_ptr+=5;						\
-		num_dwords += 5;					\
+#define DMA_LOCALS	unsigned int write; volatile u8 *prim;
+
+#define DMA_BLOCK_SIZE	(5 * sizeof(u32))
+
+#define BEGIN_DMA( n )							\
+do {									\
+	if ( MGA_VERBOSE ) {						\
+		DRM_INFO( "BEGIN_DMA( %d ) in %s\n",			\
+			  (n), __FUNCTION__ );				\
+		DRM_INFO( "   space=0x%x req=0x%x\n",			\
+			  dev_priv->prim.space, (n) * DMA_BLOCK_SIZE );	\
 	}								\
-}while (0)
+	prim = dev_priv->prim.start;					\
+	write = dev_priv->prim.tail;					\
+} while (0)
+
+#define BEGIN_DMA_WRAP()						\
+do {									\
+	if ( MGA_VERBOSE ) {						\
+		DRM_INFO( "BEGIN_DMA() in %s\n", __FUNCTION__ );	\
+		DRM_INFO( "   space=0x%x\n", dev_priv->prim.space );	\
+	}								\
+	prim = dev_priv->prim.start;					\
+	write = dev_priv->prim.tail;					\
+} while (0)
+
+#define ADVANCE_DMA()							\
+do {									\
+	dev_priv->prim.tail = write;					\
+	if ( MGA_VERBOSE ) {						\
+		DRM_INFO( "ADVANCE_DMA() tail=0x%05x sp=0x%x\n",	\
+			  write, dev_priv->prim.space );		\
+	}								\
+} while (0)
+
+#define FLUSH_DMA()							\
+do {									\
+	if ( 0 ) {							\
+		DRM_INFO( __FUNCTION__ ":\n" );				\
+		DRM_INFO( "   tail=0x%06x head=0x%06lx\n",		\
+			  dev_priv->prim.tail,				\
+			  MGA_READ( MGA_PRIMADDRESS ) -			\
+			  dev_priv->primary->offset );			\
+	}								\
+	if ( !test_bit( 0, &dev_priv->prim.wrapped ) ) {		\
+		if ( dev_priv->prim.space <				\
+		     dev_priv->prim.high_mark ) {			\
+			mga_do_dma_wrap_start( dev_priv );		\
+		} else {						\
+			mga_do_dma_flush( dev_priv );			\
+		}							\
+	}								\
+} while (0)
+
+/* Never use this, always use DMA_BLOCK(...) for primary DMA output.
+ */
+#define DMA_WRITE( offset, val )					\
+do {									\
+	if ( MGA_VERBOSE ) {						\
+		DRM_INFO( "   DMA_WRITE( 0x%08x ) at 0x%04x\n",		\
+			  (u32)(val), write + (offset) * sizeof(u32) );	\
+	}								\
+	*(volatile u32 *)(prim + write + (offset) * sizeof(u32)) = val;	\
+} while (0)
+
+#define DMA_BLOCK( reg0, val0, reg1, val1, reg2, val2, reg3, val3 )	\
+do {									\
+	DMA_WRITE( 0, ((DMAREG( reg0 ) << 0) |				\
+		       (DMAREG( reg1 ) << 8) |				\
+		       (DMAREG( reg2 ) << 16) |				\
+		       (DMAREG( reg3 ) << 24)) );			\
+	DMA_WRITE( 1, val0 );						\
+	DMA_WRITE( 2, val1 );						\
+	DMA_WRITE( 3, val2 );						\
+	DMA_WRITE( 4, val3 );						\
+	write += DMA_BLOCK_SIZE;					\
+} while (0)
+
+
+/* Buffer aging via primary DMA stream head pointer.
+ */
+
+#define SET_AGE( age, h, w )						\
+do {									\
+	(age)->head = h;						\
+	(age)->wrap = w;						\
+} while (0)
+
+#define TEST_AGE( age, h, w )		( (age)->wrap < w ||		\
+					  ( (age)->wrap == w &&		\
+					    (age)->head < h ) )
+
+#define AGE_BUFFER( buf_priv )						\
+do {									\
+	drm_mga_freelist_t *entry = (buf_priv)->list_entry;		\
+	if ( (buf_priv)->dispatched ) {					\
+		entry->age.head = (dev_priv->prim.tail +		\
+				   dev_priv->primary->offset);		\
+		entry->age.wrap = dev_priv->sarea_priv->last_wrap;	\
+	} else {							\
+		entry->age.head = 0;					\
+		entry->age.wrap = 0;					\
+	}								\
+} while (0)
+
+
+#define MGA_ENGINE_IDLE_MASK		(MGA_SOFTRAPEN |		\
+					 MGA_DWGENGSTS |		\
+					 MGA_ENDPRDMASTS)
+#define MGA_DMA_IDLE_MASK		(MGA_SOFTRAPEN |		\
+					 MGA_ENDPRDMASTS)
+
+#define MGA_DMA_DEBUG			0
+
+
 
 /* A reduced set of the mga registers.
  */
+#define MGA_CRTC_INDEX			0x1fd4
+
+#define MGA_ALPHACTRL 			0x2c7c
+#define MGA_AR0 			0x1c60
+#define MGA_AR1 			0x1c64
+#define MGA_AR2 			0x1c68
+#define MGA_AR3 			0x1c6c
+#define MGA_AR4 			0x1c70
+#define MGA_AR5 			0x1c74
+#define MGA_AR6 			0x1c78
+
+#define MGA_CXBNDRY			0x1c80
+#define MGA_CXLEFT 			0x1ca0
+#define MGA_CXRIGHT			0x1ca4
+
+#define MGA_DMAPAD 			0x1c54
+#define MGA_DSTORG 			0x2cb8
+#define MGA_DWGCTL 			0x1c00
+#	define MGA_OPCOD_MASK			(15 << 0)
+#	define MGA_OPCOD_TRAP			(4 << 0)
+#	define MGA_OPCOD_TEXTURE_TRAP		(6 << 0)
+#	define MGA_OPCOD_BITBLT			(8 << 0)
+#	define MGA_OPCOD_ILOAD			(9 << 0)
+#	define MGA_ATYPE_MASK			(7 << 4)
+#	define MGA_ATYPE_RPL			(0 << 4)
+#	define MGA_ATYPE_RSTR			(1 << 4)
+#	define MGA_ATYPE_ZI			(3 << 4)
+#	define MGA_ATYPE_BLK			(4 << 4)
+#	define MGA_ATYPE_I			(7 << 4)
+#	define MGA_LINEAR			(1 << 7)
+#	define MGA_ZMODE_MASK			(7 << 8)
+#	define MGA_ZMODE_NOZCMP			(0 << 8)
+#	define MGA_ZMODE_ZE			(2 << 8)
+#	define MGA_ZMODE_ZNE			(3 << 8)
+#	define MGA_ZMODE_ZLT			(4 << 8)
+#	define MGA_ZMODE_ZLTE			(5 << 8)
+#	define MGA_ZMODE_ZGT			(6 << 8)
+#	define MGA_ZMODE_ZGTE			(7 << 8)
+#	define MGA_SOLID			(1 << 11)
+#	define MGA_ARZERO			(1 << 12)
+#	define MGA_SGNZERO			(1 << 13)
+#	define MGA_SHIFTZERO			(1 << 14)
+#	define MGA_BOP_MASK			(15 << 16)
+#	define MGA_BOP_ZERO			(0 << 16)
+#	define MGA_BOP_DST			(10 << 16)
+#	define MGA_BOP_SRC			(12 << 16)
+#	define MGA_BOP_ONE			(15 << 16)
+#	define MGA_TRANS_SHIFT			20
+#	define MGA_TRANS_MASK			(15 << 20)
+#	define MGA_BLTMOD_MASK			(15 << 25)
+#	define MGA_BLTMOD_BMONOLEF		(0 << 25)
+#	define MGA_BLTMOD_BMONOWF		(4 << 25)
+#	define MGA_BLTMOD_PLAN			(1 << 25)
+#	define MGA_BLTMOD_BFCOL			(2 << 25)
+#	define MGA_BLTMOD_BU32BGR		(3 << 25)
+#	define MGA_BLTMOD_BU32RGB		(7 << 25)
+#	define MGA_BLTMOD_BU24BGR		(11 << 25)
+#	define MGA_BLTMOD_BU24RGB		(15 << 25)
+#	define MGA_PATTERN			(1 << 29)
+#	define MGA_TRANSC			(1 << 30)
+#	define MGA_CLIPDIS			(1 << 31)
+#define MGA_DWGSYNC			0x2c4c
+
+#define MGA_FCOL 			0x1c24
+#define MGA_FIFOSTATUS 			0x1e10
+#define MGA_FOGCOL 			0x1cf4
+#define MGA_FXBNDRY			0x1c84
+#define MGA_FXLEFT 			0x1ca8
+#define MGA_FXRIGHT			0x1cac
+
+#define MGA_ICLEAR 			0x1e18
+#	define MGA_SOFTRAPICLR			(1 << 0)
+#define MGA_IEN 			0x1e1c
+#	define MGA_SOFTRAPIEN			(1 << 0)
+
+#define MGA_LEN 			0x1c5c
+
+#define MGA_MACCESS			0x1c04
+
+#define MGA_PITCH 			0x1c8c
+#define MGA_PLNWT 			0x1c1c
+#define MGA_PRIMADDRESS 		0x1e58
+#	define MGA_DMA_GENERAL			(0 << 0)
+#	define MGA_DMA_BLIT			(1 << 0)
+#	define MGA_DMA_VECTOR			(2 << 0)
+#	define MGA_DMA_VERTEX			(3 << 0)
+#define MGA_PRIMEND			0x1e5c
+#	define MGA_PRIMNOSTART			(1 << 0)
+#	define MGA_PAGPXFER			(1 << 1)
+#define MGA_PRIMPTR			0x1e50
+#	define MGA_PRIMPTREN0			(1 << 0)
+#	define MGA_PRIMPTREN1			(1 << 1)
+
+#define MGA_RST 			0x1e40
+#	define MGA_SOFTRESET			(1 << 0)
+#	define MGA_SOFTEXTRST			(1 << 1)
+
+#define MGA_SECADDRESS 			0x2c40
+#define MGA_SECEND 			0x2c44
+#define MGA_SETUPADDRESS 		0x2cd0
+#define MGA_SETUPEND 			0x2cd4
+#define MGA_SGN				0x1c58
+#define MGA_SOFTRAP			0x2c48
+#define MGA_SRCORG 			0x2cb4
+#	define MGA_SRMMAP_MASK			(1 << 0)
+#	define MGA_SRCMAP_FB			(0 << 0)
+#	define MGA_SRCMAP_SYSMEM		(1 << 0)
+#	define MGA_SRCACC_MASK			(1 << 1)
+#	define MGA_SRCACC_PCI			(0 << 1)
+#	define MGA_SRCACC_AGP			(1 << 1)
+#define MGA_STATUS 			0x1e14
+#	define MGA_SOFTRAPEN			(1 << 0)
+#	define MGA_DWGENGSTS			(1 << 16)
+#	define MGA_ENDPRDMASTS			(1 << 17)
+#define MGA_STENCIL			0x2cc8
+#define MGA_STENCILCTL 			0x2ccc
+
+#define MGA_TDUALSTAGE0 		0x2cf8
+#define MGA_TDUALSTAGE1 		0x2cfc
+#define MGA_TEXBORDERCOL 		0x2c5c
+#define MGA_TEXCTL 			0x2c30
+#define MGA_TEXCTL2			0x2c3c
+#	define MGA_DUALTEX			(1 << 7)
+#	define MGA_G400_TC2_MAGIC		(1 << 15)
+#	define MGA_MAP1_ENABLE			(1 << 31)
+#define MGA_TEXFILTER 			0x2c58
+#define MGA_TEXHEIGHT 			0x2c2c
+#define MGA_TEXORG 			0x2c24
+#	define MGA_TEXORGMAP_MASK		(1 << 0)
+#	define MGA_TEXORGMAP_FB			(0 << 0)
+#	define MGA_TEXORGMAP_SYSMEM		(1 << 0)
+#	define MGA_TEXORGACC_MASK		(1 << 1)
+#	define MGA_TEXORGACC_PCI		(0 << 1)
+#	define MGA_TEXORGACC_AGP		(1 << 1)
+#define MGA_TEXORG1			0x2ca4
+#define MGA_TEXORG2			0x2ca8
+#define MGA_TEXORG3			0x2cac
+#define MGA_TEXORG4			0x2cb0
+#define MGA_TEXTRANS 			0x2c34
+#define MGA_TEXTRANSHIGH 		0x2c38
+#define MGA_TEXWIDTH 			0x2c28
+
+#define MGA_WACCEPTSEQ 			0x1dd4
+#define MGA_WCODEADDR 			0x1e6c
+#define MGA_WFLAG 			0x1dc4
+#define MGA_WFLAG1 			0x1de0
+#define MGA_WFLAGNB			0x1e64
+#define MGA_WFLAGNB1 			0x1e08
+#define MGA_WGETMSB			0x1dc8
+#define MGA_WIADDR 			0x1dc0
+#define MGA_WIADDR2			0x1dd8
+#	define MGA_WMODE_SUSPEND		(0 << 0)
+#	define MGA_WMODE_RESUME			(1 << 0)
+#	define MGA_WMODE_JUMP			(2 << 0)
+#	define MGA_WMODE_START			(3 << 0)
+#	define MGA_WAGP_ENABLE			(1 << 2)
+#define MGA_WMISC 			0x1e70
+#	define MGA_WUCODECACHE_ENABLE		(1 << 0)
+#	define MGA_WMASTER_ENABLE		(1 << 1)
+#	define MGA_WCACHEFLUSH_ENABLE		(1 << 3)
+#define MGA_WVRTXSZ			0x1dcc
+
+#define MGA_YBOT 			0x1c9c
+#define MGA_YDST 			0x1c90
+#define MGA_YDSTLEN			0x1c88
+#define MGA_YDSTORG			0x1c94
+#define MGA_YTOP 			0x1c98
+
+#define MGA_ZORG 			0x1c0c
+
+/* This finishes the current batch of commands
+ */
+#define MGA_EXEC 			0x0100
 
-#define MGAREG_MGA_EXEC 			0x0100
-#define MGAREG_ALPHACTRL 			0x2c7c
-#define MGAREG_AR0 				0x1c60
-#define MGAREG_AR1 				0x1c64
-#define MGAREG_AR2 				0x1c68
-#define MGAREG_AR3 				0x1c6c
-#define MGAREG_AR4 				0x1c70
-#define MGAREG_AR5 				0x1c74
-#define MGAREG_AR6 				0x1c78
-#define MGAREG_CXBNDRY				0x1c80
-#define MGAREG_CXLEFT 				0x1ca0
-#define MGAREG_CXRIGHT				0x1ca4
-#define MGAREG_DMAPAD 				0x1c54
-#define MGAREG_DSTORG 				0x2cb8
-#define MGAREG_DWGCTL 				0x1c00
-#define MGAREG_DWGSYNC				0x2c4c
-#define MGAREG_FCOL 				0x1c24
-#define MGAREG_FIFOSTATUS 			0x1e10
-#define MGAREG_FOGCOL 				0x1cf4
-#define MGAREG_FXBNDRY				0x1c84
-#define MGAREG_FXLEFT 				0x1ca8
-#define MGAREG_FXRIGHT				0x1cac
-#define MGAREG_ICLEAR 				0x1e18
-#define MGAREG_IEN 				0x1e1c
-#define MGAREG_LEN 				0x1c5c
-#define MGAREG_MACCESS				0x1c04
-#define MGAREG_PITCH 				0x1c8c
-#define MGAREG_PLNWT 				0x1c1c
-#define MGAREG_PRIMADDRESS 			0x1e58
-#define MGAREG_PRIMEND				0x1e5c
-#define MGAREG_PRIMPTR				0x1e50
-#define MGAREG_SECADDRESS 			0x2c40
-#define MGAREG_SECEND 				0x2c44
-#define MGAREG_SETUPADDRESS 			0x2cd0
-#define MGAREG_SETUPEND 			0x2cd4
-#define MGAREG_SOFTRAP				0x2c48
-#define MGAREG_SRCORG 				0x2cb4
-#define MGAREG_STATUS 				0x1e14
-#define MGAREG_STENCIL				0x2cc8
-#define MGAREG_STENCILCTL 			0x2ccc
-#define MGAREG_TDUALSTAGE0 			0x2cf8
-#define MGAREG_TDUALSTAGE1 			0x2cfc
-#define MGAREG_TEXBORDERCOL 			0x2c5c
-#define MGAREG_TEXCTL 				0x2c30
-#define MGAREG_TEXCTL2				0x2c3c
-#define MGAREG_TEXFILTER 			0x2c58
-#define MGAREG_TEXHEIGHT 			0x2c2c
-#define MGAREG_TEXORG 				0x2c24
-#define MGAREG_TEXORG1				0x2ca4
-#define MGAREG_TEXORG2				0x2ca8
-#define MGAREG_TEXORG3				0x2cac
-#define MGAREG_TEXORG4				0x2cb0
-#define MGAREG_TEXTRANS 			0x2c34
-#define MGAREG_TEXTRANSHIGH 			0x2c38
-#define MGAREG_TEXWIDTH 			0x2c28
-#define MGAREG_WACCEPTSEQ 			0x1dd4
-#define MGAREG_WCODEADDR 			0x1e6c
-#define MGAREG_WFLAG 				0x1dc4
-#define MGAREG_WFLAG1 				0x1de0
-#define MGAREG_WFLAGNB				0x1e64
-#define MGAREG_WFLAGNB1 			0x1e08
-#define MGAREG_WGETMSB				0x1dc8
-#define MGAREG_WIADDR 				0x1dc0
-#define MGAREG_WIADDR2				0x1dd8
-#define MGAREG_WMISC 				0x1e70
-#define MGAREG_WVRTXSZ				0x1dcc
-#define MGAREG_YBOT 				0x1c9c
-#define MGAREG_YDST 				0x1c90
-#define MGAREG_YDSTLEN				0x1c88
-#define MGAREG_YDSTORG				0x1c94
-#define MGAREG_YTOP 				0x1c98
-#define MGAREG_ZORG 				0x1c0c
-
-/* Warp registers */
-#define MGAREG_WR0                              0x2d00
-#define MGAREG_WR1                              0x2d04
-#define MGAREG_WR2                              0x2d08
-#define MGAREG_WR3                              0x2d0c
-#define MGAREG_WR4                              0x2d10
-#define MGAREG_WR5                              0x2d14
-#define MGAREG_WR6                              0x2d18
-#define MGAREG_WR7                              0x2d1c
-#define MGAREG_WR8                              0x2d20
-#define MGAREG_WR9                              0x2d24
-#define MGAREG_WR10                             0x2d28
-#define MGAREG_WR11                             0x2d2c
-#define MGAREG_WR12                             0x2d30
-#define MGAREG_WR13                             0x2d34
-#define MGAREG_WR14                             0x2d38
-#define MGAREG_WR15                             0x2d3c
-#define MGAREG_WR16                             0x2d40
-#define MGAREG_WR17                             0x2d44
-#define MGAREG_WR18                             0x2d48
-#define MGAREG_WR19                             0x2d4c
-#define MGAREG_WR20                             0x2d50
-#define MGAREG_WR21                             0x2d54
-#define MGAREG_WR22                             0x2d58
-#define MGAREG_WR23                             0x2d5c
-#define MGAREG_WR24                             0x2d60
-#define MGAREG_WR25                             0x2d64
-#define MGAREG_WR26                             0x2d68
-#define MGAREG_WR27                             0x2d6c
-#define MGAREG_WR28                             0x2d70
-#define MGAREG_WR29                             0x2d74
-#define MGAREG_WR30                             0x2d78
-#define MGAREG_WR31                             0x2d7c
-#define MGAREG_WR32                             0x2d80
-#define MGAREG_WR33                             0x2d84
-#define MGAREG_WR34                             0x2d88
-#define MGAREG_WR35                             0x2d8c
-#define MGAREG_WR36                             0x2d90
-#define MGAREG_WR37                             0x2d94
-#define MGAREG_WR38                             0x2d98
-#define MGAREG_WR39                             0x2d9c
-#define MGAREG_WR40                             0x2da0
-#define MGAREG_WR41                             0x2da4
-#define MGAREG_WR42                             0x2da8
-#define MGAREG_WR43                             0x2dac
-#define MGAREG_WR44                             0x2db0
-#define MGAREG_WR45                             0x2db4
-#define MGAREG_WR46                             0x2db8
-#define MGAREG_WR47                             0x2dbc
-#define MGAREG_WR48                             0x2dc0
-#define MGAREG_WR49                             0x2dc4
-#define MGAREG_WR50                             0x2dc8
-#define MGAREG_WR51                             0x2dcc
-#define MGAREG_WR52                             0x2dd0
-#define MGAREG_WR53                             0x2dd4
-#define MGAREG_WR54                             0x2dd8
-#define MGAREG_WR55                             0x2ddc
-#define MGAREG_WR56                             0x2de0
-#define MGAREG_WR57                             0x2de4
-#define MGAREG_WR58                             0x2de8
-#define MGAREG_WR59                             0x2dec
-#define MGAREG_WR60                             0x2df0
-#define MGAREG_WR61                             0x2df4
-#define MGAREG_WR62                             0x2df8
-#define MGAREG_WR63                             0x2dfc
-
-
-#define PDEA_pagpxfer_enable			0x2
-
-#define WIA_wmode_suspend			0x0
-#define WIA_wmode_start 			0x3
-#define WIA_wagp_agp				0x4
-
-#define DC_opcod_line_open 			0x0
-#define DC_opcod_autoline_open 			0x1
-#define DC_opcod_line_close 			0x2
-#define DC_opcod_autoline_close 		0x3
-#define DC_opcod_trap 				0x4
-#define DC_opcod_texture_trap 			0x6
-#define DC_opcod_bitblt 			0x8
-#define DC_opcod_iload 				0x9
-#define DC_atype_rpl 				0x0
-#define DC_atype_rstr 				0x10
-#define DC_atype_zi 				0x30
-#define DC_atype_blk 				0x40
-#define DC_atype_i 				0x70
-#define DC_linear_xy 				0x0 		
-#define DC_linear_linear 			0x80 		
-#define DC_zmode_nozcmp 			0x0
-#define DC_zmode_ze 				0x200
-#define DC_zmode_zne 				0x300
-#define DC_zmode_zlt 				0x400
-#define DC_zmode_zlte 				0x500
-#define DC_zmode_zgt 				0x600
-#define DC_zmode_zgte 				0x700
-#define DC_solid_disable 			0x0 		
-#define DC_solid_enable 			0x800 		
-#define DC_arzero_disable 			0x0 		
-#define DC_arzero_enable 			0x1000 		
-#define DC_sgnzero_disable 			0x0 		
-#define DC_sgnzero_enable 			0x2000 		
-#define DC_shftzero_disable 			0x0 		
-#define DC_shftzero_enable 			0x4000 		
-#define DC_bop_SHIFT 				16 		
-#define DC_trans_SHIFT 				20 		
-#define DC_bltmod_bmonolef 			0x0
-#define DC_bltmod_bmonowf 			0x8000000
-#define DC_bltmod_bplan 			0x2000000
-#define DC_bltmod_bfcol 			0x4000000
-#define DC_bltmod_bu32bgr 			0x6000000
-#define DC_bltmod_bu32rgb 			0xe000000
-#define DC_bltmod_bu24bgr 			0x16000000
-#define DC_bltmod_bu24rgb 			0x1e000000
-#define DC_pattern_disable 			0x0 		
-#define DC_pattern_enable 			0x20000000 	
-#define DC_transc_disable 			0x0 		
-#define DC_transc_enable 			0x40000000 	
-#define DC_clipdis_disable 			0x0 		
-#define DC_clipdis_enable 			0x80000000 	
-
-#define SETADD_mode_vertlist                   	0x0 	
-
-
-#define MGA_CLEAR_CMD (DC_opcod_trap | DC_arzero_enable | 		\
-		       DC_sgnzero_enable | DC_shftzero_enable | 	\
-		       (0xC << DC_bop_SHIFT) | DC_clipdis_enable | 	\
-		       DC_solid_enable | DC_transc_enable)
-	  
-
-#define MGA_COPY_CMD (DC_opcod_bitblt | DC_atype_rpl | DC_linear_xy |	\
-		      DC_solid_disable | DC_arzero_disable | 		\
-		      DC_sgnzero_enable | DC_shftzero_enable | 		\
-		      (0xC << DC_bop_SHIFT) | DC_bltmod_bfcol | 	\
-		      DC_pattern_disable | DC_transc_disable | 		\
-		      DC_clipdis_enable)				\
-
-#define MGA_FLUSH_CMD (DC_opcod_texture_trap | (0xF << DC_trans_SHIFT) |\
-		       DC_arzero_enable | DC_sgnzero_enable |		\
-		       DC_atype_i)
+/* Warp registers
+ */
+#define MGA_WR0				0x2d00
+#define MGA_WR1				0x2d04
+#define MGA_WR2				0x2d08
+#define MGA_WR3				0x2d0c
+#define MGA_WR4				0x2d10
+#define MGA_WR5				0x2d14
+#define MGA_WR6				0x2d18
+#define MGA_WR7				0x2d1c
+#define MGA_WR8				0x2d20
+#define MGA_WR9				0x2d24
+#define MGA_WR10			0x2d28
+#define MGA_WR11			0x2d2c
+#define MGA_WR12			0x2d30
+#define MGA_WR13			0x2d34
+#define MGA_WR14			0x2d38
+#define MGA_WR15			0x2d3c
+#define MGA_WR16			0x2d40
+#define MGA_WR17			0x2d44
+#define MGA_WR18			0x2d48
+#define MGA_WR19			0x2d4c
+#define MGA_WR20			0x2d50
+#define MGA_WR21			0x2d54
+#define MGA_WR22			0x2d58
+#define MGA_WR23			0x2d5c
+#define MGA_WR24			0x2d60
+#define MGA_WR25			0x2d64
+#define MGA_WR26			0x2d68
+#define MGA_WR27			0x2d6c
+#define MGA_WR28			0x2d70
+#define MGA_WR29			0x2d74
+#define MGA_WR30			0x2d78
+#define MGA_WR31			0x2d7c
+#define MGA_WR32			0x2d80
+#define MGA_WR33			0x2d84
+#define MGA_WR34			0x2d88
+#define MGA_WR35			0x2d8c
+#define MGA_WR36			0x2d90
+#define MGA_WR37			0x2d94
+#define MGA_WR38			0x2d98
+#define MGA_WR39			0x2d9c
+#define MGA_WR40			0x2da0
+#define MGA_WR41			0x2da4
+#define MGA_WR42			0x2da8
+#define MGA_WR43			0x2dac
+#define MGA_WR44			0x2db0
+#define MGA_WR45			0x2db4
+#define MGA_WR46			0x2db8
+#define MGA_WR47			0x2dbc
+#define MGA_WR48			0x2dc0
+#define MGA_WR49			0x2dc4
+#define MGA_WR50			0x2dc8
+#define MGA_WR51			0x2dcc
+#define MGA_WR52			0x2dd0
+#define MGA_WR53			0x2dd4
+#define MGA_WR54			0x2dd8
+#define MGA_WR55			0x2ddc
+#define MGA_WR56			0x2de0
+#define MGA_WR57			0x2de4
+#define MGA_WR58			0x2de8
+#define MGA_WR59			0x2dec
+#define MGA_WR60			0x2df0
+#define MGA_WR61			0x2df4
+#define MGA_WR62			0x2df8
+#define MGA_WR63			0x2dfc
+#	define MGA_G400_WR_MAGIC		(1 << 6)
+#	define MGA_G400_WR56_MAGIC		0x46480000	/* 12800.0f */
+
+
+#define MGA_ILOAD_ALIGN		64
+#define MGA_ILOAD_MASK		(MGA_ILOAD_ALIGN - 1)
+
+#define MGA_DWGCTL_FLUSH	(MGA_OPCOD_TEXTURE_TRAP |		\
+				 MGA_ATYPE_I |				\
+				 MGA_ZMODE_NOZCMP |			\
+				 MGA_ARZERO |				\
+				 MGA_SGNZERO |				\
+				 MGA_BOP_SRC |				\
+				 (15 << MGA_TRANS_SHIFT))
+
+#define MGA_DWGCTL_CLEAR	(MGA_OPCOD_TRAP |			\
+				 MGA_ZMODE_NOZCMP |			\
+				 MGA_SOLID |				\
+				 MGA_ARZERO |				\
+				 MGA_SGNZERO |				\
+				 MGA_SHIFTZERO |			\
+				 MGA_BOP_SRC |				\
+				 (0 << MGA_TRANS_SHIFT) |		\
+				 MGA_BLTMOD_BMONOLEF |			\
+				 MGA_TRANSC |				\
+				 MGA_CLIPDIS)
+
+#define MGA_DWGCTL_COPY		(MGA_OPCOD_BITBLT |			\
+				 MGA_ATYPE_RPL |			\
+				 MGA_SGNZERO |				\
+				 MGA_SHIFTZERO |			\
+				 MGA_BOP_SRC |				\
+				 (0 << MGA_TRANS_SHIFT) |		\
+				 MGA_BLTMOD_BFCOL |			\
+				 MGA_CLIPDIS)
+
+/* Simple idle test.
+ */
+static __inline__ int mga_is_idle( drm_mga_private_t *dev_priv )
+{
+	u32 status = MGA_READ( MGA_STATUS ) & MGA_ENGINE_IDLE_MASK;
+	return ( status == MGA_ENDPRDMASTS );
+}
 
 #endif
diff --git a/bsd/mga/mga_state.c b/bsd/mga/mga_state.c
index fb365631..320e2b3e 100644
--- a/bsd/mga/mga_state.c
+++ b/bsd/mga/mga_state.c
@@ -1,4 +1,4 @@
-/* mga_state.c -- State support for mga g200/g400
+/* mga_state.c -- State support for MGA G200/G400 -*- linux-c -*-
  * Created: Thu Jan 27 02:53:43 2000 by jhartmann@precisioninsight.com
  *
  * Copyright 1999 Precision Insight, Inc., Cedar Park, Texas.
@@ -11,431 +11,408 @@
  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  * and/or sell copies of the Software, and to permit persons to whom the
  * Software is furnished to do so, subject to the following conditions:
- * 
+ *
  * The above copyright notice and this permission notice (including the next
  * paragraph) shall be included in all copies or substantial portions of the
  * Software.
- * 
+ *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+ * VA LINUX SYSTEMS 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.
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
  *
- * Authors: Jeff Hartmann <jhartmann@precisioninsight.com>
- * 	    Keith Whitwell <keithw@precisioninsight.com>
+ * Authors:
+ *    Jeff Hartmann <jhartmann@valinux.com>
+ *    Keith Whitwell <keithw@valinux.com>
  *
+ * Rewritten by:
+ *    Gareth Hughes <gareth@valinux.com>
  */
 
 #define __NO_VERSION__
+#include "mga.h"
 #include "drmP.h"
 #include "mga_drv.h"
 #include "drm.h"
 
-typedef u_int16_t u16;
-typedef u_int32_t u32;
-
-#define MGAEMITCLIP_SIZE        10
-#define MGAEMITCTX_SIZE         20
-#define MGAG200EMITTEX_SIZE     20
-#define MGAG400EMITTEX0_SIZE    30
-#define MGAG400EMITTEX1_SIZE    25
-#define MGAG400EMITPIPE_SIZE    50
-#define MGAG200EMITPIPE_SIZE    15
-
-#define MAX_STATE_SIZE ((MGAEMITCLIP_SIZE * MGA_NR_SAREA_CLIPRECTS) + \
-                        MGAEMITCTX_SIZE + MGAG400EMITTEX0_SIZE + \
-                        MGAG400EMITTEX1_SIZE + MGAG400EMITPIPE_SIZE)
-
 
+/* ================================================================
+ * DMA hardware state programming functions
+ */
 
-static void mgaEmitClipRect(drm_mga_private_t * dev_priv,
-			    drm_clip_rect_t * box)
+static void mga_emit_clip_rect( drm_mga_private_t *dev_priv,
+				drm_clip_rect_t *box )
 {
 	drm_mga_sarea_t *sarea_priv = dev_priv->sarea_priv;
-	unsigned int *regs = sarea_priv->ContextState;
-	PRIMLOCALS;
-	DRM_DEBUG("%s\n", __FUNCTION__);
+	drm_mga_context_regs_t *ctx = &sarea_priv->context_state;
+	unsigned int pitch = dev_priv->front_pitch;
+	DMA_LOCALS;
 
-	/* This takes 10 dwords */
-	PRIMGETPTR(dev_priv);
+	BEGIN_DMA( 2 );
 
-	/* Force reset of dwgctl (eliminates clip disable) */
-	if (dev_priv->chipset == MGA_CARD_TYPE_G400) {
-#if 0
-	PRIMOUTREG(MGAREG_DMAPAD, 0);
-	PRIMOUTREG(MGAREG_DWGSYNC, 0);
-	PRIMOUTREG(MGAREG_DWGSYNC, 0);
-	PRIMOUTREG(MGAREG_DWGCTL, regs[MGA_CTXREG_DWGCTL]);
-#else
-	PRIMOUTREG(MGAREG_DWGCTL, regs[MGA_CTXREG_DWGCTL]);
-	PRIMOUTREG(MGAREG_LEN + MGAREG_MGA_EXEC, 0x80000000);
-	PRIMOUTREG(MGAREG_DWGCTL, regs[MGA_CTXREG_DWGCTL]);
-	PRIMOUTREG(MGAREG_LEN + MGAREG_MGA_EXEC, 0x80000000);
-#endif
+	/* Force reset of DWGCTL on G400 (eliminates clip disable bit).
+	 */
+	if ( dev_priv->chipset == MGA_CARD_TYPE_G400 ) {
+		DMA_BLOCK( MGA_DWGCTL,		ctx->dwgctl,
+			   MGA_LEN + MGA_EXEC,	0x80000000,
+			   MGA_DWGCTL,		ctx->dwgctl,
+			   MGA_LEN + MGA_EXEC,	0x80000000 );
 	}
-	PRIMOUTREG(MGAREG_DMAPAD, 0);
-	PRIMOUTREG(MGAREG_CXBNDRY, ((box->x2) << 16) | (box->x1));
-	PRIMOUTREG(MGAREG_YTOP, box->y1 * dev_priv->stride / dev_priv->cpp);
-	PRIMOUTREG(MGAREG_YBOT, box->y2 * dev_priv->stride / dev_priv->cpp);
+	DMA_BLOCK( MGA_DMAPAD,	0x00000000,
+		   MGA_CXBNDRY,	(box->x2 << 16) | box->x1,
+		   MGA_YTOP,	box->y1 * pitch,
+		   MGA_YBOT,	box->y2 * pitch );
 
-	PRIMADVANCE(dev_priv);
+	ADVANCE_DMA();
 }
 
-static void mgaEmitContext(drm_mga_private_t * dev_priv)
+static __inline__ void mga_g200_emit_context( drm_mga_private_t *dev_priv )
 {
 	drm_mga_sarea_t *sarea_priv = dev_priv->sarea_priv;
-	unsigned int *regs = sarea_priv->ContextState;
-	PRIMLOCALS;
-	DRM_DEBUG("%s\n", __FUNCTION__);
-
-	/* This takes a max of 20 dwords */
-	PRIMGETPTR(dev_priv);
-
-	PRIMOUTREG(MGAREG_DSTORG, regs[MGA_CTXREG_DSTORG]);
-	PRIMOUTREG(MGAREG_MACCESS, regs[MGA_CTXREG_MACCESS]);
-	PRIMOUTREG(MGAREG_PLNWT, regs[MGA_CTXREG_PLNWT]);
-	PRIMOUTREG(MGAREG_DWGCTL, regs[MGA_CTXREG_DWGCTL]);
-
-	PRIMOUTREG(MGAREG_ALPHACTRL, regs[MGA_CTXREG_ALPHACTRL]);
-	PRIMOUTREG(MGAREG_FOGCOL, regs[MGA_CTXREG_FOGCOLOR]);
-	PRIMOUTREG(MGAREG_WFLAG, regs[MGA_CTXREG_WFLAG]);
-	PRIMOUTREG(MGAREG_ZORG, dev_priv->depthOffset);	/* invarient */
-
-	if (dev_priv->chipset == MGA_CARD_TYPE_G400) {
-		PRIMOUTREG(MGAREG_WFLAG1, regs[MGA_CTXREG_WFLAG]);
-		PRIMOUTREG(MGAREG_TDUALSTAGE0, regs[MGA_CTXREG_TDUAL0]);
-		PRIMOUTREG(MGAREG_TDUALSTAGE1, regs[MGA_CTXREG_TDUAL1]);
-		PRIMOUTREG(MGAREG_FCOL, regs[MGA_CTXREG_FCOL]);
-
-                PRIMOUTREG(MGAREG_STENCIL, regs[MGA_CTXREG_STENCIL]);
-                PRIMOUTREG(MGAREG_STENCILCTL, regs[MGA_CTXREG_STENCILCTL]);
-                PRIMOUTREG(MGAREG_DMAPAD, 0);
-                PRIMOUTREG(MGAREG_DMAPAD, 0);
+	drm_mga_context_regs_t *ctx = &sarea_priv->context_state;
+	DMA_LOCALS;
 
-	} else {
-		PRIMOUTREG(MGAREG_FCOL, regs[MGA_CTXREG_FCOL]);
-		PRIMOUTREG(MGAREG_DMAPAD, 0);
-		PRIMOUTREG(MGAREG_DMAPAD, 0);
-		PRIMOUTREG(MGAREG_DMAPAD, 0);
-	}
+	BEGIN_DMA( 3 );
+
+	DMA_BLOCK( MGA_DSTORG,		ctx->dstorg,
+		   MGA_MACCESS,		ctx->maccess,
+		   MGA_PLNWT,		ctx->plnwt,
+		   MGA_DWGCTL,		ctx->dwgctl );
 
-	PRIMADVANCE(dev_priv);
+	DMA_BLOCK( MGA_ALPHACTRL,	ctx->alphactrl,
+		   MGA_FOGCOL,		ctx->fogcolor,
+		   MGA_WFLAG,		ctx->wflag,
+		   MGA_ZORG,		dev_priv->depth_offset );
+
+	DMA_BLOCK( MGA_FCOL,		ctx->fcol,
+		   MGA_DMAPAD,		0x00000000,
+		   MGA_DMAPAD,		0x00000000,
+		   MGA_DMAPAD,		0x00000000 );
+
+	ADVANCE_DMA();
 }
 
-static void mgaG200EmitTex(drm_mga_private_t * dev_priv)
+static __inline__ void mga_g400_emit_context( drm_mga_private_t *dev_priv )
 {
 	drm_mga_sarea_t *sarea_priv = dev_priv->sarea_priv;
-	unsigned int *regs = sarea_priv->TexState[0];
-	PRIMLOCALS;
-	DRM_DEBUG("%s\n", __FUNCTION__);
-
-	PRIMGETPTR(dev_priv);
+	drm_mga_context_regs_t *ctx = &sarea_priv->context_state;
+	DMA_LOCALS;
 
-	/* This takes 20 dwords */
+	BEGIN_DMA( 4 );
 
-	PRIMOUTREG(MGAREG_TEXCTL2, regs[MGA_TEXREG_CTL2]);
-	PRIMOUTREG(MGAREG_TEXCTL, regs[MGA_TEXREG_CTL]);
-	PRIMOUTREG(MGAREG_TEXFILTER, regs[MGA_TEXREG_FILTER]);
-	PRIMOUTREG(MGAREG_TEXBORDERCOL, regs[MGA_TEXREG_BORDERCOL]);
+	DMA_BLOCK( MGA_DSTORG,		ctx->dstorg,
+		   MGA_MACCESS,		ctx->maccess,
+		   MGA_PLNWT,		ctx->plnwt,
+		   MGA_DWGCTL,		ctx->dwgctl );
 
-	PRIMOUTREG(MGAREG_TEXORG, regs[MGA_TEXREG_ORG]);
-	PRIMOUTREG(MGAREG_TEXORG1, regs[MGA_TEXREG_ORG1]);
-	PRIMOUTREG(MGAREG_TEXORG2, regs[MGA_TEXREG_ORG2]);
-	PRIMOUTREG(MGAREG_TEXORG3, regs[MGA_TEXREG_ORG3]);
+	DMA_BLOCK( MGA_ALPHACTRL,	ctx->alphactrl,
+		   MGA_FOGCOL,		ctx->fogcolor,
+		   MGA_WFLAG,		ctx->wflag,
+		   MGA_ZORG,		dev_priv->depth_offset );
 
-	PRIMOUTREG(MGAREG_TEXORG4, regs[MGA_TEXREG_ORG4]);
-	PRIMOUTREG(MGAREG_TEXWIDTH, regs[MGA_TEXREG_WIDTH]);
-	PRIMOUTREG(MGAREG_TEXHEIGHT, regs[MGA_TEXREG_HEIGHT]);
-	PRIMOUTREG(MGAREG_WR24, regs[MGA_TEXREG_WIDTH]);
+	DMA_BLOCK( MGA_WFLAG1,		ctx->wflag,
+		   MGA_TDUALSTAGE0,	ctx->tdualstage0,
+		   MGA_TDUALSTAGE1,	ctx->tdualstage1,
+		   MGA_FCOL,		ctx->fcol );
 
-	PRIMOUTREG(MGAREG_WR34, regs[MGA_TEXREG_HEIGHT]);
-	PRIMOUTREG(MGAREG_TEXTRANS, 0xffff);
-	PRIMOUTREG(MGAREG_TEXTRANSHIGH, 0xffff);
-	PRIMOUTREG(MGAREG_DMAPAD, 0);
+	DMA_BLOCK( MGA_STENCIL,		ctx->stencil,
+		   MGA_STENCILCTL,	ctx->stencilctl,
+		   MGA_DMAPAD,		0x00000000,
+		   MGA_DMAPAD,		0x00000000 );
 
-	PRIMADVANCE(dev_priv);
+	ADVANCE_DMA();
 }
 
-#define TMC_dualtex_enable              0x80
-
-static void mgaG400EmitTex0(drm_mga_private_t * dev_priv)
+static __inline__ void mga_g200_emit_tex0( drm_mga_private_t *dev_priv )
 {
 	drm_mga_sarea_t *sarea_priv = dev_priv->sarea_priv;
-	unsigned int *regs = sarea_priv->TexState[0];
-	PRIMLOCALS;
-	DRM_DEBUG("%s\n", __FUNCTION__);
-
-	PRIMGETPTR(dev_priv);
-
-	/* This takes a max of 30 dwords */
-
-	PRIMOUTREG(MGAREG_TEXCTL2, regs[MGA_TEXREG_CTL2] | 0x00008000);
-	PRIMOUTREG(MGAREG_TEXCTL, regs[MGA_TEXREG_CTL]);
-	PRIMOUTREG(MGAREG_TEXFILTER, regs[MGA_TEXREG_FILTER]);
-	PRIMOUTREG(MGAREG_TEXBORDERCOL, regs[MGA_TEXREG_BORDERCOL]);
+	drm_mga_texture_regs_t *tex = &sarea_priv->tex_state[0];
+	DMA_LOCALS;
 
-	PRIMOUTREG(MGAREG_TEXORG, regs[MGA_TEXREG_ORG]);
-	PRIMOUTREG(MGAREG_TEXORG1, regs[MGA_TEXREG_ORG1]);
-	PRIMOUTREG(MGAREG_TEXORG2, regs[MGA_TEXREG_ORG2]);
-	PRIMOUTREG(MGAREG_TEXORG3, regs[MGA_TEXREG_ORG3]);
+	BEGIN_DMA( 4 );
 
-	PRIMOUTREG(MGAREG_TEXORG4, regs[MGA_TEXREG_ORG4]);
-	PRIMOUTREG(MGAREG_TEXWIDTH, regs[MGA_TEXREG_WIDTH]);
-	PRIMOUTREG(MGAREG_TEXHEIGHT, regs[MGA_TEXREG_HEIGHT]);
-        PRIMOUTREG(MGAREG_WR49, 0);
+	DMA_BLOCK( MGA_TEXCTL2,		tex->texctl2,
+		   MGA_TEXCTL,		tex->texctl,
+		   MGA_TEXFILTER,	tex->texfilter,
+		   MGA_TEXBORDERCOL,	tex->texbordercol );
 
-        PRIMOUTREG(MGAREG_WR57, 0);
-        PRIMOUTREG(MGAREG_WR53, 0);
-        PRIMOUTREG(MGAREG_WR61, 0);
-        PRIMOUTREG(MGAREG_WR52, 0x40);
+	DMA_BLOCK( MGA_TEXORG,		tex->texorg,
+		   MGA_TEXORG1,		tex->texorg1,
+		   MGA_TEXORG2,		tex->texorg2,
+		   MGA_TEXORG3,		tex->texorg3 );
 
-        PRIMOUTREG(MGAREG_WR60, 0x40);
-        PRIMOUTREG(MGAREG_WR54, regs[MGA_TEXREG_WIDTH] | 0x40);
-        PRIMOUTREG(MGAREG_WR62, regs[MGA_TEXREG_HEIGHT] | 0x40);
-	PRIMOUTREG(MGAREG_DMAPAD, 0);
+	DMA_BLOCK( MGA_TEXORG4,		tex->texorg4,
+		   MGA_TEXWIDTH,	tex->texwidth,
+		   MGA_TEXHEIGHT,	tex->texheight,
+		   MGA_WR24,		tex->texwidth );
 
-		PRIMOUTREG(MGAREG_DMAPAD, 0);
-		PRIMOUTREG(MGAREG_DMAPAD, 0);
+	DMA_BLOCK( MGA_WR34,		tex->texheight,
+		   MGA_TEXTRANS,	0x0000ffff,
+		   MGA_TEXTRANSHIGH,	0x0000ffff,
+		   MGA_DMAPAD,		0x00000000 );
 
-	PRIMOUTREG(MGAREG_TEXTRANS, 0xffff);
-	PRIMOUTREG(MGAREG_TEXTRANSHIGH, 0xffff);
-
-	PRIMADVANCE(dev_priv);
+	ADVANCE_DMA();
 }
 
-#define TMC_map1_enable 		0x80000000
-
-static void mgaG400EmitTex1(drm_mga_private_t * dev_priv)
+static __inline__ void mga_g400_emit_tex0( drm_mga_private_t *dev_priv )
 {
 	drm_mga_sarea_t *sarea_priv = dev_priv->sarea_priv;
-	unsigned int *regs = sarea_priv->TexState[1];
-	PRIMLOCALS;
-	DRM_DEBUG("%s\n", __FUNCTION__);
-
-	PRIMGETPTR(dev_priv);
-
-	/* This takes 25 dwords */
-
-	PRIMOUTREG(MGAREG_TEXCTL2,
-		   regs[MGA_TEXREG_CTL2] | TMC_map1_enable | 0x00008000);
-	PRIMOUTREG(MGAREG_TEXCTL, regs[MGA_TEXREG_CTL]);
-	PRIMOUTREG(MGAREG_TEXFILTER, regs[MGA_TEXREG_FILTER]);
-	PRIMOUTREG(MGAREG_TEXBORDERCOL, regs[MGA_TEXREG_BORDERCOL]);
+	drm_mga_texture_regs_t *tex = &sarea_priv->tex_state[0];
+	DMA_LOCALS;
+
+	BEGIN_DMA( 6 );
+
+	DMA_BLOCK( MGA_TEXCTL2,		tex->texctl2 | MGA_G400_TC2_MAGIC,
+		   MGA_TEXCTL,		tex->texctl,
+		   MGA_TEXFILTER,	tex->texfilter,
+		   MGA_TEXBORDERCOL,	tex->texbordercol );
+
+	DMA_BLOCK( MGA_TEXORG,		tex->texorg,
+		   MGA_TEXORG1,		tex->texorg1,
+		   MGA_TEXORG2,		tex->texorg2,
+		   MGA_TEXORG3,		tex->texorg3 );
+
+	DMA_BLOCK( MGA_TEXORG4,		tex->texorg4,
+		   MGA_TEXWIDTH,	tex->texwidth,
+		   MGA_TEXHEIGHT,	tex->texheight,
+		   MGA_WR49,		0x00000000 );
+
+	DMA_BLOCK( MGA_WR57,		0x00000000,
+		   MGA_WR53,		0x00000000,
+		   MGA_WR61,		0x00000000,
+		   MGA_WR52,		MGA_G400_WR_MAGIC );
+
+	DMA_BLOCK( MGA_WR60,		MGA_G400_WR_MAGIC,
+		   MGA_WR54,		tex->texwidth | MGA_G400_WR_MAGIC,
+		   MGA_WR62,		tex->texheight | MGA_G400_WR_MAGIC,
+		   MGA_DMAPAD,		0x00000000 );
+
+	DMA_BLOCK( MGA_DMAPAD,		0x00000000,
+		   MGA_DMAPAD,		0x00000000,
+		   MGA_TEXTRANS,	0x0000ffff,
+		   MGA_TEXTRANSHIGH,	0x0000ffff );
+
+	ADVANCE_DMA();
+}
 
-	PRIMOUTREG(MGAREG_TEXORG, regs[MGA_TEXREG_ORG]);
-	PRIMOUTREG(MGAREG_TEXORG1, regs[MGA_TEXREG_ORG1]);
-	PRIMOUTREG(MGAREG_TEXORG2, regs[MGA_TEXREG_ORG2]);
-	PRIMOUTREG(MGAREG_TEXORG3, regs[MGA_TEXREG_ORG3]);
+static __inline__ void mga_g400_emit_tex1( drm_mga_private_t *dev_priv )
+{
+	drm_mga_sarea_t *sarea_priv = dev_priv->sarea_priv;
+	drm_mga_texture_regs_t *tex = &sarea_priv->tex_state[1];
+	DMA_LOCALS;
+
+	BEGIN_DMA( 5 );
+
+	DMA_BLOCK( MGA_TEXCTL2,		(tex->texctl2 |
+					 MGA_MAP1_ENABLE |
+					 MGA_G400_TC2_MAGIC),
+		   MGA_TEXCTL,		tex->texctl,
+		   MGA_TEXFILTER,	tex->texfilter,
+		   MGA_TEXBORDERCOL,	tex->texbordercol );
+
+	DMA_BLOCK( MGA_TEXORG,		tex->texorg,
+		   MGA_TEXORG1,		tex->texorg1,
+		   MGA_TEXORG2,		tex->texorg2,
+		   MGA_TEXORG3,		tex->texorg3 );
+
+	DMA_BLOCK( MGA_TEXORG4,		tex->texorg4,
+		   MGA_TEXWIDTH,	tex->texwidth,
+		   MGA_TEXHEIGHT,	tex->texheight,
+		   MGA_WR49,		0x00000000 );
+
+	DMA_BLOCK( MGA_WR57,		0x00000000,
+		   MGA_WR53,		0x00000000,
+		   MGA_WR61,		0x00000000,
+		   MGA_WR52,		tex->texwidth | MGA_G400_WR_MAGIC );
+
+	DMA_BLOCK( MGA_WR60,		tex->texheight | MGA_G400_WR_MAGIC,
+		   MGA_TEXTRANS,	0x0000ffff,
+		   MGA_TEXTRANSHIGH,	0x0000ffff,
+		   MGA_TEXCTL2,		tex->texctl2 | MGA_G400_TC2_MAGIC );
+
+	ADVANCE_DMA();
+}
 
-	PRIMOUTREG(MGAREG_TEXORG4, regs[MGA_TEXREG_ORG4]);
-	PRIMOUTREG(MGAREG_TEXWIDTH, regs[MGA_TEXREG_WIDTH]);
-	PRIMOUTREG(MGAREG_TEXHEIGHT, regs[MGA_TEXREG_HEIGHT]);
-        PRIMOUTREG(MGAREG_WR49, 0);
+static __inline__ void mga_g200_emit_pipe( drm_mga_private_t *dev_priv )
+{
+	drm_mga_sarea_t *sarea_priv = dev_priv->sarea_priv;
+	unsigned int pipe = sarea_priv->warp_pipe;
+	DMA_LOCALS;
 
-        PRIMOUTREG(MGAREG_WR57, 0);
-        PRIMOUTREG(MGAREG_WR53, 0);
-        PRIMOUTREG(MGAREG_WR61, 0);
-        PRIMOUTREG(MGAREG_WR52, regs[MGA_TEXREG_WIDTH] | 0x40);
+	BEGIN_DMA( 3 );
 
-        PRIMOUTREG(MGAREG_WR60, regs[MGA_TEXREG_HEIGHT] | 0x40);
+	DMA_BLOCK( MGA_WIADDR,	MGA_WMODE_SUSPEND,
+		   MGA_WVRTXSZ,	0x00000007,
+		   MGA_WFLAG,	0x00000000,
+		   MGA_WR24,	0x00000000 );
 
-	PRIMOUTREG(MGAREG_TEXTRANS, 0xffff);
-	PRIMOUTREG(MGAREG_TEXTRANSHIGH, 0xffff);
-	PRIMOUTREG(MGAREG_TEXCTL2, regs[MGA_TEXREG_CTL2] | 0x00008000);
+	DMA_BLOCK( MGA_WR25,	0x00000100,
+		   MGA_WR34,	0x00000000,
+		   MGA_WR42,	0x0000ffff,
+		   MGA_WR60,	0x0000ffff );
 
-	PRIMADVANCE(dev_priv);
+	/* Padding required to to hardware bug.
+	 */
+	DMA_BLOCK( MGA_DMAPAD,	0xffffffff,
+		   MGA_DMAPAD,	0xffffffff,
+		   MGA_DMAPAD,	0xffffffff,
+		   MGA_WIADDR,	(dev_priv->warp_pipe_phys[pipe] |
+				 MGA_WMODE_START |
+				 MGA_WAGP_ENABLE) );
+
+	ADVANCE_DMA();
 }
 
-#define MAGIC_FPARAM_HEX_VALUE 0x46480000
-/* This is the hex value of 12800.0f which is a magic value we must
- * set in wr56.
- */
-
-
-#define EMIT_PIPE 50
-static void mgaG400EmitPipe(drm_mga_private_t * dev_priv)
+static __inline__ void mga_g400_emit_pipe( drm_mga_private_t *dev_priv )
 {
 	drm_mga_sarea_t *sarea_priv = dev_priv->sarea_priv;
-	unsigned int pipe = sarea_priv->WarpPipe;
-	PRIMLOCALS;
-	DRM_DEBUG("%s\n", __FUNCTION__);
-
-	PRIMGETPTR(dev_priv);
-
-	/* This takes 50 dwords */
-
-	/* Establish vertex size.  
-	 */
-	PRIMOUTREG(MGAREG_WIADDR2, WIA_wmode_suspend);
-	PRIMOUTREG(MGAREG_DMAPAD, 0);
-	PRIMOUTREG(MGAREG_DMAPAD, 0);
-	PRIMOUTREG(MGAREG_DMAPAD, 0);
-
-	if (pipe & MGA_T2) {
-		PRIMOUTREG(MGAREG_WVRTXSZ, 0x00001e09);
-		PRIMOUTREG(MGAREG_DMAPAD, 0);
-		PRIMOUTREG(MGAREG_DMAPAD, 0);
-		PRIMOUTREG(MGAREG_DMAPAD, 0);
-
-		PRIMOUTREG(MGAREG_WACCEPTSEQ, 0);
-		PRIMOUTREG(MGAREG_WACCEPTSEQ, 0);
-		PRIMOUTREG(MGAREG_WACCEPTSEQ, 0);
-		PRIMOUTREG(MGAREG_WACCEPTSEQ, 0x1e000000);
+	unsigned int pipe = sarea_priv->warp_pipe;
+	DMA_LOCALS;
+
+	BEGIN_DMA( 10 );
+
+	DMA_BLOCK( MGA_WIADDR2,	MGA_WMODE_SUSPEND,
+		   MGA_DMAPAD,	0x00000000,
+		   MGA_DMAPAD,	0x00000000,
+		   MGA_DMAPAD,	0x00000000 );
+
+	if ( pipe & MGA_T2 ) {
+		DMA_BLOCK( MGA_WVRTXSZ,		0x00001e09,
+			   MGA_DMAPAD,		0x00000000,
+			   MGA_DMAPAD,		0x00000000,
+			   MGA_DMAPAD,		0x00000000 );
+
+		DMA_BLOCK( MGA_WACCEPTSEQ,	0x00000000,
+			   MGA_WACCEPTSEQ,	0x00000000,
+			   MGA_WACCEPTSEQ,	0x00000000,
+			   MGA_WACCEPTSEQ,	0x1e000000 );
 	} else {
-		if (dev_priv->WarpPipe & MGA_T2) {
+		if ( dev_priv->warp_pipe & MGA_T2 ) {
 			/* Flush the WARP pipe */
-			PRIMOUTREG(MGAREG_YDST, 0);
-			PRIMOUTREG(MGAREG_FXLEFT, 0);
-			PRIMOUTREG(MGAREG_FXRIGHT, 1);
-			PRIMOUTREG(MGAREG_DWGCTL, MGA_FLUSH_CMD);
-
-			PRIMOUTREG(MGAREG_LEN + MGAREG_MGA_EXEC, 1);
-			PRIMOUTREG(MGAREG_DWGSYNC, 0x7000);
-			PRIMOUTREG(MGAREG_TEXCTL2, 0x00008000);
-			PRIMOUTREG(MGAREG_LEN + MGAREG_MGA_EXEC, 0);
-
-			PRIMOUTREG(MGAREG_TEXCTL2, 0x80 | 0x00008000);
-			PRIMOUTREG(MGAREG_LEN + MGAREG_MGA_EXEC, 0);
-			PRIMOUTREG(MGAREG_TEXCTL2, 0x00008000);
-			PRIMOUTREG(MGAREG_DMAPAD, 0);
+			DMA_BLOCK( MGA_YDST,		0x00000000,
+				   MGA_FXLEFT,		0x00000000,
+				   MGA_FXRIGHT,		0x00000001,
+				   MGA_DWGCTL,		MGA_DWGCTL_FLUSH );
+
+			DMA_BLOCK( MGA_LEN + MGA_EXEC,	0x00000001,
+				   MGA_DWGSYNC,		0x00007000,
+				   MGA_TEXCTL2,		MGA_G400_TC2_MAGIC,
+				   MGA_LEN + MGA_EXEC,	0x00000000 );
+
+			DMA_BLOCK( MGA_TEXCTL2,		(MGA_DUALTEX |
+							 MGA_G400_TC2_MAGIC),
+				   MGA_LEN + MGA_EXEC,	0x00000000,
+				   MGA_TEXCTL2,		MGA_G400_TC2_MAGIC,
+				   MGA_DMAPAD,		0x00000000 );
 		}
 
-		PRIMOUTREG(MGAREG_WVRTXSZ, 0x00001807);
-		PRIMOUTREG(MGAREG_DMAPAD, 0);
-		PRIMOUTREG(MGAREG_DMAPAD, 0);
-		PRIMOUTREG(MGAREG_DMAPAD, 0);
+		DMA_BLOCK( MGA_WVRTXSZ,		0x00001807,
+			   MGA_DMAPAD,		0x00000000,
+			   MGA_DMAPAD,		0x00000000,
+			   MGA_DMAPAD,		0x00000000 );
 
-		PRIMOUTREG(MGAREG_WACCEPTSEQ, 0);
-		PRIMOUTREG(MGAREG_WACCEPTSEQ, 0);
-		PRIMOUTREG(MGAREG_WACCEPTSEQ, 0);
-		PRIMOUTREG(MGAREG_WACCEPTSEQ, 0x18000000);
+		DMA_BLOCK( MGA_WACCEPTSEQ,	0x00000000,
+			   MGA_WACCEPTSEQ,	0x00000000,
+			   MGA_WACCEPTSEQ,	0x00000000,
+			   MGA_WACCEPTSEQ,	0x18000000 );
 	}
 
-	PRIMOUTREG(MGAREG_WFLAG, 0);
-	PRIMOUTREG(MGAREG_WFLAG1, 0);
-	PRIMOUTREG(MGAREG_WR56, MAGIC_FPARAM_HEX_VALUE);
-	PRIMOUTREG(MGAREG_DMAPAD, 0);
-
-        PRIMOUTREG(MGAREG_WR49, 0);     /* Tex stage 0 */
-        PRIMOUTREG(MGAREG_WR57, 0);     /* Tex stage 0 */
-        PRIMOUTREG(MGAREG_WR53, 0);     /* Tex stage 1 */
-        PRIMOUTREG(MGAREG_WR61, 0);     /* Tex stage 1 */
-
-
-        PRIMOUTREG(MGAREG_WR54, 0x40);  /* Tex stage 0 : w */
-        PRIMOUTREG(MGAREG_WR62, 0x40);  /* Tex stage 0 : h */
-        PRIMOUTREG(MGAREG_WR52, 0x40);  /* Tex stage 1 : w */
-        PRIMOUTREG(MGAREG_WR60, 0x40);  /* Tex stage 1 : h */
-
-
-	/* Dma pading required due to hw bug */
-	PRIMOUTREG(MGAREG_DMAPAD, 0xffffffff);
-	PRIMOUTREG(MGAREG_DMAPAD, 0xffffffff);
-	PRIMOUTREG(MGAREG_DMAPAD, 0xffffffff);
-	PRIMOUTREG(MGAREG_WIADDR2,
-		   (u32) (dev_priv->WarpIndex[pipe].
-			  phys_addr | WIA_wmode_start | WIA_wagp_agp));
-	PRIMADVANCE(dev_priv);
+	DMA_BLOCK( MGA_WFLAG,	0x00000000,
+		   MGA_WFLAG1,	0x00000000,
+		   MGA_WR56,	MGA_G400_WR56_MAGIC,
+		   MGA_DMAPAD,	0x00000000 );
+
+	DMA_BLOCK( MGA_WR49,	0x00000000,		/* tex0              */
+		   MGA_WR57,	0x00000000,		/* tex0              */
+		   MGA_WR53,	0x00000000,		/* tex1              */
+		   MGA_WR61,	0x00000000 );		/* tex1              */
+
+	DMA_BLOCK( MGA_WR54,	MGA_G400_WR_MAGIC,	/* tex0 width        */
+		   MGA_WR62,	MGA_G400_WR_MAGIC,	/* tex0 height       */
+		   MGA_WR52,	MGA_G400_WR_MAGIC,	/* tex1 width        */
+		   MGA_WR60,	MGA_G400_WR_MAGIC );	/* tex1 height       */
+
+	/* Padding required to to hardware bug */
+	DMA_BLOCK( MGA_DMAPAD,	0xffffffff,
+		   MGA_DMAPAD,	0xffffffff,
+		   MGA_DMAPAD,	0xffffffff,
+		   MGA_WIADDR2,	(dev_priv->warp_pipe_phys[pipe] |
+				 MGA_WMODE_START |
+				 MGA_WAGP_ENABLE) );
+
+	ADVANCE_DMA();
 }
 
-static void mgaG200EmitPipe(drm_mga_private_t * dev_priv)
+static void mga_g200_emit_state( drm_mga_private_t *dev_priv )
 {
 	drm_mga_sarea_t *sarea_priv = dev_priv->sarea_priv;
-	unsigned int pipe = sarea_priv->WarpPipe;
-	PRIMLOCALS;
-	DRM_DEBUG("%s\n", __FUNCTION__);
-
-	PRIMGETPTR(dev_priv);
-
-	/* This takes 15 dwords */
-
-	PRIMOUTREG(MGAREG_WIADDR, WIA_wmode_suspend);
-	PRIMOUTREG(MGAREG_WVRTXSZ, 7);
-	PRIMOUTREG(MGAREG_WFLAG, 0);
-	PRIMOUTREG(MGAREG_WR24, 0);     /* tex w/h */
+	unsigned int dirty = sarea_priv->dirty;
 
-        PRIMOUTREG(MGAREG_WR25, 0x100);
-        PRIMOUTREG(MGAREG_WR34, 0);     /* tex w/h */
-        PRIMOUTREG(MGAREG_WR42, 0xFFFF);
-        PRIMOUTREG(MGAREG_WR60, 0xFFFF);
+	if ( sarea_priv->warp_pipe != dev_priv->warp_pipe ) {
+		mga_g200_emit_pipe( dev_priv );
+		dev_priv->warp_pipe = sarea_priv->warp_pipe;
+	}
 
-	/* Dma pading required due to hw bug */
-	PRIMOUTREG(MGAREG_DMAPAD, 0xffffffff);
-	PRIMOUTREG(MGAREG_DMAPAD, 0xffffffff);
-	PRIMOUTREG(MGAREG_DMAPAD, 0xffffffff);
-	PRIMOUTREG(MGAREG_WIADDR,
-		   (u32) (dev_priv->WarpIndex[pipe].
-			  phys_addr | WIA_wmode_start | WIA_wagp_agp));
+	if ( dirty & MGA_UPLOAD_CONTEXT ) {
+		mga_g200_emit_context( dev_priv );
+		sarea_priv->dirty &= ~MGA_UPLOAD_CONTEXT;
+	}
 
-	PRIMADVANCE(dev_priv);
+	if ( dirty & MGA_UPLOAD_TEX0 ) {
+		mga_g200_emit_tex0( dev_priv );
+		sarea_priv->dirty &= ~MGA_UPLOAD_TEX0;
+	}
 }
 
-static void mgaEmitState(drm_mga_private_t * dev_priv)
+static void mga_g400_emit_state( drm_mga_private_t *dev_priv )
 {
 	drm_mga_sarea_t *sarea_priv = dev_priv->sarea_priv;
 	unsigned int dirty = sarea_priv->dirty;
-	DRM_DEBUG("%s\n", __FUNCTION__);
-
-	if (dev_priv->chipset == MGA_CARD_TYPE_G400) {
-		int multitex = sarea_priv->WarpPipe & MGA_T2;
-
-		if (sarea_priv->WarpPipe != dev_priv->WarpPipe) {
-			mgaG400EmitPipe(dev_priv);
-			dev_priv->WarpPipe = sarea_priv->WarpPipe;
-		}
-
-		if (dirty & MGA_UPLOAD_CTX) {
-			mgaEmitContext(dev_priv);
-			sarea_priv->dirty &= ~MGA_UPLOAD_CTX;
-		}
+	int multitex = sarea_priv->warp_pipe & MGA_T2;
 
-		if (dirty & MGA_UPLOAD_TEX0) {
-			mgaG400EmitTex0(dev_priv);
-			sarea_priv->dirty &= ~MGA_UPLOAD_TEX0;
-		}
+	if ( sarea_priv->warp_pipe != dev_priv->warp_pipe ) {
+		mga_g400_emit_pipe( dev_priv );
+		dev_priv->warp_pipe = sarea_priv->warp_pipe;
+	}
 
-		if ((dirty & MGA_UPLOAD_TEX1) && multitex) {
-			mgaG400EmitTex1(dev_priv);
-			sarea_priv->dirty &= ~MGA_UPLOAD_TEX1;
-		}
-	} else {
-		if (sarea_priv->WarpPipe != dev_priv->WarpPipe) {
-			mgaG200EmitPipe(dev_priv);
-			dev_priv->WarpPipe = sarea_priv->WarpPipe;
-		}
+	if ( dirty & MGA_UPLOAD_CONTEXT ) {
+		mga_g400_emit_context( dev_priv );
+		sarea_priv->dirty &= ~MGA_UPLOAD_CONTEXT;
+	}
 
-		if (dirty & MGA_UPLOAD_CTX) {
-			mgaEmitContext(dev_priv);
-			sarea_priv->dirty &= ~MGA_UPLOAD_CTX;
-		}
+	if ( dirty & MGA_UPLOAD_TEX0 ) {
+		mga_g400_emit_tex0( dev_priv );
+		sarea_priv->dirty &= ~MGA_UPLOAD_TEX0;
+	}
 
-		if (dirty & MGA_UPLOAD_TEX0) {
-			mgaG200EmitTex(dev_priv);
-			sarea_priv->dirty &= ~MGA_UPLOAD_TEX0;
-		}
+	if ( (dirty & MGA_UPLOAD_TEX1) && multitex ) {
+		mga_g400_emit_tex1( dev_priv );
+		sarea_priv->dirty &= ~MGA_UPLOAD_TEX1;
 	}
 }
 
 
+/* ================================================================
+ * SAREA state verification
+ */
+
 /* Disallow all write destinations except the front and backbuffer.
  */
-static int mgaVerifyContext(drm_mga_private_t * dev_priv)
+static int mga_verify_context( drm_mga_private_t *dev_priv )
 {
 	drm_mga_sarea_t *sarea_priv = dev_priv->sarea_priv;
-	unsigned int *regs = sarea_priv->ContextState;
-
-	DRM_DEBUG("%s\n", __FUNCTION__);
-
-	if (regs[MGA_CTXREG_DSTORG] != dev_priv->frontOffset &&
-	    regs[MGA_CTXREG_DSTORG] != dev_priv->backOffset) {
-		DRM_DEBUG("BAD DSTORG: %x (front %x, back %x)\n\n",
-			  regs[MGA_CTXREG_DSTORG], dev_priv->frontOffset,
-			  dev_priv->backOffset);
-		regs[MGA_CTXREG_DSTORG] = 0;
-		return -1;
+	drm_mga_context_regs_t *ctx = &sarea_priv->context_state;
+
+	if ( ctx->dstorg != dev_priv->front_offset &&
+	     ctx->dstorg != dev_priv->back_offset ) {
+		DRM_ERROR( "*** bad DSTORG: %x (front %x, back %x)\n\n",
+			   ctx->dstorg, dev_priv->front_offset,
+			   dev_priv->back_offset );
+		ctx->dstorg = 0;
+		DRM_OS_RETURN( EINVAL );
 	}
 
 	return 0;
@@ -443,667 +420,647 @@ static int mgaVerifyContext(drm_mga_private_t * dev_priv)
 
 /* Disallow texture reads from PCI space.
  */
-static int mgaVerifyTex(drm_mga_private_t * dev_priv, int unit)
+static int mga_verify_tex( drm_mga_private_t *dev_priv, int unit )
 {
 	drm_mga_sarea_t *sarea_priv = dev_priv->sarea_priv;
+	drm_mga_texture_regs_t *tex = &sarea_priv->tex_state[unit];
+	unsigned int org;
 
-	DRM_DEBUG("%s\n", __FUNCTION__);
+	org = tex->texorg & (MGA_TEXORGMAP_MASK | MGA_TEXORGACC_MASK);
 
-	if ((sarea_priv->TexState[unit][MGA_TEXREG_ORG] & 0x3) == 0x1) {
-		DRM_DEBUG("BAD TEXREG_ORG: %x, unit %d\n",
-			  sarea_priv->TexState[unit][MGA_TEXREG_ORG],
-			  unit);
-		sarea_priv->TexState[unit][MGA_TEXREG_ORG] = 0;
-		return -1;
+	if ( org == (MGA_TEXORGMAP_SYSMEM | MGA_TEXORGACC_PCI) ) {
+		DRM_ERROR( "*** bad TEXORG: 0x%x, unit %d\n",
+			   tex->texorg, unit );
+		tex->texorg = 0;
+		DRM_OS_RETURN( EINVAL );
 	}
 
 	return 0;
 }
 
-static int mgaVerifyState(drm_mga_private_t * dev_priv)
+static int mga_verify_state( drm_mga_private_t *dev_priv )
 {
 	drm_mga_sarea_t *sarea_priv = dev_priv->sarea_priv;
 	unsigned int dirty = sarea_priv->dirty;
-	int rv = 0;
-
-	DRM_DEBUG("%s\n", __FUNCTION__);
+	int ret = 0;
 
-	if (sarea_priv->nbox > MGA_NR_SAREA_CLIPRECTS)
+	if ( sarea_priv->nbox > MGA_NR_SAREA_CLIPRECTS )
 		sarea_priv->nbox = MGA_NR_SAREA_CLIPRECTS;
 
-	if (dirty & MGA_UPLOAD_CTX)
-		rv |= mgaVerifyContext(dev_priv);
+	if ( dirty & MGA_UPLOAD_CONTEXT )
+		ret |= mga_verify_context( dev_priv );
 
-	if (dirty & MGA_UPLOAD_TEX0)
-		rv |= mgaVerifyTex(dev_priv, 0);
+	if ( dirty & MGA_UPLOAD_TEX0 )
+		ret |= mga_verify_tex( dev_priv, 0 );
 
-	if (dev_priv->chipset == MGA_CARD_TYPE_G400) {
-		if (dirty & MGA_UPLOAD_TEX1)
-			rv |= mgaVerifyTex(dev_priv, 1);
+	if ( dev_priv->chipset == MGA_CARD_TYPE_G400 ) {
+		if ( dirty & MGA_UPLOAD_TEX1 )
+			ret |= mga_verify_tex( dev_priv, 1 );
 
-		if (dirty & MGA_UPLOAD_PIPE)
-			rv |= (sarea_priv->WarpPipe > MGA_MAX_G400_PIPES);
+		if ( dirty & MGA_UPLOAD_PIPE )
+			ret |= ( sarea_priv->warp_pipe > MGA_MAX_G400_PIPES );
 	} else {
-		if (dirty & MGA_UPLOAD_PIPE)
-			rv |= (sarea_priv->WarpPipe > MGA_MAX_G200_PIPES);
+		if ( dirty & MGA_UPLOAD_PIPE )
+			ret |= ( sarea_priv->warp_pipe > MGA_MAX_G200_PIPES );
 	}
 
-	return rv == 0;
+	return ( ret == 0 );
 }
 
-static int mgaVerifyIload(drm_mga_private_t * dev_priv,
-			  unsigned long bus_address,
-			  unsigned int dstOrg, int length)
+static int mga_verify_iload( drm_mga_private_t *dev_priv,
+			     unsigned int dstorg, unsigned int length )
 {
-	DRM_DEBUG("%s\n", __FUNCTION__);
+	if ( dstorg < dev_priv->texture_offset ||
+	     dstorg + length > (dev_priv->texture_offset +
+				dev_priv->texture_size) ) {
+		DRM_ERROR( "*** bad iload DSTORG: 0x%x\n", dstorg );
+		DRM_OS_RETURN( EINVAL );
+	}
 
-	if (dstOrg < dev_priv->textureOffset ||
-	    dstOrg + length >
-	    (dev_priv->textureOffset + dev_priv->textureSize)) {
-		return EINVAL;
+	if ( length & MGA_ILOAD_MASK ) {
+		DRM_ERROR( "*** bad iload length: 0x%x\n",
+			   length & MGA_ILOAD_MASK );
+		DRM_OS_RETURN( EINVAL );
 	}
-	if (length % 64) {
-		return EINVAL;
+
+	return 0;
+}
+
+static int mga_verify_blit( drm_mga_private_t *dev_priv,
+			    unsigned int srcorg, unsigned int dstorg )
+{
+	if ( (srcorg & 0x3) == (MGA_SRCACC_PCI | MGA_SRCMAP_SYSMEM) ||
+	     (dstorg & 0x3) == (MGA_SRCACC_PCI | MGA_SRCMAP_SYSMEM) ) {
+		DRM_ERROR( "*** bad blit: src=0x%x dst=0x%x\n",
+			   srcorg, dstorg );
+		DRM_OS_RETURN( EINVAL );
 	}
 	return 0;
 }
 
-/* This copies a 64 byte aligned agp region to the frambuffer
- * with a standard blit, the ioctl needs to do checking */
 
-static void mga_dma_dispatch_tex_blit(drm_device_t * dev,
-				      unsigned long bus_address,
-				      int length, unsigned int destOrg)
+/* ================================================================
+ *
+ */
+
+static void mga_dma_dispatch_clear( drm_device_t *dev,
+				    drm_mga_clear_t *clear )
 {
 	drm_mga_private_t *dev_priv = dev->dev_private;
-	int use_agp = PDEA_pagpxfer_enable | 0x00000001;
-	u16 y2;
-	PRIMLOCALS;
-	DRM_DEBUG("%s\n", __FUNCTION__);
+	drm_mga_sarea_t *sarea_priv = dev_priv->sarea_priv;
+	drm_mga_context_regs_t *ctx = &sarea_priv->context_state;
+	drm_clip_rect_t *pbox = sarea_priv->boxes;
+	int nbox = sarea_priv->nbox;
+	int i;
+	DMA_LOCALS;
+	DRM_DEBUG( __FUNCTION__ ":\n" );
 
-	y2 = length / 64;
+	BEGIN_DMA( 1 );
 
-	PRIM_OVERFLOW(dev, dev_priv, 30);
+	DMA_BLOCK( MGA_DMAPAD,	0x00000000,
+		   MGA_DMAPAD,	0x00000000,
+		   MGA_DWGSYNC,	0x00007100,
+		   MGA_DWGSYNC,	0x00007000 );
 
-	PRIMOUTREG(MGAREG_DSTORG, destOrg);
-	PRIMOUTREG(MGAREG_MACCESS, 0x00000000);
-	DRM_DEBUG("srcorg : %lx\n", bus_address | use_agp);
-	PRIMOUTREG(MGAREG_SRCORG, (u32) bus_address | use_agp);
-	PRIMOUTREG(MGAREG_AR5, 64);
+	ADVANCE_DMA();
 
-	PRIMOUTREG(MGAREG_PITCH, 64);
-	PRIMOUTREG(MGAREG_DMAPAD, 0);
-	PRIMOUTREG(MGAREG_DMAPAD, 0);
-	PRIMOUTREG(MGAREG_DWGCTL, MGA_COPY_CMD);
+	for ( i = 0 ; i < nbox ; i++ ) {
+		drm_clip_rect_t *box = &pbox[i];
+		u32 height = box->y2 - box->y1;
 
-	PRIMOUTREG(MGAREG_AR0, 63);
-	PRIMOUTREG(MGAREG_AR3, 0);
-	PRIMOUTREG(MGAREG_FXBNDRY, (63 << 16));
-	PRIMOUTREG(MGAREG_YDSTLEN + MGAREG_MGA_EXEC, y2);
+		DRM_DEBUG( "   from=%d,%d to=%d,%d\n",
+			   box->x1, box->y1, box->x2, box->y2 );
 
-	PRIMOUTREG(MGAREG_DMAPAD, 0);
-	PRIMOUTREG(MGAREG_SRCORG, 0);
-	PRIMOUTREG(MGAREG_PITCH, dev_priv->stride / dev_priv->cpp);
-	PRIMOUTREG(MGAREG_DWGSYNC, 0x7000);
+		if ( clear->flags & MGA_FRONT ) {
+			BEGIN_DMA( 2 );
 
-	PRIMADVANCE(dev_priv);
-}
+			DMA_BLOCK( MGA_DMAPAD,	0x00000000,
+				   MGA_PLNWT,	clear->color_mask,
+				   MGA_YDSTLEN, (box->y1 << 16) | height,
+				   MGA_FXBNDRY, (box->x2 << 16) | box->x1 );
 
-static void mga_dma_dispatch_vertex(drm_device_t * dev, drm_buf_t * buf)
-{
-	drm_mga_private_t *dev_priv = dev->dev_private;
-	drm_mga_buf_priv_t *buf_priv = buf->dev_private;
-	drm_mga_sarea_t *sarea_priv = dev_priv->sarea_priv;
-	unsigned long address = (unsigned long) buf->bus_address;
-	int length = buf->used;
-	int use_agp = PDEA_pagpxfer_enable;
-	int i = 0;
-	PRIMLOCALS;
-	DRM_DEBUG("%s\n", __FUNCTION__);
+			DMA_BLOCK( MGA_DMAPAD,	0x00000000,
+				   MGA_FCOL,	clear->clear_color,
+				   MGA_DSTORG,	dev_priv->front_offset,
+				   MGA_DWGCTL + MGA_EXEC,
+						dev_priv->clear_cmd );
 
-	DRM_DEBUG("dispatch vertex %d addr 0x%lx, "
-		  "length 0x%x nbox %d dirty %x\n",
-		  buf->idx, address, length,
-		  sarea_priv->nbox, sarea_priv->dirty);
+			ADVANCE_DMA();
+		}
 
-	DRM_DEBUG("used : %d, total : %d\n", buf->used, buf->total);
 
-	if (buf->used) {
-		/* WARNING: if you change any of the state functions verify
-		 * these numbers (Overestimating this doesn't hurt).  
-		 */
-		buf_priv->dispatched = 1;
-		PRIM_OVERFLOW(dev, dev_priv,
-			      (MAX_STATE_SIZE + (5 * MGA_NR_SAREA_CLIPRECTS)));
-		mgaEmitState(dev_priv);
+		if ( clear->flags & MGA_BACK ) {
+			BEGIN_DMA( 2 );
 
-#if 0
-                length = dev_priv->vertexsize * 3 * 4;
-#endif
+			DMA_BLOCK( MGA_DMAPAD,	0x00000000,
+				   MGA_PLNWT,	clear->color_mask,
+				   MGA_YDSTLEN, (box->y1 << 16) | height,
+				   MGA_FXBNDRY, (box->x2 << 16) | box->x1 );
 
+			DMA_BLOCK( MGA_DMAPAD,	0x00000000,
+				   MGA_FCOL,	clear->clear_color,
+				   MGA_DSTORG,	dev_priv->back_offset,
+				   MGA_DWGCTL + MGA_EXEC,
+						dev_priv->clear_cmd );
 
+			ADVANCE_DMA();
+		}
 
-		do {
-			if (i < sarea_priv->nbox) {
-				DRM_DEBUG("idx %d Emit box %d/%d:"
-					  "%d,%d - %d,%d\n",
-					  buf->idx,
-					  i, sarea_priv->nbox,
-					  sarea_priv->boxes[i].x1,
-					  sarea_priv->boxes[i].y1,
-					  sarea_priv->boxes[i].x2,
-					  sarea_priv->boxes[i].y2);
-
-				mgaEmitClipRect(dev_priv,
-						&sarea_priv->boxes[i]);
-			}
+		if ( clear->flags & MGA_DEPTH ) {
+			BEGIN_DMA( 2 );
 
-			PRIMGETPTR(dev_priv);
-			PRIMOUTREG(MGAREG_DMAPAD, 0);
-			PRIMOUTREG(MGAREG_DMAPAD, 0);
-			PRIMOUTREG(MGAREG_SECADDRESS,
-				   ((u32) address) | TT_VERTEX);
-			PRIMOUTREG(MGAREG_SECEND,
-				   (((u32) (address + length)) | use_agp));
-			PRIMADVANCE(dev_priv);
-		} while (++i < sarea_priv->nbox);
-	}
+			DMA_BLOCK( MGA_DMAPAD,	0x00000000,
+				   MGA_PLNWT,	clear->depth_mask,
+				   MGA_YDSTLEN, (box->y1 << 16) | height,
+				   MGA_FXBNDRY, (box->x2 << 16) | box->x1 );
+
+			DMA_BLOCK( MGA_DMAPAD,	0x00000000,
+				   MGA_FCOL,	clear->clear_depth,
+				   MGA_DSTORG,	dev_priv->depth_offset,
+				   MGA_DWGCTL + MGA_EXEC,
+						dev_priv->clear_cmd );
+
+			ADVANCE_DMA();
+		}
 
-	if (buf_priv->discard) {
-		if (buf_priv->dispatched == 1)
-			AGEBUF(dev_priv, buf_priv);
-		buf_priv->dispatched = 0;
-		mga_freelist_put(dev, buf);
 	}
 
+	BEGIN_DMA( 1 );
+
+	/* Force reset of DWGCTL */
+	DMA_BLOCK( MGA_DMAPAD,	0x00000000,
+		   MGA_DMAPAD,	0x00000000,
+		   MGA_PLNWT,	ctx->plnwt,
+		   MGA_DWGCTL,	ctx->dwgctl );
+
+	ADVANCE_DMA();
 
+	FLUSH_DMA();
 }
 
+static void mga_dma_dispatch_swap( drm_device_t *dev )
+{
+	drm_mga_private_t *dev_priv = dev->dev_private;
+	drm_mga_sarea_t *sarea_priv = dev_priv->sarea_priv;
+	drm_mga_context_regs_t *ctx = &sarea_priv->context_state;
+	drm_clip_rect_t *pbox = sarea_priv->boxes;
+	int nbox = sarea_priv->nbox;
+	int i;
+	DMA_LOCALS;
+	DRM_DEBUG( __FUNCTION__ ":\n" );
+
+	sarea_priv->last_frame.head = dev_priv->prim.tail;
+	sarea_priv->last_frame.wrap = dev_priv->prim.last_wrap;
+
+	BEGIN_DMA( 4 + nbox );
+
+	DMA_BLOCK( MGA_DMAPAD,	0x00000000,
+		   MGA_DMAPAD,	0x00000000,
+		   MGA_DWGSYNC,	0x00007100,
+		   MGA_DWGSYNC,	0x00007000 );
+
+	DMA_BLOCK( MGA_DSTORG,	dev_priv->front_offset,
+		   MGA_MACCESS,	dev_priv->maccess,
+		   MGA_SRCORG,	dev_priv->back_offset,
+		   MGA_AR5,	dev_priv->front_pitch );
+
+	DMA_BLOCK( MGA_DMAPAD,	0x00000000,
+		   MGA_DMAPAD,	0x00000000,
+		   MGA_PLNWT,	0xffffffff,
+		   MGA_DWGCTL,	MGA_DWGCTL_COPY );
+
+	for ( i = 0 ; i < nbox ; i++ ) {
+		drm_clip_rect_t *box = &pbox[i];
+		u32 height = box->y2 - box->y1;
+		u32 start = box->y1 * dev_priv->front_pitch;
+
+		DRM_DEBUG( "   from=%d,%d to=%d,%d\n",
+			   box->x1, box->y1, box->x2, box->y2 );
+
+		DMA_BLOCK( MGA_AR0,	start + box->x2 - 1,
+			   MGA_AR3,	start + box->x1,
+			   MGA_FXBNDRY,	((box->x2 - 1) << 16) | box->x1,
+			   MGA_YDSTLEN + MGA_EXEC,
+					(box->y1 << 16) | height );
+	}
 
-static void mga_dma_dispatch_indices(drm_device_t * dev,
-				     drm_buf_t * buf,
-				     unsigned int start, unsigned int end)
+	DMA_BLOCK( MGA_DMAPAD,	0x00000000,
+		   MGA_PLNWT,	ctx->plnwt,
+		   MGA_SRCORG,	dev_priv->front_offset,
+		   MGA_DWGCTL,	ctx->dwgctl );
+
+	ADVANCE_DMA();
+
+	FLUSH_DMA();
+
+	DRM_DEBUG( "%s... done.\n", __FUNCTION__ );
+}
+
+static void mga_dma_dispatch_vertex( drm_device_t *dev, drm_buf_t *buf )
 {
 	drm_mga_private_t *dev_priv = dev->dev_private;
 	drm_mga_buf_priv_t *buf_priv = buf->dev_private;
 	drm_mga_sarea_t *sarea_priv = dev_priv->sarea_priv;
-	unsigned int address = (unsigned int) buf->bus_address;
-	int use_agp = PDEA_pagpxfer_enable;
+	u32 address = (u32) buf->bus_address;
+	u32 length = (u32) buf->used;
 	int i = 0;
-	PRIMLOCALS;
-	DRM_DEBUG("%s\n", __FUNCTION__);
-
-	DRM_DEBUG("dispatch indices %d addr 0x%x, "
-		  "start 0x%x end 0x%x nbox %d dirty %x\n",
-		  buf->idx, address, start, end,
-		  sarea_priv->nbox, sarea_priv->dirty);
-
-	if (start != end) {
-		/* WARNING: if you change any of the state functions verify
-		 * these numbers (Overestimating this doesn't hurt).  
-		 */
+	DMA_LOCALS;
+	DRM_DEBUG( "vertex: buf=%d used=%d\n", buf->idx, buf->used );
+
+	if ( buf->used ) {
 		buf_priv->dispatched = 1;
-                PRIM_OVERFLOW(dev, dev_priv,
-                              (MAX_STATE_SIZE + (5 * MGA_NR_SAREA_CLIPRECTS)));
 
-		mgaEmitState(dev_priv);
+		MGA_EMIT_STATE( dev_priv, sarea_priv->dirty );
 
 		do {
-			if (i < sarea_priv->nbox) {
-				DRM_DEBUG("idx %d Emit box %d/%d:"
-					  "%d,%d - %d,%d\n",
-					  buf->idx,
-					  i, sarea_priv->nbox,
-					  sarea_priv->boxes[i].x1,
-					  sarea_priv->boxes[i].y1,
-					  sarea_priv->boxes[i].x2,
-					  sarea_priv->boxes[i].y2);
-
-				mgaEmitClipRect(dev_priv,
-						&sarea_priv->boxes[i]);
+			if ( i < sarea_priv->nbox ) {
+				mga_emit_clip_rect( dev_priv,
+						    &sarea_priv->boxes[i] );
 			}
 
-			PRIMGETPTR(dev_priv);
-			PRIMOUTREG(MGAREG_DMAPAD, 0);
-			PRIMOUTREG(MGAREG_DMAPAD, 0);
-			PRIMOUTREG(MGAREG_SETUPADDRESS,
-				   ((address + start) |
-				    SETADD_mode_vertlist));
-			PRIMOUTREG(MGAREG_SETUPEND,
-				   ((address + end) | use_agp));
-				  
-			PRIMADVANCE(dev_priv);
-		} while (++i < sarea_priv->nbox);
+			BEGIN_DMA( 1 );
+
+			DMA_BLOCK( MGA_DMAPAD,		0x00000000,
+				   MGA_DMAPAD,		0x00000000,
+				   MGA_SECADDRESS,	(address |
+							 MGA_DMA_VERTEX),
+				   MGA_SECEND,		((address + length) |
+							 MGA_PAGPXFER) );
+
+			ADVANCE_DMA();
+		} while ( ++i < sarea_priv->nbox );
 	}
-	if (buf_priv->discard) {
-		if (buf_priv->dispatched == 1)
-			AGEBUF(dev_priv, buf_priv);
+
+	if ( buf_priv->discard ) {
+		AGE_BUFFER( buf_priv );
+		buf->pending = 0;
+		buf->used = 0;
 		buf_priv->dispatched = 0;
-		mga_freelist_put(dev, buf);
-	}
-}
 
+		mga_freelist_put( dev, buf );
+	}
 
-static void mga_dma_dispatch_clear(drm_device_t * dev, int flags,
-				   unsigned int clear_color,
-                                   unsigned int clear_zval,
-                                   unsigned int clear_colormask,
-                                   unsigned int clear_depthmask)
+	FLUSH_DMA();
+}
 
+static void mga_dma_dispatch_indices( drm_device_t *dev, drm_buf_t *buf,
+				      unsigned int start, unsigned int end )
 {
 	drm_mga_private_t *dev_priv = dev->dev_private;
+	drm_mga_buf_priv_t *buf_priv = buf->dev_private;
 	drm_mga_sarea_t *sarea_priv = dev_priv->sarea_priv;
-	unsigned int *regs = sarea_priv->ContextState;
-	int nbox = sarea_priv->nbox;
-	drm_clip_rect_t *pbox = sarea_priv->boxes;
-	unsigned int cmd;
-	int i;
-	PRIMLOCALS;
-	DRM_DEBUG("%s\n", __FUNCTION__);
-
-	if (dev_priv->sgram)
-		cmd = MGA_CLEAR_CMD | DC_atype_blk;
-	else
-		cmd = MGA_CLEAR_CMD | DC_atype_rstr;
-
-	PRIM_OVERFLOW(dev, dev_priv, 35 * MGA_NR_SAREA_CLIPRECTS);
-
-	for (i = 0; i < nbox; i++) {
-		unsigned int height = pbox[i].y2 - pbox[i].y1;
-
-		DRM_DEBUG("dispatch clear %d,%d-%d,%d flags %x!\n",
-			  pbox[i].x1, pbox[i].y1, pbox[i].x2,
-			  pbox[i].y2, flags);
-
-		if (flags & MGA_FRONT) {
-			DRM_DEBUG("clear front\n");
-			PRIMOUTREG(MGAREG_DMAPAD, 0);
-			PRIMOUTREG(MGAREG_PLNWT, clear_colormask);
-			PRIMOUTREG(MGAREG_YDSTLEN,
-				   (pbox[i].y1 << 16) | height);
-			PRIMOUTREG(MGAREG_FXBNDRY,
-				   (pbox[i].x2 << 16) | pbox[i].x1);
-
-			PRIMOUTREG(MGAREG_DMAPAD, 0);
-			PRIMOUTREG(MGAREG_FCOL, clear_color);
-			PRIMOUTREG(MGAREG_DSTORG, dev_priv->frontOffset);
-			PRIMOUTREG(MGAREG_DWGCTL + MGAREG_MGA_EXEC, cmd);
-		}
+	u32 address = (u32) buf->bus_address;
+	int i = 0;
+	DMA_LOCALS;
+	DRM_DEBUG( "indices: buf=%d start=%d end=%d\n", buf->idx, start, end );
 
-		if (flags & MGA_BACK) {
-			DRM_DEBUG("clear back\n");
-			PRIMOUTREG(MGAREG_DMAPAD, 0);
-			PRIMOUTREG(MGAREG_PLNWT, clear_colormask);
-			PRIMOUTREG(MGAREG_YDSTLEN,
-				   (pbox[i].y1 << 16) | height);
-			PRIMOUTREG(MGAREG_FXBNDRY,
-				   (pbox[i].x2 << 16) | pbox[i].x1);
-
-			PRIMOUTREG(MGAREG_DMAPAD, 0);
-			PRIMOUTREG(MGAREG_FCOL, clear_color);
-			PRIMOUTREG(MGAREG_DSTORG, dev_priv->backOffset);
-			PRIMOUTREG(MGAREG_DWGCTL + MGAREG_MGA_EXEC, cmd);
-		}
+	if ( start != end ) {
+		buf_priv->dispatched = 1;
 
-		if (flags & MGA_DEPTH) {
-			DRM_DEBUG("clear depth\n");
-			PRIMOUTREG(MGAREG_DMAPAD, 0);
-			PRIMOUTREG(MGAREG_PLNWT, clear_depthmask);
-			PRIMOUTREG(MGAREG_YDSTLEN,
-				   (pbox[i].y1 << 16) | height);
-			PRIMOUTREG(MGAREG_FXBNDRY,
-				   (pbox[i].x2 << 16) | pbox[i].x1);
-
-			PRIMOUTREG(MGAREG_DMAPAD, 0);
-			PRIMOUTREG(MGAREG_FCOL, clear_zval);
-			PRIMOUTREG(MGAREG_DSTORG, dev_priv->depthOffset);
-			PRIMOUTREG(MGAREG_DWGCTL + MGAREG_MGA_EXEC, cmd);
-		}
+		MGA_EMIT_STATE( dev_priv, sarea_priv->dirty );
+
+		do {
+			if ( i < sarea_priv->nbox ) {
+				mga_emit_clip_rect( dev_priv,
+						    &sarea_priv->boxes[i] );
+			}
+
+			BEGIN_DMA( 1 );
+
+			DMA_BLOCK( MGA_DMAPAD,		0x00000000,
+				   MGA_DMAPAD,		0x00000000,
+				   MGA_SETUPADDRESS,	address + start,
+				   MGA_SETUPEND,	((address + end) |
+							 MGA_PAGPXFER) );
+
+			ADVANCE_DMA();
+		} while ( ++i < sarea_priv->nbox );
 	}
 
-	/* Force reset of DWGCTL */
-	PRIMOUTREG(MGAREG_DMAPAD, 0);
-	PRIMOUTREG(MGAREG_DMAPAD, 0);
-	PRIMOUTREG(MGAREG_DMAPAD, 0);
-	PRIMOUTREG(MGAREG_DWGCTL, regs[MGA_CTXREG_DWGCTL]);
-	PRIMADVANCE(dev_priv);
+	if ( buf_priv->discard ) {
+		AGE_BUFFER( buf_priv );
+		buf->pending = 0;
+		buf->used = 0;
+		buf_priv->dispatched = 0;
+
+		mga_freelist_put( dev, buf );
+	}
+
+	FLUSH_DMA();
 }
 
-static void mga_dma_dispatch_swap(drm_device_t * dev)
+/* This copies a 64 byte aligned agp region to the frambuffer with a
+ * standard blit, the ioctl needs to do checking.
+ */
+static void mga_dma_dispatch_iload( drm_device_t *dev, drm_buf_t *buf,
+				    unsigned int dstorg, unsigned int length )
 {
 	drm_mga_private_t *dev_priv = dev->dev_private;
-	drm_mga_sarea_t *sarea_priv = dev_priv->sarea_priv;
-	unsigned int *regs = sarea_priv->ContextState;
-	int nbox = sarea_priv->nbox;
-	drm_clip_rect_t *pbox = sarea_priv->boxes;
-	int i;
-	int pixel_stride = dev_priv->stride / dev_priv->cpp;
+	drm_mga_buf_priv_t *buf_priv = buf->dev_private;
+	drm_mga_context_regs_t *ctx = &dev_priv->sarea_priv->context_state;
+	u32 srcorg = buf->bus_address | MGA_SRCACC_AGP | MGA_SRCMAP_SYSMEM;
+	u32 y2;
+	DMA_LOCALS;
+	DRM_DEBUG( "%s: buf=%d used=%d\n",
+		   __FUNCTION__, buf->idx, buf->used );
 
-	PRIMLOCALS;
-	DRM_DEBUG("%s\n", __FUNCTION__);
+	y2 = length / 64;
 
-        PRIM_OVERFLOW(dev, dev_priv, (MGA_NR_SAREA_CLIPRECTS * 5) + 20);
+	BEGIN_DMA( 5 );
 
-        PRIMOUTREG(MGAREG_DMAPAD, 0);
-        PRIMOUTREG(MGAREG_DMAPAD, 0);
-        PRIMOUTREG(MGAREG_DWGSYNC, 0x7100);
-        PRIMOUTREG(MGAREG_DWGSYNC, 0x7000);
+	DMA_BLOCK( MGA_DMAPAD,	0x00000000,
+		   MGA_DMAPAD,	0x00000000,
+		   MGA_DWGSYNC,	0x00007100,
+		   MGA_DWGSYNC,	0x00007000 );
 
-	PRIMOUTREG(MGAREG_DSTORG, dev_priv->frontOffset);
-	PRIMOUTREG(MGAREG_MACCESS, dev_priv->mAccess);
-	PRIMOUTREG(MGAREG_SRCORG, dev_priv->backOffset);
-        PRIMOUTREG(MGAREG_AR5, pixel_stride);
+	DMA_BLOCK( MGA_DSTORG,	dstorg,
+		   MGA_MACCESS,	0x00000000,
+		   MGA_SRCORG,	srcorg,
+		   MGA_AR5,	64 );
 
-	PRIMOUTREG(MGAREG_DMAPAD, 0);
-	PRIMOUTREG(MGAREG_DMAPAD, 0);
-	PRIMOUTREG(MGAREG_DMAPAD, 0);
-	PRIMOUTREG(MGAREG_DWGCTL, MGA_COPY_CMD);
+	DMA_BLOCK( MGA_PITCH,	64,
+		   MGA_PLNWT,	0xffffffff,
+		   MGA_DMAPAD,	0x00000000,
+		   MGA_DWGCTL,	MGA_DWGCTL_COPY );
 
+	DMA_BLOCK( MGA_AR0,	63,
+		   MGA_AR3,	0,
+		   MGA_FXBNDRY,	(63 << 16) | 0,
+		   MGA_YDSTLEN + MGA_EXEC, y2 );
 
-	for (i = 0; i < nbox; i++) {
-		unsigned int h = pbox[i].y2 - pbox[i].y1;
-		unsigned int start = pbox[i].y1 * pixel_stride;
+	DMA_BLOCK( MGA_PLNWT,	ctx->plnwt,
+		   MGA_SRCORG,	dev_priv->front_offset,
+		   MGA_PITCH,	dev_priv->front_pitch,
+		   MGA_DWGSYNC,	0x00007000 );
 
-		PRIMOUTREG(MGAREG_AR0, start + pbox[i].x2 - 1);
-		PRIMOUTREG(MGAREG_AR3, start + pbox[i].x1);
-		PRIMOUTREG(MGAREG_FXBNDRY,
-			   pbox[i].x1 | ((pbox[i].x2 - 1) << 16));
-		PRIMOUTREG(MGAREG_YDSTLEN + MGAREG_MGA_EXEC,
-			   (pbox[i].y1 << 16) | h);
-	}
+	ADVANCE_DMA();
 
-	/* Force reset of DWGCTL */
-	PRIMOUTREG(MGAREG_DMAPAD, 0);
-	PRIMOUTREG(MGAREG_DMAPAD, 0);
-	PRIMOUTREG(MGAREG_SRCORG, 0);
-	PRIMOUTREG(MGAREG_DWGCTL, regs[MGA_CTXREG_DWGCTL]);
+	AGE_BUFFER( buf_priv );
+
+	buf->pending = 0;
+	buf->used = 0;
+	buf_priv->dispatched = 0;
 
-	PRIMADVANCE(dev_priv);
+	mga_freelist_put( dev, buf );
+
+	FLUSH_DMA();
 }
 
-int mga_clear_bufs(dev_t kdev, u_long cmd, caddr_t data,
-		   int flags, struct proc *p)
+static void mga_dma_dispatch_blit( drm_device_t *dev,
+				   drm_mga_blit_t *blit )
 {
-	drm_device_t *dev = kdev->si_drv1;
-	drm_mga_private_t *dev_priv =
-	    (drm_mga_private_t *) dev->dev_private;
+	drm_mga_private_t *dev_priv = dev->dev_private;
 	drm_mga_sarea_t *sarea_priv = dev_priv->sarea_priv;
-	drm_mga_clear_t clear;
-	int s;
+	drm_mga_context_regs_t *ctx = &sarea_priv->context_state;
+	drm_clip_rect_t *pbox = sarea_priv->boxes;
+	int nbox = sarea_priv->nbox;
+	u32 scandir = 0, i;
+	DMA_LOCALS;
+	DRM_DEBUG( __FUNCTION__ ":\n" );
+
+	BEGIN_DMA( 4 + nbox );
+
+	DMA_BLOCK( MGA_DMAPAD,	0x00000000,
+		   MGA_DMAPAD,	0x00000000,
+		   MGA_DWGSYNC,	0x00007100,
+		   MGA_DWGSYNC,	0x00007000 );
+
+	DMA_BLOCK( MGA_DWGCTL,	MGA_DWGCTL_COPY,
+		   MGA_PLNWT,	blit->planemask,
+		   MGA_SRCORG,	blit->srcorg,
+		   MGA_DSTORG,	blit->dstorg );
+
+	DMA_BLOCK( MGA_SGN,	scandir,
+		   MGA_MACCESS,	dev_priv->maccess,
+		   MGA_AR5,	blit->ydir * blit->src_pitch,
+		   MGA_PITCH,	blit->dst_pitch );
+
+	for ( i = 0 ; i < nbox ; i++ ) {
+		int srcx = pbox[i].x1 + blit->delta_sx;
+		int srcy = pbox[i].y1 + blit->delta_sy;
+		int dstx = pbox[i].x1 + blit->delta_dx;
+		int dsty = pbox[i].y1 + blit->delta_dy;
+		int h = pbox[i].y2 - pbox[i].y1;
+		int w = pbox[i].x2 - pbox[i].x1 - 1;
+		int start;
+
+		if ( blit->ydir == -1 ) {
+			srcy = blit->height - srcy - 1;
+		}
 
-	clear = *(drm_mga_clear_t *) data;
-	DRM_DEBUG("%s\n", __FUNCTION__);
+		start = srcy * blit->src_pitch + srcx;
 
-	if (!_DRM_LOCK_IS_HELD(dev->lock.hw_lock->lock)) {
-		DRM_ERROR("mga_clear_bufs called without lock held\n");
-		return EINVAL;
+		DMA_BLOCK( MGA_AR0,	start + w,
+			   MGA_AR3,	start,
+			   MGA_FXBNDRY,	((dstx + w) << 16) | (dstx & 0xffff),
+			   MGA_YDSTLEN + MGA_EXEC, (dsty << 16) | h );
 	}
 
-	if (sarea_priv->nbox > MGA_NR_SAREA_CLIPRECTS)
-		sarea_priv->nbox = MGA_NR_SAREA_CLIPRECTS;
-
-	/* Make sure we restore the 3D state next time.
+	/* Do something to flush AGP?
 	 */
-	dev_priv->sarea_priv->dirty |= MGA_UPLOAD_CTX;
-	mga_dma_dispatch_clear(dev, clear.flags,
-				clear.clear_color,
-                               clear.clear_depth,
-                               clear.clear_color_mask,
-                               clear.clear_depth_mask);
-	PRIMUPDATE(dev_priv);
-	mga_flush_write_combine();
-	s = splsofttq();
-	mga_dma_schedule(dev, 1);
-	splx(s);
-	return 0;
+
+	/* Force reset of DWGCTL */
+	DMA_BLOCK( MGA_DMAPAD,	0x00000000,
+		   MGA_PLNWT,	ctx->plnwt,
+		   MGA_PITCH,	dev_priv->front_pitch,
+		   MGA_DWGCTL,	ctx->dwgctl );
+
+	ADVANCE_DMA();
 }
 
-int mga_swap_bufs(dev_t kdev, u_long cmd, caddr_t data,
-		  int flags, struct proc *p)
+
+/* ================================================================
+ *
+ */
+
+int mga_dma_clear( DRM_OS_IOCTL )
 {
-	drm_device_t *dev = kdev->si_drv1;
-	drm_mga_private_t *dev_priv =
-	    (drm_mga_private_t *) dev->dev_private;
+	DRM_OS_DEVICE;
+	drm_mga_private_t *dev_priv = dev->dev_private;
 	drm_mga_sarea_t *sarea_priv = dev_priv->sarea_priv;
-	int s;
+	drm_mga_clear_t clear;
 
-	DRM_DEBUG("%s\n", __FUNCTION__);
+	LOCK_TEST_WITH_RETURN( dev );
 
-	if (!_DRM_LOCK_IS_HELD(dev->lock.hw_lock->lock)) {
-		DRM_ERROR("mga_swap_bufs called without lock held\n");
-		return EINVAL;
-	}
+	DRM_OS_KRNFROMUSR( clear, (drm_mga_clear_t *) data, sizeof(clear) );
 
-	if (sarea_priv->nbox > MGA_NR_SAREA_CLIPRECTS)
+	if ( sarea_priv->nbox > MGA_NR_SAREA_CLIPRECTS )
 		sarea_priv->nbox = MGA_NR_SAREA_CLIPRECTS;
 
+	WRAP_TEST_WITH_RETURN( dev_priv );
+
+	mga_dma_dispatch_clear( dev, &clear );
+
 	/* Make sure we restore the 3D state next time.
 	 */
-	dev_priv->sarea_priv->dirty |= MGA_UPLOAD_CTX;
-	mga_dma_dispatch_swap(dev);
-	PRIMUPDATE(dev_priv);
-	set_bit(MGA_BUF_SWAP_PENDING,
-		&dev_priv->current_prim->buffer_status);
-	mga_flush_write_combine();
-	s = splsofttq();
-	mga_dma_schedule(dev, 1);
-	splx(s);
+	dev_priv->sarea_priv->dirty |= MGA_UPLOAD_CONTEXT;
+
 	return 0;
 }
 
-int mga_iload(dev_t kdev, u_long cmd, caddr_t data,
-	      int flags, struct proc *p)
+int mga_dma_swap( DRM_OS_IOCTL )
 {
-	drm_device_t *dev = kdev->si_drv1;
-	drm_device_dma_t *dma = dev->dma;
-	drm_mga_private_t *dev_priv =
-	    (drm_mga_private_t *) dev->dev_private;
+	DRM_OS_DEVICE;
+	drm_mga_private_t *dev_priv = dev->dev_private;
 	drm_mga_sarea_t *sarea_priv = dev_priv->sarea_priv;
-	drm_buf_t *buf;
-	drm_mga_buf_priv_t *buf_priv;
-	drm_mga_iload_t iload;
-	unsigned long bus_address;
-	int s;
 
-	DRM_DEBUG("%s\n", __FUNCTION__);
+	LOCK_TEST_WITH_RETURN( dev );
 
-	DRM_DEBUG("Starting Iload\n");
-	iload = *(drm_mga_iload_t *) data;
+	if ( sarea_priv->nbox > MGA_NR_SAREA_CLIPRECTS )
+		sarea_priv->nbox = MGA_NR_SAREA_CLIPRECTS;
 
-	if (!_DRM_LOCK_IS_HELD(dev->lock.hw_lock->lock)) {
-		DRM_ERROR("mga_iload called without lock held\n");
-		return EINVAL;
-	}
+	WRAP_TEST_WITH_RETURN( dev_priv );
 
-	buf = dma->buflist[iload.idx];
-	buf_priv = buf->dev_private;
-	bus_address = buf->bus_address;
-	DRM_DEBUG("bus_address %lx, length %d, destorg : %x\n",
-		  bus_address, iload.length, iload.destOrg);
-
-	if (mgaVerifyIload(dev_priv,
-			   bus_address, iload.destOrg, iload.length)) {
-		mga_freelist_put(dev, buf);
-		return EINVAL;
-	}
+	mga_dma_dispatch_swap( dev );
+
+	/* Make sure we restore the 3D state next time.
+	 */
+	dev_priv->sarea_priv->dirty |= MGA_UPLOAD_CONTEXT;
 
-	sarea_priv->dirty |= MGA_UPLOAD_CTX;
-
-	mga_dma_dispatch_tex_blit(dev, bus_address, iload.length,
-				  iload.destOrg);
-	AGEBUF(dev_priv, buf_priv);
-	buf_priv->discard = 1;
-	mga_freelist_put(dev, buf);
-	mga_flush_write_combine();
-	s = splsofttq();
-	mga_dma_schedule(dev, 1);
-	splx(s);
 	return 0;
 }
 
-int mga_vertex(dev_t kdev, u_long cmd, caddr_t data,
-	       int flags, struct proc *p)
+int mga_dma_vertex( DRM_OS_IOCTL )
 {
-	drm_device_t *dev = kdev->si_drv1;
-	drm_mga_private_t *dev_priv =
-	    (drm_mga_private_t *) dev->dev_private;
+	DRM_OS_DEVICE;
+	drm_mga_private_t *dev_priv = dev->dev_private;
 	drm_device_dma_t *dma = dev->dma;
 	drm_buf_t *buf;
 	drm_mga_buf_priv_t *buf_priv;
 	drm_mga_vertex_t vertex;
 
-	DRM_DEBUG("%s\n", __FUNCTION__);
+	LOCK_TEST_WITH_RETURN( dev );
 
-	vertex = *(drm_mga_vertex_t *) data;
-
-	if (!_DRM_LOCK_IS_HELD(dev->lock.hw_lock->lock)) {
-		DRM_ERROR("mga_vertex called without lock held\n");
-		return EINVAL;
-	}
-
-	DRM_DEBUG("mga_vertex\n");
+	DRM_OS_KRNFROMUSR( vertex, (drm_mga_vertex_t *) data, sizeof(vertex) );
 
+        if(vertex.idx < 0 || vertex.idx > dma->buf_count) DRM_OS_RETURN( EINVAL );
 	buf = dma->buflist[vertex.idx];
 	buf_priv = buf->dev_private;
 
 	buf->used = vertex.used;
 	buf_priv->discard = vertex.discard;
 
-	if (!mgaVerifyState(dev_priv)) {
-		if (vertex.discard) {
-			if (buf_priv->dispatched == 1)
-				AGEBUF(dev_priv, buf_priv);
+	if ( !mga_verify_state( dev_priv ) ) {
+		if ( vertex.discard ) {
+			if ( buf_priv->dispatched == 1 )
+				AGE_BUFFER( buf_priv );
 			buf_priv->dispatched = 0;
-			mga_freelist_put(dev, buf);
+			mga_freelist_put( dev, buf );
 		}
-		DRM_DEBUG("bad state\n");
-		return EINVAL;
+		DRM_OS_RETURN( EINVAL );
 	}
 
-	mga_dma_dispatch_vertex(dev, buf);
+	WRAP_TEST_WITH_RETURN( dev_priv );
+
+	mga_dma_dispatch_vertex( dev, buf );
 
-	PRIMUPDATE(dev_priv);
-	mga_flush_write_combine();
-	mga_dma_schedule(dev, 1);
 	return 0;
 }
 
-
-int mga_indices(dev_t kdev, u_long cmd, caddr_t data,
-		int flags, struct proc *p)
+int mga_dma_indices( DRM_OS_IOCTL )
 {
-	drm_device_t *dev = kdev->si_drv1;
-	drm_mga_private_t *dev_priv =
-	    (drm_mga_private_t *) dev->dev_private;
+	DRM_OS_DEVICE;
+	drm_mga_private_t *dev_priv = dev->dev_private;
 	drm_device_dma_t *dma = dev->dma;
 	drm_buf_t *buf;
 	drm_mga_buf_priv_t *buf_priv;
 	drm_mga_indices_t indices;
-	DRM_DEBUG("%s\n", __FUNCTION__);
 
-	indices = *(drm_mga_indices_t *) data;
+	LOCK_TEST_WITH_RETURN( dev );
 
-	if (!_DRM_LOCK_IS_HELD(dev->lock.hw_lock->lock)) {
-		DRM_ERROR("mga_indices called without lock held\n");
-		return EINVAL;
-	}
+	DRM_OS_KRNFROMUSR( indices, (drm_mga_indices_t *) data, sizeof(indices) );
 
-	DRM_DEBUG("mga_indices\n");
+        if(indices.idx < 0 || indices.idx > dma->buf_count) DRM_OS_RETURN( EINVAL );
 
 	buf = dma->buflist[indices.idx];
 	buf_priv = buf->dev_private;
 
 	buf_priv->discard = indices.discard;
 
-	if (!mgaVerifyState(dev_priv)) {
-		if (indices.discard) {
-			if (buf_priv->dispatched == 1)
-				AGEBUF(dev_priv, buf_priv);
+	if ( !mga_verify_state( dev_priv ) ) {
+		if ( indices.discard ) {
+			if ( buf_priv->dispatched == 1 )
+				AGE_BUFFER( buf_priv );
 			buf_priv->dispatched = 0;
-			mga_freelist_put(dev, buf);
+			mga_freelist_put( dev, buf );
 		}
-		return EINVAL;
+		DRM_OS_RETURN( EINVAL );
 	}
 
-	mga_dma_dispatch_indices(dev, buf, indices.start, indices.end);
+	WRAP_TEST_WITH_RETURN( dev_priv );
+
+	mga_dma_dispatch_indices( dev, buf, indices.start, indices.end );
 
-	PRIMUPDATE(dev_priv);
-	mga_flush_write_combine();
-	mga_dma_schedule(dev, 1);
 	return 0;
 }
 
-
-
-static int
-mga_dma_get_buffers(drm_device_t * dev, drm_dma_t * d, struct proc *p)
+int mga_dma_iload( DRM_OS_IOCTL )
 {
-	int i, error;
+	DRM_OS_DEVICE;
+	drm_device_dma_t *dma = dev->dma;
+	drm_mga_private_t *dev_priv = dev->dev_private;
 	drm_buf_t *buf;
-	DRM_DEBUG("%s\n", __FUNCTION__);
-
-	for (i = d->granted_count; i < d->request_count; i++) {
-		buf = mga_freelist_get(dev);
-		if (!buf)
-			break;
-		buf->pid = p->p_pid;
-		error = copyout(&buf->idx,
-				&d->request_indices[i],
-				sizeof(buf->idx));
-		if (error) return error;
-		error = copyout(&buf->total,
-				&d->request_sizes[i],
-				sizeof(buf->total));
-		if (error) return error;
-		++d->granted_count;
+	drm_mga_buf_priv_t *buf_priv;
+	drm_mga_iload_t iload;
+	DRM_DEBUG( __FUNCTION__ ":\n" );
+
+	LOCK_TEST_WITH_RETURN( dev );
+
+	DRM_OS_KRNFROMUSR( iload, (drm_mga_iload_t *) data, sizeof(iload) );
+
+#if 0
+	if ( mga_do_wait_for_idle( dev_priv ) ) {
+		if ( MGA_DMA_DEBUG )
+			DRM_INFO( __FUNCTION__": -EBUSY\n" );
+		DRM_OS_RETURN( EBUSY );
 	}
+#endif
+        if(iload.idx < 0 || iload.idx > dma->buf_count) DRM_OS_RETURN( EINVAL );
+
+	buf = dma->buflist[iload.idx];
+	buf_priv = buf->dev_private;
+
+	if ( mga_verify_iload( dev_priv, iload.dstorg, iload.length ) ) {
+		mga_freelist_put( dev, buf );
+		DRM_OS_RETURN( EINVAL );
+	}
+
+	WRAP_TEST_WITH_RETURN( dev_priv );
+
+	mga_dma_dispatch_iload( dev, buf, iload.dstorg, iload.length );
+
+	/* Make sure we restore the 3D state next time.
+	 */
+	dev_priv->sarea_priv->dirty |= MGA_UPLOAD_CONTEXT;
+
 	return 0;
 }
 
-int mga_dma(dev_t kdev, u_long cmd, caddr_t data,
-	    int flags, struct proc *p)
+int mga_dma_blit( DRM_OS_IOCTL )
 {
-	drm_device_t *dev = kdev->si_drv1;
-	drm_device_dma_t *dma = dev->dma;
-	int retcode = 0;
-	drm_dma_t d;
-	DRM_DEBUG("%s\n", __FUNCTION__);
+	DRM_OS_DEVICE;
+	drm_mga_private_t *dev_priv = dev->dev_private;
+	drm_mga_sarea_t *sarea_priv = dev_priv->sarea_priv;
+	drm_mga_blit_t blit;
+	DRM_DEBUG( "%s\n", __FUNCTION__ );
 
-	d = *(drm_dma_t *) data;
-	DRM_DEBUG("%d %d: %d send, %d req\n",
-		  p->p_pid, d.context, d.send_count, d.request_count);
+	LOCK_TEST_WITH_RETURN( dev );
 
-	if (!_DRM_LOCK_IS_HELD(dev->lock.hw_lock->lock)) {
-		DRM_ERROR("mga_dma called without lock held\n");
-		return EINVAL;
-	}
+	DRM_OS_KRNFROMUSR( blit, (drm_mga_blit_t *) data, sizeof(blit) );
 
-	/* Please don't send us buffers.
-	 */
-	if (d.send_count != 0) {
-		DRM_ERROR
-		    ("Process %d trying to send %d buffers via drmDMA\n",
-		     p->p_pid, d.send_count);
-		return EINVAL;
-	}
+	if ( sarea_priv->nbox > MGA_NR_SAREA_CLIPRECTS )
+		sarea_priv->nbox = MGA_NR_SAREA_CLIPRECTS;
 
-	/* We'll send you buffers.
-	 */
-	if (d.request_count < 0 || d.request_count > dma->buf_count) {
-		DRM_ERROR
-		    ("Process %d trying to get %d buffers (of %d max)\n",
-		     p->p_pid, d.request_count, dma->buf_count);
-		return EINVAL;
-	}
+	if ( mga_verify_blit( dev_priv, blit.srcorg, blit.dstorg ) )
+		DRM_OS_RETURN( EINVAL );
 
-	d.granted_count = 0;
+	WRAP_TEST_WITH_RETURN( dev_priv );
 
-	if (d.request_count) {
-		retcode = mga_dma_get_buffers(dev, &d, p);
-	}
+	mga_dma_dispatch_blit( dev, &blit );
 
-	DRM_DEBUG("%d returning, granted = %d\n",
-		  p->p_pid, d.granted_count);
-	*(drm_dma_t *) data = d;
-	return retcode;
+	/* Make sure we restore the 3D state next time.
+	 */
+	dev_priv->sarea_priv->dirty |= MGA_UPLOAD_CONTEXT;
+
+	return 0;
 }
diff --git a/bsd/mga_drm.h b/bsd/mga_drm.h
new file mode 100644
index 00000000..4af2ca2e
--- /dev/null
+++ b/bsd/mga_drm.h
@@ -0,0 +1,310 @@
+/* mga_drm.h -- Public header for the Matrox g200/g400 driver -*- linux-c -*-
+ * Created: Tue Jan 25 01:50:01 1999 by jhartmann@precisioninsight.com
+ *
+ * Copyright 1999 Precision Insight, Inc., Cedar Park, Texas.
+ * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
+ * All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Authors:
+ *    Jeff Hartmann <jhartmann@valinux.com>
+ *    Keith Whitwell <keithw@valinux.com>
+ *
+ * Rewritten by:
+ *    Gareth Hughes <gareth@valinux.com>
+ */
+
+#ifndef __MGA_DRM_H__
+#define __MGA_DRM_H__
+
+/* WARNING: If you change any of these defines, make sure to change the
+ * defines in the Xserver file (mga_sarea.h)
+ */
+#ifndef __MGA_SAREA_DEFINES__
+#define __MGA_SAREA_DEFINES__
+
+/* WARP pipe flags
+ */
+#define MGA_F			0x1		/* fog */
+#define MGA_A			0x2		/* alpha */
+#define MGA_S			0x4		/* specular */
+#define MGA_T2			0x8		/* multitexture */
+
+#define MGA_WARP_TGZ		0
+#define MGA_WARP_TGZF		(MGA_F)
+#define MGA_WARP_TGZA		(MGA_A)
+#define MGA_WARP_TGZAF		(MGA_F|MGA_A)
+#define MGA_WARP_TGZS		(MGA_S)
+#define MGA_WARP_TGZSF		(MGA_S|MGA_F)
+#define MGA_WARP_TGZSA		(MGA_S|MGA_A)
+#define MGA_WARP_TGZSAF		(MGA_S|MGA_F|MGA_A)
+#define MGA_WARP_T2GZ		(MGA_T2)
+#define MGA_WARP_T2GZF		(MGA_T2|MGA_F)
+#define MGA_WARP_T2GZA		(MGA_T2|MGA_A)
+#define MGA_WARP_T2GZAF		(MGA_T2|MGA_A|MGA_F)
+#define MGA_WARP_T2GZS		(MGA_T2|MGA_S)
+#define MGA_WARP_T2GZSF		(MGA_T2|MGA_S|MGA_F)
+#define MGA_WARP_T2GZSA		(MGA_T2|MGA_S|MGA_A)
+#define MGA_WARP_T2GZSAF	(MGA_T2|MGA_S|MGA_F|MGA_A)
+
+#define MGA_MAX_G200_PIPES	8		/* no multitex */
+#define MGA_MAX_G400_PIPES	16
+#define MGA_MAX_WARP_PIPES	MGA_MAX_G400_PIPES
+#define MGA_WARP_UCODE_SIZE	32768		/* in bytes */
+
+#define MGA_CARD_TYPE_G200	1
+#define MGA_CARD_TYPE_G400	2
+
+
+#define MGA_FRONT		0x1
+#define MGA_BACK		0x2
+#define MGA_DEPTH		0x4
+
+/* What needs to be changed for the current vertex dma buffer?
+ */
+#define MGA_UPLOAD_CONTEXT	0x1
+#define MGA_UPLOAD_TEX0		0x2
+#define MGA_UPLOAD_TEX1		0x4
+#define MGA_UPLOAD_PIPE		0x8
+#define MGA_UPLOAD_TEX0IMAGE	0x10 /* handled client-side */
+#define MGA_UPLOAD_TEX1IMAGE	0x20 /* handled client-side */
+#define MGA_UPLOAD_2D		0x40
+#define MGA_WAIT_AGE		0x80 /* handled client-side */
+#define MGA_UPLOAD_CLIPRECTS	0x100 /* handled client-side */
+#if 0
+#define MGA_DMA_FLUSH		0x200 /* set when someone gets the lock
+					 quiescent */
+#endif
+
+/* 32 buffers of 64k each, total 2 meg.
+ */
+#define MGA_BUFFER_SIZE		(1 << 16)
+#define MGA_NUM_BUFFERS		128
+
+/* Keep these small for testing.
+ */
+#define MGA_NR_SAREA_CLIPRECTS	8
+
+/* 2 heaps (1 for card, 1 for agp), each divided into upto 128
+ * regions, subject to a minimum region size of (1<<16) == 64k.
+ *
+ * Clients may subdivide regions internally, but when sharing between
+ * clients, the region size is the minimum granularity.
+ */
+
+#define MGA_CARD_HEAP			0
+#define MGA_AGP_HEAP			1
+#define MGA_NR_TEX_HEAPS		2
+#define MGA_NR_TEX_REGIONS		16
+#define MGA_LOG_MIN_TEX_REGION_SIZE	16
+
+#endif /* __MGA_SAREA_DEFINES__ */
+
+
+/* Setup registers for 3D context
+ */
+typedef struct {
+	unsigned int dstorg;
+	unsigned int maccess;
+	unsigned int plnwt;
+	unsigned int dwgctl;
+	unsigned int alphactrl;
+	unsigned int fogcolor;
+	unsigned int wflag;
+	unsigned int tdualstage0;
+	unsigned int tdualstage1;
+	unsigned int fcol;
+	unsigned int stencil;
+	unsigned int stencilctl;
+} drm_mga_context_regs_t;
+
+/* Setup registers for 2D, X server
+ */
+typedef struct {
+	unsigned int pitch;
+} drm_mga_server_regs_t;
+
+/* Setup registers for each texture unit
+ */
+typedef struct {
+	unsigned int texctl;
+	unsigned int texctl2;
+	unsigned int texfilter;
+	unsigned int texbordercol;
+	unsigned int texorg;
+	unsigned int texwidth;
+	unsigned int texheight;
+	unsigned int texorg1;
+	unsigned int texorg2;
+	unsigned int texorg3;
+	unsigned int texorg4;
+} drm_mga_texture_regs_t;
+
+/* General aging mechanism
+ */
+typedef struct {
+	unsigned int head;		/* Position of head pointer          */
+	unsigned int wrap;		/* Primary DMA wrap count            */
+} drm_mga_age_t;
+
+typedef struct _drm_mga_sarea {
+	/* The channel for communication of state information to the kernel
+	 * on firing a vertex dma buffer.
+	 */
+   	drm_mga_context_regs_t context_state;
+   	drm_mga_server_regs_t server_state;
+   	drm_mga_texture_regs_t tex_state[2];
+   	unsigned int warp_pipe;
+   	unsigned int dirty;
+   	unsigned int vertsize;
+
+	/* The current cliprects, or a subset thereof.
+	 */
+   	drm_clip_rect_t boxes[MGA_NR_SAREA_CLIPRECTS];
+   	unsigned int nbox;
+
+	/* Information about the most recently used 3d drawable.  The
+	 * client fills in the req_* fields, the server fills in the
+	 * exported_ fields and puts the cliprects into boxes, above.
+	 *
+	 * The client clears the exported_drawable field before
+	 * clobbering the boxes data.
+	 */
+        unsigned int req_drawable;	 /* the X drawable id */
+	unsigned int req_draw_buffer;	 /* MGA_FRONT or MGA_BACK */
+
+        unsigned int exported_drawable;
+	unsigned int exported_index;
+        unsigned int exported_stamp;
+        unsigned int exported_buffers;
+        unsigned int exported_nfront;
+        unsigned int exported_nback;
+	int exported_back_x, exported_front_x, exported_w;
+	int exported_back_y, exported_front_y, exported_h;
+   	drm_clip_rect_t exported_boxes[MGA_NR_SAREA_CLIPRECTS];
+
+	/* Counters for aging textures and for client-side throttling.
+	 */
+	unsigned int status[4];
+	unsigned int last_wrap;
+
+	drm_mga_age_t last_frame;
+        unsigned int last_enqueue;	/* last time a buffer was enqueued */
+	unsigned int last_dispatch;	/* age of the most recently dispatched buffer */
+	unsigned int last_quiescent;     /*  */
+
+	/* LRU lists for texture memory in agp space and on the card.
+	 */
+	drm_tex_region_t texList[MGA_NR_TEX_HEAPS][MGA_NR_TEX_REGIONS+1];
+	unsigned int texAge[MGA_NR_TEX_HEAPS];
+
+	/* Mechanism to validate card state.
+	 */
+   	int ctxOwner;
+} drm_mga_sarea_t;
+
+
+/* WARNING: If you change any of these defines, make sure to change the
+ * defines in the Xserver file (xf86drmMga.h)
+ */
+typedef struct _drm_mga_warp_index {
+   	int installed;
+   	unsigned long phys_addr;
+   	int size;
+} drm_mga_warp_index_t;
+
+typedef struct drm_mga_init {
+   	enum {
+	   	MGA_INIT_DMA    = 0x01,
+	       	MGA_CLEANUP_DMA = 0x02
+	} func;
+
+   	unsigned long sarea_priv_offset;
+
+	int chipset;
+   	int sgram;
+
+	unsigned int maccess;
+
+   	unsigned int fb_cpp;
+	unsigned int front_offset, front_pitch;
+   	unsigned int back_offset, back_pitch;
+
+   	unsigned int depth_cpp;
+   	unsigned int depth_offset, depth_pitch;
+
+   	unsigned int texture_offset[MGA_NR_TEX_HEAPS];
+   	unsigned int texture_size[MGA_NR_TEX_HEAPS];
+
+	unsigned long fb_offset;
+	unsigned long mmio_offset;
+	unsigned long status_offset;
+	unsigned long warp_offset;
+	unsigned long primary_offset;
+	unsigned long buffers_offset;
+} drm_mga_init_t;
+
+typedef struct drm_mga_fullscreen {
+	enum {
+		MGA_INIT_FULLSCREEN    = 0x01,
+		MGA_CLEANUP_FULLSCREEN = 0x02
+	} func;
+} drm_mga_fullscreen_t;
+
+typedef struct drm_mga_clear {
+	unsigned int flags;
+	unsigned int clear_color;
+	unsigned int clear_depth;
+	unsigned int color_mask;
+	unsigned int depth_mask;
+} drm_mga_clear_t;
+
+typedef struct drm_mga_vertex {
+   	int idx;			/* buffer to queue */
+	int used;			/* bytes in use */
+	int discard;			/* client finished with buffer?  */
+} drm_mga_vertex_t;
+
+typedef struct drm_mga_indices {
+   	int idx;			/* buffer to queue */
+	unsigned int start;
+	unsigned int end;
+	int discard;			/* client finished with buffer?  */
+} drm_mga_indices_t;
+
+typedef struct drm_mga_iload {
+	int idx;
+	unsigned int dstorg;
+	unsigned int length;
+} drm_mga_iload_t;
+
+typedef struct _drm_mga_blit {
+	unsigned int planemask;
+	unsigned int srcorg;
+	unsigned int dstorg;
+	int src_pitch, dst_pitch;
+	int delta_sx, delta_sy;
+	int delta_dx, delta_dy;
+	int height, ydir;		/* flip image vertically */
+	int source_pitch, dest_pitch;
+} drm_mga_blit_t;
+
+#endif
diff --git a/bsd/r128_drm.h b/bsd/r128_drm.h
new file mode 100644
index 00000000..0fc6a6cd
--- /dev/null
+++ b/bsd/r128_drm.h
@@ -0,0 +1,287 @@
+/* r128_drm.h -- Public header for the r128 driver -*- linux-c -*-
+ * Created: Wed Apr  5 19:24:19 2000 by kevin@precisioninsight.com
+ *
+ * Copyright 2000 Precision Insight, Inc., Cedar Park, Texas.
+ * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
+ * All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ * Authors:
+ *    Gareth Hughes <gareth@valinux.com>
+ *    Kevin E. Martin <martin@valinux.com>
+ */
+
+#ifndef __R128_DRM_H__
+#define __R128_DRM_H__
+
+/* WARNING: If you change any of these defines, make sure to change the
+ * defines in the X server file (r128_sarea.h)
+ */
+#ifndef __R128_SAREA_DEFINES__
+#define __R128_SAREA_DEFINES__
+
+/* What needs to be changed for the current vertex buffer?
+ */
+#define R128_UPLOAD_CONTEXT		0x001
+#define R128_UPLOAD_SETUP		0x002
+#define R128_UPLOAD_TEX0		0x004
+#define R128_UPLOAD_TEX1		0x008
+#define R128_UPLOAD_TEX0IMAGES		0x010
+#define R128_UPLOAD_TEX1IMAGES		0x020
+#define R128_UPLOAD_CORE		0x040
+#define R128_UPLOAD_MASKS		0x080
+#define R128_UPLOAD_WINDOW		0x100
+#define R128_UPLOAD_CLIPRECTS		0x200	/* handled client-side */
+#define R128_REQUIRE_QUIESCENCE		0x400
+#define R128_UPLOAD_ALL			0x7ff
+
+#define R128_FRONT			0x1
+#define R128_BACK			0x2
+#define R128_DEPTH			0x4
+
+/* Primitive types
+ */
+#define R128_POINTS			0x1
+#define R128_LINES			0x2
+#define R128_LINE_STRIP			0x3
+#define R128_TRIANGLES			0x4
+#define R128_TRIANGLE_FAN		0x5
+#define R128_TRIANGLE_STRIP		0x6
+
+/* Vertex/indirect buffer size
+ */
+#define R128_BUFFER_SIZE		16384
+
+/* Byte offsets for indirect buffer data
+ */
+#define R128_INDEX_PRIM_OFFSET		20
+#define R128_HOSTDATA_BLIT_OFFSET	32
+
+/* Keep these small for testing.
+ */
+#define R128_NR_SAREA_CLIPRECTS		12
+
+/* There are 2 heaps (local/AGP).  Each region within a heap is a
+ *  minimum of 64k, and there are at most 64 of them per heap.
+ */
+#define R128_LOCAL_TEX_HEAP		0
+#define R128_AGP_TEX_HEAP		1
+#define R128_NR_TEX_HEAPS		2
+#define R128_NR_TEX_REGIONS		64
+#define R128_LOG_TEX_GRANULARITY	16
+
+#define R128_NR_CONTEXT_REGS		12
+
+#define R128_MAX_TEXTURE_LEVELS		11
+#define R128_MAX_TEXTURE_UNITS		2
+
+#endif /* __R128_SAREA_DEFINES__ */
+
+typedef struct {
+	/* Context state - can be written in one large chunk */
+	unsigned int dst_pitch_offset_c;
+	unsigned int dp_gui_master_cntl_c;
+	unsigned int sc_top_left_c;
+	unsigned int sc_bottom_right_c;
+	unsigned int z_offset_c;
+	unsigned int z_pitch_c;
+	unsigned int z_sten_cntl_c;
+	unsigned int tex_cntl_c;
+	unsigned int misc_3d_state_cntl_reg;
+	unsigned int texture_clr_cmp_clr_c;
+	unsigned int texture_clr_cmp_msk_c;
+	unsigned int fog_color_c;
+
+	/* Texture state */
+	unsigned int tex_size_pitch_c;
+	unsigned int constant_color_c;
+
+	/* Setup state */
+	unsigned int pm4_vc_fpu_setup;
+	unsigned int setup_cntl;
+
+	/* Mask state */
+	unsigned int dp_write_mask;
+	unsigned int sten_ref_mask_c;
+	unsigned int plane_3d_mask_c;
+
+	/* Window state */
+	unsigned int window_xy_offset;
+
+	/* Core state */
+	unsigned int scale_3d_cntl;
+} drm_r128_context_regs_t;
+
+/* Setup registers for each texture unit
+ */
+typedef struct {
+	unsigned int tex_cntl;
+	unsigned int tex_combine_cntl;
+	unsigned int tex_size_pitch;
+	unsigned int tex_offset[R128_MAX_TEXTURE_LEVELS];
+	unsigned int tex_border_color;
+} drm_r128_texture_regs_t;
+
+
+typedef struct drm_r128_sarea {
+	/* The channel for communication of state information to the kernel
+	 * on firing a vertex buffer.
+	 */
+	drm_r128_context_regs_t context_state;
+	drm_r128_texture_regs_t tex_state[R128_MAX_TEXTURE_UNITS];
+	unsigned int dirty;
+	unsigned int vertsize;
+	unsigned int vc_format;
+
+	/* The current cliprects, or a subset thereof.
+	 */
+	drm_clip_rect_t boxes[R128_NR_SAREA_CLIPRECTS];
+	unsigned int nbox;
+
+	/* Counters for client-side throttling of rendering clients.
+	 */
+	unsigned int last_frame;
+	unsigned int last_dispatch;
+
+	drm_tex_region_t tex_list[R128_NR_TEX_HEAPS][R128_NR_TEX_REGIONS+1];
+	int tex_age[R128_NR_TEX_HEAPS];
+	int ctx_owner;
+} drm_r128_sarea_t;
+
+
+/* WARNING: If you change any of these defines, make sure to change the
+ * defines in the Xserver file (xf86drmR128.h)
+ */
+typedef struct drm_r128_init {
+	enum {
+		R128_INIT_CCE    = 0x01,
+		R128_CLEANUP_CCE = 0x02
+	} func;
+#if CONFIG_XFREE86_VERSION < XFREE86_VERSION(4,1,0,0)
+	int sarea_priv_offset;
+#else
+	unsigned long sarea_priv_offset;
+#endif
+	int is_pci;
+	int cce_mode;
+	int cce_secure;
+	int ring_size;
+	int usec_timeout;
+
+	unsigned int fb_bpp;
+	unsigned int front_offset, front_pitch;
+	unsigned int back_offset, back_pitch;
+	unsigned int depth_bpp;
+	unsigned int depth_offset, depth_pitch;
+	unsigned int span_offset;
+
+#if CONFIG_XFREE86_VERSION < XFREE86_VERSION(4,1,0,0)
+	unsigned int fb_offset;
+	unsigned int mmio_offset;
+	unsigned int ring_offset;
+	unsigned int ring_rptr_offset;
+	unsigned int buffers_offset;
+	unsigned int agp_textures_offset;
+#else
+	unsigned long fb_offset;
+	unsigned long mmio_offset;
+	unsigned long ring_offset;
+	unsigned long ring_rptr_offset;
+	unsigned long buffers_offset;
+	unsigned long agp_textures_offset;
+#endif
+} drm_r128_init_t;
+
+typedef struct drm_r128_cce_stop {
+	int flush;
+	int idle;
+} drm_r128_cce_stop_t;
+
+typedef struct drm_r128_clear {
+	unsigned int flags;
+#if CONFIG_XFREE86_VERSION < XFREE86_VERSION(4,1,0,0)
+	int x, y, w, h;
+#endif
+	unsigned int clear_color;
+	unsigned int clear_depth;
+#if CONFIG_XFREE86_VERSION >= XFREE86_VERSION(4,1,0,0)
+	unsigned int color_mask;
+	unsigned int depth_mask;
+#endif
+} drm_r128_clear_t;
+
+typedef struct drm_r128_vertex {
+	int prim;
+	int idx;			/* Index of vertex buffer */
+	int count;			/* Number of vertices in buffer */
+	int discard;			/* Client finished with buffer? */
+} drm_r128_vertex_t;
+
+typedef struct drm_r128_indices {
+	int prim;
+	int idx;
+	int start;
+	int end;
+	int discard;			/* Client finished with buffer? */
+} drm_r128_indices_t;
+
+typedef struct drm_r128_blit {
+	int idx;
+	int pitch;
+	int offset;
+	int format;
+	unsigned short x, y;
+	unsigned short width, height;
+} drm_r128_blit_t;
+
+typedef struct drm_r128_depth {
+	enum {
+		R128_WRITE_SPAN		= 0x01,
+		R128_WRITE_PIXELS	= 0x02,
+		R128_READ_SPAN		= 0x03,
+		R128_READ_PIXELS	= 0x04
+	} func;
+	int n;
+	int *x;
+	int *y;
+	unsigned int *buffer;
+	unsigned char *mask;
+} drm_r128_depth_t;
+
+typedef struct drm_r128_stipple {
+	unsigned int *mask;
+} drm_r128_stipple_t;
+
+typedef struct drm_r128_indirect {
+	int idx;
+	int start;
+	int end;
+	int discard;
+} drm_r128_indirect_t;
+
+typedef struct drm_r128_fullscreen {
+	enum {
+		R128_INIT_FULLSCREEN    = 0x01,
+		R128_CLEANUP_FULLSCREEN = 0x02
+	} func;
+} drm_r128_fullscreen_t;
+
+#endif
diff --git a/bsd/tdfx/Makefile b/bsd/tdfx/Makefile
index 4362a5ba..d177ff60 100644
--- a/bsd/tdfx/Makefile
+++ b/bsd/tdfx/Makefile
@@ -1,10 +1,10 @@
 # $FreeBSD$
 
-KMOD	= tdfx
-SRCS    = tdfx_drv.c tdfx_context.c
-SRCS   += device_if.h bus_if.h pci_if.h
-CFLAGS += ${DEBUG_FLAGS} -I. -I..
-KMODDEPS = drm
+KMOD=	tdfx
+NOMAN=	YES
+SRCS=	tdfx_drv.c
+SRCS+=	device_if.h bus_if.h pci_if.h opt_drm_linux.h
+CFLAGS+=	${DEBUG_FLAGS} -I. -I.. 
 
 @:
 	ln -sf /sys @
@@ -12,4 +12,14 @@ KMODDEPS = drm
 machine:
 	ln -sf /sys/i386/include machine
 
+.if ${MACHINE_ARCH} == "i386"
+# This line enables linux ioctl handling
+# If you want support for this uncomment this line
+#TDFX_OPTS=     "\#define DRM_LINUX" 1
+.endif
+
+opt_drm_linux.h:
+	touch opt_drm_linux.h
+	echo $(TDFX_OPTS) >> opt_drm_linux.h
+
 .include <bsd.kmod.mk>
diff --git a/bsd/tdfx/tdfx_context.c b/bsd/tdfx/tdfx_context.c
deleted file mode 100644
index 5a334058..00000000
--- a/bsd/tdfx/tdfx_context.c
+++ /dev/null
@@ -1,204 +0,0 @@
-/* tdfx_context.c -- IOCTLs for tdfx contexts -*- c -*-
- * Created: Thu Oct  7 10:50:22 1999 by faith@precisioninsight.com
- *
- * Copyright 1999 Precision Insight, Inc., Cedar Park, Texas.
- * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
- * All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice (including the next
- * paragraph) shall be included in all copies or substantial portions of the
- * Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
- * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
- * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- * 
- * Authors:
- *    Rickard E. (Rik) Faith <faith@valinux.com>
- *    Daryll Strauss <daryll@valinux.com>
- *
- */
-
-#include "drmP.h"
-#include "tdfx_drv.h"
-
-extern drm_ctx_t tdfx_res_ctx;
-
-static int tdfx_alloc_queue(drm_device_t *dev)
-{
-	return drm_ctxbitmap_next(dev);
-}
-
-int tdfx_context_switch(drm_device_t *dev, int old, int new)
-{
-        char        buf[64];
-
-        atomic_inc(&dev->total_ctx);
-
-        if (test_and_set_bit(0, &dev->context_flag)) {
-                DRM_ERROR("Reentering -- FIXME\n");
-                return -EBUSY;
-        }
-
-#if DRM_DMA_HISTOGRAM
-        getnanotime(&dev->ctx_start);
-#endif
-        
-        DRM_DEBUG("Context switch from %d to %d\n", old, new);
-
-        if (new == dev->last_context) {
-                clear_bit(0, &dev->context_flag);
-                return 0;
-        }
-        
-        if (drm_flags & DRM_FLAG_NOCTX) {
-                tdfx_context_switch_complete(dev, new);
-        } else {
-                sprintf(buf, "C %d %d\n", old, new);
-                drm_write_string(dev, buf);
-        }
-        
-        return 0;
-}
-
-int tdfx_context_switch_complete(drm_device_t *dev, int new)
-{
-        dev->last_context = new;  /* PRE/POST: This is the _only_ writer. */
-        dev->last_switch  = ticks;
-        
-        if (!_DRM_LOCK_IS_HELD(dev->lock.hw_lock->lock)) {
-                DRM_ERROR("Lock isn't held after context switch\n");
-        }
-
-				/* If a context switch is ever initiated
-                                   when the kernel holds the lock, release
-                                   that lock here. */
-#if DRM_DMA_HISTOGRAM
-	{
-	    struct timespec ts;
-	    getnanotime(&ts);
-	    timespecsub(&ts, &dev->lck_start);
-	    atomic_inc(&dev->histo.ctx[drm_histogram_slot(&ts)]);
-	}
-#endif
-        clear_bit(0, &dev->context_flag);
-        wakeup(&dev->context_wait);
-        
-        return 0;
-}
-
-
-int
-tdfx_resctx(dev_t kdev, u_long cmd, caddr_t data, int flags, struct proc *p)
-{
-	drm_ctx_res_t	res;
-	drm_ctx_t	ctx;
-	int		i, error;
-
-	DRM_DEBUG("%d\n", DRM_RESERVED_CONTEXTS);
-	res = *(drm_ctx_res_t *) data;
-	if (res.count >= DRM_RESERVED_CONTEXTS) {
-		memset(&ctx, 0, sizeof(ctx));
-		for (i = 0; i < DRM_RESERVED_CONTEXTS; i++) {
-			ctx.handle = i;
-			error = copyout(&i, &res.contexts[i], sizeof(i));
-			if (error) return error;
-		}
-	}
-	res.count = DRM_RESERVED_CONTEXTS;
-	*(drm_ctx_res_t *) data = res;
-	return 0;
-}
-
-
-int
-tdfx_addctx(dev_t kdev, u_long cmd, caddr_t data, int flags, struct proc *p)
-{
-	drm_device_t	*dev	= kdev->si_drv1;
-	drm_ctx_t	ctx;
-
-	ctx = *(drm_ctx_t *) data;
-	if ((ctx.handle = tdfx_alloc_queue(dev)) == DRM_KERNEL_CONTEXT) {
-				/* Skip kernel's context and get a new one. */
-		ctx.handle = tdfx_alloc_queue(dev);
-	}
-	DRM_DEBUG("%d\n", ctx.handle);
-	if (ctx.handle == -1) {
-		DRM_DEBUG("Not enough free contexts.\n");
-				/* Should this return -EBUSY instead? */
-		return ENOMEM;
-	}
-
-	*(drm_ctx_t *) data = ctx;
-	return 0;
-}
-
-int
-tdfx_modctx(dev_t kdev, u_long cmd, caddr_t data, int flags, struct proc *p)
-{
-	drm_ctx_t ctx;
-
-	ctx = *(drm_ctx_t *) data;
-	if (ctx.flags==_DRM_CONTEXT_PRESERVED)
-		tdfx_res_ctx.handle=ctx.handle;
-	return 0;
-}
-
-int
-tdfx_getctx(dev_t kdev, u_long cmd, caddr_t data, int flags, struct proc *p)
-{
-	drm_ctx_t ctx;
-
-	ctx = *(drm_ctx_t *) data;
-	/* This is 0, because we don't hanlde any context flags */
-	ctx.flags = 0;
-	*(drm_ctx_t *) data = ctx;
-	return 0;
-}
-
-int
-tdfx_switchctx(dev_t kdev, u_long cmd, caddr_t data, int flags, struct proc *p)
-{
-	drm_device_t	*dev	= kdev->si_drv1;
-	drm_ctx_t	ctx;
-
-	ctx = *(drm_ctx_t *) data;
-	DRM_DEBUG("%d\n", ctx.handle);
-	return tdfx_context_switch(dev, dev->last_context, ctx.handle);
-}
-
-int
-tdfx_newctx(dev_t kdev, u_long cmd, caddr_t data, int flags, struct proc *p)
-{
-	drm_device_t	*dev	= kdev->si_drv1;
-	drm_ctx_t	ctx;
-
-	ctx = *(drm_ctx_t *) data;
-	DRM_DEBUG("%d\n", ctx.handle);
-	tdfx_context_switch_complete(dev, ctx.handle);
-
-	return 0;
-}
-
-int
-tdfx_rmctx(dev_t kdev, u_long cmd, caddr_t data, int flags, struct proc *p)
-{
-	drm_device_t	*dev	= kdev->si_drv1;
-	drm_ctx_t	ctx;
-
-	ctx = *(drm_ctx_t *) data;
-	drm_ctxbitmap_free(dev, ctx.handle);
-	
-	return 0;
-}
diff --git a/bsd/tdfx/tdfx_drv.c b/bsd/tdfx/tdfx_drv.c
index 202df7c3..29d19558 100644
--- a/bsd/tdfx/tdfx_drv.c
+++ b/bsd/tdfx/tdfx_drv.c
@@ -1,4 +1,4 @@
-/* tdfx.c -- tdfx driver -*- c -*-
+/* tdfx_drv.c -- tdfx driver -*- linux-c -*-
  * Created: Thu Oct  7 10:38:32 1999 by faith@precisioninsight.com
  *
  * Copyright 1999 Precision Insight, Inc., Cedar Park, Texas.
@@ -11,11 +11,11 @@
  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  * and/or sell copies of the Software, and to permit persons to whom the
  * Software is furnished to do so, subject to the following conditions:
- * 
+ *
  * The above copyright notice and this permission notice (including the next
  * paragraph) shall be included in all copies or substantial portions of the
  * Software.
- * 
+ *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
@@ -23,719 +23,78 @@
  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  * DEALINGS IN THE SOFTWARE.
- * 
+ *
  * Authors:
  *    Rickard E. (Rik) Faith <faith@valinux.com>
  *    Daryll Strauss <daryll@valinux.com>
- *
+ *    Gareth Hughes <gareth@valinux.com>
  */
 
-#include "drmP.h"
-#include "tdfx_drv.h"
 
+#include <sys/types.h>
+#include <sys/bus.h>
 #include <pci/pcivar.h>
+#include <opt_drm_linux.h>
 
-MODULE_DEPEND(tdfx, drm, 1, 1, 1);
-#ifdef DRM_AGP
-MODULE_DEPEND(tdfx, agp, 1, 1, 1);
-#endif
-
-#define TDFX_NAME	 "tdfx"
-#define TDFX_DESC	 "tdfx"
-#define TDFX_DATE	 "20000928"
-#define TDFX_MAJOR	 1
-#define TDFX_MINOR	 0
-#define TDFX_PATCHLEVEL  0
-
-static int tdfx_init(device_t nbdev);
-static void tdfx_cleanup(device_t nbdev);
-
-drm_ctx_t	              tdfx_res_ctx;
-
-static int tdfx_probe(device_t dev)
-{
-	const char *s = 0;
-
-	switch (pci_get_devid(dev)) {
-	case 0x0003121a:
-		s = "3Dfx Voodoo Banshee graphics accelerator";
-		break;
-		
-	case 0x0005121a:
-		s = "3Dfx Voodoo 3 graphics accelerator";
-		break;
-	case 0x0009121a:
-		s = "3Dfx Voodoo 5 graphics accelerator";
-		break;
-	}
-
-	if (s) {
-		device_set_desc(dev, s);
-		return 0;
-	}
-
-	return ENXIO;
-}
-
-static int tdfx_attach(device_t dev)
-{
-	tdfx_init(dev);
-	return 0;
-}
-
-static int tdfx_detach(device_t dev)
-{
-	tdfx_cleanup(dev);
-	return 0;
-}
-
-static device_method_t tdfx_methods[] = {
-	/* Device interface */
-	DEVMETHOD(device_probe,		tdfx_probe),
-	DEVMETHOD(device_attach,	tdfx_attach),
-	DEVMETHOD(device_detach,	tdfx_detach),
-
-	{ 0, 0 }
-};
-
-static driver_t tdfx_driver = {
-	"drm",
-	tdfx_methods,
-	sizeof(drm_device_t),
-};
-
-static devclass_t tdfx_devclass;
-#define TDFX_SOFTC(unit) \
-	((drm_device_t *) devclass_get_softc(tdfx_devclass, unit))
-
-DRIVER_MODULE(if_tdfx, pci, tdfx_driver, tdfx_devclass, 0, 0);
-
-#define CDEV_MAJOR	145
-				/* tdfx_drv.c */
-static d_open_t tdfx_open;
-static d_close_t tdfx_close;
-static d_ioctl_t tdfx_version;
-static d_ioctl_t tdfx_ioctl;
-static d_ioctl_t tdfx_lock;
-static d_ioctl_t tdfx_unlock;
-
-static struct cdevsw tdfx_cdevsw = {
-	/* open */	tdfx_open,
-	/* close */	tdfx_close,
-	/* read */	drm_read,
-	/* write */	drm_write,
-	/* ioctl */	tdfx_ioctl,
-	/* poll */	drm_poll,
-	/* mmap */	drm_mmap,
-	/* strategy */	nostrategy,
-	/* name */	"tdfx",
-	/* maj */	CDEV_MAJOR,
-	/* dump */	nodump,
-	/* psize */	nopsize,
-	/* flags */	D_TTY | D_TRACKCLOSE,
-	/* bmaj */	-1
-};
-
-static drm_ioctl_desc_t	      tdfx_ioctls[] = {
-	[DRM_IOCTL_NR(DRM_IOCTL_VERSION)]    = { tdfx_version,	  0, 0 },
-	[DRM_IOCTL_NR(DRM_IOCTL_GET_UNIQUE)] = { drm_getunique,	  0, 0 },
-	[DRM_IOCTL_NR(DRM_IOCTL_GET_MAGIC)]  = { drm_getmagic,	  0, 0 },
-	[DRM_IOCTL_NR(DRM_IOCTL_IRQ_BUSID)]  = { drm_irq_busid,	  0, 1 },
-
-	[DRM_IOCTL_NR(DRM_IOCTL_SET_UNIQUE)] = { drm_setunique,	  1, 1 },
-	[DRM_IOCTL_NR(DRM_IOCTL_BLOCK)]	     = { drm_block,	  1, 1 },
-	[DRM_IOCTL_NR(DRM_IOCTL_UNBLOCK)]    = { drm_unblock,	  1, 1 },
-	[DRM_IOCTL_NR(DRM_IOCTL_AUTH_MAGIC)] = { drm_authmagic,	  1, 1 },
-	[DRM_IOCTL_NR(DRM_IOCTL_ADD_MAP)]    = { drm_addmap,	  1, 1 },
-	
-	[DRM_IOCTL_NR(DRM_IOCTL_ADD_CTX)]    = { tdfx_addctx,	  1, 1 },
-	[DRM_IOCTL_NR(DRM_IOCTL_RM_CTX)]     = { tdfx_rmctx,	  1, 1 },
-	[DRM_IOCTL_NR(DRM_IOCTL_MOD_CTX)]    = { tdfx_modctx,	  1, 1 },
-	[DRM_IOCTL_NR(DRM_IOCTL_GET_CTX)]    = { tdfx_getctx,	  1, 0 },
-	[DRM_IOCTL_NR(DRM_IOCTL_SWITCH_CTX)] = { tdfx_switchctx,  1, 1 },
-	[DRM_IOCTL_NR(DRM_IOCTL_NEW_CTX)]    = { tdfx_newctx,	  1, 1 },
-	[DRM_IOCTL_NR(DRM_IOCTL_RES_CTX)]    = { tdfx_resctx,	  1, 0 },
-	[DRM_IOCTL_NR(DRM_IOCTL_ADD_DRAW)]   = { drm_adddraw,	  1, 1 },
-	[DRM_IOCTL_NR(DRM_IOCTL_RM_DRAW)]    = { drm_rmdraw,	  1, 1 },
-	[DRM_IOCTL_NR(DRM_IOCTL_LOCK)]	     = { tdfx_lock,	  1, 0 },
-	[DRM_IOCTL_NR(DRM_IOCTL_UNLOCK)]     = { tdfx_unlock,	  1, 0 },
-	[DRM_IOCTL_NR(DRM_IOCTL_FINISH)]     = { drm_finish,	  1, 0 },
-#ifdef DRM_AGP
-	[DRM_IOCTL_NR(DRM_IOCTL_AGP_ACQUIRE)]   = {drm_agp_acquire, 1, 1},
-	[DRM_IOCTL_NR(DRM_IOCTL_AGP_RELEASE)]   = {drm_agp_release, 1, 1},
-	[DRM_IOCTL_NR(DRM_IOCTL_AGP_ENABLE)]    = {drm_agp_enable,  1, 1},
-	[DRM_IOCTL_NR(DRM_IOCTL_AGP_INFO)]      = {drm_agp_info,    1, 1},
-	[DRM_IOCTL_NR(DRM_IOCTL_AGP_ALLOC)]     = {drm_agp_alloc,   1, 1},
-	[DRM_IOCTL_NR(DRM_IOCTL_AGP_FREE)]      = {drm_agp_free,    1, 1},
-	[DRM_IOCTL_NR(DRM_IOCTL_AGP_BIND)]      = {drm_agp_unbind,  1, 1},
-	[DRM_IOCTL_NR(DRM_IOCTL_AGP_UNBIND)]    = {drm_agp_bind,    1, 1},
-#endif
-};
-#define TDFX_IOCTL_COUNT DRM_ARRAY_SIZE(tdfx_ioctls)
-
-static int
-tdfx_setup(drm_device_t *dev)
-{
-	int i;
-	
-	device_busy(dev->device);
-
-	atomic_set(&dev->ioctl_count, 0);
-	atomic_set(&dev->vma_count, 0);
-	dev->buf_use	  = 0;
-	atomic_set(&dev->buf_alloc, 0);
-
-	atomic_set(&dev->total_open, 0);
-	atomic_set(&dev->total_close, 0);
-	atomic_set(&dev->total_ioctl, 0);
-	atomic_set(&dev->total_irq, 0);
-	atomic_set(&dev->total_ctx, 0);
-	atomic_set(&dev->total_locks, 0);
-	atomic_set(&dev->total_unlocks, 0);
-	atomic_set(&dev->total_contends, 0);
-	atomic_set(&dev->total_sleeps, 0);
-
-	for (i = 0; i < DRM_HASH_SIZE; i++) {
-		dev->magiclist[i].head = NULL;
-		dev->magiclist[i].tail = NULL;
-	}
-	dev->maplist	    = NULL;
-	dev->map_count	    = 0;
-	dev->vmalist	    = NULL;
-	dev->lock.hw_lock   = NULL;
-	dev->lock.lock_queue = 0;
-	dev->queue_count    = 0;
-	dev->queue_reserved = 0;
-	dev->queue_slots    = 0;
-	dev->queuelist	    = NULL;
-	dev->irq	    = 0;
-	dev->context_flag   = 0;
-	dev->interrupt_flag = 0;
-	dev->dma            = 0;
-	dev->dma_flag	    = 0;
-	dev->last_context   = 0;
-	dev->last_switch    = 0;
-	dev->last_checked   = 0;
-	callout_init(&dev->timer);
-	dev->context_wait   = 0;
-
-	timespecclear(&dev->ctx_start);
-	timespecclear(&dev->lck_start);
-	
-	dev->buf_rp	  = dev->buf;
-	dev->buf_wp	  = dev->buf;
-	dev->buf_end	  = dev->buf + DRM_BSZ;
-	bzero(&dev->buf_sel, sizeof dev->buf_sel);
-	dev->buf_sigio	  = NULL;
-	dev->buf_readers  = 0;
-	dev->buf_writers  = 0;
-	dev->buf_selecting = 0;
-
-	tdfx_res_ctx.handle=-1;
-			
-	DRM_DEBUG("\n");
-			
-	/* The kernel's context could be created here, but is now created
-	   in drm_dma_enqueue.	This is more resource-efficient for
-	   hardware that does not do DMA, but may mean that
-	   drm_select_queue fails between the time the interrupt is
-	   initialized and the time the queues are initialized. */
-			
-	return 0;
-}
-
-
-static int
-tdfx_takedown(drm_device_t *dev)
-{
-	int		  i;
-	drm_magic_entry_t *pt, *next;
-	drm_map_t	  *map;
-	drm_vma_entry_t	  *vma, *vma_next;
-
-	DRM_DEBUG("\n");
-
-	lockmgr(&dev->dev_lock, LK_EXCLUSIVE, 0, curproc);
-	callout_stop(&dev->timer);
-	
-	if (dev->devname) {
-		drm_free(dev->devname, strlen(dev->devname)+1, DRM_MEM_DRIVER);
-		dev->devname = NULL;
-	}
-	
-	if (dev->unique) {
-		drm_free(dev->unique, strlen(dev->unique)+1, DRM_MEM_DRIVER);
-		dev->unique = NULL;
-		dev->unique_len = 0;
-	}
-				/* Clear pid list */
-	for (i = 0; i < DRM_HASH_SIZE; i++) {
-		for (pt = dev->magiclist[i].head; pt; pt = next) {
-			next = pt->next;
-			drm_free(pt, sizeof(*pt), DRM_MEM_MAGIC);
-		}
-		dev->magiclist[i].head = dev->magiclist[i].tail = NULL;
-	}
-#ifdef DRM_AGP
-				/* Clear AGP information */
-	if (dev->agp) {
-		drm_agp_mem_t *temp;
-		drm_agp_mem_t *temp_next;
-	   
-		temp = dev->agp->memory;
-		while(temp != NULL) {
-			temp_next = temp->next;
-			drm_free_agp(temp->handle, temp->pages);
-			drm_free(temp, sizeof(*temp), DRM_MEM_AGPLISTS);
-			temp = temp_next;
-		}
-
-		if (dev->agp->acquired)
-			agp_release(dev->agp->agpdev);
-		drm_free(dev->agp, sizeof(*dev->agp), DRM_MEM_AGPLISTS);
-		dev->agp = NULL;
-	}
-#endif
-	
-				/* Clear vma list (only built for debugging) */
-	if (dev->vmalist) {
-		for (vma = dev->vmalist; vma; vma = vma_next) {
-			vma_next = vma->next;
-			drm_free(vma, sizeof(*vma), DRM_MEM_VMAS);
-		}
-		dev->vmalist = NULL;
-	}
-	
-				/* Clear map area and mtrr information */
-	if (dev->maplist) {
-		for (i = 0; i < dev->map_count; i++) {
-			map = dev->maplist[i];
-			switch (map->type) {
-			case _DRM_REGISTERS:
-			case _DRM_FRAME_BUFFER:
-#ifdef CONFIG_MTRR
-				if (map->mtrr >= 0) {
-					int retcode;
-					retcode = mtrr_del(map->mtrr,
-							   map->offset,
-							   map->size);
-					DRM_DEBUG("mtrr_del = %d\n", retcode);
-				}
-#endif
-				drm_ioremapfree(map->handle, map->size);
-				break;
-			case _DRM_SHM:
-				drm_free_pages((unsigned long)map->handle,
-					       drm_order(map->size)
-					       - PAGE_SHIFT,
-					       DRM_MEM_SAREA);
-				break;
-			case _DRM_AGP:
-				break; /* XXX */
-			}
-			drm_free(map, sizeof(*map), DRM_MEM_MAPS);
-		}
-		drm_free(dev->maplist,
-			 dev->map_count * sizeof(*dev->maplist),
-			 DRM_MEM_MAPS);
-		dev->maplist   = NULL;
-		dev->map_count = 0;
-	}
-	
-	if (dev->lock.hw_lock) {
-		dev->lock.hw_lock    = NULL; /* SHM removed */
-		dev->lock.pid	     = 0;
-		wakeup(&dev->lock.lock_queue);
-	}
-	lockmgr(&dev->dev_lock, LK_RELEASE, 0, curproc);
-
-	return 0;
-}
-
-/* tdfx_init is called via tdfx_attach at module load time, */
-
-static int
-tdfx_init(device_t nbdev)
-{
-	drm_device_t *dev = device_get_softc(nbdev);
-	int          retcode;
-
-	DRM_DEBUG("\n");
-
-	memset((void *)dev, 0, sizeof(*dev));
-	simple_lock_init(&dev->count_lock);
-	lockinit(&dev->dev_lock, PZERO, "drmlk", 0, 0);
-	
-#if 0
-	drm_parse_options(tdfx);
-#endif
-
-	dev->device = nbdev;
-	dev->devnode = make_dev(&tdfx_cdevsw,
-				device_get_unit(nbdev),
-				DRM_DEV_UID,
-				DRM_DEV_GID,
-				DRM_DEV_MODE,
-				TDFX_NAME);
-	dev->name   = TDFX_NAME;
-
-	drm_mem_init();
-	drm_sysctl_init(dev);
-	TAILQ_INIT(&dev->files);
-
-#ifdef DRM_AGP
-	dev->agp    = drm_agp_init();
-#endif
-	if((retcode = drm_ctxbitmap_init(dev))) {
-		DRM_ERROR("Cannot allocate memory for context bitmap.\n");
-		drm_sysctl_cleanup(dev);
-		tdfx_takedown(dev);
-		return retcode;
-	}
-
-	DRM_INFO("Initialized %s %d.%d.%d %s on minor %d\n",
-		 TDFX_NAME,
-		 TDFX_MAJOR,
-		 TDFX_MINOR,
-		 TDFX_PATCHLEVEL,
-		 TDFX_DATE,
-		 device_get_unit(nbdev));
-	
-	return 0;
-}
-
-/* tdfx_cleanup is called via tdfx_detach at module unload time. */
-
-static void
-tdfx_cleanup(device_t nbdev)
-{
-	drm_device_t *dev = device_get_softc(nbdev);
-
-	DRM_DEBUG("\n");
-	
-	drm_sysctl_cleanup(dev);
-	destroy_dev(dev->devnode);
-
-	DRM_INFO("Module unloaded\n");
-
-	drm_ctxbitmap_cleanup(dev);
-	tdfx_takedown(dev);
-}
-
-static int
-tdfx_version(dev_t kdev, u_long cmd, caddr_t data, int flags, struct proc *p)
-{
-	drm_version_t version;
-	int	      len;
-
-	version = *(drm_version_t *) data;
-
-#define DRM_COPY(name,value)				\
-	len = strlen(value);				\
-	if (len > name##_len) len = name##_len;		\
-	name##_len = strlen(value);			\
-	if (len && name) {				\
-		int error = copyout(value, name, len);	\
-		if (error) return error;		\
-	}
-
-	version.version_major	   = TDFX_MAJOR;
-	version.version_minor	   = TDFX_MINOR;
-	version.version_patchlevel = TDFX_PATCHLEVEL;
-
-	DRM_COPY(version.name, TDFX_NAME);
-	DRM_COPY(version.date, TDFX_DATE);
-	DRM_COPY(version.desc, TDFX_DESC);
-
-	*(drm_version_t *) data = version;
-	return 0;
-}
-
-static int
-tdfx_open(dev_t kdev, int flags, int fmt, struct proc *p)
-{
-	drm_device_t  *dev    = TDFX_SOFTC(minor(kdev));
-	int	      retcode = 0;
-	
-	DRM_DEBUG("open_count = %d\n", dev->open_count);
-
-	device_busy(dev->device);
-	if (!(retcode = drm_open_helper(kdev, flags, fmt, p, dev))) {
-		atomic_inc(&dev->total_open);
-		simple_lock(&dev->count_lock);
-		if (!dev->open_count++) {
-			simple_unlock(&dev->count_lock);
-			retcode = tdfx_setup(dev);
-		}
-		simple_unlock(&dev->count_lock);
-	}
-	device_unbusy(dev->device);
-
-	return retcode;
-}
-
-static int
-tdfx_close(dev_t kdev, int flags, int fmt, struct proc *p)
-{
-	drm_device_t  *dev    = kdev->si_drv1;
-	int	      retcode = 0;
-
-	DRM_DEBUG("open_count = %d\n", dev->open_count);
-	if (!(retcode = drm_close(kdev, flags, fmt, p))) {
-		atomic_inc(&dev->total_close);
-		simple_lock(&dev->count_lock);
-		if (!--dev->open_count) {
-			if (atomic_read(&dev->ioctl_count) || dev->blocked) {
-				DRM_ERROR("Device busy: %d %d\n",
-					  atomic_read(&dev->ioctl_count),
-					  dev->blocked);
-				simple_unlock(&dev->count_lock);
-				return EBUSY;
-			}
-			simple_unlock(&dev->count_lock);
-			device_unbusy(dev->device);
-			return tdfx_takedown(dev);
-		}
-		simple_unlock(&dev->count_lock);
-	}
-
-	return retcode;
-}
-
-/* tdfx_ioctl is called whenever a process performs an ioctl on /dev/drm. */
-
-static int
-tdfx_ioctl(dev_t kdev, u_long cmd, caddr_t data, int flags, struct proc *p)
-{
-	int		 nr	 = DRM_IOCTL_NR(cmd);
-	drm_device_t	 *dev	 = kdev->si_drv1;
-	drm_file_t       *priv;
-	int		 retcode = 0;
-	drm_ioctl_desc_t *ioctl;
-	d_ioctl_t	 *func;
-
-	DRM_DEBUG("dev=%p\n", dev);
-	priv = drm_find_file_by_proc(dev, p);
-	if (!priv) {
-		DRM_DEBUG("can't find authenticator\n");
-		return EINVAL;
-	}
-
-	atomic_inc(&dev->ioctl_count);
-	atomic_inc(&dev->total_ioctl);
-	++priv->ioctl_count;
-	
-	DRM_DEBUG("pid = %d, cmd = 0x%02lx, nr = 0x%02x, auth = %d\n",
-		  p->p_pid, cmd, nr, priv->authenticated);
-
-	switch (cmd) {
-	case FIONBIO:
-		atomic_dec(&dev->ioctl_count);
-		return 0;
-
-	case FIOASYNC:
-		atomic_dec(&dev->ioctl_count);
-		dev->flags |= FASYNC;
-		return 0;
-
-	case FIOSETOWN:
-		atomic_dec(&dev->ioctl_count);
-		return fsetown(*(int *)data, &dev->buf_sigio);
-
-	case FIOGETOWN:
-		atomic_dec(&dev->ioctl_count);
-		*(int *) data = fgetown(dev->buf_sigio);
-		return 0;
-	}
-
-	if (nr >= TDFX_IOCTL_COUNT) {
-		retcode = EINVAL;
-	} else {
-		ioctl	  = &tdfx_ioctls[nr];
-		func	  = ioctl->func;
-
-		if (!func) {
-			DRM_DEBUG("no function\n");
-			retcode = EINVAL;
-		} else if ((ioctl->root_only && suser(p))
-			    || (ioctl->auth_needed && !priv->authenticated)) {
-			retcode = EACCES;
-		} else {
-			retcode = (func)(kdev, cmd, data, flags, p);
-		}
-	}
-	
-	atomic_dec(&dev->ioctl_count);
-	return retcode;
-}
-
-static int
-tdfx_lock(dev_t kdev, u_long cmd, caddr_t data, int flags, struct proc *p)
-{
-        drm_device_t      *dev    = kdev->si_drv1;
-        int               ret   = 0;
-        drm_lock_t        lock;
-#if DRM_DMA_HISTOGRAM
-
-        getnanotime(&dev->lck_start);
-#endif
+#include "tdfx.h"
+#include "drmP.h"
 
-	lock = *(drm_lock_t *) data;
+#define DRIVER_AUTHOR		"VA Linux Systems Inc."
 
-        if (lock.context == DRM_KERNEL_CONTEXT) {
-                DRM_ERROR("Process %d using kernel context %d\n",
-                          p->p_pid, lock.context);
-                return EINVAL;
-        }
+#define DRIVER_NAME		"tdfx"
+#define DRIVER_DESC		"3dfx Banshee/Voodoo3+"
+#define DRIVER_DATE		"20010216"
 
-        DRM_DEBUG("%d (pid %d) requests lock (0x%08x), flags = 0x%08x\n",
-                  lock.context, p->p_pid, dev->lock.hw_lock->lock,
-                  lock.flags);
+#define DRIVER_MAJOR		1
+#define DRIVER_MINOR		0
+#define DRIVER_PATCHLEVEL	0
 
-#if 0
-				/* dev->queue_count == 0 right now for
-                                   tdfx.  FIXME? */
-        if (lock.context < 0 || lock.context >= dev->queue_count)
-                return EINVAL;
+#ifndef PCI_VENDOR_ID_3DFX
+#define PCI_VENDOR_ID_3DFX 0x121A
 #endif
-        
-        if (!ret) {
-#if 0
-                if (_DRM_LOCKING_CONTEXT(dev->lock.hw_lock->lock)
-                    != lock.context) {
-                        long j = ticks - dev->lock.lock_time;
-
-                        if (lock.context == tdfx_res_ctx.handle &&
-				j >= 0 && j < DRM_LOCK_SLICE) {
-                                /* Can't take lock if we just had it and
-                                   there is contention. */
-                                DRM_DEBUG("%d (pid %d) delayed j=%d dev=%d ticks=%d\n",
-					lock.context, p->p_pid, j, 
-					dev->lock.lock_time, ticks);
-				ret = tsleep(&never, PZERO|PCATCH, "drmlk1",
-					       DRM_LOCK_SLICE - j);
-				if (ret)
-					return ret;
-				DRM_DEBUG("ticks=%d\n", ticks);
-                        }
-                }
+#ifndef PCI_DEVICE_ID_3DFX_VOODOO5
+#define PCI_DEVICE_ID_3DFX_VOODOO5 0x0009
 #endif
-                for (;;) {
-                        if (!dev->lock.hw_lock) {
-                                /* Device has been unregistered */
-                                ret = EINTR;
-                                break;
-                        }
-                        if (drm_lock_take(&dev->lock.hw_lock->lock,
-                                          lock.context)) {
-                                dev->lock.pid       = p->p_pid;
-                                dev->lock.lock_time = ticks;
-                                atomic_inc(&dev->total_locks);
-                                break;  /* Got lock */
-                        }
-                        
-                                /* Contention */
-                        atomic_inc(&dev->total_sleeps);
-			ret = tsleep(&dev->lock.lock_queue,
-				       PZERO|PCATCH,
-				       "drmlk2",
-				       0);
-			if (ret)
-				break;
-                }
-        }
-
-#if 0
-	if (!ret && dev->last_context != lock.context &&
-		lock.context != tdfx_res_ctx.handle &&
-		dev->last_context != tdfx_res_ctx.handle) {
-		add_wait_queue(&dev->context_wait, &entry);
-	        current->state = TASK_INTERRUPTIBLE;
-                /* PRE: dev->last_context != lock.context */
-	        tdfx_context_switch(dev, dev->last_context, lock.context);
-		/* POST: we will wait for the context
-                   switch and will dispatch on a later call
-                   when dev->last_context == lock.context
-                   NOTE WE HOLD THE LOCK THROUGHOUT THIS
-                   TIME! */
-		current->policy |= SCHED_YIELD;
-	        schedule();
-	        current->state = TASK_RUNNING;
-	        remove_wait_queue(&dev->context_wait, &entry);
-	        if (signal_pending(current)) {
-	                ret = EINTR;
-	        } else if (dev->last_context != lock.context) {
-			DRM_ERROR("Context mismatch: %d %d\n",
-                        	dev->last_context, lock.context);
-	        }
-	}
+#ifndef PCI_DEVICE_ID_3DFX_VOODOO4
+#define PCI_DEVICE_ID_3DFX_VOODOO4 0x0007
 #endif
-
-        if (!ret) {
-                if (lock.flags & _DRM_LOCK_READY) {
-				/* Wait for space in DMA/FIFO */
-		}
-                if (lock.flags & _DRM_LOCK_QUIESCENT) {
-				/* Make hardware quiescent */
-#if 0
-                        tdfx_quiescent(dev);
+#ifndef PCI_DEVICE_ID_3DFX_VOODOO3_3000 /* Voodoo3 3000 */
+#define PCI_DEVICE_ID_3DFX_VOODOO3_3000 0x0005
 #endif
-		}
-        }
-
-#if 0
-	DRM_ERROR("pid = %5d, old counter = %5ld\n", 
-		p->p_pid, current->counter);
+#ifndef PCI_DEVICE_ID_3DFX_VOODOO3_2000 /* Voodoo3 3000 */
+#define PCI_DEVICE_ID_3DFX_VOODOO3_2000 0x0004
 #endif
-#if 0
-	while (current->counter > 25)
-		current->counter >>= 1; /* decrease time slice */
-	DRM_ERROR("pid = %5d, new counter = %5ld\n",
-		 p->p_pid, current->counter);
+#ifndef PCI_DEVICE_ID_3DFX_BANSHEE
+#define PCI_DEVICE_ID_3DFX_BANSHEE 0x0003
 #endif
-        DRM_DEBUG("%d %s\n", lock.context, ret ? "interrupted" : "has lock");
 
-#if DRM_DMA_HISTOGRAM
-	{
-	    struct timespec ts;
-	    getnanotime(&ts);
-	    timespecsub(&ts, &dev->lck_start);
-	    atomic_inc(&dev->histo.lhld[drm_histogram_slot(&ts)]);
-	}
-#endif
-        
-        return ret;
-}
+/* List acquired from http://www.yourvote.com/pci/pcihdr.h and xc/xc/programs/Xserver/hw/xfree86/common/xf86PciInfo.h
+ * Please report to anholt@teleport.com inaccuracies or if a chip you have works that is marked unsupported here.
+ */
+drm_chipinfo_t DRM(devicelist)[] = {
+	{0x121a, 0x0003, 1, "3dfx Voodoo Banshee"},
+	{0x121a, 0x0004, 1, "3dfx Voodoo3 2000"},
+	{0x121a, 0x0005, 1, "3dfx Voodoo3 3000"},
+	{0x121a, 0x0007, 1, "3dfx Voodoo4"},
+	{0x121a, 0x0009, 1, "3dfx Voodoo5"},
+	{0, 0, 0, NULL}
+};
 
 
-static int
-tdfx_unlock(dev_t kdev, u_long cmd, caddr_t data, int flags, struct proc *p)
-{
-	drm_device_t	  *dev	  = kdev->si_drv1;
-	drm_lock_t	  lock;
+#include "drm_auth.h"
+#include "drm_bufs.h"
+#include "drm_context.h"
+#include "drm_dma.h"
+#include "drm_drawable.h"
+#include "drm_drv.h"
 
-	lock = *(drm_lock_t *) data;
-	
-	if (lock.context == DRM_KERNEL_CONTEXT) {
-		DRM_ERROR("Process %d using kernel context %d\n",
-			  p->p_pid, lock.context);
-		return EINVAL;
-	}
 
-	DRM_DEBUG("%d frees lock (%d holds)\n",
-		  lock.context,
-		  _DRM_LOCKING_CONTEXT(dev->lock.hw_lock->lock));
-	atomic_inc(&dev->total_unlocks);
-	if (_DRM_LOCK_IS_CONT(dev->lock.hw_lock->lock))
-		atomic_inc(&dev->total_contends);
-	drm_lock_transfer(dev, &dev->lock.hw_lock->lock, DRM_KERNEL_CONTEXT);
-				/* FIXME: Try to send data to card here */
-	if (!dev->context_flag) {
-		if (drm_lock_free(dev, &dev->lock.hw_lock->lock,
-				  DRM_KERNEL_CONTEXT)) {
-			DRM_ERROR("\n");
-		}
-	}
+#include "drm_fops.h"
+#include "drm_init.h"
+#include "drm_ioctl.h"
+#include "drm_lock.h"
+#include "drm_memory.h"
+#include "drm_vm.h"
+#include "drm_sysctl.h"
 
-	return 0;
-}
+DRIVER_MODULE(tdfx, pci, tdfx_driver, tdfx_devclass, 0, 0);
diff --git a/bsd/tdfx/tdfx_drv.h b/bsd/tdfx/tdfx_drv.h
deleted file mode 100644
index 5b27e052..00000000
--- a/bsd/tdfx/tdfx_drv.h
+++ /dev/null
@@ -1,45 +0,0 @@
-/* tdfx_drv.h -- Private header for tdfx driver -*- c -*-
- * Created: Thu Oct  7 10:40:04 1999 by faith@precisioninsight.com
- *
- * Copyright 1999 Precision Insight, Inc., Cedar Park, Texas.
- * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
- * All rights reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice (including the next
- * paragraph) shall be included in all copies or substantial portions of the
- * Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * PRECISION INSIGHT 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 _TDFX_DRV_H_
-#define _TDFX_DRV_H_
-
-				/* tdfx_context.c */
-
-extern d_ioctl_t tdfx_resctx;
-extern d_ioctl_t tdfx_addctx;
-extern d_ioctl_t tdfx_modctx;
-extern d_ioctl_t tdfx_getctx;
-extern d_ioctl_t tdfx_switchctx;
-extern d_ioctl_t tdfx_newctx;
-extern d_ioctl_t tdfx_rmctx;
-
-extern int  tdfx_context_switch(drm_device_t *dev, int old, int new);
-extern int  tdfx_context_switch_complete(drm_device_t *dev, int new);
-#endif