include/asm-cris/dma-mapping.h

   1 /* DMA mapping. Nothing tricky here, just virt_to_phys */
   2
   3 #ifndef _ASM_CRIS_DMA_MAPPING_H
   4 #define _ASM_CRIS_DMA_MAPPING_H
   5
   6 #include <linux/mm.h>
   7 #include <linux/kernel.h>
   8
   9 #include <asm/cache.h>
  10 #include <asm/io.h>
  11 #include <asm/scatterlist.h>
  12
  13 #define dma_alloc_noncoherent(d, s, h, f) dma_alloc_coherent(d, s, h, f)
  14 #define dma_free_noncoherent(d, s, v, h) dma_free_coherent(d, s, v, h)
  15
  16 #ifdef CONFIG_PCI
  17 void *dma_alloc_coherent(struct device *dev, size_t size,
  18                            dma_addr_t *dma_handle, gfp_t flag);
  19
  20 void dma_free_coherent(struct device *dev, size_t size,
  21                          void *vaddr, dma_addr_t dma_handle);
  22 #else
  23 static inline void *
  24 dma_alloc_coherent(struct device *dev, size_t size, dma_addr_t *dma_handle,
  25                    gfp_t flag)
  26 {
  27         BUG();
  28         return NULL;
  29 }
  30
  31 static inline void
  32 dma_free_coherent(struct device *dev, size_t size, void *cpu_addr,
  33                     dma_addr_t dma_handle)
  34 {
  35         BUG();
  36 }
  37 #endif
  38 static inline dma_addr_t
  39 dma_map_single(struct device *dev, void *ptr, size_t size,
  40                enum dma_data_direction direction)
  41 {
  42         BUG_ON(direction == DMA_NONE);
  43         return virt_to_phys(ptr);
  44 }
  45
  46 static inline void
  47 dma_unmap_single(struct device *dev, dma_addr_t dma_addr, size_t size,
  48                  enum dma_data_direction direction)
  49 {
  50         BUG_ON(direction == DMA_NONE);
  51 }
  52
  53 static inline int
  54 dma_map_sg(struct device *dev, struct scatterlist *sg, int nents,
  55            enum dma_data_direction direction)
  56 {
  57         printk("Map sg\n");
  58         return nents;
  59 }
  60
  61 static inline dma_addr_t
  62 dma_map_page(struct device *dev, struct page *page, unsigned long offset,
  63              size_t size, enum dma_data_direction direction)
  64 {
  65         BUG_ON(direction == DMA_NONE);
  66         return page_to_phys(page) + offset;
  67 }
  68
  69 static inline void
  70 dma_unmap_page(struct device *dev, dma_addr_t dma_address, size_t size,
  71                enum dma_data_direction direction)
  72 {
  73         BUG_ON(direction == DMA_NONE);
  74 }
  75
  76
  77 static inline void
  78 dma_unmap_sg(struct device *dev, struct scatterlist *sg, int nhwentries,
  79              enum dma_data_direction direction)
  80 {
  81         BUG_ON(direction == DMA_NONE);
  82 }
  83
  84 static inline void
  85 dma_sync_single_for_cpu(struct device *dev, dma_addr_t dma_handle, size_t size,
  86                         enum dma_data_direction direction)
  87 {
  88 }
  89
  90 static inline void
  91 dma_sync_single_for_device(struct device *dev, dma_addr_t dma_handle, size_t size,
  92                         enum dma_data_direction direction)
  93 {
  94 }
  95
  96 static inline void
  97 dma_sync_single_range_for_cpu(struct device *dev, dma_addr_t dma_handle,
  98                               unsigned long offset, size_t size,
  99                               enum dma_data_direction direction)
 100 {
 101 }
 102
 103 static inline void
 104 dma_sync_single_range_for_device(struct device *dev, dma_addr_t dma_handle,
 105                                  unsigned long offset, size_t size,
 106                                  enum dma_data_direction direction)
 107 {
 108 }
 109
 110 static inline void
 111 dma_sync_sg_for_cpu(struct device *dev, struct scatterlist *sg, int nelems,
 112                     enum dma_data_direction direction)
 113 {
 114 }
 115
 116 static inline void
 117 dma_sync_sg_for_device(struct device *dev, struct scatterlist *sg, int nelems,
 118                     enum dma_data_direction direction)
 119 {
 120 }
 121
 122 static inline int
 123 dma_mapping_error(dma_addr_t dma_addr)
 124 {
 125         return 0;
 126 }
 127
 128 static inline int
 129 dma_supported(struct device *dev, u64 mask)
 130 {
 131         /*
 132          * we fall back to GFP_DMA when the mask isn't all 1s,
 133          * so we can't guarantee allocations that must be
 134          * within a tighter range than GFP_DMA..
 135          */
 136         if(mask < 0x00ffffff)
 137                 return 0;
 138
 139         return 1;
 140 }
 141
 142 static inline int
 143 dma_set_mask(struct device *dev, u64 mask)
 144 {
 145         if(!dev->dma_mask || !dma_supported(dev, mask))
 146                 return -EIO;
 147
 148         *dev->dma_mask = mask;
 149
 150         return 0;
 151 }
 152
 153 static inline int
 154 dma_get_cache_alignment(void)
 155 {
 156         return (1 << INTERNODE_CACHE_SHIFT);
 157 }
 158
 159 #define dma_is_consistent(d, h) (1)
 160
 161 static inline void
 162 dma_cache_sync(struct device *dev, void *vaddr, size_t size,
 163                enum dma_data_direction direction)
 164 {
 165 }
 166
 167 #define ARCH_HAS_DMA_DECLARE_COHERENT_MEMORY
 168 extern int
 169 dma_declare_coherent_memory(struct device *dev, dma_addr_t bus_addr,
 170                             dma_addr_t device_addr, size_t size, int flags);
 171
 172 extern void
 173 dma_release_declared_memory(struct device *dev);
 174
 175 extern void *
 176 dma_mark_declared_memory_occupied(struct device *dev,
 177                                   dma_addr_t device_addr, size_t size);
 178
 179 #endif