index : renesas/drm.git	android live master
	libdrm, cloned from git://anongit.freedesktop.org/mesa/drm	Laurent Pinchart

summaryrefslogtreecommitdiff

log msg author committer range

path: root/linux-core/drm_ioctl.c

Age	Commit message (Expand)	Author
2005-08-16	add Egberts 32/64 bit patch (its in kernel already...)	Dave Airlie
2005-08-05	Rename the driver hooks in the DRM to something a little more	Eric Anholt
2005-03-08	Fix for bug 2673 from Egbert Eich - memset the version	Dave Airlie
2005-01-24	hopefully fix drm_core setversion ioctl... pointed out by Eric on irc	Dave Airlie
2004-10-20	Switch linux-core from using dev->pdev->driver->name to	Jon Smirl
2004-10-20	Fix dd vs di version typo in drm_setversion	Jon Smirl
2004-10-19	Add a protective check against a possible buffer overflow	Jon Smirl
2004-10-18	Update Doxygen configuration & comments.	Jose Fonseca
2004-10-12	Breakout heads into their own data structures.	Jon Smirl
2004-10-10	Rename fn_tbl to driver. Core driver now uses pci_driver name which	Jon Smirl
2004-09-30	Lindent of core build. Drivers checked for no binary diffs. A few files	Jon Smirl
2004-09-30	Move things around to reduce public symbols and even out files. Switch to	Jon Smirl
2004-09-27	First check in for DRM that splits core from personality modules	Jon Smirl
2004-09-05	merge back bunch of whitespace and misc changes from kernel	Dave Airlie
2004-08-27	__NO_VERSION__ hasn't been needed since 2.3 days ditch it...	Dave Airlie
2004-08-24	Merged drmfntbl-0-0-2	Dave Airlie
2004-07-25	sync up with current 2.6 kernel bk tree - mostly __user annotations	Dave Airlie
2004-07-20	first set of __user annotations from kernel (Al Viro)	Dave Airlie
2004-06-07	The dev->devname being passed to request_irq in drm_irq.h is null. With the	Dave Airlie
2003-11-05	- Tie the DRM to a specific device: setunique no longer succeeds when given	Eric Anholt
2003-10-23	- Introduce a new ioctl, DRM_IOCTL_SET_VERSION. This ioctl allows the	Eric Anholt
2003-05-27	Merged DRM documentation.	Jose Fonseca
2003-04-24	Remove unused dev->map_count. We always iterate the maplist with	Leif Delgass
2003-04-08	Use list_entry() to get container struct from struct list_head pointers.	Leif Delgass
2003-03-25	linux merge for drm	Alan Hourihane
2002-10-08	Fix error condition...	Keith Whitwell
2002-10-08	Call pci_enable_device() in DRM(irq_busid).	Keith Whitwell
2001-09-25	merge with 2.4.10 kernel	Alan Hourihane
2001-08-14	A few warning fixes when actually building under 2.4.9-pre2 + some	Jeff Hartmann
2001-08-10	Commit Keith Owens kernel Makefile changes, merge and commit alpha patch	Jeff Hartmann
2001-08-07	Lots of DRM fixes: added new pieces of template code so the ffb driver can	Jeff Hartmann
2001-07-20	Merge checker fixes from Alan Cox made to the drm in the ac kernel tree.	Jeff Hartmann
2001-05-01	Import of XFree86 4.0.99.3	David Dawes
2001-04-09	Import -f XFree86 4.0.99.2	David Dawes
2001-04-05	Merged ati-pcigart-1-0-0	Kevin E Martin
2001-03-14	Merged sarea-1-0-0	Kevin E Martin
2001-02-15	Merge mga-1-0-0-branch into trunk.	Gareth Hughes

generated by cgit v1.2.3 (git 2.25.1) at 2024-10-01 13:23:22 +0000

/**
 * \file drm_bufs.h 
 * Generic buffer template
 * 
 * \author Rickard E. (Rik) Faith <faith@valinux.com>
 * \author Gareth Hughes <gareth@valinux.com>
 */

/*
 * Created: Thu Nov 23 03:10:50 2000 by gareth@valinux.com
 *
 * 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.
 */

#include <linux/vmalloc.h>
#include "drmP.h"

/**
 * Compute size order.  Returns the exponent of the smaller power of two which
 * is greater or equal to given number.
 * 
 * \param size size.
 * \return order.
 *
 * \todo Can be made faster.
 */
int DRM(order)( unsigned long size )
{
	int order;
	unsigned long tmp;

	for (order = 0, tmp = size >> 1; tmp; tmp >>= 1, order++)
		;

	if (size & (size - 1))
		++order;

	return order;
}

static int permanent_maps = 0; 
 /**
 * Adjusts the memory offset to its absolute value according to the mapping
 * type.  Adds the map to the map list drm_device::maplist. Adds MTRR's where
 * applicable and if supported by the kernel.
 */
int DRM(initmap)( drm_device_t *dev, unsigned int offset, unsigned int size, int type, int flags )
{
	drm_map_t *map;
	drm_map_list_t *list;

	DRM_DEBUG("\n");

	if ( (offset & (~PAGE_MASK)) || (size & (~PAGE_MASK)) )
		return -EINVAL;
#if !defined(__sparc__) && !defined(__alpha__)
	if ( offset + size < offset || offset < virt_to_phys(high_memory) )
		return -EINVAL;
#endif
	if ( !(list = DRM(alloc)( sizeof(*list), DRM_MEM_MAPS )))
		return -ENOMEM;
	memset(list, 0, sizeof(*list));
		
	if ( !(map = DRM(alloc)( sizeof(*map), DRM_MEM_MAPS ))) {
		DRM(free)(list, sizeof(*list), DRM_MEM_MAPS);
		return -ENOMEM;
	}

	*map = (drm_map_t){
		.offset = offset,
		.size = size,
		.type = type,
		.flags = flags,
		.mtrr = -1,
		.handle = 0,
	};
	list->map = map;

	DRM_DEBUG( "initmap offset = 0x%08lx, size = 0x%08lx, type = %d\n",
		   map->offset, map->size, map->type );
        
#ifdef __alpha__
	map->offset += dev->hose->mem_space->start;
#endif
	if (drm_core_has_MTRR(dev)) {
		if ( map->type == _DRM_FRAME_BUFFER ||
		     (map->flags & _DRM_WRITE_COMBINING) ) {
			map->mtrr = mtrr_add( map->offset, map->size,
					      MTRR_TYPE_WRCOMB, 1 );
		}
	}

	if (map->type == _DRM_REGISTERS)
		map->handle = DRM(ioremap)( map->offset, map->size, dev );

	down(&dev->struct_sem);
	list_add(&list->head, &dev->maplist->head);
	up(&dev->struct_sem);
	
	permanent_maps = 1;
	DRM_DEBUG("finished\n");

	return 0;
}

/**
 * Ioctl to specify a range of memory that is available for mapping by a non-root process.
 *
 * \param inode device inode.
 * \param filp file pointer.
 * \param cmd command.
 * \param arg pointer to a drm_map structure.
 * \return zero on success or a negative value on error.
 *
 * Adjusts the memory offset to its absolute value according to the mapping
 * type.  Adds the map to the map list drm_device::maplist. Adds MTRR's where
 * applicable and if supported by the kernel.
 */
int DRM(addmap)( struct inode *inode, struct file *filp,
		 unsigned int cmd, unsigned long arg )
{
	drm_file_t *priv = filp->private_data;
	drm_device_t *dev = priv->dev;
	drm_map_t *map;
	drm_map_t __user *argp = (void __user *)arg;
	drm_map_list_t *list;

	if ( !(filp->f_mode & 3) ) return -EACCES; /* Require read/write */

	map = DRM(alloc)( sizeof(*map), DRM_MEM_MAPS );
	if ( !map )
		return -ENOMEM;

	if ( copy_from_user( map, argp, sizeof(*map) ) ) {
		DRM(free)( map, sizeof(*map), DRM_MEM_MAPS );
		return -EFAULT;
	}

	/* 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 ( (map->flags & _DRM_REMOVABLE) && map->type != _DRM_SHM ) {
		DRM(free)( map, sizeof(*map), DRM_MEM_MAPS );
		return -EINVAL;
	}
	DRM_DEBUG( "offset = 0x%08lx, size = 0x%08lx, type = %d\n",
		   map->offset, map->size, map->type );
	if ( (map->offset & (~PAGE_MASK)) || (map->size & (~PAGE_MASK)) ) {
		DRM(free)( map, sizeof(*map), DRM_MEM_MAPS );
		return -EINVAL;
	}
	map->mtrr   = -1;
	map->handle = NULL;

	switch ( map->type ) {
	case _DRM_REGISTERS:
	case _DRM_FRAME_BUFFER: {
		/* after all the drivers switch to permanent mapping this should just return an error */
        	struct list_head *_list;

		/* If permanent maps are implemented, maps must match */
		if (permanent_maps) {
			DRM_DEBUG( "Looking for: offset = 0x%08lx, size = 0x%08lx, type = %d\n",
				map->offset, map->size, map->type );
			list_for_each( _list, &dev->maplist->head ) {
				drm_map_list_t *_entry = list_entry( _list, drm_map_list_t, head );
				DRM_DEBUG( "Checking: offset = 0x%08lx, size = 0x%08lx, type = %d\n",
					_entry->map->offset, _entry->map->size, _entry->map->type );
				if ( _entry->map && map->type == _entry->map->type  &&
						map->offset == _entry->map->offset ) {
					_entry->map->size = map->size;
					DRM(free)( map, sizeof(*map), DRM_MEM_MAPS );
					map = _entry->map;
					DRM_DEBUG( "Found existing: offset = 0x%08lx, size = 0x%08lx, type = %d\n",
						map->offset, map->size, map->type );
					goto found_it;
				}
			}
			/* addmap didn't match an existing permanent map, that's an error */
			return -EINVAL;
		}
#if !defined(__sparc__) && !defined(__alpha__) && !defined(__ia64__)
		if ( map->offset + map->size < map->offset ||
		     map->offset < virt_to_phys(high_memory) ) {
			DRM(free)( map, sizeof(*map), DRM_MEM_MAPS );
			return -EINVAL;
		}
#endif
#ifdef __alpha__
		map->offset += dev->hose->mem_space->start;
#endif
		if (drm_core_has_MTRR(dev)) {
			if ( map->type == _DRM_FRAME_BUFFER ||
			     (map->flags & _DRM_WRITE_COMBINING) ) {
				map->mtrr = mtrr_add( map->offset, map->size,
						      MTRR_TYPE_WRCOMB, 1 );
			}
		}
		if (map->type == _DRM_REGISTERS)
			map->handle = DRM(ioremap)( map->offset, map->size,
						    dev );
		break;
	}
	case _DRM_SHM:
		map->handle = vmalloc_32(map->size);
		DRM_DEBUG( "%lu %d %p\n",
			   map->size, DRM(order)( map->size ), map->handle );
		if ( !map->handle ) {
			DRM(free)( map, sizeof(*map), DRM_MEM_MAPS );
			return -ENOMEM;
		}
		map->offset = (unsigned long)map->handle;
		if ( map->flags & _DRM_CONTAINS_LOCK ) {
			/* Prevent a 2nd X Server from creating a 2nd lock */
			if (dev->lock.hw_lock != NULL) {
				vfree( map->handle );
				DRM(free)( map, sizeof(*map), DRM_MEM_MAPS );
				return -EBUSY;
			}
			dev->sigdata.lock =
			dev->lock.hw_lock = map->handle; /* Pointer to lock */
		}
		break;
	case _DRM_AGP:
		if (drm_core_has_AGP(dev)) {
#ifdef __alpha__
			map->offset += dev->hose->mem_space->start;
#endif
			map->offset += dev->agp->base;
			map->mtrr   = dev->agp->agp_mtrr; /* for getmap */
		}
		break;
	case _DRM_SCATTER_GATHER:
		if (!dev->sg) {
			DRM(free)(map, sizeof(*map), DRM_MEM_MAPS);
			return -EINVAL;
		}
		map->offset += dev->sg->handle;
		break;

	default:
		DRM(free)( map, sizeof(*map), DRM_MEM_MAPS );
		return -EINVAL;
	}

	list = DRM(alloc)(sizeof(*list), DRM_MEM_MAPS);
	if(!list) {
		DRM(free)(map, sizeof(*map), DRM_MEM_MAPS);
		return -EINVAL;
	}
	memset(list, 0, sizeof(*list));
	list->map = map;

	down(&dev->struct_sem);
	list_add(&list->head, &dev->maplist->head);
 	up(&dev->struct_sem);
found_it:
	if ( copy_to_user( argp, map, sizeof(*map) ) )
		return -EFAULT;
	if ( map->type != _DRM_SHM ) {
		if ( copy_to_user( &argp->handle,
				   &map->offset,
				   sizeof(map->offset) ) )
			return -EFAULT;
	}
	return 0;
}


/**
 * Remove a map private from list and deallocate resources if the mapping
 * isn't in use.
 *
 * \param inode device inode.
 * \param filp file pointer.
 * \param cmd command.
 * \param arg pointer to a drm_map_t structure.
 * \return zero on success or a negative value on error.
 *
 * Searches the map on drm_device::maplist, removes it from the list, see if
 * its being used, and free any associate resource (such as MTRR's) if it's not
 * being on use.
 *
 * \sa addmap().
 */
int DRM(rmmap)(struct inode *inode, struct file *filp,
	       unsigned int cmd, unsigned long arg)
{
	drm_file_t	*priv	= filp->private_data;
	drm_device_t	*dev	= priv->dev;
	struct list_head *list;
	drm_map_list_t *r_list = NULL;
	drm_vma_entry_t *pt, *prev;
	drm_map_t *map;
	drm_map_t request;
	int found_maps = 0;

	if (copy_from_user(&request, (drm_map_t __user *)arg,
			   sizeof(request))) {
		return -EFAULT;
	}
	
	down(&dev->struct_sem);
	list = &dev->maplist->head;
	list_for_each(list, &dev->maplist->head) {
		r_list = list_entry(list, drm_map_list_t, head);

		if(r_list->map &&
		   r_list->map->handle == request.handle &&
		   r_list->map->flags & _DRM_REMOVABLE) break;
	}

	/* List has wrapped around to the head pointer, or its empty we didn't
	 * find anything.
	 */
	if(list == (&dev->maplist->head)) {
		up(&dev->struct_sem);
		return -EINVAL;
	}
	map = r_list->map;
	
	/* Register and framebuffer maps are permanent */
	if ((map->type == _DRM_REGISTERS) || (map->type == _DRM_FRAME_BUFFER)) {
		up(&dev->struct_sem);
		return 0;
	}
	list_del(list);
	DRM(free)(list, sizeof(*list), DRM_MEM_MAPS);

	for (pt = dev->vmalist, prev = NULL; pt; prev = pt, pt = pt->next) {
		if (pt->vma->vm_private_data == map) found_maps++;
	}

	if(!found_maps) {
		switch (map->type) {
		case _DRM_REGISTERS:
		case _DRM_FRAME_BUFFER:
			break;  /* Can't get here, make compiler happy */
		case _DRM_SHM:
			vfree(map->handle);
			break;
		case _DRM_AGP:
		case _DRM_SCATTER_GATHER:
			break;
		}
		DRM(free)(map, sizeof(*map), DRM_MEM_MAPS);
	}
	up(&dev->struct_sem);
	return 0;
}

/**
 * Cleanup after an error on one of the addbufs() functions.
 *
 * \param dev DRM device.
 * \param entry buffer entry where the error occurred.
 *
 * Frees any pages and buffers associated with the given entry.
 */
static void DRM(cleanup_buf_error)(drm_device_t *dev, drm_buf_entry_t *entry)
{
	int i;

	if (entry->seg_count) {
		for (i = 0; i < entry->seg_count; i++) {
			if (entry->seglist[i]) {
				DRM(free_pages)(entry->seglist[i],
					        entry->page_order,
					        DRM_MEM_DMA);
			}
		}
		DRM(free)(entry->seglist,
			  entry->seg_count *
			  sizeof(*entry->seglist),
			  DRM_MEM_SEGS);

		entry->seg_count = 0;
	}

   	if (entry->buf_count) {
	   	for (i = 0; i < entry->buf_count; i++) {
			if (entry->buflist[i].dev_private) {
				DRM(free)(entry->buflist[i].dev_private,