1 /*- 2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD 3 * 4 * Copyright (C) 2010 Nathan Whitehorn 5 * Copyright (C) 2011 glevand (geoffrey.levand@mail.ru) 6 * All rights reserved. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 20 * IN NO EVENT SHALL TOOLS GMBH BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 21 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 22 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; 23 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 24 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR 25 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF 26 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 27 */ 28 29 #include <sys/cdefs.h> 30 __FBSDID("$FreeBSD$"); 31 32 #include <sys/param.h> 33 #include <sys/systm.h> 34 #include <sys/kernel.h> 35 #include <sys/module.h> 36 #include <sys/malloc.h> 37 #include <sys/bus.h> 38 #include <sys/clock.h> 39 #include <sys/cpu.h> 40 #include <sys/resource.h> 41 #include <sys/rman.h> 42 43 #include <vm/vm.h> 44 #include <vm/pmap.h> 45 46 #include <machine/bus.h> 47 #include <machine/platform.h> 48 #include <machine/resource.h> 49 50 #include "ps3bus.h" 51 #include "ps3-hvcall.h" 52 #include "iommu_if.h" 53 #include "clock_if.h" 54 55 static void ps3bus_identify(driver_t *, device_t); 56 static int ps3bus_probe(device_t); 57 static int ps3bus_attach(device_t); 58 static int ps3bus_print_child(device_t dev, device_t child); 59 static int ps3bus_read_ivar(device_t bus, device_t child, int which, 60 uintptr_t *result); 61 static struct resource *ps3bus_alloc_resource(device_t bus, device_t child, 62 int type, int *rid, rman_res_t start, rman_res_t end, 63 rman_res_t count, u_int flags); 64 static int ps3bus_activate_resource(device_t bus, device_t child, int type, 65 int rid, struct resource *res); 66 static bus_dma_tag_t ps3bus_get_dma_tag(device_t dev, device_t child); 67 static int ps3_iommu_map(device_t dev, bus_dma_segment_t *segs, int *nsegs, bus_addr_t min, bus_addr_t max, bus_size_t alignment, 68 bus_addr_t boundary, void *cookie); 69 static int ps3_iommu_unmap(device_t dev, bus_dma_segment_t *segs, 70 int nsegs, void *cookie); 71 static int ps3_gettime(device_t dev, struct timespec *ts); 72 static int ps3_settime(device_t dev, struct timespec *ts); 73 74 struct ps3bus_devinfo { 75 int bus; 76 int dev; 77 uint64_t bustype; 78 uint64_t devtype; 79 int busidx; 80 int devidx; 81 82 struct resource_list resources; 83 bus_dma_tag_t dma_tag; 84 85 struct mtx iommu_mtx; 86 bus_addr_t dma_base[4]; 87 }; 88 89 static MALLOC_DEFINE(M_PS3BUS, "ps3bus", "PS3 system bus device information"); 90 91 enum ps3bus_irq_type { 92 SB_IRQ = 2, 93 OHCI_IRQ = 3, 94 EHCI_IRQ = 4, 95 }; 96 97 enum ps3bus_reg_type { 98 OHCI_REG = 3, 99 EHCI_REG = 4, 100 }; 101 102 static device_method_t ps3bus_methods[] = { 103 /* Device interface */ 104 DEVMETHOD(device_identify, ps3bus_identify), 105 DEVMETHOD(device_probe, ps3bus_probe), 106 DEVMETHOD(device_attach, ps3bus_attach), 107 108 /* Bus interface */ 109 DEVMETHOD(bus_add_child, bus_generic_add_child), 110 DEVMETHOD(bus_get_dma_tag, ps3bus_get_dma_tag), 111 DEVMETHOD(bus_print_child, ps3bus_print_child), 112 DEVMETHOD(bus_read_ivar, ps3bus_read_ivar), 113 DEVMETHOD(bus_alloc_resource, ps3bus_alloc_resource), 114 DEVMETHOD(bus_activate_resource, ps3bus_activate_resource), 115 DEVMETHOD(bus_setup_intr, bus_generic_setup_intr), 116 DEVMETHOD(bus_teardown_intr, bus_generic_teardown_intr), 117 118 /* IOMMU interface */ 119 DEVMETHOD(iommu_map, ps3_iommu_map), 120 DEVMETHOD(iommu_unmap, ps3_iommu_unmap), 121 122 /* Clock interface */ 123 DEVMETHOD(clock_gettime, ps3_gettime), 124 DEVMETHOD(clock_settime, ps3_settime), 125 126 DEVMETHOD_END 127 }; 128 129 struct ps3bus_softc { 130 struct rman sc_mem_rman; 131 struct rman sc_intr_rman; 132 struct mem_region *regions; 133 int rcount; 134 }; 135 136 static driver_t ps3bus_driver = { 137 "ps3bus", 138 ps3bus_methods, 139 sizeof(struct ps3bus_softc) 140 }; 141 142 static devclass_t ps3bus_devclass; 143 144 DRIVER_MODULE(ps3bus, nexus, ps3bus_driver, ps3bus_devclass, 0, 0); 145 146 static void 147 ps3bus_identify(driver_t *driver, device_t parent) 148 { 149 if (strcmp(installed_platform(), "ps3") != 0) 150 return; 151 152 if (device_find_child(parent, "ps3bus", -1) == NULL) 153 BUS_ADD_CHILD(parent, 0, "ps3bus", 0); 154 } 155 156 static int 157 ps3bus_probe(device_t dev) 158 { 159 /* Do not attach to any OF nodes that may be present */ 160 161 device_set_desc(dev, "Playstation 3 System Bus"); 162 163 return (BUS_PROBE_NOWILDCARD); 164 } 165 166 static void 167 ps3bus_resources_init(struct rman *rm, int bus_index, int dev_index, 168 struct ps3bus_devinfo *dinfo) 169 { 170 uint64_t irq_type, irq, outlet; 171 uint64_t reg_type, paddr, len; 172 uint64_t ppe, junk; 173 int i, result; 174 int thread; 175 176 resource_list_init(&dinfo->resources); 177 178 lv1_get_logical_ppe_id(&ppe); 179 thread = 32 - fls(mfctrl()); 180 181 /* Scan for interrupts */ 182 for (i = 0; i < 10; i++) { 183 result = lv1_get_repository_node_value(PS3_LPAR_ID_PME, 184 (lv1_repository_string("bus") >> 32) | bus_index, 185 lv1_repository_string("dev") | dev_index, 186 lv1_repository_string("intr") | i, 0, &irq_type, &irq); 187 188 if (result != 0) 189 break; 190 191 switch (irq_type) { 192 case SB_IRQ: 193 lv1_construct_event_receive_port(&outlet); 194 lv1_connect_irq_plug_ext(ppe, thread, outlet, outlet, 195 0); 196 lv1_connect_interrupt_event_receive_port(dinfo->bus, 197 dinfo->dev, outlet, irq); 198 break; 199 case OHCI_IRQ: 200 case EHCI_IRQ: 201 lv1_construct_io_irq_outlet(irq, &outlet); 202 lv1_connect_irq_plug_ext(ppe, thread, outlet, outlet, 203 0); 204 break; 205 default: 206 printf("Unknown IRQ type %ld for device %d.%d\n", 207 irq_type, dinfo->bus, dinfo->dev); 208 break; 209 } 210 211 resource_list_add(&dinfo->resources, SYS_RES_IRQ, i, 212 outlet, outlet, 1); 213 } 214 215 /* Scan for registers */ 216 for (i = 0; i < 10; i++) { 217 result = lv1_get_repository_node_value(PS3_LPAR_ID_PME, 218 (lv1_repository_string("bus") >> 32) | bus_index, 219 lv1_repository_string("dev") | dev_index, 220 lv1_repository_string("reg") | i, 221 lv1_repository_string("type"), ®_type, &junk); 222 223 if (result != 0) 224 break; 225 226 result = lv1_get_repository_node_value(PS3_LPAR_ID_PME, 227 (lv1_repository_string("bus") >> 32) | bus_index, 228 lv1_repository_string("dev") | dev_index, 229 lv1_repository_string("reg") | i, 230 lv1_repository_string("data"), &paddr, &len); 231 232 result = lv1_map_device_mmio_region(dinfo->bus, dinfo->dev, 233 paddr, len, 12 /* log_2(4 KB) */, &paddr); 234 235 if (result != 0) { 236 printf("Mapping registers failed for device " 237 "%d.%d (%ld.%ld): %d\n", dinfo->bus, dinfo->dev, 238 dinfo->bustype, dinfo->devtype, result); 239 continue; 240 } 241 242 rman_manage_region(rm, paddr, paddr + len - 1); 243 resource_list_add(&dinfo->resources, SYS_RES_MEMORY, i, 244 paddr, paddr + len, len); 245 } 246 } 247 248 static void 249 ps3bus_resources_init_by_type(struct rman *rm, int bus_index, int dev_index, 250 uint64_t irq_type, uint64_t reg_type, struct ps3bus_devinfo *dinfo) 251 { 252 uint64_t _irq_type, irq, outlet; 253 uint64_t _reg_type, paddr, len; 254 uint64_t ppe, junk; 255 int i, result; 256 int thread; 257 258 resource_list_init(&dinfo->resources); 259 260 lv1_get_logical_ppe_id(&ppe); 261 thread = 32 - fls(mfctrl()); 262 263 /* Scan for interrupts */ 264 for (i = 0; i < 10; i++) { 265 result = lv1_get_repository_node_value(PS3_LPAR_ID_PME, 266 (lv1_repository_string("bus") >> 32) | bus_index, 267 lv1_repository_string("dev") | dev_index, 268 lv1_repository_string("intr") | i, 0, &_irq_type, &irq); 269 270 if (result != 0) 271 break; 272 273 if (_irq_type != irq_type) 274 continue; 275 276 lv1_construct_io_irq_outlet(irq, &outlet); 277 lv1_connect_irq_plug_ext(ppe, thread, outlet, outlet, 278 0); 279 resource_list_add(&dinfo->resources, SYS_RES_IRQ, i, 280 outlet, outlet, 1); 281 } 282 283 /* Scan for registers */ 284 for (i = 0; i < 10; i++) { 285 result = lv1_get_repository_node_value(PS3_LPAR_ID_PME, 286 (lv1_repository_string("bus") >> 32) | bus_index, 287 lv1_repository_string("dev") | dev_index, 288 lv1_repository_string("reg") | i, 289 lv1_repository_string("type"), &_reg_type, &junk); 290 291 if (result != 0) 292 break; 293 294 if (_reg_type != reg_type) 295 continue; 296 297 result = lv1_get_repository_node_value(PS3_LPAR_ID_PME, 298 (lv1_repository_string("bus") >> 32) | bus_index, 299 lv1_repository_string("dev") | dev_index, 300 lv1_repository_string("reg") | i, 301 lv1_repository_string("data"), &paddr, &len); 302 303 result = lv1_map_device_mmio_region(dinfo->bus, dinfo->dev, 304 paddr, len, 12 /* log_2(4 KB) */, &paddr); 305 306 if (result != 0) { 307 printf("Mapping registers failed for device " 308 "%d.%d (%ld.%ld): %d\n", dinfo->bus, dinfo->dev, 309 dinfo->bustype, dinfo->devtype, result); 310 break; 311 } 312 313 rman_manage_region(rm, paddr, paddr + len - 1); 314 resource_list_add(&dinfo->resources, SYS_RES_MEMORY, i, 315 paddr, paddr + len, len); 316 } 317 } 318 319 static int 320 ps3bus_attach(device_t self) 321 { 322 struct ps3bus_softc *sc; 323 struct ps3bus_devinfo *dinfo; 324 int bus_index, dev_index, result; 325 uint64_t bustype, bus, devs; 326 uint64_t dev, devtype; 327 uint64_t junk; 328 device_t cdev; 329 330 sc = device_get_softc(self); 331 sc->sc_mem_rman.rm_type = RMAN_ARRAY; 332 sc->sc_mem_rman.rm_descr = "PS3Bus Memory Mapped I/O"; 333 sc->sc_intr_rman.rm_type = RMAN_ARRAY; 334 sc->sc_intr_rman.rm_descr = "PS3Bus Interrupts"; 335 rman_init(&sc->sc_mem_rman); 336 rman_init(&sc->sc_intr_rman); 337 rman_manage_region(&sc->sc_intr_rman, 0, ~0); 338 339 /* Get memory regions for DMA */ 340 mem_regions(&sc->regions, &sc->rcount, NULL, NULL); 341 342 /* 343 * Probe all the PS3's buses. 344 */ 345 346 for (bus_index = 0; bus_index < 5; bus_index++) { 347 result = lv1_get_repository_node_value(PS3_LPAR_ID_PME, 348 (lv1_repository_string("bus") >> 32) | bus_index, 349 lv1_repository_string("type"), 0, 0, &bustype, &junk); 350 351 if (result != 0) 352 continue; 353 354 result = lv1_get_repository_node_value(PS3_LPAR_ID_PME, 355 (lv1_repository_string("bus") >> 32) | bus_index, 356 lv1_repository_string("id"), 0, 0, &bus, &junk); 357 358 if (result != 0) 359 continue; 360 361 result = lv1_get_repository_node_value(PS3_LPAR_ID_PME, 362 (lv1_repository_string("bus") >> 32) | bus_index, 363 lv1_repository_string("num_dev"), 0, 0, &devs, &junk); 364 365 for (dev_index = 0; dev_index < devs; dev_index++) { 366 result = lv1_get_repository_node_value(PS3_LPAR_ID_PME, 367 (lv1_repository_string("bus") >> 32) | bus_index, 368 lv1_repository_string("dev") | dev_index, 369 lv1_repository_string("type"), 0, &devtype, &junk); 370 371 if (result != 0) 372 continue; 373 374 result = lv1_get_repository_node_value(PS3_LPAR_ID_PME, 375 (lv1_repository_string("bus") >> 32) | bus_index, 376 lv1_repository_string("dev") | dev_index, 377 lv1_repository_string("id"), 0, &dev, &junk); 378 379 if (result != 0) 380 continue; 381 382 switch (devtype) { 383 case PS3_DEVTYPE_USB: 384 /* USB device has OHCI and EHCI USB host controllers */ 385 386 lv1_open_device(bus, dev, 0); 387 388 /* OHCI host controller */ 389 390 dinfo = malloc(sizeof(*dinfo), M_PS3BUS, 391 M_WAITOK | M_ZERO); 392 393 dinfo->bus = bus; 394 dinfo->dev = dev; 395 dinfo->bustype = bustype; 396 dinfo->devtype = devtype; 397 dinfo->busidx = bus_index; 398 dinfo->devidx = dev_index; 399 400 ps3bus_resources_init_by_type(&sc->sc_mem_rman, bus_index, 401 dev_index, OHCI_IRQ, OHCI_REG, dinfo); 402 403 cdev = device_add_child(self, "ohci", -1); 404 if (cdev == NULL) { 405 device_printf(self, 406 "device_add_child failed\n"); 407 free(dinfo, M_PS3BUS); 408 continue; 409 } 410 411 mtx_init(&dinfo->iommu_mtx, "iommu", NULL, MTX_DEF); 412 device_set_ivars(cdev, dinfo); 413 414 /* EHCI host controller */ 415 416 dinfo = malloc(sizeof(*dinfo), M_PS3BUS, 417 M_WAITOK | M_ZERO); 418 419 dinfo->bus = bus; 420 dinfo->dev = dev; 421 dinfo->bustype = bustype; 422 dinfo->devtype = devtype; 423 dinfo->busidx = bus_index; 424 dinfo->devidx = dev_index; 425 426 ps3bus_resources_init_by_type(&sc->sc_mem_rman, bus_index, 427 dev_index, EHCI_IRQ, EHCI_REG, dinfo); 428 429 cdev = device_add_child(self, "ehci", -1); 430 if (cdev == NULL) { 431 device_printf(self, 432 "device_add_child failed\n"); 433 free(dinfo, M_PS3BUS); 434 continue; 435 } 436 437 mtx_init(&dinfo->iommu_mtx, "iommu", NULL, MTX_DEF); 438 device_set_ivars(cdev, dinfo); 439 break; 440 default: 441 dinfo = malloc(sizeof(*dinfo), M_PS3BUS, 442 M_WAITOK | M_ZERO); 443 444 dinfo->bus = bus; 445 dinfo->dev = dev; 446 dinfo->bustype = bustype; 447 dinfo->devtype = devtype; 448 dinfo->busidx = bus_index; 449 dinfo->devidx = dev_index; 450 451 if (dinfo->bustype == PS3_BUSTYPE_SYSBUS || 452 dinfo->bustype == PS3_BUSTYPE_STORAGE) 453 lv1_open_device(bus, dev, 0); 454 455 ps3bus_resources_init(&sc->sc_mem_rman, bus_index, 456 dev_index, dinfo); 457 458 cdev = device_add_child(self, NULL, -1); 459 if (cdev == NULL) { 460 device_printf(self, 461 "device_add_child failed\n"); 462 free(dinfo, M_PS3BUS); 463 continue; 464 } 465 466 mtx_init(&dinfo->iommu_mtx, "iommu", NULL, MTX_DEF); 467 device_set_ivars(cdev, dinfo); 468 } 469 } 470 } 471 472 clock_register(self, 1000); 473 474 return (bus_generic_attach(self)); 475 } 476 477 static int 478 ps3bus_print_child(device_t dev, device_t child) 479 { 480 struct ps3bus_devinfo *dinfo = device_get_ivars(child); 481 int retval = 0; 482 483 retval += bus_print_child_header(dev, child); 484 retval += resource_list_print_type(&dinfo->resources, "mem", 485 SYS_RES_MEMORY, "%#jx"); 486 retval += resource_list_print_type(&dinfo->resources, "irq", 487 SYS_RES_IRQ, "%jd"); 488 489 retval += bus_print_child_footer(dev, child); 490 491 return (retval); 492 } 493 494 static int 495 ps3bus_read_ivar(device_t bus, device_t child, int which, uintptr_t *result) 496 { 497 struct ps3bus_devinfo *dinfo = device_get_ivars(child); 498 499 switch (which) { 500 case PS3BUS_IVAR_BUS: 501 *result = dinfo->bus; 502 break; 503 case PS3BUS_IVAR_DEVICE: 504 *result = dinfo->dev; 505 break; 506 case PS3BUS_IVAR_BUSTYPE: 507 *result = dinfo->bustype; 508 break; 509 case PS3BUS_IVAR_DEVTYPE: 510 *result = dinfo->devtype; 511 break; 512 case PS3BUS_IVAR_BUSIDX: 513 *result = dinfo->busidx; 514 break; 515 case PS3BUS_IVAR_DEVIDX: 516 *result = dinfo->devidx; 517 break; 518 default: 519 return (EINVAL); 520 } 521 522 return (0); 523 } 524 525 static struct resource * 526 ps3bus_alloc_resource(device_t bus, device_t child, int type, int *rid, 527 rman_res_t start, rman_res_t end, rman_res_t count, u_int flags) 528 { 529 struct ps3bus_devinfo *dinfo; 530 struct ps3bus_softc *sc; 531 int needactivate; 532 struct resource *rv; 533 struct rman *rm; 534 rman_res_t adjstart, adjend, adjcount; 535 struct resource_list_entry *rle; 536 537 sc = device_get_softc(bus); 538 dinfo = device_get_ivars(child); 539 needactivate = flags & RF_ACTIVE; 540 flags &= ~RF_ACTIVE; 541 542 switch (type) { 543 case SYS_RES_MEMORY: 544 rle = resource_list_find(&dinfo->resources, SYS_RES_MEMORY, 545 *rid); 546 if (rle == NULL) { 547 device_printf(bus, "no rle for %s memory %d\n", 548 device_get_nameunit(child), *rid); 549 return (NULL); 550 } 551 552 if (start < rle->start) 553 adjstart = rle->start; 554 else if (start > rle->end) 555 adjstart = rle->end; 556 else 557 adjstart = start; 558 559 if (end < rle->start) 560 adjend = rle->start; 561 else if (end > rle->end) 562 adjend = rle->end; 563 else 564 adjend = end; 565 566 adjcount = adjend - adjstart; 567 568 rm = &sc->sc_mem_rman; 569 break; 570 case SYS_RES_IRQ: 571 rle = resource_list_find(&dinfo->resources, SYS_RES_IRQ, 572 *rid); 573 rm = &sc->sc_intr_rman; 574 adjstart = rle->start; 575 adjcount = ulmax(count, rle->count); 576 adjend = ulmax(rle->end, rle->start + adjcount - 1); 577 break; 578 default: 579 device_printf(bus, "unknown resource request from %s\n", 580 device_get_nameunit(child)); 581 return (NULL); 582 } 583 584 rv = rman_reserve_resource(rm, adjstart, adjend, adjcount, flags, 585 child); 586 if (rv == NULL) { 587 device_printf(bus, 588 "failed to reserve resource %#lx - %#lx (%#lx)" 589 " for %s\n", adjstart, adjend, adjcount, 590 device_get_nameunit(child)); 591 return (NULL); 592 } 593 594 rman_set_rid(rv, *rid); 595 596 if (needactivate) { 597 if (bus_activate_resource(child, type, *rid, rv) != 0) { 598 device_printf(bus, 599 "failed to activate resource for %s\n", 600 device_get_nameunit(child)); 601 rman_release_resource(rv); 602 return (NULL); 603 } 604 } 605 606 return (rv); 607 } 608 609 static int 610 ps3bus_activate_resource(device_t bus, device_t child, int type, int rid, 611 struct resource *res) 612 { 613 void *p; 614 615 if (type == SYS_RES_IRQ) 616 return (bus_activate_resource(bus, type, rid, res)); 617 618 if (type == SYS_RES_MEMORY) { 619 vm_offset_t start; 620 621 start = (vm_offset_t) rman_get_start(res); 622 623 if (bootverbose) 624 printf("ps3 mapdev: start %zx, len %ld\n", start, 625 rman_get_size(res)); 626 627 p = pmap_mapdev(start, (vm_size_t) rman_get_size(res)); 628 if (p == NULL) 629 return (ENOMEM); 630 rman_set_virtual(res, p); 631 rman_set_bustag(res, &bs_be_tag); 632 rman_set_bushandle(res, (rman_res_t)p); 633 } 634 635 return (rman_activate_resource(res)); 636 } 637 638 static bus_dma_tag_t 639 ps3bus_get_dma_tag(device_t dev, device_t child) 640 { 641 struct ps3bus_devinfo *dinfo = device_get_ivars(child); 642 struct ps3bus_softc *sc = device_get_softc(dev); 643 int i, err, flags, pagesize; 644 645 if (dinfo->bustype != PS3_BUSTYPE_SYSBUS && 646 dinfo->bustype != PS3_BUSTYPE_STORAGE) 647 return (bus_get_dma_tag(dev)); 648 649 mtx_lock(&dinfo->iommu_mtx); 650 if (dinfo->dma_tag != NULL) { 651 mtx_unlock(&dinfo->iommu_mtx); 652 return (dinfo->dma_tag); 653 } 654 655 flags = 0; /* 32-bit mode */ 656 if (dinfo->bustype == PS3_BUSTYPE_SYSBUS && 657 dinfo->devtype == PS3_DEVTYPE_USB) 658 flags = 2; /* 8-bit mode */ 659 660 pagesize = 24; /* log_2(16 MB) */ 661 if (dinfo->bustype == PS3_BUSTYPE_STORAGE) 662 pagesize = 12; /* 4 KB */ 663 664 for (i = 0; i < sc->rcount; i++) { 665 err = lv1_allocate_device_dma_region(dinfo->bus, dinfo->dev, 666 sc->regions[i].mr_size, pagesize, flags, 667 &dinfo->dma_base[i]); 668 if (err != 0) { 669 device_printf(child, 670 "could not allocate DMA region %d: %d\n", i, err); 671 goto fail; 672 } 673 674 err = lv1_map_device_dma_region(dinfo->bus, dinfo->dev, 675 sc->regions[i].mr_start, dinfo->dma_base[i], 676 sc->regions[i].mr_size, 677 0xf800000000000800UL /* Cell Handbook Figure 7.3.4.1 */); 678 if (err != 0) { 679 device_printf(child, 680 "could not map DMA region %d: %d\n", i, err); 681 goto fail; 682 } 683 } 684 685 err = bus_dma_tag_create(bus_get_dma_tag(dev), 686 1, 0, BUS_SPACE_MAXADDR, BUS_SPACE_MAXADDR, 687 NULL, NULL, BUS_SPACE_MAXSIZE, 0, BUS_SPACE_MAXSIZE, 688 0, NULL, NULL, &dinfo->dma_tag); 689 690 /* 691 * Note: storage devices have IOMMU mappings set up by the hypervisor, 692 * but use physical, non-translated addresses. The above IOMMU 693 * initialization is necessary for the hypervisor to be able to set up 694 * the mappings, but actual DMA mappings should not use the IOMMU 695 * routines. 696 */ 697 if (dinfo->bustype != PS3_BUSTYPE_STORAGE) 698 bus_dma_tag_set_iommu(dinfo->dma_tag, dev, dinfo); 699 700 fail: 701 mtx_unlock(&dinfo->iommu_mtx); 702 703 if (err) 704 return (NULL); 705 706 return (dinfo->dma_tag); 707 } 708 709 static int 710 ps3_iommu_map(device_t dev, bus_dma_segment_t *segs, int *nsegs, 711 bus_addr_t min, bus_addr_t max, bus_size_t alignment, bus_addr_t boundary, 712 void *cookie) 713 { 714 struct ps3bus_devinfo *dinfo = cookie; 715 struct ps3bus_softc *sc = device_get_softc(dev); 716 int i, j; 717 718 for (i = 0; i < *nsegs; i++) { 719 for (j = 0; j < sc->rcount; j++) { 720 if (segs[i].ds_addr >= sc->regions[j].mr_start && 721 segs[i].ds_addr < sc->regions[j].mr_start + 722 sc->regions[j].mr_size) 723 break; 724 } 725 KASSERT(j < sc->rcount, 726 ("Trying to map address %#lx not in physical memory", 727 segs[i].ds_addr)); 728 729 segs[i].ds_addr = dinfo->dma_base[j] + 730 (segs[i].ds_addr - sc->regions[j].mr_start); 731 } 732 733 return (0); 734 } 735 736 static int 737 ps3_iommu_unmap(device_t dev, bus_dma_segment_t *segs, int nsegs, void *cookie) 738 { 739 740 return (0); 741 } 742 743 #define Y2K 946684800 744 745 static int 746 ps3_gettime(device_t dev, struct timespec *ts) 747 { 748 uint64_t rtc, tb; 749 int result; 750 751 result = lv1_get_rtc(&rtc, &tb); 752 if (result) 753 return (result); 754 755 ts->tv_sec = rtc + Y2K; 756 ts->tv_nsec = 0; 757 return (0); 758 } 759 760 static int 761 ps3_settime(device_t dev, struct timespec *ts) 762 { 763 return (-1); 764 } 765 766