1
2
3
4
5
6
7
8
9
10
11
12#include <linux/module.h>
13#include <asm/dma.h>
14#include <asm/sn/intr.h>
15#include <asm/sn/pcibus_provider_defs.h>
16#include <asm/sn/pcidev.h>
17#include <asm/sn/sn_sal.h>
18
19#define SG_ENT_VIRT_ADDRESS(sg) (sg_virt((sg)))
20#define SG_ENT_PHYS_ADDRESS(SG) virt_to_phys(SG_ENT_VIRT_ADDRESS(SG))
21
22
23
24
25
26
27
28
29
30
31
32
33int sn_dma_supported(struct device *dev, u64 mask)
34{
35 BUG_ON(dev->bus != &pci_bus_type);
36
37 if (mask < 0x7fffffff)
38 return 0;
39 return 1;
40}
41EXPORT_SYMBOL(sn_dma_supported);
42
43
44
45
46
47
48
49
50int sn_dma_set_mask(struct device *dev, u64 dma_mask)
51{
52 BUG_ON(dev->bus != &pci_bus_type);
53
54 if (!sn_dma_supported(dev, dma_mask))
55 return 0;
56
57 *dev->dma_mask = dma_mask;
58 return 1;
59}
60EXPORT_SYMBOL(sn_dma_set_mask);
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77void *sn_dma_alloc_coherent(struct device *dev, size_t size,
78 dma_addr_t * dma_handle, gfp_t flags)
79{
80 void *cpuaddr;
81 unsigned long phys_addr;
82 int node;
83 struct pci_dev *pdev = to_pci_dev(dev);
84 struct sn_pcibus_provider *provider = SN_PCIDEV_BUSPROVIDER(pdev);
85
86 BUG_ON(dev->bus != &pci_bus_type);
87
88
89
90
91 node = pcibus_to_node(pdev->bus);
92 if (likely(node >=0)) {
93 struct page *p = alloc_pages_node(node, flags, get_order(size));
94
95 if (likely(p))
96 cpuaddr = page_address(p);
97 else
98 return NULL;
99 } else
100 cpuaddr = (void *)__get_free_pages(flags, get_order(size));
101
102 if (unlikely(!cpuaddr))
103 return NULL;
104
105 memset(cpuaddr, 0x0, size);
106
107
108 phys_addr = __pa(cpuaddr);
109
110
111
112
113
114
115
116 *dma_handle = provider->dma_map_consistent(pdev, phys_addr, size,
117 SN_DMA_ADDR_PHYS);
118 if (!*dma_handle) {
119 printk(KERN_ERR "%s: out of ATEs\n", __FUNCTION__);
120 free_pages((unsigned long)cpuaddr, get_order(size));
121 return NULL;
122 }
123
124 return cpuaddr;
125}
126EXPORT_SYMBOL(sn_dma_alloc_coherent);
127
128
129
130
131
132
133
134
135
136
137
138void sn_dma_free_coherent(struct device *dev, size_t size, void *cpu_addr,
139 dma_addr_t dma_handle)
140{
141 struct pci_dev *pdev = to_pci_dev(dev);
142 struct sn_pcibus_provider *provider = SN_PCIDEV_BUSPROVIDER(pdev);
143
144 BUG_ON(dev->bus != &pci_bus_type);
145
146 provider->dma_unmap(pdev, dma_handle, 0);
147 free_pages((unsigned long)cpu_addr, get_order(size));
148}
149EXPORT_SYMBOL(sn_dma_free_coherent);
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169dma_addr_t sn_dma_map_single(struct device *dev, void *cpu_addr, size_t size,
170 int direction)
171{
172 dma_addr_t dma_addr;
173 unsigned long phys_addr;
174 struct pci_dev *pdev = to_pci_dev(dev);
175 struct sn_pcibus_provider *provider = SN_PCIDEV_BUSPROVIDER(pdev);
176
177 BUG_ON(dev->bus != &pci_bus_type);
178
179 phys_addr = __pa(cpu_addr);
180 dma_addr = provider->dma_map(pdev, phys_addr, size, SN_DMA_ADDR_PHYS);
181 if (!dma_addr) {
182 printk(KERN_ERR "%s: out of ATEs\n", __FUNCTION__);
183 return 0;
184 }
185 return dma_addr;
186}
187EXPORT_SYMBOL(sn_dma_map_single);
188
189
190
191
192
193
194
195
196
197
198
199
200void sn_dma_unmap_single(struct device *dev, dma_addr_t dma_addr, size_t size,
201 int direction)
202{
203 struct pci_dev *pdev = to_pci_dev(dev);
204 struct sn_pcibus_provider *provider = SN_PCIDEV_BUSPROVIDER(pdev);
205
206 BUG_ON(dev->bus != &pci_bus_type);
207
208 provider->dma_unmap(pdev, dma_addr, direction);
209}
210EXPORT_SYMBOL(sn_dma_unmap_single);
211
212
213
214
215
216
217
218
219
220
221void sn_dma_unmap_sg(struct device *dev, struct scatterlist *sgl,
222 int nhwentries, int direction)
223{
224 int i;
225 struct pci_dev *pdev = to_pci_dev(dev);
226 struct sn_pcibus_provider *provider = SN_PCIDEV_BUSPROVIDER(pdev);
227 struct scatterlist *sg;
228
229 BUG_ON(dev->bus != &pci_bus_type);
230
231 for_each_sg(sgl, sg, nhwentries, i) {
232 provider->dma_unmap(pdev, sg->dma_address, direction);
233 sg->dma_address = (dma_addr_t) NULL;
234 sg->dma_length = 0;
235 }
236}
237EXPORT_SYMBOL(sn_dma_unmap_sg);
238
239
240
241
242
243
244
245
246
247
248int sn_dma_map_sg(struct device *dev, struct scatterlist *sgl, int nhwentries,
249 int direction)
250{
251 unsigned long phys_addr;
252 struct scatterlist *saved_sg = sgl, *sg;
253 struct pci_dev *pdev = to_pci_dev(dev);
254 struct sn_pcibus_provider *provider = SN_PCIDEV_BUSPROVIDER(pdev);
255 int i;
256
257 BUG_ON(dev->bus != &pci_bus_type);
258
259
260
261
262 for_each_sg(sgl, sg, nhwentries, i) {
263 phys_addr = SG_ENT_PHYS_ADDRESS(sg);
264 sg->dma_address = provider->dma_map(pdev,
265 phys_addr, sg->length,
266 SN_DMA_ADDR_PHYS);
267
268 if (!sg->dma_address) {
269 printk(KERN_ERR "%s: out of ATEs\n", __FUNCTION__);
270
271
272
273
274 if (i > 0)
275 sn_dma_unmap_sg(dev, saved_sg, i, direction);
276 return 0;
277 }
278
279 sg->dma_length = sg->length;
280 }
281
282 return nhwentries;
283}
284EXPORT_SYMBOL(sn_dma_map_sg);
285
286void sn_dma_sync_single_for_cpu(struct device *dev, dma_addr_t dma_handle,
287 size_t size, int direction)
288{
289 BUG_ON(dev->bus != &pci_bus_type);
290}
291EXPORT_SYMBOL(sn_dma_sync_single_for_cpu);
292
293void sn_dma_sync_single_for_device(struct device *dev, dma_addr_t dma_handle,
294 size_t size, int direction)
295{
296 BUG_ON(dev->bus != &pci_bus_type);
297}
298EXPORT_SYMBOL(sn_dma_sync_single_for_device);
299
300void sn_dma_sync_sg_for_cpu(struct device *dev, struct scatterlist *sg,
301 int nelems, int direction)
302{
303 BUG_ON(dev->bus != &pci_bus_type);
304}
305EXPORT_SYMBOL(sn_dma_sync_sg_for_cpu);
306
307void sn_dma_sync_sg_for_device(struct device *dev, struct scatterlist *sg,
308 int nelems, int direction)
309{
310 BUG_ON(dev->bus != &pci_bus_type);
311}
312EXPORT_SYMBOL(sn_dma_sync_sg_for_device);
313
314int sn_dma_mapping_error(dma_addr_t dma_addr)
315{
316 return 0;
317}
318EXPORT_SYMBOL(sn_dma_mapping_error);
319
320char *sn_pci_get_legacy_mem(struct pci_bus *bus)
321{
322 if (!SN_PCIBUS_BUSSOFT(bus))
323 return ERR_PTR(-ENODEV);
324
325 return (char *)(SN_PCIBUS_BUSSOFT(bus)->bs_legacy_mem | __IA64_UNCACHED_OFFSET);
326}
327
328int sn_pci_legacy_read(struct pci_bus *bus, u16 port, u32 *val, u8 size)
329{
330 unsigned long addr;
331 int ret;
332 struct ia64_sal_retval isrv;
333
334
335
336
337
338
339
340 SAL_CALL(isrv, SN_SAL_IOIF_PCI_SAFE,
341 pci_domain_nr(bus), bus->number,
342 0,
343 0,
344 port, size, __pa(val));
345
346 if (isrv.status == 0)
347 return size;
348
349
350
351
352
353
354
355
356 if (!SN_PCIBUS_BUSSOFT(bus))
357 return -ENODEV;
358
359 addr = SN_PCIBUS_BUSSOFT(bus)->bs_legacy_io | __IA64_UNCACHED_OFFSET;
360 addr += port;
361
362 ret = ia64_sn_probe_mem(addr, (long)size, (void *)val);
363
364 if (ret == 2)
365 return -EINVAL;
366
367 if (ret == 1)
368 *val = -1;
369
370 return size;
371}
372
373int sn_pci_legacy_write(struct pci_bus *bus, u16 port, u32 val, u8 size)
374{
375 int ret = size;
376 unsigned long paddr;
377 unsigned long *addr;
378 struct ia64_sal_retval isrv;
379
380
381
382
383
384
385
386 SAL_CALL(isrv, SN_SAL_IOIF_PCI_SAFE,
387 pci_domain_nr(bus), bus->number,
388 0,
389 1,
390 port, size, __pa(&val));
391
392 if (isrv.status == 0)
393 return size;
394
395
396
397
398
399
400
401
402 if (!SN_PCIBUS_BUSSOFT(bus)) {
403 ret = -ENODEV;
404 goto out;
405 }
406
407
408 paddr = SN_PCIBUS_BUSSOFT(bus)->bs_legacy_io | __IA64_UNCACHED_OFFSET;
409 paddr += port;
410 addr = (unsigned long *)paddr;
411
412 switch (size) {
413 case 1:
414 *(volatile u8 *)(addr) = (u8)(val);
415 break;
416 case 2:
417 *(volatile u16 *)(addr) = (u16)(val);
418 break;
419 case 4:
420 *(volatile u32 *)(addr) = (u32)(val);
421 break;
422 default:
423 ret = -EINVAL;
424 break;
425 }
426 out:
427 return ret;
428}
429