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