History

Merge tag 'dma-mapping-4.21-1' of git://git.infradead.org/users/hch/dma-mapping

Pull dma-mapping fixes from Christoph Hellwig: "Fix various regressions introduced in this cycles: - fix dma-debug tracking for the map_page / map_single consolidatation - properly stub out DMA mapping symbols for !HAS_DMA builds to avoid link failures - fix AMD Gart direct mappings - setup the dma address for no kernel mappings using the remap allocator" * tag 'dma-mapping-4.21-1' of git://git.infradead.org/users/hch/dma-mapping: dma-direct: fix DMA_ATTR_NO_KERNEL_MAPPING for remapped allocations x86/amd_gart: fix unmapping of non-GART mappings dma-mapping: remove a few unused exports dma-mapping: properly stub out the DMA API for !CONFIG_HAS_DMA dma-mapping: remove dmam_{declare,release}_coherent_memory dma-mapping: implement dmam_alloc_coherent using dmam_alloc_attrs dma-mapping: implement dma_map_single_attrs using dma_map_page_attrs

Linus Torvalds committed 7 years ago

Commit e2b745f2 parents 1213325 8270f3a8 files · +215 −275Browse files

Showing the changes to include/linux (2 of 8 files). Show all

Unified · Split

2 files
  1. include/linux/dma-debug.h +4 −7
  2. include/linux/dma-mapping.h +191 −149
include/linux/dma-debug.h+4−7
@@ -35,13 +35,12 @@ extern void debug_dma_map_single(struct device *dev, const void *addr, · 34 unmodified lines
35 35
36extern void debug_dma_map_page(struct device *dev, struct page *page,36extern void debug_dma_map_page(struct device *dev, struct page *page,
37 size_t offset, size_t size,37 size_t offset, size_t size,
38 int direction, dma_addr_t dma_addr,38 int direction, dma_addr_t dma_addr);
39 bool map_single);
40 39
41extern void debug_dma_mapping_error(struct device *dev, dma_addr_t dma_addr);40extern void debug_dma_mapping_error(struct device *dev, dma_addr_t dma_addr);
42 41
43extern void debug_dma_unmap_page(struct device *dev, dma_addr_t addr,42extern void debug_dma_unmap_page(struct device *dev, dma_addr_t addr,
44 size_t size, int direction, bool map_single);43 size_t size, int direction);
45 44
46extern void debug_dma_map_sg(struct device *dev, struct scatterlist *sg,45extern void debug_dma_map_sg(struct device *dev, struct scatterlist *sg,
47 int nents, int mapped_ents, int direction);46 int nents, int mapped_ents, int direction);
@@ -95,8 +94,7 @@ static inline void debug_dma_map_single(struct device *dev, const void *addr, · 47 unmodified lines
95 94
96static inline void debug_dma_map_page(struct device *dev, struct page *page,95static inline void debug_dma_map_page(struct device *dev, struct page *page,
97 size_t offset, size_t size,96 size_t offset, size_t size,
98 int direction, dma_addr_t dma_addr,97 int direction, dma_addr_t dma_addr)
99 bool map_single)
100{98{
101}99}
102 100
@@ -106,8 +104,7 @@ static inline void debug_dma_mapping_error(struct device *dev, · 3 unmodified lines
106}104}
107 105
108static inline void debug_dma_unmap_page(struct device *dev, dma_addr_t addr,106static inline void debug_dma_unmap_page(struct device *dev, dma_addr_t addr,
109 size_t size, int direction,107 size_t size, int direction)
110 bool map_single)
111{108{
112}109}
113 110
include/linux/dma-mapping.h+191−149
@@ -194,33 +194,6 @@ static inline int dma_mmap_from_global_coherent(struct vm_area_struct *vma, · 193 unmodified lines
194}194}
195#endif /* CONFIG_HAVE_GENERIC_DMA_COHERENT */195#endif /* CONFIG_HAVE_GENERIC_DMA_COHERENT */
196 196
197#ifdef CONFIG_HAS_DMA
198#include <asm/dma-mapping.h>
199static inline const struct dma_map_ops *get_dma_ops(struct device *dev)
200{
201 if (dev && dev->dma_ops)
202 return dev->dma_ops;
203 return get_arch_dma_ops(dev ? dev->bus : NULL);
204}
205
206static inline void set_dma_ops(struct device *dev,
207 const struct dma_map_ops *dma_ops)
208{
209 dev->dma_ops = dma_ops;
210}
211#else
212/*
213 * Define the dma api to allow compilation of dma dependent code.
214 * Code that depends on the dma-mapping API needs to set 'depends on HAS_DMA'
215 * in its Kconfig, unless it already depends on <something> || COMPILE_TEST,
216 * where <something> guarantuees the availability of the dma-mapping API.
217 */
218static inline const struct dma_map_ops *get_dma_ops(struct device *dev)
219{
220 return NULL;
221}
222#endif
223
224static inline bool dma_is_direct(const struct dma_map_ops *ops)197static inline bool dma_is_direct(const struct dma_map_ops *ops)
225{198{
226 return likely(!ops);199 return likely(!ops);
@@ -284,32 +257,41 @@ static inline void dma_direct_sync_sg_for_cpu(struct device *dev, · 57 unmodified lines
284}257}
285#endif258#endif
286 259
287static inline dma_addr_t dma_map_single_attrs(struct device *dev, void *ptr,260#ifdef CONFIG_HAS_DMA
288 size_t size,261#include <asm/dma-mapping.h>
289 enum dma_data_direction dir,262
290 unsigned long attrs)263static inline const struct dma_map_ops *get_dma_ops(struct device *dev)
264{
265 if (dev && dev->dma_ops)
266 return dev->dma_ops;
267 return get_arch_dma_ops(dev ? dev->bus : NULL);
268}
269
270static inline void set_dma_ops(struct device *dev,
271 const struct dma_map_ops *dma_ops)
272{
273 dev->dma_ops = dma_ops;
274}
275
276static inline dma_addr_t dma_map_page_attrs(struct device *dev,
277 struct page *page, size_t offset, size_t size,
278 enum dma_data_direction dir, unsigned long attrs)
291{279{
292 const struct dma_map_ops *ops = get_dma_ops(dev);280 const struct dma_map_ops *ops = get_dma_ops(dev);
293 dma_addr_t addr;281 dma_addr_t addr;
294 282
295 BUG_ON(!valid_dma_direction(dir));283 BUG_ON(!valid_dma_direction(dir));
296 debug_dma_map_single(dev, ptr, size);
297 if (dma_is_direct(ops))284 if (dma_is_direct(ops))
298 addr = dma_direct_map_page(dev, virt_to_page(ptr),285 addr = dma_direct_map_page(dev, page, offset, size, dir, attrs);
299 offset_in_page(ptr), size, dir, attrs);
300 else286 else
301 addr = ops->map_page(dev, virt_to_page(ptr),287 addr = ops->map_page(dev, page, offset, size, dir, attrs);
302 offset_in_page(ptr), size, dir, attrs);288 debug_dma_map_page(dev, page, offset, size, dir, addr);
303 debug_dma_map_page(dev, virt_to_page(ptr),289
304 offset_in_page(ptr), size,
305 dir, addr, true);
306 return addr;290 return addr;
307}291}
308 292
309static inline void dma_unmap_single_attrs(struct device *dev, dma_addr_t addr,293static inline void dma_unmap_page_attrs(struct device *dev, dma_addr_t addr,
310 size_t size,294 size_t size, enum dma_data_direction dir, unsigned long attrs)
311 enum dma_data_direction dir,
312 unsigned long attrs)
313{295{
314 const struct dma_map_ops *ops = get_dma_ops(dev);296 const struct dma_map_ops *ops = get_dma_ops(dev);
315 297
@@ -318,13 +300,7 @@ static inline void dma_unmap_single_attrs(struct device *dev, dma_addr_t addr, · 2 unmodified lines
318 dma_direct_unmap_page(dev, addr, size, dir, attrs);300 dma_direct_unmap_page(dev, addr, size, dir, attrs);
319 else if (ops->unmap_page)301 else if (ops->unmap_page)
320 ops->unmap_page(dev, addr, size, dir, attrs);302 ops->unmap_page(dev, addr, size, dir, attrs);
321 debug_dma_unmap_page(dev, addr, size, dir, true);303 debug_dma_unmap_page(dev, addr, size, dir);
322}
323
324static inline void dma_unmap_page_attrs(struct device *dev, dma_addr_t addr,
325 size_t size, enum dma_data_direction dir, unsigned long attrs)
326{
327 return dma_unmap_single_attrs(dev, addr, size, dir, attrs);
328}304}
329 305
330/*306/*
@@ -363,25 +339,6 @@ static inline void dma_unmap_sg_attrs(struct device *dev, struct scatterlist *sg · 32 unmodified lines
363 ops->unmap_sg(dev, sg, nents, dir, attrs);339 ops->unmap_sg(dev, sg, nents, dir, attrs);
364}340}
365 341
366static inline dma_addr_t dma_map_page_attrs(struct device *dev,
367 struct page *page,
368 size_t offset, size_t size,
369 enum dma_data_direction dir,
370 unsigned long attrs)
371{
372 const struct dma_map_ops *ops = get_dma_ops(dev);
373 dma_addr_t addr;
374
375 BUG_ON(!valid_dma_direction(dir));
376 if (dma_is_direct(ops))
377 addr = dma_direct_map_page(dev, page, offset, size, dir, attrs);
378 else
379 addr = ops->map_page(dev, page, offset, size, dir, attrs);
380 debug_dma_map_page(dev, page, offset, size, dir, addr, false);
381
382 return addr;
383}
384
385static inline dma_addr_t dma_map_resource(struct device *dev,342static inline dma_addr_t dma_map_resource(struct device *dev,
386 phys_addr_t phys_addr,343 phys_addr_t phys_addr,
387 size_t size,344 size_t size,
@@ -431,13 +388,6 @@ static inline void dma_sync_single_for_cpu(struct device *dev, dma_addr_t addr, · 43 unmodified lines
431 debug_dma_sync_single_for_cpu(dev, addr, size, dir);388 debug_dma_sync_single_for_cpu(dev, addr, size, dir);
432}389}
433 390
434static inline void dma_sync_single_range_for_cpu(struct device *dev,
435 dma_addr_t addr, unsigned long offset, size_t size,
436 enum dma_data_direction dir)
437{
438 return dma_sync_single_for_cpu(dev, addr + offset, size, dir);
439}
440
441static inline void dma_sync_single_for_device(struct device *dev,391static inline void dma_sync_single_for_device(struct device *dev,
442 dma_addr_t addr, size_t size,392 dma_addr_t addr, size_t size,
443 enum dma_data_direction dir)393 enum dma_data_direction dir)
@@ -452,13 +402,6 @@ static inline void dma_sync_single_for_device(struct device *dev, · 8 unmodified lines
452 debug_dma_sync_single_for_device(dev, addr, size, dir);402 debug_dma_sync_single_for_device(dev, addr, size, dir);
453}403}
454 404
455static inline void dma_sync_single_range_for_device(struct device *dev,
456 dma_addr_t addr, unsigned long offset, size_t size,
457 enum dma_data_direction dir)
458{
459 return dma_sync_single_for_device(dev, addr + offset, size, dir);
460}
461
462static inline void405static inline void
463dma_sync_sg_for_cpu(struct device *dev, struct scatterlist *sg,406dma_sync_sg_for_cpu(struct device *dev, struct scatterlist *sg,
464 int nelems, enum dma_data_direction dir)407 int nelems, enum dma_data_direction dir)
@@ -488,15 +431,174 @@ dma_sync_sg_for_device(struct device *dev, struct scatterlist *sg, · 23 unmodified lines
488 431
489}432}
490 433
434static inline int dma_mapping_error(struct device *dev, dma_addr_t dma_addr)
435{
436 debug_dma_mapping_error(dev, dma_addr);
437
438 if (dma_addr == DMA_MAPPING_ERROR)
439 return -ENOMEM;
440 return 0;
441}
442
443void *dma_alloc_attrs(struct device *dev, size_t size, dma_addr_t *dma_handle,
444 gfp_t flag, unsigned long attrs);
445void dma_free_attrs(struct device *dev, size_t size, void *cpu_addr,
446 dma_addr_t dma_handle, unsigned long attrs);
447void *dmam_alloc_attrs(struct device *dev, size_t size, dma_addr_t *dma_handle,
448 gfp_t gfp, unsigned long attrs);
449void dmam_free_coherent(struct device *dev, size_t size, void *vaddr,
450 dma_addr_t dma_handle);
451void dma_cache_sync(struct device *dev, void *vaddr, size_t size,
452 enum dma_data_direction dir);
453int dma_get_sgtable_attrs(struct device *dev, struct sg_table *sgt,
454 void *cpu_addr, dma_addr_t dma_addr, size_t size,
455 unsigned long attrs);
456int dma_mmap_attrs(struct device *dev, struct vm_area_struct *vma,
457 void *cpu_addr, dma_addr_t dma_addr, size_t size,
458 unsigned long attrs);
459int dma_supported(struct device *dev, u64 mask);
460int dma_set_mask(struct device *dev, u64 mask);
461int dma_set_coherent_mask(struct device *dev, u64 mask);
462u64 dma_get_required_mask(struct device *dev);
463#else /* CONFIG_HAS_DMA */
464static inline dma_addr_t dma_map_page_attrs(struct device *dev,
465 struct page *page, size_t offset, size_t size,
466 enum dma_data_direction dir, unsigned long attrs)
467{
468 return DMA_MAPPING_ERROR;
469}
470static inline void dma_unmap_page_attrs(struct device *dev, dma_addr_t addr,
471 size_t size, enum dma_data_direction dir, unsigned long attrs)
472{
473}
474static inline int dma_map_sg_attrs(struct device *dev, struct scatterlist *sg,
475 int nents, enum dma_data_direction dir, unsigned long attrs)
476{
477 return 0;
478}
479static inline void dma_unmap_sg_attrs(struct device *dev,
480 struct scatterlist *sg, int nents, enum dma_data_direction dir,
481 unsigned long attrs)
482{
483}
484static inline dma_addr_t dma_map_resource(struct device *dev,
485 phys_addr_t phys_addr, size_t size, enum dma_data_direction dir,
486 unsigned long attrs)
487{
488 return DMA_MAPPING_ERROR;
489}
490static inline void dma_unmap_resource(struct device *dev, dma_addr_t addr,
491 size_t size, enum dma_data_direction dir, unsigned long attrs)
492{
493}
494static inline void dma_sync_single_for_cpu(struct device *dev, dma_addr_t addr,
495 size_t size, enum dma_data_direction dir)
496{
497}
498static inline void dma_sync_single_for_device(struct device *dev,
499 dma_addr_t addr, size_t size, enum dma_data_direction dir)
500{
501}
502static inline void dma_sync_sg_for_cpu(struct device *dev,
503 struct scatterlist *sg, int nelems, enum dma_data_direction dir)
504{
505}
506static inline void dma_sync_sg_for_device(struct device *dev,
507 struct scatterlist *sg, int nelems, enum dma_data_direction dir)
508{
509}
510static inline int dma_mapping_error(struct device *dev, dma_addr_t dma_addr)
511{
512 return -ENOMEM;
513}
514static inline void *dma_alloc_attrs(struct device *dev, size_t size,
515 dma_addr_t *dma_handle, gfp_t flag, unsigned long attrs)
516{
517 return NULL;
518}
519static void dma_free_attrs(struct device *dev, size_t size, void *cpu_addr,
520 dma_addr_t dma_handle, unsigned long attrs)
521{
522}
523static inline void *dmam_alloc_attrs(struct device *dev, size_t size,
524 dma_addr_t *dma_handle, gfp_t gfp, unsigned long attrs)
525{
526 return NULL;
527}
528static inline void dmam_free_coherent(struct device *dev, size_t size,
529 void *vaddr, dma_addr_t dma_handle)
530{
531}
532static inline void dma_cache_sync(struct device *dev, void *vaddr, size_t size,
533 enum dma_data_direction dir)
534{
535}
536static inline int dma_get_sgtable_attrs(struct device *dev,
537 struct sg_table *sgt, void *cpu_addr, dma_addr_t dma_addr,
538 size_t size, unsigned long attrs)
539{
540 return -ENXIO;
541}
542static inline int dma_mmap_attrs(struct device *dev, struct vm_area_struct *vma,
543 void *cpu_addr, dma_addr_t dma_addr, size_t size,
544 unsigned long attrs)
545{
546 return -ENXIO;
547}
548static inline int dma_supported(struct device *dev, u64 mask)
549{
550 return 0;
551}
552static inline int dma_set_mask(struct device *dev, u64 mask)
553{
554 return -EIO;
555}
556static inline int dma_set_coherent_mask(struct device *dev, u64 mask)
557{
558 return -EIO;
559}
560static inline u64 dma_get_required_mask(struct device *dev)
561{
562 return 0;
563}
564#endif /* CONFIG_HAS_DMA */
565
566static inline dma_addr_t dma_map_single_attrs(struct device *dev, void *ptr,
567 size_t size, enum dma_data_direction dir, unsigned long attrs)
568{
569 debug_dma_map_single(dev, ptr, size);
570 return dma_map_page_attrs(dev, virt_to_page(ptr), offset_in_page(ptr),
571 size, dir, attrs);
572}
573
574static inline void dma_unmap_single_attrs(struct device *dev, dma_addr_t addr,
575 size_t size, enum dma_data_direction dir, unsigned long attrs)
576{
577 return dma_unmap_page_attrs(dev, addr, size, dir, attrs);
578}
579
580static inline void dma_sync_single_range_for_cpu(struct device *dev,
581 dma_addr_t addr, unsigned long offset, size_t size,
582 enum dma_data_direction dir)
583{
584 return dma_sync_single_for_cpu(dev, addr + offset, size, dir);
585}
586
587static inline void dma_sync_single_range_for_device(struct device *dev,
588 dma_addr_t addr, unsigned long offset, size_t size,
589 enum dma_data_direction dir)
590{
591 return dma_sync_single_for_device(dev, addr + offset, size, dir);
592}
593
491#define dma_map_single(d, a, s, r) dma_map_single_attrs(d, a, s, r, 0)594#define dma_map_single(d, a, s, r) dma_map_single_attrs(d, a, s, r, 0)
492#define dma_unmap_single(d, a, s, r) dma_unmap_single_attrs(d, a, s, r, 0)595#define dma_unmap_single(d, a, s, r) dma_unmap_single_attrs(d, a, s, r, 0)
493#define dma_map_sg(d, s, n, r) dma_map_sg_attrs(d, s, n, r, 0)596#define dma_map_sg(d, s, n, r) dma_map_sg_attrs(d, s, n, r, 0)
494#define dma_unmap_sg(d, s, n, r) dma_unmap_sg_attrs(d, s, n, r, 0)597#define dma_unmap_sg(d, s, n, r) dma_unmap_sg_attrs(d, s, n, r, 0)
495#define dma_map_page(d, p, o, s, r) dma_map_page_attrs(d, p, o, s, r, 0)598#define dma_map_page(d, p, o, s, r) dma_map_page_attrs(d, p, o, s, r, 0)
496#define dma_unmap_page(d, a, s, r) dma_unmap_page_attrs(d, a, s, r, 0)599#define dma_unmap_page(d, a, s, r) dma_unmap_page_attrs(d, a, s, r, 0)
497 600#define dma_get_sgtable(d, t, v, h, s) dma_get_sgtable_attrs(d, t, v, h, s, 0)
498void dma_cache_sync(struct device *dev, void *vaddr, size_t size,601#define dma_mmap_coherent(d, v, c, h, s) dma_mmap_attrs(d, v, c, h, s, 0)
499 enum dma_data_direction dir);
500 602
501extern int dma_common_mmap(struct device *dev, struct vm_area_struct *vma,603extern int dma_common_mmap(struct device *dev, struct vm_area_struct *vma,
502 void *cpu_addr, dma_addr_t dma_addr, size_t size,604 void *cpu_addr, dma_addr_t dma_addr, size_t size,
@@ -516,25 +618,10 @@ bool dma_in_atomic_pool(void *start, size_t size); · 13 unmodified lines
516void *dma_alloc_from_pool(size_t size, struct page **ret_page, gfp_t flags);618void *dma_alloc_from_pool(size_t size, struct page **ret_page, gfp_t flags);
517bool dma_free_from_pool(void *start, size_t size);619bool dma_free_from_pool(void *start, size_t size);
518 620
519int dma_mmap_attrs(struct device *dev, struct vm_area_struct *vma,
520 void *cpu_addr, dma_addr_t dma_addr, size_t size,
521 unsigned long attrs);
522#define dma_mmap_coherent(d, v, c, h, s) dma_mmap_attrs(d, v, c, h, s, 0)
523
524int621int
525dma_common_get_sgtable(struct device *dev, struct sg_table *sgt, void *cpu_addr,622dma_common_get_sgtable(struct device *dev, struct sg_table *sgt, void *cpu_addr,
526 dma_addr_t dma_addr, size_t size, unsigned long attrs);623 dma_addr_t dma_addr, size_t size, unsigned long attrs);
527 624
528int dma_get_sgtable_attrs(struct device *dev, struct sg_table *sgt,
529 void *cpu_addr, dma_addr_t dma_addr, size_t size,
530 unsigned long attrs);
531#define dma_get_sgtable(d, t, v, h, s) dma_get_sgtable_attrs(d, t, v, h, s, 0)
532
533void *dma_alloc_attrs(struct device *dev, size_t size, dma_addr_t *dma_handle,
534 gfp_t flag, unsigned long attrs);
535void dma_free_attrs(struct device *dev, size_t size, void *cpu_addr,
536 dma_addr_t dma_handle, unsigned long attrs);
537
538static inline void *dma_alloc_coherent(struct device *dev, size_t size,625static inline void *dma_alloc_coherent(struct device *dev, size_t size,
539 dma_addr_t *dma_handle, gfp_t gfp)626 dma_addr_t *dma_handle, gfp_t gfp)
540{627{
@@ -549,18 +636,6 @@ static inline void dma_free_coherent(struct device *dev, size_t size, · 8 unmodified lines
549 return dma_free_attrs(dev, size, cpu_addr, dma_handle, 0);636 return dma_free_attrs(dev, size, cpu_addr, dma_handle, 0);
550}637}
551 638
552static inline int dma_mapping_error(struct device *dev, dma_addr_t dma_addr)
553{
554 debug_dma_mapping_error(dev, dma_addr);
555
556 if (dma_addr == DMA_MAPPING_ERROR)
557 return -ENOMEM;
558 return 0;
559}
560
561int dma_supported(struct device *dev, u64 mask);
562int dma_set_mask(struct device *dev, u64 mask);
563int dma_set_coherent_mask(struct device *dev, u64 mask);
564 639
565static inline u64 dma_get_mask(struct device *dev)640static inline u64 dma_get_mask(struct device *dev)
566{641{
@@ -593,8 +668,6 @@ static inline int dma_coerce_mask_and_coherent(struct device *dev, u64 mask) · 26 unmodified lines
593 return dma_set_mask_and_coherent(dev, mask);668 return dma_set_mask_and_coherent(dev, mask);
594}669}
595 670
596extern u64 dma_get_required_mask(struct device *dev);
597
598#ifndef arch_setup_dma_ops671#ifndef arch_setup_dma_ops
599static inline void arch_setup_dma_ops(struct device *dev, u64 dma_base,672static inline void arch_setup_dma_ops(struct device *dev, u64 dma_base,
600 u64 size, const struct iommu_ops *iommu,673 u64 size, const struct iommu_ops *iommu,
@@ -691,43 +764,12 @@ dma_mark_declared_memory_occupied(struct device *dev, · 90 unmodified lines
691}764}
692#endif /* CONFIG_HAVE_GENERIC_DMA_COHERENT */765#endif /* CONFIG_HAVE_GENERIC_DMA_COHERENT */
693 766
694/*
695 * Managed DMA API
696 */
697#ifdef CONFIG_HAS_DMA
698extern void *dmam_alloc_coherent(struct device *dev, size_t size,
699 dma_addr_t *dma_handle, gfp_t gfp);
700extern void dmam_free_coherent(struct device *dev, size_t size, void *vaddr,
701 dma_addr_t dma_handle);
702#else /* !CONFIG_HAS_DMA */
703static inline void *dmam_alloc_coherent(struct device *dev, size_t size,767static inline void *dmam_alloc_coherent(struct device *dev, size_t size,
704 dma_addr_t *dma_handle, gfp_t gfp)768 dma_addr_t *dma_handle, gfp_t gfp)
705{ return NULL; }
706static inline void dmam_free_coherent(struct device *dev, size_t size,
707 void *vaddr, dma_addr_t dma_handle) { }
708#endif /* !CONFIG_HAS_DMA */
709
710extern void *dmam_alloc_attrs(struct device *dev, size_t size,
711 dma_addr_t *dma_handle, gfp_t gfp,
712 unsigned long attrs);
713#ifdef CONFIG_HAVE_GENERIC_DMA_COHERENT
714extern int dmam_declare_coherent_memory(struct device *dev,
715 phys_addr_t phys_addr,
716 dma_addr_t device_addr, size_t size,
717 int flags);
718extern void dmam_release_declared_memory(struct device *dev);
719#else /* CONFIG_HAVE_GENERIC_DMA_COHERENT */
720static inline int dmam_declare_coherent_memory(struct device *dev,
721 phys_addr_t phys_addr, dma_addr_t device_addr,
722 size_t size, gfp_t gfp)
723{
724 return 0;
725}
726
727static inline void dmam_release_declared_memory(struct device *dev)
728{769{
770 return dmam_alloc_attrs(dev, size, dma_handle, gfp,
771 (gfp & __GFP_NOWARN) ? DMA_ATTR_NO_WARN : 0);
729}772}
730#endif /* CONFIG_HAVE_GENERIC_DMA_COHERENT */
731 773
732static inline void *dma_alloc_wc(struct device *dev, size_t size,774static inline void *dma_alloc_wc(struct device *dev, size_t size,
733 dma_addr_t *dma_addr, gfp_t gfp)775 dma_addr_t *dma_addr, gfp_t gfp)

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t