1 /*- 2 * SPDX-License-Identifier: BSD-2-Clause 3 * 4 * Copyright (c) 2006 Marcel Moolenaar 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 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 THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 26 * THIS SOFTWARE, EVEN IF 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/bus.h> 36 #include <sys/conf.h> 37 #include <sys/malloc.h> 38 #include <sys/mutex.h> 39 #include <sys/sbuf.h> 40 #include <sys/sysctl.h> 41 42 #include <machine/bus.h> 43 #include <machine/resource.h> 44 #include <sys/rman.h> 45 46 #include <dev/pci/pcireg.h> 47 #include <dev/pci/pcivar.h> 48 49 #include <dev/puc/puc_bus.h> 50 #include <dev/puc/puc_cfg.h> 51 #include <dev/puc/puc_bfe.h> 52 53 #define PUC_ISRCCNT 5 54 55 struct puc_port { 56 struct puc_bar *p_bar; 57 struct resource *p_rres; 58 struct resource *p_ires; 59 device_t p_dev; 60 int p_nr; 61 int p_type; 62 int p_rclk; 63 64 bool p_hasintr:1; 65 66 serdev_intr_t *p_ihsrc[PUC_ISRCCNT]; 67 void *p_iharg; 68 69 int p_ipend; 70 }; 71 72 const char puc_driver_name[] = "puc"; 73 74 static MALLOC_DEFINE(M_PUC, "PUC", "PUC driver"); 75 76 SYSCTL_NODE(_hw, OID_AUTO, puc, CTLFLAG_RD | CTLFLAG_MPSAFE, 0, 77 "puc(9) driver configuration"); 78 79 struct puc_bar * 80 puc_get_bar(struct puc_softc *sc, int rid) 81 { 82 struct puc_bar *bar; 83 struct rman *rm; 84 rman_res_t end, start; 85 int error, i; 86 87 /* Find the BAR entry with the given RID. */ 88 i = 0; 89 while (i < PUC_PCI_BARS && sc->sc_bar[i].b_rid != rid) 90 i++; 91 if (i < PUC_PCI_BARS) 92 return (&sc->sc_bar[i]); 93 94 /* Not found. If we're looking for an unused entry, return NULL. */ 95 if (rid == -1) 96 return (NULL); 97 98 /* Get an unused entry for us to fill. */ 99 bar = puc_get_bar(sc, -1); 100 if (bar == NULL) 101 return (NULL); 102 bar->b_rid = rid; 103 bar->b_type = SYS_RES_IOPORT; 104 bar->b_res = bus_alloc_resource_any(sc->sc_dev, bar->b_type, 105 &bar->b_rid, RF_ACTIVE); 106 if (bar->b_res == NULL) { 107 bar->b_rid = rid; 108 bar->b_type = SYS_RES_MEMORY; 109 bar->b_res = bus_alloc_resource_any(sc->sc_dev, bar->b_type, 110 &bar->b_rid, RF_ACTIVE); 111 if (bar->b_res == NULL) { 112 bar->b_rid = -1; 113 return (NULL); 114 } 115 } 116 117 /* Update our managed space. */ 118 rm = (bar->b_type == SYS_RES_IOPORT) ? &sc->sc_ioport : &sc->sc_iomem; 119 start = rman_get_start(bar->b_res); 120 end = rman_get_end(bar->b_res); 121 error = rman_manage_region(rm, start, end); 122 if (error) { 123 bus_release_resource(sc->sc_dev, bar->b_type, bar->b_rid, 124 bar->b_res); 125 bar->b_res = NULL; 126 bar->b_rid = -1; 127 bar = NULL; 128 } 129 130 return (bar); 131 } 132 133 static int 134 puc_intr(void *arg) 135 { 136 struct puc_port *port; 137 struct puc_softc *sc = arg; 138 u_long ds, dev, devs; 139 int i, idx, ipend, isrc, nints; 140 uint8_t ilr; 141 142 nints = 0; 143 while (1) { 144 /* 145 * Obtain the set of devices with pending interrupts. 146 */ 147 devs = sc->sc_serdevs; 148 if (sc->sc_ilr == PUC_ILR_DIGI) { 149 idx = 0; 150 while (devs & (0xfful << idx)) { 151 ilr = ~bus_read_1(sc->sc_port[idx].p_rres, 7); 152 devs &= ~0ul ^ ((u_long)ilr << idx); 153 idx += 8; 154 } 155 } else if (sc->sc_ilr == PUC_ILR_QUATECH) { 156 /* 157 * Don't trust the value if it's the same as the option 158 * register. It may mean that the ILR is not active and 159 * we're reading the option register instead. This may 160 * lead to false positives on 8-port boards. 161 */ 162 ilr = bus_read_1(sc->sc_port[0].p_rres, 7); 163 if (ilr != (sc->sc_cfg_data & 0xff)) 164 devs &= (u_long)ilr; 165 } 166 if (devs == 0UL) 167 break; 168 169 /* 170 * Obtain the set of interrupt sources from those devices 171 * that have pending interrupts. 172 */ 173 ipend = 0; 174 idx = 0, dev = 1UL; 175 ds = devs; 176 while (ds != 0UL) { 177 while ((ds & dev) == 0UL) 178 idx++, dev <<= 1; 179 ds &= ~dev; 180 port = &sc->sc_port[idx]; 181 port->p_ipend = SERDEV_IPEND(port->p_dev); 182 ipend |= port->p_ipend; 183 } 184 if (ipend == 0) 185 break; 186 187 i = 0, isrc = SER_INT_OVERRUN; 188 while (ipend) { 189 while (i < PUC_ISRCCNT && !(ipend & isrc)) 190 i++, isrc <<= 1; 191 KASSERT(i < PUC_ISRCCNT, ("%s", __func__)); 192 ipend &= ~isrc; 193 idx = 0, dev = 1UL; 194 ds = devs; 195 while (ds != 0UL) { 196 while ((ds & dev) == 0UL) 197 idx++, dev <<= 1; 198 ds &= ~dev; 199 port = &sc->sc_port[idx]; 200 if (!(port->p_ipend & isrc)) 201 continue; 202 if (port->p_ihsrc[i] != NULL) 203 (*port->p_ihsrc[i])(port->p_iharg); 204 nints++; 205 } 206 } 207 } 208 209 return ((nints > 0) ? FILTER_HANDLED : FILTER_STRAY); 210 } 211 212 int 213 puc_bfe_attach(device_t dev) 214 { 215 char buffer[64]; 216 struct puc_bar *bar; 217 struct puc_port *port; 218 struct puc_softc *sc; 219 struct rman *rm; 220 intptr_t res; 221 bus_addr_t ofs, start; 222 bus_size_t size; 223 bus_space_handle_t bsh; 224 bus_space_tag_t bst; 225 int error, idx; 226 227 sc = device_get_softc(dev); 228 229 for (idx = 0; idx < PUC_PCI_BARS; idx++) 230 sc->sc_bar[idx].b_rid = -1; 231 232 do { 233 sc->sc_ioport.rm_type = RMAN_ARRAY; 234 error = rman_init(&sc->sc_ioport); 235 if (!error) { 236 sc->sc_iomem.rm_type = RMAN_ARRAY; 237 error = rman_init(&sc->sc_iomem); 238 if (!error) { 239 sc->sc_irq.rm_type = RMAN_ARRAY; 240 error = rman_init(&sc->sc_irq); 241 if (!error) 242 break; 243 rman_fini(&sc->sc_iomem); 244 } 245 rman_fini(&sc->sc_ioport); 246 } 247 return (error); 248 } while (0); 249 250 snprintf(buffer, sizeof(buffer), "%s I/O port mapping", 251 device_get_nameunit(dev)); 252 sc->sc_ioport.rm_descr = strdup(buffer, M_PUC); 253 snprintf(buffer, sizeof(buffer), "%s I/O memory mapping", 254 device_get_nameunit(dev)); 255 sc->sc_iomem.rm_descr = strdup(buffer, M_PUC); 256 snprintf(buffer, sizeof(buffer), "%s port numbers", 257 device_get_nameunit(dev)); 258 sc->sc_irq.rm_descr = strdup(buffer, M_PUC); 259 260 error = puc_config(sc, PUC_CFG_GET_NPORTS, 0, &res); 261 KASSERT(error == 0, ("%s %d", __func__, __LINE__)); 262 sc->sc_nports = (int)res; 263 sc->sc_port = malloc(sc->sc_nports * sizeof(struct puc_port), 264 M_PUC, M_WAITOK|M_ZERO); 265 266 error = rman_manage_region(&sc->sc_irq, 1, sc->sc_nports); 267 if (error) 268 goto fail; 269 270 error = puc_config(sc, PUC_CFG_SETUP, 0, &res); 271 if (error) 272 goto fail; 273 274 for (idx = 0; idx < sc->sc_nports; idx++) { 275 port = &sc->sc_port[idx]; 276 port->p_nr = idx + 1; 277 error = puc_config(sc, PUC_CFG_GET_TYPE, idx, &res); 278 if (error) 279 goto fail; 280 port->p_type = res; 281 error = puc_config(sc, PUC_CFG_GET_RID, idx, &res); 282 if (error) 283 goto fail; 284 bar = puc_get_bar(sc, res); 285 if (bar == NULL) { 286 error = ENXIO; 287 goto fail; 288 } 289 port->p_bar = bar; 290 start = rman_get_start(bar->b_res); 291 error = puc_config(sc, PUC_CFG_GET_OFS, idx, &res); 292 if (error) 293 goto fail; 294 ofs = res; 295 error = puc_config(sc, PUC_CFG_GET_LEN, idx, &res); 296 if (error) 297 goto fail; 298 size = res; 299 rm = (bar->b_type == SYS_RES_IOPORT) 300 ? &sc->sc_ioport: &sc->sc_iomem; 301 port->p_rres = rman_reserve_resource(rm, start + ofs, 302 start + ofs + size - 1, size, 0, NULL); 303 if (port->p_rres != NULL) { 304 bsh = rman_get_bushandle(bar->b_res); 305 bst = rman_get_bustag(bar->b_res); 306 bus_space_subregion(bst, bsh, ofs, size, &bsh); 307 rman_set_bushandle(port->p_rres, bsh); 308 rman_set_bustag(port->p_rres, bst); 309 } 310 port->p_ires = rman_reserve_resource(&sc->sc_irq, port->p_nr, 311 port->p_nr, 1, 0, NULL); 312 if (port->p_ires == NULL) { 313 error = ENXIO; 314 goto fail; 315 } 316 error = puc_config(sc, PUC_CFG_GET_CLOCK, idx, &res); 317 if (error) 318 goto fail; 319 port->p_rclk = res; 320 321 port->p_dev = device_add_child(dev, NULL, -1); 322 if (port->p_dev != NULL) 323 device_set_ivars(port->p_dev, (void *)port); 324 } 325 326 error = puc_config(sc, PUC_CFG_GET_ILR, 0, &res); 327 if (error) 328 goto fail; 329 sc->sc_ilr = res; 330 if (bootverbose && sc->sc_ilr != 0) 331 device_printf(dev, "using interrupt latch register\n"); 332 333 sc->sc_ires = bus_alloc_resource_any(dev, SYS_RES_IRQ, &sc->sc_irid, 334 RF_ACTIVE|RF_SHAREABLE); 335 if (sc->sc_ires != NULL) { 336 error = bus_setup_intr(dev, sc->sc_ires, 337 INTR_TYPE_TTY, puc_intr, NULL, sc, &sc->sc_icookie); 338 if (error) 339 error = bus_setup_intr(dev, sc->sc_ires, 340 INTR_TYPE_TTY | INTR_MPSAFE, NULL, 341 (driver_intr_t *)puc_intr, sc, &sc->sc_icookie); 342 else 343 sc->sc_fastintr = 1; 344 345 if (error) { 346 device_printf(dev, "could not activate interrupt\n"); 347 bus_release_resource(dev, SYS_RES_IRQ, sc->sc_irid, 348 sc->sc_ires); 349 sc->sc_ires = NULL; 350 } 351 } 352 if (sc->sc_ires == NULL) { 353 /* XXX no interrupt resource. Force polled mode. */ 354 sc->sc_polled = 1; 355 } 356 357 /* Probe and attach our children. */ 358 for (idx = 0; idx < sc->sc_nports; idx++) { 359 port = &sc->sc_port[idx]; 360 if (port->p_dev == NULL) 361 continue; 362 error = device_probe_and_attach(port->p_dev); 363 if (error) { 364 device_delete_child(dev, port->p_dev); 365 port->p_dev = NULL; 366 } 367 } 368 369 /* 370 * If there are no serdev devices, then our interrupt handler 371 * will do nothing. Tear it down. 372 */ 373 if (sc->sc_serdevs == 0UL) 374 bus_teardown_intr(dev, sc->sc_ires, sc->sc_icookie); 375 376 return (0); 377 378 fail: 379 for (idx = 0; idx < sc->sc_nports; idx++) { 380 port = &sc->sc_port[idx]; 381 if (port->p_dev != NULL) 382 device_delete_child(dev, port->p_dev); 383 if (port->p_rres != NULL) 384 rman_release_resource(port->p_rres); 385 if (port->p_ires != NULL) 386 rman_release_resource(port->p_ires); 387 } 388 for (idx = 0; idx < PUC_PCI_BARS; idx++) { 389 bar = &sc->sc_bar[idx]; 390 if (bar->b_res != NULL) 391 bus_release_resource(sc->sc_dev, bar->b_type, 392 bar->b_rid, bar->b_res); 393 } 394 rman_fini(&sc->sc_irq); 395 free(__DECONST(void *, sc->sc_irq.rm_descr), M_PUC); 396 rman_fini(&sc->sc_iomem); 397 free(__DECONST(void *, sc->sc_iomem.rm_descr), M_PUC); 398 rman_fini(&sc->sc_ioport); 399 free(__DECONST(void *, sc->sc_ioport.rm_descr), M_PUC); 400 free(sc->sc_port, M_PUC); 401 return (error); 402 } 403 404 int 405 puc_bfe_detach(device_t dev) 406 { 407 struct puc_bar *bar; 408 struct puc_port *port; 409 struct puc_softc *sc; 410 int error, idx; 411 412 sc = device_get_softc(dev); 413 414 /* Detach our children. */ 415 error = 0; 416 for (idx = 0; idx < sc->sc_nports; idx++) { 417 port = &sc->sc_port[idx]; 418 if (port->p_dev == NULL) 419 continue; 420 if (device_delete_child(dev, port->p_dev) == 0) { 421 if (port->p_rres != NULL) 422 rman_release_resource(port->p_rres); 423 if (port->p_ires != NULL) 424 rman_release_resource(port->p_ires); 425 } else 426 error = ENXIO; 427 } 428 if (error) 429 return (error); 430 431 if (sc->sc_serdevs != 0UL) 432 bus_teardown_intr(dev, sc->sc_ires, sc->sc_icookie); 433 bus_release_resource(dev, SYS_RES_IRQ, sc->sc_irid, sc->sc_ires); 434 435 for (idx = 0; idx < PUC_PCI_BARS; idx++) { 436 bar = &sc->sc_bar[idx]; 437 if (bar->b_res != NULL) 438 bus_release_resource(sc->sc_dev, bar->b_type, 439 bar->b_rid, bar->b_res); 440 } 441 442 rman_fini(&sc->sc_irq); 443 free(__DECONST(void *, sc->sc_irq.rm_descr), M_PUC); 444 rman_fini(&sc->sc_iomem); 445 free(__DECONST(void *, sc->sc_iomem.rm_descr), M_PUC); 446 rman_fini(&sc->sc_ioport); 447 free(__DECONST(void *, sc->sc_ioport.rm_descr), M_PUC); 448 free(sc->sc_port, M_PUC); 449 return (0); 450 } 451 452 int 453 puc_bfe_probe(device_t dev, const struct puc_cfg *cfg) 454 { 455 struct puc_softc *sc; 456 intptr_t res; 457 int error; 458 459 sc = device_get_softc(dev); 460 sc->sc_dev = dev; 461 sc->sc_cfg = cfg; 462 463 /* We don't attach to single-port serial cards. */ 464 if (cfg->ports == PUC_PORT_1S || cfg->ports == PUC_PORT_1P) 465 return (EDOOFUS); 466 error = puc_config(sc, PUC_CFG_GET_NPORTS, 0, &res); 467 if (error) 468 return (error); 469 error = puc_config(sc, PUC_CFG_GET_DESC, 0, &res); 470 if (error) 471 return (error); 472 if (res != 0) 473 device_set_desc(dev, (const char *)res); 474 return (BUS_PROBE_DEFAULT); 475 } 476 477 struct resource * 478 puc_bus_alloc_resource(device_t dev, device_t child, int type, int *rid, 479 rman_res_t start, rman_res_t end, rman_res_t count, u_int flags) 480 { 481 struct puc_port *port; 482 struct resource *res; 483 device_t assigned, originator; 484 int error; 485 486 /* Get our immediate child. */ 487 originator = child; 488 while (child != NULL && device_get_parent(child) != dev) 489 child = device_get_parent(child); 490 if (child == NULL) 491 return (NULL); 492 493 port = device_get_ivars(child); 494 KASSERT(port != NULL, ("%s %d", __func__, __LINE__)); 495 496 if (rid == NULL || *rid != 0) 497 return (NULL); 498 499 /* We only support default allocations. */ 500 if (!RMAN_IS_DEFAULT_RANGE(start, end)) 501 return (NULL); 502 503 if (type == port->p_bar->b_type) 504 res = port->p_rres; 505 else if (type == SYS_RES_IRQ) 506 res = port->p_ires; 507 else 508 return (NULL); 509 510 if (res == NULL) 511 return (NULL); 512 513 assigned = rman_get_device(res); 514 if (assigned == NULL) /* Not allocated */ 515 rman_set_device(res, originator); 516 else if (assigned != originator) 517 return (NULL); 518 519 if (flags & RF_ACTIVE) { 520 error = rman_activate_resource(res); 521 if (error) { 522 if (assigned == NULL) 523 rman_set_device(res, NULL); 524 return (NULL); 525 } 526 } 527 528 return (res); 529 } 530 531 int 532 puc_bus_release_resource(device_t dev, device_t child, int type, int rid, 533 struct resource *res) 534 { 535 struct puc_port *port; 536 device_t originator; 537 538 /* Get our immediate child. */ 539 originator = child; 540 while (child != NULL && device_get_parent(child) != dev) 541 child = device_get_parent(child); 542 if (child == NULL) 543 return (EINVAL); 544 545 port = device_get_ivars(child); 546 KASSERT(port != NULL, ("%s %d", __func__, __LINE__)); 547 548 if (rid != 0 || res == NULL) 549 return (EINVAL); 550 551 if (type == port->p_bar->b_type) { 552 if (res != port->p_rres) 553 return (EINVAL); 554 } else if (type == SYS_RES_IRQ) { 555 if (res != port->p_ires) 556 return (EINVAL); 557 if (port->p_hasintr) 558 return (EBUSY); 559 } else 560 return (EINVAL); 561 562 if (rman_get_device(res) != originator) 563 return (ENXIO); 564 if (rman_get_flags(res) & RF_ACTIVE) 565 rman_deactivate_resource(res); 566 rman_set_device(res, NULL); 567 return (0); 568 } 569 570 int 571 puc_bus_get_resource(device_t dev, device_t child, int type, int rid, 572 rman_res_t *startp, rman_res_t *countp) 573 { 574 struct puc_port *port; 575 struct resource *res; 576 rman_res_t start; 577 578 /* Get our immediate child. */ 579 while (child != NULL && device_get_parent(child) != dev) 580 child = device_get_parent(child); 581 if (child == NULL) 582 return (EINVAL); 583 584 port = device_get_ivars(child); 585 KASSERT(port != NULL, ("%s %d", __func__, __LINE__)); 586 587 if (type == port->p_bar->b_type) 588 res = port->p_rres; 589 else if (type == SYS_RES_IRQ) 590 res = port->p_ires; 591 else 592 return (ENXIO); 593 594 if (rid != 0 || res == NULL) 595 return (ENXIO); 596 597 start = rman_get_start(res); 598 if (startp != NULL) 599 *startp = start; 600 if (countp != NULL) 601 *countp = rman_get_end(res) - start + 1; 602 return (0); 603 } 604 605 int 606 puc_bus_setup_intr(device_t dev, device_t child, struct resource *res, 607 int flags, driver_filter_t *filt, void (*ihand)(void *), void *arg, void **cookiep) 608 { 609 struct puc_port *port; 610 struct puc_softc *sc; 611 device_t originator; 612 int i, isrc, serdev; 613 614 sc = device_get_softc(dev); 615 616 /* Get our immediate child. */ 617 originator = child; 618 while (child != NULL && device_get_parent(child) != dev) 619 child = device_get_parent(child); 620 if (child == NULL) 621 return (EINVAL); 622 623 port = device_get_ivars(child); 624 KASSERT(port != NULL, ("%s %d", __func__, __LINE__)); 625 626 if (cookiep == NULL || res != port->p_ires) 627 return (EINVAL); 628 /* We demand that serdev devices use filter_only interrupts. */ 629 if (port->p_type == PUC_TYPE_SERIAL && ihand != NULL) 630 return (ENXIO); 631 if (rman_get_device(port->p_ires) != originator) 632 return (ENXIO); 633 634 /* 635 * Have non-serdev ports handled by the bus implementation. It 636 * supports multiple handlers for a single interrupt as it is, 637 * so we wouldn't add value if we did it ourselves. 638 */ 639 serdev = 0; 640 if (port->p_type == PUC_TYPE_SERIAL) { 641 i = 0, isrc = SER_INT_OVERRUN; 642 while (i < PUC_ISRCCNT) { 643 port->p_ihsrc[i] = SERDEV_IHAND(originator, isrc); 644 if (port->p_ihsrc[i] != NULL) 645 serdev = 1; 646 i++, isrc <<= 1; 647 } 648 } 649 if (!serdev) 650 return (BUS_SETUP_INTR(device_get_parent(dev), originator, 651 sc->sc_ires, flags, filt, ihand, arg, cookiep)); 652 653 sc->sc_serdevs |= 1UL << (port->p_nr - 1); 654 655 port->p_hasintr = 1; 656 port->p_iharg = arg; 657 658 *cookiep = port; 659 return (0); 660 } 661 662 int 663 puc_bus_teardown_intr(device_t dev, device_t child, struct resource *res, 664 void *cookie) 665 { 666 struct puc_port *port; 667 struct puc_softc *sc; 668 device_t originator; 669 int i; 670 671 sc = device_get_softc(dev); 672 673 /* Get our immediate child. */ 674 originator = child; 675 while (child != NULL && device_get_parent(child) != dev) 676 child = device_get_parent(child); 677 if (child == NULL) 678 return (EINVAL); 679 680 port = device_get_ivars(child); 681 KASSERT(port != NULL, ("%s %d", __func__, __LINE__)); 682 683 if (res != port->p_ires) 684 return (EINVAL); 685 if (rman_get_device(port->p_ires) != originator) 686 return (ENXIO); 687 688 if (!port->p_hasintr) 689 return (BUS_TEARDOWN_INTR(device_get_parent(dev), originator, 690 sc->sc_ires, cookie)); 691 692 if (cookie != port) 693 return (EINVAL); 694 695 port->p_hasintr = 0; 696 port->p_iharg = NULL; 697 698 for (i = 0; i < PUC_ISRCCNT; i++) 699 port->p_ihsrc[i] = NULL; 700 701 return (0); 702 } 703 704 int 705 puc_bus_read_ivar(device_t dev, device_t child, int index, uintptr_t *result) 706 { 707 struct puc_port *port; 708 709 /* Get our immediate child. */ 710 while (child != NULL && device_get_parent(child) != dev) 711 child = device_get_parent(child); 712 if (child == NULL) 713 return (EINVAL); 714 715 port = device_get_ivars(child); 716 KASSERT(port != NULL, ("%s %d", __func__, __LINE__)); 717 718 if (result == NULL) 719 return (EINVAL); 720 721 switch(index) { 722 case PUC_IVAR_CLOCK: 723 *result = port->p_rclk; 724 break; 725 case PUC_IVAR_TYPE: 726 *result = port->p_type; 727 break; 728 default: 729 return (ENOENT); 730 } 731 return (0); 732 } 733 734 int 735 puc_bus_print_child(device_t dev, device_t child) 736 { 737 struct puc_port *port; 738 int retval; 739 740 port = device_get_ivars(child); 741 retval = 0; 742 743 retval += bus_print_child_header(dev, child); 744 retval += printf(" at port %d", port->p_nr); 745 retval += bus_print_child_footer(dev, child); 746 747 return (retval); 748 } 749 750 int 751 puc_bus_child_location(device_t dev, device_t child, struct sbuf *sb) 752 { 753 struct puc_port *port; 754 755 port = device_get_ivars(child); 756 sbuf_printf(sb, "port=%d", port->p_nr); 757 return (0); 758 } 759 760 int 761 puc_bus_child_pnpinfo(device_t dev, device_t child, struct sbuf *sb) 762 { 763 struct puc_port *port; 764 765 port = device_get_ivars(child); 766 sbuf_printf(sb, "type=%d", port->p_type); 767 return (0); 768 } 769