Branch data     Line data    Source code

       1                 :            : /* SPDX-License-Identifier: GPL-2.0 */
       2                 :            : #ifndef __LINUX_SWIOTLB_H
       3                 :            : #define __LINUX_SWIOTLB_H
       4                 :            : 
       5                 :            : #include <linux/dma-direction.h>
       6                 :            : #include <linux/init.h>
       7                 :            : #include <linux/types.h>
       8                 :            : 
       9                 :            : struct device;
      10                 :            : struct page;
      11                 :            : struct scatterlist;
      12                 :            : 
      13                 :            : enum swiotlb_force {
      14                 :            :         SWIOTLB_NORMAL,         /* Default - depending on HW DMA mask etc. */
      15                 :            :         SWIOTLB_FORCE,          /* swiotlb=force */
      16                 :            :         SWIOTLB_NO_FORCE,       /* swiotlb=noforce */
      17                 :            : };
      18                 :            : 
      19                 :            : /*
      20                 :            :  * Maximum allowable number of contiguous slabs to map,
      21                 :            :  * must be a power of 2.  What is the appropriate value ?
      22                 :            :  * The complexity of {map,unmap}_single is linearly dependent on this value.
      23                 :            :  */
      24                 :            : #define IO_TLB_SEGSIZE  128
      25                 :            : 
      26                 :            : /*
      27                 :            :  * log of the size of each IO TLB slab.  The number of slabs is command line
      28                 :            :  * controllable.
      29                 :            :  */
      30                 :            : #define IO_TLB_SHIFT 11
      31                 :            : 
      32                 :            : extern void swiotlb_init(int verbose);
      33                 :            : int swiotlb_init_with_tbl(char *tlb, unsigned long nslabs, int verbose);
      34                 :            : extern unsigned long swiotlb_nr_tbl(void);
      35                 :            : unsigned long swiotlb_size_or_default(void);
      36                 :            : extern int swiotlb_late_init_with_tbl(char *tlb, unsigned long nslabs);
      37                 :            : extern void __init swiotlb_update_mem_attributes(void);
      38                 :            : 
      39                 :            : /*
      40                 :            :  * Enumeration for sync targets
      41                 :            :  */
      42                 :            : enum dma_sync_target {
      43                 :            :         SYNC_FOR_CPU = 0,
      44                 :            :         SYNC_FOR_DEVICE = 1,
      45                 :            : };
      46                 :            : 
      47                 :            : extern phys_addr_t swiotlb_tbl_map_single(struct device *hwdev,
      48                 :            :                                           dma_addr_t tbl_dma_addr,
      49                 :            :                                           phys_addr_t phys,
      50                 :            :                                           size_t mapping_size,
      51                 :            :                                           size_t alloc_size,
      52                 :            :                                           enum dma_data_direction dir,
      53                 :            :                                           unsigned long attrs);
      54                 :            : 
      55                 :            : extern void swiotlb_tbl_unmap_single(struct device *hwdev,
      56                 :            :                                      phys_addr_t tlb_addr,
      57                 :            :                                      size_t mapping_size,
      58                 :            :                                      size_t alloc_size,
      59                 :            :                                      enum dma_data_direction dir,
      60                 :            :                                      unsigned long attrs);
      61                 :            : 
      62                 :            : extern void swiotlb_tbl_sync_single(struct device *hwdev,
      63                 :            :                                     phys_addr_t tlb_addr,
      64                 :            :                                     size_t size, enum dma_data_direction dir,
      65                 :            :                                     enum dma_sync_target target);
      66                 :            : 
      67                 :            : dma_addr_t swiotlb_map(struct device *dev, phys_addr_t phys,
      68                 :            :                 size_t size, enum dma_data_direction dir, unsigned long attrs);
      69                 :            : 
      70                 :            : #ifdef CONFIG_SWIOTLB
      71                 :            : extern enum swiotlb_force swiotlb_force;
      72                 :            : extern phys_addr_t io_tlb_start, io_tlb_end;
      73                 :            : 
      74                 :     564592 : static inline bool is_swiotlb_buffer(phys_addr_t paddr)
      75                 :            : {
      76   [ +  -  +  -  :     564592 :         return paddr >= io_tlb_start && paddr < io_tlb_end;
          -  -  -  -  +  
          -  +  -  -  -  
          -  -  -  -  -  
                      - ]
      77                 :            : }
      78                 :            : 
      79                 :            : void __init swiotlb_exit(void);
      80                 :            : unsigned int swiotlb_max_segment(void);
      81                 :            : size_t swiotlb_max_mapping_size(struct device *dev);
      82                 :            : bool is_swiotlb_active(void);
      83                 :            : #else
      84                 :            : #define swiotlb_force SWIOTLB_NO_FORCE
      85                 :            : static inline bool is_swiotlb_buffer(phys_addr_t paddr)
      86                 :            : {
      87                 :            :         return false;
      88                 :            : }
      89                 :            : static inline void swiotlb_exit(void)
      90                 :            : {
      91                 :            : }
      92                 :            : static inline unsigned int swiotlb_max_segment(void)
      93                 :            : {
      94                 :            :         return 0;
      95                 :            : }
      96                 :            : static inline size_t swiotlb_max_mapping_size(struct device *dev)
      97                 :            : {
      98                 :            :         return SIZE_MAX;
      99                 :            : }
     100                 :            : 
     101                 :            : static inline bool is_swiotlb_active(void)
     102                 :            : {
     103                 :            :         return false;
     104                 :            : }
     105                 :            : #endif /* CONFIG_SWIOTLB */
     106                 :            : 
     107                 :            : extern void swiotlb_print_info(void);
     108                 :            : extern void swiotlb_set_max_segment(unsigned int);
     109                 :            : 
     110                 :            : #endif /* __LINUX_SWIOTLB_H */