aboutsummaryrefslogtreecommitdiffstats
path: root/arch/powerpc/kernel/dma.c
diff options
context:
space:
mode:
Diffstat (limited to 'arch/powerpc/kernel/dma.c')
-rw-r--r--arch/powerpc/kernel/dma.c131
1 files changed, 131 insertions, 0 deletions
diff --git a/arch/powerpc/kernel/dma.c b/arch/powerpc/kernel/dma.c
new file mode 100644
index 000000000000..1562daf8839a
--- /dev/null
+++ b/arch/powerpc/kernel/dma.c
@@ -0,0 +1,131 @@
1/*
2 * Copyright (C) 2006 Benjamin Herrenschmidt, IBM Corporation
3 *
4 * Provide default implementations of the DMA mapping callbacks for
5 * directly mapped busses.
6 */
7
8#include <linux/device.h>
9#include <linux/dma-mapping.h>
10#include <asm/bug.h>
11#include <asm/abs_addr.h>
12
13/*
14 * Generic direct DMA implementation
15 *
16 * This implementation supports a per-device offset that can be applied if
17 * the address at which memory is visible to devices is not 0. Platform code
18 * can set archdata.dma_data to an unsigned long holding the offset. By
19 * default the offset is PCI_DRAM_OFFSET.
20 */
21
22static unsigned long get_dma_direct_offset(struct device *dev)
23{
24 if (dev)
25 return (unsigned long)dev->archdata.dma_data;
26
27 return PCI_DRAM_OFFSET;
28}
29
30void *dma_direct_alloc_coherent(struct device *dev, size_t size,
31 dma_addr_t *dma_handle, gfp_t flag)
32{
33 void *ret;
34#ifdef CONFIG_NOT_COHERENT_CACHE
35 ret = __dma_alloc_coherent(size, dma_handle, flag);
36 if (ret == NULL)
37 return NULL;
38 *dma_handle += get_dma_direct_offset(dev);
39 return ret;
40#else
41 struct page *page;
42 int node = dev_to_node(dev);
43
44 /* ignore region specifiers */
45 flag &= ~(__GFP_HIGHMEM);
46
47 page = alloc_pages_node(node, flag, get_order(size));
48 if (page == NULL)
49 return NULL;
50 ret = page_address(page);
51 memset(ret, 0, size);
52 *dma_handle = virt_to_abs(ret) + get_dma_direct_offset(dev);
53
54 return ret;
55#endif
56}
57
58void dma_direct_free_coherent(struct device *dev, size_t size,
59 void *vaddr, dma_addr_t dma_handle)
60{
61#ifdef CONFIG_NOT_COHERENT_CACHE
62 __dma_free_coherent(size, vaddr);
63#else
64 free_pages((unsigned long)vaddr, get_order(size));
65#endif
66}
67
68static int dma_direct_map_sg(struct device *dev, struct scatterlist *sgl,
69 int nents, enum dma_data_direction direction,
70 struct dma_attrs *attrs)
71{
72 struct scatterlist *sg;
73 int i;
74
75 for_each_sg(sgl, sg, nents, i) {
76 sg->dma_address = sg_phys(sg) + get_dma_direct_offset(dev);
77 sg->dma_length = sg->length;
78 }
79
80 return nents;
81}
82
83static void dma_direct_unmap_sg(struct device *dev, struct scatterlist *sg,
84 int nents, enum dma_data_direction direction,
85 struct dma_attrs *attrs)
86{
87}
88
89static int dma_direct_dma_supported(struct device *dev, u64 mask)
90{
91#ifdef CONFIG_PPC64
92 /* Could be improved to check for memory though it better be
93 * done via some global so platforms can set the limit in case
94 * they have limited DMA windows
95 */
96 return mask >= DMA_32BIT_MASK;
97#else
98 return 1;
99#endif
100}
101
102static inline dma_addr_t dma_direct_map_page(struct device *dev,
103 struct page *page,
104 unsigned long offset,
105 size_t size,
106 enum dma_data_direction dir,
107 struct dma_attrs *attrs)
108{
109 BUG_ON(dir == DMA_NONE);
110 __dma_sync_page(page, offset, size, dir);
111 return page_to_phys(page) + offset + get_dma_direct_offset(dev);
112}
113
114static inline void dma_direct_unmap_page(struct device *dev,
115 dma_addr_t dma_address,
116 size_t size,
117 enum dma_data_direction direction,
118 struct dma_attrs *attrs)
119{
120}
121
122struct dma_mapping_ops dma_direct_ops = {
123 .alloc_coherent = dma_direct_alloc_coherent,
124 .free_coherent = dma_direct_free_coherent,
125 .map_sg = dma_direct_map_sg,
126 .unmap_sg = dma_direct_unmap_sg,
127 .dma_supported = dma_direct_dma_supported,
128 .map_page = dma_direct_map_page,
129 .unmap_page = dma_direct_unmap_page,
130};
131EXPORT_SYMBOL(dma_direct_ops);