sys/dev/puc/puc.c

   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$");
  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
  51 struct 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_filter_t *p_ih;
  63         serdev_intr_t   *p_ihsrc[PUC_ISRCCNT];
  64         void            *p_iharg;
  65
  66         int             p_ipend;
  67 };
  68
  69 devclass_t puc_devclass;
  70 const char puc_driver_name[] = "puc";
  71
  72 MALLOC_DEFINE(M_PUC, "PUC", "PUC driver");
  73
  74 struct puc_bar *
  75 puc_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
 128 static int
 129 puc_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                 return (FILTER_HANDLED);
 187         }
 188         return (FILTER_STRAY);
 189 }
 190
 191 int
 192 puc_bfe_attach(device_t dev)
 193 {
 194         char buffer[64];
 195         struct puc_bar *bar;
 196         struct puc_port *port;
 197         struct puc_softc *sc;
 198         struct rman *rm;
 199         intptr_t res;
 200         bus_addr_t ofs, start;
 201         bus_size_t size;
 202         bus_space_handle_t bsh;
 203         bus_space_tag_t bst;
 204         int error, idx;
 205
 206         sc = device_get_softc(dev);
 207
 208         for (idx = 0; idx < PUC_PCI_BARS; idx++)
 209                 sc->sc_bar[idx].b_rid = -1;
 210
 211         do {
 212                 sc->sc_ioport.rm_type = RMAN_ARRAY;
 213                 error = rman_init(&sc->sc_ioport);
 214                 if (!error) {
 215                         sc->sc_iomem.rm_type = RMAN_ARRAY;
 216                         error = rman_init(&sc->sc_iomem);
 217                         if (!error) {
 218                                 sc->sc_irq.rm_type = RMAN_ARRAY;
 219                                 error = rman_init(&sc->sc_irq);
 220                                 if (!error)
 221                                         break;
 222                                 rman_fini(&sc->sc_iomem);
 223                         }
 224                         rman_fini(&sc->sc_ioport);
 225                 }
 226                 return (error);
 227         } while (0);
 228
 229         snprintf(buffer, sizeof(buffer), "%s I/O port mapping",
 230             device_get_nameunit(dev));
 231         sc->sc_ioport.rm_descr = strdup(buffer, M_PUC);
 232         snprintf(buffer, sizeof(buffer), "%s I/O memory mapping",
 233             device_get_nameunit(dev));
 234         sc->sc_iomem.rm_descr = strdup(buffer, M_PUC);
 235         snprintf(buffer, sizeof(buffer), "%s port numbers",
 236             device_get_nameunit(dev));
 237         sc->sc_irq.rm_descr = strdup(buffer, M_PUC);
 238
 239         error = puc_config(sc, PUC_CFG_GET_NPORTS, 0, &res);
 240         KASSERT(error == 0, ("%s %d", __func__, __LINE__));
 241         sc->sc_nports = (int)res;
 242         sc->sc_port = malloc(sc->sc_nports * sizeof(struct puc_port),
 243             M_PUC, M_WAITOK|M_ZERO);
 244
 245         error = rman_manage_region(&sc->sc_irq, 1, sc->sc_nports);
 246         if (error)
 247                 goto fail;
 248
 249         error = puc_config(sc, PUC_CFG_SETUP, 0, &res);
 250         if (error)
 251                 goto fail;
 252
 253         for (idx = 0; idx < sc->sc_nports; idx++) {
 254                 port = &sc->sc_port[idx];
 255                 port->p_nr = idx + 1;
 256                 error = puc_config(sc, PUC_CFG_GET_TYPE, idx, &res);
 257                 if (error)
 258                         goto fail;
 259                 port->p_type = res;
 260                 error = puc_config(sc, PUC_CFG_GET_RID, idx, &res);
 261                 if (error)
 262                         goto fail;
 263                 bar = puc_get_bar(sc, res);
 264                 if (bar == NULL) {
 265                         error = ENXIO;
 266                         goto fail;
 267                 }
 268                 port->p_bar = bar;
 269                 start = rman_get_start(bar->b_res);
 270                 error = puc_config(sc, PUC_CFG_GET_OFS, idx, &res);
 271                 if (error)
 272                         goto fail;
 273                 ofs = res;
 274                 error = puc_config(sc, PUC_CFG_GET_LEN, idx, &res);
 275                 if (error)
 276                         goto fail;
 277                 size = res;
 278                 rm = (bar->b_type == SYS_RES_IOPORT)
 279                     ? &sc->sc_ioport: &sc->sc_iomem;
 280                 port->p_rres = rman_reserve_resource(rm, start + ofs,
 281                     start + ofs + size - 1, size, 0, NULL);
 282                 if (port->p_rres != NULL) {
 283                         bsh = rman_get_bushandle(bar->b_res);
 284                         bst = rman_get_bustag(bar->b_res);
 285                         bus_space_subregion(bst, bsh, ofs, size, &bsh);
 286                         rman_set_bushandle(port->p_rres, bsh);
 287                         rman_set_bustag(port->p_rres, bst);
 288                 }
 289                 port->p_ires = rman_reserve_resource(&sc->sc_irq, port->p_nr,
 290                     port->p_nr, 1, 0, NULL);
 291                 if (port->p_ires == NULL) {
 292                         error = ENXIO;
 293                         goto fail;
 294                 }
 295                 error = puc_config(sc, PUC_CFG_GET_CLOCK, idx, &res);
 296                 if (error)
 297                         goto fail;
 298                 port->p_rclk = res;
 299
 300                 port->p_dev = device_add_child(dev, NULL, -1);
 301                 if (port->p_dev != NULL)
 302                         device_set_ivars(port->p_dev, (void *)port);
 303         }
 304
 305         error = puc_config(sc, PUC_CFG_GET_ILR, 0, &res);
 306         if (error)
 307                 goto fail;
 308         sc->sc_ilr = res;
 309         if (bootverbose && sc->sc_ilr != 0)
 310                 device_printf(dev, "using interrupt latch register\n");
 311
 312         sc->sc_irid = 0;
 313         sc->sc_ires = bus_alloc_resource_any(dev, SYS_RES_IRQ, &sc->sc_irid,
 314             RF_ACTIVE|RF_SHAREABLE);
 315         if (sc->sc_ires != NULL) {
 316                 error = bus_setup_intr(dev, sc->sc_ires,
 317                     INTR_TYPE_TTY, puc_intr, NULL, sc, &sc->sc_icookie);
 318                 if (error)
 319                         error = bus_setup_intr(dev, sc->sc_ires,
 320                             INTR_TYPE_TTY | INTR_MPSAFE, NULL,
 321                             (driver_intr_t *)puc_intr, sc, &sc->sc_icookie);
 322                 else
 323                         sc->sc_fastintr = 1;
 324
 325                 if (error) {
 326                         device_printf(dev, "could not activate interrupt\n");
 327                         bus_release_resource(dev, SYS_RES_IRQ, sc->sc_irid,
 328                             sc->sc_ires);
 329                         sc->sc_ires = NULL;
 330                 }
 331         }
 332         if (sc->sc_ires == NULL) {
 333                 /* XXX no interrupt resource. Force polled mode. */
 334                 sc->sc_polled = 1;
 335         }
 336
 337         /* Probe and attach our children. */
 338         for (idx = 0; idx < sc->sc_nports; idx++) {
 339                 port = &sc->sc_port[idx];
 340                 if (port->p_dev == NULL)
 341                         continue;
 342                 error = device_probe_and_attach(port->p_dev);
 343                 if (error) {
 344                         device_delete_child(dev, port->p_dev);
 345                         port->p_dev = NULL;
 346                 }
 347         }
 348
 349         /*
 350          * If there are no serdev devices, then our interrupt handler
 351          * will do nothing. Tear it down.
 352          */
 353         if (sc->sc_serdevs == 0UL)
 354                 bus_teardown_intr(dev, sc->sc_ires, sc->sc_icookie);
 355
 356         return (0);
 357
 358 fail:
 359         for (idx = 0; idx < sc->sc_nports; idx++) {
 360                 port = &sc->sc_port[idx];
 361                 if (port->p_dev != NULL)
 362                         device_delete_child(dev, port->p_dev);
 363                 if (port->p_rres != NULL)
 364                         rman_release_resource(port->p_rres);
 365                 if (port->p_ires != NULL)
 366                         rman_release_resource(port->p_ires);
 367         }
 368         for (idx = 0; idx < PUC_PCI_BARS; idx++) {
 369                 bar = &sc->sc_bar[idx];
 370                 if (bar->b_res != NULL)
 371                         bus_release_resource(sc->sc_dev, bar->b_type,
 372                             bar->b_rid, bar->b_res);
 373         }
 374         rman_fini(&sc->sc_irq);
 375         free(__DECONST(void *, sc->sc_irq.rm_descr), M_PUC);
 376         rman_fini(&sc->sc_iomem);
 377         free(__DECONST(void *, sc->sc_iomem.rm_descr), M_PUC);
 378         rman_fini(&sc->sc_ioport);
 379         free(__DECONST(void *, sc->sc_ioport.rm_descr), M_PUC);
 380         free(sc->sc_port, M_PUC);
 381         return (error);
 382 }
 383
 384 int
 385 puc_bfe_detach(device_t dev)
 386 {
 387         struct puc_bar *bar;
 388         struct puc_port *port;
 389         struct puc_softc *sc;
 390         int error, idx;
 391
 392         sc = device_get_softc(dev);
 393
 394         /* Detach our children. */
 395         error = 0;
 396         for (idx = 0; idx < sc->sc_nports; idx++) {
 397                 port = &sc->sc_port[idx];
 398                 if (port->p_dev == NULL)
 399                         continue;
 400                 if (device_detach(port->p_dev) == 0) {
 401                         device_delete_child(dev, port->p_dev);
 402                         if (port->p_rres != NULL)
 403                                 rman_release_resource(port->p_rres);
 404                         if (port->p_ires != NULL)
 405                                 rman_release_resource(port->p_ires);
 406                 } else
 407                         error = ENXIO;
 408         }
 409         if (error)
 410                 return (error);
 411
 412         if (sc->sc_serdevs != 0UL)
 413                 bus_teardown_intr(dev, sc->sc_ires, sc->sc_icookie);
 414         bus_release_resource(dev, SYS_RES_IRQ, sc->sc_irid, sc->sc_ires);
 415
 416         for (idx = 0; idx < PUC_PCI_BARS; idx++) {
 417                 bar = &sc->sc_bar[idx];
 418                 if (bar->b_res != NULL)
 419                         bus_release_resource(sc->sc_dev, bar->b_type,
 420                             bar->b_rid, bar->b_res);
 421         }
 422
 423         rman_fini(&sc->sc_irq);
 424         free(__DECONST(void *, sc->sc_irq.rm_descr), M_PUC);
 425         rman_fini(&sc->sc_iomem);
 426         free(__DECONST(void *, sc->sc_iomem.rm_descr), M_PUC);
 427         rman_fini(&sc->sc_ioport);
 428         free(__DECONST(void *, sc->sc_ioport.rm_descr), M_PUC);
 429         free(sc->sc_port, M_PUC);
 430         return (0);
 431 }
 432
 433 int
 434 puc_bfe_probe(device_t dev, const struct puc_cfg *cfg)
 435 {
 436         struct puc_softc *sc;
 437         intptr_t res;
 438         int error;
 439
 440         sc = device_get_softc(dev);
 441         sc->sc_dev = dev;
 442         sc->sc_cfg = cfg;
 443
 444         /* We don't attach to single-port serial cards. */
 445         if (cfg->ports == PUC_PORT_1S || cfg->ports == PUC_PORT_1P)
 446                 return (EDOOFUS);
 447         error = puc_config(sc, PUC_CFG_GET_NPORTS, 0, &res);
 448         if (error)
 449                 return (error);
 450         error = puc_config(sc, PUC_CFG_GET_DESC, 0, &res);
 451         if (error)
 452                 return (error);
 453         if (res != 0)
 454                 device_set_desc(dev, (const char *)res);
 455         return (BUS_PROBE_DEFAULT);
 456 }
 457
 458 struct resource *
 459 puc_bus_alloc_resource(device_t dev, device_t child, int type, int *rid,
 460     u_long start, u_long end, u_long count, u_int flags)
 461 {
 462         struct puc_port *port;
 463         struct resource *res;
 464         device_t assigned, originator;
 465         int error;
 466
 467         /* Get our immediate child. */
 468         originator = child;
 469         while (child != NULL && device_get_parent(child) != dev)
 470                 child = device_get_parent(child);
 471         if (child == NULL)
 472                 return (NULL);
 473
 474         port = device_get_ivars(child);
 475         KASSERT(port != NULL, ("%s %d", __func__, __LINE__));
 476
 477         if (rid == NULL || *rid != 0)
 478                 return (NULL);
 479
 480         /* We only support default allocations. */
 481         if (start != 0UL || end != ~0UL)
 482                 return (NULL);
 483
 484         if (type == port->p_bar->b_type)
 485                 res = port->p_rres;
 486         else if (type == SYS_RES_IRQ)
 487                 res = port->p_ires;
 488         else
 489                 return (NULL);
 490
 491         if (res == NULL)
 492                 return (NULL);
 493
 494         assigned = rman_get_device(res);
 495         if (assigned == NULL)   /* Not allocated */
 496                 rman_set_device(res, originator);
 497         else if (assigned != originator)
 498                 return (NULL);
 499
 500         if (flags & RF_ACTIVE) {
 501                 error = rman_activate_resource(res);
 502                 if (error) {
 503                         if (assigned == NULL)
 504                                 rman_set_device(res, NULL);
 505                         return (NULL);
 506                 }
 507         }
 508
 509         return (res);
 510 }
 511
 512 int
 513 puc_bus_release_resource(device_t dev, device_t child, int type, int rid,
 514     struct resource *res)
 515 {
 516         struct puc_port *port;
 517         device_t originator;
 518
 519         /* Get our immediate child. */
 520         originator = child;
 521         while (child != NULL && device_get_parent(child) != dev)
 522                 child = device_get_parent(child);
 523         if (child == NULL)
 524                 return (EINVAL);
 525
 526         port = device_get_ivars(child);
 527         KASSERT(port != NULL, ("%s %d", __func__, __LINE__));
 528
 529         if (rid != 0 || res == NULL)
 530                 return (EINVAL);
 531
 532         if (type == port->p_bar->b_type) {
 533                 if (res != port->p_rres)
 534                         return (EINVAL);
 535         } else if (type == SYS_RES_IRQ) {
 536                 if (res != port->p_ires)
 537                         return (EINVAL);
 538                 if (port->p_hasintr)
 539                         return (EBUSY);
 540         } else
 541                 return (EINVAL);
 542
 543         if (rman_get_device(res) != originator)
 544                 return (ENXIO);
 545         if (rman_get_flags(res) & RF_ACTIVE)
 546                 rman_deactivate_resource(res);
 547         rman_set_device(res, NULL);
 548         return (0);
 549 }
 550
 551 int
 552 puc_bus_get_resource(device_t dev, device_t child, int type, int rid,
 553     u_long *startp, u_long *countp)
 554 {
 555         struct puc_port *port;
 556         struct resource *res;
 557         u_long start;
 558
 559         /* Get our immediate child. */
 560         while (child != NULL && device_get_parent(child) != dev)
 561                 child = device_get_parent(child);
 562         if (child == NULL)
 563                 return (EINVAL);
 564
 565         port = device_get_ivars(child);
 566         KASSERT(port != NULL, ("%s %d", __func__, __LINE__));
 567
 568         if (type == port->p_bar->b_type)
 569                 res = port->p_rres;
 570         else if (type == SYS_RES_IRQ)
 571                 res = port->p_ires;
 572         else
 573                 return (ENXIO);
 574
 575         if (rid != 0 || res == NULL)
 576                 return (ENXIO);
 577
 578         start = rman_get_start(res);
 579         if (startp != NULL)
 580                 *startp = start;
 581         if (countp != NULL)
 582                 *countp = rman_get_end(res) - start + 1;
 583         return (0);
 584 }
 585
 586 int
 587 puc_bus_setup_intr(device_t dev, device_t child, struct resource *res,
 588     int flags, driver_filter_t *filt, void (*ihand)(void *), void *arg, void **cookiep)
 589 {
 590         struct puc_port *port;
 591         struct puc_softc *sc;
 592         device_t originator;
 593         int i, isrc, serdev;
 594
 595         sc = device_get_softc(dev);
 596
 597         /* Get our immediate child. */
 598         originator = child;
 599         while (child != NULL && device_get_parent(child) != dev)
 600                 child = device_get_parent(child);
 601         if (child == NULL)
 602                 return (EINVAL);
 603
 604         port = device_get_ivars(child);
 605         KASSERT(port != NULL, ("%s %d", __func__, __LINE__));
 606
 607         if (filt == NULL || cookiep == NULL || res != port->p_ires)
 608                 return (EINVAL);
 609         if (rman_get_device(port->p_ires) != originator)
 610                 return (ENXIO);
 611
 612         /*
 613          * Have non-serdev ports handled by the bus implementation. It
 614          * supports multiple handlers for a single interrupt as it is,
 615          * so we wouldn't add value if we did it ourselves.
 616          */
 617         serdev = 0;
 618         if (port->p_type == PUC_TYPE_SERIAL) {
 619                 i = 0, isrc = SER_INT_OVERRUN;
 620                 while (i < PUC_ISRCCNT) {
 621                         port->p_ihsrc[i] = SERDEV_IHAND(originator, isrc);
 622                         if (port->p_ihsrc[i] != NULL)
 623                                 serdev = 1;
 624                         i++, isrc <<= 1;
 625                 }
 626         }
 627         if (!serdev)
 628                 return (BUS_SETUP_INTR(device_get_parent(dev), originator,
 629                     sc->sc_ires, flags, filt, ihand, arg, cookiep));
 630
 631         /* We demand that serdev devices use fast interrupts. */
 632         if (filt == NULL)
 633                 return (ENXIO);
 634
 635         sc->sc_serdevs |= 1UL << (port->p_nr - 1);
 636
 637         port->p_hasintr = 1;
 638         port->p_ih = filt;
 639         port->p_iharg = arg;
 640
 641         *cookiep = port;
 642         return (0);
 643 }
 644
 645 int
 646 puc_bus_teardown_intr(device_t dev, device_t child, struct resource *res,
 647     void *cookie)
 648 {
 649         struct puc_port *port;
 650         struct puc_softc *sc;
 651         device_t originator;
 652         int i;
 653
 654         sc = device_get_softc(dev);
 655
 656         /* Get our immediate child. */
 657         originator = child;
 658         while (child != NULL && device_get_parent(child) != dev)
 659                 child = device_get_parent(child);
 660         if (child == NULL)
 661                 return (EINVAL);
 662
 663         port = device_get_ivars(child);
 664         KASSERT(port != NULL, ("%s %d", __func__, __LINE__));
 665
 666         if (res != port->p_ires)
 667                 return (EINVAL);
 668         if (rman_get_device(port->p_ires) != originator)
 669                 return (ENXIO);
 670
 671         if (!port->p_hasintr)
 672                 return (BUS_TEARDOWN_INTR(device_get_parent(dev), originator,
 673                     sc->sc_ires, cookie));
 674
 675         if (cookie != port)
 676                 return (EINVAL);
 677
 678         port->p_hasintr = 0;
 679         port->p_ih = NULL;
 680         port->p_iharg = NULL;
 681
 682         for (i = 0; i < PUC_ISRCCNT; i++)
 683                 port->p_ihsrc[i] = NULL;
 684
 685         return (0);
 686 }
 687
 688 int
 689 puc_bus_read_ivar(device_t dev, device_t child, int index, uintptr_t *result)
 690 {
 691         struct puc_port *port;
 692
 693         /* Get our immediate child. */
 694         while (child != NULL && device_get_parent(child) != dev)
 695                 child = device_get_parent(child);
 696         if (child == NULL)
 697                 return (EINVAL);
 698
 699         port = device_get_ivars(child);
 700         KASSERT(port != NULL, ("%s %d", __func__, __LINE__));
 701
 702         if (result == NULL)
 703                 return (EINVAL);
 704
 705         switch(index) {
 706         case PUC_IVAR_CLOCK:
 707                 *result = port->p_rclk;
 708                 break;
 709         case PUC_IVAR_TYPE:
 710                 *result = port->p_type;
 711                 break;
 712         default:
 713                 return (ENOENT);
 714         }
 715         return (0);
 716 }