Commit | Line | Data |
---|---|---|
944c67df DM |
1 | /* dma.c: PCI and SBUS DMA accessors for 32-bit sparc. |
2 | * | |
3 | * Copyright (C) 2008 David S. Miller <davem@davemloft.net> | |
4 | */ | |
5 | ||
6 | #include <linux/kernel.h> | |
7 | #include <linux/module.h> | |
8 | #include <linux/dma-mapping.h> | |
9 | #include <linux/scatterlist.h> | |
10 | #include <linux/mm.h> | |
11 | ||
12 | #ifdef CONFIG_PCI | |
13 | #include <linux/pci.h> | |
14 | #endif | |
15 | ||
16 | #include "dma.h" | |
17 | ||
18 | int dma_supported(struct device *dev, u64 mask) | |
19 | { | |
20 | #ifdef CONFIG_PCI | |
21 | if (dev->bus == &pci_bus_type) | |
22 | return pci_dma_supported(to_pci_dev(dev), mask); | |
23 | #endif | |
24 | return 0; | |
25 | } | |
26 | EXPORT_SYMBOL(dma_supported); | |
27 | ||
28 | int dma_set_mask(struct device *dev, u64 dma_mask) | |
29 | { | |
30 | #ifdef CONFIG_PCI | |
31 | if (dev->bus == &pci_bus_type) | |
32 | return pci_set_dma_mask(to_pci_dev(dev), dma_mask); | |
33 | #endif | |
34 | return -EOPNOTSUPP; | |
35 | } | |
36 | EXPORT_SYMBOL(dma_set_mask); | |
37 | ||
38 | void *dma_alloc_coherent(struct device *dev, size_t size, | |
39 | dma_addr_t *dma_handle, gfp_t flag) | |
40 | { | |
41 | #ifdef CONFIG_PCI | |
42 | if (dev->bus == &pci_bus_type) | |
43 | return pci_alloc_consistent(to_pci_dev(dev), size, dma_handle); | |
44 | #endif | |
45 | return sbus_alloc_consistent(dev, size, dma_handle); | |
46 | } | |
47 | EXPORT_SYMBOL(dma_alloc_coherent); | |
48 | ||
49 | void dma_free_coherent(struct device *dev, size_t size, | |
50 | void *cpu_addr, dma_addr_t dma_handle) | |
51 | { | |
52 | #ifdef CONFIG_PCI | |
53 | if (dev->bus == &pci_bus_type) { | |
54 | pci_free_consistent(to_pci_dev(dev), size, | |
55 | cpu_addr, dma_handle); | |
56 | return; | |
57 | } | |
58 | #endif | |
59 | sbus_free_consistent(dev, size, cpu_addr, dma_handle); | |
60 | } | |
61 | EXPORT_SYMBOL(dma_free_coherent); | |
62 | ||
63 | dma_addr_t dma_map_single(struct device *dev, void *cpu_addr, | |
64 | size_t size, enum dma_data_direction direction) | |
65 | { | |
66 | #ifdef CONFIG_PCI | |
67 | if (dev->bus == &pci_bus_type) | |
68 | return pci_map_single(to_pci_dev(dev), cpu_addr, | |
69 | size, (int)direction); | |
70 | #endif | |
71 | return sbus_map_single(dev, cpu_addr, size, (int)direction); | |
72 | } | |
73 | EXPORT_SYMBOL(dma_map_single); | |
74 | ||
75 | void dma_unmap_single(struct device *dev, dma_addr_t dma_addr, | |
76 | size_t size, | |
77 | enum dma_data_direction direction) | |
78 | { | |
79 | #ifdef CONFIG_PCI | |
80 | if (dev->bus == &pci_bus_type) { | |
81 | pci_unmap_single(to_pci_dev(dev), dma_addr, | |
82 | size, (int)direction); | |
83 | return; | |
84 | } | |
85 | #endif | |
86 | sbus_unmap_single(dev, dma_addr, size, (int)direction); | |
87 | } | |
88 | EXPORT_SYMBOL(dma_unmap_single); | |
89 | ||
90 | dma_addr_t dma_map_page(struct device *dev, struct page *page, | |
91 | unsigned long offset, size_t size, | |
92 | enum dma_data_direction direction) | |
93 | { | |
94 | #ifdef CONFIG_PCI | |
95 | if (dev->bus == &pci_bus_type) | |
96 | return pci_map_page(to_pci_dev(dev), page, offset, | |
97 | size, (int)direction); | |
98 | #endif | |
99 | return sbus_map_single(dev, page_address(page) + offset, | |
100 | size, (int)direction); | |
101 | } | |
102 | EXPORT_SYMBOL(dma_map_page); | |
103 | ||
104 | void dma_unmap_page(struct device *dev, dma_addr_t dma_address, | |
105 | size_t size, enum dma_data_direction direction) | |
106 | { | |
107 | #ifdef CONFIG_PCI | |
108 | if (dev->bus == &pci_bus_type) { | |
109 | pci_unmap_page(to_pci_dev(dev), dma_address, | |
110 | size, (int)direction); | |
111 | return; | |
112 | } | |
113 | #endif | |
114 | sbus_unmap_single(dev, dma_address, size, (int)direction); | |
115 | } | |
116 | EXPORT_SYMBOL(dma_unmap_page); | |
117 | ||
118 | int dma_map_sg(struct device *dev, struct scatterlist *sg, | |
119 | int nents, enum dma_data_direction direction) | |
120 | { | |
121 | #ifdef CONFIG_PCI | |
122 | if (dev->bus == &pci_bus_type) | |
123 | return pci_map_sg(to_pci_dev(dev), sg, nents, (int)direction); | |
124 | #endif | |
125 | return sbus_map_sg(dev, sg, nents, direction); | |
126 | } | |
127 | EXPORT_SYMBOL(dma_map_sg); | |
128 | ||
129 | void dma_unmap_sg(struct device *dev, struct scatterlist *sg, | |
130 | int nents, enum dma_data_direction direction) | |
131 | { | |
132 | #ifdef CONFIG_PCI | |
133 | if (dev->bus == &pci_bus_type) { | |
134 | pci_unmap_sg(to_pci_dev(dev), sg, nents, (int)direction); | |
135 | return; | |
136 | } | |
137 | #endif | |
138 | sbus_unmap_sg(dev, sg, nents, (int)direction); | |
139 | } | |
140 | EXPORT_SYMBOL(dma_unmap_sg); | |
141 | ||
142 | void dma_sync_single_for_cpu(struct device *dev, dma_addr_t dma_handle, | |
143 | size_t size, enum dma_data_direction direction) | |
144 | { | |
145 | #ifdef CONFIG_PCI | |
146 | if (dev->bus == &pci_bus_type) { | |
147 | pci_dma_sync_single_for_cpu(to_pci_dev(dev), dma_handle, | |
148 | size, (int)direction); | |
149 | return; | |
150 | } | |
151 | #endif | |
152 | sbus_dma_sync_single_for_cpu(dev, dma_handle, size, (int) direction); | |
153 | } | |
154 | EXPORT_SYMBOL(dma_sync_single_for_cpu); | |
155 | ||
156 | void dma_sync_single_for_device(struct device *dev, dma_addr_t dma_handle, | |
157 | size_t size, enum dma_data_direction direction) | |
158 | { | |
159 | #ifdef CONFIG_PCI | |
160 | if (dev->bus == &pci_bus_type) { | |
161 | pci_dma_sync_single_for_device(to_pci_dev(dev), dma_handle, | |
162 | size, (int)direction); | |
163 | return; | |
164 | } | |
165 | #endif | |
166 | sbus_dma_sync_single_for_device(dev, dma_handle, size, (int) direction); | |
167 | } | |
168 | EXPORT_SYMBOL(dma_sync_single_for_device); | |
169 | ||
170 | void dma_sync_single_range_for_cpu(struct device *dev, | |
171 | dma_addr_t dma_handle, | |
172 | unsigned long offset, | |
173 | size_t size, | |
174 | enum dma_data_direction direction) | |
175 | { | |
176 | dma_sync_single_for_cpu(dev, dma_handle+offset, size, direction); | |
177 | } | |
178 | EXPORT_SYMBOL(dma_sync_single_range_for_cpu); | |
179 | ||
180 | void dma_sync_single_range_for_device(struct device *dev, dma_addr_t dma_handle, | |
181 | unsigned long offset, size_t size, | |
182 | enum dma_data_direction direction) | |
183 | { | |
184 | dma_sync_single_for_device(dev, dma_handle+offset, size, direction); | |
185 | } | |
186 | EXPORT_SYMBOL(dma_sync_single_range_for_device); | |
187 | ||
188 | void dma_sync_sg_for_cpu(struct device *dev, struct scatterlist *sg, | |
189 | int nelems, enum dma_data_direction direction) | |
190 | { | |
191 | #ifdef CONFIG_PCI | |
192 | if (dev->bus == &pci_bus_type) { | |
193 | pci_dma_sync_sg_for_cpu(to_pci_dev(dev), sg, | |
194 | nelems, (int)direction); | |
195 | return; | |
196 | } | |
197 | #endif | |
198 | BUG(); | |
199 | } | |
200 | EXPORT_SYMBOL(dma_sync_sg_for_cpu); | |
201 | ||
202 | void dma_sync_sg_for_device(struct device *dev, | |
203 | struct scatterlist *sg, int nelems, | |
204 | enum dma_data_direction direction) | |
205 | { | |
206 | #ifdef CONFIG_PCI | |
207 | if (dev->bus == &pci_bus_type) { | |
208 | pci_dma_sync_sg_for_device(to_pci_dev(dev), sg, | |
209 | nelems, (int)direction); | |
210 | return; | |
211 | } | |
212 | #endif | |
213 | BUG(); | |
214 | } | |
215 | EXPORT_SYMBOL(dma_sync_sg_for_device); | |
216 | ||
217 | int dma_mapping_error(struct device *dev, dma_addr_t dma_addr) | |
218 | { | |
219 | return (dma_addr == DMA_ERROR_CODE); | |
220 | } | |
221 | EXPORT_SYMBOL(dma_mapping_error); | |
222 | ||
223 | int dma_get_cache_alignment(void) | |
224 | { | |
225 | return 32; | |
226 | } | |
227 | EXPORT_SYMBOL(dma_get_cache_alignment); |