1 /* SPDX-License-Identifier: GPL-2.0 */ 1 /* SPDX-License-Identifier: GPL-2.0 */ 2 /* << 3 * Internals of the DMA direct mapping impleme << 4 * DMA mapping code and IOMMU drivers. << 5 */ << 6 #ifndef _LINUX_DMA_DIRECT_H 2 #ifndef _LINUX_DMA_DIRECT_H 7 #define _LINUX_DMA_DIRECT_H 1 3 #define _LINUX_DMA_DIRECT_H 1 8 4 9 #include <linux/dma-mapping.h> 5 #include <linux/dma-mapping.h> 10 #include <linux/dma-map-ops.h> << 11 #include <linux/memblock.h> /* for min_low_pfn << 12 #include <linux/mem_encrypt.h> 6 #include <linux/mem_encrypt.h> 13 #include <linux/swiotlb.h> << 14 << 15 extern unsigned int zone_dma_bits; << 16 << 17 /* << 18 * Record the mapping of CPU physical to DMA a << 19 */ << 20 struct bus_dma_region { << 21 phys_addr_t cpu_start; << 22 dma_addr_t dma_start; << 23 u64 size; << 24 }; << 25 7 26 static inline dma_addr_t translate_phys_to_dma !! 8 #ifdef CONFIG_ARCH_HAS_PHYS_TO_DMA 27 phys_addr_t paddr) !! 9 #include <asm/dma-direct.h> 28 { !! 10 #else 29 const struct bus_dma_region *m; !! 11 static inline dma_addr_t __phys_to_dma(struct device *dev, phys_addr_t paddr) 30 << 31 for (m = dev->dma_range_map; m->size; << 32 u64 offset = paddr - m->cpu_st << 33 << 34 if (paddr >= m->cpu_start && o << 35 return m->dma_start + << 36 } << 37 << 38 /* make sure dma_capable fails when no << 39 return DMA_MAPPING_ERROR; << 40 } << 41 << 42 static inline phys_addr_t translate_dma_to_phy << 43 dma_addr_t dma_addr) << 44 { 12 { 45 const struct bus_dma_region *m; !! 13 dma_addr_t dev_addr = (dma_addr_t)paddr; 46 << 47 for (m = dev->dma_range_map; m->size; << 48 u64 offset = dma_addr - m->dma << 49 14 50 if (dma_addr >= m->dma_start & !! 15 return dev_addr - ((dma_addr_t)dev->dma_pfn_offset << PAGE_SHIFT); 51 return m->cpu_start + << 52 } << 53 << 54 return (phys_addr_t)-1; << 55 } 16 } 56 17 57 static inline dma_addr_t dma_range_map_min(con !! 18 static inline phys_addr_t __dma_to_phys(struct device *dev, dma_addr_t dev_addr) 58 { 19 { 59 dma_addr_t ret = (dma_addr_t)U64_MAX; !! 20 phys_addr_t paddr = (phys_addr_t)dev_addr; 60 21 61 for (; map->size; map++) !! 22 return paddr + ((phys_addr_t)dev->dma_pfn_offset << PAGE_SHIFT); 62 ret = min(ret, map->dma_start) << 63 return ret; << 64 } 23 } 65 24 66 static inline dma_addr_t dma_range_map_max(con !! 25 static inline bool dma_capable(struct device *dev, dma_addr_t addr, size_t size) 67 { 26 { 68 dma_addr_t ret = 0; !! 27 if (!dev->dma_mask) >> 28 return false; 69 29 70 for (; map->size; map++) !! 30 return addr + size - 1 <= 71 ret = max(ret, map->dma_start !! 31 min_not_zero(*dev->dma_mask, dev->bus_dma_mask); 72 return ret; << 73 } << 74 << 75 #ifdef CONFIG_ARCH_HAS_PHYS_TO_DMA << 76 #include <asm/dma-direct.h> << 77 #ifndef phys_to_dma_unencrypted << 78 #define phys_to_dma_unencrypted phys_t << 79 #endif << 80 #else << 81 static inline dma_addr_t phys_to_dma_unencrypt << 82 phys_addr_t paddr) << 83 { << 84 if (dev->dma_range_map) << 85 return translate_phys_to_dma(d << 86 return paddr; << 87 } 32 } >> 33 #endif /* !CONFIG_ARCH_HAS_PHYS_TO_DMA */ 88 34 89 /* 35 /* 90 * If memory encryption is supported, phys_to_ 36 * If memory encryption is supported, phys_to_dma will set the memory encryption 91 * bit in the DMA address, and dma_to_phys wil !! 37 * bit in the DMA address, and dma_to_phys will clear it. The raw __phys_to_dma 92 * phys_to_dma_unencrypted is for use on speci !! 38 * and __dma_to_phys versions should only be used on non-encrypted memory for 93 * buffers. !! 39 * special occasions like DMA coherent buffers. 94 */ 40 */ 95 static inline dma_addr_t phys_to_dma(struct de 41 static inline dma_addr_t phys_to_dma(struct device *dev, phys_addr_t paddr) 96 { 42 { 97 return __sme_set(phys_to_dma_unencrypt !! 43 return __sme_set(__phys_to_dma(dev, paddr)); 98 } << 99 << 100 static inline phys_addr_t dma_to_phys(struct d << 101 { << 102 phys_addr_t paddr; << 103 << 104 if (dev->dma_range_map) << 105 paddr = translate_dma_to_phys( << 106 else << 107 paddr = dma_addr; << 108 << 109 return __sme_clr(paddr); << 110 } << 111 #endif /* !CONFIG_ARCH_HAS_PHYS_TO_DMA */ << 112 << 113 #ifdef CONFIG_ARCH_HAS_FORCE_DMA_UNENCRYPTED << 114 bool force_dma_unencrypted(struct device *dev) << 115 #else << 116 static inline bool force_dma_unencrypted(struc << 117 { << 118 return false; << 119 } 44 } 120 #endif /* CONFIG_ARCH_HAS_FORCE_DMA_UNENCRYPTE << 121 45 122 static inline bool dma_capable(struct device * !! 46 static inline phys_addr_t dma_to_phys(struct device *dev, dma_addr_t daddr) 123 bool is_ram) << 124 { 47 { 125 dma_addr_t end = addr + size - 1; !! 48 return __sme_clr(__dma_to_phys(dev, daddr)); 126 << 127 if (addr == DMA_MAPPING_ERROR) << 128 return false; << 129 if (is_ram && !IS_ENABLED(CONFIG_ARCH_ << 130 min(addr, end) < phys_to_dma(dev, << 131 return false; << 132 << 133 return end <= min_not_zero(*dev->dma_m << 134 } 49 } 135 50 136 u64 dma_direct_get_required_mask(struct device 51 u64 dma_direct_get_required_mask(struct device *dev); 137 void *dma_direct_alloc(struct device *dev, siz 52 void *dma_direct_alloc(struct device *dev, size_t size, dma_addr_t *dma_handle, 138 gfp_t gfp, unsigned long attrs 53 gfp_t gfp, unsigned long attrs); 139 void dma_direct_free(struct device *dev, size_ 54 void dma_direct_free(struct device *dev, size_t size, void *cpu_addr, 140 dma_addr_t dma_addr, unsigned 55 dma_addr_t dma_addr, unsigned long attrs); 141 struct page *dma_direct_alloc_pages(struct dev !! 56 void *dma_direct_alloc_pages(struct device *dev, size_t size, 142 dma_addr_t *dma_handle, enum d !! 57 dma_addr_t *dma_handle, gfp_t gfp, unsigned long attrs); 143 void dma_direct_free_pages(struct device *dev, !! 58 void dma_direct_free_pages(struct device *dev, size_t size, void *cpu_addr, 144 struct page *page, dma_addr_t !! 59 dma_addr_t dma_addr, unsigned long attrs); 145 enum dma_data_direction dir); !! 60 struct page *__dma_direct_alloc_pages(struct device *dev, size_t size, >> 61 dma_addr_t *dma_handle, gfp_t gfp, unsigned long attrs); >> 62 void __dma_direct_free_pages(struct device *dev, size_t size, struct page *page); 146 int dma_direct_supported(struct device *dev, u 63 int dma_direct_supported(struct device *dev, u64 mask); 147 dma_addr_t dma_direct_map_resource(struct devi << 148 size_t size, enum dma_data_dir << 149 << 150 #endif /* _LINUX_DMA_DIRECT_H */ 64 #endif /* _LINUX_DMA_DIRECT_H */ 151 65
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.