2 ** Dynamic DMA mapping support.
3 ** See Documentation/DMA-mapping.txt for interface definitions.
5 ** (c) Copyright 1999,2000 Hewlett-Packard Company
6 ** (c) Copyright 2000 Grant Grundler
7 ** (c) Copyright 2000 Philipp Rumpf <prumpf@tux.org>
8 ** (c) Copyright 2000 John Marvin
10 ** This implementation is for PA-RISC platforms that do not support
11 ** I/O TLBs (aka DMA address translation hardware).
13 ** "leveraged" from 2.3.47: arch/ia64/kernel/pci-dma.c.
14 ** (I assume it's from David Mosberger-Tang but there was no Copyright)
16 ** AFAIK, all PA7100LC and PA7300LC platforms can use this code.
17 ** All PA2.0 machines but V-class can alias xxx_alloc_consistent()
18 ** to use regular cacheable memory.
23 #include <linux/types.h>
25 #include <linux/string.h>
26 #include <linux/pci.h>
27 #include <linux/init.h>
29 #include <linux/malloc.h>
30 #include <linux/vmalloc.h>
32 #include <asm/uaccess.h>
33 #include <asm/pgalloc.h>
36 #include <asm/page.h> /* get_order */
37 #include <asm/dma.h> /* for DMA_CHUNK_SIZE */
39 #include <linux/proc_fs.h>
41 static struct proc_dir_entry
* proc_gsc_root
= NULL
;
42 static int pcxl_proc_info(char *buffer
, char **start
, off_t offset
, int length
);
43 static unsigned long pcxl_used_bytes
= 0;
44 static unsigned long pcxl_used_pages
= 0;
46 extern unsigned long pcxl_dma_start
; /* Start of pcxl dma mapping area */
47 static spinlock_t pcxl_res_lock
;
48 static char *pcxl_res_map
;
49 static int pcxl_res_hint
;
50 static int pcxl_res_size
;
52 #ifdef DEBUG_PCXL_RESOURCE
53 #define DBG_RES(x...) printk(x)
60 ** Dump a hex representation of the resource map.
65 void dump_resmap(void)
67 u_long
*res_ptr
= (unsigned long *)pcxl_res_map
;
71 for(; i
< (pcxl_res_size
/ sizeof(unsigned long)); ++i
, ++res_ptr
)
72 printk("%08lx ", *res_ptr
);
77 static inline void dump_resmap(void) {;}
80 static int pa11_dma_supported( struct pci_dev
*dev
, dma_addr_t mask
)
85 static inline int map_pte_uncached(pte_t
* pte
,
87 unsigned long size
, unsigned long *paddr_ptr
)
90 unsigned long orig_vaddr
= vaddr
;
98 printk(KERN_ERR
"map_pte_uncached: page already exists\n");
99 set_pte(pte
, __mk_pte(*paddr_ptr
, PAGE_KERNEL_UNC
));
100 pdtlb_kernel(orig_vaddr
);
102 orig_vaddr
+= PAGE_SIZE
;
103 (*paddr_ptr
) += PAGE_SIZE
;
105 } while (vaddr
< end
);
109 static inline int map_pmd_uncached(pmd_t
* pmd
, unsigned long vaddr
,
110 unsigned long size
, unsigned long *paddr_ptr
)
113 unsigned long orig_vaddr
= vaddr
;
115 vaddr
&= ~PGDIR_MASK
;
117 if (end
> PGDIR_SIZE
)
120 pte_t
* pte
= pte_alloc_kernel(pmd
, vaddr
);
123 if (map_pte_uncached(pte
, orig_vaddr
, end
- vaddr
, paddr_ptr
))
125 vaddr
= (vaddr
+ PMD_SIZE
) & PMD_MASK
;
126 orig_vaddr
+= PMD_SIZE
;
128 } while (vaddr
< end
);
132 static inline int map_uncached_pages(unsigned long vaddr
, unsigned long size
,
136 unsigned long end
= vaddr
+ size
;
138 dir
= pgd_offset_k(vaddr
);
142 pmd
= pmd_alloc_kernel(dir
, vaddr
);
145 if (map_pmd_uncached(pmd
, vaddr
, end
- vaddr
, &paddr
))
147 vaddr
= vaddr
+ PGDIR_SIZE
;
149 } while (vaddr
&& (vaddr
< end
));
153 static inline void unmap_uncached_pte(pmd_t
* pmd
, unsigned long vaddr
,
158 unsigned long orig_vaddr
= vaddr
;
167 pte
= pte_offset(pmd
, vaddr
);
175 pdtlb_kernel(orig_vaddr
);
177 orig_vaddr
+= PAGE_SIZE
;
179 if (pte_none(page
) || pte_present(page
))
181 printk(KERN_CRIT
"Whee.. Swapped out page in kernel page table\n");
182 } while (vaddr
< end
);
185 static inline void unmap_uncached_pmd(pgd_t
* dir
, unsigned long vaddr
,
190 unsigned long orig_vaddr
= vaddr
;
199 pmd
= pmd_offset(dir
, vaddr
);
200 vaddr
&= ~PGDIR_MASK
;
202 if (end
> PGDIR_SIZE
)
205 unmap_uncached_pte(pmd
, orig_vaddr
, end
- vaddr
);
206 vaddr
= (vaddr
+ PMD_SIZE
) & PMD_MASK
;
207 orig_vaddr
+= PMD_SIZE
;
209 } while (vaddr
< end
);
212 static void unmap_uncached_pages(unsigned long vaddr
, unsigned long size
)
215 unsigned long end
= vaddr
+ size
;
217 dir
= pgd_offset_k(vaddr
);
219 unmap_uncached_pmd(dir
, vaddr
, end
- vaddr
);
220 vaddr
= vaddr
+ PGDIR_SIZE
;
222 } while (vaddr
&& (vaddr
< end
));
225 #define PCXL_SEARCH_LOOP(idx, mask, size) \
226 for(; res_ptr < res_end; ++res_ptr) \
228 if(0 == ((*res_ptr) & mask)) { \
230 idx = (int)((u_long)res_ptr - (u_long)pcxl_res_map); \
231 pcxl_res_hint = idx + (size >> 3); \
232 goto resource_found; \
236 #define PCXL_FIND_FREE_MAPPING(idx, mask, size) { \
237 u##size *res_ptr = (u##size *)&(pcxl_res_map[pcxl_res_hint & ~((size >> 3) - 1)]); \
238 u##size *res_end = (u##size *)&pcxl_res_map[pcxl_res_size]; \
239 PCXL_SEARCH_LOOP(idx, mask, size); \
240 res_ptr = (u##size *)&pcxl_res_map[0]; \
241 PCXL_SEARCH_LOOP(idx, mask, size); \
245 pcxl_alloc_range(size_t size
)
249 unsigned int pages_needed
= size
>> PAGE_SHIFT
;
251 ASSERT(pages_needed
);
252 ASSERT((pages_needed
* PAGE_SIZE
) < DMA_CHUNK_SIZE
);
253 ASSERT(pages_needed
< (BITS_PER_LONG
- PAGE_SHIFT
));
256 mask
>>= BITS_PER_LONG
- pages_needed
;
258 DBG_RES("pcxl_alloc_range() size: %d pages_needed %d pages_mask 0x%08lx\n",
259 size
, pages_needed
, mask
);
261 spin_lock_irqsave(&pcxl_res_lock
, flags
);
263 if(pages_needed
<= 8) {
264 PCXL_FIND_FREE_MAPPING(res_idx
, mask
, 8);
265 } else if(pages_needed
<= 16) {
266 PCXL_FIND_FREE_MAPPING(res_idx
, mask
, 16);
267 } else if(pages_needed
<= 32) {
268 PCXL_FIND_FREE_MAPPING(res_idx
, mask
, 32);
270 panic(__FILE__
": pcxl_alloc_range() Too many pages to map.\n");
274 panic(__FILE__
": pcxl_alloc_range() out of dma mapping resources\n");
278 DBG_RES("pcxl_alloc_range() res_idx %d mask 0x%08lx res_hint: %d\n",
279 res_idx
, mask
, pcxl_res_hint
);
281 pcxl_used_pages
+= pages_needed
;
282 pcxl_used_bytes
+= ((pages_needed
>> 3) ? (pages_needed
>> 3) : 1);
284 spin_unlock_irqrestore(&pcxl_res_lock
, flags
);
289 ** return the corresponding vaddr in the pcxl dma map
291 return (pcxl_dma_start
+ (res_idx
<< (PAGE_SHIFT
+ 3)));
294 #define PCXL_FREE_MAPPINGS(idx, m, size) \
295 u##size *res_ptr = (u##size *)&(pcxl_res_map[(idx) + (((size >> 3) - 1) & (~((size >> 3) - 1)))]); \
296 ASSERT((*res_ptr & m) == m); \
300 ** clear bits in the pcxl resource map
303 pcxl_free_range(unsigned long vaddr
, size_t size
)
306 unsigned int res_idx
= (vaddr
- pcxl_dma_start
) >> (PAGE_SHIFT
+ 3);
307 unsigned int pages_mapped
= size
>> PAGE_SHIFT
;
309 ASSERT(pages_mapped
);
310 ASSERT((pages_mapped
* PAGE_SIZE
) < DMA_CHUNK_SIZE
);
311 ASSERT(pages_mapped
< (BITS_PER_LONG
- PAGE_SHIFT
));
314 mask
>>= BITS_PER_LONG
- pages_mapped
;
316 DBG_RES("pcxl_free_range() res_idx: %d size: %d pages_mapped %d mask 0x%08lx\n",
317 res_idx
, size
, pages_mapped
, mask
);
319 spin_lock_irqsave(&pcxl_res_lock
, flags
);
321 if(pages_mapped
<= 8) {
322 PCXL_FREE_MAPPINGS(res_idx
, mask
, 8);
323 } else if(pages_mapped
<= 16) {
324 PCXL_FREE_MAPPINGS(res_idx
, mask
, 16);
325 } else if(pages_mapped
<= 32) {
326 PCXL_FREE_MAPPINGS(res_idx
, mask
, 32);
328 panic(__FILE__
": pcxl_free_range() Too many pages to unmap.\n");
331 pcxl_used_pages
-= (pages_mapped
? pages_mapped
: 1);
332 pcxl_used_bytes
-= ((pages_mapped
>> 3) ? (pages_mapped
>> 3) : 1);
334 spin_unlock_irqrestore(&pcxl_res_lock
, flags
);
342 if (pcxl_dma_start
== 0)
345 spin_lock_init(&pcxl_res_lock
);
346 pcxl_res_size
= PCXL_DMA_MAP_SIZE
>> (PAGE_SHIFT
+ 3);
348 pcxl_res_map
= (char *)__get_free_pages(GFP_KERNEL
,
349 get_order(pcxl_res_size
));
351 proc_gsc_root
= proc_mkdir("gsc", 0);
352 create_proc_info_entry("dino", 0, proc_gsc_root
, pcxl_proc_info
);
356 __initcall(pcxl_dma_init
);
358 static void * pa11_dma_alloc_consistent (struct pci_dev
*hwdev
, size_t size
, dma_addr_t
*dma_handle
)
364 order
= get_order(size
);
365 size
= 1 << (order
+ PAGE_SHIFT
);
366 vaddr
= pcxl_alloc_range(size
);
367 paddr
= __get_free_pages(GFP_ATOMIC
, order
);
368 flush_kernel_dcache_range(paddr
, size
);
370 map_uncached_pages(vaddr
, size
, paddr
);
371 *dma_handle
= (dma_addr_t
) paddr
;
374 /* This probably isn't needed to support EISA cards.
375 ** ISA cards will certainly only support 24-bit DMA addressing.
376 ** Not clear if we can, want, or need to support ISA.
378 if (!hwdev
|| hwdev
->dma_mask
!= 0xffffffff)
381 return (void *)vaddr
;
384 static void pa11_dma_free_consistent (struct pci_dev
*hwdev
, size_t size
, void *vaddr
, dma_addr_t dma_handle
)
388 order
= get_order(size
);
389 size
= 1 << (order
+ PAGE_SHIFT
);
390 unmap_uncached_pages((unsigned long)vaddr
, size
);
391 pcxl_free_range((unsigned long)vaddr
, size
);
392 free_pages((unsigned long)__va(dma_handle
), order
);
395 static dma_addr_t
pa11_dma_map_single(struct pci_dev
*dev
, void *addr
, size_t size
, int direction
)
397 if (direction
== PCI_DMA_NONE
) {
398 printk(KERN_ERR
"pa11_dma_map_single(PCI_DMA_NONE) called by %p\n", __builtin_return_address(0));
402 flush_kernel_dcache_range((unsigned long) addr
, size
);
403 return virt_to_phys(addr
);
406 static void pa11_dma_unmap_single(struct pci_dev
*dev
, dma_addr_t dma_handle
, size_t size
, int direction
)
408 if (direction
== PCI_DMA_NONE
) {
409 printk(KERN_ERR
"pa11_dma_unmap_single(PCI_DMA_NONE) called by %p\n", __builtin_return_address(0));
413 if (direction
== PCI_DMA_TODEVICE
)
417 * For PCI_DMA_FROMDEVICE this flush is not necessary for the
418 * simple map/unmap case. However, it IS necessary if if
419 * pci_dma_sync_single has been called and the buffer reused.
422 flush_kernel_dcache_range((unsigned long) phys_to_virt(dma_handle
), size
);
426 static int pa11_dma_map_sg(struct pci_dev
*dev
, struct scatterlist
*sglist
, int nents
, int direction
)
430 if (direction
== PCI_DMA_NONE
)
433 for (i
= 0; i
< nents
; i
++, sglist
++ ) {
434 sg_dma_address(sglist
) = (dma_addr_t
) virt_to_phys(sglist
->address
);
435 sg_dma_len(sglist
) = sglist
->length
;
436 flush_kernel_dcache_range((unsigned long)sglist
->address
,
442 static void pa11_dma_unmap_sg(struct pci_dev
*dev
, struct scatterlist
*sglist
, int nents
, int direction
)
446 if (direction
== PCI_DMA_NONE
)
449 if (direction
== PCI_DMA_TODEVICE
)
452 /* once we do combining we'll need to use phys_to_virt(sg_dma_address(sglist)) */
454 for (i
= 0; i
< nents
; i
++, sglist
++ )
455 flush_kernel_dcache_range((unsigned long) sglist
->address
, sglist
->length
);
459 static void pa11_dma_sync_single(struct pci_dev
*dev
, dma_addr_t dma_handle
, size_t size
, int direction
)
461 if (direction
== PCI_DMA_NONE
)
464 flush_kernel_dcache_range((unsigned long) phys_to_virt(dma_handle
), size
);
467 static void pa11_dma_sync_sg(struct pci_dev
*dev
, struct scatterlist
*sglist
, int nents
, int direction
)
471 /* once we do combining we'll need to use phys_to_virt(sg_dma_address(sglist)) */
473 for (i
= 0; i
< nents
; i
++, sglist
++ )
474 flush_kernel_dcache_range((unsigned long) sglist
->address
, sglist
->length
);
477 struct pci_dma_ops pcxl_dma_ops
= {
478 pa11_dma_supported
, /* dma_support */
479 pa11_dma_alloc_consistent
,
480 pa11_dma_free_consistent
,
481 pa11_dma_map_single
, /* map_single */
482 pa11_dma_unmap_single
, /* unmap_single */
483 pa11_dma_map_sg
, /* map_sg */
484 pa11_dma_unmap_sg
, /* unmap_sg */
485 pa11_dma_sync_single
, /* dma_sync_single */
486 pa11_dma_sync_sg
/* dma_sync_sg */
489 static void *fail_alloc_consistent(struct pci_dev
*hwdev
, size_t size
,
490 dma_addr_t
*dma_handle
)
495 static void fail_free_consistent(struct pci_dev
*dev
, size_t size
,
496 void *vaddr
, dma_addr_t iova
)
501 struct pci_dma_ops pcx_dma_ops
= {
502 pa11_dma_supported
, /* dma_support */
503 fail_alloc_consistent
,
504 fail_free_consistent
,
505 pa11_dma_map_single
, /* map_single */
506 pa11_dma_unmap_single
, /* unmap_single */
507 pa11_dma_map_sg
, /* map_sg */
508 pa11_dma_unmap_sg
, /* unmap_sg */
509 pa11_dma_sync_single
, /* dma_sync_single */
510 pa11_dma_sync_sg
/* dma_sync_sg */
513 struct pci_dma_ops
*hppa_dma_ops
;
515 static int pcxl_proc_info(char *buf
, char **start
, off_t offset
, int len
)
518 unsigned long *res_ptr
= (u_long
*)pcxl_res_map
;
519 unsigned long total_pages
= pcxl_res_size
<< 3; /* 8 bits per byte */
521 sprintf(buf
, "\nDMA Mapping Area size : %d bytes (%d pages)\n",
523 (pcxl_res_size
<< 3) ); /* 1 bit per page */
525 sprintf(buf
, "%sResource bitmap : %d bytes (%d pages)\n",
526 buf
, pcxl_res_size
, pcxl_res_size
<< 3); /* 8 bits per byte */
528 strcat(buf
, " total: free: used: % used:\n");
529 sprintf(buf
, "%sblocks %8d %8ld %8ld %8ld%%\n", buf
, pcxl_res_size
,
530 pcxl_res_size
- pcxl_used_bytes
, pcxl_used_bytes
,
531 (pcxl_used_bytes
* 100) / pcxl_res_size
);
533 sprintf(buf
, "%spages %8ld %8ld %8ld %8ld%%\n", buf
, total_pages
,
534 total_pages
- pcxl_used_pages
, pcxl_used_pages
,
535 (pcxl_used_pages
* 100 / total_pages
));
537 strcat(buf
, "\nResource bitmap:");
539 for(; i
< (pcxl_res_size
/ sizeof(u_long
)); ++i
, ++res_ptr
) {
542 sprintf(buf
, "%s %08lx", buf
, *res_ptr
);