Loading...
1/*
2 * Copyright (C) 2009-2010 PetaLogix
3 * Copyright (C) 2006 Benjamin Herrenschmidt, IBM Corporation
4 *
5 * Provide default implementations of the DMA mapping callbacks for
6 * directly mapped busses.
7 */
8
9#include <linux/device.h>
10#include <linux/dma-mapping.h>
11#include <linux/gfp.h>
12#include <linux/dma-debug.h>
13#include <linux/export.h>
14#include <asm/bug.h>
15
16/*
17 * Generic direct DMA implementation
18 *
19 * This implementation supports a per-device offset that can be applied if
20 * the address at which memory is visible to devices is not 0. Platform code
21 * can set archdata.dma_data to an unsigned long holding the offset. By
22 * default the offset is PCI_DRAM_OFFSET.
23 */
24
25static unsigned long get_dma_direct_offset(struct device *dev)
26{
27 if (likely(dev))
28 return (unsigned long)dev->archdata.dma_data;
29
30 return PCI_DRAM_OFFSET; /* FIXME Not sure if is correct */
31}
32
33#define NOT_COHERENT_CACHE
34
35static void *dma_direct_alloc_coherent(struct device *dev, size_t size,
36 dma_addr_t *dma_handle, gfp_t flag,
37 struct dma_attrs *attrs)
38{
39#ifdef NOT_COHERENT_CACHE
40 return consistent_alloc(flag, size, dma_handle);
41#else
42 void *ret;
43 struct page *page;
44 int node = dev_to_node(dev);
45
46 /* ignore region specifiers */
47 flag &= ~(__GFP_HIGHMEM);
48
49 page = alloc_pages_node(node, flag, get_order(size));
50 if (page == NULL)
51 return NULL;
52 ret = page_address(page);
53 memset(ret, 0, size);
54 *dma_handle = virt_to_phys(ret) + get_dma_direct_offset(dev);
55
56 return ret;
57#endif
58}
59
60static void dma_direct_free_coherent(struct device *dev, size_t size,
61 void *vaddr, dma_addr_t dma_handle,
62 struct dma_attrs *attrs)
63{
64#ifdef NOT_COHERENT_CACHE
65 consistent_free(size, vaddr);
66#else
67 free_pages((unsigned long)vaddr, get_order(size));
68#endif
69}
70
71static int dma_direct_map_sg(struct device *dev, struct scatterlist *sgl,
72 int nents, enum dma_data_direction direction,
73 struct dma_attrs *attrs)
74{
75 struct scatterlist *sg;
76 int i;
77
78 /* FIXME this part of code is untested */
79 for_each_sg(sgl, sg, nents, i) {
80 sg->dma_address = sg_phys(sg) + get_dma_direct_offset(dev);
81 __dma_sync(page_to_phys(sg_page(sg)) + sg->offset,
82 sg->length, direction);
83 }
84
85 return nents;
86}
87
88static void dma_direct_unmap_sg(struct device *dev, struct scatterlist *sg,
89 int nents, enum dma_data_direction direction,
90 struct dma_attrs *attrs)
91{
92}
93
94static int dma_direct_dma_supported(struct device *dev, u64 mask)
95{
96 return 1;
97}
98
99static inline dma_addr_t dma_direct_map_page(struct device *dev,
100 struct page *page,
101 unsigned long offset,
102 size_t size,
103 enum dma_data_direction direction,
104 struct dma_attrs *attrs)
105{
106 __dma_sync(page_to_phys(page) + offset, size, direction);
107 return page_to_phys(page) + offset + get_dma_direct_offset(dev);
108}
109
110static inline void dma_direct_unmap_page(struct device *dev,
111 dma_addr_t dma_address,
112 size_t size,
113 enum dma_data_direction direction,
114 struct dma_attrs *attrs)
115{
116/* There is not necessary to do cache cleanup
117 *
118 * phys_to_virt is here because in __dma_sync_page is __virt_to_phys and
119 * dma_address is physical address
120 */
121 __dma_sync(dma_address, size, direction);
122}
123
124static inline void
125dma_direct_sync_single_for_cpu(struct device *dev,
126 dma_addr_t dma_handle, size_t size,
127 enum dma_data_direction direction)
128{
129 /*
130 * It's pointless to flush the cache as the memory segment
131 * is given to the CPU
132 */
133
134 if (direction == DMA_FROM_DEVICE)
135 __dma_sync(dma_handle, size, direction);
136}
137
138static inline void
139dma_direct_sync_single_for_device(struct device *dev,
140 dma_addr_t dma_handle, size_t size,
141 enum dma_data_direction direction)
142{
143 /*
144 * It's pointless to invalidate the cache if the device isn't
145 * supposed to write to the relevant region
146 */
147
148 if (direction == DMA_TO_DEVICE)
149 __dma_sync(dma_handle, size, direction);
150}
151
152static inline void
153dma_direct_sync_sg_for_cpu(struct device *dev,
154 struct scatterlist *sgl, int nents,
155 enum dma_data_direction direction)
156{
157 struct scatterlist *sg;
158 int i;
159
160 /* FIXME this part of code is untested */
161 if (direction == DMA_FROM_DEVICE)
162 for_each_sg(sgl, sg, nents, i)
163 __dma_sync(sg->dma_address, sg->length, direction);
164}
165
166static inline void
167dma_direct_sync_sg_for_device(struct device *dev,
168 struct scatterlist *sgl, int nents,
169 enum dma_data_direction direction)
170{
171 struct scatterlist *sg;
172 int i;
173
174 /* FIXME this part of code is untested */
175 if (direction == DMA_TO_DEVICE)
176 for_each_sg(sgl, sg, nents, i)
177 __dma_sync(sg->dma_address, sg->length, direction);
178}
179
180struct dma_map_ops dma_direct_ops = {
181 .alloc = dma_direct_alloc_coherent,
182 .free = dma_direct_free_coherent,
183 .map_sg = dma_direct_map_sg,
184 .unmap_sg = dma_direct_unmap_sg,
185 .dma_supported = dma_direct_dma_supported,
186 .map_page = dma_direct_map_page,
187 .unmap_page = dma_direct_unmap_page,
188 .sync_single_for_cpu = dma_direct_sync_single_for_cpu,
189 .sync_single_for_device = dma_direct_sync_single_for_device,
190 .sync_sg_for_cpu = dma_direct_sync_sg_for_cpu,
191 .sync_sg_for_device = dma_direct_sync_sg_for_device,
192};
193EXPORT_SYMBOL(dma_direct_ops);
194
195/* Number of entries preallocated for DMA-API debugging */
196#define PREALLOC_DMA_DEBUG_ENTRIES (1 << 16)
197
198static int __init dma_init(void)
199{
200 dma_debug_init(PREALLOC_DMA_DEBUG_ENTRIES);
201
202 return 0;
203}
204fs_initcall(dma_init);