Root/target/linux/ubicom32/files/arch/ubicom32/include/asm/dma-mapping.h

1/*
2 * arch/ubicom32/include/asm/dma-mapping.h
3 * Generic dma-mapping.h for Ubicom32 architecture.
4 *
5 * (C) Copyright 2009, Ubicom, Inc.
6 *
7 * This file is part of the Ubicom32 Linux Kernel Port.
8 *
9 * The Ubicom32 Linux Kernel Port is free software: you can redistribute
10 * it and/or modify it under the terms of the GNU General Public License
11 * as published by the Free Software Foundation, either version 2 of the
12 * License, or (at your option) any later version.
13 *
14 * The Ubicom32 Linux Kernel Port is distributed in the hope that it
15 * will be useful, but WITHOUT ANY WARRANTY; without even the implied
16 * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
17 * the GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with the Ubicom32 Linux Kernel Port. If not,
21 * see <http://www.gnu.org/licenses/>.
22 *
23 * Ubicom32 implementation derived from (with many thanks):
24 * arch/m68knommu
25 * arch/blackfin
26 * arch/parisc
27 */
28#ifndef _ASM_UBICOM32_DMA_MAPPING_H
29#define _ASM_UBICOM32_DMA_MAPPING_H
30
31#include <linux/scatterlist.h>
32#ifdef CONFIG_PCI
33
34/* we implement the API below in terms of the existing PCI one,
35 * so include it */
36#include <linux/pci.h>
37/* need struct page definitions */
38#include <linux/mm.h>
39
40static inline int
41dma_supported(struct device *dev, u64 mask)
42{
43    BUG_ON(dev->bus != &pci_bus_type);
44
45    return pci_dma_supported(to_pci_dev(dev), mask);
46}
47
48static inline int
49dma_set_mask(struct device *dev, u64 dma_mask)
50{
51    BUG_ON(dev->bus != &pci_bus_type);
52
53    return pci_set_dma_mask(to_pci_dev(dev), dma_mask);
54}
55
56static inline void *
57dma_alloc_coherent(struct device *dev, size_t size, dma_addr_t *dma_handle,
58           gfp_t flag)
59{
60    BUG_ON(dev->bus != &pci_bus_type);
61
62    return pci_alloc_consistent(to_pci_dev(dev), size, dma_handle);
63}
64
65static inline void
66dma_free_coherent(struct device *dev, size_t size, void *cpu_addr,
67            dma_addr_t dma_handle)
68{
69    BUG_ON(dev->bus != &pci_bus_type);
70
71    pci_free_consistent(to_pci_dev(dev), size, cpu_addr, dma_handle);
72}
73
74static inline dma_addr_t
75dma_map_single(struct device *dev, void *cpu_addr, size_t size,
76           enum dma_data_direction direction)
77{
78    BUG_ON(dev->bus != &pci_bus_type);
79
80    return pci_map_single(to_pci_dev(dev), cpu_addr, size, (int)direction);
81}
82
83static inline void
84dma_unmap_single(struct device *dev, dma_addr_t dma_addr, size_t size,
85         enum dma_data_direction direction)
86{
87    BUG_ON(dev->bus != &pci_bus_type);
88
89    pci_unmap_single(to_pci_dev(dev), dma_addr, size, (int)direction);
90}
91
92static inline dma_addr_t
93dma_map_page(struct device *dev, struct page *page,
94         unsigned long offset, size_t size,
95         enum dma_data_direction direction)
96{
97    BUG_ON(dev->bus != &pci_bus_type);
98
99    return pci_map_page(to_pci_dev(dev), page, offset, size, (int)direction);
100}
101
102static inline void
103dma_unmap_page(struct device *dev, dma_addr_t dma_address, size_t size,
104           enum dma_data_direction direction)
105{
106    BUG_ON(dev->bus != &pci_bus_type);
107
108    pci_unmap_page(to_pci_dev(dev), dma_address, size, (int)direction);
109}
110
111static inline int
112dma_map_sg(struct device *dev, struct scatterlist *sg, int nents,
113       enum dma_data_direction direction)
114{
115    BUG_ON(dev->bus != &pci_bus_type);
116
117    return pci_map_sg(to_pci_dev(dev), sg, nents, (int)direction);
118}
119
120static inline void
121dma_unmap_sg(struct device *dev, struct scatterlist *sg, int nhwentries,
122         enum dma_data_direction direction)
123{
124    BUG_ON(dev->bus != &pci_bus_type);
125
126    pci_unmap_sg(to_pci_dev(dev), sg, nhwentries, (int)direction);
127}
128
129static inline void
130dma_sync_single_for_cpu(struct device *dev, dma_addr_t dma_handle, size_t size,
131            enum dma_data_direction direction)
132{
133    BUG_ON(dev->bus != &pci_bus_type);
134
135    pci_dma_sync_single_for_cpu(to_pci_dev(dev), dma_handle,
136                    size, (int)direction);
137}
138
139static inline void
140dma_sync_single_for_device(struct device *dev, dma_addr_t dma_handle, size_t size,
141               enum dma_data_direction direction)
142{
143    BUG_ON(dev->bus != &pci_bus_type);
144
145    pci_dma_sync_single_for_device(to_pci_dev(dev), dma_handle,
146                       size, (int)direction);
147}
148
149static inline void
150dma_sync_sg_for_cpu(struct device *dev, struct scatterlist *sg, int nelems,
151            enum dma_data_direction direction)
152{
153    BUG_ON(dev->bus != &pci_bus_type);
154
155    pci_dma_sync_sg_for_cpu(to_pci_dev(dev), sg, nelems, (int)direction);
156}
157
158static inline void
159dma_sync_sg_for_device(struct device *dev, struct scatterlist *sg, int nelems,
160               enum dma_data_direction direction)
161{
162    BUG_ON(dev->bus != &pci_bus_type);
163
164    pci_dma_sync_sg_for_device(to_pci_dev(dev), sg, nelems, (int)direction);
165}
166
167static inline int
168dma_mapping_error(struct device *dev, dma_addr_t dma_addr)
169{
170    return pci_dma_mapping_error(to_pci_dev(dev), dma_addr);
171}
172
173
174#else
175
176static inline int
177dma_supported(struct device *dev, u64 mask)
178{
179    return 0;
180}
181
182static inline int
183dma_set_mask(struct device *dev, u64 dma_mask)
184{
185    BUG();
186    return 0;
187}
188
189static inline void *
190dma_alloc_coherent(struct device *dev, size_t size, dma_addr_t *dma_handle,
191           gfp_t flag)
192{
193    BUG();
194    return NULL;
195}
196
197static inline void
198dma_free_coherent(struct device *dev, size_t size, void *cpu_addr,
199            dma_addr_t dma_handle)
200{
201    BUG();
202}
203
204static inline dma_addr_t
205dma_map_single(struct device *dev, void *cpu_addr, size_t size,
206           enum dma_data_direction direction)
207{
208    BUG();
209    return 0;
210}
211
212static inline void
213dma_unmap_single(struct device *dev, dma_addr_t dma_addr, size_t size,
214         enum dma_data_direction direction)
215{
216    BUG();
217}
218
219static inline dma_addr_t
220dma_map_page(struct device *dev, struct page *page,
221         unsigned long offset, size_t size,
222         enum dma_data_direction direction)
223{
224    BUG();
225    return 0;
226}
227
228static inline void
229dma_unmap_page(struct device *dev, dma_addr_t dma_address, size_t size,
230           enum dma_data_direction direction)
231{
232    BUG();
233}
234
235static inline int
236dma_map_sg(struct device *dev, struct scatterlist *sg, int nents,
237       enum dma_data_direction direction)
238{
239    BUG();
240    return 0;
241}
242
243static inline void
244dma_unmap_sg(struct device *dev, struct scatterlist *sg, int nhwentries,
245         enum dma_data_direction direction)
246{
247    BUG();
248}
249
250static inline void
251dma_sync_single_for_cpu(struct device *dev, dma_addr_t dma_handle, size_t size,
252            enum dma_data_direction direction)
253{
254    BUG();
255}
256
257static inline void
258dma_sync_single_for_device(struct device *dev, dma_addr_t dma_handle, size_t size,
259               enum dma_data_direction direction)
260{
261    BUG();
262}
263
264static inline void
265dma_sync_sg_for_cpu(struct device *dev, struct scatterlist *sg, int nelems,
266            enum dma_data_direction direction)
267{
268    BUG();
269}
270
271static inline void
272dma_sync_sg_for_device(struct device *dev, struct scatterlist *sg, int nelems,
273               enum dma_data_direction direction)
274{
275    BUG();
276}
277
278static inline int
279dma_mapping_error(struct device *dev, dma_addr_t dma_addr)
280{
281    return 0;
282}
283
284#endif
285
286/* Now for the API extensions over the pci_ one */
287
288#define dma_alloc_noncoherent(d, s, h, f) dma_alloc_coherent(d, s, h, f)
289#define dma_free_noncoherent(d, s, v, h) dma_free_coherent(d, s, v, h)
290#define dma_is_consistent(d, h) (1)
291
292static inline int
293dma_get_cache_alignment(void)
294{
295    /* no easy way to get cache size on all processors, so return
296     * the maximum possible, to be safe */
297    return (1 << INTERNODE_CACHE_SHIFT);
298}
299
300static inline void
301dma_sync_single_range_for_cpu(struct device *dev, dma_addr_t dma_handle,
302                  unsigned long offset, size_t size,
303                  enum dma_data_direction direction)
304{
305    /* just sync everything, that's all the pci API can do */
306    dma_sync_single_for_cpu(dev, dma_handle, offset+size, direction);
307}
308
309static inline void
310dma_sync_single_range_for_device(struct device *dev, dma_addr_t dma_handle,
311                 unsigned long offset, size_t size,
312                 enum dma_data_direction direction)
313{
314    /* just sync everything, that's all the pci API can do */
315    dma_sync_single_for_device(dev, dma_handle, offset+size, direction);
316}
317
318static inline void
319dma_cache_sync(struct device *dev, void *vaddr, size_t size,
320           enum dma_data_direction direction)
321{
322    /* could define this in terms of the dma_cache ... operations,
323     * but if you get this on a platform, you should convert the platform
324     * to using the generic device DMA API */
325    BUG();
326}
327
328#endif /* _ASM_UBICOM32_DMA_MAPPING_H */
329

Archive Download this file

Branches:
backfire
history
master
release_2010-11-17
release_2010-12-14
release_2011-02-23
release_2011-05-28
release_2011-08-27
release_2011-11-13
release_2012-03-18
release_2012-04-09
release_2012-10-11
uclibc_nptl



interactive