1/*
2 * Dynamic DMA mapping support.
3 *
4 * On i386 there is no hardware dynamic DMA address translation,
5 * so consistent alloc/free are merely page allocation/freeing.
6 * The rest of the dynamic DMA mapping interface is implemented
7 * in asm/pci.h.
8 */
9
10#include <linux/types.h>
11#include <linux/mm.h>
12#include <linux/string.h>
13#include <linux/pci.h>
14#include <linux/module.h>
15#include <linux/pci.h>
16#include <asm/io.h>
17
18struct dma_coherent_mem {
19	void		*virt_base;
20	u32		device_base;
21	int		size;
22	int		flags;
23	unsigned long	*bitmap;
24};
25
26void *dma_alloc_coherent(struct device *dev, size_t size,
27			   dma_addr_t *dma_handle, gfp_t gfp)
28{
29	void *ret;
30	struct dma_coherent_mem *mem = dev ? dev->dma_mem : NULL;
31	int order = get_order(size);
32	/* ignore region specifiers */
33	gfp &= ~(__GFP_DMA | __GFP_HIGHMEM);
34
35	if (mem) {
36		int page = bitmap_find_free_region(mem->bitmap, mem->size,
37						     order);
38		if (page >= 0) {
39			*dma_handle = mem->device_base + (page << PAGE_SHIFT);
40			ret = mem->virt_base + (page << PAGE_SHIFT);
41			memset(ret, 0, size);
42			return ret;
43		}
44		if (mem->flags & DMA_MEMORY_EXCLUSIVE)
45			return NULL;
46	}
47
48	if (dev == NULL || (dev->coherent_dma_mask < 0xffffffff))
49		gfp |= GFP_DMA;
50
51	ret = (void *)__get_free_pages(gfp, order);
52
53	if (ret != NULL) {
54		memset(ret, 0, size);
55		*dma_handle = virt_to_phys(ret);
56	}
57	return ret;
58}
59EXPORT_SYMBOL(dma_alloc_coherent);
60
61void dma_free_coherent(struct device *dev, size_t size,
62			 void *vaddr, dma_addr_t dma_handle)
63{
64	struct dma_coherent_mem *mem = dev ? dev->dma_mem : NULL;
65	int order = get_order(size);
66
67	if (mem && vaddr >= mem->virt_base && vaddr < (mem->virt_base + (mem->size << PAGE_SHIFT))) {
68		int page = (vaddr - mem->virt_base) >> PAGE_SHIFT;
69
70		bitmap_release_region(mem->bitmap, page, order);
71	} else
72		free_pages((unsigned long)vaddr, order);
73}
74EXPORT_SYMBOL(dma_free_coherent);
75
76int dma_declare_coherent_memory(struct device *dev, dma_addr_t bus_addr,
77				dma_addr_t device_addr, size_t size, int flags)
78{
79	void __iomem *mem_base = NULL;
80	int pages = size >> PAGE_SHIFT;
81	int bitmap_size = BITS_TO_LONGS(pages) * sizeof(long);
82
83	if ((flags & (DMA_MEMORY_MAP | DMA_MEMORY_IO)) == 0)
84		goto out;
85	if (!size)
86		goto out;
87	if (dev->dma_mem)
88		goto out;
89
90
91	mem_base = ioremap(bus_addr, size);
92	if (!mem_base)
93		goto out;
94
95	dev->dma_mem = kzalloc(sizeof(struct dma_coherent_mem), GFP_KERNEL);
96	if (!dev->dma_mem)
97		goto out;
98	dev->dma_mem->bitmap = kzalloc(bitmap_size, GFP_KERNEL);
99	if (!dev->dma_mem->bitmap)
100		goto free1_out;
101
102	dev->dma_mem->virt_base = mem_base;
103	dev->dma_mem->device_base = device_addr;
104	dev->dma_mem->size = pages;
105	dev->dma_mem->flags = flags;
106
107	if (flags & DMA_MEMORY_MAP)
108		return DMA_MEMORY_MAP;
109
110	return DMA_MEMORY_IO;
111
112 free1_out:
113	kfree(dev->dma_mem);
114 out:
115	if (mem_base)
116		iounmap(mem_base);
117	return 0;
118}
119EXPORT_SYMBOL(dma_declare_coherent_memory);
120
121void dma_release_declared_memory(struct device *dev)
122{
123	struct dma_coherent_mem *mem = dev->dma_mem;
124
125	if(!mem)
126		return;
127	dev->dma_mem = NULL;
128	iounmap(mem->virt_base);
129	kfree(mem->bitmap);
130	kfree(mem);
131}
132EXPORT_SYMBOL(dma_release_declared_memory);
133
134void *dma_mark_declared_memory_occupied(struct device *dev,
135					dma_addr_t device_addr, size_t size)
136{
137	struct dma_coherent_mem *mem = dev->dma_mem;
138	int pages = (size + (device_addr & ~PAGE_MASK) + PAGE_SIZE - 1) >> PAGE_SHIFT;
139	int pos, err;
140
141	if (!mem)
142		return ERR_PTR(-EINVAL);
143
144	pos = (device_addr - mem->device_base) >> PAGE_SHIFT;
145	err = bitmap_allocate_region(mem->bitmap, pos, get_order(pages));
146	if (err != 0)
147		return ERR_PTR(err);
148	return mem->virt_base + (pos << PAGE_SHIFT);
149}
150EXPORT_SYMBOL(dma_mark_declared_memory_occupied);
151
152#ifdef CONFIG_PCI
153/* Many VIA bridges seem to corrupt data for DAC. Disable it here */
154
155int forbid_dac;
156EXPORT_SYMBOL(forbid_dac);
157
158static __devinit void via_no_dac(struct pci_dev *dev)
159{
160	if ((dev->class >> 8) == PCI_CLASS_BRIDGE_PCI && forbid_dac == 0) {
161		printk(KERN_INFO "PCI: VIA PCI bridge detected. Disabling DAC.\n");
162		forbid_dac = 1;
163	}
164}
165DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_VIA, PCI_ANY_ID, via_no_dac);
166
167static int check_iommu(char *s)
168{
169	if (!strcmp(s, "usedac")) {
170		forbid_dac = -1;
171		return 1;
172	}
173	return 0;
174}
175__setup("iommu=", check_iommu);
176#endif
177