dma-mapping.h 4.4 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176
  1. #ifndef _ASM_X86_DMA_MAPPING_H
  2. #define _ASM_X86_DMA_MAPPING_H
  3. /*
  4. * IOMMU interface. See Documentation/DMA-API-HOWTO.txt and
  5. * Documentation/DMA-API.txt for documentation.
  6. */
  7. #include <linux/kmemcheck.h>
  8. #include <linux/scatterlist.h>
  9. #include <linux/dma-debug.h>
  10. #include <linux/dma-attrs.h>
  11. #include <asm/io.h>
  12. #include <asm/swiotlb.h>
  13. #include <asm-generic/dma-coherent.h>
  14. #include <linux/dma-contiguous.h>
  15. #ifdef CONFIG_ISA
  16. # define ISA_DMA_BIT_MASK DMA_BIT_MASK(24)
  17. #else
  18. # define ISA_DMA_BIT_MASK DMA_BIT_MASK(32)
  19. #endif
  20. #define DMA_ERROR_CODE 0
  21. extern int iommu_merge;
  22. extern struct device x86_dma_fallback_dev;
  23. extern int panic_on_overflow;
  24. extern struct dma_map_ops *dma_ops;
  25. static inline struct dma_map_ops *get_dma_ops(struct device *dev)
  26. {
  27. #ifndef CONFIG_X86_DEV_DMA_OPS
  28. return dma_ops;
  29. #else
  30. if (unlikely(!dev) || !dev->archdata.dma_ops)
  31. return dma_ops;
  32. else
  33. return dev->archdata.dma_ops;
  34. #endif
  35. }
  36. #include <asm-generic/dma-mapping-common.h>
  37. /* Make sure we keep the same behaviour */
  38. static inline int dma_mapping_error(struct device *dev, dma_addr_t dma_addr)
  39. {
  40. struct dma_map_ops *ops = get_dma_ops(dev);
  41. debug_dma_mapping_error(dev, dma_addr);
  42. if (ops->mapping_error)
  43. return ops->mapping_error(dev, dma_addr);
  44. return (dma_addr == DMA_ERROR_CODE);
  45. }
  46. #define dma_alloc_noncoherent(d, s, h, f) dma_alloc_coherent(d, s, h, f)
  47. #define dma_free_noncoherent(d, s, v, h) dma_free_coherent(d, s, v, h)
  48. extern int dma_supported(struct device *hwdev, u64 mask);
  49. extern int dma_set_mask(struct device *dev, u64 mask);
  50. extern void *dma_generic_alloc_coherent(struct device *dev, size_t size,
  51. dma_addr_t *dma_addr, gfp_t flag,
  52. struct dma_attrs *attrs);
  53. extern void dma_generic_free_coherent(struct device *dev, size_t size,
  54. void *vaddr, dma_addr_t dma_addr,
  55. struct dma_attrs *attrs);
  56. #ifdef CONFIG_X86_DMA_REMAP /* Platform code defines bridge-specific code */
  57. extern bool dma_capable(struct device *dev, dma_addr_t addr, size_t size);
  58. extern dma_addr_t phys_to_dma(struct device *dev, phys_addr_t paddr);
  59. extern phys_addr_t dma_to_phys(struct device *dev, dma_addr_t daddr);
  60. #else
  61. static inline bool dma_capable(struct device *dev, dma_addr_t addr, size_t size)
  62. {
  63. if (!dev->dma_mask)
  64. return 0;
  65. return addr + size - 1 <= *dev->dma_mask;
  66. }
  67. static inline dma_addr_t phys_to_dma(struct device *dev, phys_addr_t paddr)
  68. {
  69. return paddr;
  70. }
  71. static inline phys_addr_t dma_to_phys(struct device *dev, dma_addr_t daddr)
  72. {
  73. return daddr;
  74. }
  75. #endif /* CONFIG_X86_DMA_REMAP */
  76. static inline void
  77. dma_cache_sync(struct device *dev, void *vaddr, size_t size,
  78. enum dma_data_direction dir)
  79. {
  80. flush_write_buffers();
  81. }
  82. static inline unsigned long dma_alloc_coherent_mask(struct device *dev,
  83. gfp_t gfp)
  84. {
  85. unsigned long dma_mask = 0;
  86. dma_mask = dev->coherent_dma_mask;
  87. if (!dma_mask)
  88. dma_mask = (gfp & GFP_DMA) ? DMA_BIT_MASK(24) : DMA_BIT_MASK(32);
  89. return dma_mask;
  90. }
  91. static inline gfp_t dma_alloc_coherent_gfp_flags(struct device *dev, gfp_t gfp)
  92. {
  93. unsigned long dma_mask = dma_alloc_coherent_mask(dev, gfp);
  94. if (dma_mask <= DMA_BIT_MASK(24))
  95. gfp |= GFP_DMA;
  96. #ifdef CONFIG_X86_64
  97. if (dma_mask <= DMA_BIT_MASK(32) && !(gfp & GFP_DMA))
  98. gfp |= GFP_DMA32;
  99. #endif
  100. return gfp;
  101. }
  102. #define dma_alloc_coherent(d,s,h,f) dma_alloc_attrs(d,s,h,f,NULL)
  103. static inline void *
  104. dma_alloc_attrs(struct device *dev, size_t size, dma_addr_t *dma_handle,
  105. gfp_t gfp, struct dma_attrs *attrs)
  106. {
  107. struct dma_map_ops *ops = get_dma_ops(dev);
  108. void *memory;
  109. gfp &= ~(__GFP_DMA | __GFP_HIGHMEM | __GFP_DMA32);
  110. if (dma_alloc_from_coherent(dev, size, dma_handle, &memory))
  111. return memory;
  112. if (!dev)
  113. dev = &x86_dma_fallback_dev;
  114. if (!is_device_dma_capable(dev))
  115. return NULL;
  116. if (!ops->alloc)
  117. return NULL;
  118. memory = ops->alloc(dev, size, dma_handle,
  119. dma_alloc_coherent_gfp_flags(dev, gfp), attrs);
  120. debug_dma_alloc_coherent(dev, size, *dma_handle, memory);
  121. return memory;
  122. }
  123. #define dma_free_coherent(d,s,c,h) dma_free_attrs(d,s,c,h,NULL)
  124. static inline void dma_free_attrs(struct device *dev, size_t size,
  125. void *vaddr, dma_addr_t bus,
  126. struct dma_attrs *attrs)
  127. {
  128. struct dma_map_ops *ops = get_dma_ops(dev);
  129. WARN_ON(irqs_disabled()); /* for portability */
  130. if (dma_release_from_coherent(dev, get_order(size), vaddr))
  131. return;
  132. debug_dma_free_coherent(dev, size, vaddr, bus);
  133. if (ops->free)
  134. ops->free(dev, size, vaddr, bus, attrs);
  135. }
  136. #endif