1 files changed, 136 insertions, 103 deletions

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