1 /* $Id: ioport.c,v 1.45 2001/10/30 04:54:21 davem Exp $ 2 * ioport.c: Simple io mapping allocator. 3 * 4 * Copyright (C) 1995 David S. Miller (davem@caip.rutgers.edu) 5 * Copyright (C) 1995 Miguel de Icaza (miguel@nuclecu.unam.mx) 6 * 7 * 1996: sparc_free_io, 1999: ioremap()/iounmap() by Pete Zaitcev. 8 * 9 * 2000/01/29 10 * <rth> zait: as long as pci_alloc_consistent produces something addressable, 11 * things are ok. 12 * <zaitcev> rth: no, it is relevant, because get_free_pages returns you a 13 * pointer into the big page mapping 14 * <rth> zait: so what? 15 * <rth> zait: remap_it_my_way(virt_to_phys(get_free_page())) 16 * <zaitcev> Hmm 17 * <zaitcev> Suppose I did this remap_it_my_way(virt_to_phys(get_free_page())). 18 * So far so good. 19 * <zaitcev> Now, driver calls pci_free_consistent(with result of 20 * remap_it_my_way()). 21 * <zaitcev> How do you find the address to pass to free_pages()? 22 * <rth> zait: walk the page tables? It's only two or three level after all. 23 * <rth> zait: you have to walk them anyway to remove the mapping. 24 * <zaitcev> Hmm 25 * <zaitcev> Sounds reasonable 26 */ 27 28 #include <linux/config.h> 29 #include <linux/module.h> 30 #include <linux/sched.h> 31 #include <linux/kernel.h> 32 #include <linux/errno.h> 33 #include <linux/types.h> 34 #include <linux/ioport.h> 35 #include <linux/mm.h> 36 #include <linux/slab.h> 37 #include <linux/pci.h> /* struct pci_dev */ 38 #include <linux/proc_fs.h> 39 40 #include <asm/io.h> 41 #include <asm/vaddrs.h> 42 #include <asm/oplib.h> 43 #include <asm/prom.h> 44 #include <asm/of_device.h> 45 #include <asm/sbus.h> 46 #include <asm/page.h> 47 #include <asm/pgalloc.h> 48 #include <asm/dma.h> 49 50 #define mmu_inval_dma_area(p, l) /* Anton pulled it out for 2.4.0-xx */ 51 52 struct resource *_sparc_find_resource(struct resource *r, unsigned long); 53 54 static void __iomem *_sparc_ioremap(struct resource *res, u32 bus, u32 pa, int sz); 55 static void __iomem *_sparc_alloc_io(unsigned int busno, unsigned long phys, 56 unsigned long size, char *name); 57 static void _sparc_free_io(struct resource *res); 58 59 /* This points to the next to use virtual memory for DVMA mappings */ 60 static struct resource _sparc_dvma = { 61 .name = "sparc_dvma", .start = DVMA_VADDR, .end = DVMA_END - 1 62 }; 63 /* This points to the start of I/O mappings, cluable from outside. */ 64 /*ext*/ struct resource sparc_iomap = { 65 .name = "sparc_iomap", .start = IOBASE_VADDR, .end = IOBASE_END - 1 66 }; 67 68 /* 69 * Our mini-allocator... 70 * Boy this is gross! We need it because we must map I/O for 71 * timers and interrupt controller before the kmalloc is available. 72 */ 73 74 #define XNMLN 15 75 #define XNRES 10 /* SS-10 uses 8 */ 76 77 struct xresource { 78 struct resource xres; /* Must be first */ 79 int xflag; /* 1 == used */ 80 char xname[XNMLN+1]; 81 }; 82 83 static struct xresource xresv[XNRES]; 84 85 static struct xresource *xres_alloc(void) { 86 struct xresource *xrp; 87 int n; 88 89 xrp = xresv; 90 for (n = 0; n < XNRES; n++) { 91 if (xrp->xflag == 0) { 92 xrp->xflag = 1; 93 return xrp; 94 } 95 xrp++; 96 } 97 return NULL; 98 } 99 100 static void xres_free(struct xresource *xrp) { 101 xrp->xflag = 0; 102 } 103 104 /* 105 * These are typically used in PCI drivers 106 * which are trying to be cross-platform. 107 * 108 * Bus type is always zero on IIep. 109 */ 110 void __iomem *ioremap(unsigned long offset, unsigned long size) 111 { 112 char name[14]; 113 114 sprintf(name, "phys_%08x", (u32)offset); 115 return _sparc_alloc_io(0, offset, size, name); 116 } 117 118 /* 119 * Comlimentary to ioremap(). 120 */ 121 void iounmap(volatile void __iomem *virtual) 122 { 123 unsigned long vaddr = (unsigned long) virtual & PAGE_MASK; 124 struct resource *res; 125 126 if ((res = _sparc_find_resource(&sparc_iomap, vaddr)) == NULL) { 127 printk("free_io/iounmap: cannot free %lx\n", vaddr); 128 return; 129 } 130 _sparc_free_io(res); 131 132 if ((char *)res >= (char*)xresv && (char *)res < (char *)&xresv[XNRES]) { 133 xres_free((struct xresource *)res); 134 } else { 135 kfree(res); 136 } 137 } 138 139 /* 140 */ 141 void __iomem *sbus_ioremap(struct resource *phyres, unsigned long offset, 142 unsigned long size, char *name) 143 { 144 return _sparc_alloc_io(phyres->flags & 0xF, 145 phyres->start + offset, size, name); 146 } 147 148 void __iomem *of_ioremap(struct resource *res, unsigned long offset, 149 unsigned long size, char *name) 150 { 151 return _sparc_alloc_io(res->flags & 0xF, 152 res->start + offset, 153 size, name); 154 } 155 EXPORT_SYMBOL(of_ioremap); 156 157 void of_iounmap(void __iomem *base, unsigned long size) 158 { 159 iounmap(base); 160 } 161 EXPORT_SYMBOL(of_iounmap); 162 163 /* 164 */ 165 void sbus_iounmap(volatile void __iomem *addr, unsigned long size) 166 { 167 iounmap(addr); 168 } 169 170 /* 171 * Meat of mapping 172 */ 173 static void __iomem *_sparc_alloc_io(unsigned int busno, unsigned long phys, 174 unsigned long size, char *name) 175 { 176 static int printed_full; 177 struct xresource *xres; 178 struct resource *res; 179 char *tack; 180 int tlen; 181 void __iomem *va; /* P3 diag */ 182 183 if (name == NULL) name = "???"; 184 185 if ((xres = xres_alloc()) != 0) { 186 tack = xres->xname; 187 res = &xres->xres; 188 } else { 189 if (!printed_full) { 190 printk("ioremap: done with statics, switching to malloc\n"); 191 printed_full = 1; 192 } 193 tlen = strlen(name); 194 tack = kmalloc(sizeof (struct resource) + tlen + 1, GFP_KERNEL); 195 if (tack == NULL) return NULL; 196 memset(tack, 0, sizeof(struct resource)); 197 res = (struct resource *) tack; 198 tack += sizeof (struct resource); 199 } 200 201 strlcpy(tack, name, XNMLN+1); 202 res->name = tack; 203 204 va = _sparc_ioremap(res, busno, phys, size); 205 /* printk("ioremap(0x%x:%08lx[0x%lx])=%p\n", busno, phys, size, va); */ /* P3 diag */ 206 return va; 207 } 208 209 /* 210 */ 211 static void __iomem * 212 _sparc_ioremap(struct resource *res, u32 bus, u32 pa, int sz) 213 { 214 unsigned long offset = ((unsigned long) pa) & (~PAGE_MASK); 215 216 if (allocate_resource(&sparc_iomap, res, 217 (offset + sz + PAGE_SIZE-1) & PAGE_MASK, 218 sparc_iomap.start, sparc_iomap.end, PAGE_SIZE, NULL, NULL) != 0) { 219 /* Usually we cannot see printks in this case. */ 220 prom_printf("alloc_io_res(%s): cannot occupy\n", 221 (res->name != NULL)? res->name: "???"); 222 prom_halt(); 223 } 224 225 pa &= PAGE_MASK; 226 sparc_mapiorange(bus, pa, res->start, res->end - res->start + 1); 227 228 return (void __iomem *)(unsigned long)(res->start + offset); 229 } 230 231 /* 232 * Comlimentary to _sparc_ioremap(). 233 */ 234 static void _sparc_free_io(struct resource *res) 235 { 236 unsigned long plen; 237 238 plen = res->end - res->start + 1; 239 BUG_ON((plen & (PAGE_SIZE-1)) != 0); 240 sparc_unmapiorange(res->start, plen); 241 release_resource(res); 242 } 243 244 #ifdef CONFIG_SBUS 245 246 void sbus_set_sbus64(struct sbus_dev *sdev, int x) 247 { 248 printk("sbus_set_sbus64: unsupported\n"); 249 } 250 251 extern unsigned int sun4d_build_irq(struct sbus_dev *sdev, int irq); 252 void __init sbus_fill_device_irq(struct sbus_dev *sdev) 253 { 254 struct linux_prom_irqs irqs[PROMINTR_MAX]; 255 int len; 256 257 len = prom_getproperty(sdev->prom_node, "intr", 258 (char *)irqs, sizeof(irqs)); 259 if (len != -1) { 260 sdev->num_irqs = len / 8; 261 if (sdev->num_irqs == 0) { 262 sdev->irqs[0] = 0; 263 } else if (sparc_cpu_model == sun4d) { 264 for (len = 0; len < sdev->num_irqs; len++) 265 sdev->irqs[len] = 266 sun4d_build_irq(sdev, irqs[len].pri); 267 } else { 268 for (len = 0; len < sdev->num_irqs; len++) 269 sdev->irqs[len] = irqs[len].pri; 270 } 271 } else { 272 int interrupts[PROMINTR_MAX]; 273 274 /* No "intr" node found-- check for "interrupts" node. 275 * This node contains SBus interrupt levels, not IPLs 276 * as in "intr", and no vector values. We convert 277 * SBus interrupt levels to PILs (platform specific). 278 */ 279 len = prom_getproperty(sdev->prom_node, "interrupts", 280 (char *)interrupts, sizeof(interrupts)); 281 if (len == -1) { 282 sdev->irqs[0] = 0; 283 sdev->num_irqs = 0; 284 } else { 285 sdev->num_irqs = len / sizeof(int); 286 for (len = 0; len < sdev->num_irqs; len++) { 287 sdev->irqs[len] = 288 sbint_to_irq(sdev, interrupts[len]); 289 } 290 } 291 } 292 } 293 294 /* 295 * Allocate a chunk of memory suitable for DMA. 296 * Typically devices use them for control blocks. 297 * CPU may access them without any explicit flushing. 298 * 299 * XXX Some clever people know that sdev is not used and supply NULL. Watch. 300 */ 301 void *sbus_alloc_consistent(struct sbus_dev *sdev, long len, u32 *dma_addrp) 302 { 303 unsigned long len_total = (len + PAGE_SIZE-1) & PAGE_MASK; 304 unsigned long va; 305 struct resource *res; 306 int order; 307 308 /* XXX why are some lenghts signed, others unsigned? */ 309 if (len <= 0) { 310 return NULL; 311 } 312 /* XXX So what is maxphys for us and how do drivers know it? */ 313 if (len > 256*1024) { /* __get_free_pages() limit */ 314 return NULL; 315 } 316 317 order = get_order(len_total); 318 if ((va = __get_free_pages(GFP_KERNEL|__GFP_COMP, order)) == 0) 319 goto err_nopages; 320 321 if ((res = kmalloc(sizeof(struct resource), GFP_KERNEL)) == NULL) 322 goto err_nomem; 323 memset((char*)res, 0, sizeof(struct resource)); 324 325 if (allocate_resource(&_sparc_dvma, res, len_total, 326 _sparc_dvma.start, _sparc_dvma.end, PAGE_SIZE, NULL, NULL) != 0) { 327 printk("sbus_alloc_consistent: cannot occupy 0x%lx", len_total); 328 goto err_nova; 329 } 330 mmu_inval_dma_area(va, len_total); 331 // XXX The mmu_map_dma_area does this for us below, see comments. 332 // sparc_mapiorange(0, virt_to_phys(va), res->start, len_total); 333 /* 334 * XXX That's where sdev would be used. Currently we load 335 * all iommu tables with the same translations. 336 */ 337 if (mmu_map_dma_area(dma_addrp, va, res->start, len_total) != 0) 338 goto err_noiommu; 339 340 /* Set the resource name, if known. */ 341 if (sdev) { 342 res->name = sdev->prom_name; 343 } 344 345 return (void *)(unsigned long)res->start; 346 347 err_noiommu: 348 release_resource(res); 349 err_nova: 350 free_pages(va, order); 351 err_nomem: 352 kfree(res); 353 err_nopages: 354 return NULL; 355 } 356 357 void sbus_free_consistent(struct sbus_dev *sdev, long n, void *p, u32 ba) 358 { 359 struct resource *res; 360 struct page *pgv; 361 362 if ((res = _sparc_find_resource(&_sparc_dvma, 363 (unsigned long)p)) == NULL) { 364 printk("sbus_free_consistent: cannot free %p\n", p); 365 return; 366 } 367 368 if (((unsigned long)p & (PAGE_SIZE-1)) != 0) { 369 printk("sbus_free_consistent: unaligned va %p\n", p); 370 return; 371 } 372 373 n = (n + PAGE_SIZE-1) & PAGE_MASK; 374 if ((res->end-res->start)+1 != n) { 375 printk("sbus_free_consistent: region 0x%lx asked 0x%lx\n", 376 (long)((res->end-res->start)+1), n); 377 return; 378 } 379 380 release_resource(res); 381 kfree(res); 382 383 /* mmu_inval_dma_area(va, n); */ /* it's consistent, isn't it */ 384 pgv = mmu_translate_dvma(ba); 385 mmu_unmap_dma_area(ba, n); 386 387 __free_pages(pgv, get_order(n)); 388 } 389 390 /* 391 * Map a chunk of memory so that devices can see it. 392 * CPU view of this memory may be inconsistent with 393 * a device view and explicit flushing is necessary. 394 */ 395 dma_addr_t sbus_map_single(struct sbus_dev *sdev, void *va, size_t len, int direction) 396 { 397 /* XXX why are some lenghts signed, others unsigned? */ 398 if (len <= 0) { 399 return 0; 400 } 401 /* XXX So what is maxphys for us and how do drivers know it? */ 402 if (len > 256*1024) { /* __get_free_pages() limit */ 403 return 0; 404 } 405 return mmu_get_scsi_one(va, len, sdev->bus); 406 } 407 408 void sbus_unmap_single(struct sbus_dev *sdev, dma_addr_t ba, size_t n, int direction) 409 { 410 mmu_release_scsi_one(ba, n, sdev->bus); 411 } 412 413 int sbus_map_sg(struct sbus_dev *sdev, struct scatterlist *sg, int n, int direction) 414 { 415 mmu_get_scsi_sgl(sg, n, sdev->bus); 416 417 /* 418 * XXX sparc64 can return a partial length here. sun4c should do this 419 * but it currently panics if it can't fulfill the request - Anton 420 */ 421 return n; 422 } 423 424 void sbus_unmap_sg(struct sbus_dev *sdev, struct scatterlist *sg, int n, int direction) 425 { 426 mmu_release_scsi_sgl(sg, n, sdev->bus); 427 } 428 429 /* 430 */ 431 void sbus_dma_sync_single_for_cpu(struct sbus_dev *sdev, dma_addr_t ba, size_t size, int direction) 432 { 433 #if 0 434 unsigned long va; 435 struct resource *res; 436 437 /* We do not need the resource, just print a message if invalid. */ 438 res = _sparc_find_resource(&_sparc_dvma, ba); 439 if (res == NULL) 440 panic("sbus_dma_sync_single: 0x%x\n", ba); 441 442 va = page_address(mmu_translate_dvma(ba)); /* XXX higmem */ 443 /* 444 * XXX This bogosity will be fixed with the iommu rewrite coming soon 445 * to a kernel near you. - Anton 446 */ 447 /* mmu_inval_dma_area(va, (size + PAGE_SIZE-1) & PAGE_MASK); */ 448 #endif 449 } 450 451 void sbus_dma_sync_single_for_device(struct sbus_dev *sdev, dma_addr_t ba, size_t size, int direction) 452 { 453 #if 0 454 unsigned long va; 455 struct resource *res; 456 457 /* We do not need the resource, just print a message if invalid. */ 458 res = _sparc_find_resource(&_sparc_dvma, ba); 459 if (res == NULL) 460 panic("sbus_dma_sync_single: 0x%x\n", ba); 461 462 va = page_address(mmu_translate_dvma(ba)); /* XXX higmem */ 463 /* 464 * XXX This bogosity will be fixed with the iommu rewrite coming soon 465 * to a kernel near you. - Anton 466 */ 467 /* mmu_inval_dma_area(va, (size + PAGE_SIZE-1) & PAGE_MASK); */ 468 #endif 469 } 470 471 void sbus_dma_sync_sg_for_cpu(struct sbus_dev *sdev, struct scatterlist *sg, int n, int direction) 472 { 473 printk("sbus_dma_sync_sg_for_cpu: not implemented yet\n"); 474 } 475 476 void sbus_dma_sync_sg_for_device(struct sbus_dev *sdev, struct scatterlist *sg, int n, int direction) 477 { 478 printk("sbus_dma_sync_sg_for_device: not implemented yet\n"); 479 } 480 481 /* Support code for sbus_init(). */ 482 /* 483 * XXX This functions appears to be a distorted version of 484 * prom_sbus_ranges_init(), with all sun4d stuff cut away. 485 * Ask DaveM what is going on here, how is sun4d supposed to work... XXX 486 */ 487 /* added back sun4d patch from Thomas Bogendoerfer - should be OK (crn) */ 488 void __init sbus_arch_bus_ranges_init(struct device_node *pn, struct sbus_bus *sbus) 489 { 490 int parent_node = pn->node; 491 492 if (sparc_cpu_model == sun4d) { 493 struct linux_prom_ranges iounit_ranges[PROMREG_MAX]; 494 int num_iounit_ranges, len; 495 496 len = prom_getproperty(parent_node, "ranges", 497 (char *) iounit_ranges, 498 sizeof (iounit_ranges)); 499 if (len != -1) { 500 num_iounit_ranges = 501 (len / sizeof(struct linux_prom_ranges)); 502 prom_adjust_ranges(sbus->sbus_ranges, 503 sbus->num_sbus_ranges, 504 iounit_ranges, num_iounit_ranges); 505 } 506 } 507 } 508 509 void __init sbus_setup_iommu(struct sbus_bus *sbus, struct device_node *dp) 510 { 511 #ifndef CONFIG_SUN4 512 struct device_node *parent = dp->parent; 513 514 if (sparc_cpu_model != sun4d && 515 parent != NULL && 516 !strcmp(parent->name, "iommu")) { 517 extern void iommu_init(int iommu_node, struct sbus_bus *sbus); 518 519 iommu_init(parent->node, sbus); 520 } 521 522 if (sparc_cpu_model == sun4d) { 523 extern void iounit_init(int sbi_node, int iounit_node, 524 struct sbus_bus *sbus); 525 526 iounit_init(dp->node, parent->node, sbus); 527 } 528 #endif 529 } 530 531 void __init sbus_setup_arch_props(struct sbus_bus *sbus, struct device_node *dp) 532 { 533 if (sparc_cpu_model == sun4d) { 534 struct device_node *parent = dp->parent; 535 536 sbus->devid = of_getintprop_default(parent, "device-id", 0); 537 sbus->board = of_getintprop_default(parent, "board#", 0); 538 } 539 } 540 541 int __init sbus_arch_preinit(void) 542 { 543 extern void register_proc_sparc_ioport(void); 544 545 register_proc_sparc_ioport(); 546 547 #ifdef CONFIG_SUN4 548 { 549 extern void sun4_dvma_init(void); 550 sun4_dvma_init(); 551 } 552 return 1; 553 #else 554 return 0; 555 #endif 556 } 557 558 void __init sbus_arch_postinit(void) 559 { 560 if (sparc_cpu_model == sun4d) { 561 extern void sun4d_init_sbi_irq(void); 562 sun4d_init_sbi_irq(); 563 } 564 } 565 #endif /* CONFIG_SBUS */ 566 567 #ifdef CONFIG_PCI 568 569 /* Allocate and map kernel buffer using consistent mode DMA for a device. 570 * hwdev should be valid struct pci_dev pointer for PCI devices. 571 */ 572 void *pci_alloc_consistent(struct pci_dev *pdev, size_t len, dma_addr_t *pba) 573 { 574 unsigned long len_total = (len + PAGE_SIZE-1) & PAGE_MASK; 575 unsigned long va; 576 struct resource *res; 577 int order; 578 579 if (len == 0) { 580 return NULL; 581 } 582 if (len > 256*1024) { /* __get_free_pages() limit */ 583 return NULL; 584 } 585 586 order = get_order(len_total); 587 va = __get_free_pages(GFP_KERNEL, order); 588 if (va == 0) { 589 printk("pci_alloc_consistent: no %ld pages\n", len_total>>PAGE_SHIFT); 590 return NULL; 591 } 592 593 if ((res = kmalloc(sizeof(struct resource), GFP_KERNEL)) == NULL) { 594 free_pages(va, order); 595 printk("pci_alloc_consistent: no core\n"); 596 return NULL; 597 } 598 memset((char*)res, 0, sizeof(struct resource)); 599 600 if (allocate_resource(&_sparc_dvma, res, len_total, 601 _sparc_dvma.start, _sparc_dvma.end, PAGE_SIZE, NULL, NULL) != 0) { 602 printk("pci_alloc_consistent: cannot occupy 0x%lx", len_total); 603 free_pages(va, order); 604 kfree(res); 605 return NULL; 606 } 607 mmu_inval_dma_area(va, len_total); 608 #if 0 609 /* P3 */ printk("pci_alloc_consistent: kva %lx uncva %lx phys %lx size %lx\n", 610 (long)va, (long)res->start, (long)virt_to_phys(va), len_total); 611 #endif 612 sparc_mapiorange(0, virt_to_phys(va), res->start, len_total); 613 614 *pba = virt_to_phys(va); /* equals virt_to_bus (R.I.P.) for us. */ 615 return (void *) res->start; 616 } 617 618 /* Free and unmap a consistent DMA buffer. 619 * cpu_addr is what was returned from pci_alloc_consistent, 620 * size must be the same as what as passed into pci_alloc_consistent, 621 * and likewise dma_addr must be the same as what *dma_addrp was set to. 622 * 623 * References to the memory and mappings assosciated with cpu_addr/dma_addr 624 * past this call are illegal. 625 */ 626 void pci_free_consistent(struct pci_dev *pdev, size_t n, void *p, dma_addr_t ba) 627 { 628 struct resource *res; 629 unsigned long pgp; 630 631 if ((res = _sparc_find_resource(&_sparc_dvma, 632 (unsigned long)p)) == NULL) { 633 printk("pci_free_consistent: cannot free %p\n", p); 634 return; 635 } 636 637 if (((unsigned long)p & (PAGE_SIZE-1)) != 0) { 638 printk("pci_free_consistent: unaligned va %p\n", p); 639 return; 640 } 641 642 n = (n + PAGE_SIZE-1) & PAGE_MASK; 643 if ((res->end-res->start)+1 != n) { 644 printk("pci_free_consistent: region 0x%lx asked 0x%lx\n", 645 (long)((res->end-res->start)+1), (long)n); 646 return; 647 } 648 649 pgp = (unsigned long) phys_to_virt(ba); /* bus_to_virt actually */ 650 mmu_inval_dma_area(pgp, n); 651 sparc_unmapiorange((unsigned long)p, n); 652 653 release_resource(res); 654 kfree(res); 655 656 free_pages(pgp, get_order(n)); 657 } 658 659 /* Map a single buffer of the indicated size for DMA in streaming mode. 660 * The 32-bit bus address to use is returned. 661 * 662 * Once the device is given the dma address, the device owns this memory 663 * until either pci_unmap_single or pci_dma_sync_single_* is performed. 664 */ 665 dma_addr_t pci_map_single(struct pci_dev *hwdev, void *ptr, size_t size, 666 int direction) 667 { 668 BUG_ON(direction == PCI_DMA_NONE); 669 /* IIep is write-through, not flushing. */ 670 return virt_to_phys(ptr); 671 } 672 673 /* Unmap a single streaming mode DMA translation. The dma_addr and size 674 * must match what was provided for in a previous pci_map_single call. All 675 * other usages are undefined. 676 * 677 * After this call, reads by the cpu to the buffer are guaranteed to see 678 * whatever the device wrote there. 679 */ 680 void pci_unmap_single(struct pci_dev *hwdev, dma_addr_t ba, size_t size, 681 int direction) 682 { 683 BUG_ON(direction == PCI_DMA_NONE); 684 if (direction != PCI_DMA_TODEVICE) { 685 mmu_inval_dma_area((unsigned long)phys_to_virt(ba), 686 (size + PAGE_SIZE-1) & PAGE_MASK); 687 } 688 } 689 690 /* 691 * Same as pci_map_single, but with pages. 692 */ 693 dma_addr_t pci_map_page(struct pci_dev *hwdev, struct page *page, 694 unsigned long offset, size_t size, int direction) 695 { 696 BUG_ON(direction == PCI_DMA_NONE); 697 /* IIep is write-through, not flushing. */ 698 return page_to_phys(page) + offset; 699 } 700 701 void pci_unmap_page(struct pci_dev *hwdev, 702 dma_addr_t dma_address, size_t size, int direction) 703 { 704 BUG_ON(direction == PCI_DMA_NONE); 705 /* mmu_inval_dma_area XXX */ 706 } 707 708 /* Map a set of buffers described by scatterlist in streaming 709 * mode for DMA. This is the scather-gather version of the 710 * above pci_map_single interface. Here the scatter gather list 711 * elements are each tagged with the appropriate dma address 712 * and length. They are obtained via sg_dma_{address,length}(SG). 713 * 714 * NOTE: An implementation may be able to use a smaller number of 715 * DMA address/length pairs than there are SG table elements. 716 * (for example via virtual mapping capabilities) 717 * The routine returns the number of addr/length pairs actually 718 * used, at most nents. 719 * 720 * Device ownership issues as mentioned above for pci_map_single are 721 * the same here. 722 */ 723 int pci_map_sg(struct pci_dev *hwdev, struct scatterlist *sg, int nents, 724 int direction) 725 { 726 int n; 727 728 BUG_ON(direction == PCI_DMA_NONE); 729 /* IIep is write-through, not flushing. */ 730 for (n = 0; n < nents; n++) { 731 BUG_ON(page_address(sg->page) == NULL); 732 sg->dvma_address = virt_to_phys(page_address(sg->page)); 733 sg->dvma_length = sg->length; 734 sg++; 735 } 736 return nents; 737 } 738 739 /* Unmap a set of streaming mode DMA translations. 740 * Again, cpu read rules concerning calls here are the same as for 741 * pci_unmap_single() above. 742 */ 743 void pci_unmap_sg(struct pci_dev *hwdev, struct scatterlist *sg, int nents, 744 int direction) 745 { 746 int n; 747 748 BUG_ON(direction == PCI_DMA_NONE); 749 if (direction != PCI_DMA_TODEVICE) { 750 for (n = 0; n < nents; n++) { 751 BUG_ON(page_address(sg->page) == NULL); 752 mmu_inval_dma_area( 753 (unsigned long) page_address(sg->page), 754 (sg->length + PAGE_SIZE-1) & PAGE_MASK); 755 sg++; 756 } 757 } 758 } 759 760 /* Make physical memory consistent for a single 761 * streaming mode DMA translation before or after a transfer. 762 * 763 * If you perform a pci_map_single() but wish to interrogate the 764 * buffer using the cpu, yet do not wish to teardown the PCI dma 765 * mapping, you must call this function before doing so. At the 766 * next point you give the PCI dma address back to the card, you 767 * must first perform a pci_dma_sync_for_device, and then the 768 * device again owns the buffer. 769 */ 770 void pci_dma_sync_single_for_cpu(struct pci_dev *hwdev, dma_addr_t ba, size_t size, int direction) 771 { 772 BUG_ON(direction == PCI_DMA_NONE); 773 if (direction != PCI_DMA_TODEVICE) { 774 mmu_inval_dma_area((unsigned long)phys_to_virt(ba), 775 (size + PAGE_SIZE-1) & PAGE_MASK); 776 } 777 } 778 779 void pci_dma_sync_single_for_device(struct pci_dev *hwdev, dma_addr_t ba, size_t size, int direction) 780 { 781 BUG_ON(direction == PCI_DMA_NONE); 782 if (direction != PCI_DMA_TODEVICE) { 783 mmu_inval_dma_area((unsigned long)phys_to_virt(ba), 784 (size + PAGE_SIZE-1) & PAGE_MASK); 785 } 786 } 787 788 /* Make physical memory consistent for a set of streaming 789 * mode DMA translations after a transfer. 790 * 791 * The same as pci_dma_sync_single_* but for a scatter-gather list, 792 * same rules and usage. 793 */ 794 void pci_dma_sync_sg_for_cpu(struct pci_dev *hwdev, struct scatterlist *sg, int nents, int direction) 795 { 796 int n; 797 798 BUG_ON(direction == PCI_DMA_NONE); 799 if (direction != PCI_DMA_TODEVICE) { 800 for (n = 0; n < nents; n++) { 801 BUG_ON(page_address(sg->page) == NULL); 802 mmu_inval_dma_area( 803 (unsigned long) page_address(sg->page), 804 (sg->length + PAGE_SIZE-1) & PAGE_MASK); 805 sg++; 806 } 807 } 808 } 809 810 void pci_dma_sync_sg_for_device(struct pci_dev *hwdev, struct scatterlist *sg, int nents, int direction) 811 { 812 int n; 813 814 BUG_ON(direction == PCI_DMA_NONE); 815 if (direction != PCI_DMA_TODEVICE) { 816 for (n = 0; n < nents; n++) { 817 BUG_ON(page_address(sg->page) == NULL); 818 mmu_inval_dma_area( 819 (unsigned long) page_address(sg->page), 820 (sg->length + PAGE_SIZE-1) & PAGE_MASK); 821 sg++; 822 } 823 } 824 } 825 #endif /* CONFIG_PCI */ 826 827 #ifdef CONFIG_PROC_FS 828 829 static int 830 _sparc_io_get_info(char *buf, char **start, off_t fpos, int length, int *eof, 831 void *data) 832 { 833 char *p = buf, *e = buf + length; 834 struct resource *r; 835 const char *nm; 836 837 for (r = ((struct resource *)data)->child; r != NULL; r = r->sibling) { 838 if (p + 32 >= e) /* Better than nothing */ 839 break; 840 if ((nm = r->name) == 0) nm = "???"; 841 p += sprintf(p, "%016llx-%016llx: %s\n", 842 (unsigned long long)r->start, 843 (unsigned long long)r->end, nm); 844 } 845 846 return p-buf; 847 } 848 849 #endif /* CONFIG_PROC_FS */ 850 851 /* 852 * This is a version of find_resource and it belongs to kernel/resource.c. 853 * Until we have agreement with Linus and Martin, it lingers here. 854 * 855 * XXX Too slow. Can have 8192 DVMA pages on sun4m in the worst case. 856 * This probably warrants some sort of hashing. 857 */ 858 struct resource * 859 _sparc_find_resource(struct resource *root, unsigned long hit) 860 { 861 struct resource *tmp; 862 863 for (tmp = root->child; tmp != 0; tmp = tmp->sibling) { 864 if (tmp->start <= hit && tmp->end >= hit) 865 return tmp; 866 } 867 return NULL; 868 } 869 870 void register_proc_sparc_ioport(void) 871 { 872 #ifdef CONFIG_PROC_FS 873 create_proc_read_entry("io_map",0,NULL,_sparc_io_get_info,&sparc_iomap); 874 create_proc_read_entry("dvma_map",0,NULL,_sparc_io_get_info,&_sparc_dvma); 875 #endif 876 } 877