1/*
  2 *  Port on Texas Instruments TMS320C6x architecture
  3 *
  4 *  Copyright (C) 2004, 2009, 2010, 2011 Texas Instruments Incorporated
  5 *  Author: Aurelien Jacquiot <aurelien.jacquiot@ti.com>
  6 *
  7 *  This program is free software; you can redistribute it and/or modify
  8 *  it under the terms of the GNU General Public License version 2 as
  9 *  published by the Free Software Foundation.
 10 *
 11 *  DMA uncached mapping support.
 12 *
 13 *  Using code pulled from ARM
 14 *  Copyright (C) 2000-2004 Russell King
 15 *
 16 */
 17#include <linux/slab.h>
 18#include <linux/bitmap.h>
 19#include <linux/bitops.h>
 20#include <linux/module.h>
 21#include <linux/interrupt.h>
 22#include <linux/dma-mapping.h>
 23#include <linux/memblock.h>
 24
 25#include <asm/page.h>
 26
 27/*
 28 * DMA coherent memory management, can be redefined using the memdma=
 29 * kernel command line
 30 */
 31
 32/* none by default */
 33static phys_addr_t dma_base;
 34static u32 dma_size;
 35static u32 dma_pages;
 36
 37static unsigned long *dma_bitmap;
 38
 39/* bitmap lock */
 40static DEFINE_SPINLOCK(dma_lock);
 41
 42/*
 43 * Return a DMA coherent and contiguous memory chunk from the DMA memory
 44 */
 45static inline u32 __alloc_dma_pages(int order)
 46{
 47	unsigned long flags;
 48	u32 pos;
 49
 50	spin_lock_irqsave(&dma_lock, flags);
 51	pos = bitmap_find_free_region(dma_bitmap, dma_pages, order);
 52	spin_unlock_irqrestore(&dma_lock, flags);
 53
 54	return dma_base + (pos << PAGE_SHIFT);
 55}
 56
 57static void __free_dma_pages(u32 addr, int order)
 58{
 59	unsigned long flags;
 60	u32 pos = (addr - dma_base) >> PAGE_SHIFT;
 61
 62	if (addr < dma_base || (pos + (1 << order)) >= dma_pages) {
 63		printk(KERN_ERR "%s: freeing outside range.\n", __func__);
 64		BUG();
 65	}
 66
 67	spin_lock_irqsave(&dma_lock, flags);
 68	bitmap_release_region(dma_bitmap, pos, order);
 69	spin_unlock_irqrestore(&dma_lock, flags);
 70}
 71
 72/*
 73 * Allocate DMA coherent memory space and return both the kernel
 74 * virtual and DMA address for that space.
 75 */
 76void *c6x_dma_alloc(struct device *dev, size_t size, dma_addr_t *handle,
 77		gfp_t gfp, unsigned long attrs)
 78{
 79	u32 paddr;
 80	int order;
 81
 82	if (!dma_size || !size)
 83		return NULL;
 84
 85	order = get_count_order(((size - 1) >> PAGE_SHIFT) + 1);
 86
 87	paddr = __alloc_dma_pages(order);
 88
 89	if (handle)
 90		*handle = paddr;
 91
 92	if (!paddr)
 93		return NULL;
 94
 95	return phys_to_virt(paddr);
 96}
 97
 98/*
 99 * Free DMA coherent memory as defined by the above mapping.
100 */
101void c6x_dma_free(struct device *dev, size_t size, void *vaddr,
102		dma_addr_t dma_handle, unsigned long attrs)
103{
104	int order;
105
106	if (!dma_size || !size)
107		return;
108
109	order = get_count_order(((size - 1) >> PAGE_SHIFT) + 1);
110
111	__free_dma_pages(virt_to_phys(vaddr), order);
112}
113
114/*
115 * Initialise the coherent DMA memory allocator using the given uncached region.
116 */
117void __init coherent_mem_init(phys_addr_t start, u32 size)
118{
119	phys_addr_t bitmap_phys;
120
121	if (!size)
122		return;
123
124	printk(KERN_INFO
125	       "Coherent memory (DMA) region start=0x%x size=0x%x\n",
126	       start, size);
127
128	dma_base = start;
129	dma_size = size;
130
131	/* allocate bitmap */
132	dma_pages = dma_size >> PAGE_SHIFT;
133	if (dma_size & (PAGE_SIZE - 1))
134		++dma_pages;
135
136	bitmap_phys = memblock_alloc(BITS_TO_LONGS(dma_pages) * sizeof(long),
137				     sizeof(long));
138
139	dma_bitmap = phys_to_virt(bitmap_phys);
140	memset(dma_bitmap, 0, dma_pages * PAGE_SIZE);
141}