[linux-2.6-block.git] / drivers / gpu / drm / drm_memory.c

/*
 * \file drm_memory.c
 * Memory management wrappers for DRM
 *
 * \author Rickard E. (Rik) Faith <faith@valinux.com>
 * \author Gareth Hughes <gareth@valinux.com>
 */

/*
 * Created: Thu Feb  4 14:00:34 1999 by faith@valinux.com
 *
 * Copyright 1999 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/export.h>
#include <linux/highmem.h>
#include <linux/pci.h>
#include <linux/vmalloc.h>

#include <drm/drm_cache.h>
#include <drm/drm_device.h>

#include "drm_legacy.h"

#if IS_ENABLED(CONFIG_AGP)

#ifdef HAVE_PAGE_AGP
# include <asm/agp.h>
#else
# ifdef __powerpc__
#  define PAGE_AGP	pgprot_noncached_wc(PAGE_KERNEL)
# else
#  define PAGE_AGP	PAGE_KERNEL
# endif
#endif

static void *agp_remap(unsigned long offset, unsigned long size,
		       struct drm_device *dev)
{
	unsigned long i, num_pages =
	    PAGE_ALIGN(size) / PAGE_SIZE;
	struct drm_agp_mem *agpmem;
	struct page **page_map;
	struct page **phys_page_map;
	void *addr;

	size = PAGE_ALIGN(size);

#ifdef __alpha__
	offset -= dev->hose->mem_space->start;
#endif

	list_for_each_entry(agpmem, &dev->agp->memory, head)
		if (agpmem->bound <= offset
		    && (agpmem->bound + (agpmem->pages << PAGE_SHIFT)) >=
		    (offset + size))
			break;
	if (&agpmem->head == &dev->agp->memory)
		return NULL;

	/*
	 * OK, we're mapping AGP space on a chipset/platform on which memory accesses by
	 * the CPU do not get remapped by the GART.  We fix this by using the kernel's
	 * page-table instead (that's probably faster anyhow...).
	 */
	/* note: use vmalloc() because num_pages could be large... */
	page_map = vmalloc(array_size(num_pages, sizeof(struct page *)));
	if (!page_map)
		return NULL;

	phys_page_map = (agpmem->memory->pages + (offset - agpmem->bound) / PAGE_SIZE);
	for (i = 0; i < num_pages; ++i)
		page_map[i] = phys_page_map[i];
	addr = vmap(page_map, num_pages, VM_IOREMAP, PAGE_AGP);
	vfree(page_map);

	return addr;
}

#else /*  CONFIG_AGP  */
static inline void *agp_remap(unsigned long offset, unsigned long size,
			      struct drm_device *dev)
{
	return NULL;
}

#endif /* CONFIG_AGP */

void drm_legacy_ioremap(struct drm_local_map *map, struct drm_device *dev)
{
	if (dev->agp && dev->agp->cant_use_aperture && map->type == _DRM_AGP)
		map->handle = agp_remap(map->offset, map->size, dev);
	else
		map->handle = ioremap(map->offset, map->size);
}
EXPORT_SYMBOL(drm_legacy_ioremap);

void drm_legacy_ioremap_wc(struct drm_local_map *map, struct drm_device *dev)
{
	if (dev->agp && dev->agp->cant_use_aperture && map->type == _DRM_AGP)
		map->handle = agp_remap(map->offset, map->size, dev);
	else
		map->handle = ioremap_wc(map->offset, map->size);
}
EXPORT_SYMBOL(drm_legacy_ioremap_wc);

void drm_legacy_ioremapfree(struct drm_local_map *map, struct drm_device *dev)
{
	if (!map->handle || !map->size)
		return;

	if (dev->agp && dev->agp->cant_use_aperture && map->type == _DRM_AGP)
		vunmap(map->handle);
	else
		iounmap(map->handle);
}
EXPORT_SYMBOL(drm_legacy_ioremapfree);
Commit	Line	Data
45b2fda3	1	/*
b5e89ed5	2	* \file drm_memory.c
1da177e4 LT	3	* Memory management wrappers for DRM
	4	*
	5	* \author Rickard E. (Rik) Faith <faith@valinux.com>
	6	* \author Gareth Hughes <gareth@valinux.com>
	7	*/
	8
b5e89ed5	9	/*
1da177e4 LT	10	* Created: Thu Feb 4 14:00:34 1999 by faith@valinux.com
	11	*
	12	* Copyright 1999 Precision Insight, Inc., Cedar Park, Texas.
	13	* Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
	14	* All Rights Reserved.
	15	*
	16	* Permission is hereby granted, free of charge, to any person obtaining a
	17	* copy of this software and associated documentation files (the "Software"),
	18	* to deal in the Software without restriction, including without limitation
	19	* the rights to use, copy, modify, merge, publish, distribute, sublicense,
	20	* and/or sell copies of the Software, and to permit persons to whom the
	21	* Software is furnished to do so, subject to the following conditions:
	22	*
	23	* The above copyright notice and this permission notice (including the next
	24	* paragraph) shall be included in all copies or substantial portions of the
	25	* Software.
	26	*
	27	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	28	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	29	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
	30	* VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
	31	* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
	32	* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
	33	* OTHER DEALINGS IN THE SOFTWARE.
	34	*/
	35
2d1a8a48	36	#include <linux/export.h>
0500c04e SR	37	#include <linux/highmem.h>
	38	#include <linux/pci.h>
	39	#include <linux/vmalloc.h>
0500c04e	40
2c05593b	41	#include <drm/drm_cache.h>
0500c04e SR	42	#include <drm/drm_device.h>
0500c04e SR	43
cc5ea594	44	#include "drm_legacy.h"
1da177e4	45
a7fb8a23	46	#if IS_ENABLED(CONFIG_AGP)
d6db6564 DH	47
	48	#ifdef HAVE_PAGE_AGP
	49	# include <asm/agp.h>
	50	#else
	51	# ifdef __powerpc__
37035e74	52	# define PAGE_AGP pgprot_noncached_wc(PAGE_KERNEL)
d6db6564 DH	53	# else
	54	# define PAGE_AGP PAGE_KERNEL
	55	# endif
	56	#endif
	57
031de96a	58	static void *agp_remap(unsigned long offset, unsigned long size,
7bd01a08	59	struct drm_device *dev)
31f64bd1	60	{
07613ba2	61	unsigned long i, num_pages =
31f64bd1 DA	62	PAGE_ALIGN(size) / PAGE_SIZE;
	63	struct drm_agp_mem *agpmem;
	64	struct page **page_map;
07613ba2	65	struct page **phys_page_map;
31f64bd1 DA	66	void *addr;
	67
	68	size = PAGE_ALIGN(size);
	69
	70	#ifdef __alpha__
	71	offset -= dev->hose->mem_space->start;
	72	#endif
	73
bd1b331f	74	list_for_each_entry(agpmem, &dev->agp->memory, head)
31f64bd1 DA	75	if (agpmem->bound <= offset
	76	&& (agpmem->bound + (agpmem->pages << PAGE_SHIFT)) >=
	77	(offset + size))
	78	break;
404b017d	79	if (&agpmem->head == &dev->agp->memory)
31f64bd1 DA	80	return NULL;
	81
	82	/*
	83	* OK, we're mapping AGP space on a chipset/platform on which memory accesses by
	84	* the CPU do not get remapped by the GART. We fix this by using the kernel's
	85	* page-table instead (that's probably faster anyhow...).
	86	*/
	87	/* note: use vmalloc() because num_pages could be large... */
42bc47b3	88	page_map = vmalloc(array_size(num_pages, sizeof(struct page *)));
31f64bd1 DA	89	if (!page_map)
	90	return NULL;
	91
07613ba2	92	phys_page_map = (agpmem->memory->pages + (offset - agpmem->bound) / PAGE_SIZE);
31f64bd1	93	for (i = 0; i < num_pages; ++i)
07613ba2	94	page_map[i] = phys_page_map[i];
31f64bd1 DA	95	addr = vmap(page_map, num_pages, VM_IOREMAP, PAGE_AGP);
	96	vfree(page_map);
	97
	98	return addr;
	99	}
	100
a7fb8a23	101	#else /* CONFIG_AGP */
031de96a	102	static inline void *agp_remap(unsigned long offset, unsigned long size,
7bd01a08	103	struct drm_device *dev)
031de96a AB	104	{
	105	return NULL;
	106	}
	107
a7fb8a23	108	#endif /* CONFIG_AGP */
31f64bd1	109
86c1fbd5	110	void drm_legacy_ioremap(struct drm_local_map map, struct drm_device dev)
31f64bd1	111	{
d9906753	112	if (dev->agp && dev->agp->cant_use_aperture && map->type == _DRM_AGP)
004a7727 CH	113	map->handle = agp_remap(map->offset, map->size, dev);
	114	else
	115	map->handle = ioremap(map->offset, map->size);
31f64bd1	116	}
86c1fbd5	117	EXPORT_SYMBOL(drm_legacy_ioremap);
31f64bd1	118
86c1fbd5	119	void drm_legacy_ioremap_wc(struct drm_local_map map, struct drm_device dev)
242e3df8	120	{
d9906753	121	if (dev->agp && dev->agp->cant_use_aperture && map->type == _DRM_AGP)
9b8d5a12 DA	122	map->handle = agp_remap(map->offset, map->size, dev);
	123	else
	124	map->handle = ioremap_wc(map->offset, map->size);
242e3df8	125	}
86c1fbd5	126	EXPORT_SYMBOL(drm_legacy_ioremap_wc);
9b8d5a12	127
86c1fbd5	128	void drm_legacy_ioremapfree(struct drm_local_map map, struct drm_device dev)
31f64bd1	129	{
004a7727 CH	130	if (!map->handle \|\| !map->size)
	131	return;
	132
d9906753	133	if (dev->agp && dev->agp->cant_use_aperture && map->type == _DRM_AGP)
004a7727 CH	134	vunmap(map->handle);
	135	else
	136	iounmap(map->handle);
31f64bd1	137	}
86c1fbd5	138	EXPORT_SYMBOL(drm_legacy_ioremapfree);