arch/mips/mm/dma-coherent.c

   1 /*
   2  * This file is subject to the terms and conditions of the GNU General Public
   3  * License.  See the file "COPYING" in the main directory of this archive
   4  * for more details.
   5  *
   6  * Copyright (C) 2000  Ani Joshi <ajoshi@unixbox.com>
   7  * Copyright (C) 2000, 2001  Ralf Baechle <ralf@gnu.org>
   8  * swiped from i386, and cloned for MIPS by Geert, polished by Ralf.
   9  */
  10 #include <linux/config.h>
  11 #include <linux/types.h>
  12 #include <linux/dma-mapping.h>
  13 #include <linux/mm.h>
  14 #include <linux/module.h>
  15 #include <linux/string.h>
  16
  17 #include <asm/cache.h>
  18 #include <asm/io.h>
  19
  20 void *dma_alloc_noncoherent(struct device *dev, size_t size,
  21         dma_addr_t * dma_handle, gfp_t gfp)
  22 {
  23         void *ret;
  24         /* ignore region specifiers */
  25         gfp &= ~(__GFP_DMA | __GFP_HIGHMEM);
  26
  27         if (dev == NULL || (dev->coherent_dma_mask < 0xffffffff))
  28                 gfp |= GFP_DMA;
  29         ret = (void *) __get_free_pages(gfp, get_order(size));
  30
  31         if (ret != NULL) {
  32                 memset(ret, 0, size);
  33                 *dma_handle = virt_to_phys(ret);
  34         }
  35
  36         return ret;
  37 }
  38
  39 EXPORT_SYMBOL(dma_alloc_noncoherent);
  40
  41 void *dma_alloc_coherent(struct device *dev, size_t size,
  42         dma_addr_t * dma_handle, gfp_t gfp)
  43         __attribute__((alias("dma_alloc_noncoherent")));
  44
  45 EXPORT_SYMBOL(dma_alloc_coherent);
  46
  47 void dma_free_noncoherent(struct device *dev, size_t size, void *vaddr,
  48         dma_addr_t dma_handle)
  49 {
  50         unsigned long addr = (unsigned long) vaddr;
  51
  52         free_pages(addr, get_order(size));
  53 }
  54
  55 EXPORT_SYMBOL(dma_free_noncoherent);
  56
  57 void dma_free_coherent(struct device *dev, size_t size, void *vaddr,
  58         dma_addr_t dma_handle) __attribute__((alias("dma_free_noncoherent")));
  59
  60 EXPORT_SYMBOL(dma_free_coherent);
  61
  62 dma_addr_t dma_map_single(struct device *dev, void *ptr, size_t size,
  63         enum dma_data_direction direction)
  64 {
  65         BUG_ON(direction == DMA_NONE);
  66
  67         return __pa(ptr);
  68 }
  69
  70 EXPORT_SYMBOL(dma_map_single);
  71
  72 void dma_unmap_single(struct device *dev, dma_addr_t dma_addr, size_t size,
  73                  enum dma_data_direction direction)
  74 {
  75         BUG_ON(direction == DMA_NONE);
  76 }
  77
  78 EXPORT_SYMBOL(dma_unmap_single);
  79
  80 int dma_map_sg(struct device *dev, struct scatterlist *sg, int nents,
  81         enum dma_data_direction direction)
  82 {
  83         int i;
  84
  85         BUG_ON(direction == DMA_NONE);
  86
  87         for (i = 0; i < nents; i++, sg++) {
  88                 sg->dma_address = (dma_addr_t)page_to_phys(sg->page) + sg->offset;
  89         }
  90
  91         return nents;
  92 }
  93
  94 EXPORT_SYMBOL(dma_map_sg);
  95
  96 dma_addr_t dma_map_page(struct device *dev, struct page *page,
  97         unsigned long offset, size_t size, enum dma_data_direction direction)
  98 {
  99         BUG_ON(direction == DMA_NONE);
 100
 101         return page_to_phys(page) + offset;
 102 }
 103
 104 EXPORT_SYMBOL(dma_map_page);
 105
 106 void dma_unmap_page(struct device *dev, dma_addr_t dma_address, size_t size,
 107                enum dma_data_direction direction)
 108 {
 109         BUG_ON(direction == DMA_NONE);
 110 }
 111
 112 EXPORT_SYMBOL(dma_unmap_page);
 113
 114 void dma_unmap_sg(struct device *dev, struct scatterlist *sg, int nhwentries,
 115              enum dma_data_direction direction)
 116 {
 117         BUG_ON(direction == DMA_NONE);
 118 }
 119
 120 EXPORT_SYMBOL(dma_unmap_sg);
 121
 122 void dma_sync_single_for_cpu(struct device *dev, dma_addr_t dma_handle,
 123         size_t size, enum dma_data_direction direction)
 124 {
 125         BUG_ON(direction == DMA_NONE);
 126 }
 127
 128 EXPORT_SYMBOL(dma_sync_single_for_cpu);
 129
 130 void dma_sync_single_for_device(struct device *dev, dma_addr_t dma_handle,
 131         size_t size, enum dma_data_direction direction)
 132 {
 133         BUG_ON(direction == DMA_NONE);
 134 }
 135
 136 EXPORT_SYMBOL(dma_sync_single_for_device);
 137
 138 void dma_sync_single_range_for_cpu(struct device *dev, dma_addr_t dma_handle,
 139                       unsigned long offset, size_t size,
 140                       enum dma_data_direction direction)
 141 {
 142         BUG_ON(direction == DMA_NONE);
 143 }
 144
 145 EXPORT_SYMBOL(dma_sync_single_range_for_cpu);
 146
 147 void dma_sync_single_range_for_device(struct device *dev, dma_addr_t dma_handle,
 148                       unsigned long offset, size_t size,
 149                       enum dma_data_direction direction)
 150 {
 151         BUG_ON(direction == DMA_NONE);
 152 }
 153
 154 EXPORT_SYMBOL(dma_sync_single_range_for_device);
 155
 156 void dma_sync_sg_for_cpu(struct device *dev, struct scatterlist *sg, int nelems,
 157                  enum dma_data_direction direction)
 158 {
 159         BUG_ON(direction == DMA_NONE);
 160 }
 161
 162 EXPORT_SYMBOL(dma_sync_sg_for_cpu);
 163
 164 void dma_sync_sg_for_device(struct device *dev, struct scatterlist *sg, int nelems,
 165                  enum dma_data_direction direction)
 166 {
 167         BUG_ON(direction == DMA_NONE);
 168 }
 169
 170 EXPORT_SYMBOL(dma_sync_sg_for_device);
 171
 172 int dma_mapping_error(dma_addr_t dma_addr)
 173 {
 174         return 0;
 175 }
 176
 177 EXPORT_SYMBOL(dma_mapping_error);
 178
 179 int dma_supported(struct device *dev, u64 mask)
 180 {
 181         /*
 182          * we fall back to GFP_DMA when the mask isn't all 1s,
 183          * so we can't guarantee allocations that must be
 184          * within a tighter range than GFP_DMA..
 185          */
 186         if (mask < 0x00ffffff)
 187                 return 0;
 188
 189         return 1;
 190 }
 191
 192 EXPORT_SYMBOL(dma_supported);
 193
 194 int dma_is_consistent(dma_addr_t dma_addr)
 195 {
 196         return 1;
 197 }
 198
 199 EXPORT_SYMBOL(dma_is_consistent);
 200
 201 void dma_cache_sync(void *vaddr, size_t size,
 202                enum dma_data_direction direction)
 203 {
 204         BUG_ON(direction == DMA_NONE);
 205 }
 206
 207 EXPORT_SYMBOL(dma_cache_sync);
 208
 209 /* The DAC routines are a PCIism.. */
 210
 211 #ifdef CONFIG_PCI
 212
 213 #include <linux/pci.h>
 214
 215 dma64_addr_t pci_dac_page_to_dma(struct pci_dev *pdev,
 216         struct page *page, unsigned long offset, int direction)
 217 {
 218         return (dma64_addr_t)page_to_phys(page) + offset;
 219 }
 220
 221 EXPORT_SYMBOL(pci_dac_page_to_dma);
 222
 223 struct page *pci_dac_dma_to_page(struct pci_dev *pdev,
 224         dma64_addr_t dma_addr)
 225 {
 226         return mem_map + (dma_addr >> PAGE_SHIFT);
 227 }
 228
 229 EXPORT_SYMBOL(pci_dac_dma_to_page);
 230
 231 unsigned long pci_dac_dma_to_offset(struct pci_dev *pdev,
 232         dma64_addr_t dma_addr)
 233 {
 234         return dma_addr & ~PAGE_MASK;
 235 }
 236
 237 EXPORT_SYMBOL(pci_dac_dma_to_offset);
 238
 239 void pci_dac_dma_sync_single_for_cpu(struct pci_dev *pdev,
 240         dma64_addr_t dma_addr, size_t len, int direction)
 241 {
 242         BUG_ON(direction == PCI_DMA_NONE);
 243 }
 244
 245 EXPORT_SYMBOL(pci_dac_dma_sync_single_for_cpu);
 246
 247 void pci_dac_dma_sync_single_for_device(struct pci_dev *pdev,
 248         dma64_addr_t dma_addr, size_t len, int direction)
 249 {
 250         BUG_ON(direction == PCI_DMA_NONE);
 251 }
 252
 253 EXPORT_SYMBOL(pci_dac_dma_sync_single_for_device);
 254
 255 #endif /* CONFIG_PCI */