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