[deliverable/linux.git] / drivers / char / drm / radeon_mem.c

/* radeon_mem.c -- Simple GART/fb memory manager for radeon -*- linux-c -*-
 *
 * Copyright (C) The Weather Channel, Inc.  2002.  All Rights Reserved.
 *
 * The Weather Channel (TM) funded Tungsten Graphics to develop the
 * initial release of the Radeon 8500 driver under the XFree86 license.
 * This notice must be preserved.
 *
 * 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:
 *    Keith Whitwell <keith@tungstengraphics.com>
 */

#include "drmP.h"
#include "drm.h"
#include "radeon_drm.h"
#include "radeon_drv.h"

/* Very simple allocator for GART memory, working on a static range
 * already mapped into each client's address space.
 */

static struct mem_block *split_block(struct mem_block *p, int start, int size,
				     DRMFILE filp)
{
	/* Maybe cut off the start of an existing block */
	if (start > p->start) {
		struct mem_block *newblock =
		    drm_alloc(sizeof(*newblock), DRM_MEM_BUFS);
		if (!newblock)
			goto out;
		newblock->start = start;
		newblock->size = p->size - (start - p->start);
		newblock->filp = NULL;
		newblock->next = p->next;
		newblock->prev = p;
		p->next->prev = newblock;
		p->next = newblock;
		p->size -= newblock->size;
		p = newblock;
	}

	/* Maybe cut off the end of an existing block */
	if (size < p->size) {
		struct mem_block *newblock =
		    drm_alloc(sizeof(*newblock), DRM_MEM_BUFS);
		if (!newblock)
			goto out;
		newblock->start = start + size;
		newblock->size = p->size - size;
		newblock->filp = NULL;
		newblock->next = p->next;
		newblock->prev = p;
		p->next->prev = newblock;
		p->next = newblock;
		p->size = size;
	}

      out:
	/* Our block is in the middle */
	p->filp = filp;
	return p;
}

static struct mem_block *alloc_block(struct mem_block *heap, int size,
				     int align2, DRMFILE filp)
{
	struct mem_block *p;
	int mask = (1 << align2) - 1;

	list_for_each(p, heap) {
		int start = (p->start + mask) & ~mask;
		if (p->filp == 0 && start + size <= p->start + p->size)
			return split_block(p, start, size, filp);
	}

	return NULL;
}

static struct mem_block *find_block(struct mem_block *heap, int start)
{
	struct mem_block *p;

	list_for_each(p, heap)
	    if (p->start == start)
		return p;

	return NULL;
}

static void free_block(struct mem_block *p)
{
	p->filp = NULL;

	/* Assumes a single contiguous range.  Needs a special filp in
	 * 'heap' to stop it being subsumed.
	 */
	if (p->next->filp == 0) {
		struct mem_block *q = p->next;
		p->size += q->size;
		p->next = q->next;
		p->next->prev = p;
		drm_free(q, sizeof(*q), DRM_MEM_BUFS);
	}

	if (p->prev->filp == 0) {
		struct mem_block *q = p->prev;
		q->size += p->size;
		q->next = p->next;
		q->next->prev = q;
		drm_free(p, sizeof(*q), DRM_MEM_BUFS);
	}
}

/* Initialize.  How to check for an uninitialized heap?
 */
static int init_heap(struct mem_block **heap, int start, int size)
{
	struct mem_block *blocks = drm_alloc(sizeof(*blocks), DRM_MEM_BUFS);

	if (!blocks)
		return DRM_ERR(ENOMEM);

	*heap = drm_alloc(sizeof(**heap), DRM_MEM_BUFS);
	if (!*heap) {
		drm_free(blocks, sizeof(*blocks), DRM_MEM_BUFS);
		return DRM_ERR(ENOMEM);
	}

	blocks->start = start;
	blocks->size = size;
	blocks->filp = NULL;
	blocks->next = blocks->prev = *heap;

	memset(*heap, 0, sizeof(**heap));
	(*heap)->filp = (DRMFILE) - 1;
	(*heap)->next = (*heap)->prev = blocks;
	return 0;
}

/* Free all blocks associated with the releasing file.
 */
void radeon_mem_release(DRMFILE filp, struct mem_block *heap)
{
	struct mem_block *p;

	if (!heap || !heap->next)
		return;

	list_for_each(p, heap) {
		if (p->filp == filp)
			p->filp = NULL;
	}

	/* Assumes a single contiguous range.  Needs a special filp in
	 * 'heap' to stop it being subsumed.
	 */
	list_for_each(p, heap) {
		while (p->filp == 0 && p->next->filp == 0) {
			struct mem_block *q = p->next;
			p->size += q->size;
			p->next = q->next;
			p->next->prev = p;
			drm_free(q, sizeof(*q), DRM_MEM_DRIVER);
		}
	}
}

/* Shutdown.
 */
void radeon_mem_takedown(struct mem_block **heap)
{
	struct mem_block *p;

	if (!*heap)
		return;

	for (p = (*heap)->next; p != *heap;) {
		struct mem_block *q = p;
		p = p->next;
		drm_free(q, sizeof(*q), DRM_MEM_DRIVER);
	}

	drm_free(*heap, sizeof(**heap), DRM_MEM_DRIVER);
	*heap = NULL;
}

/* IOCTL HANDLERS */

static struct mem_block **get_heap(drm_radeon_private_t * dev_priv, int region)
{
	switch (region) {
	case RADEON_MEM_REGION_GART:
		return &dev_priv->gart_heap;
	case RADEON_MEM_REGION_FB:
		return &dev_priv->fb_heap;
	default:
		return NULL;
	}
}

int radeon_mem_alloc(DRM_IOCTL_ARGS)
{
	DRM_DEVICE;
	drm_radeon_private_t *dev_priv = dev->dev_private;
	drm_radeon_mem_alloc_t alloc;
	struct mem_block *block, **heap;

	if (!dev_priv) {
		DRM_ERROR("%s called with no initialization\n", __FUNCTION__);
		return DRM_ERR(EINVAL);
	}

	DRM_COPY_FROM_USER_IOCTL(alloc, (drm_radeon_mem_alloc_t __user *) data,
				 sizeof(alloc));

	heap = get_heap(dev_priv, alloc.region);
	if (!heap || !*heap)
		return DRM_ERR(EFAULT);

	/* Make things easier on ourselves: all allocations at least
	 * 4k aligned.
	 */
	if (alloc.alignment < 12)
		alloc.alignment = 12;

	block = alloc_block(*heap, alloc.size, alloc.alignment, filp);

	if (!block)
		return DRM_ERR(ENOMEM);

	if (DRM_COPY_TO_USER(alloc.region_offset, &block->start, sizeof(int))) {
		DRM_ERROR("copy_to_user\n");
		return DRM_ERR(EFAULT);
	}

	return 0;
}

int radeon_mem_free(DRM_IOCTL_ARGS)
{
	DRM_DEVICE;
	drm_radeon_private_t *dev_priv = dev->dev_private;
	drm_radeon_mem_free_t memfree;
	struct mem_block *block, **heap;

	if (!dev_priv) {
		DRM_ERROR("%s called with no initialization\n", __FUNCTION__);
		return DRM_ERR(EINVAL);
	}

	DRM_COPY_FROM_USER_IOCTL(memfree, (drm_radeon_mem_free_t __user *) data,
				 sizeof(memfree));

	heap = get_heap(dev_priv, memfree.region);
	if (!heap || !*heap)
		return DRM_ERR(EFAULT);

	block = find_block(*heap, memfree.region_offset);
	if (!block)
		return DRM_ERR(EFAULT);

	if (block->filp != filp)
		return DRM_ERR(EPERM);

	free_block(block);
	return 0;
}

int radeon_mem_init_heap(DRM_IOCTL_ARGS)
{
	DRM_DEVICE;
	drm_radeon_private_t *dev_priv = dev->dev_private;
	drm_radeon_mem_init_heap_t initheap;
	struct mem_block **heap;

	if (!dev_priv) {
		DRM_ERROR("%s called with no initialization\n", __FUNCTION__);
		return DRM_ERR(EINVAL);
	}

	DRM_COPY_FROM_USER_IOCTL(initheap,
				 (drm_radeon_mem_init_heap_t __user *) data,
				 sizeof(initheap));

	heap = get_heap(dev_priv, initheap.region);
	if (!heap)
		return DRM_ERR(EFAULT);

	if (*heap) {
		DRM_ERROR("heap already initialized?");
		return DRM_ERR(EFAULT);
	}

	return init_heap(heap, initheap.start, initheap.size);
}
Commit	Line	Data
1da177e4 LT	1	/* radeon_mem.c -- Simple GART/fb memory manager for radeon -- linux-c --
	2	*
	3	* Copyright (C) The Weather Channel, Inc. 2002. All Rights Reserved.
b5e89ed5	4	*
1da177e4 LT	5	* The Weather Channel (TM) funded Tungsten Graphics to develop the
	6	* initial release of the Radeon 8500 driver under the XFree86 license.
	7	* This notice must be preserved.
	8	*
	9	* Permission is hereby granted, free of charge, to any person obtaining a
	10	* copy of this software and associated documentation files (the "Software"),
	11	* to deal in the Software without restriction, including without limitation
	12	* the rights to use, copy, modify, merge, publish, distribute, sublicense,
	13	* and/or sell copies of the Software, and to permit persons to whom the
	14	* Software is furnished to do so, subject to the following conditions:
	15	*
	16	* The above copyright notice and this permission notice (including the next
	17	* paragraph) shall be included in all copies or substantial portions of the
	18	* Software.
	19	*
	20	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	21	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	22	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
	23	* PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
	24	* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
	25	* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
	26	* DEALINGS IN THE SOFTWARE.
	27	*
	28	* Authors:
	29	* Keith Whitwell <keith@tungstengraphics.com>
	30	*/
	31
	32	#include "drmP.h"
	33	#include "drm.h"
	34	#include "radeon_drm.h"
	35	#include "radeon_drv.h"
	36
	37	/* Very simple allocator for GART memory, working on a static range
b5e89ed5	38	* already mapped into each client's address space.
1da177e4 LT	39	*/
	40
	41	static struct mem_block split_block(struct mem_block p, int start, int size,
b5e89ed5	42	DRMFILE filp)
1da177e4 LT	43	{
	44	/* Maybe cut off the start of an existing block */
	45	if (start > p->start) {
b5e89ed5 DA	46	struct mem_block *newblock =
	47	drm_alloc(sizeof(*newblock), DRM_MEM_BUFS);
	48	if (!newblock)
1da177e4 LT	49	goto out;
	50	newblock->start = start;
	51	newblock->size = p->size - (start - p->start);
	52	newblock->filp = NULL;
	53	newblock->next = p->next;
	54	newblock->prev = p;
	55	p->next->prev = newblock;
	56	p->next = newblock;
	57	p->size -= newblock->size;
	58	p = newblock;
	59	}
b5e89ed5	60
1da177e4 LT	61	/* Maybe cut off the end of an existing block */
1da177e4 LT	62	if (size < p->size) {
b5e89ed5 DA	63	struct mem_block *newblock =
b5e89ed5 DA	64	drm_alloc(sizeof(*newblock), DRM_MEM_BUFS);
1da177e4 LT	65	if (!newblock)
	66	goto out;
	67	newblock->start = start + size;
	68	newblock->size = p->size - size;
	69	newblock->filp = NULL;
	70	newblock->next = p->next;
	71	newblock->prev = p;
	72	p->next->prev = newblock;
	73	p->next = newblock;
	74	p->size = size;
	75	}
	76
b5e89ed5	77	out:
1da177e4 LT	78	/* Our block is in the middle */
	79	p->filp = filp;
	80	return p;
	81	}
	82
b5e89ed5 DA	83	static struct mem_block alloc_block(struct mem_block heap, int size,
b5e89ed5 DA	84	int align2, DRMFILE filp)
1da177e4 LT	85	{
1da177e4 LT	86	struct mem_block *p;
b5e89ed5	87	int mask = (1 << align2) - 1;
1da177e4 LT	88
	89	list_for_each(p, heap) {
	90	int start = (p->start + mask) & ~mask;
	91	if (p->filp == 0 && start + size <= p->start + p->size)
b5e89ed5	92	return split_block(p, start, size, filp);
1da177e4 LT	93	}
	94
	95	return NULL;
	96	}
	97
b5e89ed5	98	static struct mem_block find_block(struct mem_block heap, int start)
1da177e4 LT	99	{
	100	struct mem_block *p;
	101
	102	list_for_each(p, heap)
b5e89ed5 DA	103	if (p->start == start)
b5e89ed5 DA	104	return p;
1da177e4 LT	105
	106	return NULL;
	107	}
	108
b5e89ed5	109	static void free_block(struct mem_block *p)
1da177e4 LT	110	{
	111	p->filp = NULL;
	112
	113	/* Assumes a single contiguous range. Needs a special filp in
	114	* 'heap' to stop it being subsumed.
	115	*/
	116	if (p->next->filp == 0) {
	117	struct mem_block *q = p->next;
	118	p->size += q->size;
	119	p->next = q->next;
	120	p->next->prev = p;
b5e89ed5	121	drm_free(q, sizeof(*q), DRM_MEM_BUFS);
1da177e4 LT	122	}
	123
	124	if (p->prev->filp == 0) {
	125	struct mem_block *q = p->prev;
	126	q->size += p->size;
	127	q->next = p->next;
	128	q->next->prev = q;
b5e89ed5	129	drm_free(p, sizeof(*q), DRM_MEM_BUFS);
1da177e4 LT	130	}
	131	}
	132
	133	/* Initialize. How to check for an uninitialized heap?
	134	*/
	135	static int init_heap(struct mem_block **heap, int start, int size)
	136	{
b5e89ed5	137	struct mem_block blocks = drm_alloc(sizeof(blocks), DRM_MEM_BUFS);
1da177e4	138
b5e89ed5	139	if (!blocks)
1da177e4	140	return DRM_ERR(ENOMEM);
b5e89ed5 DA	141
b5e89ed5 DA	142	heap = drm_alloc(sizeof(*heap), DRM_MEM_BUFS);
1da177e4	143	if (!*heap) {
b5e89ed5	144	drm_free(blocks, sizeof(*blocks), DRM_MEM_BUFS);
1da177e4 LT	145	return DRM_ERR(ENOMEM);
	146	}
	147
	148	blocks->start = start;
	149	blocks->size = size;
	150	blocks->filp = NULL;
	151	blocks->next = blocks->prev = *heap;
	152
b5e89ed5 DA	153	memset(heap, 0, sizeof(*heap));
b5e89ed5 DA	154	(*heap)->filp = (DRMFILE) - 1;
1da177e4 LT	155	(heap)->next = (heap)->prev = blocks;
	156	return 0;
	157	}
	158
1da177e4 LT	159	/* Free all blocks associated with the releasing file.
1da177e4 LT	160	*/
b5e89ed5	161	void radeon_mem_release(DRMFILE filp, struct mem_block *heap)
1da177e4 LT	162	{
	163	struct mem_block *p;
	164
	165	if (!heap \|\| !heap->next)
	166	return;
	167
	168	list_for_each(p, heap) {
b5e89ed5	169	if (p->filp == filp)
1da177e4 LT	170	p->filp = NULL;
	171	}
	172
	173	/* Assumes a single contiguous range. Needs a special filp in
	174	* 'heap' to stop it being subsumed.
	175	*/
	176	list_for_each(p, heap) {
	177	while (p->filp == 0 && p->next->filp == 0) {
	178	struct mem_block *q = p->next;
	179	p->size += q->size;
	180	p->next = q->next;
	181	p->next->prev = p;
b5e89ed5	182	drm_free(q, sizeof(*q), DRM_MEM_DRIVER);
1da177e4 LT	183	}
	184	}
	185	}
	186
	187	/* Shutdown.
	188	*/
b5e89ed5	189	void radeon_mem_takedown(struct mem_block **heap)
1da177e4 LT	190	{
1da177e4 LT	191	struct mem_block *p;
b5e89ed5	192
1da177e4 LT	193	if (!*heap)
	194	return;
	195
b5e89ed5	196	for (p = (heap)->next; p != heap;) {
1da177e4 LT	197	struct mem_block *q = p;
1da177e4 LT	198	p = p->next;
b5e89ed5	199	drm_free(q, sizeof(*q), DRM_MEM_DRIVER);
1da177e4 LT	200	}
1da177e4 LT	201
b5e89ed5	202	drm_free(heap, sizeof(*heap), DRM_MEM_DRIVER);
1da177e4 LT	203	*heap = NULL;
	204	}
	205
1da177e4 LT	206	/* IOCTL HANDLERS */
1da177e4 LT	207
b5e89ed5	208	static struct mem_block *get_heap(drm_radeon_private_t dev_priv, int region)
1da177e4	209	{
b5e89ed5	210	switch (region) {
1da177e4	211	case RADEON_MEM_REGION_GART:
b5e89ed5	212	return &dev_priv->gart_heap;
1da177e4 LT	213	case RADEON_MEM_REGION_FB:
	214	return &dev_priv->fb_heap;
	215	default:
	216	return NULL;
	217	}
	218	}
	219
b5e89ed5	220	int radeon_mem_alloc(DRM_IOCTL_ARGS)
1da177e4 LT	221	{
	222	DRM_DEVICE;
	223	drm_radeon_private_t *dev_priv = dev->dev_private;
	224	drm_radeon_mem_alloc_t alloc;
	225	struct mem_block block, *heap;
	226
b5e89ed5 DA	227	if (!dev_priv) {
b5e89ed5 DA	228	DRM_ERROR("%s called with no initialization\n", __FUNCTION__);
1da177e4 LT	229	return DRM_ERR(EINVAL);
	230	}
	231
b5e89ed5 DA	232	DRM_COPY_FROM_USER_IOCTL(alloc, (drm_radeon_mem_alloc_t __user *) data,
b5e89ed5 DA	233	sizeof(alloc));
1da177e4	234
b5e89ed5	235	heap = get_heap(dev_priv, alloc.region);
1da177e4 LT	236	if (!heap \|\| !*heap)
1da177e4 LT	237	return DRM_ERR(EFAULT);
b5e89ed5	238
1da177e4 LT	239	/* Make things easier on ourselves: all allocations at least
	240	* 4k aligned.
	241	*/
	242	if (alloc.alignment < 12)
	243	alloc.alignment = 12;
	244
b5e89ed5	245	block = alloc_block(*heap, alloc.size, alloc.alignment, filp);
1da177e4	246
b5e89ed5	247	if (!block)
1da177e4 LT	248	return DRM_ERR(ENOMEM);
1da177e4 LT	249
b5e89ed5 DA	250	if (DRM_COPY_TO_USER(alloc.region_offset, &block->start, sizeof(int))) {
b5e89ed5 DA	251	DRM_ERROR("copy_to_user\n");
1da177e4 LT	252	return DRM_ERR(EFAULT);
1da177e4 LT	253	}
b5e89ed5	254
1da177e4 LT	255	return 0;
	256	}
	257
b5e89ed5	258	int radeon_mem_free(DRM_IOCTL_ARGS)
1da177e4 LT	259	{
	260	DRM_DEVICE;
	261	drm_radeon_private_t *dev_priv = dev->dev_private;
	262	drm_radeon_mem_free_t memfree;
	263	struct mem_block block, *heap;
	264
b5e89ed5 DA	265	if (!dev_priv) {
b5e89ed5 DA	266	DRM_ERROR("%s called with no initialization\n", __FUNCTION__);
1da177e4 LT	267	return DRM_ERR(EINVAL);
	268	}
	269
b5e89ed5 DA	270	DRM_COPY_FROM_USER_IOCTL(memfree, (drm_radeon_mem_free_t __user *) data,
b5e89ed5 DA	271	sizeof(memfree));
1da177e4	272
b5e89ed5	273	heap = get_heap(dev_priv, memfree.region);
1da177e4 LT	274	if (!heap \|\| !*heap)
1da177e4 LT	275	return DRM_ERR(EFAULT);
b5e89ed5 DA	276
b5e89ed5 DA	277	block = find_block(*heap, memfree.region_offset);
1da177e4 LT	278	if (!block)
	279	return DRM_ERR(EFAULT);
	280
	281	if (block->filp != filp)
	282	return DRM_ERR(EPERM);
	283
b5e89ed5	284	free_block(block);
1da177e4 LT	285	return 0;
	286	}
	287
b5e89ed5	288	int radeon_mem_init_heap(DRM_IOCTL_ARGS)
1da177e4 LT	289	{
	290	DRM_DEVICE;
	291	drm_radeon_private_t *dev_priv = dev->dev_private;
	292	drm_radeon_mem_init_heap_t initheap;
	293	struct mem_block **heap;
	294
b5e89ed5 DA	295	if (!dev_priv) {
b5e89ed5 DA	296	DRM_ERROR("%s called with no initialization\n", __FUNCTION__);
1da177e4 LT	297	return DRM_ERR(EINVAL);
	298	}
	299
b5e89ed5 DA	300	DRM_COPY_FROM_USER_IOCTL(initheap,
	301	(drm_radeon_mem_init_heap_t __user *) data,
	302	sizeof(initheap));
1da177e4	303
b5e89ed5 DA	304	heap = get_heap(dev_priv, initheap.region);
b5e89ed5 DA	305	if (!heap)
1da177e4	306	return DRM_ERR(EFAULT);
b5e89ed5	307
1da177e4 LT	308	if (*heap) {
	309	DRM_ERROR("heap already initialized?");
	310	return DRM_ERR(EFAULT);
	311	}
1da177e4	312
b5e89ed5 DA	313	return init_heap(heap, initheap.start, initheap.size);
b5e89ed5 DA	314	}