include/linux/swiotlb.h

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 #ifndef __LINUX_SWIOTLB_H
   3 #define __LINUX_SWIOTLB_H
   4
   5 #include <linux/device.h>
   6 #include <linux/dma-direction.h>
   7 #include <linux/init.h>
   8 #include <linux/types.h>
   9 #include <linux/limits.h>
  10 #include <linux/spinlock.h>
  11
  12 struct device;
  13 struct page;
  14 struct scatterlist;
  15
  16 #define SWIOTLB_VERBOSE (1 << 0) /* verbose initialization */
  17 #define SWIOTLB_FORCE   (1 << 1) /* force bounce buffering */
  18 #define SWIOTLB_ANY     (1 << 2) /* allow any memory for the buffer */
  19
  20 /*
  21  * Maximum allowable number of contiguous slabs to map,
  22  * must be a power of 2.  What is the appropriate value ?
  23  * The complexity of {map,unmap}_single is linearly dependent on this value.
  24  */
  25 #define IO_TLB_SEGSIZE  128
  26
  27 /*
  28  * log of the size of each IO TLB slab.  The number of slabs is command line
  29  * controllable.
  30  */
  31 #define IO_TLB_SHIFT 11
  32 #define IO_TLB_SIZE (1 << IO_TLB_SHIFT)
  33
  34 /* default to 64MB */
  35 #define IO_TLB_DEFAULT_SIZE (64UL<<20)
  36
  37 unsigned long swiotlb_size_or_default(void);
  38 void __init swiotlb_init_remap(bool addressing_limit, unsigned int flags,
  39         int (*remap)(void *tlb, unsigned long nslabs));
  40 int swiotlb_init_late(size_t size, gfp_t gfp_mask,
  41         int (*remap)(void *tlb, unsigned long nslabs));
  42 extern void __init swiotlb_update_mem_attributes(void);
  43
  44 phys_addr_t swiotlb_tbl_map_single(struct device *hwdev, phys_addr_t phys,
  45                 size_t mapping_size, size_t alloc_size,
  46                 unsigned int alloc_aligned_mask, enum dma_data_direction dir,
  47                 unsigned long attrs);
  48
  49 extern void swiotlb_tbl_unmap_single(struct device *hwdev,
  50                                      phys_addr_t tlb_addr,
  51                                      size_t mapping_size,
  52                                      enum dma_data_direction dir,
  53                                      unsigned long attrs);
  54
  55 void swiotlb_sync_single_for_device(struct device *dev, phys_addr_t tlb_addr,
  56                 size_t size, enum dma_data_direction dir);
  57 void swiotlb_sync_single_for_cpu(struct device *dev, phys_addr_t tlb_addr,
  58                 size_t size, enum dma_data_direction dir);
  59 dma_addr_t swiotlb_map(struct device *dev, phys_addr_t phys,
  60                 size_t size, enum dma_data_direction dir, unsigned long attrs);
  61
  62 #ifdef CONFIG_SWIOTLB
  63
  64 /**
  65  * struct io_tlb_mem - IO TLB Memory Pool Descriptor
  66  *
  67  * @start:      The start address of the swiotlb memory pool. Used to do a quick
  68  *              range check to see if the memory was in fact allocated by this
  69  *              API.
  70  * @end:        The end address of the swiotlb memory pool. Used to do a quick
  71  *              range check to see if the memory was in fact allocated by this
  72  *              API.
  73  * @vaddr:      The vaddr of the swiotlb memory pool. The swiotlb memory pool
  74  *              may be remapped in the memory encrypted case and store virtual
  75  *              address for bounce buffer operation.
  76  * @nslabs:     The number of IO TLB blocks (in groups of 64) between @start and
  77  *              @end. For default swiotlb, this is command line adjustable via
  78  *              setup_io_tlb_npages.
  79  * @used:       The number of used IO TLB block.
  80  * @list:       The free list describing the number of free entries available
  81  *              from each index.
  82  * @orig_addr:  The original address corresponding to a mapped entry.
  83  * @alloc_size: Size of the allocated buffer.
  84  * @debugfs:    The dentry to debugfs.
  85  * @late_alloc: %true if allocated using the page allocator
  86  * @force_bounce: %true if swiotlb bouncing is forced
  87  * @for_alloc:  %true if the pool is used for memory allocation
  88  * @nareas:  The area number in the pool.
  89  * @area_nslabs: The slot number in the area.
  90  * @total_used: The total number of slots in the pool that are currently used
  91  *              across all areas. Used only for calculating used_hiwater in
  92  *              debugfs.
  93  * @used_hiwater: The high water mark for total_used.  Used only for reporting
  94  *              in debugfs.
  95  */
  96 struct io_tlb_mem {
  97         phys_addr_t start;
  98         phys_addr_t end;
  99         void *vaddr;
 100         unsigned long nslabs;
 101         unsigned long used;
 102         struct dentry *debugfs;
 103         bool late_alloc;
 104         bool force_bounce;
 105         bool for_alloc;
 106         unsigned int nareas;
 107         unsigned int area_nslabs;
 108         struct io_tlb_area *areas;
 109         struct io_tlb_slot *slots;
 110 #ifdef CONFIG_DEBUG_FS
 111         atomic_long_t total_used;
 112         atomic_long_t used_hiwater;
 113 #endif
 114 };
 115 extern struct io_tlb_mem io_tlb_default_mem;
 116
 117 static inline bool is_swiotlb_buffer(struct device *dev, phys_addr_t paddr)
 118 {
 119         struct io_tlb_mem *mem = dev->dma_io_tlb_mem;
 120
 121         return mem && paddr >= mem->start && paddr < mem->end;
 122 }
 123
 124 static inline bool is_swiotlb_force_bounce(struct device *dev)
 125 {
 126         struct io_tlb_mem *mem = dev->dma_io_tlb_mem;
 127
 128         return mem && mem->force_bounce;
 129 }
 130
 131 void swiotlb_init(bool addressing_limited, unsigned int flags);
 132 void __init swiotlb_exit(void);
 133 size_t swiotlb_max_mapping_size(struct device *dev);
 134 bool is_swiotlb_active(struct device *dev);
 135 void __init swiotlb_adjust_size(unsigned long size);
 136 #else
 137 static inline void swiotlb_init(bool addressing_limited, unsigned int flags)
 138 {
 139 }
 140 static inline bool is_swiotlb_buffer(struct device *dev, phys_addr_t paddr)
 141 {
 142         return false;
 143 }
 144 static inline bool is_swiotlb_force_bounce(struct device *dev)
 145 {
 146         return false;
 147 }
 148 static inline void swiotlb_exit(void)
 149 {
 150 }
 151 static inline size_t swiotlb_max_mapping_size(struct device *dev)
 152 {
 153         return SIZE_MAX;
 154 }
 155
 156 static inline bool is_swiotlb_active(struct device *dev)
 157 {
 158         return false;
 159 }
 160
 161 static inline void swiotlb_adjust_size(unsigned long size)
 162 {
 163 }
 164 #endif /* CONFIG_SWIOTLB */
 165
 166 extern void swiotlb_print_info(void);
 167
 168 #ifdef CONFIG_DMA_RESTRICTED_POOL
 169 struct page *swiotlb_alloc(struct device *dev, size_t size);
 170 bool swiotlb_free(struct device *dev, struct page *page, size_t size);
 171
 172 static inline bool is_swiotlb_for_alloc(struct device *dev)
 173 {
 174         return dev->dma_io_tlb_mem->for_alloc;
 175 }
 176 #else
 177 static inline struct page *swiotlb_alloc(struct device *dev, size_t size)
 178 {
 179         return NULL;
 180 }
 181 static inline bool swiotlb_free(struct device *dev, struct page *page,
 182                                 size_t size)
 183 {
 184         return false;
 185 }
 186 static inline bool is_swiotlb_for_alloc(struct device *dev)
 187 {
 188         return false;
 189 }
 190 #endif /* CONFIG_DMA_RESTRICTED_POOL */
 191
 192 #endif /* __LINUX_SWIOTLB_H */