[linux-2.6-block.git] / arch / sh / mm / consistent.c

/*
 * arch/sh/mm/consistent.c
 *
 * Copyright (C) 2004  Paul Mundt
 *
 * This file is subject to the terms and conditions of the GNU General Public
 * License.  See the file "COPYING" in the main directory of this archive
 * for more details.
 */
#include <linux/mm.h>
#include <linux/dma-mapping.h>
#include <asm/cacheflush.h>
#include <asm/addrspace.h>
#include <asm/io.h>

void *consistent_alloc(gfp_t gfp, size_t size, dma_addr_t *handle)
{
	struct page *page, *end, *free;
	void *ret;
	int order;

	size = PAGE_ALIGN(size);
	order = get_order(size);

	page = alloc_pages(gfp, order);
	if (!page)
		return NULL;
	split_page(page, order);

	ret = page_address(page);
	memset(ret, 0, size);
	*handle = virt_to_phys(ret);

	/*
	 * We must flush the cache before we pass it on to the device
	 */
	dma_cache_wback_inv(ret, size);

	page = virt_to_page(ret);
	free = page + (size >> PAGE_SHIFT);
	end  = page + (1 << order);

	while (++page < end) {
		/* Free any unused pages */
		if (page >= free) {
			__free_page(page);
		}
	}

	return P2SEGADDR(ret);
}

void consistent_free(void *vaddr, size_t size)
{
	unsigned long addr = P1SEGADDR((unsigned long)vaddr);
	struct page *page=virt_to_page(addr);
	int num_pages=(size+PAGE_SIZE-1) >> PAGE_SHIFT;
	int i;

	for(i=0;i<num_pages;i++) {
		__free_page((page+i));
	}
}

void consistent_sync(void *vaddr, size_t size, int direction)
{
	void * p1addr = (void*) P1SEGADDR((unsigned long)vaddr);

	switch (direction) {
	case DMA_FROM_DEVICE:		/* invalidate only */
		dma_cache_inv(p1addr, size);
		break;
	case DMA_TO_DEVICE:		/* writeback only */
		dma_cache_wback(p1addr, size);
		break;
	case DMA_BIDIRECTIONAL:		/* writeback and invalidate */
		dma_cache_wback_inv(p1addr, size);
		break;
	default:
		BUG();
	}
}

EXPORT_SYMBOL(consistent_alloc);
EXPORT_SYMBOL(consistent_free);
EXPORT_SYMBOL(consistent_sync);
Commit	Line	Data
1da177e4 LT	1	/*
	2	* arch/sh/mm/consistent.c
	3	*
	4	* Copyright (C) 2004 Paul Mundt
	5	*
	6	* This file is subject to the terms and conditions of the GNU General Public
	7	* License. See the file "COPYING" in the main directory of this archive
	8	* for more details.
	9	*/
	10	#include <linux/mm.h>
	11	#include <linux/dma-mapping.h>
26ff6c11 PM	12	#include <asm/cacheflush.h>
26ff6c11 PM	13	#include <asm/addrspace.h>
1da177e4 LT	14	#include <asm/io.h>
1da177e4 LT	15
6dae2c23	16	void consistent_alloc(gfp_t gfp, size_t size, dma_addr_t handle)
1da177e4 LT	17	{
	18	struct page page, end, *free;
	19	void *ret;
	20	int order;
	21
	22	size = PAGE_ALIGN(size);
	23	order = get_order(size);
	24
	25	page = alloc_pages(gfp, order);
	26	if (!page)
	27	return NULL;
8dfcc9ba	28	split_page(page, order);
1da177e4 LT	29
1da177e4 LT	30	ret = page_address(page);
833abf7f	31	memset(ret, 0, size);
1da177e4 LT	32	*handle = virt_to_phys(ret);
	33
	34	/*
	35	* We must flush the cache before we pass it on to the device
	36	*/
	37	dma_cache_wback_inv(ret, size);
	38
	39	page = virt_to_page(ret);
	40	free = page + (size >> PAGE_SHIFT);
	41	end = page + (1 << order);
	42
	43	while (++page < end) {
1da177e4 LT	44	/* Free any unused pages */
	45	if (page >= free) {
	46	__free_page(page);
	47	}
	48	}
	49
	50	return P2SEGADDR(ret);
	51	}
	52
	53	void consistent_free(void *vaddr, size_t size)
	54	{
	55	unsigned long addr = P1SEGADDR((unsigned long)vaddr);
	56	struct page *page=virt_to_page(addr);
	57	int num_pages=(size+PAGE_SIZE-1) >> PAGE_SHIFT;
	58	int i;
	59
	60	for(i=0;i<num_pages;i++) {
	61	__free_page((page+i));
	62	}
	63	}
	64
	65	void consistent_sync(void *vaddr, size_t size, int direction)
	66	{
	67	void * p1addr = (void*) P1SEGADDR((unsigned long)vaddr);
	68
	69	switch (direction) {
	70	case DMA_FROM_DEVICE: /* invalidate only */
	71	dma_cache_inv(p1addr, size);
	72	break;
	73	case DMA_TO_DEVICE: /* writeback only */
	74	dma_cache_wback(p1addr, size);
	75	break;
	76	case DMA_BIDIRECTIONAL: /* writeback and invalidate */
	77	dma_cache_wback_inv(p1addr, size);
	78	break;
	79	default:
	80	BUG();
	81	}
	82	}
	83
	84	EXPORT_SYMBOL(consistent_alloc);
	85	EXPORT_SYMBOL(consistent_free);
	86	EXPORT_SYMBOL(consistent_sync);
	87