include/asm-sparc64/dma-mapping.h

   1 #ifndef _ASM_SPARC64_DMA_MAPPING_H
   2 #define _ASM_SPARC64_DMA_MAPPING_H
   3
   4 #include <linux/scatterlist.h>
   5 #include <linux/mm.h>
   6
   7 #define DMA_ERROR_CODE  (~(dma_addr_t)0x0)
   8
   9 struct dma_ops {
  10         void *(*alloc_coherent)(struct device *dev, size_t size,
  11                                 dma_addr_t *dma_handle, gfp_t flag);
  12         void (*free_coherent)(struct device *dev, size_t size,
  13                               void *cpu_addr, dma_addr_t dma_handle);
  14         dma_addr_t (*map_single)(struct device *dev, void *cpu_addr,
  15                                  size_t size,
  16                                  enum dma_data_direction direction);
  17         void (*unmap_single)(struct device *dev, dma_addr_t dma_addr,
  18                              size_t size,
  19                              enum dma_data_direction direction);
  20         int (*map_sg)(struct device *dev, struct scatterlist *sg, int nents,
  21                       enum dma_data_direction direction);
  22         void (*unmap_sg)(struct device *dev, struct scatterlist *sg,
  23                          int nhwentries,
  24                          enum dma_data_direction direction);
  25         void (*sync_single_for_cpu)(struct device *dev,
  26                                     dma_addr_t dma_handle, size_t size,
  27                                     enum dma_data_direction direction);
  28         void (*sync_single_for_device)(struct device *dev,
  29                                        dma_addr_t dma_handle, size_t size,
  30                                        enum dma_data_direction direction);
  31         void (*sync_sg_for_cpu)(struct device *dev, struct scatterlist *sg,
  32                                 int nelems,
  33                                 enum dma_data_direction direction);
  34         void (*sync_sg_for_device)(struct device *dev, struct scatterlist *sg,
  35                                    int nelems,
  36                                    enum dma_data_direction direction);
  37 };
  38 extern const struct dma_ops *dma_ops;
  39
  40 extern int dma_supported(struct device *dev, u64 mask);
  41 extern int dma_set_mask(struct device *dev, u64 dma_mask);
  42
  43 static inline void *dma_alloc_coherent(struct device *dev, size_t size,
  44                                        dma_addr_t *dma_handle, gfp_t flag)
  45 {
  46         return dma_ops->alloc_coherent(dev, size, dma_handle, flag);
  47 }
  48
  49 static inline void dma_free_coherent(struct device *dev, size_t size,
  50                                      void *cpu_addr, dma_addr_t dma_handle)
  51 {
  52         dma_ops->free_coherent(dev, size, cpu_addr, dma_handle);
  53 }
  54
  55 static inline dma_addr_t dma_map_single(struct device *dev, void *cpu_addr,
  56                                         size_t size,
  57                                         enum dma_data_direction direction)
  58 {
  59         return dma_ops->map_single(dev, cpu_addr, size, direction);
  60 }
  61
  62 static inline void dma_unmap_single(struct device *dev, dma_addr_t dma_addr,
  63                                     size_t size,
  64                                     enum dma_data_direction direction)
  65 {
  66         dma_ops->unmap_single(dev, dma_addr, size, direction);
  67 }
  68
  69 static inline dma_addr_t dma_map_page(struct device *dev, struct page *page,
  70                                       unsigned long offset, size_t size,
  71                                       enum dma_data_direction direction)
  72 {
  73         return dma_ops->map_single(dev, page_address(page) + offset,
  74                                    size, direction);
  75 }
  76
  77 static inline void dma_unmap_page(struct device *dev, dma_addr_t dma_address,
  78                                   size_t size,
  79                                   enum dma_data_direction direction)
  80 {
  81         dma_ops->unmap_single(dev, dma_address, size, direction);
  82 }
  83
  84 static inline int dma_map_sg(struct device *dev, struct scatterlist *sg,
  85                              int nents, enum dma_data_direction direction)
  86 {
  87         return dma_ops->map_sg(dev, sg, nents, direction);
  88 }
  89
  90 static inline void dma_unmap_sg(struct device *dev, struct scatterlist *sg,
  91                                 int nents, enum dma_data_direction direction)
  92 {
  93         dma_ops->unmap_sg(dev, sg, nents, direction);
  94 }
  95
  96 static inline void dma_sync_single_for_cpu(struct device *dev,
  97                                            dma_addr_t dma_handle, size_t size,
  98                                            enum dma_data_direction direction)
  99 {
 100         dma_ops->sync_single_for_cpu(dev, dma_handle, size, direction);
 101 }
 102
 103 static inline void dma_sync_single_for_device(struct device *dev,
 104                                               dma_addr_t dma_handle,
 105                                               size_t size,
 106                                               enum dma_data_direction direction)
 107 {
 108         dma_ops->sync_single_for_device(dev, dma_handle, size, direction);
 109 }
 110
 111 static inline void dma_sync_single_range_for_cpu(struct device *dev,
 112                                                  dma_addr_t dma_handle,
 113                                                  unsigned long offset,
 114                                                  size_t size,
 115                                                  enum dma_data_direction direction)
 116 {
 117         dma_sync_single_for_cpu(dev, dma_handle+offset, size, direction);
 118 }
 119
 120 static inline void dma_sync_single_range_for_device(struct device *dev,
 121                                                     dma_addr_t dma_handle,
 122                                                     unsigned long offset,
 123                                                     size_t size,
 124                                                     enum dma_data_direction direction)
 125 {
 126         dma_sync_single_for_device(dev, dma_handle+offset, size, direction);
 127 }
 128
 129
 130 static inline void dma_sync_sg_for_cpu(struct device *dev,
 131                                        struct scatterlist *sg, int nelems,
 132                                        enum dma_data_direction direction)
 133 {
 134         dma_ops->sync_sg_for_cpu(dev, sg, nelems, direction);
 135 }
 136
 137 static inline void dma_sync_sg_for_device(struct device *dev,
 138                                           struct scatterlist *sg, int nelems,
 139                                           enum dma_data_direction direction)
 140 {
 141         dma_ops->sync_sg_for_device(dev, sg, nelems, direction);
 142 }
 143
 144 static inline int dma_mapping_error(dma_addr_t dma_addr)
 145 {
 146         return (dma_addr == DMA_ERROR_CODE);
 147 }
 148
 149 static inline int dma_get_cache_alignment(void)
 150 {
 151         /* no easy way to get cache size on all processors, so return
 152          * the maximum possible, to be safe */
 153         return (1 << INTERNODE_CACHE_SHIFT);
 154 }
 155
 156 #define dma_alloc_noncoherent(d, s, h, f) dma_alloc_coherent(d, s, h, f)
 157 #define dma_free_noncoherent(d, s, v, h) dma_free_coherent(d, s, v, h)
 158 #define dma_is_consistent(d, h) (1)
 159
 160 #endif /* _ASM_SPARC64_DMA_MAPPING_H */