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_sg_for_cpu(struct device *dev,
 112                                        struct scatterlist *sg, int nelems,
 113                                        enum dma_data_direction direction)
 114 {
 115         dma_ops->sync_sg_for_cpu(dev, sg, nelems, direction);
 116 }
 117
 118 static inline void dma_sync_sg_for_device(struct device *dev,
 119                                           struct scatterlist *sg, int nelems,
 120                                           enum dma_data_direction direction)
 121 {
 122         dma_ops->sync_sg_for_device(dev, sg, nelems, direction);
 123 }
 124
 125 static inline int dma_mapping_error(dma_addr_t dma_addr)
 126 {
 127         return (dma_addr == DMA_ERROR_CODE);
 128 }
 129
 130 static inline int dma_get_cache_alignment(void)
 131 {
 132         /* no easy way to get cache size on all processors, so return
 133          * the maximum possible, to be safe */
 134         return (1 << INTERNODE_CACHE_SHIFT);
 135 }
 136
 137 #define dma_alloc_noncoherent(d, s, h, f) dma_alloc_coherent(d, s, h, f)
 138 #define dma_free_noncoherent(d, s, v, h) dma_free_coherent(d, s, v, h)
 139 #define dma_is_consistent(d, h) (1)
 140
 141 #endif /* _ASM_SPARC64_DMA_MAPPING_H */