~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/include/asm-generic/dma-mapping-common.h

Version: ~ [ linux-5.3-rc5 ] ~ [ linux-5.2.9 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.67 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.139 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.189 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.189 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.72 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 #ifndef _ASM_GENERIC_DMA_MAPPING_H
  2 #define _ASM_GENERIC_DMA_MAPPING_H
  3 
  4 #include <linux/kmemcheck.h>
  5 #include <linux/bug.h>
  6 #include <linux/scatterlist.h>
  7 #include <linux/dma-debug.h>
  8 #include <linux/dma-attrs.h>
  9 
 10 static inline dma_addr_t dma_map_single_attrs(struct device *dev, void *ptr,
 11                                               size_t size,
 12                                               enum dma_data_direction dir,
 13                                               struct dma_attrs *attrs)
 14 {
 15         struct dma_map_ops *ops = get_dma_ops(dev);
 16         dma_addr_t addr;
 17 
 18         kmemcheck_mark_initialized(ptr, size);
 19         BUG_ON(!valid_dma_direction(dir));
 20         addr = ops->map_page(dev, virt_to_page(ptr),
 21                              (unsigned long)ptr & ~PAGE_MASK, size,
 22                              dir, attrs);
 23         debug_dma_map_page(dev, virt_to_page(ptr),
 24                            (unsigned long)ptr & ~PAGE_MASK, size,
 25                            dir, addr, true);
 26         return addr;
 27 }
 28 
 29 static inline void dma_unmap_single_attrs(struct device *dev, dma_addr_t addr,
 30                                           size_t size,
 31                                           enum dma_data_direction dir,
 32                                           struct dma_attrs *attrs)
 33 {
 34         struct dma_map_ops *ops = get_dma_ops(dev);
 35 
 36         BUG_ON(!valid_dma_direction(dir));
 37         if (ops->unmap_page)
 38                 ops->unmap_page(dev, addr, size, dir, attrs);
 39         debug_dma_unmap_page(dev, addr, size, dir, true);
 40 }
 41 
 42 /*
 43  * dma_maps_sg_attrs returns 0 on error and > 0 on success.
 44  * It should never return a value < 0.
 45  */
 46 static inline int dma_map_sg_attrs(struct device *dev, struct scatterlist *sg,
 47                                    int nents, enum dma_data_direction dir,
 48                                    struct dma_attrs *attrs)
 49 {
 50         struct dma_map_ops *ops = get_dma_ops(dev);
 51         int i, ents;
 52         struct scatterlist *s;
 53 
 54         for_each_sg(sg, s, nents, i)
 55                 kmemcheck_mark_initialized(sg_virt(s), s->length);
 56         BUG_ON(!valid_dma_direction(dir));
 57         ents = ops->map_sg(dev, sg, nents, dir, attrs);
 58         BUG_ON(ents < 0);
 59         debug_dma_map_sg(dev, sg, nents, ents, dir);
 60 
 61         return ents;
 62 }
 63 
 64 static inline void dma_unmap_sg_attrs(struct device *dev, struct scatterlist *sg,
 65                                       int nents, enum dma_data_direction dir,
 66                                       struct dma_attrs *attrs)
 67 {
 68         struct dma_map_ops *ops = get_dma_ops(dev);
 69 
 70         BUG_ON(!valid_dma_direction(dir));
 71         debug_dma_unmap_sg(dev, sg, nents, dir);
 72         if (ops->unmap_sg)
 73                 ops->unmap_sg(dev, sg, nents, dir, attrs);
 74 }
 75 
 76 static inline dma_addr_t dma_map_page(struct device *dev, struct page *page,
 77                                       size_t offset, size_t size,
 78                                       enum dma_data_direction dir)
 79 {
 80         struct dma_map_ops *ops = get_dma_ops(dev);
 81         dma_addr_t addr;
 82 
 83         kmemcheck_mark_initialized(page_address(page) + offset, size);
 84         BUG_ON(!valid_dma_direction(dir));
 85         addr = ops->map_page(dev, page, offset, size, dir, NULL);
 86         debug_dma_map_page(dev, page, offset, size, dir, addr, false);
 87 
 88         return addr;
 89 }
 90 
 91 static inline void dma_unmap_page(struct device *dev, dma_addr_t addr,
 92                                   size_t size, enum dma_data_direction dir)
 93 {
 94         struct dma_map_ops *ops = get_dma_ops(dev);
 95 
 96         BUG_ON(!valid_dma_direction(dir));
 97         if (ops->unmap_page)
 98                 ops->unmap_page(dev, addr, size, dir, NULL);
 99         debug_dma_unmap_page(dev, addr, size, dir, false);
100 }
101 
102 static inline void dma_sync_single_for_cpu(struct device *dev, dma_addr_t addr,
103                                            size_t size,
104                                            enum dma_data_direction dir)
105 {
106         struct dma_map_ops *ops = get_dma_ops(dev);
107 
108         BUG_ON(!valid_dma_direction(dir));
109         if (ops->sync_single_for_cpu)
110                 ops->sync_single_for_cpu(dev, addr, size, dir);
111         debug_dma_sync_single_for_cpu(dev, addr, size, dir);
112 }
113 
114 static inline void dma_sync_single_for_device(struct device *dev,
115                                               dma_addr_t addr, size_t size,
116                                               enum dma_data_direction dir)
117 {
118         struct dma_map_ops *ops = get_dma_ops(dev);
119 
120         BUG_ON(!valid_dma_direction(dir));
121         if (ops->sync_single_for_device)
122                 ops->sync_single_for_device(dev, addr, size, dir);
123         debug_dma_sync_single_for_device(dev, addr, size, dir);
124 }
125 
126 static inline void dma_sync_single_range_for_cpu(struct device *dev,
127                                                  dma_addr_t addr,
128                                                  unsigned long offset,
129                                                  size_t size,
130                                                  enum dma_data_direction dir)
131 {
132         const struct dma_map_ops *ops = get_dma_ops(dev);
133 
134         BUG_ON(!valid_dma_direction(dir));
135         if (ops->sync_single_for_cpu)
136                 ops->sync_single_for_cpu(dev, addr + offset, size, dir);
137         debug_dma_sync_single_range_for_cpu(dev, addr, offset, size, dir);
138 }
139 
140 static inline void dma_sync_single_range_for_device(struct device *dev,
141                                                     dma_addr_t addr,
142                                                     unsigned long offset,
143                                                     size_t size,
144                                                     enum dma_data_direction dir)
145 {
146         const struct dma_map_ops *ops = get_dma_ops(dev);
147 
148         BUG_ON(!valid_dma_direction(dir));
149         if (ops->sync_single_for_device)
150                 ops->sync_single_for_device(dev, addr + offset, size, dir);
151         debug_dma_sync_single_range_for_device(dev, addr, offset, size, dir);
152 }
153 
154 static inline void
155 dma_sync_sg_for_cpu(struct device *dev, struct scatterlist *sg,
156                     int nelems, enum dma_data_direction dir)
157 {
158         struct dma_map_ops *ops = get_dma_ops(dev);
159 
160         BUG_ON(!valid_dma_direction(dir));
161         if (ops->sync_sg_for_cpu)
162                 ops->sync_sg_for_cpu(dev, sg, nelems, dir);
163         debug_dma_sync_sg_for_cpu(dev, sg, nelems, dir);
164 }
165 
166 static inline void
167 dma_sync_sg_for_device(struct device *dev, struct scatterlist *sg,
168                        int nelems, enum dma_data_direction dir)
169 {
170         struct dma_map_ops *ops = get_dma_ops(dev);
171 
172         BUG_ON(!valid_dma_direction(dir));
173         if (ops->sync_sg_for_device)
174                 ops->sync_sg_for_device(dev, sg, nelems, dir);
175         debug_dma_sync_sg_for_device(dev, sg, nelems, dir);
176 
177 }
178 
179 #define dma_map_single(d, a, s, r) dma_map_single_attrs(d, a, s, r, NULL)
180 #define dma_unmap_single(d, a, s, r) dma_unmap_single_attrs(d, a, s, r, NULL)
181 #define dma_map_sg(d, s, n, r) dma_map_sg_attrs(d, s, n, r, NULL)
182 #define dma_unmap_sg(d, s, n, r) dma_unmap_sg_attrs(d, s, n, r, NULL)
183 
184 extern int dma_common_mmap(struct device *dev, struct vm_area_struct *vma,
185                            void *cpu_addr, dma_addr_t dma_addr, size_t size);
186 
187 void *dma_common_contiguous_remap(struct page *page, size_t size,
188                         unsigned long vm_flags,
189                         pgprot_t prot, const void *caller);
190 
191 void *dma_common_pages_remap(struct page **pages, size_t size,
192                         unsigned long vm_flags, pgprot_t prot,
193                         const void *caller);
194 void dma_common_free_remap(void *cpu_addr, size_t size, unsigned long vm_flags);
195 
196 /**
197  * dma_mmap_attrs - map a coherent DMA allocation into user space
198  * @dev: valid struct device pointer, or NULL for ISA and EISA-like devices
199  * @vma: vm_area_struct describing requested user mapping
200  * @cpu_addr: kernel CPU-view address returned from dma_alloc_attrs
201  * @handle: device-view address returned from dma_alloc_attrs
202  * @size: size of memory originally requested in dma_alloc_attrs
203  * @attrs: attributes of mapping properties requested in dma_alloc_attrs
204  *
205  * Map a coherent DMA buffer previously allocated by dma_alloc_attrs
206  * into user space.  The coherent DMA buffer must not be freed by the
207  * driver until the user space mapping has been released.
208  */
209 static inline int
210 dma_mmap_attrs(struct device *dev, struct vm_area_struct *vma, void *cpu_addr,
211                dma_addr_t dma_addr, size_t size, struct dma_attrs *attrs)
212 {
213         struct dma_map_ops *ops = get_dma_ops(dev);
214         BUG_ON(!ops);
215         if (ops->mmap)
216                 return ops->mmap(dev, vma, cpu_addr, dma_addr, size, attrs);
217         return dma_common_mmap(dev, vma, cpu_addr, dma_addr, size);
218 }
219 
220 #define dma_mmap_coherent(d, v, c, h, s) dma_mmap_attrs(d, v, c, h, s, NULL)
221 
222 int
223 dma_common_get_sgtable(struct device *dev, struct sg_table *sgt,
224                        void *cpu_addr, dma_addr_t dma_addr, size_t size);
225 
226 static inline int
227 dma_get_sgtable_attrs(struct device *dev, struct sg_table *sgt, void *cpu_addr,
228                       dma_addr_t dma_addr, size_t size, struct dma_attrs *attrs)
229 {
230         struct dma_map_ops *ops = get_dma_ops(dev);
231         BUG_ON(!ops);
232         if (ops->get_sgtable)
233                 return ops->get_sgtable(dev, sgt, cpu_addr, dma_addr, size,
234                                         attrs);
235         return dma_common_get_sgtable(dev, sgt, cpu_addr, dma_addr, size);
236 }
237 
238 #define dma_get_sgtable(d, t, v, h, s) dma_get_sgtable_attrs(d, t, v, h, s, NULL)
239 
240 #endif
241 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp