1
2
3
4
5
6
7
8
9
10
11
12
13#include <linux/types.h>
14#include <linux/mm.h>
15#include <linux/export.h>
16#include <linux/string.h>
17#include <linux/scatterlist.h>
18#include <linux/dma-mapping.h>
19#include <linux/io.h>
20#include <linux/cache.h>
21#include <asm/cacheflush.h>
22
23static inline void __dma_sync_for_device(void *vaddr, size_t size,
24 enum dma_data_direction direction)
25{
26 switch (direction) {
27 case DMA_FROM_DEVICE:
28 invalidate_dcache_range((unsigned long)vaddr,
29 (unsigned long)(vaddr + size));
30 break;
31 case DMA_TO_DEVICE:
32
33
34
35
36 case DMA_BIDIRECTIONAL:
37 flush_dcache_range((unsigned long)vaddr,
38 (unsigned long)(vaddr + size));
39 break;
40 default:
41 BUG();
42 }
43}
44
45static inline void __dma_sync_for_cpu(void *vaddr, size_t size,
46 enum dma_data_direction direction)
47{
48 switch (direction) {
49 case DMA_BIDIRECTIONAL:
50 case DMA_FROM_DEVICE:
51 invalidate_dcache_range((unsigned long)vaddr,
52 (unsigned long)(vaddr + size));
53 break;
54 case DMA_TO_DEVICE:
55 break;
56 default:
57 BUG();
58 }
59}
60
61static void *nios2_dma_alloc(struct device *dev, size_t size,
62 dma_addr_t *dma_handle, gfp_t gfp, unsigned long attrs)
63{
64 void *ret;
65
66
67 gfp &= ~(__GFP_DMA | __GFP_HIGHMEM);
68
69
70 gfp |= __GFP_ZERO;
71
72 if (dev == NULL || (dev->coherent_dma_mask < 0xffffffff))
73 gfp |= GFP_DMA;
74
75 ret = (void *) __get_free_pages(gfp, get_order(size));
76 if (ret != NULL) {
77 *dma_handle = virt_to_phys(ret);
78 flush_dcache_range((unsigned long) ret,
79 (unsigned long) ret + size);
80 ret = UNCAC_ADDR(ret);
81 }
82
83 return ret;
84}
85
86static void nios2_dma_free(struct device *dev, size_t size, void *vaddr,
87 dma_addr_t dma_handle, unsigned long attrs)
88{
89 unsigned long addr = (unsigned long) CAC_ADDR((unsigned long) vaddr);
90
91 free_pages(addr, get_order(size));
92}
93
94static int nios2_dma_map_sg(struct device *dev, struct scatterlist *sg,
95 int nents, enum dma_data_direction direction,
96 unsigned long attrs)
97{
98 int i;
99
100 for_each_sg(sg, sg, nents, i) {
101 void *addr = sg_virt(sg);
102
103 if (!addr)
104 continue;
105
106 sg->dma_address = sg_phys(sg);
107
108 if (attrs & DMA_ATTR_SKIP_CPU_SYNC)
109 continue;
110
111 __dma_sync_for_device(addr, sg->length, direction);
112 }
113
114 return nents;
115}
116
117static dma_addr_t nios2_dma_map_page(struct device *dev, struct page *page,
118 unsigned long offset, size_t size,
119 enum dma_data_direction direction,
120 unsigned long attrs)
121{
122 void *addr = page_address(page) + offset;
123
124 if (!(attrs & DMA_ATTR_SKIP_CPU_SYNC))
125 __dma_sync_for_device(addr, size, direction);
126
127 return page_to_phys(page) + offset;
128}
129
130static void nios2_dma_unmap_page(struct device *dev, dma_addr_t dma_address,
131 size_t size, enum dma_data_direction direction,
132 unsigned long attrs)
133{
134 if (!(attrs & DMA_ATTR_SKIP_CPU_SYNC))
135 __dma_sync_for_cpu(phys_to_virt(dma_address), size, direction);
136}
137
138static void nios2_dma_unmap_sg(struct device *dev, struct scatterlist *sg,
139 int nhwentries, enum dma_data_direction direction,
140 unsigned long attrs)
141{
142 void *addr;
143 int i;
144
145 if (direction == DMA_TO_DEVICE)
146 return;
147
148 if (attrs & DMA_ATTR_SKIP_CPU_SYNC)
149 return;
150
151 for_each_sg(sg, sg, nhwentries, i) {
152 addr = sg_virt(sg);
153 if (addr)
154 __dma_sync_for_cpu(addr, sg->length, direction);
155 }
156}
157
158static void nios2_dma_sync_single_for_cpu(struct device *dev,
159 dma_addr_t dma_handle, size_t size,
160 enum dma_data_direction direction)
161{
162 __dma_sync_for_cpu(phys_to_virt(dma_handle), size, direction);
163}
164
165static void nios2_dma_sync_single_for_device(struct device *dev,
166 dma_addr_t dma_handle, size_t size,
167 enum dma_data_direction direction)
168{
169 __dma_sync_for_device(phys_to_virt(dma_handle), size, direction);
170}
171
172static void nios2_dma_sync_sg_for_cpu(struct device *dev,
173 struct scatterlist *sg, int nelems,
174 enum dma_data_direction direction)
175{
176 int i;
177
178
179 for_each_sg(sg, sg, nelems, i)
180 __dma_sync_for_cpu(sg_virt(sg), sg->length, direction);
181}
182
183static void nios2_dma_sync_sg_for_device(struct device *dev,
184 struct scatterlist *sg, int nelems,
185 enum dma_data_direction direction)
186{
187 int i;
188
189
190 for_each_sg(sg, sg, nelems, i)
191 __dma_sync_for_device(sg_virt(sg), sg->length, direction);
192
193}
194
195const struct dma_map_ops nios2_dma_ops = {
196 .alloc = nios2_dma_alloc,
197 .free = nios2_dma_free,
198 .map_page = nios2_dma_map_page,
199 .unmap_page = nios2_dma_unmap_page,
200 .map_sg = nios2_dma_map_sg,
201 .unmap_sg = nios2_dma_unmap_sg,
202 .sync_single_for_device = nios2_dma_sync_single_for_device,
203 .sync_single_for_cpu = nios2_dma_sync_single_for_cpu,
204 .sync_sg_for_cpu = nios2_dma_sync_sg_for_cpu,
205 .sync_sg_for_device = nios2_dma_sync_sg_for_device,
206};
207EXPORT_SYMBOL(nios2_dma_ops);
208
