root/include/linux/pci-dma-compat.h

INCLUDED FROM

DEFINITIONS

1. pci_alloc_consistent
2. pci_zalloc_consistent
3. pci_free_consistent
4. pci_map_single
5. pci_unmap_single
6. pci_map_page
7. pci_unmap_page
8. pci_map_sg
9. pci_unmap_sg
10. pci_dma_sync_single_for_cpu
11. pci_dma_sync_single_for_device
12. pci_dma_sync_sg_for_cpu
13. pci_dma_sync_sg_for_device
14. pci_dma_mapping_error
15. pci_set_dma_mask
16. pci_set_consistent_dma_mask
17. pci_set_dma_mask
18. pci_set_consistent_dma_mask

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 /* include this file if the platform implements the dma_ DMA Mapping API
   3  * and wants to provide the pci_ DMA Mapping API in terms of it */
   4 
   5 #ifndef _ASM_GENERIC_PCI_DMA_COMPAT_H
   6 #define _ASM_GENERIC_PCI_DMA_COMPAT_H
   7 
   8 #include <linux/dma-mapping.h>
   9 
  10 /* This defines the direction arg to the DMA mapping routines. */
  11 #define PCI_DMA_BIDIRECTIONAL   DMA_BIDIRECTIONAL
  12 #define PCI_DMA_TODEVICE        DMA_TO_DEVICE
  13 #define PCI_DMA_FROMDEVICE      DMA_FROM_DEVICE
  14 #define PCI_DMA_NONE            DMA_NONE
  15 
  16 static inline void *
  17 pci_alloc_consistent(struct pci_dev *hwdev, size_t size,
  18                      dma_addr_t *dma_handle)
  19 {
  20         return dma_alloc_coherent(&hwdev->dev, size, dma_handle, GFP_ATOMIC);
  21 }
  22 
  23 static inline void *
  24 pci_zalloc_consistent(struct pci_dev *hwdev, size_t size,
  25                       dma_addr_t *dma_handle)
  26 {
  27         return dma_alloc_coherent(&hwdev->dev, size, dma_handle, GFP_ATOMIC);
  28 }
  29 
  30 static inline void
  31 pci_free_consistent(struct pci_dev *hwdev, size_t size,
  32                     void *vaddr, dma_addr_t dma_handle)
  33 {
  34         dma_free_coherent(&hwdev->dev, size, vaddr, dma_handle);
  35 }
  36 
  37 static inline dma_addr_t
  38 pci_map_single(struct pci_dev *hwdev, void *ptr, size_t size, int direction)
  39 {
  40         return dma_map_single(&hwdev->dev, ptr, size, (enum dma_data_direction)direction);
  41 }
  42 
  43 static inline void
  44 pci_unmap_single(struct pci_dev *hwdev, dma_addr_t dma_addr,
  45                  size_t size, int direction)
  46 {
  47         dma_unmap_single(&hwdev->dev, dma_addr, size, (enum dma_data_direction)direction);
  48 }
  49 
  50 static inline dma_addr_t
  51 pci_map_page(struct pci_dev *hwdev, struct page *page,
  52              unsigned long offset, size_t size, int direction)
  53 {
  54         return dma_map_page(&hwdev->dev, page, offset, size, (enum dma_data_direction)direction);
  55 }
  56 
  57 static inline void
  58 pci_unmap_page(struct pci_dev *hwdev, dma_addr_t dma_address,
  59                size_t size, int direction)
  60 {
  61         dma_unmap_page(&hwdev->dev, dma_address, size, (enum dma_data_direction)direction);
  62 }
  63 
  64 static inline int
  65 pci_map_sg(struct pci_dev *hwdev, struct scatterlist *sg,
  66            int nents, int direction)
  67 {
  68         return dma_map_sg(&hwdev->dev, sg, nents, (enum dma_data_direction)direction);
  69 }
  70 
  71 static inline void
  72 pci_unmap_sg(struct pci_dev *hwdev, struct scatterlist *sg,
  73              int nents, int direction)
  74 {
  75         dma_unmap_sg(&hwdev->dev, sg, nents, (enum dma_data_direction)direction);
  76 }
  77 
  78 static inline void
  79 pci_dma_sync_single_for_cpu(struct pci_dev *hwdev, dma_addr_t dma_handle,
  80                     size_t size, int direction)
  81 {
  82         dma_sync_single_for_cpu(&hwdev->dev, dma_handle, size, (enum dma_data_direction)direction);
  83 }
  84 
  85 static inline void
  86 pci_dma_sync_single_for_device(struct pci_dev *hwdev, dma_addr_t dma_handle,
  87                     size_t size, int direction)
  88 {
  89         dma_sync_single_for_device(&hwdev->dev, dma_handle, size, (enum dma_data_direction)direction);
  90 }
  91 
  92 static inline void
  93 pci_dma_sync_sg_for_cpu(struct pci_dev *hwdev, struct scatterlist *sg,
  94                 int nelems, int direction)
  95 {
  96         dma_sync_sg_for_cpu(&hwdev->dev, sg, nelems, (enum dma_data_direction)direction);
  97 }
  98 
  99 static inline void
 100 pci_dma_sync_sg_for_device(struct pci_dev *hwdev, struct scatterlist *sg,
 101                 int nelems, int direction)
 102 {
 103         dma_sync_sg_for_device(&hwdev->dev, sg, nelems, (enum dma_data_direction)direction);
 104 }
 105 
 106 static inline int
 107 pci_dma_mapping_error(struct pci_dev *pdev, dma_addr_t dma_addr)
 108 {
 109         return dma_mapping_error(&pdev->dev, dma_addr);
 110 }
 111 
 112 #ifdef CONFIG_PCI
 113 static inline int pci_set_dma_mask(struct pci_dev *dev, u64 mask)
 114 {
 115         return dma_set_mask(&dev->dev, mask);
 116 }
 117 
 118 static inline int pci_set_consistent_dma_mask(struct pci_dev *dev, u64 mask)
 119 {
 120         return dma_set_coherent_mask(&dev->dev, mask);
 121 }
 122 #else
 123 static inline int pci_set_dma_mask(struct pci_dev *dev, u64 mask)
 124 { return -EIO; }
 125 static inline int pci_set_consistent_dma_mask(struct pci_dev *dev, u64 mask)
 126 { return -EIO; }
 127 #endif
 128 
 129 #endif