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