remove dri1 interfaces

discussed with kettenis some time last year

8 files changed, 23 insertions, 1732 deletions

diff --git a/sys/dev/pci/drm/drmP.h b/sys/dev/pci/drm/drmP.h
index f431fe8ab6d..4e8281f82cf 100644
--- a/sys/dev/pci/drm/drmP.h
+++ b/sys/dev/pci/drm/drmP.h
@@ -1,4 +1,4 @@
-/* $OpenBSD: drmP.h,v 1.168 2014/02/23 09:36:52 kettenis Exp $ */
+/* $OpenBSD: drmP.h,v 1.169 2014/03/09 07:42:29 jsg Exp $ */
 /* drmP.h -- Private header for Direct Rendering Manager -*- linux-c -*-
  * Created: Mon Jan  4 10:05:05 1999 by faith@precisioninsight.com
  */
@@ -87,11 +87,6 @@
 #define __LITTLE_ENDIAN
 #endif
 
-#define DRM_KERNEL_CONTEXT    0	 /* Change drm_resctx if changed	  */
-#define DRM_RESERVED_CONTEXTS 1	 /* Change drm_resctx if changed	  */
-
-#define DRM_MAX_CTXBITMAP (PAGE_SIZE * 8)
-
 				/* Internal types and structures */
 #define DRM_IF_VERSION(maj, min) (maj << 16 | min)
 
@@ -386,16 +381,6 @@ mdelay(unsigned long msecs)
 
 #define	drm_can_sleep()	(hz & 1)
 
-#define LOCK_TEST_WITH_RETURN(dev, file_priv)				\
-do {									\
-	if (!_DRM_LOCK_IS_HELD(dev->lock.hw_lock->lock) ||		\
-	     dev->lock.file_priv != file_priv) {			\
-		DRM_ERROR("%s called without lock held\n",		\
-			   __FUNCTION__);				\
-		return EINVAL;						\
-	}								\
-} while (0)
-
 #define DRM_WAIT_ON(ret, queue, lock,  timeout, msg, condition ) do {	\
 	mtx_enter(lock);						\
 	while ((ret) == 0) {						\
@@ -548,13 +533,6 @@ struct drm_file {
 	void					*driver_priv;
 };
 
-struct drm_lock_data {
-	struct mutex		 spinlock;
-	struct drm_hw_lock	*hw_lock;	/* Hardware lock */
-	/* Unique identifier of holding process (NULL is kernel) */
-	struct drm_file		*file_priv;
-};
-
 /* This structure, in the struct drm_device, is always initialized while
  * the device is open.  dev->dma_lock protects the incrementing of
  * dev->buf_use, which when set marks that no further bufs may be allocated
@@ -599,11 +577,6 @@ struct drm_agp_head {
    	int					 mtrr;
 };
 
-struct drm_sg_mem {
-	struct drm_dmamem	*mem;
-	unsigned long		 handle;
-};
-
 struct drm_local_map {
 	TAILQ_ENTRY(drm_local_map)	 link;	/* Link for map list */
 	struct drm_dmamem		*dmamem;/* Handle to DMA mem */
@@ -830,9 +803,6 @@ struct drm_device {
 	struct extent				*handle_ext;
 	TAILQ_HEAD(drm_map_list, drm_local_map)	 maplist;
 
-
-	struct drm_lock_data  lock;	/* Information on hardware lock	*/
-
 				/* DMA queues (contexts) */
 	struct drm_device_dma  *dma;		/* Optional pointer for DMA support */
 
@@ -865,8 +835,6 @@ struct drm_device {
 	pid_t			 buf_pgid;
 
 	struct drm_agp_head	*agp;
-	struct drm_sg_mem	*sg;  /* Scatter gather memory */
-	atomic_t		*ctx_bitmap;
 	void			*dev_private;
 	struct drm_local_map	*agp_buffer_map;
 
@@ -962,6 +930,7 @@ void			 drm_dmamem_free(bus_dma_tag_t, struct drm_dmamem *);
 
 const struct drm_pcidev	*drm_find_description(int , int ,
 			     const struct drm_pcidev *);
+int	 drm_order(unsigned long);
 
 /* File operations helpers (drm_fops.c) */
 struct drm_file	*drm_find_file_by_minor(struct drm_device *, int);
@@ -980,35 +949,6 @@ void	drm_core_ioremapfree(struct drm_local_map *, struct drm_device *);
 int	drm_mtrr_add(unsigned long, size_t, int);
 int	drm_mtrr_del(int, unsigned long, size_t, int);
 
-/* Context management (DRI1, deprecated) */
-int	drm_ctxbitmap_init(struct drm_device *);
-void	drm_ctxbitmap_cleanup(struct drm_device *);
-void	drm_ctxbitmap_free(struct drm_device *, int);
-int	drm_ctxbitmap_next(struct drm_device *);
-
-/* Locking IOCTL support (drm_lock.c) */
-int	drm_lock_take(struct drm_lock_data *, unsigned int);
-int	drm_lock_free(struct drm_lock_data *, unsigned int);
-
-/* Buffer management and DMA support (drm_bufs.c) */
-int	drm_order(unsigned long);
-struct drm_local_map *drm_core_findmap(struct drm_device *, unsigned long);
-int	drm_rmmap_ioctl(struct drm_device *, void *, struct drm_file *);
-void	drm_rmmap(struct drm_device *, struct drm_local_map *);
-void	drm_rmmap_locked(struct drm_device *, struct drm_local_map *);
-int	drm_addmap_ioctl(struct drm_device *, void *, struct drm_file *);
-int	drm_addmap(struct drm_device *, unsigned long, unsigned long,
-	    enum drm_map_type, enum drm_map_flags, struct drm_local_map **);
-int	drm_addbufs(struct drm_device *, struct drm_buf_desc *);
-int	drm_freebufs(struct drm_device *, void *, struct drm_file *);
-int	drm_mapbufs(struct drm_device *, void *, struct drm_file *);
-int	drm_dma(struct drm_device *, void *, struct drm_file *);
-int	drm_dma_setup(struct drm_device *);
-void	drm_dma_takedown(struct drm_device *);
-void	drm_cleanup_buf(struct drm_device *, struct drm_buf_entry *);
-void	drm_free_buffer(struct drm_device *, struct drm_buf *);
-void	drm_reclaim_buffers(struct drm_device *, struct drm_file *);
-
 /* IRQ support (drm_irq.c) */
 int	drm_irq_install(struct drm_device *);
 int	drm_irq_uninstall(struct drm_device *);
@@ -1052,20 +992,6 @@ int	drm_agp_free(struct drm_device *, struct drm_agp_buffer *);
 int	drm_agp_bind(struct drm_device *, struct drm_agp_binding *);
 int	drm_agp_unbind(struct drm_device *, struct drm_agp_binding *);
 
-/* Scatter Gather Support (drm_scatter.c) */
-void	drm_sg_cleanup(struct drm_device *, struct drm_sg_mem *);
-int	drm_sg_alloc(struct drm_device *, struct drm_scatter_gather *);
-
-/* Locking IOCTL support (drm_drv.c) */
-int	drm_lock(struct drm_device *, void *, struct drm_file *);
-int	drm_unlock(struct drm_device *, void *, struct drm_file *);
-
-/* Context IOCTL support (drm_context.c) */
-int	drm_resctx(struct drm_device *, void *, struct drm_file *);
-int	drm_addctx(struct drm_device *, void *, struct drm_file *);
-int	drm_getctx(struct drm_device *, void *, struct drm_file *);
-int	drm_rmctx(struct drm_device *, void *, struct drm_file *);
-
 /* IRQ support (drm_irq.c) */
 int	drm_control(struct drm_device *, void *, struct drm_file *);
 int	drm_wait_vblank(struct drm_device *, void *, struct drm_file *);
@@ -1083,10 +1009,6 @@ int	drm_agp_free_ioctl(struct drm_device *, void *, struct drm_file *);
 int	drm_agp_unbind_ioctl(struct drm_device *, void *, struct drm_file *);
 int	drm_agp_bind_ioctl(struct drm_device *, void *, struct drm_file *);
 
-/* Scatter Gather Support (drm_scatter.c) */
-int	drm_sg_alloc_ioctl(struct drm_device *, void *, struct drm_file *);
-int	drm_sg_free(struct drm_device *, void *, struct drm_file *);
-
 static inline int
 drm_sysfs_connector_add(struct drm_connector *connector)
 {
diff --git a/sys/dev/pci/drm/drm_bufs.c b/sys/dev/pci/drm/drm_bufs.c
deleted file mode 100644
index 2f64aa271fa..00000000000
--- a/sys/dev/pci/drm/drm_bufs.c
+++ /dev/null
@@ -1,1003 +0,0 @@
-/* $OpenBSD: drm_bufs.c,v 1.49 2012/03/09 13:01:28 ariane Exp $ */
-/*-
- * Copyright 1999, 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
- * 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>
- *    Gareth Hughes <gareth@valinux.com>
- *
- */
-
-/** @file drm_bufs.c
- * Implementation of the ioctls for setup of DRM mappings and DMA buffers.
- */
-
-#include "sys/types.h"
-#include "dev/pci/pcireg.h"
-
-#include "drmP.h"
-
-int	drm_addbufs_pci(struct drm_device *, struct drm_buf_desc *);
-int	drm_addbufs_sg(struct drm_device *, struct drm_buf_desc *);
-int	drm_addbufs_agp(struct drm_device *, struct drm_buf_desc *);
-
-/*
- * 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;
-}
-
-struct drm_local_map *
-drm_core_findmap(struct drm_device *dev, unsigned long offset)
-{
-	struct drm_local_map	*map;
-
-	DRM_LOCK();
-	TAILQ_FOREACH(map, &dev->maplist, link) {
-		if (offset == map->ext)
-			break;
-	}
-	DRM_UNLOCK();
-	return (map);
-}
-
-int
-drm_addmap(struct drm_device * dev, unsigned long offset, unsigned long size,
-    enum drm_map_type type, enum drm_map_flags flags,
-    struct drm_local_map **map_ptr)
-{
-	struct drm_local_map	*map;
-	int			 align, ret = 0;
-#if 0 /* disabled for now */
-	struct drm_agp_mem	*entry;
-	int			 valid;
-#endif 
-
-	/* 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 ((flags & _DRM_REMOVABLE) && type != _DRM_SHM) {
-		DRM_ERROR("Requested removable map for non-DRM_SHM\n");
-		return EINVAL;
-	}
-	if ((offset & PAGE_MASK) || (size & PAGE_MASK)) {
-		DRM_ERROR("offset/size not page aligned: 0x%lx/0x%lx\n",
-		    offset, size);
-		return EINVAL;
-	}
-	if (offset + size < offset) {
-		DRM_ERROR("offset and size wrap around: 0x%lx/0x%lx\n",
-		    offset, size);
-		return EINVAL;
-	}
-
-	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.
-	 */
-	DRM_LOCK();
-	if (type == _DRM_REGISTERS || type == _DRM_FRAME_BUFFER ||
-	    type == _DRM_SHM) {
-		TAILQ_FOREACH(map, &dev->maplist, link) {
-			if (map->type == type && (map->offset == offset ||
-			    (map->type == _DRM_SHM &&
-			    map->flags == _DRM_CONTAINS_LOCK))) {
-				DRM_DEBUG("Found kernel map %d\n", type);
-				goto done;
-			}
-		}
-	}
-	DRM_UNLOCK();
-
-	/* Allocate a new map structure, fill it in, and do any type-specific
-	 * initialization necessary.
-	 */
-	map = drm_calloc(1, sizeof(*map));
-	if (map == NULL) {
-		DRM_LOCK();
-		return ENOMEM;
-	}
-
-	map->offset = offset;
-	map->size = size;
-	map->type = type;
-	map->flags = flags;
-
-
-	DRM_LOCK();
-	ret = extent_alloc(dev->handle_ext, map->size, PAGE_SIZE, 0,
-	    0, EX_NOWAIT, &map->ext);
-	if (ret) {
-		DRM_ERROR("can't find free offset\n");
-		DRM_UNLOCK();
-		drm_free(map);
-		return (ret);
-	}
-	DRM_UNLOCK();
-
-	switch (map->type) {
-	case _DRM_REGISTERS:
-		if (!(map->flags & _DRM_WRITE_COMBINING))
-			break;
-		/* FALLTHROUGH */
-	case _DRM_FRAME_BUFFER:
-		if (drm_mtrr_add(map->offset, map->size, DRM_MTRR_WC) == 0)
-			map->mtrr = 1;
-		break;
-	case _DRM_AGP:
-		/*valid = 0;*/
-		/* In some cases (i810 driver), user space may have already
-		 * added the AGP base itself, because dev->agp->base previously
-		 * only got set during AGP enable.  So, only add the base
-		 * address if the map's offset isn't already within the
-		 * aperture.
-		 */
-		if (map->offset < dev->agp->base ||
-		    map->offset > dev->agp->base +
-		    dev->agp->info.ai_aperture_size - 1) {
-			map->offset += dev->agp->base;
-		}
-		map->mtrr   = dev->agp->mtrr; /* for getmap */
-#if 0 /* disabled for now */
-		/*
-		 * If agp is in control of userspace (some intel drivers for
-		 * example. In which case ignore this loop.
-		 */
-		DRM_LOCK();
-		TAILQ_FOREACH(entry, &dev->agp->memory, link) {
-			DRM_DEBUG("bound = %p, pages = %p, %p\n",
-			    entry->bound, entry->pages,
-			    entry->pages * PAGE_SIZE);
-			if ((map->offset >= entry->bound) &&
-			    (map->offset + map->size <=
-			    entry->bound + entry->pages * PAGE_SIZE)) {
-				valid = 1;
-				break;
-			}
-		}
-		if (!TAILQ_EMPTY(&dev->agp->memory) && !valid) {
-			DRM_UNLOCK();
-			drm_free(map);
-			DRM_ERROR("invalid agp map requested\n");
-			return (EACCES);
-		}
-		DRM_UNLOCK();
-#endif
-		break;
-	case _DRM_SCATTER_GATHER:
-		if (dev->sg == NULL) {
-			drm_free(map);
-			return (EINVAL);
-		}
-		map->offset += dev->sg->handle;
-		break;
-	case _DRM_SHM:
-	case _DRM_CONSISTENT:
-		/*
-		 * Unfortunately, we don't get any alignment specification from
-		 * the caller, so we have to guess. So try to align the bus
-		 * address of the map to its size if possible, otherwise just
-		 * assume PAGE_SIZE alignment.
-		 */
-		align = map->size;
-		if ((align & (align - 1)) != 0)
-			align = PAGE_SIZE;
-		map->dmamem = drm_dmamem_alloc(dev->dmat, map->size, align,
-		    1, map->size, 0, 0);
-		if (map->dmamem == NULL) {
-			drm_free(map);
-			return (ENOMEM);
-		}
-		map->handle = map->dmamem->kva;
-		map->offset = map->dmamem->map->dm_segs[0].ds_addr;
-		if (map->type == _DRM_SHM && map->flags & _DRM_CONTAINS_LOCK) {
-			DRM_LOCK();
-			/* Prevent a 2nd X Server from creating a 2nd lock */
-			if (dev->lock.hw_lock != NULL) {
-				DRM_UNLOCK();
-				drm_dmamem_free(dev->dmat, map->dmamem);
-				drm_free(map);
-				return (EBUSY);
-			}
-			dev->lock.hw_lock = map->handle;
-			DRM_UNLOCK();
-		}
-		break;
-	default:
-		DRM_ERROR("Bad map type %d\n", map->type);
-		drm_free(map);
-		return EINVAL;
-	}
-
-	DRM_LOCK();
-	TAILQ_INSERT_TAIL(&dev->maplist, map, link);
-done:
-	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(struct drm_device *dev, void *data, struct drm_file *file_priv)
-{
-	struct drm_map		*request = data;
-	struct drm_local_map	*map;
-	int			 err;
-
-	if (!(file_priv->flags & (FREAD|FWRITE)))
-		return EACCES; /* Require read/write */
-
-	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;
-
-	request->handle = (void *)map->ext;
-
-	return 0;
-}
-
-void
-drm_rmmap(struct drm_device *dev, struct drm_local_map *map)
-{
-	DRM_LOCK();
-	drm_rmmap_locked(dev, map);
-	DRM_UNLOCK();
-}
-
-
-void
-drm_rmmap_locked(struct drm_device *dev, struct drm_local_map *map)
-{
-	TAILQ_REMOVE(&dev->maplist, map, link);
-
-	switch (map->type) {
-	case _DRM_REGISTERS:
-		/* FALLTHROUGH */
-	case _DRM_FRAME_BUFFER:
-		if (map->mtrr) {
-			int retcode;
-			
-			retcode = drm_mtrr_del(0, map->offset, map->size,
-			    DRM_MTRR_WC);
-			DRM_DEBUG("mtrr_del = %d\n", retcode);
-		}
-		break;
-	case _DRM_AGP:
-		/* FALLTHROUGH */
-	case _DRM_SCATTER_GATHER:
-		break;
-	case _DRM_SHM:
-		/* FALLTHROUGH */
-	case _DRM_CONSISTENT:
-		drm_dmamem_free(dev->dmat, map->dmamem);
-		break;
-	default:
-		DRM_ERROR("Bad map type %d\n", map->type);
-		break;
-	}
-
-	/* NOCOALESCE set, can't fail */
-	extent_free(dev->handle_ext, map->ext, map->size, EX_NOWAIT);
-
-	drm_free(map);
-}
-
-/* Remove a map private from list and deallocate resources if the mapping
- * isn't in use.
- */
-
-int
-drm_rmmap_ioctl(struct drm_device *dev, void *data, struct drm_file *file_priv)
-{
-	struct drm_local_map	*map;
-	struct drm_map		*request = data;
-
-	DRM_LOCK();
-	TAILQ_FOREACH(map, &dev->maplist, link) {
-		if (map->handle == request->handle &&
-		    map->flags & _DRM_REMOVABLE)
-			break;
-	}
-
-	/* No match found. */
-	if (map == NULL) {
-		DRM_UNLOCK();
-		return (EINVAL);
-	}
-
-	drm_rmmap_locked(dev, map);
-
-	DRM_UNLOCK();
-
-	return 0;
-}
-
-/*
- * DMA buffers api.
- *
- * The implementation used to be significantly more complicated, but the
- * complexity has been moved into the drivers as different buffer management
- * schemes evolved.
- *
- * This api is going to die eventually.
- */
-
-int
-drm_dma_setup(struct drm_device *dev)
-{
-
-	dev->dma = drm_calloc(1, sizeof(*dev->dma));
-	if (dev->dma == NULL)
-		return (ENOMEM);
-
-	rw_init(&dev->dma->dma_lock, "drmdma");
-
-	return (0);
-}
-
-void
-drm_cleanup_buf(struct drm_device *dev, struct drm_buf_entry *entry)
-{
-	int i;
-
-	if (entry->seg_count) {
-		for (i = 0; i < entry->seg_count; i++)
-			drm_dmamem_free(dev->dmat, entry->seglist[i]);
-		drm_free(entry->seglist);
-
-		entry->seg_count = 0;
-	}
-
-   	if (entry->buf_count) {
-	   	for (i = 0; i < entry->buf_count; i++) {
-			drm_free(entry->buflist[i].dev_private);
-		}
-		drm_free(entry->buflist);
-
-		entry->buf_count = 0;
-	}
-}
-
-void
-drm_dma_takedown(struct drm_device *dev)
-{
-	struct drm_device_dma	*dma = dev->dma;
-	int			 i;
-
-	if (dma == NULL)
-		return;
-
-	/* Clear dma buffers */
-	for (i = 0; i <= DRM_MAX_ORDER; i++)
-		drm_cleanup_buf(dev, &dma->bufs[i]);
-
-	drm_free(dma->buflist);
-	drm_free(dma->pagelist);
-	drm_free(dev->dma);
-	dev->dma = NULL;
-}
-
-
-void
-drm_free_buffer(struct drm_device *dev, struct drm_buf *buf)
-{
-	if (buf == NULL)
-		return;
-
-	buf->pending = 0;
-	buf->file_priv= NULL;
-	buf->used = 0;
-}
-
-void
-drm_reclaim_buffers(struct drm_device *dev, struct drm_file *file_priv)
-{
-	struct drm_device_dma	*dma = dev->dma;
-	int			 i;
-
-	if (dma == NULL)
-		return;
-	for (i = 0; i < dma->buf_count; i++) {
-		if (dma->buflist[i]->file_priv == file_priv)
-				drm_free_buffer(dev, dma->buflist[i]);
-	}
-}
-
-/* Call into the driver-specific DMA handler */
-int
-drm_dma(struct drm_device *dev, void *data, struct drm_file *file_priv)
-{
-	struct drm_device_dma	*dma = dev->dma;
-	struct drm_dma		*d = data;
-	int			 ret = 0;
-
-	if (dev->driver->dma_ioctl == NULL) {
-		DRM_DEBUG("DMA ioctl on driver with no dma handler\n");
-		return (EINVAL);
-	}
-
-	LOCK_TEST_WITH_RETURN(dev, file_priv);
-
-	/* Please don't send us buffers.
-	 */
-	if (d->send_count != 0) {
-		DRM_ERROR("process trying to send %d buffers via drmDMA\n",
-		    d->send_count);
-		return (EINVAL);
-	}
-
-	/* We'll send you buffers.
-	 */
-	if (d->request_count < 0 || d->request_count > dma->buf_count) {
-		DRM_ERROR("Process trying to get %d buffers (of %d max)\n",
-			  d->request_count, dma->buf_count);
-		return (EINVAL);
-	}
-	d->granted_count = 0;
-
-	if (d->request_count)
-		ret = dev->driver->dma_ioctl(dev, d, file_priv);
-	return (ret);
-}
-
-int
-drm_addbufs_agp(struct drm_device *dev, struct drm_buf_desc *request)
-{
-	struct drm_device_dma	*dma = dev->dma;
-	struct drm_buf_entry	*entry;
-	struct drm_buf		*buf, **temp_buflist;
-	unsigned long		 agp_offset, offset;
-	int			 alignment, count, order, page_order, size;
-	int			 total, byte_count, i;
-#if 0 /* disabled for now */
-	struct drm_agp_mem	*agp_entry;
-	int			 valid;
-#endif
-
-	count = request->count;
-	order = drm_order(request->size);
-	size = 1 << order;
-
-	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;
-	agp_offset = dev->agp->base + request->agp_start;
-
-	DRM_DEBUG("count:      %d\n",  count);
-	DRM_DEBUG("order:      %d\n",  order);
-	DRM_DEBUG("size:       %d\n",  size);
-	DRM_DEBUG("agp_offset: 0x%lx\n", agp_offset);
-	DRM_DEBUG("alignment:  %d\n",  alignment);
-	DRM_DEBUG("page_order: %d\n",  page_order);
-	DRM_DEBUG("total:      %d\n",  total);
-
-	/* Make sure buffers are located in AGP memory that we own */
-
-	/* Breaks MGA due to drm_alloc_agp not setting up entries for the
-	 * memory.  Safe to ignore for now because these ioctls are still
-	 * root-only.
-	 */
-#if 0 /* disabled for now */
-	valid = 0;
-	DRM_LOCK();
-	TAILQ_FOREACH(agp_entry, &dev->agp->memory, link) {
-		if ((agp_offset >= agp_entry->bound) &&
-		    (agp_offset + total * count <=
-		    agp_entry->bound + agp_entry->pages * PAGE_SIZE)) {
-			valid = 1;
-			break;
-		}
-	}
-	if (!TAILQ_EMPTY(&dev->agp->memory) && !valid) {
-		DRM_DEBUG("zone invalid\n");
-		DRM_UNLOCK();
-		return (EINVAL);
-	}
-	DRM_UNLOCK();
-#endif
-
-	entry = &dma->bufs[order];
-
-	entry->buflist = drm_calloc(count, sizeof(*entry->buflist));
-	if (entry->buflist == NULL)
-		return ENOMEM;
-
-	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->used = 0;
-
-		buf->offset = (dma->byte_count + offset);
-		buf->bus_address = agp_offset + offset;
-		buf->pending = 0;
-		buf->file_priv = NULL;
-
-		buf->dev_private = drm_calloc(1, dev->driver->buf_priv_size);
-		if (buf->dev_private == NULL) {
-			/* Set count correctly so we free the proper amount. */
-			entry->buf_count = count;
-			drm_cleanup_buf(dev, entry);
-			return ENOMEM;
-		}
-
-		offset += alignment;
-		entry->buf_count++;
-		byte_count += PAGE_SIZE << page_order;
-	}
-
-	DRM_DEBUG("byte_count: %d\n", byte_count);
-
-	/* OpenBSD lacks realloc in kernel */
-	temp_buflist = drm_realloc(dma->buflist,
-	    dma->buf_count * sizeof(*dma->buflist),
-	    (dma->buf_count + entry->buf_count) * sizeof(*dma->buflist));
-	if (temp_buflist == NULL) {
-		/* Free the entry because it isn't valid */
-		drm_cleanup_buf(dev, entry);
-		return ENOMEM;
-	}
-	dma->buflist = temp_buflist;
-
-	for (i = 0; i < entry->buf_count; i++)
-		dma->buflist[i + dma->buf_count] = &entry->buflist[i];
-
-	dma->buf_count += entry->buf_count;
-	dma->byte_count += byte_count;
-
-	DRM_DEBUG("dma->buf_count : %d\n", dma->buf_count);
-	DRM_DEBUG("entry->buf_count : %d\n", entry->buf_count);
-
-	request->count = entry->buf_count;
-	request->size = size;
-
-	dma->flags = _DRM_DMA_USE_AGP;
-
-	return 0;
-}
-
-int
-drm_addbufs_pci(struct drm_device *dev, struct drm_buf_desc *request)
-{
-	struct drm_device_dma	*dma = dev->dma;
-	struct drm_buf		*buf, **temp_buflist;
-	struct drm_buf_entry	*entry;
-	int			 alignment, byte_count, count, i, order;
-	int			 page_count, page_order, size, total;
-	unsigned long		 offset, *temp_pagelist;
-
-	count = request->count;
-	order = drm_order(request->size);
-	size = 1 << order;
-
-	DRM_DEBUG("count=%d, size=%d (%d), order=%d\n",
-	    request->count, request->size, size, order);
-
-	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;
-
-	entry = &dma->bufs[order];
-
-	entry->buflist = drm_calloc(count, sizeof(*entry->buflist));
-	entry->seglist = drm_calloc(count, sizeof(*entry->seglist));
-
-	/* Keep the original pagelist until we know all the allocations
-	 * have succeeded
-	 */
-	temp_pagelist = drm_calloc((dma->page_count + (count << page_order)),
-	    sizeof(*dma->pagelist));
-
-	if (entry->buflist == NULL || entry->seglist == NULL || 
-	    temp_pagelist == NULL) {
-		drm_free(temp_pagelist);
-		drm_free(entry->seglist);
-		drm_free(entry->buflist);
-		return ENOMEM;
-	}
-
-	memcpy(temp_pagelist, dma->pagelist, dma->page_count * 
-	    sizeof(*dma->pagelist));
-
-	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) {
-		struct drm_dmamem *mem = drm_dmamem_alloc(dev->dmat, size,
-		    alignment, 1, size, 0, 0);
-		if (mem == NULL) {
-			/* Set count correctly so we free the proper amount. */
-			entry->buf_count = count;
-			entry->seg_count = count;
-			drm_cleanup_buf(dev, entry);
-			drm_free(temp_pagelist);
-			return ENOMEM;
-		}
-
-		entry->seglist[entry->seg_count++] = mem;
-		for (i = 0; i < (1 << page_order); i++) {
-			DRM_DEBUG("page %d @ %p\n", dma->page_count +
-			    page_count, mem->kva + PAGE_SIZE * i);
-			temp_pagelist[dma->page_count + page_count++] = 
-			    (long)mem->kva + 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->used = 0;
-			buf->offset = (dma->byte_count + byte_count + offset);
-			buf->address = mem->kva + offset;
-			buf->bus_address = mem->map->dm_segs[0].ds_addr +
-			    offset;
-			buf->pending = 0;
-			buf->file_priv = NULL;
-
-			buf->dev_private = drm_calloc(1,
-			    dev->driver->buf_priv_size);
-			if (buf->dev_private == NULL) {
-				/* Set count so we free the proper amount. */
-				entry->buf_count = count;
-				entry->seg_count = count;
-				drm_cleanup_buf(dev, entry);
-				drm_free(temp_pagelist);
-				return ENOMEM;
-			}
-
-			DRM_DEBUG("buffer %d\n",
-			    entry->buf_count);
-		}
-		byte_count += PAGE_SIZE << page_order;
-	}
-
-	temp_buflist = drm_realloc(dma->buflist,
-	    dma->buf_count * sizeof(*dma->buflist),
-	    (dma->buf_count + entry->buf_count) * sizeof(*dma->buflist));
-	if (temp_buflist == NULL) {
-		/* Free the entry because it isn't valid */
-		drm_cleanup_buf(dev, entry);
-		drm_free(temp_pagelist);
-		return ENOMEM;
-	}
-	dma->buflist = temp_buflist;
-
-	for (i = 0; i < entry->buf_count; i++)
-		dma->buflist[i + dma->buf_count] = &entry->buflist[i];
-
-	/* No allocations failed, so now we can replace the orginal pagelist
-	 * with the new one.
-	 */
-	drm_free(dma->pagelist);
-	dma->pagelist = temp_pagelist;
-
-	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);
-
-	request->count = entry->buf_count;
-	request->size = size;
-
-	return 0;
-
-}
-
-int
-drm_addbufs_sg(struct drm_device *dev, struct drm_buf_desc *request)
-{
-	struct drm_device_dma	*dma = dev->dma;
-	struct drm_buf_entry	*entry;
-	struct drm_buf		*buf, **temp_buflist;
-	unsigned long		 agp_offset, offset;
-	int			 alignment, byte_count, count, i, order;
-	int			 page_order, size, total;
-
-	count = request->count;
-	order = drm_order(request->size);
-	size = 1 << order;
-
-	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;
-	agp_offset = request->agp_start;
-
-	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);
-
-	entry = &dma->bufs[order];
-
-	entry->buflist = drm_calloc(count, sizeof(*entry->buflist));
-	if (entry->buflist == NULL)
-		return ENOMEM;
-
-	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->used = 0;
-
-		buf->offset = (dma->byte_count + offset);
-		buf->bus_address = agp_offset + offset;
-		buf->pending = 0;
-		buf->file_priv = NULL;
-
-		buf->dev_private = drm_calloc(1, dev->driver->buf_priv_size);
-		if (buf->dev_private == NULL) {
-			/* Set count correctly so we free the proper amount. */
-			entry->buf_count = count;
-			drm_cleanup_buf(dev, entry);
-			return ENOMEM;
-		}
-
-		DRM_DEBUG("buffer %d\n", entry->buf_count);
-
-		offset += alignment;
-		entry->buf_count++;
-		byte_count += PAGE_SIZE << page_order;
-	}
-
-	DRM_DEBUG("byte_count: %d\n", byte_count);
-
-	temp_buflist = drm_realloc(dma->buflist, 
-	    dma->buf_count * sizeof(*dma->buflist),
-	    (dma->buf_count + entry->buf_count) * sizeof(*dma->buflist));
-	if (temp_buflist == NULL) {
-		/* Free the entry because it isn't valid */
-		drm_cleanup_buf(dev, entry);
-		return ENOMEM;
-	}
-	dma->buflist = temp_buflist;
-
-	for (i = 0; i < entry->buf_count; i++)
-		dma->buflist[i + dma->buf_count] = &entry->buflist[i];
-
-	dma->buf_count += entry->buf_count;
-	dma->byte_count += byte_count;
-
-	DRM_DEBUG("dma->buf_count : %d\n", dma->buf_count);
-	DRM_DEBUG("entry->buf_count : %d\n", entry->buf_count);
-
-	request->count = entry->buf_count;
-	request->size = size;
-
-	dma->flags = _DRM_DMA_USE_SG;
-
-	return 0;
-}
-
-int
-drm_addbufs(struct drm_device *dev, struct drm_buf_desc *request)
-{
-	struct drm_device_dma	*dma = dev->dma;
-	int			 order, ret;
-
-	if (request->count < 0 || request->count > 4096)
-		return (EINVAL);
-	
-	order = drm_order(request->size);
-	if (order < DRM_MIN_ORDER || order > DRM_MAX_ORDER)
-		return (EINVAL);
-
-	rw_enter_write(&dma->dma_lock);
-
-	/* No more allocations after first buffer-using ioctl. */
-	if (dma->buf_use != 0) {
-		rw_exit_write(&dma->dma_lock);
-		return (EBUSY);
-	}
-	/* No more than one allocation per order */
-	if (dma->bufs[order].buf_count != 0) {
-		rw_exit_write(&dma->dma_lock);
-		return (ENOMEM);
-	}
-
-	if (request->flags & _DRM_AGP_BUFFER)
-		ret = drm_addbufs_agp(dev, request);
-	else if (request->flags & _DRM_SG_BUFFER)
-		ret = drm_addbufs_sg(dev, request);
-	else
-		ret = drm_addbufs_pci(dev, request);
-
-	rw_exit_write(&dma->dma_lock);
-
-	return (ret);
-}
-
-int
-drm_freebufs(struct drm_device *dev, void *data, struct drm_file *file_priv)
-{
-	struct drm_device_dma	*dma = dev->dma;
-	struct drm_buf_free	*request = data;
-	struct drm_buf		*buf;
-	int			 i, idx, retcode = 0;
-
-	DRM_DEBUG("%d\n", request->count);
-	
-	rw_enter_write(&dma->dma_lock);
-	for (i = 0; i < request->count; i++) {
-		if (DRM_COPY_FROM_USER(&idx, &request->list[i], sizeof(idx))) {
-			retcode = EFAULT;
-			break;
-		}
-		if (idx < 0 || idx >= dma->buf_count) {
-			DRM_ERROR("Index %d (of %d max)\n", idx,
-			    dma->buf_count - 1);
-			retcode = EINVAL;
-			break;
-		}
-		buf = dma->buflist[idx];
-		if (buf->file_priv != file_priv) {
-			DRM_ERROR("Process %d freeing buffer not owned\n",
-			    DRM_CURRENTPID);
-			retcode = EINVAL;
-			break;
-		}
-		drm_free_buffer(dev, buf);
-	}
-	rw_exit_write(&dma->dma_lock);
-
-	return retcode;
-}
-
-int
-drm_mapbufs(struct drm_device *dev, void *data, struct drm_file *file_priv)
-{
-	struct drm_device_dma	*dma = dev->dma;
-	struct drm_buf_map	*request = data;
-	struct vnode		*vn;
-	vaddr_t			 address, vaddr;
-	voff_t			 foff;
-	vsize_t			 size;
-	const int		 zero = 0;
-	int			 i, retcode = 0;
-
-	if (!vfinddev(file_priv->kdev, VCHR, &vn))
-		return EINVAL;
-
-	rw_enter_write(&dma->dma_lock);
-	dev->dma->buf_use++;	/* Can't allocate more after this call */
-	rw_exit_write(&dma->dma_lock);
-
-	if (request->count < dma->buf_count)
-		goto done;
-
-	if ((dev->driver->flags & DRIVER_AGP &&
-	    (dma->flags & _DRM_DMA_USE_AGP)) ||
-	    (dev->driver->flags & DRIVER_SG &&
-	    (dma->flags & _DRM_DMA_USE_SG))) {
-		struct drm_local_map *map = dev->agp_buffer_map;
-
-		if (map == NULL) {
-			DRM_DEBUG("couldn't find agp buffer map\n");
-			retcode = EINVAL;
-			goto done;
-		}
-		size = round_page(map->size);
-		foff = map->ext;
-	} else {
-		size = round_page(dma->byte_count),
-		foff = 0;
-	}
-
-	vaddr = 0;
-	retcode = uvm_mmap(&curproc->p_vmspace->vm_map, &vaddr, size,
-	    UVM_PROT_READ | UVM_PROT_WRITE, UVM_PROT_ALL, MAP_SHARED,
-	    (caddr_t)vn, foff, curproc->p_rlimit[RLIMIT_MEMLOCK].rlim_cur,
-	    curproc);
-	if (retcode) {
-		DRM_DEBUG("uvm_mmap failed\n");
-		goto done;
-	}
-
-	request->virtual = (void *)vaddr;
-
-	for (i = 0; i < dma->buf_count; i++) {
-		if (DRM_COPY_TO_USER(&request->list[i].idx,
-		    &dma->buflist[i]->idx, sizeof(request->list[0].idx))) {
-			retcode = EFAULT;
-			goto done;
-		}
-		if (DRM_COPY_TO_USER(&request->list[i].total,
-		    &dma->buflist[i]->total, sizeof(request->list[0].total))) {
-			retcode = EFAULT;
-			goto done;
-		}
-		if (DRM_COPY_TO_USER(&request->list[i].used, &zero,
-		    sizeof(zero))) {
-			retcode = EFAULT;
-			goto done;
-		}
-		address = vaddr + dma->buflist[i]->offset; /* *** */
-		if (DRM_COPY_TO_USER(&request->list[i].address, &address,
-		    sizeof(address))) {
-			retcode = EFAULT;
-			goto done;
-		}
-	}
-
- done:
-	request->count = dma->buf_count;
-
-	DRM_DEBUG("%d buffers, retcode = %d\n", request->count, retcode);
-
-	return retcode;
-}
diff --git a/sys/dev/pci/drm/drm_context.c b/sys/dev/pci/drm/drm_context.c
deleted file mode 100644
index 7579e87c7e5..00000000000
--- a/sys/dev/pci/drm/drm_context.c
+++ /dev/null
@@ -1,174 +0,0 @@
-/* $OpenBSD: drm_context.c,v 1.15 2011/06/02 18:22:00 weerd Exp $ */
-/*-
- * Copyright 1999, 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
- * 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>
- *    Gareth Hughes <gareth@valinux.com>
- *
- */
-
-/** @file drm_context.c
- * Implementation of the context management ioctls.
- */
-
-#include "drmP.h"
-
-/* ================================================================
- * Context bitmap support
- */
-
-void
-drm_ctxbitmap_free(struct drm_device *dev, int ctx_handle)
-{
-	if (ctx_handle < 0 || ctx_handle >= DRM_MAX_CTXBITMAP || 
-	    dev->ctx_bitmap == NULL) {
-		DRM_ERROR("Attempt to free invalid context handle: %d\n",
-		   ctx_handle);
-		return;
-	}
-
-	DRM_LOCK();
-	clear_bit(ctx_handle, dev->ctx_bitmap);
-	DRM_UNLOCK();
-	return;
-}
-
-int
-drm_ctxbitmap_next(struct drm_device *dev)
-{
-	int	bit;
-
-	if (dev->ctx_bitmap == NULL)
-		return (-1);
-
-	DRM_LOCK();
-	bit = find_first_zero_bit(dev->ctx_bitmap, DRM_MAX_CTXBITMAP);
-	if (bit >= DRM_MAX_CTXBITMAP) {
-		DRM_UNLOCK();
-		return (-1);
-	}
-
-	set_bit(bit, dev->ctx_bitmap);
-	DRM_DEBUG("drm_ctxbitmap_next bit : %d\n", bit);
-	DRM_UNLOCK();
-	return (bit);
-}
-
-int
-drm_ctxbitmap_init(struct drm_device *dev)
-{
-	atomic_t	*bitmap;
-	int		 i, temp;
-
-	
-	if ((bitmap = drm_calloc(1, PAGE_SIZE)) == NULL)
-		return (ENOMEM);
-	DRM_LOCK();
-	dev->ctx_bitmap = bitmap;
-	DRM_UNLOCK();
-
-	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(struct drm_device *dev)
-{
-	atomic_t *bitmap;
-
-	DRM_LOCK();
-	bitmap = dev->ctx_bitmap;
-	dev->ctx_bitmap = NULL;
-	DRM_UNLOCK();
-	drm_free(bitmap);
-}
-
-int
-drm_resctx(struct drm_device *dev, void *data, struct drm_file *file_priv)
-{
-	struct drm_ctx_res	*res = data;
-	struct drm_ctx		 ctx;
-	int			 i;
-
-	if (res->count >= DRM_RESERVED_CONTEXTS) {
-		bzero(&ctx, sizeof(ctx));
-		for (i = 0; i < DRM_RESERVED_CONTEXTS; i++) {
-			ctx.handle = i;
-			if (DRM_COPY_TO_USER(&res->contexts[i],
-			    &ctx, sizeof(ctx)))
-				return (EFAULT);
-		}
-	}
-	res->count = DRM_RESERVED_CONTEXTS;
-
-	return (0);
-}
-
-int
-drm_addctx(struct drm_device *dev, void *data, struct drm_file *file_priv)
-{
-	struct drm_ctx	*ctx = data;
-
-	ctx->handle = drm_ctxbitmap_next(dev);
-	if (ctx->handle == DRM_KERNEL_CONTEXT) {
-		/* Skip kernel's context and get a new one. */
-		ctx->handle = drm_ctxbitmap_next(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);
-	}
-
-	return (0);
-}
-
-int
-drm_getctx(struct drm_device *dev, void *data, struct drm_file *file_priv)
-{
-	struct drm_ctx	*ctx = data;
-
-	/* This is 0, because we don't handle any context flags */
-	ctx->flags = 0;
-
-	return (0);
-}
-
-int
-drm_rmctx(struct drm_device *dev, void *data, struct drm_file *file_priv)
-{
-	struct drm_ctx	*ctx = data;
-
-	DRM_DEBUG("%d\n", ctx->handle);
-	if (ctx->handle != DRM_KERNEL_CONTEXT)
-		drm_ctxbitmap_free(dev, ctx->handle);
-
-	return (0);
-}
diff --git a/sys/dev/pci/drm/drm_drv.c b/sys/dev/pci/drm/drm_drv.c
index 0475338a863..5db10f52c4e 100644
--- a/sys/dev/pci/drm/drm_drv.c
+++ b/sys/dev/pci/drm/drm_drv.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: drm_drv.c,v 1.123 2014/02/23 09:36:52 kettenis Exp $ */
+/* $OpenBSD: drm_drv.c,v 1.124 2014/03/09 07:42:29 jsg Exp $ */
 /*-
  * Copyright 2007-2009 Owain G. Ainsworth <oga@openbsd.org>
  * Copyright © 2008 Intel Corporation
@@ -211,7 +211,6 @@ drm_attach(struct device *parent, struct device *self, void *aux)
 	dev->bridgetag = da->bridgetag;
 
 	rw_init(&dev->dev_lock, "drmdevlk");
-	mtx_init(&dev->lock.spinlock, IPL_NONE);
 	mtx_init(&dev->event_lock, IPL_TTY);
 
 	TAILQ_INIT(&dev->maplist);
@@ -246,11 +245,6 @@ drm_attach(struct device *parent, struct device *self, void *aux)
 		}
 	}
 
-	if (drm_ctxbitmap_init(dev) != 0) {
-		printf(": couldn't allocate memory for context bitmap.\n");
-		goto error;
-	}
-
 	if (dev->driver->flags & DRIVER_GEM) {
 		mtx_init(&dev->obj_name_lock, IPL_NONE);
 		SPLAY_INIT(&dev->name_tree);
@@ -278,8 +272,6 @@ drm_detach(struct device *self, int flags)
 	if (dev->driver->flags & DRIVER_GEM)
 		pool_destroy(&dev->objpl);
 
-	drm_ctxbitmap_cleanup(dev);
-
 	extent_destroy(dev->handle_ext);
 
 	drm_vblank_cleanup(dev);
@@ -354,24 +346,9 @@ drm_get_device_from_kdev(dev_t kdev)
 int
 drm_firstopen(struct drm_device *dev)
 {
-	struct drm_local_map	*map;
-	int			 i;
-
-	/* prebuild the SAREA */
-	i = drm_addmap(dev, 0, SAREA_MAX, _DRM_SHM,
-	    _DRM_CONTAINS_LOCK, &map);
-	if (i != 0)
-		return i;
-
 	if (dev->driver->firstopen)
 		dev->driver->firstopen(dev);
 
-	if (drm_core_check_feature(dev, DRIVER_DMA) &&
-	    !drm_core_check_feature(dev, DRIVER_MODESET)) {
-		if ((i = drm_dma_setup(dev)) != 0)
-			return (i);
-	}
-
 	dev->magicid = 1;
 
 	if (!drm_core_check_feature(dev, DRIVER_MODESET))
@@ -388,8 +365,6 @@ drm_firstopen(struct drm_device *dev)
 int
 drm_lastclose(struct drm_device *dev)
 {
-	struct drm_local_map	*map, *mapsave;
-
 	DRM_DEBUG("\n");
 
 	if (dev->driver->lastclose != NULL)
@@ -402,33 +377,6 @@ drm_lastclose(struct drm_device *dev)
 	if (!drm_core_check_feature(dev, DRIVER_MODESET))
 		drm_agp_takedown(dev);
 #endif
-	if (!drm_core_check_feature(dev, DRIVER_MODESET))
-		drm_dma_takedown(dev);
-
-	DRM_LOCK();
-	if (dev->sg != NULL &&
-	    !drm_core_check_feature(dev, DRIVER_MODESET)) {
-		struct drm_sg_mem *sg = dev->sg; 
-		dev->sg = NULL;
-
-		DRM_UNLOCK();
-		drm_sg_cleanup(dev, sg);
-		DRM_LOCK();
-	}
-
-	for (map = TAILQ_FIRST(&dev->maplist); map != TAILQ_END(&dev->maplist);
-	    map = mapsave) {
-		mapsave = TAILQ_NEXT(map, link);
-		if ((map->flags & _DRM_DRIVER) == 0)
-			drm_rmmap_locked(dev, map);
-	}
-
-	if (dev->lock.hw_lock != NULL) {
-		dev->lock.hw_lock = NULL; /* SHM removed */
-		dev->lock.file_priv = NULL;
-		wakeup(&dev->lock); /* there should be nothing sleeping on it */
-	}
-	DRM_UNLOCK();
 
 	return 0;
 }
@@ -542,18 +490,6 @@ drmclose(dev_t kdev, int flags, int fmt, struct proc *p)
 	DRM_DEBUG("pid = %d, device = 0x%lx, open_count = %d\n",
 	    DRM_CURRENTPID, (long)&dev->device, dev->open_count);
 
-	if (dev->lock.hw_lock && _DRM_LOCK_IS_HELD(dev->lock.hw_lock->lock)
-	    && dev->lock.file_priv == file_priv) {
-		DRM_DEBUG("Process %d dead, freeing lock for context %d\n",
-		    DRM_CURRENTPID,
-		    _DRM_LOCKING_CONTEXT(dev->lock.hw_lock->lock));
-
-		drm_lock_free(&dev->lock,
-		    _DRM_LOCKING_CONTEXT(dev->lock.hw_lock->lock));
-	}
-	if (dev->driver->flags & DRIVER_DMA)
-		drm_reclaim_buffers(dev, file_priv);
-
 	mtx_enter(&dev->event_lock);
 	struct drmevlist *list = &dev->vbl_events;
 	for (ev = TAILQ_FIRST(list); ev != TAILQ_END(list);
@@ -655,13 +591,6 @@ drmioctl(dev_t kdev, u_long cmd, caddr_t data, int flags,
 	case DRM_IOCTL_GEM_CLOSE:
 		return -drm_gem_close_ioctl(dev, data, file_priv);
 
-	/* removed */
-	case DRM_IOCTL_GET_MAP:
-		/* FALLTHROUGH */
-	case DRM_IOCTL_GET_CLIENT:
-		/* FALLTHROUGH */
-	case DRM_IOCTL_GET_STATS:
-		return (EINVAL);
 	/*
 	 * no-oped ioctls, we don't check permissions on them because
 	 * they do nothing. they'll be removed as soon as userland is
@@ -682,33 +611,12 @@ drmioctl(dev_t kdev, u_long cmd, caddr_t data, int flags,
 
 	if (file_priv->authenticated == 1) {
 		switch (cmd) {
-		case DRM_IOCTL_RM_MAP:
-			return (drm_rmmap_ioctl(dev, data, file_priv));
-		case DRM_IOCTL_GET_CTX:
-			return (drm_getctx(dev, data, file_priv));
-		case DRM_IOCTL_RES_CTX:
-			return (drm_resctx(dev, data, file_priv));
-		case DRM_IOCTL_LOCK:
-			return (drm_lock(dev, data, file_priv));
-		case DRM_IOCTL_UNLOCK:
-			return (drm_unlock(dev, data, file_priv));
-		case DRM_IOCTL_MAP_BUFS:
-			return (drm_mapbufs(dev, data, file_priv));
-		case DRM_IOCTL_FREE_BUFS:
-			return (drm_freebufs(dev, data, file_priv));
-		case DRM_IOCTL_DMA:
-			return (drm_dma(dev, data, file_priv));
-#if __OS_HAS_AGP
-		case DRM_IOCTL_AGP_INFO:
-			return (drm_agp_info_ioctl(dev, data, file_priv));
-#endif
 		case DRM_IOCTL_GEM_FLINK:
 			return (drm_gem_flink_ioctl(dev, data, file_priv));
 		case DRM_IOCTL_GEM_OPEN:
 			return -drm_gem_open_ioctl(dev, data, file_priv);
 		case DRM_IOCTL_GET_CAP:
 			return (drm_getcap(dev, data, file_priv));
-
 		}
 	}
 
@@ -721,36 +629,8 @@ drmioctl(dev_t kdev, u_long cmd, caddr_t data, int flags,
 			return (drm_irq_by_busid(dev, data, file_priv));
 		case DRM_IOCTL_AUTH_MAGIC:
 			return (drm_authmagic(dev, data, file_priv));
-		case DRM_IOCTL_ADD_MAP:
-			return (drm_addmap_ioctl(dev, data, file_priv));
-		case DRM_IOCTL_ADD_CTX:
-			return (drm_addctx(dev, data, file_priv));
-		case DRM_IOCTL_RM_CTX:
-			return (drm_rmctx(dev, data, file_priv));
-		case DRM_IOCTL_ADD_BUFS:
-			return (drm_addbufs(dev, (struct drm_buf_desc *)data));
 		case DRM_IOCTL_CONTROL:
 			return (drm_control(dev, data, file_priv));
-#if __OS_HAS_AGP
-		case DRM_IOCTL_AGP_ACQUIRE:
-			return (drm_agp_acquire_ioctl(dev, data, file_priv));
-		case DRM_IOCTL_AGP_RELEASE:
-			return (drm_agp_release_ioctl(dev, data, file_priv));
-		case DRM_IOCTL_AGP_ENABLE:
-			return (drm_agp_enable_ioctl(dev, data, file_priv));
-		case DRM_IOCTL_AGP_ALLOC:
-			return (drm_agp_alloc_ioctl(dev, data, file_priv));
-		case DRM_IOCTL_AGP_FREE:
-			return (drm_agp_free_ioctl(dev, data, file_priv));
-		case DRM_IOCTL_AGP_BIND:
-			return (drm_agp_bind_ioctl(dev, data, file_priv));
-		case DRM_IOCTL_AGP_UNBIND:
-			return (drm_agp_unbind_ioctl(dev, data, file_priv));
-#endif
-		case DRM_IOCTL_SG_ALLOC:
-			return (drm_sg_alloc_ioctl(dev, data, file_priv));
-		case DRM_IOCTL_SG_FREE:
-			return (drm_sg_free(dev, data, file_priv));
 		case DRM_IOCTL_ADD_DRAW:
 		case DRM_IOCTL_RM_DRAW:
 		case DRM_IOCTL_UPDATE_DRAW:
@@ -1036,11 +916,6 @@ drmmmap(dev_t kdev, off_t offset, int prot)
 	case _DRM_REGISTERS:
 		return (offset + map->offset);
 		break;
-	/* XXX unify all the bus_dmamem_mmap bits */
-	case _DRM_SCATTER_GATHER:
-		return (bus_dmamem_mmap(dev->dmat, dev->sg->mem->segs,
-		    dev->sg->mem->nsegs, map->offset - dev->sg->handle +
-		    offset, prot, BUS_DMA_NOWAIT));
 	case _DRM_SHM:
 	case _DRM_CONSISTENT:
 		return (bus_dmamem_mmap(dev->dmat, map->dmamem->segs,
@@ -1751,6 +1626,24 @@ udv_attach_drm(void *arg, vm_prot_t accessprot, voff_t off, vsize_t size)
 	return &obj->uobj;
 }
 
+/*
+ * 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_pcie_get_speed_cap_mask(struct drm_device *dev, u32 *mask)
 {
 	pci_chipset_tag_t	pc = dev->pc;
diff --git a/sys/dev/pci/drm/drm_lock.c b/sys/dev/pci/drm/drm_lock.c
deleted file mode 100644
index 7176c4d9e54..00000000000
--- a/sys/dev/pci/drm/drm_lock.c
+++ /dev/null
@@ -1,161 +0,0 @@
-/* $OpenBSD: drm_lock.c,v 1.17 2011/06/02 18:22:00 weerd Exp $ */
-/*-
- * 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>
- *    Gareth Hughes <gareth@valinux.com>
- *
- */
-
-/** @file drm_lock.c
- * Implementation of the ioctls and other support code for dealing with the
- * hardware lock.
- *
- * The DRM hardware lock is a shared structure between the kernel and userland.
- *
- * On uncontended access where the new context was the last context, the
- * client may take the lock without dropping down into the kernel, using atomic
- * compare-and-set.
- *
- * If the client finds during compare-and-set that it was not the last owner
- * of the lock, it calls the DRM lock ioctl, which may sleep waiting for the
- * lock, and may have side-effects of kernel-managed context switching.
- *
- * When the client releases the lock, if the lock is marked as being contended
- * by another client, then the DRM unlock ioctl is called so that the
- * contending client may be woken up.
- */
-
-#include "drmP.h"
-
-int
-drm_lock_take(struct drm_lock_data *lock_data, unsigned int context)
-{
-	volatile unsigned int	*lock = &lock_data->hw_lock->lock;
-	unsigned int		 old, new;
-
-	do {
-		old = *lock;
-		if (old & _DRM_LOCK_HELD)
-			new = old | _DRM_LOCK_CONT;
-		else
-			new = context | _DRM_LOCK_HELD;
-	} while (!atomic_cmpset_int(lock, old, new));
-
-	if (_DRM_LOCKING_CONTEXT(old) == context && _DRM_LOCK_IS_HELD(old)) {
-		if (context != DRM_KERNEL_CONTEXT)
-			DRM_ERROR("%d holds heavyweight lock\n", context);
-		return (0);
-	}
-	/* If the lock wasn't held before, it's ours */
-	return (!_DRM_LOCK_IS_HELD(old));
-}
-
-int
-drm_lock_free(struct drm_lock_data *lock_data, unsigned int context)
-{
-	volatile unsigned int	*lock = &lock_data->hw_lock->lock;
-	unsigned int		 old, new;
-
-	mtx_enter(&lock_data->spinlock);
-	lock_data->file_priv = NULL;
-	do {
-		old  = *lock;
-		new  = 0;
-	} while (!atomic_cmpset_int(lock, old, new));
-	mtx_leave(&lock_data->spinlock);
-
-	if (_DRM_LOCK_IS_HELD(old) && _DRM_LOCKING_CONTEXT(old) != context) {
-		DRM_ERROR("%d freed heavyweight lock held by %d\n",
-			  context, _DRM_LOCKING_CONTEXT(old));
-		return 1;
-	}
-	wakeup(lock_data);
-	return 0;
-}
-
-int
-drm_lock(struct drm_device *dev, void *data, struct drm_file *file_priv)
-{
-        struct drm_lock	*lock = data;
-        int		 ret = 0;
-
-        if (lock->context == DRM_KERNEL_CONTEXT) {
-                DRM_ERROR("Process %d using kernel context %d\n",
-		    DRM_CURRENTPID, lock->context);
-                return EINVAL;
-        }
-
-        DRM_DEBUG("%d (pid %d) requests lock (0x%08x), flags = 0x%08x\n",
-	    lock->context, DRM_CURRENTPID, dev->lock.hw_lock->lock,
-	    lock->flags);
-
-	mtx_enter(&dev->lock.spinlock);
-	for (;;) {
-		if (drm_lock_take(&dev->lock, lock->context)) {
-			dev->lock.file_priv = file_priv;
-			break;  /* Got lock */
-		}
-
-		/* Contention */
-		ret = msleep(&dev->lock, &dev->lock.spinlock,
-		    PZERO | PCATCH, "drmlkq", 0);
-		if (ret != 0)
-			break;
-	}
-	mtx_leave(&dev->lock.spinlock);
-	DRM_DEBUG("%d %s\n", lock->context, ret ? "interrupted" : "has lock");
-
-	if (ret != 0)
-		return ret;
-
-	/* XXX: Add signal blocking here */
-
-	return 0;
-}
-
-int
-drm_unlock(struct drm_device *dev, void *data, struct drm_file *file_priv)
-{
-	struct drm_lock	*lock = data;
-
-	if (lock->context == DRM_KERNEL_CONTEXT) {
-		DRM_ERROR("Process %d using kernel context %d\n",
-		    DRM_CURRENTPID, lock->context);
-		return EINVAL;
-	}
-	/* Check that the context unlock being requested actually matches
-	 * who currently holds the lock.
-	 */
-	if (!_DRM_LOCK_IS_HELD(dev->lock.hw_lock->lock) ||
-	    _DRM_LOCKING_CONTEXT(dev->lock.hw_lock->lock) != lock->context)
-		return EINVAL;
-
-	if (drm_lock_free(&dev->lock, lock->context)) {
-		DRM_ERROR("\n");
-	}
-
-	return 0;
-}
diff --git a/sys/dev/pci/drm/drm_memory.c b/sys/dev/pci/drm/drm_memory.c
index 2d50e351365..0173c462f4b 100644
--- a/sys/dev/pci/drm/drm_memory.c
+++ b/sys/dev/pci/drm/drm_memory.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: drm_memory.c,v 1.24 2012/12/06 15:05:21 mpi Exp $ */
+/* $OpenBSD: drm_memory.c,v 1.25 2014/03/09 07:42:29 jsg Exp $ */
 /*-
  *Copyright 1999 Precision Insight, Inc., Cedar Park, Texas.
  * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
@@ -80,69 +80,6 @@ drm_free(void *pt)
 		free(pt, M_DRM);
 }
 
-/* Inline replacements for DRM_IOREMAP macros */
-void
-drm_core_ioremap(struct drm_local_map *map, struct drm_device *dev)
-{
-	DRM_DEBUG("offset: 0x%x size: 0x%x type: %d\n", map->offset, map->size,
-	    map->type);
-
-	/* default to failure. */
-	map->handle = 0;
-
-	switch (map->type) {
-#if __OS_HAS_AGP
-	case _DRM_AGP:
-		DRM_DEBUG("AGP map\n");
-		map->bst = dev->bst;
-		/* handles are still supposed to be kernel virtual addresses */
-		map->handle = agp_map(dev->agp->agpdev,
-		    map->offset - dev->agp->base, map->size, &map->bsh);
-		if (map->handle == 0) {
-			DRM_ERROR("ioremap fail\n");
-			return;
-		}
-		break;
-#endif
-	case _DRM_FRAME_BUFFER:
-		DRM_DEBUG("FRAME_BUFFER map\n");
-		map->bst = dev->bst;
-		if (bus_space_map(map->bst, map->offset,
-		    map->size, BUS_SPACE_MAP_LINEAR |
-		    BUS_SPACE_MAP_PREFETCHABLE, &map->bsh)) {
-			DRM_ERROR("ioremap fail\n");
-			return;
-		}
-		/* handles are still supposed to be kernel virtual addresses */
-		map->handle = bus_space_vaddr(map->bst, map->bsh);
-		break;
-	default:
-		break;
-	}
-}
-
-void
-drm_core_ioremapfree(struct drm_local_map *map, struct drm_device *dev)
-{
-	if (map->handle == 0 || map->size == 0)
-		return;
-
-	switch (map->type) {
-#if __OS_HAS_AGP
-	case _DRM_AGP:
-		agp_unmap(dev->agp->agpdev, map->handle, map->size, map->bsh);
-		map->handle = 0;
-		break;
-#endif
-	case _DRM_FRAME_BUFFER:
-		bus_space_unmap(map->bst, map->bsh, map->size);
-		map->handle = 0;
-		break;
-	default:
-		break;
-	}
-}
-
 int
 drm_mtrr_add(unsigned long offset, size_t size, int flags)
 {
diff --git a/sys/dev/pci/drm/drm_scatter.c b/sys/dev/pci/drm/drm_scatter.c
deleted file mode 100644
index 5383d760c45..00000000000
--- a/sys/dev/pci/drm/drm_scatter.c
+++ /dev/null
@@ -1,119 +0,0 @@
-/* $OpenBSD: drm_scatter.c,v 1.15 2011/06/02 18:22:00 weerd Exp $ */
-/*-
- * 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>
- *   Eric Anholt <anholt@FreeBSD.org>
- *
- */
-
-/*
- * Allocation of memory for scatter-gather mappings by the graphics chip.
- *
- * The memory allocated here is then made into an aperture in the card
- * by drm_ati_pcigart_init().
- */
-#include "drmP.h"
-
-void
-drm_sg_cleanup(struct drm_device *dev, struct drm_sg_mem *entry)
-{
-	if (entry == NULL)
-		return;
-
-	drm_dmamem_free(dev->dmat, entry->mem);
-	drm_free(entry);
-}
-
-int
-drm_sg_alloc(struct drm_device * dev, struct drm_scatter_gather *request)
-{
-	struct drm_sg_mem	*entry;
-	bus_size_t		 size;
-	unsigned long		 pages;
-
-	if (dev->sg != NULL)
-		return (EINVAL);
-
-	entry = drm_calloc(1, sizeof(*entry));
-        if (entry == NULL)
-                return (ENOMEM);
-
-	pages = round_page(request->size) / PAGE_SIZE;
-	size = pages << PAGE_SHIFT;
-
-	DRM_DEBUG("sg size=%ld pages=%ld\n", request->size, pages);
-
-	if ((entry->mem = drm_dmamem_alloc(dev->dmat, size, PAGE_SIZE, pages,
-	    PAGE_SIZE, 0, 0)) == NULL)
-		return (ENOMEM);
-
-	request->handle = entry->handle = (unsigned long)entry->mem->kva;
-	DRM_DEBUG("sg alloc handle  = %08lx\n", entry->handle);
-
-	DRM_LOCK();
-	if (dev->sg) {
-		DRM_UNLOCK();
-		drm_sg_cleanup(dev, entry);
-		return EINVAL;
-	}
-	dev->sg = entry;
-	DRM_UNLOCK();
-
-	return (0);
-}
-
-int
-drm_sg_alloc_ioctl(struct drm_device *dev, void *data,
-    struct drm_file *file_priv)
-{
-	struct drm_scatter_gather	*request = data;
-	int				 ret;
-
-	DRM_DEBUG("\n");
-
-	ret = drm_sg_alloc(dev, request);
-	return ret;
-}
-
-int
-drm_sg_free(struct drm_device *dev, void *data, struct drm_file *file_priv)
-{
-	struct drm_scatter_gather	*request = data;
-	struct drm_sg_mem		*entry;
-
-	DRM_LOCK();
-	entry = dev->sg;
-	dev->sg = NULL;
-	DRM_UNLOCK();
-
-	if (entry == NULL || entry->handle != request->handle)
-		return EINVAL;
-
-	DRM_DEBUG("sg free virtual  = 0x%lx\n", entry->handle);
-
-	drm_sg_cleanup(dev, entry);
-
-	return 0;
-}
diff --git a/sys/dev/pci/drm/files.drm b/sys/dev/pci/drm/files.drm
index da7ba078919..0ab4d55a2c8 100644
--- a/sys/dev/pci/drm/files.drm
+++ b/sys/dev/pci/drm/files.drm
@@ -1,21 +1,17 @@
 # $NetBSD: files.drm,v 1.2 2007/03/28 11:29:37 jmcneill Exp $
-# $OpenBSD: files.drm,v 1.30 2014/02/23 09:36:52 kettenis Exp $
+# $OpenBSD: files.drm,v 1.31 2014/03/09 07:42:29 jsg Exp $
 
 # direct rendering modules
 define drmbase {[console = -1]}
 device drm: drmbase
 attach drm at drmbase
 file   dev/pci/drm/drm_agpsupport.c	drm & agp
-file   dev/pci/drm/drm_bufs.c		drm
-file   dev/pci/drm/drm_context.c	drm
 file   dev/pci/drm/drm_drv.c		drm	needs-flag
 file   dev/pci/drm/drm_global.c		drm
 file   dev/pci/drm/drm_hashtab.c	drm
 file   dev/pci/drm/drm_irq.c		drm
-file   dev/pci/drm/drm_lock.c		drm
 file   dev/pci/drm/drm_memory.c		drm
 file   dev/pci/drm/drm_mm.c		drm
-file   dev/pci/drm/drm_scatter.c	drm
 file   dev/pci/drm/drm_crtc.c		drm
 file   dev/pci/drm/drm_modes.c		drm
 file   dev/pci/drm/drm_crtc_helper.c	drm