Index: drmP.h
===================================================================
RCS file: /cvsroot/dri/xc/xc/programs/Xserver/hw/xfree86/os-support/bsd/drm/kernel/drmP.h,v
retrieving revision 1.16
diff -u -r1.16 drmP.h
--- drmP.h	29 Mar 2003 18:22:28 -0000	1.16
+++ drmP.h	1 Apr 2003 22:45:41 -0000
@@ -271,10 +271,10 @@
 	int		  minor;
 	pid_t		  pid;
 	uid_t		  uid;
-	int		  refs;
 	drm_magic_t	  magic;
 	unsigned long	  ioctl_count;
-	struct drm_device *devXX;
+	struct drm_device *dev;
+	dev_t		  kdev;
 };
 
 typedef struct drm_queue {
@@ -414,7 +414,6 @@
 	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		   */
 
@@ -423,7 +422,6 @@
 	struct lock       dev_lock;	/* For others			   */
 				/* Usage Counters */
 	int		  open_count;	/* Outstanding files open	   */
-	atomic_t	  ioctl_count;	/* Outstanding IOCTLs pending	   */
 	int		  buf_use;	/* Buffers in use -- cannot alloc  */
 	atomic_t	  buf_alloc;	/* Buffer allocation in progress   */
 
@@ -486,22 +484,6 @@
 #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			   */
-#ifdef __FreeBSD__
-	struct sigio      *buf_sigio;	/* Processes waiting for SIGIO     */
-#elif defined(__NetBSD__)
-	pid_t		  buf_pgid;
-#endif
-	struct selinfo    buf_sel;	/* Workspace for select/poll       */
-	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;
Index: drm_auth.h
===================================================================
RCS file: /cvsroot/dri/xc/xc/programs/Xserver/hw/xfree86/os-support/bsd/drm/kernel/drm_auth.h,v
retrieving revision 1.5
diff -u -r1.5 drm_auth.h
--- drm_auth.h	11 Mar 2003 20:51:21 -0000	1.5
+++ drm_auth.h	1 Apr 2003 22:45:41 -0000
@@ -117,8 +117,10 @@
 {
 	static drm_magic_t sequence = 0;
 	drm_auth_t	   auth;
+	drm_file_t *priv;
 	DRM_DEVICE;
-	DRM_PRIV;
+	
+	DRM_GET_PRIV();
 
 				/* Find unique magic */
 	if (priv->magic) {
Index: drm_context.h
===================================================================
RCS file: /cvsroot/dri/xc/xc/programs/Xserver/hw/xfree86/os-support/bsd/drm/kernel/drm_context.h,v
retrieving revision 1.4
diff -u -r1.4 drm_context.h
--- drm_context.h	11 Mar 2003 20:51:21 -0000	1.4
+++ drm_context.h	1 Apr 2003 22:45:41 -0000
@@ -206,8 +206,6 @@
 
 int DRM(context_switch)( drm_device_t *dev, int old, int new )
 {
-        char buf[64];
-
         if ( test_and_set_bit( 0, &dev->context_flag ) ) {
                 DRM_ERROR( "Reentering -- FIXME\n" );
                 return DRM_ERR(EBUSY);
@@ -226,9 +224,6 @@
 
         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 );
         }
 
         return 0;
@@ -412,9 +407,6 @@
 
 	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);
Index: drm_drv.h
===================================================================
RCS file: /cvsroot/dri/xc/xc/programs/Xserver/hw/xfree86/os-support/bsd/drm/kernel/drm_drv.h,v
retrieving revision 1.14
diff -u -r1.14 drm_drv.h
--- drm_drv.h	29 Mar 2003 18:22:28 -0000	1.14
+++ drm_drv.h	1 Apr 2003 22:45:42 -0000
@@ -222,15 +222,28 @@
 #define DRIVER_IOCTL_COUNT	DRM_ARRAY_SIZE( DRM(ioctls) )
 
 const char *DRM(find_description)(int vendor, int device);
+int DRM(ioctl_handle)( dev_t kdev, u_long cmd, caddr_t data, int flags,
+    DRM_STRUCTPROC *p, struct file *filp );
 
 #ifdef __FreeBSD__
+static d_open_t DRM(open);
+static fo_close_t DRM(close);
+static fo_ioctl_t DRM(ioctl);
+static fo_kqfilter_t DRM(kqfilter);
+static fo_stat_t DRM(stat);
+static fo_rdwr_t DRM(read);
+static fo_rdwr_t DRM(write);
+static fo_poll_t DRM(poll);
+
 static struct cdevsw DRM(cdevsw) = {
 	.d_open =	DRM( open ),
+	/*
 	.d_close =	DRM( close ),
 	.d_read =	DRM( read ),
 	.d_write =	DRM( write ),
 	.d_ioctl =	DRM( ioctl ),
 	.d_poll =	DRM( poll ),
+	*/
 	.d_mmap =	DRM( mmap ),
 	.d_name =	DRIVER_NAME,
 	.d_maj =	CDEV_MAJOR,
@@ -240,6 +253,17 @@
 #endif
 };
 
+/* The DRM requires private data per opening of the device.
+ * This is not available normally to devices, but following the
+ * lead of dev/streams/streams.c, we hijack struct file
+ * and use our own fileops so we can have device private data
+ * and get the struct file in the close routine.
+ */
+static struct fileops DRM(fileops) = {
+	DRM(read), DRM(write), DRM(ioctl), DRM(poll),
+	DRM(kqfilter), DRM(stat), DRM(close)
+};
+
 static int DRM(probe)(device_t dev)
 {
 	const char *s = NULL;
@@ -432,7 +456,6 @@
 	int i;
 
 	DRIVER_PRESETUP();
-	atomic_set( &dev->ioctl_count, 0 );
 	dev->buf_use = 0;
 	atomic_set( &dev->buf_alloc, 0 );
 
@@ -518,18 +541,6 @@
 	dev->ctx_start = 0;
 	dev->lck_start = 0;
 
-	dev->buf_rp = dev->buf;
-	dev->buf_wp = dev->buf;
-	dev->buf_end = dev->buf + DRM_BSZ;
-#ifdef __FreeBSD__
-	dev->buf_sigio = NULL;
-#elif defined(__NetBSD__)
-	dev->buf_pgid = 0;
-#endif
-	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
@@ -542,7 +553,7 @@
 	return 0;
 }
 
-
+/* Called from DRM(close) on the last close of the device */
 static int DRM(takedown)( drm_device_t *dev )
 {
 	drm_magic_entry_t *pt, *next;
@@ -887,44 +898,116 @@
 	return 0;
 }
 
-int DRM(open)(dev_t kdev, int flags, int fmt, DRM_STRUCTPROC *p)
+#if defined(__FreeBSD__) && (__FreeBSD_version >= 500000)
+int DRM(open)(dev_t kdev, int flags, int fmt, struct thread *td)
+#else
+int DRM(open)(dev_t kdev, int flags, int fmt, struct proc *p)
+#endif
 {
 	drm_device_t *dev = NULL;
 	int retcode = 0;
+	int fd;
+	struct file *filp;
+	drm_file_t *priv;
+#if defined(__FreeBSD__) && __FreeBSD_version >= 500000
+	struct proc *p = td->td_proc;
+#endif
 
 	dev = DRIVER_SOFTC(minor(kdev));
 
 	DRM_DEBUG( "open_count = %d\n", dev->open_count );
 
-	retcode = DRM(open_helper)(kdev, flags, fmt, p, dev);
+	if (flags & O_EXCL)
+		return EBUSY; /* No exclusive opens */
+	dev->flags = flags;
+
+	priv = (drm_file_t *) DRM(alloc)(sizeof(*priv), DRM_MEM_FILES);
+	if (priv == NULL)
+		return ENOMEM;
+	bzero(priv, sizeof(*priv));
+#if __FreeBSD_version >= 500000
+	priv->uid		= td->td_proc->p_ucred->cr_svuid;
+	priv->pid		= td->td_proc->p_pid;
+#else
+	priv->uid		= p->p_cred->p_svuid;
+	priv->pid		= p->p_pid;
+#endif
+	priv->minor		= minor(kdev);
+	priv->dev		= dev;
+	priv->ioctl_count 	= 0;
+#if __FreeBSD_version >= 500000
+	priv->authenticated	= !DRM_SUSER(td);
+#else
+	priv->authenticated	= !DRM_SUSER(p);
+#endif
+	kdev->si_drv1 = dev;
+	priv->kdev = kdev;
 
-	if ( !retcode ) {
-		atomic_inc( &dev->counts[_DRM_STAT_OPENS] );
-		DRM_SPINLOCK( &dev->count_lock );
 #ifdef __FreeBSD__
-		device_busy(dev->device);
-#endif
-		if ( !dev->open_count++ )
-			retcode = DRM(setup)( dev );
-		DRM_SPINUNLOCK( &dev->count_lock );
+	if ((retcode = falloc(td, &filp, &fd)) != 0) {
+		FILEDESC_LOCK(p->p_fd);
+		p->p_fd->fd_ofiles[fd] = 0;
+		FILEDESC_UNLOCK(p->p_fd);
+		ffree(filp);
+		DRM(free)(priv, sizeof(*priv), DRM_MEM_FILES);
+		return retcode;
 	}
 
-	return retcode;
+	device_busy(dev->device);
+#endif
+	DRM_SPINLOCK( &dev->count_lock );
+	if ( !dev->open_count++ )
+		retcode = DRM(setup)( dev );
+	DRM_SPINUNLOCK( &dev->count_lock );
+	atomic_inc( &dev->counts[_DRM_STAT_OPENS] );
+
+	/* Insert our new drm_file_t into the list */
+	DRM_LOCK;
+	TAILQ_INSERT_TAIL(&dev->files, priv, link);
+	DRM_UNLOCK;
+
+#ifdef __NetBSD__
+	return 0;
+#else
+	/* Initialize the new struct file */
+	FILEDESC_LOCK(p->p_fd);
+	filp->f_data = priv;
+	filp->f_flag = FREAD|FWRITE;
+	filp->f_ops = &DRM(fileops);
+	filp->f_type = DTYPE_VNODE;
+	FILEDESC_UNLOCK(p->p_fd);
+
+	/* Set dupfd and return ENXIO.  This will cause the previous
+	 * struct file to be destroyed and our new one used instead.
+	 */
+	PROC_LOCK(p);
+	td->td_dupfd = fd;
+	PROC_UNLOCK(p);
+	return ENXIO;
+#endif
 }
 
+#if defined(__FreeBSD__) && (__FreeBSD_version >= 500000)
+int DRM(close)(struct file *filp, struct thread *td)
+#else
 int DRM(close)(dev_t kdev, int flags, int fmt, DRM_STRUCTPROC *p)
+#endif
 {
 	drm_file_t *priv;
-	DRM_DEVICE;
 	int retcode = 0;
+#ifdef __NetBSD__
+	DRM_DEVICE;
 	DRMFILE __unused filp = (void *)(DRM_CURRENTPID);
-	
+#else
+	drm_device_t *dev;
+#endif
+
 	DRM_DEBUG( "open_count = %d\n", dev->open_count );
-	priv = DRM(find_file_by_proc)(dev, p);
-	if (!priv) {
-		DRM_DEBUG("can't find authenticator\n");
-		return EINVAL;
-	}
+	
+	DRM_GET_PRIV();
+#if defined(__FreeBSD__) && (__FreeBSD_version >= 500000)
+	dev = priv->dev;
+#endif
 
 	DRIVER_PRERELEASE();
 
@@ -994,23 +1077,9 @@
 	DRM(reclaim_buffers)( dev, (void *)priv->pid );
 #endif
 
-#if defined (__FreeBSD__) && (__FreeBSD_version >= 500000)
-	funsetown(&dev->buf_sigio);
-#elif defined(__FreeBSD__)
-	funsetown(dev->buf_sigio);
-#elif defined(__NetBSD__)
-	dev->buf_pgid = 0;
-#endif /* __NetBSD__ */
-
 	DRM_LOCK;
-	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 );
-		}
-	}
+	TAILQ_REMOVE(&dev->files, priv, link);
+	DRM(free)( priv, sizeof(*priv), DRM_MEM_FILES );
 	DRM_UNLOCK;
 
 
@@ -1020,38 +1089,48 @@
 
 	atomic_inc( &dev->counts[_DRM_STAT_CLOSES] );
 	DRM_SPINLOCK( &dev->count_lock );
-#ifdef __FreeBSD__
-	device_unbusy(dev->device);
-#endif
-	if ( !--dev->open_count ) {
-		if ( atomic_read( &dev->ioctl_count ) || dev->blocked ) {
-			DRM_ERROR( "Device busy: %ld %d\n",
-				(unsigned long)atomic_read( &dev->ioctl_count ),
-				   dev->blocked );
-			DRM_SPINUNLOCK( &dev->count_lock );
-			return DRM_ERR(EBUSY);
-		}
-		DRM_SPINUNLOCK( &dev->count_lock );
+	if (--dev->open_count == 0) {
 		return DRM(takedown)( dev );
+		DRM_SPINUNLOCK( &dev->count_lock );
 	}
 	DRM_SPINUNLOCK( &dev->count_lock );
+#ifdef __FreeBSD__
+	device_unbusy(dev->device);
+#endif
 	
 	return retcode;
 }
 
-/* DRM(ioctl) is called whenever a process performs an ioctl on /dev/drm.
- */
+#if defined(__FreeBSD__)
+int DRM(ioctl)(struct file *filp, u_long com, void *data,
+		    struct ucred *active_cred, DRM_STRUCTPROC *p)
+{
+	drm_file_t *priv = filp->f_data;
+
+	return DRM(ioctl_handle)( priv->kdev, com, data, filp->f_flag, p, filp );
+}
+#else
 int DRM(ioctl)(dev_t kdev, u_long cmd, caddr_t data, int flags, 
     DRM_STRUCTPROC *p)
+
 {
+	DRMFILE __unused filp = (void *)(DRM_CURRENTPID);
+
+	return DRM(ioctl_handle)( priv->kdev, com, data, filp->f_flag, p, filp );
+}
+#endif
+
+int DRM(ioctl_handle)( dev_t kdev, u_long cmd, caddr_t data, int flags,
+    DRM_STRUCTPROC *p, struct file *filp ) {
 	DRM_DEVICE;
 	int retcode = 0;
 	drm_ioctl_desc_t *ioctl;
 	int (*func)(DRM_IOCTL_ARGS);
 	int nr = DRM_IOCTL_NR(cmd);
-	DRM_PRIV;
-
-	atomic_inc( &dev->ioctl_count );
+	drm_file_t *priv;
+	
+	DRM_GET_PRIV();
+	
 	atomic_inc( &dev->counts[_DRM_STAT_IOCTLS] );
 	++priv->ioctl_count;
 
@@ -1065,39 +1144,10 @@
 
 	switch (cmd) {
 	case FIONBIO:
-		atomic_dec(&dev->ioctl_count);
 		return 0;
-
 	case FIOASYNC:
-		atomic_dec(&dev->ioctl_count);
 		dev->flags |= FASYNC;
 		return 0;
-
-#ifdef __FreeBSD__
-	case FIOSETOWN:
-		atomic_dec(&dev->ioctl_count);
-		return fsetown(*(int *)data, &dev->buf_sigio);
-
-	case FIOGETOWN:
-		atomic_dec(&dev->ioctl_count);
-#if (__FreeBSD_version >= 500000)
-		*(int *) data = fgetown(&dev->buf_sigio);
-#else
-		*(int *) data = fgetown(dev->buf_sigio);
-#endif
-		return 0;
-#endif /* __FreeBSD__ */
-#ifdef __NetBSD__
-	case TIOCSPGRP:
-		atomic_dec(&dev->ioctl_count);
-		dev->buf_pgid = *(int *)data;
-		return 0;
-
-	case TIOCGPGRP:
-		atomic_dec(&dev->ioctl_count);
-		*(int *)data = dev->buf_pgid;
-		return 0;
-#endif /* __NetBSD__ */
 	}
 
 	if ( nr >= DRIVER_IOCTL_COUNT ) {
@@ -1113,14 +1163,56 @@
 			 || ( ioctl->auth_needed && !priv->authenticated ) ) {
 			retcode = EACCES;
 		} else {
-			retcode = func(kdev, cmd, data, flags, p, (void *)DRM_CURRENTPID);
+			retcode = func(kdev, cmd, data, flags, p, filp);
 		}
 	}
 
-	atomic_dec( &dev->ioctl_count );
 	return DRM_ERR(retcode);
 }
 
+/* Stub fops for things that shouldn't be called on
+ * the DRM. */
+static int
+DRM(stat)(struct file *filp, struct stat *sb, 
+    struct ucred *active_cred, struct thread *td)
+{
+	return EBADF;
+}
+
+static int
+DRM(kqfilter)(struct file *filp, struct knote *kn)
+{
+
+	return EBADF;
+}
+
+/* The read/write/poll functions were previously used to supply some
+ * simple context switch information, but appeared to not work on 
+ * BSD and were removed for not being useful.
+ */
+static int
+DRM(read)(struct file *filp, struct uio *uio,
+		    struct ucred *active_cred, int flags,
+		    struct thread *td)
+{
+	return ENODEV;
+}
+
+static int
+DRM(write)(struct file *filp, struct uio *uio,
+		    struct ucred *active_cred, int flags,
+		    struct thread *td)
+{
+	return ENODEV;
+}
+
+static int
+DRM(poll)(struct file *filp, int events,
+		    struct ucred *active_cred, DRM_STRUCTPROC *p)
+{
+	return ENODEV;
+}
+
 int DRM(lock)( DRM_IOCTL_ARGS )
 {
 	DRM_DEVICE;
@@ -1177,7 +1269,7 @@
                                 /* Contention */
 			ret = tsleep((void *)&dev->lock.lock_queue,
 					PZERO|PCATCH,
-					"drmlk2",
+					"drmlk3",
 					0);
 			if (ret)
 				break;
@@ -1299,10 +1391,11 @@
 	caddr_t		data=NULL, memp=NULL;
 	u_int		size = IOCPARM_LEN(cmd);
 	int		error;
+	drm_file_t	*priv;
 #if (__FreeBSD_version >= 500000)
-	struct file	*fp;
+	struct file	*filp;
 #else
-	struct file	*fp = p->p_fd->fd_ofiles[args->fd];
+	struct file	*filp = p->p_fd->fd_ofiles[args->fd];
 #endif
 	if ( size > STK_PARAMS ) {
 		if ( size > IOCPARM_MAX )
@@ -1335,15 +1428,16 @@
 	}
 
 #if (__FreeBSD_version >= 500000)
-	if ( (error = fget( p, args->fd, &fp )) != 0 ) {
+	if ( (error = fget( p, args->fd, &filp )) != 0 ) {
 		if ( memp )
 			free( memp, DRM(M_DRM) );
 		return (error);
 	}
-	error = fo_ioctl( fp, cmd, data, p->td_ucred, p );
-	fdrop( fp, p );
-#else
-	error = fo_ioctl( fp, cmd, data, p );
+#endif
+	priv = filp->f_data;
+	DRM(ioctl_handle)( priv->kdev, cmd, data, filp->f_flag, p, filp );
+#if (__FreeBSD_version >= 500000)
+	fdrop( filp, p );
 #endif
 	if ( error == 0 && (cmd & LINUX_IOC_OUT) && size )
 		error = copyout( data, (caddr_t)args->arg, (u_int)size );
Index: drm_fops.h
===================================================================
RCS file: /cvsroot/dri/xc/xc/programs/Xserver/hw/xfree86/os-support/bsd/drm/kernel/drm_fops.h,v
retrieving revision 1.4
diff -u -r1.4 drm_fops.h
--- drm_fops.h	11 Mar 2003 20:51:22 -0000	1.4
+++ drm_fops.h	1 Apr 2003 22:45:42 -0000
@@ -51,195 +51,3 @@
 	return NULL;
 }
 
-/* DRM(open) is called whenever a process opens /dev/drm. */
-
-int DRM(open_helper)(dev_t kdev, int flags, int fmt, DRM_STRUCTPROC *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;
-	if (!DRM(cpu_valid)())
-		return DRM_ERR(EINVAL);
-
-	DRM_DEBUG("pid = %d, minor = %d\n", DRM_CURRENTPID, m);
-
-	/* FIXME: linux mallocs and bzeros here */
-	priv = (drm_file_t *) DRM(find_file_by_proc)(dev, p);
-	if (priv) {
-		priv->refs++;
-	} else {
-		priv = (drm_file_t *) DRM(alloc)(sizeof(*priv), DRM_MEM_FILES);
-		bzero(priv, sizeof(*priv));
-#if __FreeBSD_version >= 500000
-		priv->uid		= p->td_proc->p_ucred->cr_svuid;
-		priv->pid		= p->td_proc->p_pid;
-#else
-		priv->uid		= p->p_cred->p_svuid;
-		priv->pid		= p->p_pid;
-#endif
-
-		priv->refs		= 1;
-		priv->minor		= m;
-		priv->devXX		= dev;
-		priv->ioctl_count 	= 0;
-		priv->authenticated	= !DRM_SUSER(p);
-		DRM_LOCK;
-		TAILQ_INSERT_TAIL(&dev->files, priv, link);
-		DRM_UNLOCK;
-	}
-#ifdef __FreeBSD__
-	kdev->si_drv1 = dev;
-#endif
-	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. */
-
-int DRM(read)(dev_t kdev, struct uio *uio, int ioflag)
-{
-	DRM_DEVICE;
-	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;
-#ifdef __NetBSD__
-	struct proc *p;
-#endif /* __NetBSD__ */
-
-	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);
-	}
-		
-#ifdef __FreeBSD__
-	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);
-#if __FreeBSD_version >= 500000
-		pgsigio(&dev->buf_sigio, SIGIO, 0);
-#else
-		pgsigio(dev->buf_sigio, SIGIO, 0);
-#endif /* __FreeBSD_version */
-	}
-#endif /* __FreeBSD__ */
-#ifdef __NetBSD__
-	if (dev->buf_pgid) {
-		DRM_DEBUG("dev->buf_pgid=%d\n", dev->buf_pgid);
-		if(dev->buf_pgid > 0)
-			gsignal(dev->buf_pgid, SIGIO);
-		else if(dev->buf_pgid && (p = pfind(-dev->buf_pgid)) != NULL)
-			psignal(p, SIGIO);
-	}
-#endif /* __NetBSD__ */
-	DRM_DEBUG("waking\n");
-	wakeup(&dev->buf_rp);
-
-	return 0;
-}
-
-int DRM(poll)(dev_t kdev, int events, DRM_STRUCTPROC *p)
-{
-	DRM_DEVICE;
-	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;
-}
-
-int DRM(write)(dev_t kdev, struct uio *uio, int ioflag)
-{
-#if DRM_DEBUG_CODE
-	DRM_DEVICE;
-#endif
-#ifdef __FreeBSD__
-	DRM_DEBUG("pid = %d, device = %p, open_count = %d\n",
-		  curproc->p_pid, dev->device, dev->open_count);
-#elif defined(__NetBSD__)
-	DRM_DEBUG("pid = %d, device = %p, open_count = %d\n",
-		  curproc->p_pid, &dev->device, dev->open_count);
-#endif
-	return 0;
-}
Index: drm_os_freebsd.h
===================================================================
RCS file: /cvsroot/dri/xc/xc/programs/Xserver/hw/xfree86/os-support/bsd/drm/kernel/drm_os_freebsd.h,v
retrieving revision 1.17
diff -u -r1.17 drm_os_freebsd.h
--- drm_os_freebsd.h	29 Mar 2003 03:38:47 -0000	1.17
+++ drm_os_freebsd.h	1 Apr 2003 22:45:42 -0000
@@ -18,6 +18,7 @@
 #include <sys/bus.h>
 #include <sys/signalvar.h>
 #include <sys/poll.h>
+#include <sys/filedesc.h>
 #include <vm/vm.h>
 #include <vm/pmap.h>
 #include <vm/vm_extern.h>
@@ -101,10 +102,7 @@
 #define DRM_CURRENTPID		curproc->p_pid
 #endif
 
-/* Currently our DRMFILE (filp) is a void * which is actually the pid
- * of the current process.  It should be a per-open unique pointer, but
- * code for that is not yet written */
-#define DRMFILE			void *
+#define DRMFILE			struct file *
 #define DRM_IOCTL_ARGS		dev_t kdev, u_long cmd, caddr_t data, int flags, DRM_STRUCTPROC *p, DRMFILE filp
 #define DRM_LOCK		lockmgr(&dev->dev_lock, LK_EXCLUSIVE, 0, DRM_CURPROC)
 #define DRM_UNLOCK 		lockmgr(&dev->dev_lock, LK_RELEASE, 0, DRM_CURPROC)
@@ -130,12 +128,7 @@
 #define DRM_AGP_FIND_DEVICE()	agp_find_device()
 #define DRM_ERR(v)		v
 
-#define DRM_PRIV					\
-	drm_file_t	*priv	= (drm_file_t *) DRM(find_file_by_proc)(dev, p); \
-	if (!priv) {						\
-		DRM_DEBUG("can't find authenticator\n");	\
-		return EINVAL;					\
-	}
+#define DRM_GET_PRIV()		priv = (drm_file_t *)filp->f_data
 
 #define LOCK_TEST_WITH_RETURN(dev, filp)				\
 do {									\
@@ -381,15 +374,7 @@
 /* Internal functions */
 
 /* drm_drv.h */
-extern d_ioctl_t	DRM(ioctl);
-extern d_open_t		DRM(open);
-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 d_mmap_t		DRM(mmap);
-extern int		DRM(open_helper)(dev_t kdev, int flags, int fmt, 
-					 DRM_STRUCTPROC *p, drm_device_t *dev);
 extern drm_file_t	*DRM(find_file_by_proc)(drm_device_t *dev, 
 					 DRM_STRUCTPROC *p);
 
Index: drm_os_netbsd.h
===================================================================
RCS file: /cvsroot/dri/xc/xc/programs/Xserver/hw/xfree86/os-support/bsd/drm/kernel/drm_os_netbsd.h,v
retrieving revision 1.6
diff -u -r1.6 drm_os_netbsd.h
--- drm_os_netbsd.h	29 Mar 2003 03:38:47 -0000	1.6
+++ drm_os_netbsd.h	1 Apr 2003 22:45:42 -0000
@@ -103,9 +103,9 @@
 
 #define DRM_AGP_FIND_DEVICE()	agp_find_device(0)
 
-#define DRM_PRIV					\
-	drm_file_t	*priv	= (drm_file_t *) DRM(find_file_by_proc)(dev, p); \
-	if (!priv) {						\
+#define DRM_GET_PRIV()						\
+	priv = DRM(find_file_by_proc)(dev, p);			\
+	if (priv == NULL) {					\
 		DRM_DEBUG("can't find authenticator\n");	\
 		return EINVAL;					\
 	}
@@ -341,8 +341,6 @@
 extern dev_type_write(DRM(write));
 extern dev_type_poll(DRM(poll));
 extern dev_type_mmap(DRM(mmap));
-extern int		DRM(open_helper)(dev_t kdev, int flags, int fmt, 
-					 DRM_STRUCTPROC *p, drm_device_t *dev);
 extern drm_file_t	*DRM(find_file_by_proc)(drm_device_t *dev, 
 					 DRM_STRUCTPROC *p);
 
Index: drm_vm.h
===================================================================
RCS file: /cvsroot/dri/xc/xc/programs/Xserver/hw/xfree86/os-support/bsd/drm/kernel/drm_vm.h,v
retrieving revision 1.7
diff -u -r1.7 drm_vm.h
--- drm_vm.h	1 Apr 2003 18:53:24 -0000	1.7
+++ drm_vm.h	1 Apr 2003 22:45:42 -0000
@@ -45,6 +45,8 @@
 	drm_map_list_entry_t *listentry=NULL;
 	drm_file_t *priv;
 
+	/* We can't use DRM_GET_PRIV() because FreeBSD can't pass
+	 * in the filp to the device mmap handler */
 	priv = DRM(find_file_by_proc)(dev, DRM_CURPROC);
 	if (!priv) {
 		DRM_DEBUG("can't find authenticator\n");