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

Age	Commit message (Collapse)	Author
2006-10-21	Merge branch 'master' of git+ssh://git.freedesktop.org/git/mesa/drm	Thomas Hellstrom
2006-10-21	The CPU cache must be flushed _before_ we start modifying the kernel map ptes,	Thomas Hellstrom
	otherwise data will be missing, which becomes apparent when the kernel evicts batch buffers which are likely to be written into in the evicted state, and then rebound to the AGP aperture. This means we cannot rely on the AGP module to flush the cache for us.
2006-10-20	Bug #1746: Set dev_priv_size for the MGA driver.	Tilman Sauerbeck
2006-10-20	We apparently need this global cache flush anyway.	Thomas Hellstrom
2006-10-20	Bug #8707, 2.6.19-rc compatibility for memory manager code.	Thomas Hellstrom
2006-10-19	Merge branch 'master' of git+ssh://git.freedesktop.org/git/mesa/drm	Thomas Hellstrom
2006-10-19	Importing fixes from drm-ttm-0-2-branch	Thomas Hellstrom
2006-10-19	Make sure delayed delete list is empty on lastclose.	Thomas Hellstrom
	Fix some refcounting errors. Fix some error messages.
2006-10-18	Merging drm-ttm-0-2-branch	Thomas Hellstrom
	Conflicts: linux-core/drmP.h linux-core/drm_drv.c linux-core/drm_irq.c linux-core/drm_stub.c shared-core/drm.h shared-core/i915_drv.h shared-core/i915_irq.c
2006-10-18	Remove stray softlink.	Thomas Hellstrom
2006-10-18	Avoid driver-specific AGP user-populated types, since we don't know what AGP	Thomas Hellstrom
	driver we're on. Avoid global cache flushes before inserting pages. In general, they are never mapped, and not accessed through the kernel map, so a cache flush should not be necessary. The exception is pages that are bound cached. We might need a cache flush for those.
2006-10-17	Remove max number of locked pages check and call, since	Thomas Hellstrom
	that is now handled by the memory accounting.
2006-10-17	Lindent.	Thomas Hellstrom
2006-10-17	Add vma list memory usage to memory accounting.	Thomas Hellstrom
	Use byte unit for /proc printout of memory usage for small sizes to be able to detect memory allocation bugs more easily.
2006-10-17	Add memory usage accounting to avoid DOS problems.	Thomas Hellstrom
2006-10-17	Implement mm_lock and mm_unlock functions.	Thomas Hellstrom
	The mm_lock function is used when leaving vt. It evicts _all_ buffers. Buffers with the DRM_BO_NO_MOVE attribute set will be guaranteed to get the same offset when / if they are rebound.
2006-10-17	Remove the memory manager parameter from the put_block function, as this	Thomas Hellstrom
	makes the client code a lot cleaner. Prepare buffer manager for lock and unlock calls.
2006-10-17	Extend generality for more memory types.	Thomas Hellstrom
	Fix up init and destruction code.
2006-10-16	Change Intel AGP memory type numbers.	Thomas Hellstrom
2006-10-15	Merge branch 'master' of git://anongit.freedesktop.org/git/mesa/drm into ↵	Stephane Marchesin
	nouveau-1
2006-10-14	remove config.h from build no longer exists kbuild does it	Dave Airlie
2006-10-12	Bugfixes.	Thomas Hellstrom
2006-10-12	Simplify the AGP backend interface somewhat.	Thomas Hellstrom
	Fix buffer bound caching policy changing, Allow on-the-fly changing of caching policy on bound buffers if the hardware supports it. Allow drivers to use driver-specific AGP memory types for TTM AGP pages. Will make AGP drivers much easier to migrate.
2006-10-11	Compatibility code for 2.6.15-2.6.18. It is ugly but a little comfort is that	Thomas Hellstrom
	it will go away in the mainstream kernel. Some bugfixes, mainly in error paths.
2006-10-11	Big update:	Thomas Hellstrom
	Adapt for new functions in the 2.6.19 kernel. Remove the ability to have multiple regions in one TTM. This simplifies a lot of code. Remove the ability to access TTMs from user space. We don't need it anymore without ttm regions. Don't change caching policy for evicted buffers. Instead change it only when the buffer is accessed by the CPU (on the first page fault). This tremendously speeds up eviction rates. Current code is safe for kernels <= 2.6.14. Should also be OK with 2.6.19 and above.
2006-10-10	Use a nopage-based approach to fault in pfns.	Thomas Hellstrom
2006-10-03	Get rid of all ugly PTE hacks.	Thomas Hellstrom
2006-10-02	Bug 6242: [mach64] Use private DMA buffers, part #3.	George Sapountzis
	Add DRM_PCI_BUFFER_RO flag for mapping PCI DMA buffer read-only. An additional flag is needed, since PCI DMA buffers do not have an associated map.
2006-10-02	Fix type of second argument to spin_lock_irqsave().	Michel Dänzer
	(cherry picked from f6238cf6244b32bd84e3d2819963d7f5473867c8 commit)
2006-10-02	Fix type of second argument to spin_lock_irqsave().	Michel Dänzer
2006-10-02	Make the user_token 44-bit for TTMs, and have them occupy a unique file space	Thomas Hellstrom
	starting at 0x00100000000. This will hopefully allow us to use unmap_mapping_range(). Note that user-space will need 64-bit file offset support.
2006-10-02	Add a buffer object manager for TTM maps.	Thomas Hellstrom
2006-10-02	Allow for 44 bit user-tokens (or drm_file offsets)	Thomas Hellstrom
2006-10-02	Add a comment to previos commit.	Thomas Hellstrom
2006-10-02	Trap and be verbose about a deadlock that occurs with AIGLX and drivers that	Thomas Hellstrom
	use drm_reclaim_buffers_locked().
2006-10-02	Make locked tasklet handling more robust.	Michel Dänzer
	Initialize the spinlock unconditionally when struct drm_device is filled in, and return early in drm_locked_tasklet() if the driver doesn't support IRQs.
2006-09-29	Core vsync: Don't clobber target sequence number when scheduling signal.	Michel Dänzer
	It looks like this would have caused signals to always get sent on the next vertical blank, regardless of the sequence number. (cherry picked from cf6b2c5299e9be3542d4deddfd05d5811f11d2ef commit)
2006-09-29	Core vsync: Add flag DRM_VBLANK_NEXTONMISS.	Michel Dänzer
	When this flag is set and the target sequence is missed, wait for the next vertical blank instead of returning immediately. (cherry picked from 89e323e4900af84cc33219ad24eb0b435a039d23 commit)
2006-09-29	Change first valid DRM drawable ID to be 1 instead of 0.	Michel Dänzer
	This makes it easier for userspace to know when it needs to allocate an ID. Also free drawable information memory when it's no longer needed. (cherry picked from df7551ef7334d728ec0371423661bb403d3e270a commit)
2006-09-29	Drop tasklet locked driver callback when uninstalling IRQ.	Michel Dänzer
	(cherry picked from b9f3009160d8bd1a26a77d6f1616f1679c7b969d commit)
2006-09-29	Hook up DRM_IOCTL_UPDATE_DRAW ioctl.	Michel Dänzer
	(cherry picked from 98a89504589427a76c3f5cfa2266962a1a212672 commit)
2006-09-29	Add support for tracking drawable information to core	Michel Dänzer
	Actually make the existing ioctls for adding and removing drawables do something useful, and add another ioctl for the X server to update drawable information. The only kind of drawable information tracked so far is cliprects. (cherry picked from 29598e5253ff5c085ccf63580fd24b84db848424 commit)
2006-09-29	Add support for interrupt triggered driver callback with lock held to DRM core.	Michel Dänzer
	(cherry picked from d817cc1f30060fcc4a85a05b2de8a2a1687421b5 commit)
2006-09-29	Add support for secondary vertical blank interrupt to i915 driver.	Michel Dänzer
	When the vertical blank interrupt is enabled for both pipes, pipe A is considered primary and pipe B secondary. When it's only enabled for one pipe, it's always considered primary for backwards compatibility. (cherry picked from 0c7d7f43610f705e8536a949cf2407efaa5ec217 commit)
2006-09-29	Add support for secondary vertical blank interrupt to DRM core.	Michel Dänzer
	(cherry picked from ab351505f36a6c66405ea7604378268848340a42 commit)
2006-09-29	Fix buffer manager takedown error.	Thomas Hellstrom
	Prepare for the possibility to evict all buffers from vram / agp. This will be used by the X server when, for example, switching vts.
2006-09-28	Core vsync: Don't clobber target sequence number when scheduling signal.	Michel Dänzer
	It looks like this would have caused signals to always get sent on the next vertical blank, regardless of the sequence number.
2006-09-28	Core vsync: Add flag DRM_VBLANK_NEXTONMISS.	Michel Dänzer
	When this flag is set and the target sequence is missed, wait for the next vertical blank instead of returning immediately.
2006-09-28	Change first valid DRM drawable ID to be 1 instead of 0.	Michel Dänzer
	This makes it easier for userspace to know when it needs to allocate an ID. Also free drawable information memory when it's no longer needed.
2006-09-28	Drop tasklet locked driver callback when uninstalling IRQ.	Michel Dänzer

• [prev]
• [next]

generated by cgit v1.2.3 (git 2.25.1) at 2025-11-04 23:14:58 +0000

/*-
 * 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 "dev/pci/pcireg.h"

#include "drmP.h"

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

/* Allocation of PCI memory resources (framebuffer, registers, etc.) for
 * drm_get_resource_*.  Note that they are not RF_ACTIVE, so there's no virtual
 * address for accessing them.  Cleaned up at unload.
 */
static int drm_alloc_resource(drm_device_t *dev, int resource)
{
	if (resource >= DRM_MAX_PCI_RESOURCE) {
		DRM_ERROR("Resource %d too large\n", resource);
		return 1;
	}

	DRM_UNLOCK();
	if (dev->pcir[resource] != NULL) {
		DRM_LOCK();
		return 0;
	}

	dev->pcirid[resource] = PCIR_BAR(resource);
	dev->pcir[resource] = bus_alloc_resource_any(dev->device,
	    SYS_RES_MEMORY, &dev->pcirid[resource], RF_SHAREABLE);
	DRM_LOCK();

	if (dev->pcir[resource] == NULL) {
		DRM_ERROR("Couldn't find resource 0x%x\n", resource);
		return 1;
	}

	return 0;
}

unsigned long drm_get_resource_start(drm_device_t *dev, unsigned int resource)
{
	if (drm_alloc_resource(dev, resource) != 0)
		return 0;

	return rman_get_start(dev->pcir[resource]);
}

unsigned long drm_get_resource_len(drm_device_t *dev, unsigned int resource)
{
	if (drm_alloc_resource(dev, resource) != 0)
		return 0;

	return rman_get_size(dev->pcir[resource]);
}

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;
	int align;
	/*drm_agp_mem_t *entry;
	int valid;*/

	/* 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.
	 */
	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))) {
				map->size = size;
				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 = malloc(sizeof(*map), M_DRM, M_ZERO | M_NOWAIT);
	if ( !map )
		return ENOMEM;

	map->offset = offset;
	map->size = size;
	map->type = type;
	map->flags = flags;

	switch ( map->type ) {
	case _DRM_REGISTERS:
		map->handle = drm_ioremap(dev, map);
		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_SHM:
		map->handle = malloc(map->size, M_DRM, M_NOWAIT);
		DRM_DEBUG( "%lu %d %p\n",
			   map->size, drm_order(map->size), map->handle );
		if ( !map->handle ) {
			free(map, M_DRM);
			return ENOMEM;
		}
		map->offset = (unsigned long)map->handle;
		if ( map->flags & _DRM_CONTAINS_LOCK ) {
			/* Prevent a 2nd X Server from creating a 2nd lock */
			DRM_LOCK();
			if (dev->lock.hw_lock != NULL) {
				DRM_UNLOCK();
				free(map->handle, M_DRM);
				free(map, M_DRM);
				return EBUSY;
			}
			dev->lock.hw_lock = map->handle; /* Pointer to lock */
			DRM_UNLOCK();
		}
		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 */
		/*for (entry = dev->agp->memory; entry; entry = entry->next) {
			if ((map->offset >= entry->bound) &&
			    (map->offset + map->size <=
			    entry->bound + entry->pages * PAGE_SIZE)) {
				valid = 1;
				break;
			}
		}
		if (!valid) {
			free(map, M_DRM);
			return EACCES;
		}*/
		break;
	case _DRM_SCATTER_GATHER:
		if (!dev->sg) {
			free(map, M_DRM);
			return EINVAL;
		}
		map->offset = map->offset + dev->sg->handle;
		break;
	case _DRM_CONSISTENT:
		/* Unfortunately, we don't get any alignment specification from
		 * the caller, so we have to guess.  drm_pci_alloc requires
		 * a power-of-two alignment, so try to align the bus address of
		 * the map to it size if possible, otherwise just assume
		 * PAGE_SIZE alignment.
		 */
		align = map->size;
		if ((align & (align - 1)) != 0)
			align = PAGE_SIZE;
		map->dmah = drm_pci_alloc(dev, map->size, align, 0xfffffffful);
		if (map->dmah == NULL) {
			free(map, M_DRM);
			return ENOMEM;
		}
		map->handle = map->dmah->vaddr;
		map->offset = map->dmah->busaddr;
		break;
	default:
		DRM_ERROR("Bad map type %d\n", map->type);
		free(map, M_DRM);
		return EINVAL;
	}

	DRM_LOCK();
	TAILQ_INSERT_TAIL(&dev->maplist, map, link);

done:
	/* Jumped to, with lock held, when a kernel map is found. */

	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_device_t *dev, void *data, struct drm_file *file_priv)
{
	drm_map_t *request = data;
	drm_local_map_t *map;
	int err;

	if (!(dev->flags & (FREAD|FWRITE)))
		return EACCES; /* Require read/write */

	if (!DRM_SUSER(DRM_CURPROC) && request->type != _DRM_AGP)
		return EACCES;

	DRM_LOCK();
	err = drm_addmap(dev, request->offset, request->size, request->type,
	    request->flags, &map);
	DRM_UNLOCK();
	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;

	if (request->type != _DRM_SHM) {
		request->handle = (void *)request->offset;
	}

	return 0;
}

void drm_rmmap(drm_device_t *dev, drm_local_map_t *map)
{
	DRM_SPINLOCK_ASSERT(&dev->dev_lock);

	TAILQ_REMOVE(&dev->maplist, map, link);

	switch (map->type) {
	case _DRM_REGISTERS:
		if (map->bsr == NULL)
			drm_ioremapfree(map);
		/* FALLTHROUGH */
	case _DRM_FRAME_BUFFER:
		if (map->mtrr) {
			int __unused retcode;
			
			retcode = drm_mtrr_del(0, map->offset, map->size,
			    DRM_MTRR_WC);
			DRM_DEBUG("mtrr_del = %d\n", retcode);
		}
		break;
	case _DRM_SHM:
		free(map->handle, M_DRM);
		break;
	case _DRM_AGP:
	case _DRM_SCATTER_GATHER:
		break;
	case _DRM_CONSISTENT:
		drm_pci_free(dev, map->dmah);
		break;
	default:
		DRM_ERROR("Bad map type %d\n", map->type);
		break;
	}

	if (map->bsr != NULL) {
		bus_release_resource(dev->device, SYS_RES_MEMORY, map->rid,
		    map->bsr);
	}

	free(map, M_DRM);
}

/* Remove a map private from list and deallocate resources if the mapping
 * isn't in use.
 */

int drm_rmmap_ioctl(drm_device_t *dev, void *data, struct drm_file *file_priv)
{
	drm_local_map_t *map;
	drm_map_t *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(dev, map);

	DRM_UNLOCK();

	return 0;
}


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++) {
			drm_pci_free(dev, entry->seglist[i]);
		}
		free(entry->seglist, M_DRM);

		entry->seg_count = 0;
	}

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

		entry->buf_count = 0;
	}
}

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;
	/*drm_agp_mem_t *agp_entry;
	int valid*/
	drm_buf_t *buf;
	unsigned long offset;
	unsigned long agp_offset;
	int count;
	int order;
	int size;
	int alignment;
	int page_order;
	int total;
	int byte_count;
	int i;
	drm_buf_t **temp_buflist;

	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.
	 */
	/*valid = 0;
	for (agp_entry = dev->agp->memory; agp_entry;
	    agp_entry = agp_entry->next) {
		if ((agp_offset >= agp_entry->bound) &&
		    (agp_offset + total * count <=
		    agp_entry->bound + agp_entry->pages * PAGE_SIZE)) {
			valid = 1;
			break;
		}
	}
	if (!valid) {
		DRM_DEBUG("zone invalid\n");
		return EINVAL;
	}*/

	entry = &dma->bufs[order];

	entry->buflist = malloc(count * sizeof(*entry->buflist), M_DRM,
	    M_NOWAIT | M_ZERO);
	if ( !entry->buflist ) {
		return ENOMEM;
	}

	entry->buf_size = size;
	entry->page_order = page_order;