890531e32fe87462f4a0cdbc20c8df019ad2db71
[linux-2.6.git] / arch / parisc / include / asm / dma-mapping.h
1 #ifndef _PARISC_DMA_MAPPING_H
2 #define _PARISC_DMA_MAPPING_H
3
4 #include <linux/mm.h>
5 #include <asm/cacheflush.h>
6 #include <asm/scatterlist.h>
7
8 /* See Documentation/PCI/PCI-DMA-mapping.txt */
9 struct hppa_dma_ops {
10         int  (*dma_supported)(struct device *dev, u64 mask);
11         void *(*alloc_consistent)(struct device *dev, size_t size, dma_addr_t *iova, gfp_t flag);
12         void *(*alloc_noncoherent)(struct device *dev, size_t size, dma_addr_t *iova, gfp_t flag);
13         void (*free_consistent)(struct device *dev, size_t size, void *vaddr, dma_addr_t iova);
14         dma_addr_t (*map_single)(struct device *dev, void *addr, size_t size, enum dma_data_direction direction);
15         void (*unmap_single)(struct device *dev, dma_addr_t iova, size_t size, enum dma_data_direction direction);
16         int  (*map_sg)(struct device *dev, struct scatterlist *sg, int nents, enum dma_data_direction direction);
17         void (*unmap_sg)(struct device *dev, struct scatterlist *sg, int nhwents, enum dma_data_direction direction);
18         void (*dma_sync_single_for_cpu)(struct device *dev, dma_addr_t iova, unsigned long offset, size_t size, enum dma_data_direction direction);
19         void (*dma_sync_single_for_device)(struct device *dev, dma_addr_t iova, unsigned long offset, size_t size, enum dma_data_direction direction);
20         void (*dma_sync_sg_for_cpu)(struct device *dev, struct scatterlist *sg, int nelems, enum dma_data_direction direction);
21         void (*dma_sync_sg_for_device)(struct device *dev, struct scatterlist *sg, int nelems, enum dma_data_direction direction);
22 };
23
24 /*
25 ** We could live without the hppa_dma_ops indirection if we didn't want
26 ** to support 4 different coherent dma models with one binary (they will
27 ** someday be loadable modules):
28 **     I/O MMU        consistent method           dma_sync behavior
29 **  =============   ======================       =======================
30 **  a) PA-7x00LC    uncachable host memory          flush/purge
31 **  b) U2/Uturn      cachable host memory              NOP
32 **  c) Ike/Astro     cachable host memory              NOP
33 **  d) EPIC/SAGA     memory on EPIC/SAGA         flush/reset DMA channel
34 **
35 ** PA-7[13]00LC processors have a GSC bus interface and no I/O MMU.
36 **
37 ** Systems (eg PCX-T workstations) that don't fall into the above
38 ** categories will need to modify the needed drivers to perform
39 ** flush/purge and allocate "regular" cacheable pages for everything.
40 */
41
42 #ifdef CONFIG_PA11
43 extern struct hppa_dma_ops pcxl_dma_ops;
44 extern struct hppa_dma_ops pcx_dma_ops;
45 #endif
46
47 extern struct hppa_dma_ops *hppa_dma_ops;
48
49 static inline void *
50 dma_alloc_coherent(struct device *dev, size_t size, dma_addr_t *dma_handle,
51                    gfp_t flag)
52 {
53         return hppa_dma_ops->alloc_consistent(dev, size, dma_handle, flag);
54 }
55
56 static inline void *
57 dma_alloc_noncoherent(struct device *dev, size_t size, dma_addr_t *dma_handle,
58                       gfp_t flag)
59 {
60         return hppa_dma_ops->alloc_noncoherent(dev, size, dma_handle, flag);
61 }
62
63 static inline void
64 dma_free_coherent(struct device *dev, size_t size, 
65                     void *vaddr, dma_addr_t dma_handle)
66 {
67         hppa_dma_ops->free_consistent(dev, size, vaddr, dma_handle);
68 }
69
70 static inline void
71 dma_free_noncoherent(struct device *dev, size_t size, 
72                     void *vaddr, dma_addr_t dma_handle)
73 {
74         hppa_dma_ops->free_consistent(dev, size, vaddr, dma_handle);
75 }
76
77 static inline dma_addr_t
78 dma_map_single(struct device *dev, void *ptr, size_t size,
79                enum dma_data_direction direction)
80 {
81         return hppa_dma_ops->map_single(dev, ptr, size, direction);
82 }
83
84 static inline void
85 dma_unmap_single(struct device *dev, dma_addr_t dma_addr, size_t size,
86                  enum dma_data_direction direction)
87 {
88         hppa_dma_ops->unmap_single(dev, dma_addr, size, direction);
89 }
90
91 static inline int
92 dma_map_sg(struct device *dev, struct scatterlist *sg, int nents,
93            enum dma_data_direction direction)
94 {
95         return hppa_dma_ops->map_sg(dev, sg, nents, direction);
96 }
97
98 static inline void
99 dma_unmap_sg(struct device *dev, struct scatterlist *sg, int nhwentries,
100              enum dma_data_direction direction)
101 {
102         hppa_dma_ops->unmap_sg(dev, sg, nhwentries, direction);
103 }
104
105 static inline dma_addr_t
106 dma_map_page(struct device *dev, struct page *page, unsigned long offset,
107              size_t size, enum dma_data_direction direction)
108 {
109         return dma_map_single(dev, (page_address(page) + (offset)), size, direction);
110 }
111
112 static inline void
113 dma_unmap_page(struct device *dev, dma_addr_t dma_address, size_t size,
114                enum dma_data_direction direction)
115 {
116         dma_unmap_single(dev, dma_address, size, direction);
117 }
118
119
120 static inline void
121 dma_sync_single_for_cpu(struct device *dev, dma_addr_t dma_handle, size_t size,
122                 enum dma_data_direction direction)
123 {
124         if(hppa_dma_ops->dma_sync_single_for_cpu)
125                 hppa_dma_ops->dma_sync_single_for_cpu(dev, dma_handle, 0, size, direction);
126 }
127
128 static inline void
129 dma_sync_single_for_device(struct device *dev, dma_addr_t dma_handle, size_t size,
130                 enum dma_data_direction direction)
131 {
132         if(hppa_dma_ops->dma_sync_single_for_device)
133                 hppa_dma_ops->dma_sync_single_for_device(dev, dma_handle, 0, size, direction);
134 }
135
136 static inline void
137 dma_sync_single_range_for_cpu(struct device *dev, dma_addr_t dma_handle,
138                       unsigned long offset, size_t size,
139                       enum dma_data_direction direction)
140 {
141         if(hppa_dma_ops->dma_sync_single_for_cpu)
142                 hppa_dma_ops->dma_sync_single_for_cpu(dev, dma_handle, offset, size, direction);
143 }
144
145 static inline void
146 dma_sync_single_range_for_device(struct device *dev, dma_addr_t dma_handle,
147                       unsigned long offset, size_t size,
148                       enum dma_data_direction direction)
149 {
150         if(hppa_dma_ops->dma_sync_single_for_device)
151                 hppa_dma_ops->dma_sync_single_for_device(dev, dma_handle, offset, size, direction);
152 }
153
154 static inline void
155 dma_sync_sg_for_cpu(struct device *dev, struct scatterlist *sg, int nelems,
156                  enum dma_data_direction direction)
157 {
158         if(hppa_dma_ops->dma_sync_sg_for_cpu)
159                 hppa_dma_ops->dma_sync_sg_for_cpu(dev, sg, nelems, direction);
160 }
161
162 static inline void
163 dma_sync_sg_for_device(struct device *dev, struct scatterlist *sg, int nelems,
164                  enum dma_data_direction direction)
165 {
166         if(hppa_dma_ops->dma_sync_sg_for_device)
167                 hppa_dma_ops->dma_sync_sg_for_device(dev, sg, nelems, direction);
168 }
169
170 static inline int
171 dma_supported(struct device *dev, u64 mask)
172 {
173         return hppa_dma_ops->dma_supported(dev, mask);
174 }
175
176 static inline int
177 dma_set_mask(struct device *dev, u64 mask)
178 {
179         if(!dev->dma_mask || !dma_supported(dev, mask))
180                 return -EIO;
181
182         *dev->dma_mask = mask;
183
184         return 0;
185 }
186
187 static inline void
188 dma_cache_sync(struct device *dev, void *vaddr, size_t size,
189                enum dma_data_direction direction)
190 {
191         if(hppa_dma_ops->dma_sync_single_for_cpu)
192                 flush_kernel_dcache_range((unsigned long)vaddr, size);
193 }
194
195 static inline void *
196 parisc_walk_tree(struct device *dev)
197 {
198         struct device *otherdev;
199         if(likely(dev->platform_data != NULL))
200                 return dev->platform_data;
201         /* OK, just traverse the bus to find it */
202         for(otherdev = dev->parent; otherdev;
203             otherdev = otherdev->parent) {
204                 if(otherdev->platform_data) {
205                         dev->platform_data = otherdev->platform_data;
206                         break;
207                 }
208         }
209         BUG_ON(!dev->platform_data);
210         return dev->platform_data;
211 }
212                 
213 #define GET_IOC(dev) (HBA_DATA(parisc_walk_tree(dev))->iommu)
214         
215
216 #ifdef CONFIG_IOMMU_CCIO
217 struct parisc_device;
218 struct ioc;
219 void * ccio_get_iommu(const struct parisc_device *dev);
220 int ccio_request_resource(const struct parisc_device *dev,
221                 struct resource *res);
222 int ccio_allocate_resource(const struct parisc_device *dev,
223                 struct resource *res, unsigned long size,
224                 unsigned long min, unsigned long max, unsigned long align);
225 #else /* !CONFIG_IOMMU_CCIO */
226 #define ccio_get_iommu(dev) NULL
227 #define ccio_request_resource(dev, res) insert_resource(&iomem_resource, res)
228 #define ccio_allocate_resource(dev, res, size, min, max, align) \
229                 allocate_resource(&iomem_resource, res, size, min, max, \
230                                 align, NULL, NULL)
231 #endif /* !CONFIG_IOMMU_CCIO */
232
233 #ifdef CONFIG_IOMMU_SBA
234 struct parisc_device;
235 void * sba_get_iommu(struct parisc_device *dev);
236 #endif
237
238 /* At the moment, we panic on error for IOMMU resource exaustion */
239 #define dma_mapping_error(dev, x)       0
240
241 #endif