Get the BSD DRM compiling again after MGA and mapping changes. Note that

    i915 has been disabled for the moment, rather than working around
    linux-specific code in the shared dir.

6 files changed, 251 insertions, 190 deletions

diff --git a/bsd-core/Makefile b/bsd-core/Makefile
index 79dd685d..895e0377 100644
--- a/bsd-core/Makefile
+++ b/bsd-core/Makefile
@@ -47,7 +47,7 @@ SHAREDFILES=	drm.h \
 		via_3d_reg.h \
 		via_dma.c
 
-SUBDIR = drm i915 mach64 mga r128 radeon sis tdfx
+SUBDIR = drm mach64 mga r128 radeon sis tdfx # i915
 
 CLEANFILES+= ${SHAREDFILES}
 
diff --git a/bsd-core/drmP.h b/bsd-core/drmP.h
index b22ce3b2..88cf938b 100644
--- a/bsd-core/drmP.h
+++ b/bsd-core/drmP.h
@@ -215,6 +215,13 @@ typedef void			irqreturn_t;
 #define IRQ_HANDLED		/* nothing */
 #define IRQ_NONE		/* nothing */
 
+enum {
+	DRM_IS_NOT_AGP,
+	DRM_MIGHT_BE_AGP,
+	DRM_IS_AGP
+};
+#define DRM_AGP_MEM		struct agp_memory_info
+
 #if defined(__FreeBSD__)
 #define DRM_DEVICE							\
 	drm_device_t *dev = kdev->si_drv1
@@ -585,7 +592,6 @@ typedef struct drm_local_map {
 	int		mtrr;	 /* Boolean: MTRR used */
 				 /* Private data			    */
 	int		rid;	 /* PCI resource ID for bus_space */
-	int		kernel_owned; /* Boolean: 1 = initmapped, 0 = addmapped */
 	struct resource *bsr;
 	bus_space_tag_t bst;
 	bus_space_handle_t bsh;
@@ -823,10 +829,14 @@ int	drm_lock_free(drm_device_t *dev,
 /* Buffer management support (drm_bufs.c) */
 unsigned long drm_get_resource_start(drm_device_t *dev, unsigned int resource);
 unsigned long drm_get_resource_len(drm_device_t *dev, unsigned int resource);
-int	drm_initmap(drm_device_t *dev, unsigned long start, unsigned long len,
-		    unsigned int resource, int type, int flags);
-void	drm_remove_map(drm_device_t *dev, drm_local_map_t *map);
+void	drm_rmmap(drm_device_t *dev, drm_local_map_t *map);
 int	drm_order(unsigned long size);
+int	drm_addmap(drm_device_t * dev, unsigned long offset, unsigned long size,
+		   drm_map_type_t type, drm_map_flags_t flags,
+		   drm_local_map_t **map_ptr);
+int	drm_addbufs_pci(drm_device_t *dev, drm_buf_desc_t *request);
+int	drm_addbufs_sg(drm_device_t *dev, drm_buf_desc_t *request);
+int	drm_addbufs_agp(drm_device_t *dev, drm_buf_desc_t *request);
 
 /* DMA support (drm_dma.c) */
 int	drm_dma_setup(drm_device_t *dev);
@@ -848,11 +858,18 @@ void	drm_vbl_send_signals(drm_device_t *dev);
 int	drm_device_is_agp(drm_device_t *dev);
 drm_agp_head_t *drm_agp_init(void);
 void	drm_agp_uninit(void);
+int	drm_agp_acquire(drm_device_t *dev);
 int	drm_agp_release(drm_device_t *dev);
+int	drm_agp_info(drm_device_t * dev, drm_agp_info_t *info);
+int	drm_agp_enable(drm_device_t *dev, drm_agp_mode_t mode);
 void	*drm_agp_allocate_memory(size_t pages, u32 type);
 int	drm_agp_free_memory(void *handle);
 int	drm_agp_bind_memory(void *handle, off_t start);
 int	drm_agp_unbind_memory(void *handle);
+#define drm_alloc_agp(dev, pages, type) drm_agp_allocate_memory(pages, type)
+#define drm_free_agp(handle, pages) drm_agp_free_memory(handle)
+#define drm_bind_agp(handle, start) drm_agp_bind_memory(handle, start)
+#define drm_unbind_agp(handle) drm_agp_unbind_memory(handle)
 
 /* Scatter Gather Support (drm_scatter.c) */
 void	drm_sg_cleanup(drm_sg_mem_t *entry);
@@ -904,9 +921,9 @@ int	drm_getmagic(DRM_IOCTL_ARGS);
 int	drm_authmagic(DRM_IOCTL_ARGS);
 
 /* Buffer management support (drm_bufs.c) */
-int	drm_addmap(DRM_IOCTL_ARGS);
-int	drm_rmmap(DRM_IOCTL_ARGS);
-int	drm_addbufs(DRM_IOCTL_ARGS);
+int	drm_addmap_ioctl(DRM_IOCTL_ARGS);
+int	drm_rmmap_ioctl(DRM_IOCTL_ARGS);
+int	drm_addbufs_ioctl(DRM_IOCTL_ARGS);
 int	drm_infobufs(DRM_IOCTL_ARGS);
 int	drm_markbufs(DRM_IOCTL_ARGS);
 int	drm_freebufs(DRM_IOCTL_ARGS);
@@ -920,10 +937,10 @@ int	drm_control(DRM_IOCTL_ARGS);
 int	drm_wait_vblank(DRM_IOCTL_ARGS);
 
 /* AGP/GART support (drm_agpsupport.c) */
-int	drm_agp_acquire(DRM_IOCTL_ARGS);
+int	drm_agp_acquire_ioctl(DRM_IOCTL_ARGS);
 int	drm_agp_release_ioctl(DRM_IOCTL_ARGS);
-int	drm_agp_enable(DRM_IOCTL_ARGS);
-int	drm_agp_info(DRM_IOCTL_ARGS);
+int	drm_agp_enable_ioctl(DRM_IOCTL_ARGS);
+int	drm_agp_info_ioctl(DRM_IOCTL_ARGS);
 int	drm_agp_alloc(DRM_IOCTL_ARGS);
 int	drm_agp_free(DRM_IOCTL_ARGS);
 int	drm_agp_unbind(DRM_IOCTL_ARGS);
diff --git a/bsd-core/drm_agpsupport.c b/bsd-core/drm_agpsupport.c
index 7c5351ae..9e98140a 100644
--- a/bsd-core/drm_agpsupport.c
+++ b/bsd-core/drm_agpsupport.c
@@ -38,23 +38,25 @@
 #include <dev/pci/pcireg.h>
 #endif
 
+/* Returns 1 if AGP or 0 if not. */
 int
 drm_device_is_agp(drm_device_t *dev)
 {
+	int ret;
+
+	if (dev->device_is_agp != NULL) {
+		ret = (*dev->device_is_agp)(dev);
+		
+		if (ret != DRM_MIGHT_BE_AGP) {
+			return ret == 2;
+		}
+	}
+
 #ifdef __FreeBSD__
 	/* Code taken from agp.c.  IWBNI that was a public interface. */
 	u_int32_t status;
 	u_int8_t ptr, next;
 
-
-	if ( dev->driver->device_is_agp != NULL ) {
-		int err = (*dev->driver->device_is_agp)( dev );
-	
-		if (err != 2) {
-			return err;
-		}
-	}
-
 	/*
 	 * Check the CAP_LIST bit of the PCI status register first.
 	 */
@@ -80,51 +82,65 @@ drm_device_is_agp(drm_device_t *dev)
 
 	return 0;
 #else
-	if ( (dev->driver->device_is_agp != NULL)
-	     && ! (*dev->driver->device_is_agp)( dev ) ) {
-		return 0;
-	}
-
 	/* XXX: fill me in for non-FreeBSD */
 	return 1;
 #endif
 }
 
-int drm_agp_info(DRM_IOCTL_ARGS)
+int drm_agp_info(drm_device_t * dev, drm_agp_info_t *info)
 {
-	DRM_DEVICE;
 	struct agp_info *kern;
-	drm_agp_info_t   info;
 
 	if (!dev->agp || !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;
+	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;
+
+	return 0;
+}
+
+int drm_agp_info_ioctl(DRM_IOCTL_ARGS)
+{
+	int err;
+	drm_agp_info_t info;
+	DRM_DEVICE;
+
+	err = drm_agp_info(dev, &info);
+	if (err != 0)
+		return err;
 
 	*(drm_agp_info_t *) data = info;
 	return 0;
 }
 
-int drm_agp_acquire(DRM_IOCTL_ARGS)
+int drm_agp_acquire_ioctl(DRM_IOCTL_ARGS)
 {
 	DRM_DEVICE;
-	int          retcode;
+
+	return drm_agp_acquire(dev);
+}
+
+int drm_agp_acquire(drm_device_t *dev)
+{
+	int retcode;
 
 	if (!dev->agp || dev->agp->acquired)
 		return EINVAL;
+
 	retcode = agp_acquire(dev->agp->agpdev);
 	if (retcode)
 		return retcode;
+
 	dev->agp->acquired = 1;
 	return 0;
 }
@@ -136,7 +152,7 @@ int drm_agp_release_ioctl(DRM_IOCTL_ARGS)
 	return drm_agp_release(dev);
 }
 
-void drm_agp_release(drm_device_t * dev)
+int drm_agp_release(drm_device_t * dev)
 {
 	if (!dev->agp || !dev->agp->acquired)
 		return EINVAL;
@@ -145,15 +161,11 @@ void drm_agp_release(drm_device_t * dev)
 	return 0;
 }
 
-int drm_agp_enable(DRM_IOCTL_ARGS)
+int drm_agp_enable(drm_device_t *dev, drm_agp_mode_t mode)
 {
-	DRM_DEVICE;
-	drm_agp_mode_t mode;
 
 	if (!dev->agp || !dev->agp->acquired)
 		return EINVAL;
-
-	mode = *(drm_agp_mode_t *) data;
 	
 	dev->agp->mode    = mode.mode;
 	agp_enable(dev->agp->agpdev, mode.mode);
@@ -162,6 +174,16 @@ int drm_agp_enable(DRM_IOCTL_ARGS)
 	return 0;
 }
 
+int drm_agp_enable_ioctl(DRM_IOCTL_ARGS)
+{
+	drm_agp_mode_t mode;
+	DRM_DEVICE;
+
+	mode = *(drm_agp_mode_t *) data;
+
+	return drm_agp_enable(dev, mode);
+}
+
 int drm_agp_alloc(DRM_IOCTL_ARGS)
 {
 	DRM_DEVICE;
diff --git a/bsd-core/drm_bufs.c b/bsd-core/drm_bufs.c
index 9397e4df..0cc2a0d9 100644
--- a/bsd-core/drm_bufs.c
+++ b/bsd-core/drm_bufs.c
@@ -91,98 +91,35 @@ unsigned long drm_get_resource_len(drm_device_t *dev, unsigned int resource)
 	return len;
 }
 
-int drm_initmap(drm_device_t *dev, unsigned long start, unsigned long len,
-		unsigned int resource, int type, int flags)
+int drm_addmap(drm_device_t * dev, unsigned long offset, unsigned long size,
+    drm_map_type_t type, drm_map_flags_t flags, drm_local_map_t **map_ptr)
 {
 	drm_local_map_t *map;
-	struct resource *bsr;
-
-	if (type != _DRM_REGISTERS && type != _DRM_FRAME_BUFFER)
-		return EINVAL;
-	if (len == 0)
-		return EINVAL;
-
-	map = malloc(sizeof(*map), M_DRM, M_ZERO | M_NOWAIT);
-	if (map == NULL)
-		return ENOMEM;
-
-	map->rid = resource * 4 + 0x10;
-	bsr = bus_alloc_resource_any(dev->device, SYS_RES_MEMORY, &map->rid,
-	    RF_ACTIVE | RF_SHAREABLE);
-	if (bsr == NULL) {
-		DRM_ERROR("Couldn't allocate %s resource\n",
-		    ((type == _DRM_REGISTERS) ? "mmio" : "framebuffer"));
-		free(map, M_DRM);
-		return ENOMEM;
-	}
-
-	map->kernel_owned = 1;
-	map->type = type;
-	map->flags = flags;
-	map->bsr = bsr;
-	map->bst = rman_get_bustag(bsr);
-	map->bsh = rman_get_bushandle(bsr);
-	map->offset = start;
-	map->size = len;
-
-	if (type == _DRM_REGISTERS)
-		map->handle = rman_get_virtual(bsr);
-
-	DRM_DEBUG("initmap %d,0x%x@0x%lx/0x%lx\n", map->type, map->flags,
-	    map->offset, map->size);
-
-	if (map->flags & _DRM_WRITE_COMBINING) {
-		int err;
-
-		err = drm_mtrr_add(map->offset, map->size, DRM_MTRR_WC);
-		if (err == 0)
-			map->mtrr = 1;
-	}
-
-	DRM_LOCK();
-	TAILQ_INSERT_TAIL(&dev->maplist, map, link);
-	DRM_UNLOCK();
-
-	return 0;
-}
-
-int drm_addmap(DRM_IOCTL_ARGS)
-{
-	DRM_DEVICE;
-	drm_map_t request;
-	drm_local_map_t *map;
-	
-	if (!(dev->flags & (FREAD|FWRITE)))
-		return DRM_ERR(EACCES); /* Require read/write */
-
-	DRM_COPY_FROM_USER_IOCTL( request, (drm_map_t *)data, sizeof(drm_map_t) );
 
 	/* Only allow shared memory to be removable since we only keep enough
 	 * book keeping information about shared memory to allow for removal
 	 * when processes fork.
 	 */
-	if ((request.flags & _DRM_REMOVABLE) && request.type != _DRM_SHM)
+	if ((flags & _DRM_REMOVABLE) && type != _DRM_SHM)
 		return EINVAL;
-	if ((request.offset & PAGE_MASK) || (request.size & PAGE_MASK))
+	if ((offset & PAGE_MASK) || (size & PAGE_MASK))
 		return EINVAL;
-	if (request.offset + request.size < request.offset)
+	if (offset + size < offset)
 		return EINVAL;
 
-	DRM_DEBUG("offset = 0x%08lx, size = 0x%08lx, type = %d\n",
-	    request.offset, request.size, request.type);
+	DRM_DEBUG("offset = 0x%08lx, size = 0x%08lx, type = %d\n", offset,
+	    size, type);
 
 	/* Check if this is just another version of a kernel-allocated map, and
 	 * just hand that back if so.
 	 */
-	if (request.type == _DRM_REGISTERS || request.type == _DRM_FRAME_BUFFER)
+	if (type == _DRM_REGISTERS || type == _DRM_FRAME_BUFFER)
 	{
 		DRM_LOCK();
 		TAILQ_FOREACH(map, &dev->maplist, link) {
-			if (map->kernel_owned && map->type == request.type &&
-			    map->offset == request.offset) {
-				/* XXX: this size setting is questionable. */
-				map->size = request.size;
-				DRM_DEBUG("Found kernel map %d\n", request.type);
+			if (map->type == type && map->offset == offset) {
+				map->size = size;
+				DRM_DEBUG("Found kernel map %d\n", type);
 				goto done;
 			}
 		}
@@ -196,10 +133,10 @@ int drm_addmap(DRM_IOCTL_ARGS)
 	if ( !map )
 		return DRM_ERR(ENOMEM);
 
-	map->offset = request.offset;
-	map->size = request.size;
-	map->type = request.type;
-	map->flags = request.flags;
+	map->offset = offset;
+	map->size = size;
+	map->type = type;
+	map->flags = flags;
 
 	switch ( map->type ) {
 	case _DRM_REGISTERS:
@@ -264,26 +201,49 @@ int drm_addmap(DRM_IOCTL_ARGS)
 
 done:
 	/* Jumped to, with lock held, when a kernel map is found. */
+	DRM_UNLOCK();
+
+	DRM_DEBUG("Added map %d 0x%lx/0x%lx\n", map->type, map->offset,
+	    map->size);
+
+	*map_ptr = map;
+
+	return 0;
+}
+
+int drm_addmap_ioctl(DRM_IOCTL_ARGS)
+{
+	drm_map_t request;
+	drm_local_map_t *map;
+	int err;
+	DRM_DEVICE;
+
+	if (!(dev->flags & (FREAD|FWRITE)))
+		return DRM_ERR(EACCES); /* Require read/write */
+
+	DRM_COPY_FROM_USER_IOCTL(request, (drm_map_t *)data, sizeof(drm_map_t));
+
+	err = drm_addmap(dev, request.offset, request.size, request.type,
+	    request.flags, &map);
+	if (err != 0)
+		return err;
+
 	request.offset = map->offset;
 	request.size = map->size;
 	request.type = map->type;
 	request.flags = map->flags;
 	request.mtrr   = map->mtrr;
 	request.handle = map->handle;
-	DRM_UNLOCK();
-
-	DRM_DEBUG("Added map %d 0x%lx/0x%lx\n", request.type, request.offset, request.size);
 
-	if ( request.type != _DRM_SHM ) {
+	if (request.type != _DRM_SHM) {
 		request.handle = (void *)request.offset;
 	}
-
-	DRM_COPY_TO_USER_IOCTL( (drm_map_t *)data, request, sizeof(drm_map_t) );
+	DRM_COPY_TO_USER_IOCTL((drm_map_t *)data, request, sizeof(drm_map_t));
 
 	return 0;
 }
 
-void drm_remove_map(drm_device_t *dev, drm_local_map_t *map)
+void drm_rmmap(drm_device_t *dev, drm_local_map_t *map)
 {
 	DRM_SPINLOCK_ASSERT(&dev->dev_lock);
 
@@ -326,7 +286,7 @@ void drm_remove_map(drm_device_t *dev, drm_local_map_t *map)
  * isn't in use.
  */
 
-int drm_rmmap(DRM_IOCTL_ARGS)
+int drm_rmmap_ioctl(DRM_IOCTL_ARGS)
 {
 	DRM_DEVICE;
 	drm_local_map_t *map;
@@ -347,7 +307,7 @@ int drm_rmmap(DRM_IOCTL_ARGS)
 		return DRM_ERR(EINVAL);
 	}
 
-	drm_remove_map(dev, map);
+	drm_rmmap(dev, map);
 
 	DRM_UNLOCK();
 
@@ -378,7 +338,7 @@ static void drm_cleanup_buf_error(drm_device_t *dev, drm_buf_entry_t *entry)
 	}
 }
 
-static int drm_addbufs_agp(drm_device_t *dev, drm_buf_desc_t *request)
+static int drm_do_addbufs_agp(drm_device_t *dev, drm_buf_desc_t *request)
 {
 	drm_device_dma_t *dma = dev->dma;
 	drm_buf_entry_t *entry;
@@ -487,7 +447,7 @@ static int drm_addbufs_agp(drm_device_t *dev, drm_buf_desc_t *request)
 	return 0;
 }
 
-static int drm_addbufs_pci(drm_device_t *dev, drm_buf_desc_t *request)
+static int drm_do_addbufs_pci(drm_device_t *dev, drm_buf_desc_t *request)
 {
 	drm_device_dma_t *dma = dev->dma;
 	int count;
@@ -634,7 +594,7 @@ static int drm_addbufs_pci(drm_device_t *dev, drm_buf_desc_t *request)
 
 }
 
-static int drm_addbufs_sg(drm_device_t *dev, drm_buf_desc_t *request)
+static int drm_do_addbufs_sg(drm_device_t *dev, drm_buf_desc_t *request)
 {
 	drm_device_dma_t *dma = dev->dma;
 	drm_buf_entry_t *entry;
@@ -745,23 +705,81 @@ static int drm_addbufs_sg(drm_device_t *dev, drm_buf_desc_t *request)
 	return 0;
 }
 
-int drm_addbufs(DRM_IOCTL_ARGS)
+int drm_addbufs_agp(drm_device_t *dev, drm_buf_desc_t *request)
 {
-	DRM_DEVICE;
-	drm_buf_desc_t request;
-	int err;
-	int order;
+	int order, ret;
 
-	DRM_COPY_FROM_USER_IOCTL( request, (drm_buf_desc_t *)data, sizeof(request) );
+	DRM_SPINLOCK(&dev->dma_lock);
 
-	if (request.count < 0 || request.count > 4096)
+	if (request->count < 0 || request->count > 4096)
+		return DRM_ERR(EINVAL);
+	
+	order = drm_order(request->size);
+	if (order < DRM_MIN_ORDER || order > DRM_MAX_ORDER)
 		return DRM_ERR(EINVAL);
 
-	order = drm_order(request.size);
+	/* No more allocations after first buffer-using ioctl. */
+	if (dev->buf_use != 0) {
+		DRM_SPINUNLOCK(&dev->dma_lock);
+		return DRM_ERR(EBUSY);
+	}
+	/* No more than one allocation per order */
+	if (dev->dma->bufs[order].buf_count != 0) {
+		DRM_SPINUNLOCK(&dev->dma_lock);
+		return DRM_ERR(ENOMEM);
+	}
+
+	ret = drm_do_addbufs_agp(dev, request);
+
+	DRM_SPINUNLOCK(&dev->dma_lock);
+
+	return ret;
+}
+
+int drm_addbufs_sg(drm_device_t *dev, drm_buf_desc_t *request)
+{
+	int order, ret;
+
+	DRM_SPINLOCK(&dev->dma_lock);
+
+	if (request->count < 0 || request->count > 4096)
+		return DRM_ERR(EINVAL);
+	
+	order = drm_order(request->size);
 	if (order < DRM_MIN_ORDER || order > DRM_MAX_ORDER)
 		return DRM_ERR(EINVAL);
 
+	/* No more allocations after first buffer-using ioctl. */
+	if (dev->buf_use != 0) {
+		DRM_SPINUNLOCK(&dev->dma_lock);
+		return DRM_ERR(EBUSY);
+	}
+	/* No more than one allocation per order */
+	if (dev->dma->bufs[order].buf_count != 0) {
+		DRM_SPINUNLOCK(&dev->dma_lock);
+		return DRM_ERR(ENOMEM);
+	}
+
+	ret = drm_do_addbufs_sg(dev, request);
+
+	DRM_SPINUNLOCK(&dev->dma_lock);
+
+	return ret;
+}
+
+int drm_addbufs_pci(drm_device_t *dev, drm_buf_desc_t *request)
+{
+	int order, ret;
+
 	DRM_SPINLOCK(&dev->dma_lock);
+
+	if (request->count < 0 || request->count > 4096)
+		return DRM_ERR(EINVAL);
+	
+	order = drm_order(request->size);
+	if (order < DRM_MIN_ORDER || order > DRM_MAX_ORDER)
+		return DRM_ERR(EINVAL);
+
 	/* No more allocations after first buffer-using ioctl. */
 	if (dev->buf_use != 0) {
 		DRM_SPINUNLOCK(&dev->dma_lock);
@@ -773,16 +791,31 @@ int drm_addbufs(DRM_IOCTL_ARGS)
 		return DRM_ERR(ENOMEM);
 	}
 
-	if ( request.flags & _DRM_AGP_BUFFER )
+	ret = drm_do_addbufs_pci(dev, request);
+
+	DRM_SPINUNLOCK(&dev->dma_lock);
+
+	return ret;
+}
+
+int drm_addbufs_ioctl(DRM_IOCTL_ARGS)
+{
+	DRM_DEVICE;
+	drm_buf_desc_t request;
+	int err;
+
+	DRM_COPY_FROM_USER_IOCTL(request, (drm_buf_desc_t *)data,
+	    sizeof(request));
+
+	if (request.flags & _DRM_AGP_BUFFER)
 		err = drm_addbufs_agp(dev, &request);
-	else
-	if ( request.flags & _DRM_SG_BUFFER )
+	else if (request.flags & _DRM_SG_BUFFER)
 		err = drm_addbufs_sg(dev, &request);
 	else
 		err = drm_addbufs_pci(dev, &request);
-	DRM_SPINUNLOCK(&dev->dma_lock);
 
-	DRM_COPY_TO_USER_IOCTL((drm_buf_desc_t *)data, request, sizeof(request));
+	DRM_COPY_TO_USER_IOCTL((drm_buf_desc_t *)data, request,
+	    sizeof(request));
 
 	return err;
 }
diff --git a/bsd-core/drm_drv.c b/bsd-core/drm_drv.c
index e3cac422..019852d9 100644
--- a/bsd-core/drm_drv.c
+++ b/bsd-core/drm_drv.c
@@ -71,8 +71,8 @@ static drm_ioctl_desc_t		  drm_ioctls[256] = {
 	[DRM_IOCTL_NR(DRM_IOCTL_UNBLOCK)]       = { drm_noop,        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_RM_MAP)]        = { drm_rmmap,       1, 0 },
+	[DRM_IOCTL_NR(DRM_IOCTL_ADD_MAP)]       = { drm_addmap_ioctl, 1, 1 },
+	[DRM_IOCTL_NR(DRM_IOCTL_RM_MAP)]        = { drm_rmmap_ioctl, 1, 0 },
 
 	[DRM_IOCTL_NR(DRM_IOCTL_SET_SAREA_CTX)] = { drm_setsareactx, 1, 1 },
 	[DRM_IOCTL_NR(DRM_IOCTL_GET_SAREA_CTX)] = { drm_getsareactx, 1, 0 },
@@ -92,7 +92,7 @@ static drm_ioctl_desc_t		  drm_ioctls[256] = {
 	[DRM_IOCTL_NR(DRM_IOCTL_UNLOCK)]        = { drm_unlock,      1, 0 },
 	[DRM_IOCTL_NR(DRM_IOCTL_FINISH)]        = { drm_noop,        1, 0 },
 
-	[DRM_IOCTL_NR(DRM_IOCTL_ADD_BUFS)]      = { drm_addbufs,     1, 1 },
+	[DRM_IOCTL_NR(DRM_IOCTL_ADD_BUFS)]      = { drm_addbufs_ioctl, 1, 1 },
 	[DRM_IOCTL_NR(DRM_IOCTL_MARK_BUFS)]     = { drm_markbufs,    1, 1 },
 	[DRM_IOCTL_NR(DRM_IOCTL_INFO_BUFS)]     = { drm_infobufs,    1, 0 },
 	[DRM_IOCTL_NR(DRM_IOCTL_MAP_BUFS)]      = { drm_mapbufs,     1, 0 },
@@ -101,10 +101,10 @@ static drm_ioctl_desc_t		  drm_ioctls[256] = {
 
 	[DRM_IOCTL_NR(DRM_IOCTL_CONTROL)]       = { drm_control,     1, 1 },
 
-	[DRM_IOCTL_NR(DRM_IOCTL_AGP_ACQUIRE)]   = { drm_agp_acquire, 1, 1 },
+	[DRM_IOCTL_NR(DRM_IOCTL_AGP_ACQUIRE)]   = { drm_agp_acquire_ioctl, 1, 1 },
 	[DRM_IOCTL_NR(DRM_IOCTL_AGP_RELEASE)]   = { drm_agp_release_ioctl, 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_ENABLE)]    = { drm_agp_enable_ioctl, 1, 1 },
+	[DRM_IOCTL_NR(DRM_IOCTL_AGP_INFO)]      = { drm_agp_info_ioctl, 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 },
@@ -424,7 +424,7 @@ static int drm_takedown(drm_device_t *dev)
 		dev->agp->memory = NULL;
 
 		if (dev->agp->acquired)
-			drm_agp_release();
+			drm_agp_release(dev);
 
 		dev->agp->acquired = 0;
 		dev->agp->enabled  = 0;
@@ -434,10 +434,8 @@ static int drm_takedown(drm_device_t *dev)
 		dev->sg = NULL;
 	}
 
-	/* Clean up maps that weren't set up by the driver. */
 	TAILQ_FOREACH_SAFE(map, &dev->maplist, link, mapsave) {
-		if (!map->kernel_owned)
-			drm_remove_map(dev, map);
+		drm_rmmap(dev, map);
 	}
 
 	drm_dma_takedown(dev);
@@ -562,8 +560,6 @@ error:
  */
 static void drm_cleanup(drm_device_t *dev)
 {
-	drm_local_map_t *map;
-
 	DRM_DEBUG( "\n" );
 
 #ifdef __FreeBSD__
@@ -585,11 +581,6 @@ static void drm_cleanup(drm_device_t *dev)
 	drm_takedown(dev);
 	DRM_UNLOCK();
 
-	/* Clean up any maps left over that had been allocated by the driver. */
-	while ((map = TAILQ_FIRST(&dev->maplist)) != NULL) {
-		drm_remove_map(dev, map);
-	}
-
 	if ( dev->agp ) {
 		drm_agp_uninit();
 		free(dev->agp, M_DRM);
diff --git a/bsd-core/mga_drv.c b/bsd-core/mga_drv.c
index efb7cc99..04124c06 100644
--- a/bsd-core/mga_drv.c
+++ b/bsd-core/mga_drv.c
@@ -37,17 +37,36 @@
 #include "mga_drv.h"
 #include "drm_pciids.h"
 
-int mga_driver_device_is_agp(drm_device_t * dev)
 /* drv_PCI_IDs comes from drm_pciids.h, generated from drm_pciids.txt. */
 static drm_pci_id_list_t mga_pciidlist[] = {
 	mga_PCI_IDS
 };
 
-static int mga_driver_device_is_agp(drm_device_t * dev);
-
 extern drm_ioctl_desc_t mga_ioctls[];
 extern int mga_max_ioctl;
 
+/**
+ * Determine if the device really is AGP or not.
+ *
+ * In addition to the usual tests performed by \c drm_device_is_agp, this
+ * function detects PCI G450 cards that appear to the system exactly like
+ * AGP G450 cards.
+ *
+ * \param dev   The device to be tested.
+ *
+ * \returns
+ * If the device is a PCI G450, zero is returned.  Otherwise non-zero is
+ * returned.
+ *
+ * \bug
+ * This function needs to be filled in!  The implementation in
+ * linux-core/mga_drv.c shows what needs to be done.
+ */
+static int mga_driver_device_is_agp(drm_device_t * dev)
+{
+	return 1;
+}
+
 static void mga_configure(drm_device_t *dev)
 {
 	dev->dev_priv_size = sizeof(drm_mga_buf_priv_t);
@@ -62,7 +81,6 @@ static void mga_configure(drm_device_t *dev)
 	dev->dma_ioctl = mga_dma_buffers;
 	dev->pretakedown = mga_driver_pretakedown;
 	dev->dma_quiescent = mga_driver_dma_quiescent;
-
 	dev->device_is_agp = mga_driver_device_is_agp;
 
 	dev->driver_ioctls = mga_ioctls;
@@ -83,27 +101,7 @@ static void mga_configure(drm_device_t *dev)
 	dev->use_vbl_irq = 1;
 }
 
-/**
- * Determine if the device really is AGP or not.
- *
- * In addition to the usual tests performed by \c drm_device_is_agp, this
- * function detects PCI G450 cards that appear to the system exactly like
- * AGP G450 cards.
- *
- * \param dev   The device to be tested.
- *
- * \returns
- * If the device is a PCI G450, zero is returned.  Otherwise non-zero is
- * returned.
- *
- * \bug
- * This function needs to be filled in!  The implementation in
- * linux-core/mga_drv.c shows what needs to be done.
- */
-int mga_driver_device_is_agp(drm_device_t * dev)
-{
-	return 1;
-}
+
 
 #ifdef __FreeBSD__
 static int