release/src-rt-6.x/linux/linux-2.6/arch/mips/mm/dma-default.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, 06  Ralf Baechle <ralf@linux-mips.org>
   8  * swiped from i386, and cloned for MIPS by Geert, polished by Ralf.
   9  */
  10
  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 #include <dma-coherence.h>
  21
  22 #ifdef CONFIG_HIGHMEM
  23 #include <linux/highmem.h>
  24 #endif
  25
  26 static inline unsigned long dma_addr_to_virt(dma_addr_t dma_addr)
  27 {
  28         unsigned long addr = plat_dma_addr_to_phys(dma_addr);
  29
  30         return (unsigned long)phys_to_virt(addr);
  31 }
  32
  33 /*
  34  * Warning on the terminology - Linux calls an uncached area coherent;
  35  * MIPS terminology calls memory areas with hardware maintained coherency
  36  * coherent.
  37  */
  38
  39 static inline int cpu_is_noncoherent_r10000(struct device *dev)
  40 {
  41         return !plat_device_is_coherent(dev) &&
  42                (current_cpu_data.cputype == CPU_R10000 &&
  43                current_cpu_data.cputype == CPU_R12000);
  44 }
  45
  46 void *dma_alloc_noncoherent(struct device *dev, size_t size,
  47         dma_addr_t * dma_handle, gfp_t gfp)
  48 {
  49         void *ret;
  50
  51         /* ignore region specifiers */
  52         gfp &= ~(__GFP_DMA | __GFP_HIGHMEM);
  53
  54         if (dev == NULL || (dev->coherent_dma_mask < DMA_64BIT_MASK))
  55                 gfp |= GFP_DMA;
  56         ret = (void *) __get_free_pages(gfp, get_order(size));
  57
  58         if (ret != NULL) {
  59                 memset(ret, 0, size);
  60                 *dma_handle = plat_map_dma_mem(dev, ret, size);
  61         }
  62
  63         return ret;
  64 }
  65
  66 EXPORT_SYMBOL(dma_alloc_noncoherent);
  67
  68 void *dma_alloc_coherent(struct device *dev, size_t size,
  69         dma_addr_t * dma_handle, gfp_t gfp)
  70 {
  71         void *ret;
  72
  73         /* ignore region specifiers */
  74         gfp &= ~(__GFP_DMA | __GFP_HIGHMEM);
  75
  76         if (dev == NULL || (dev->coherent_dma_mask < DMA_64BIT_MASK))
  77                 gfp |= GFP_DMA;
  78         ret = (void *) __get_free_pages(gfp, get_order(size));
  79
  80         if (ret) {
  81                 memset(ret, 0, size);
  82                 *dma_handle = plat_map_dma_mem(dev, ret, size);
  83
  84                 if (!plat_device_is_coherent(dev)) {
  85                         dma_cache_wback_inv((unsigned long) ret, size);
  86                         ret = UNCAC_ADDR(ret);
  87                 }
  88         }
  89
  90         return ret;
  91 }
  92
  93 EXPORT_SYMBOL(dma_alloc_coherent);
  94
  95 void dma_free_noncoherent(struct device *dev, size_t size, void *vaddr,
  96         dma_addr_t dma_handle)
  97 {
  98         plat_unmap_dma_mem(dma_handle);
  99         free_pages((unsigned long) vaddr, get_order(size));
 100 }
 101
 102 EXPORT_SYMBOL(dma_free_noncoherent);
 103
 104 void dma_free_coherent(struct device *dev, size_t size, void *vaddr,
 105         dma_addr_t dma_handle)
 106 {
 107         unsigned long addr = (unsigned long) vaddr;
 108
 109         plat_unmap_dma_mem(dma_handle);
 110
 111         if (!plat_device_is_coherent(dev))
 112                 addr = CAC_ADDR(addr);
 113
 114         free_pages(addr, get_order(size));
 115 }
 116
 117 EXPORT_SYMBOL(dma_free_coherent);
 118
 119 static inline void __dma_sync(unsigned long addr, size_t size,
 120         enum dma_data_direction direction)
 121 {
 122         switch (direction) {
 123         case DMA_TO_DEVICE:
 124                 dma_cache_wback(addr, size);
 125                 break;
 126
 127         case DMA_FROM_DEVICE:
 128                 dma_cache_inv(addr, size);
 129                 break;
 130
 131         case DMA_BIDIRECTIONAL:
 132                 dma_cache_wback_inv(addr, size);
 133                 break;
 134
 135         default:
 136                 BUG();
 137         }
 138 }
 139
 140 dma_addr_t dma_map_single(struct device *dev, void *ptr, size_t size,
 141         enum dma_data_direction direction)
 142 {
 143         unsigned long addr = (unsigned long) ptr;
 144
 145         if (!plat_device_is_coherent(dev))
 146                 __dma_sync(addr, size, direction);
 147
 148         return plat_map_dma_mem(dev, ptr, size);
 149 }
 150
 151 EXPORT_SYMBOL(dma_map_single);
 152
 153 void dma_unmap_single(struct device *dev, dma_addr_t dma_addr, size_t size,
 154         enum dma_data_direction direction)
 155 {
 156         if (cpu_is_noncoherent_r10000(dev))
 157                 __dma_sync(dma_addr_to_virt(dma_addr), size,
 158                            direction);
 159
 160         plat_unmap_dma_mem(dma_addr);
 161 }
 162
 163 EXPORT_SYMBOL(dma_unmap_single);
 164
 165 #ifdef CONFIG_HIGHMEM
 166 static inline void
 167 dma_sync_high(struct scatterlist *sg, enum dma_data_direction direction)
 168 {
 169         int i;
 170         unsigned int nr_pages;
 171         struct page * tmp_page;
 172         unsigned int offset;
 173         unsigned int length, length_remain;
 174         unsigned long addr;
 175
 176         nr_pages = (sg->length + sg->offset + PAGE_SIZE - 1) >> PAGE_SHIFT;
 177         length_remain = sg->length;
 178
 179         for (i = 0, offset = sg->offset; i < nr_pages; i++, offset = 0) {
 180                 tmp_page = nth_page(sg->page, i);
 181
 182                 length = (length_remain > (PAGE_SIZE - offset))?
 183                         (PAGE_SIZE - offset): length_remain;
 184
 185                 addr = (unsigned long)kmap(tmp_page);
 186                 __dma_sync(addr + offset, length, direction);
 187                 kunmap(tmp_page);
 188                 length_remain -= length;
 189         }
 190 }
 191 #endif /* CONFIG_HIGHMEM */
 192
 193 int dma_map_sg(struct device *dev, struct scatterlist *sg, int nents,
 194         enum dma_data_direction direction)
 195 {
 196         int i;
 197
 198         BUG_ON(direction == DMA_NONE);
 199
 200         for (i = 0; i < nents; i++, sg++) {
 201                 unsigned long addr;
 202
 203 #ifdef CONFIG_HIGHMEM
 204                 if (PageHighMem(sg->page)) {
 205                         dma_sync_high(sg, direction);
 206                         sg->dma_address = (page_to_pfn(sg->page) << PAGE_SHIFT) + sg->offset;
 207                 }
 208                 else
 209 #endif
 210                 {
 211                         addr = (unsigned long) page_address(sg->page);
 212                         if (!plat_device_is_coherent(dev) && addr)
 213                                 __dma_sync(addr + sg->offset, sg->length, direction);
 214                         sg->dma_address = plat_map_dma_mem(dev,
 215                                                            (void *)(addr + sg->offset),
 216                                                            sg->length);
 217                 }
 218         }
 219
 220         return nents;
 221 }
 222
 223 EXPORT_SYMBOL(dma_map_sg);
 224
 225 dma_addr_t dma_map_page(struct device *dev, struct page *page,
 226         unsigned long offset, size_t size, enum dma_data_direction direction)
 227 {
 228         BUG_ON(direction == DMA_NONE);
 229
 230         if (!plat_device_is_coherent(dev)) {
 231                 unsigned long addr;
 232
 233                 addr = (unsigned long) page_address(page) + offset;
 234                 dma_cache_wback_inv(addr, size);
 235         }
 236
 237         return plat_map_dma_mem_page(dev, page) + offset;
 238 }
 239
 240 EXPORT_SYMBOL(dma_map_page);
 241
 242 void dma_unmap_page(struct device *dev, dma_addr_t dma_address, size_t size,
 243         enum dma_data_direction direction)
 244 {
 245         BUG_ON(direction == DMA_NONE);
 246
 247         if (!plat_device_is_coherent(dev) && direction != DMA_TO_DEVICE) {
 248                 unsigned long addr;
 249
 250                 addr = dma_addr_to_virt(dma_address);
 251                 dma_cache_wback_inv(addr, size);
 252         }
 253
 254         plat_unmap_dma_mem(dma_address);
 255 }
 256
 257 EXPORT_SYMBOL(dma_unmap_page);
 258
 259 void dma_unmap_sg(struct device *dev, struct scatterlist *sg, int nhwentries,
 260         enum dma_data_direction direction)
 261 {
 262         unsigned long addr;
 263         int i;
 264
 265         BUG_ON(direction == DMA_NONE);
 266
 267         for (i = 0; i < nhwentries; i++, sg++) {
 268                 if (!plat_device_is_coherent(dev) &&
 269                     direction != DMA_TO_DEVICE) {
 270
 271 #ifdef CONFIG_HIGHMEM
 272                         if (PageHighMem(sg->page)) {
 273                                 dma_sync_high(sg, direction);
 274                         }
 275                         else
 276 #endif
 277                         {
 278                                 addr = (unsigned long) page_address(sg->page);
 279                                 if (addr)
 280                                         __dma_sync(addr + sg->offset, sg->length,
 281                                                    direction);
 282                         }
 283                 }
 284                 plat_unmap_dma_mem(sg->dma_address);
 285         }
 286 }
 287
 288 EXPORT_SYMBOL(dma_unmap_sg);
 289
 290 void dma_sync_single_for_cpu(struct device *dev, dma_addr_t dma_handle,
 291         size_t size, enum dma_data_direction direction)
 292 {
 293         BUG_ON(direction == DMA_NONE);
 294
 295         if (cpu_is_noncoherent_r10000(dev)) {
 296                 unsigned long addr;
 297
 298                 addr = dma_addr_to_virt(dma_handle);
 299                 __dma_sync(addr, size, direction);
 300         }
 301 }
 302
 303 EXPORT_SYMBOL(dma_sync_single_for_cpu);
 304
 305 void dma_sync_single_for_device(struct device *dev, dma_addr_t dma_handle,
 306         size_t size, enum dma_data_direction direction)
 307 {
 308         BUG_ON(direction == DMA_NONE);
 309
 310         if (!plat_device_is_coherent(dev)) {
 311                 unsigned long addr;
 312
 313                 addr = dma_addr_to_virt(dma_handle);
 314                 __dma_sync(addr, size, direction);
 315         }
 316 }
 317
 318 EXPORT_SYMBOL(dma_sync_single_for_device);
 319
 320 void dma_sync_single_range_for_cpu(struct device *dev, dma_addr_t dma_handle,
 321         unsigned long offset, size_t size, enum dma_data_direction direction)
 322 {
 323         BUG_ON(direction == DMA_NONE);
 324
 325         if (cpu_is_noncoherent_r10000(dev)) {
 326                 unsigned long addr;
 327
 328                 addr = dma_addr_to_virt(dma_handle);
 329                 __dma_sync(addr + offset, size, direction);
 330         }
 331 }
 332
 333 EXPORT_SYMBOL(dma_sync_single_range_for_cpu);
 334
 335 void dma_sync_single_range_for_device(struct device *dev, dma_addr_t dma_handle,
 336         unsigned long offset, size_t size, enum dma_data_direction direction)
 337 {
 338         BUG_ON(direction == DMA_NONE);
 339
 340         if (!plat_device_is_coherent(dev)) {
 341                 unsigned long addr;
 342
 343                 addr = dma_addr_to_virt(dma_handle);
 344                 __dma_sync(addr + offset, size, direction);
 345         }
 346 }
 347
 348 EXPORT_SYMBOL(dma_sync_single_range_for_device);
 349
 350 void dma_sync_sg_for_cpu(struct device *dev, struct scatterlist *sg, int nelems,
 351         enum dma_data_direction direction)
 352 {
 353         int i;
 354
 355         BUG_ON(direction == DMA_NONE);
 356
 357         /* Make sure that gcc doesn't leave the empty loop body.  */
 358         for (i = 0; i < nelems; i++, sg++) {
 359                 if (cpu_is_noncoherent_r10000(dev))
 360                         __dma_sync((unsigned long)page_address(sg->page),
 361                                    sg->length, direction);
 362         }
 363 }
 364
 365 EXPORT_SYMBOL(dma_sync_sg_for_cpu);
 366
 367 void dma_sync_sg_for_device(struct device *dev, struct scatterlist *sg, int nelems,
 368         enum dma_data_direction direction)
 369 {
 370         int i;
 371
 372         BUG_ON(direction == DMA_NONE);
 373
 374         /* Make sure that gcc doesn't leave the empty loop body.  */
 375         for (i = 0; i < nelems; i++, sg++) {
 376                 if (!plat_device_is_coherent(dev))
 377                         __dma_sync((unsigned long)page_address(sg->page),
 378                                    sg->length, direction);
 379         }
 380 }
 381
 382 EXPORT_SYMBOL(dma_sync_sg_for_device);
 383
 384 int dma_mapping_error(dma_addr_t dma_addr)
 385 {
 386         return 0;
 387 }
 388
 389 EXPORT_SYMBOL(dma_mapping_error);
 390
 391 int dma_supported(struct device *dev, u64 mask)
 392 {
 393         /*
 394          * we fall back to GFP_DMA when the mask isn't all 1s,
 395          * so we can't guarantee allocations that must be
 396          * within a tighter range than GFP_DMA..
 397          */
 398         if (mask < DMA_24BIT_MASK)
 399                 return 0;
 400
 401         return 1;
 402 }
 403
 404 EXPORT_SYMBOL(dma_supported);
 405
 406 int dma_is_consistent(struct device *dev, dma_addr_t dma_addr)
 407 {
 408         return plat_device_is_coherent(dev);
 409 }
 410
 411 EXPORT_SYMBOL(dma_is_consistent);
 412
 413 void dma_cache_sync(struct device *dev, void *vaddr, size_t size,
 414                enum dma_data_direction direction)
 415 {
 416         BUG_ON(direction == DMA_NONE);
 417
 418         if (!plat_device_is_coherent(dev))
 419                 dma_cache_wback_inv((unsigned long)vaddr, size);
 420 }
 421
 422 EXPORT_SYMBOL(dma_cache_sync);