arch/nios2nommu/mm/dma-noncoherent.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/types.h>
  11 #include <linux/mm.h>
  12 #include <linux/module.h>
  13 #include <linux/string.h>
  14 #include <linux/dma-mapping.h>
  15
  16 #include <asm/cache.h>
  17 #include <asm/cacheflush.h>
  18 #include <asm/io.h>
  19
  20 #define UNCAC_ADDR(addr) ((void *)((unsigned long)(addr) | 0x80000000))
  21 #define   CAC_ADDR(addr) ((void *)((unsigned long)(addr) & ~0x80000000))
  22
  23 /*
  24  * Warning on the terminology - Linux calls an uncached area coherent;
  25  * MIPS terminology calls memory areas with hardware maintained coherency
  26  * coherent.
  27  */
  28
  29 void *dma_alloc_noncoherent(struct device *dev, size_t size,
  30         dma_addr_t * dma_handle, gfp_t gfp)
  31 {
  32         void *ret;
  33         /* ignore region specifiers */
  34         gfp &= ~(__GFP_DMA | __GFP_HIGHMEM);
  35
  36         if (dev == NULL || (dev->coherent_dma_mask < 0xffffffff))
  37                 gfp |= GFP_DMA;
  38         ret = (void *) __get_free_pages(gfp, get_order(size));
  39
  40         if (ret != NULL) {
  41                 memset(ret, 0, size);
  42                 *dma_handle = virt_to_phys(ret);
  43         }
  44
  45         return ret;
  46 }
  47
  48 EXPORT_SYMBOL(dma_alloc_noncoherent);
  49
  50 void *dma_alloc_coherent(struct device *dev, size_t size,
  51         dma_addr_t * dma_handle, gfp_t gfp)
  52 {
  53         void *ret;
  54
  55         ret = dma_alloc_noncoherent(dev, size, dma_handle, gfp);
  56         if (ret) {
  57                 dma_cache_wback_inv((unsigned long) ret, size);
  58                 ret = UNCAC_ADDR(ret);
  59         }
  60
  61         return ret;
  62 }
  63
  64 EXPORT_SYMBOL(dma_alloc_coherent);
  65
  66 void dma_free_noncoherent(struct device *dev, size_t size, void *vaddr,
  67         dma_addr_t dma_handle)
  68 {
  69         free_pages((unsigned long) vaddr, get_order(size));
  70 }
  71
  72 EXPORT_SYMBOL(dma_free_noncoherent);
  73
  74 void dma_free_coherent(struct device *dev, size_t size, void *vaddr,
  75         dma_addr_t dma_handle)
  76 {
  77         unsigned long addr = (unsigned long) vaddr;
  78
  79         addr = (unsigned long) CAC_ADDR(addr);
  80         free_pages(addr, get_order(size));
  81 }
  82
  83 EXPORT_SYMBOL(dma_free_coherent);
  84
  85 static inline void __dma_sync(unsigned long addr, size_t size,
  86         enum dma_data_direction direction)
  87 {
  88         switch (direction) {
  89         case DMA_TO_DEVICE:
  90                 dma_cache_wback(addr, size);
  91                 break;
  92
  93         case DMA_FROM_DEVICE:
  94                 dma_cache_inv(addr, size);
  95                 break;
  96
  97         case DMA_BIDIRECTIONAL:
  98                 dma_cache_wback_inv(addr, size);
  99                 break;
 100
 101         default:
 102                 BUG();
 103         }
 104 }
 105
 106 dma_addr_t dma_map_single(struct device *dev, void *ptr, size_t size,
 107         enum dma_data_direction direction)
 108 {
 109         unsigned long addr = (unsigned long) ptr;
 110
 111         __dma_sync(addr, size, direction);
 112
 113         return virt_to_phys(ptr);
 114 }
 115
 116 EXPORT_SYMBOL(dma_map_single);
 117
 118 void dma_unmap_single(struct device *dev, dma_addr_t dma_addr, size_t size,
 119         enum dma_data_direction direction)
 120 {
 121         unsigned long addr;
 122         addr = dma_addr + PAGE_OFFSET;
 123
 124         //__dma_sync(addr, size, direction);
 125 }
 126
 127 EXPORT_SYMBOL(dma_unmap_single);
 128
 129 int dma_map_sg(struct device *dev, struct scatterlist *sg, int nents,
 130         enum dma_data_direction direction)
 131 {
 132         int i;
 133
 134         BUG_ON(direction == DMA_NONE);
 135
 136         for (i = 0; i < nents; i++, sg++) {
 137                 unsigned long addr;
 138
 139                 addr = (unsigned long) page_address(sg->page);
 140                 if (addr) {
 141                         __dma_sync(addr + sg->offset, sg->length, direction);
 142                         sg->dma_address = (dma_addr_t)page_to_phys(sg->page)
 143                                           + sg->offset;
 144                 }
 145         }
 146
 147         return nents;
 148 }
 149
 150 EXPORT_SYMBOL(dma_map_sg);
 151
 152 dma_addr_t dma_map_page(struct device *dev, struct page *page,
 153         unsigned long offset, size_t size, enum dma_data_direction direction)
 154 {
 155         unsigned long addr;
 156
 157         BUG_ON(direction == DMA_NONE);
 158
 159         addr = (unsigned long) page_address(page) + offset;
 160         dma_cache_wback_inv(addr, size);
 161
 162         return page_to_phys(page) + offset;
 163 }
 164
 165 EXPORT_SYMBOL(dma_map_page);
 166
 167 void dma_unmap_page(struct device *dev, dma_addr_t dma_address, size_t size,
 168         enum dma_data_direction direction)
 169 {
 170         BUG_ON(direction == DMA_NONE);
 171
 172         if (direction != DMA_TO_DEVICE) {
 173                 unsigned long addr;
 174
 175                 addr = dma_address + PAGE_OFFSET;
 176                 dma_cache_wback_inv(addr, size);
 177         }
 178 }
 179
 180 EXPORT_SYMBOL(dma_unmap_page);
 181
 182 void dma_unmap_sg(struct device *dev, struct scatterlist *sg, int nhwentries,
 183         enum dma_data_direction direction)
 184 {
 185         unsigned long addr;
 186         int i;
 187
 188         BUG_ON(direction == DMA_NONE);
 189
 190         if (direction == DMA_TO_DEVICE)
 191                 return;
 192
 193         for (i = 0; i < nhwentries; i++, sg++) {
 194                 addr = (unsigned long) page_address(sg->page);
 195                 if (addr)
 196                         __dma_sync(addr + sg->offset, sg->length, direction);
 197         }
 198 }
 199
 200 EXPORT_SYMBOL(dma_unmap_sg);
 201
 202 void dma_sync_single_for_cpu(struct device *dev, dma_addr_t dma_handle,
 203         size_t size, enum dma_data_direction direction)
 204 {
 205         unsigned long addr;
 206
 207         BUG_ON(direction == DMA_NONE);
 208
 209         addr = dma_handle + PAGE_OFFSET;
 210         __dma_sync(addr, size, direction);
 211 }
 212
 213 EXPORT_SYMBOL(dma_sync_single_for_cpu);
 214
 215 void dma_sync_single_for_device(struct device *dev, dma_addr_t dma_handle,
 216         size_t size, enum dma_data_direction direction)
 217 {
 218         unsigned long addr;
 219
 220         BUG_ON(direction == DMA_NONE);
 221
 222         addr = dma_handle + PAGE_OFFSET;
 223         __dma_sync(addr, size, direction);
 224 }
 225
 226 EXPORT_SYMBOL(dma_sync_single_for_device);
 227
 228 void dma_sync_single_range_for_cpu(struct device *dev, dma_addr_t dma_handle,
 229         unsigned long offset, size_t size, enum dma_data_direction direction)
 230 {
 231         unsigned long addr;
 232
 233         BUG_ON(direction == DMA_NONE);
 234
 235         addr = dma_handle + offset + PAGE_OFFSET;
 236         __dma_sync(addr, size, direction);
 237 }
 238
 239 EXPORT_SYMBOL(dma_sync_single_range_for_cpu);
 240
 241 void dma_sync_single_range_for_device(struct device *dev, dma_addr_t dma_handle,
 242         unsigned long offset, size_t size, enum dma_data_direction direction)
 243 {
 244         unsigned long addr;
 245
 246         BUG_ON(direction == DMA_NONE);
 247
 248         addr = dma_handle + offset + PAGE_OFFSET;
 249         __dma_sync(addr, size, direction);
 250 }
 251
 252 EXPORT_SYMBOL(dma_sync_single_range_for_device);
 253
 254 void dma_sync_sg_for_cpu(struct device *dev, struct scatterlist *sg, int nelems,
 255         enum dma_data_direction direction)
 256 {
 257         int i;
 258
 259         BUG_ON(direction == DMA_NONE);
 260
 261         /* Make sure that gcc doesn't leave the empty loop body.  */
 262         for (i = 0; i < nelems; i++, sg++)
 263                 __dma_sync((unsigned long)page_address(sg->page),
 264                            sg->length, direction);
 265 }
 266
 267 EXPORT_SYMBOL(dma_sync_sg_for_cpu);
 268
 269 void dma_sync_sg_for_device(struct device *dev, struct scatterlist *sg, int nelems,
 270         enum dma_data_direction direction)
 271 {
 272         int i;
 273
 274         BUG_ON(direction == DMA_NONE);
 275
 276         /* Make sure that gcc doesn't leave the empty loop body.  */
 277         for (i = 0; i < nelems; i++, sg++)
 278                 __dma_sync((unsigned long)page_address(sg->page),
 279                            sg->length, direction);
 280 }
 281
 282 EXPORT_SYMBOL(dma_sync_sg_for_device);
 283
 284 int dma_mapping_error(dma_addr_t dma_addr)
 285 {
 286         return 0;
 287 }
 288
 289 EXPORT_SYMBOL(dma_mapping_error);
 290
 291 int dma_supported(struct device *dev, u64 mask)
 292 {
 293         /*
 294          * we fall back to GFP_DMA when the mask isn't all 1s,
 295          * so we can't guarantee allocations that must be
 296          * within a tighter range than GFP_DMA..
 297          */
 298         if (mask < 0x00ffffff)
 299                 return 0;
 300
 301         return 1;
 302 }
 303
 304 EXPORT_SYMBOL(dma_supported);
 305
 306 int dma_is_consistent(dma_addr_t dma_addr)
 307 {
 308         return 1;
 309 }
 310
 311 EXPORT_SYMBOL(dma_is_consistent);
 312
 313 void dma_cache_sync(void *vaddr, size_t size, enum dma_data_direction direction)
 314 {
 315         if (direction == DMA_NONE)
 316                 return;
 317
 318         dma_cache_wback_inv((unsigned long)vaddr, size);
 319 }
 320
 321 EXPORT_SYMBOL(dma_cache_sync);
 322
 323 /* The DAC routines are a PCIism.. */
 324
 325 #ifdef CONFIG_PCI
 326
 327 #include <linux/pci.h>
 328
 329 dma64_addr_t pci_dac_page_to_dma(struct pci_dev *pdev,
 330         struct page *page, unsigned long offset, int direction)
 331 {
 332         return (dma64_addr_t)page_to_phys(page) + offset;
 333 }
 334
 335 EXPORT_SYMBOL(pci_dac_page_to_dma);
 336
 337 struct page *pci_dac_dma_to_page(struct pci_dev *pdev,
 338         dma64_addr_t dma_addr)
 339 {
 340         return mem_map + (dma_addr >> PAGE_SHIFT);
 341 }
 342
 343 EXPORT_SYMBOL(pci_dac_dma_to_page);
 344
 345 unsigned long pci_dac_dma_to_offset(struct pci_dev *pdev,
 346         dma64_addr_t dma_addr)
 347 {
 348         return dma_addr & ~PAGE_MASK;
 349 }
 350
 351 EXPORT_SYMBOL(pci_dac_dma_to_offset);
 352
 353 void pci_dac_dma_sync_single_for_cpu(struct pci_dev *pdev,
 354         dma64_addr_t dma_addr, size_t len, int direction)
 355 {
 356         BUG_ON(direction == PCI_DMA_NONE);
 357
 358         dma_cache_wback_inv(dma_addr + PAGE_OFFSET, len);
 359 }
 360
 361 EXPORT_SYMBOL(pci_dac_dma_sync_single_for_cpu);
 362
 363 void pci_dac_dma_sync_single_for_device(struct pci_dev *pdev,
 364         dma64_addr_t dma_addr, size_t len, int direction)
 365 {
 366         BUG_ON(direction == PCI_DMA_NONE);
 367
 368         dma_cache_wback_inv(dma_addr + PAGE_OFFSET, len);
 369 }
 370
 371 EXPORT_SYMBOL(pci_dac_dma_sync_single_for_device);
 372
 373 #endif /* CONFIG_PCI */