[deliverable/linux.git] / drivers / gpu / drm / via / via_mm.c

/*
 * Copyright 2006 Tungsten Graphics Inc., Bismarck, ND., USA.
 * 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
 * THE AUTHORS OR COPYRIGHT HOLDERS AND/OR THEIR 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: Thomas Hellström <thomas-at-tungstengraphics-dot-com>
 */

#include "drmP.h"
#include "via_drm.h"
#include "via_drv.h"
#include "drm_sman.h"

#define VIA_MM_ALIGN_SHIFT 4
#define VIA_MM_ALIGN_MASK ((1 << VIA_MM_ALIGN_SHIFT) - 1)

int via_agp_init(struct drm_device *dev, void *data, struct drm_file *file_priv)
{
	drm_via_agp_t *agp = data;
	drm_via_private_t *dev_priv = (drm_via_private_t *) dev->dev_private;
	int ret;

	mutex_lock(&dev->struct_mutex);
	ret = drm_sman_set_range(&dev_priv->sman, VIA_MEM_AGP, 0,
				 agp->size >> VIA_MM_ALIGN_SHIFT);

	if (ret) {
		DRM_ERROR("AGP memory manager initialisation error\n");
		mutex_unlock(&dev->struct_mutex);
		return ret;
	}

	dev_priv->agp_initialized = 1;
	dev_priv->agp_offset = agp->offset;
	mutex_unlock(&dev->struct_mutex);

	DRM_DEBUG("offset = %u, size = %u\n", agp->offset, agp->size);
	return 0;
}

int via_fb_init(struct drm_device *dev, void *data, struct drm_file *file_priv)
{
	drm_via_fb_t *fb = data;
	drm_via_private_t *dev_priv = (drm_via_private_t *) dev->dev_private;
	int ret;

	mutex_lock(&dev->struct_mutex);
	ret = drm_sman_set_range(&dev_priv->sman, VIA_MEM_VIDEO, 0,
				 fb->size >> VIA_MM_ALIGN_SHIFT);

	if (ret) {
		DRM_ERROR("VRAM memory manager initialisation error\n");
		mutex_unlock(&dev->struct_mutex);
		return ret;
	}

	dev_priv->vram_initialized = 1;
	dev_priv->vram_offset = fb->offset;

	mutex_unlock(&dev->struct_mutex);
	DRM_DEBUG("offset = %u, size = %u\n", fb->offset, fb->size);

	return 0;

}

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

	via_release_futex(dev_priv, context);

	/* 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");
		drm_irq_uninstall(dev);
		via_cleanup_futex(dev_priv);
		via_do_cleanup_map(dev);
	}
	return 1;
}

void via_lastclose(struct drm_device *dev)
{
	drm_via_private_t *dev_priv = (drm_via_private_t *) dev->dev_private;

	if (!dev_priv)
		return;

	mutex_lock(&dev->struct_mutex);
	drm_sman_cleanup(&dev_priv->sman);
	dev_priv->vram_initialized = 0;
	dev_priv->agp_initialized = 0;
	mutex_unlock(&dev->struct_mutex);
}

int via_mem_alloc(struct drm_device *dev, void *data,
		  struct drm_file *file)
{
	drm_via_mem_t *mem = data;
	int retval = 0, user_key;
	struct drm_memblock_item *item;
	drm_via_private_t *dev_priv = (drm_via_private_t *) dev->dev_private;
	struct via_file_private *file_priv = file->driver_priv;
	unsigned long tmpSize;

	if (mem->type > VIA_MEM_AGP) {
		DRM_ERROR("Unknown memory type allocation\n");
		return -EINVAL;
	}
	mutex_lock(&dev->struct_mutex);
	if (0 == ((mem->type == VIA_MEM_VIDEO) ? dev_priv->vram_initialized :
		      dev_priv->agp_initialized)) {
		DRM_ERROR
		    ("Attempt to allocate from uninitialized memory manager.\n");
		mutex_unlock(&dev->struct_mutex);
		return -EINVAL;
	}

	tmpSize = (mem->size + VIA_MM_ALIGN_MASK) >> VIA_MM_ALIGN_SHIFT;
	item = drm_sman_alloc(&dev_priv->sman, mem->type, tmpSize, 0, 0);
	if (!item) {
		retval = -ENOMEM;
		goto fail_alloc;
	}

again:
	if (idr_pre_get(&dev_priv->object_idr, GFP_KERNEL) == 0) {
		retval = -ENOMEM;
		goto fail_idr;
	}

	retval = idr_get_new_above(&dev_priv->object_idr, item, 1, &user_key);
	if (retval == -EAGAIN)
		goto again;
	if (retval)
		goto fail_idr;

	list_add(&item->owner_list, &file_priv->obj_list);
	mutex_unlock(&dev->struct_mutex);

	mem->offset = ((mem->type == VIA_MEM_VIDEO) ?
		      dev_priv->vram_offset : dev_priv->agp_offset) +
	    (item->mm->
	     offset(item->mm, item->mm_info) << VIA_MM_ALIGN_SHIFT);
	mem->index = user_key;

	return 0;

fail_idr:
	drm_sman_free(item);
fail_alloc:
	mutex_unlock(&dev->struct_mutex);

	mem->offset = 0;
	mem->size = 0;
	mem->index = 0;
	DRM_DEBUG("Video memory allocation failed\n");

	return retval;
}

int via_mem_free(struct drm_device *dev, void *data, struct drm_file *file_priv)
{
	drm_via_private_t *dev_priv = dev->dev_private;
	drm_via_mem_t *mem = data;
	struct drm_memblock_item *obj;
	int ret;

	mutex_lock(&dev->struct_mutex);
	obj = idr_find(&dev_priv->object_idr, mem->index);
	if (obj == NULL) {
		mutex_unlock(&dev->struct_mutex);
		return -EINVAL;
	}

	idr_remove(&dev_priv->object_idr, mem->index);
	drm_sman_free(obj);
	mutex_unlock(&dev->struct_mutex);

	DRM_DEBUG("free = 0x%lx\n", mem->index);

	return ret;
}


void via_reclaim_buffers_locked(struct drm_device *dev,
				struct drm_file *file)
{
	struct via_file_private *file_priv = file->driver_priv;
	struct drm_memblock_item *entry, *next;

	mutex_lock(&dev->struct_mutex);
	if (list_empty(&file_priv->obj_list)) {
		mutex_unlock(&dev->struct_mutex);
		return;
	}

	if (dev->driver->dma_quiescent)
		dev->driver->dma_quiescent(dev);

	list_for_each_entry_safe(entry, next, &file_priv->obj_list,
				 owner_list) {
		drm_sman_free(entry);
	}
	mutex_unlock(&dev->struct_mutex);
	return;
}
Commit	Line	Data
22f579c6	1	/*
ce65a44d TH	2	* Copyright 2006 Tungsten Graphics Inc., Bismarck, ND., USA.
ce65a44d TH	3	* All rights reserved.
22f579c6 DA	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
ce65a44d TH	19	* THE AUTHORS OR COPYRIGHT HOLDERS AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
ce65a44d TH	20	* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
22f579c6 DA	21	* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
	22	* DEALINGS IN THE SOFTWARE.
	23	*/
ce65a44d	24	/*
96de0e25	25	* Authors: Thomas Hellström <thomas-at-tungstengraphics-dot-com>
ce65a44d TH	26	*/
ce65a44d TH	27
22f579c6 DA	28	#include "drmP.h"
	29	#include "via_drm.h"
	30	#include "via_drv.h"
ce65a44d	31	#include "drm_sman.h"
22f579c6	32
ce65a44d	33	#define VIA_MM_ALIGN_SHIFT 4
58c1e85a	34	#define VIA_MM_ALIGN_MASK ((1 << VIA_MM_ALIGN_SHIFT) - 1)
22f579c6	35
c153f45f	36	int via_agp_init(struct drm_device dev, void data, struct drm_file *file_priv)
22f579c6	37	{
c153f45f	38	drm_via_agp_t *agp = data;
ce65a44d TH	39	drm_via_private_t dev_priv = (drm_via_private_t ) dev->dev_private;
ce65a44d TH	40	int ret;
22f579c6	41
ce65a44d TH	42	mutex_lock(&dev->struct_mutex);
ce65a44d TH	43	ret = drm_sman_set_range(&dev_priv->sman, VIA_MEM_AGP, 0,
c153f45f	44	agp->size >> VIA_MM_ALIGN_SHIFT);
ce65a44d TH	45
	46	if (ret) {
	47	DRM_ERROR("AGP memory manager initialisation error\n");
	48	mutex_unlock(&dev->struct_mutex);
	49	return ret;
	50	}
22f579c6	51
d40c8533	52	dev_priv->agp_initialized = 1;
c153f45f	53	dev_priv->agp_offset = agp->offset;
ce65a44d	54	mutex_unlock(&dev->struct_mutex);
22f579c6	55
3e684eae	56	DRM_DEBUG("offset = %u, size = %u\n", agp->offset, agp->size);
22f579c6 DA	57	return 0;
	58	}
	59
c153f45f	60	int via_fb_init(struct drm_device dev, void data, struct drm_file *file_priv)
22f579c6	61	{
c153f45f	62	drm_via_fb_t *fb = data;
ce65a44d TH	63	drm_via_private_t dev_priv = (drm_via_private_t ) dev->dev_private;
ce65a44d TH	64	int ret;
22f579c6	65
ce65a44d TH	66	mutex_lock(&dev->struct_mutex);
ce65a44d TH	67	ret = drm_sman_set_range(&dev_priv->sman, VIA_MEM_VIDEO, 0,
c153f45f	68	fb->size >> VIA_MM_ALIGN_SHIFT);
22f579c6	69
ce65a44d TH	70	if (ret) {
	71	DRM_ERROR("VRAM memory manager initialisation error\n");
	72	mutex_unlock(&dev->struct_mutex);
	73	return ret;
	74	}
22f579c6	75
d40c8533	76	dev_priv->vram_initialized = 1;
c153f45f	77	dev_priv->vram_offset = fb->offset;
22f579c6	78
ce65a44d	79	mutex_unlock(&dev->struct_mutex);
3e684eae	80	DRM_DEBUG("offset = %u, size = %u\n", fb->offset, fb->size);
ce65a44d TH	81
ce65a44d TH	82	return 0;
22f579c6	83
22f579c6 DA	84	}
	85
	86	int via_final_context(struct drm_device *dev, int context)
b5e89ed5	87	{
22f579c6 DA	88	drm_via_private_t dev_priv = (drm_via_private_t ) dev->dev_private;
22f579c6 DA	89
b5e89ed5 DA	90	via_release_futex(dev_priv, context);
b5e89ed5 DA	91
22f579c6 DA	92	/* Linux specific until context tracking code gets ported to BSD */
	93	/* Last context, perform cleanup */
	94	if (dev->ctx_count == 1 && dev->dev_private) {
b5e89ed5	95	DRM_DEBUG("Last Context\n");
9bfbd5cb	96	drm_irq_uninstall(dev);
22f579c6 DA	97	via_cleanup_futex(dev_priv);
	98	via_do_cleanup_map(dev);
	99	}
22f579c6 DA	100	return 1;
	101	}
	102
ce65a44d TH	103	void via_lastclose(struct drm_device *dev)
	104	{
	105	drm_via_private_t dev_priv = (drm_via_private_t ) dev->dev_private;
	106
	107	if (!dev_priv)
	108	return;
	109
	110	mutex_lock(&dev->struct_mutex);
	111	drm_sman_cleanup(&dev_priv->sman);
a1d0fcf5 AM	112	dev_priv->vram_initialized = 0;
a1d0fcf5 AM	113	dev_priv->agp_initialized = 0;
ce65a44d	114	mutex_unlock(&dev->struct_mutex);
bc5f4523	115	}
ce65a44d	116
c153f45f	117	int via_mem_alloc(struct drm_device dev, void data,
c828e204	118	struct drm_file *file)
22f579c6	119	{
c153f45f	120	drm_via_mem_t *mem = data;
77ee8f38	121	int retval = 0, user_key;
9698b4db	122	struct drm_memblock_item *item;
ce65a44d	123	drm_via_private_t dev_priv = (drm_via_private_t ) dev->dev_private;
c828e204	124	struct via_file_private *file_priv = file->driver_priv;
ce65a44d	125	unsigned long tmpSize;
22f579c6	126
c153f45f	127	if (mem->type > VIA_MEM_AGP) {
ce65a44d	128	DRM_ERROR("Unknown memory type allocation\n");
20caafa6	129	return -EINVAL;
22f579c6	130	}
ce65a44d	131	mutex_lock(&dev->struct_mutex);
c153f45f	132	if (0 == ((mem->type == VIA_MEM_VIDEO) ? dev_priv->vram_initialized :
ce65a44d TH	133	dev_priv->agp_initialized)) {
	134	DRM_ERROR
	135	("Attempt to allocate from uninitialized memory manager.\n");
	136	mutex_unlock(&dev->struct_mutex);
20caafa6	137	return -EINVAL;
22f579c6 DA	138	}
22f579c6 DA	139
c153f45f	140	tmpSize = (mem->size + VIA_MM_ALIGN_MASK) >> VIA_MM_ALIGN_SHIFT;
c828e204	141	item = drm_sman_alloc(&dev_priv->sman, mem->type, tmpSize, 0, 0);
77ee8f38 DV	142	if (!item) {
	143	retval = -ENOMEM;
	144	goto fail_alloc;
	145	}
c828e204	146
77ee8f38 DV	147	again:
77ee8f38 DV	148	if (idr_pre_get(&dev_priv->object_idr, GFP_KERNEL) == 0) {
20caafa6	149	retval = -ENOMEM;
77ee8f38	150	goto fail_idr;
22f579c6	151	}
77ee8f38 DV	152
	153	retval = idr_get_new_above(&dev_priv->object_idr, item, 1, &user_key);
	154	if (retval == -EAGAIN)
	155	goto again;
	156	if (retval)
	157	goto fail_idr;
	158
	159	list_add(&item->owner_list, &file_priv->obj_list);
c828e204	160	mutex_unlock(&dev->struct_mutex);
22f579c6	161
77ee8f38 DV	162	mem->offset = ((mem->type == VIA_MEM_VIDEO) ?
	163	dev_priv->vram_offset : dev_priv->agp_offset) +
	164	(item->mm->
	165	offset(item->mm, item->mm_info) << VIA_MM_ALIGN_SHIFT);
	166	mem->index = user_key;
	167
	168	return 0;
	169
	170	fail_idr:
	171	drm_sman_free(item);
	172	fail_alloc:
	173	mutex_unlock(&dev->struct_mutex);
	174
	175	mem->offset = 0;
	176	mem->size = 0;
	177	mem->index = 0;
	178	DRM_DEBUG("Video memory allocation failed\n");
	179
22f579c6 DA	180	return retval;
	181	}
	182
c153f45f	183	int via_mem_free(struct drm_device dev, void data, struct drm_file *file_priv)
22f579c6	184	{
ce65a44d	185	drm_via_private_t *dev_priv = dev->dev_private;
c153f45f	186	drm_via_mem_t *mem = data;
77ee8f38	187	struct drm_memblock_item *obj;
ce65a44d	188	int ret;
22f579c6	189
ce65a44d	190	mutex_lock(&dev->struct_mutex);
77ee8f38 DV	191	obj = idr_find(&dev_priv->object_idr, mem->index);
	192	if (obj == NULL) {
	193	mutex_unlock(&dev->struct_mutex);
	194	return -EINVAL;
	195	}
	196
	197	idr_remove(&dev_priv->object_idr, mem->index);
	198	drm_sman_free(obj);
ce65a44d	199	mutex_unlock(&dev->struct_mutex);
77ee8f38	200
c153f45f	201	DRM_DEBUG("free = 0x%lx\n", mem->index);
22f579c6	202
ce65a44d	203	return ret;
22f579c6 DA	204	}
22f579c6 DA	205
22f579c6	206
58c1e85a	207	void via_reclaim_buffers_locked(struct drm_device *dev,
c828e204	208	struct drm_file *file)
22f579c6	209	{
c828e204 DV	210	struct via_file_private *file_priv = file->driver_priv;
c828e204 DV	211	struct drm_memblock_item entry, next;
22f579c6	212
ce65a44d	213	mutex_lock(&dev->struct_mutex);
c828e204	214	if (list_empty(&file_priv->obj_list)) {
ce65a44d TH	215	mutex_unlock(&dev->struct_mutex);
ce65a44d TH	216	return;
22f579c6 DA	217	}
22f579c6 DA	218
58c1e85a	219	if (dev->driver->dma_quiescent)
ce65a44d	220	dev->driver->dma_quiescent(dev);
22f579c6	221
c828e204 DV	222	list_for_each_entry_safe(entry, next, &file_priv->obj_list,
	223	owner_list) {
	224	drm_sman_free(entry);
	225	}
ce65a44d TH	226	mutex_unlock(&dev->struct_mutex);
ce65a44d TH	227	return;
22f579c6	228	}