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

/*
 * Copyright 1998-2003 VIA Technologies, Inc. All Rights Reserved.
 * Copyright 2001-2003 S3 Graphics, Inc. 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, sub license,
 * 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 NON-INFRINGEMENT. IN NO EVENT SHALL
 * VIA, S3 GRAPHICS, 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 "drmP.h"
#include "via_drm.h"
#include "via_drv.h"
#include "via_ds.h"
#include "via_mm.h"

#define MAX_CONTEXT 100

typedef struct {
	int used;
	int context;
	set_t *sets[2];		/* 0 for frame buffer, 1 for AGP , 2 for System */
} via_context_t;

static via_context_t global_ppriv[MAX_CONTEXT];

static int via_agp_alloc(drm_via_mem_t * mem);
static int via_agp_free(drm_via_mem_t * mem);
static int via_fb_alloc(drm_via_mem_t * mem);
static int via_fb_free(drm_via_mem_t * mem);

static int add_alloc_set(int context, int type, unsigned int val)
{
	int i, retval = 0;

	for (i = 0; i < MAX_CONTEXT; i++) {
		if (global_ppriv[i].used && global_ppriv[i].context == context) {
			retval = via_setAdd(global_ppriv[i].sets[type], val);
			break;
		}
	}

	return retval;
}

static int del_alloc_set(int context, int type, unsigned int val)
{
	int i, retval = 0;

	for (i = 0; i < MAX_CONTEXT; i++)
		if (global_ppriv[i].used && global_ppriv[i].context == context) {
			retval = via_setDel(global_ppriv[i].sets[type], val);
			break;
		}

	return retval;
}

/* agp memory management */
static memHeap_t *AgpHeap = NULL;

int via_agp_init(DRM_IOCTL_ARGS)
{
	drm_via_agp_t agp;

	DRM_COPY_FROM_USER_IOCTL(agp, (drm_via_agp_t __user *) data,
				 sizeof(agp));

	AgpHeap = via_mmInit(agp.offset, agp.size);

	DRM_DEBUG("offset = %lu, size = %lu", (unsigned long)agp.offset, (unsigned long)agp.size);

	return 0;
}

/* fb memory management */
static memHeap_t *FBHeap = NULL;

int via_fb_init(DRM_IOCTL_ARGS)
{
	drm_via_fb_t fb;

	DRM_COPY_FROM_USER_IOCTL(fb, (drm_via_fb_t __user *) data, sizeof(fb));

	FBHeap = via_mmInit(fb.offset, fb.size);

	DRM_DEBUG("offset = %lu, size = %lu", (unsigned long)fb.offset, (unsigned long)fb.size);

	return 0;
}

int via_init_context(struct drm_device *dev, int context)
{
	int i;

	for (i = 0; i < MAX_CONTEXT; i++)
		if (global_ppriv[i].used &&
		    (global_ppriv[i].context == context))
			break;

	if (i >= MAX_CONTEXT) {
		for (i = 0; i < MAX_CONTEXT; i++) {
			if (!global_ppriv[i].used) {
				global_ppriv[i].context = context;
				global_ppriv[i].used = 1;
				global_ppriv[i].sets[0] = via_setInit();
				global_ppriv[i].sets[1] = via_setInit();
				DRM_DEBUG("init allocation set, socket=%d,"
					  " context = %d\n", i, context);
				break;
			}
		}

		if ((i >= MAX_CONTEXT) || (global_ppriv[i].sets[0] == NULL) ||
		    (global_ppriv[i].sets[1] == NULL)) {
			return 0;
		}
	}

	return 1;
}

int via_final_context(struct drm_device *dev, int context)
{	
        int i;
	drm_via_private_t *dev_priv = (drm_via_private_t *) dev->dev_private;

	for (i = 0; i < MAX_CONTEXT; i++)
		if (global_ppriv[i].used &&
		    (global_ppriv[i].context == context))
			break;

	if (i < MAX_CONTEXT) {
		set_t *set;
		ITEM_TYPE item;
		int retval;

		DRM_DEBUG("find socket %d, context = %d\n", i, context);

		/* Video Memory */
		set = global_ppriv[i].sets[0];
		retval = via_setFirst(set, &item);
		while (retval) {
			DRM_DEBUG("free video memory 0x%lx\n", item);
			via_mmFreeMem((PMemBlock) item);
			retval = via_setNext(set, &item);
		}
		via_setDestroy(set);

		/* AGP Memory */
		set = global_ppriv[i].sets[1];
		retval = via_setFirst(set, &item);
		while (retval) {
			DRM_DEBUG("free agp memory 0x%lx\n", item);
			via_mmFreeMem((PMemBlock) item);
			retval = via_setNext(set, &item);
		}
		via_setDestroy(set);
		global_ppriv[i].used = 0;
	}
	via_release_futex(dev_priv, context); 
	
			
#if defined(__linux__)
	/* Linux specific until context tracking code gets ported to BSD */
	/* Last context, perform cleanup */
	if (dev->ctx_count == 1 && dev->dev_private) {
	        DRM_DEBUG("Last Context\n");
		if (dev->irq)
			drm_irq_uninstall(dev);

		via_cleanup_futex(dev_priv);
		via_do_cleanup_map(dev);
	}
#endif

	return 1;
}

int via_mem_alloc(DRM_IOCTL_ARGS)
{
	drm_via_mem_t mem;

	DRM_COPY_FROM_USER_IOCTL(mem, (drm_via_mem_t __user *) data,
				 sizeof(mem));

	switch (mem.type) {
	case VIDEO:
		if (via_fb_alloc(&mem) < 0)
			return -EFAULT;
		DRM_COPY_TO_USER_IOCTL((drm_via_mem_t __user *) data, mem,
				       sizeof(mem));
		return 0;
	case AGP:
		if (via_agp_alloc(&mem) < 0)
			return -EFAULT;
		DRM_COPY_TO_USER_IOCTL((drm_via_mem_t __user *) data, mem,
				       sizeof(mem));
		return 0;
	}

	return -EFAULT;
}

static int via_fb_alloc(drm_via_mem_t * mem)
{
	drm_via_mm_t fb;
	PMemBlock block;
	int retval = 0;

	if (!FBHeap)
		return -1;

	fb.size = mem->size;
	fb.context = mem->context;

	block = via_mmAllocMem(FBHeap, fb.size, 5, 0);
	if (block) {
		fb.offset = block->ofs;
		fb.free = (unsigned long)block;
		if (!add_alloc_set(fb.context, VIDEO, fb.free)) {
			DRM_DEBUG("adding to allocation set fails\n");
			via_mmFreeMem((PMemBlock) fb.free);
			retval = -1;
		}
	} else {
		fb.offset = 0;
		fb.size = 0;
		fb.free = 0;
		retval = -1;
	}

	mem->offset = fb.offset;
	mem->index = fb.free;

	DRM_DEBUG("alloc fb, size = %d, offset = %d\n", fb.size,
		  (int)fb.offset);

	return retval;
}

static int via_agp_alloc(drm_via_mem_t * mem)
{
	drm_via_mm_t agp;
	PMemBlock block;
	int retval = 0;

	if (!AgpHeap)
		return -1;

	agp.size = mem->size;
	agp.context = mem->context;

	block = via_mmAllocMem(AgpHeap, agp.size, 5, 0);
	if (block) {
		agp.offset = block->ofs;
		agp.free = (unsigned long)block;
		if (!add_alloc_set(agp.context, AGP, agp.free)) {
			DRM_DEBUG("adding to allocation set fails\n");
			via_mmFreeMem((PMemBlock) agp.free);
			retval = -1;
		}
	} else {
		agp.offset = 0;
		agp.size = 0;
		agp.free = 0;
	}

	mem->offset = agp.offset;
	mem->index = agp.free;

	DRM_DEBUG("alloc agp, size = %d, offset = %d\n", agp.size,
		  (unsigned int)agp.offset);
	return retval;
}

int via_mem_free(DRM_IOCTL_ARGS)
{
	drm_via_mem_t mem;

	DRM_COPY_FROM_USER_IOCTL(mem, (drm_via_mem_t __user *) data,
				 sizeof(mem));

	switch (mem.type) {

	case VIDEO:
		if (via_fb_free(&mem) == 0)
			return 0;
		break;
	case AGP:
		if (via_agp_free(&mem) == 0)
			return 0;
		break;
	}

	return -EFAULT;
}

static int via_fb_free(drm_via_mem_t * mem)
{
	drm_via_mm_t fb;
	int retval = 0;

	if (!FBHeap) {
		return -1;
	}

	fb.free = mem->index;
	fb.context = mem->context;

	if (!fb.free) {
		return -1;

	}

	via_mmFreeMem((PMemBlock) fb.free);

	if (!del_alloc_set(fb.context, VIDEO, fb.free)) {
		retval = -1;
	}

	DRM_DEBUG("free fb, free = %ld\n", fb.free);

	return retval;
}

static int via_agp_free(drm_via_mem_t * mem)
{
	drm_via_mm_t agp;

	int retval = 0;

	agp.free = mem->index;
	agp.context = mem->context;

	if (!agp.free)
		return -1;

	via_mmFreeMem((PMemBlock) agp.free);

	if (!del_alloc_set(agp.context, AGP, agp.free)) {
		retval = -1;
	}

	DRM_DEBUG("free agp, free = %ld\n", agp.free);

	return retval;
}
Commit	Line	Data
22f579c6 DA	1	/*
	2	* Copyright 1998-2003 VIA Technologies, Inc. All Rights Reserved.
	3	* Copyright 2001-2003 S3 Graphics, Inc. All Rights Reserved.
	4	*
	5	* Permission is hereby granted, free of charge, to any person obtaining a
	6	* copy of this software and associated documentation files (the "Software"),
	7	* to deal in the Software without restriction, including without limitation
	8	* the rights to use, copy, modify, merge, publish, distribute, sub license,
	9	* and/or sell copies of the Software, and to permit persons to whom the
	10	* Software is furnished to do so, subject to the following conditions:
	11	*
	12	* The above copyright notice and this permission notice (including the
	13	* next paragraph) shall be included in all copies or substantial portions
	14	* of the Software.
	15	*
	16	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	17	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	18	* FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
	19	* VIA, S3 GRAPHICS, AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
	20	* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
	21	* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
	22	* DEALINGS IN THE SOFTWARE.
	23	*/
	24	#include "drmP.h"
	25	#include "via_drm.h"
	26	#include "via_drv.h"
	27	#include "via_ds.h"
	28	#include "via_mm.h"
	29
	30	#define MAX_CONTEXT 100
	31
	32	typedef struct {
	33	int used;
	34	int context;
	35	set_t sets[2]; / 0 for frame buffer, 1 for AGP , 2 for System */
	36	} via_context_t;
	37
	38	static via_context_t global_ppriv[MAX_CONTEXT];
	39
	40	static int via_agp_alloc(drm_via_mem_t * mem);
	41	static int via_agp_free(drm_via_mem_t * mem);
	42	static int via_fb_alloc(drm_via_mem_t * mem);
	43	static int via_fb_free(drm_via_mem_t * mem);
	44
	45	static int add_alloc_set(int context, int type, unsigned int val)
	46	{
	47	int i, retval = 0;
	48
	49	for (i = 0; i < MAX_CONTEXT; i++) {
	50	if (global_ppriv[i].used && global_ppriv[i].context == context) {
	51	retval = via_setAdd(global_ppriv[i].sets[type], val);
	52	break;
	53	}
	54	}
	55
	56	return retval;
	57	}
	58
	59	static int del_alloc_set(int context, int type, unsigned int val)
	60	{
	61	int i, retval = 0;
	62
	63	for (i = 0; i < MAX_CONTEXT; i++)
	64	if (global_ppriv[i].used && global_ppriv[i].context == context) {
65	retval = via_setDel(global_ppriv[i].sets[type], val);
66	break;
67	}
68
69	return retval;
70	}
71
72	/* agp memory management */
73	static memHeap_t *AgpHeap = NULL;
74
75	int via_agp_init(DRM_IOCTL_ARGS)
76	{
77	drm_via_agp_t agp;
78
bbaf3641 AD	79	DRM_COPY_FROM_USER_IOCTL(agp, (drm_via_agp_t __user *) data,
bbaf3641 AD	80	sizeof(agp));
22f579c6 DA	81
	82	AgpHeap = via_mmInit(agp.offset, agp.size);
	83
	84	DRM_DEBUG("offset = %lu, size = %lu", (unsigned long)agp.offset, (unsigned long)agp.size);
	85
	86	return 0;
	87	}
	88
	89	/* fb memory management */
	90	static memHeap_t *FBHeap = NULL;
	91
	92	int via_fb_init(DRM_IOCTL_ARGS)
	93	{
	94	drm_via_fb_t fb;
	95
bbaf3641	96	DRM_COPY_FROM_USER_IOCTL(fb, (drm_via_fb_t __user *) data, sizeof(fb));
22f579c6 DA	97
	98	FBHeap = via_mmInit(fb.offset, fb.size);
	99
	100	DRM_DEBUG("offset = %lu, size = %lu", (unsigned long)fb.offset, (unsigned long)fb.size);
	101
	102	return 0;
	103	}
	104
	105	int via_init_context(struct drm_device *dev, int context)
	106	{
	107	int i;
	108
	109	for (i = 0; i < MAX_CONTEXT; i++)
	110	if (global_ppriv[i].used &&
	111	(global_ppriv[i].context == context))
	112	break;
	113
	114	if (i >= MAX_CONTEXT) {
	115	for (i = 0; i < MAX_CONTEXT; i++) {
	116	if (!global_ppriv[i].used) {
	117	global_ppriv[i].context = context;
	118	global_ppriv[i].used = 1;
	119	global_ppriv[i].sets[0] = via_setInit();
	120	global_ppriv[i].sets[1] = via_setInit();
	121	DRM_DEBUG("init allocation set, socket=%d,"
	122	" context = %d\n", i, context);
	123	break;
	124	}
	125	}
	126
	127	if ((i >= MAX_CONTEXT) \|\| (global_ppriv[i].sets[0] == NULL) \|\|
	128	(global_ppriv[i].sets[1] == NULL)) {
	129	return 0;
	130	}
	131	}
	132
	133	return 1;
	134	}
	135
	136	int via_final_context(struct drm_device *dev, int context)
	137	{
	138	int i;
	139	drm_via_private_t dev_priv = (drm_via_private_t ) dev->dev_private;
	140
	141	for (i = 0; i < MAX_CONTEXT; i++)
	142	if (global_ppriv[i].used &&
	143	(global_ppriv[i].context == context))
	144	break;
	145
	146	if (i < MAX_CONTEXT) {
	147	set_t *set;
	148	ITEM_TYPE item;
	149	int retval;
	150
	151	DRM_DEBUG("find socket %d, context = %d\n", i, context);
	152
	153	/* Video Memory */
	154	set = global_ppriv[i].sets[0];
	155	retval = via_setFirst(set, &item);
	156	while (retval) {
	157	DRM_DEBUG("free video memory 0x%lx\n", item);
	158	via_mmFreeMem((PMemBlock) item);
	159	retval = via_setNext(set, &item);
	160	}
161	via_setDestroy(set);
162
163	/* AGP Memory */
164	set = global_ppriv[i].sets[1];
165	retval = via_setFirst(set, &item);
166	while (retval) {
167	DRM_DEBUG("free agp memory 0x%lx\n", item);
168	via_mmFreeMem((PMemBlock) item);
169	retval = via_setNext(set, &item);
170	}
171	via_setDestroy(set);
172	global_ppriv[i].used = 0;
173	}
174	via_release_futex(dev_priv, context);
175
176
177	#if defined(__linux__)
178	/* Linux specific until context tracking code gets ported to BSD */
179	/* Last context, perform cleanup */
180	if (dev->ctx_count == 1 && dev->dev_private) {
181	DRM_DEBUG("Last Context\n");
182	if (dev->irq)
183	drm_irq_uninstall(dev);
184
185	via_cleanup_futex(dev_priv);
186	via_do_cleanup_map(dev);
187	}
188	#endif
189
190	return 1;
191	}
192
193	int via_mem_alloc(DRM_IOCTL_ARGS)
194	{
195	drm_via_mem_t mem;
196
bbaf3641 AD	197	DRM_COPY_FROM_USER_IOCTL(mem, (drm_via_mem_t __user *) data,
bbaf3641 AD	198	sizeof(mem));
22f579c6 DA	199
	200	switch (mem.type) {
	201	case VIDEO:
	202	if (via_fb_alloc(&mem) < 0)
	203	return -EFAULT;
bbaf3641	204	DRM_COPY_TO_USER_IOCTL((drm_via_mem_t __user *) data, mem,
22f579c6 DA	205	sizeof(mem));
	206	return 0;
	207	case AGP:
	208	if (via_agp_alloc(&mem) < 0)
	209	return -EFAULT;
bbaf3641	210	DRM_COPY_TO_USER_IOCTL((drm_via_mem_t __user *) data, mem,
22f579c6 DA	211	sizeof(mem));
	212	return 0;
	213	}
	214
	215	return -EFAULT;
	216	}
	217
	218	static int via_fb_alloc(drm_via_mem_t * mem)
	219	{
	220	drm_via_mm_t fb;
	221	PMemBlock block;
	222	int retval = 0;
	223
	224	if (!FBHeap)
	225	return -1;
	226
	227	fb.size = mem->size;
	228	fb.context = mem->context;
	229
	230	block = via_mmAllocMem(FBHeap, fb.size, 5, 0);
	231	if (block) {
	232	fb.offset = block->ofs;
	233	fb.free = (unsigned long)block;
	234	if (!add_alloc_set(fb.context, VIDEO, fb.free)) {
	235	DRM_DEBUG("adding to allocation set fails\n");
	236	via_mmFreeMem((PMemBlock) fb.free);
	237	retval = -1;
	238	}
	239	} else {
	240	fb.offset = 0;
	241	fb.size = 0;
	242	fb.free = 0;
	243	retval = -1;
	244	}
	245
	246	mem->offset = fb.offset;
	247	mem->index = fb.free;
	248
	249	DRM_DEBUG("alloc fb, size = %d, offset = %d\n", fb.size,
	250	(int)fb.offset);
	251
	252	return retval;
	253	}
	254
	255	static int via_agp_alloc(drm_via_mem_t * mem)
	256	{
	257	drm_via_mm_t agp;
	258	PMemBlock block;
	259	int retval = 0;
	260
	261	if (!AgpHeap)
	262	return -1;
	263
	264	agp.size = mem->size;
	265	agp.context = mem->context;
	266
	267	block = via_mmAllocMem(AgpHeap, agp.size, 5, 0);
	268	if (block) {
	269	agp.offset = block->ofs;
	270	agp.free = (unsigned long)block;
	271	if (!add_alloc_set(agp.context, AGP, agp.free)) {
	272	DRM_DEBUG("adding to allocation set fails\n");
	273	via_mmFreeMem((PMemBlock) agp.free);
	274	retval = -1;
275	}
276	} else {
277	agp.offset = 0;
278	agp.size = 0;
279	agp.free = 0;
280	}
281
282	mem->offset = agp.offset;
283	mem->index = agp.free;
284
285	DRM_DEBUG("alloc agp, size = %d, offset = %d\n", agp.size,
286	(unsigned int)agp.offset);
287	return retval;
288	}
289
290	int via_mem_free(DRM_IOCTL_ARGS)
291	{
292	drm_via_mem_t mem;
293
bbaf3641 AD	294	DRM_COPY_FROM_USER_IOCTL(mem, (drm_via_mem_t __user *) data,
bbaf3641 AD	295	sizeof(mem));
22f579c6 DA	296
	297	switch (mem.type) {
	298
	299	case VIDEO:
	300	if (via_fb_free(&mem) == 0)
	301	return 0;
	302	break;
	303	case AGP:
	304	if (via_agp_free(&mem) == 0)
	305	return 0;
	306	break;
	307	}
	308
	309	return -EFAULT;
	310	}
	311
	312	static int via_fb_free(drm_via_mem_t * mem)
	313	{
	314	drm_via_mm_t fb;
	315	int retval = 0;
	316
	317	if (!FBHeap) {
	318	return -1;
	319	}
	320
	321	fb.free = mem->index;
	322	fb.context = mem->context;
	323
	324	if (!fb.free) {
	325	return -1;
	326
	327	}
	328
	329	via_mmFreeMem((PMemBlock) fb.free);
	330
	331	if (!del_alloc_set(fb.context, VIDEO, fb.free)) {
	332	retval = -1;
	333	}
	334
	335	DRM_DEBUG("free fb, free = %ld\n", fb.free);
	336
	337	return retval;
	338	}
	339
	340	static int via_agp_free(drm_via_mem_t * mem)
	341	{
	342	drm_via_mm_t agp;
	343
	344	int retval = 0;
	345
	346	agp.free = mem->index;
	347	agp.context = mem->context;
	348
	349	if (!agp.free)
	350	return -1;
	351
	352	via_mmFreeMem((PMemBlock) agp.free);
	353
	354	if (!del_alloc_set(agp.context, AGP, agp.free)) {
	355	retval = -1;
	356	}
	357
	358	DRM_DEBUG("free agp, free = %ld\n", agp.free);
	359
360	return retval;
361	}