sys/powerpc/mpc85xx/ocpbus.c

   1 /*-
   2  * Copyright 2006 by Juniper Networks. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  * 3. The name of the author may not be used to endorse or promote products
  13  *    derived from this software without specific prior written permission.
  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,
  20  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  21  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
  22  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  23  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  25  * SUCH DAMAGE.
  26  *
  27  */
  28
  29 #include <sys/cdefs.h>
  30 __FBSDID("$FreeBSD$");
  31
  32 #include <sys/param.h>
  33 #include <sys/systm.h>
  34 #include <sys/ktr.h>
  35 #include <sys/kernel.h>
  36 #include <sys/module.h>
  37 #include <sys/bus.h>
  38 #include <sys/rman.h>
  39 #include <sys/malloc.h>
  40
  41 #include <machine/spr.h>
  42 #include <machine/ocpbus.h>
  43 #include <machine/intr_machdep.h>
  44 #include <machine/md_var.h>
  45 #include <machine/vmparam.h>
  46 #include <machine/bootinfo.h>
  47
  48 #include <powerpc/mpc85xx/ocpbus.h>
  49 #include <powerpc/mpc85xx/mpc85xx.h>
  50
  51 #include "pic_if.h"
  52
  53 extern struct bus_space bs_be_tag;
  54
  55 struct ocpbus_softc {
  56         struct rman     sc_mem;
  57         struct rman     sc_irq;
  58 };
  59
  60 struct ocp_devinfo {
  61         int             ocp_devtype;
  62         int             ocp_unit;
  63 };
  64
  65 static int ocpbus_probe(device_t);
  66 static int ocpbus_attach(device_t);
  67 static int ocpbus_shutdown(device_t);
  68 static int ocpbus_get_resource(device_t, device_t, int, int, u_long *,
  69     u_long *);
  70 static struct resource *ocpbus_alloc_resource(device_t, device_t, int, int *,
  71     u_long, u_long, u_long, u_int);
  72 static int ocpbus_print_child(device_t, device_t);
  73 static int ocpbus_release_resource(device_t, device_t, int, int,
  74     struct resource *);
  75 static int ocpbus_read_ivar(device_t, device_t, int, uintptr_t *);
  76 static int ocpbus_setup_intr(device_t, device_t, struct resource *, int,
  77     driver_filter_t *, driver_intr_t *, void *, void **);
  78 static int ocpbus_teardown_intr(device_t, device_t, struct resource *, void *);
  79 static int ocpbus_config_intr(device_t, int, enum intr_trigger,
  80     enum intr_polarity);
  81
  82 /*
  83  * Bus interface definition
  84  */
  85 static device_method_t ocpbus_methods[] = {
  86         /* Device interface */
  87         DEVMETHOD(device_probe,         ocpbus_probe),
  88         DEVMETHOD(device_attach,        ocpbus_attach),
  89         DEVMETHOD(device_shutdown,      ocpbus_shutdown),
  90
  91         /* Bus interface */
  92         DEVMETHOD(bus_print_child,      ocpbus_print_child),
  93         DEVMETHOD(bus_read_ivar,        ocpbus_read_ivar),
  94         DEVMETHOD(bus_setup_intr,       ocpbus_setup_intr),
  95         DEVMETHOD(bus_teardown_intr,    ocpbus_teardown_intr),
  96         DEVMETHOD(bus_config_intr,      ocpbus_config_intr),
  97
  98         DEVMETHOD(bus_get_resource,     ocpbus_get_resource),
  99         DEVMETHOD(bus_alloc_resource,   ocpbus_alloc_resource),
 100         DEVMETHOD(bus_release_resource, ocpbus_release_resource),
 101         DEVMETHOD(bus_activate_resource,        bus_generic_activate_resource),
 102         DEVMETHOD(bus_deactivate_resource,      bus_generic_deactivate_resource),
 103
 104         { 0, 0 }
 105 };
 106
 107 static driver_t ocpbus_driver = {
 108         "ocpbus",
 109         ocpbus_methods,
 110         sizeof(struct ocpbus_softc)
 111 };
 112
 113 devclass_t ocpbus_devclass;
 114
 115 DRIVER_MODULE(ocpbus, nexus, ocpbus_driver, ocpbus_devclass, 0, 0);
 116
 117 static device_t
 118 ocpbus_mk_child(device_t dev, int type, int unit)
 119 {
 120         struct ocp_devinfo *dinfo;
 121         device_t child;
 122
 123         child = device_add_child(dev, NULL, -1);
 124         if (child == NULL) {
 125                 device_printf(dev, "could not add child device\n");
 126                 return (NULL);
 127         }
 128         dinfo = malloc(sizeof(struct ocp_devinfo), M_DEVBUF, M_WAITOK|M_ZERO);
 129         dinfo->ocp_devtype = type;
 130         dinfo->ocp_unit = unit;
 131         device_set_ivars(child, dinfo);
 132         return (child);
 133 }
 134
 135 static int
 136 ocpbus_write_law(int trgt, int type, u_long *startp, u_long *countp)
 137 {
 138         u_long addr, size;
 139
 140         switch (type) {
 141         case SYS_RES_MEMORY:
 142                 switch (trgt) {
 143                 case OCP85XX_TGTIF_PCI0:
 144                         addr = 0x80000000;
 145                         size = 0x10000000;
 146                         break;
 147                 case OCP85XX_TGTIF_PCI1:
 148                         addr = 0x90000000;
 149                         size = 0x10000000;
 150                         break;
 151                 case OCP85XX_TGTIF_PCI2:
 152                         addr = 0xA0000000;
 153                         size = 0x10000000;
 154                         break;
 155                 default:
 156                         return (EINVAL);
 157                 }
 158                 break;
 159         case SYS_RES_IOPORT:
 160                 switch (trgt) {
 161                 case OCP85XX_TGTIF_PCI0:
 162                         addr = 0xfee00000;
 163                         size = 0x00010000;
 164                         break;
 165                 case OCP85XX_TGTIF_PCI1:
 166                         addr = 0xfee10000;
 167                         size = 0x00010000;
 168                         break;
 169                 case OCP85XX_TGTIF_PCI2:
 170                         addr = 0xfee20000;
 171                         size = 0x00010000;
 172                         break;
 173                 default:
 174                         return (EINVAL);
 175                 }
 176                 break;
 177         default:
 178                 return (EINVAL);
 179         }
 180
 181         *startp = addr;
 182         *countp = size;
 183
 184         return (law_enable(trgt, *startp, *countp));
 185 }
 186
 187 static int
 188 ocpbus_probe(device_t dev)
 189 {
 190
 191         device_set_desc(dev, "On-Chip Peripherals bus");
 192         return (BUS_PROBE_DEFAULT);
 193 }
 194
 195 static int
 196 ocpbus_attach(device_t dev)
 197 {
 198         struct ocpbus_softc *sc;
 199         int error, i, tgt, law_max;
 200         uint32_t sr;
 201         u_long start, end;
 202
 203         sc = device_get_softc(dev);
 204
 205         ocpbus_mk_child(dev, OCPBUS_DEVTYPE_I2C, 0);
 206         ocpbus_mk_child(dev, OCPBUS_DEVTYPE_I2C, 1);
 207         ocpbus_mk_child(dev, OCPBUS_DEVTYPE_UART, 0);
 208         ocpbus_mk_child(dev, OCPBUS_DEVTYPE_UART, 1);
 209         ocpbus_mk_child(dev, OCPBUS_DEVTYPE_LBC, 0);
 210         ocpbus_mk_child(dev, OCPBUS_DEVTYPE_PCIB, 0);
 211         ocpbus_mk_child(dev, OCPBUS_DEVTYPE_PCIB, 1);
 212         ocpbus_mk_child(dev, OCPBUS_DEVTYPE_PCIB, 2);
 213         ocpbus_mk_child(dev, OCPBUS_DEVTYPE_TSEC, 0);
 214         ocpbus_mk_child(dev, OCPBUS_DEVTYPE_TSEC, 1);
 215         ocpbus_mk_child(dev, OCPBUS_DEVTYPE_TSEC, 2);
 216         ocpbus_mk_child(dev, OCPBUS_DEVTYPE_TSEC, 3);
 217         ocpbus_mk_child(dev, OCPBUS_DEVTYPE_PIC, 0);
 218         ocpbus_mk_child(dev, OCPBUS_DEVTYPE_QUICC, 0);
 219         ocpbus_mk_child(dev, OCPBUS_DEVTYPE_SEC, 0);
 220
 221         /* Set up IRQ rman */
 222         start = 0;
 223         end = INTR_VECTORS - 1;
 224         sc->sc_irq.rm_start = start;
 225         sc->sc_irq.rm_end = end;
 226         sc->sc_irq.rm_type = RMAN_ARRAY;
 227         sc->sc_irq.rm_descr = "Interrupt request lines";
 228         if (rman_init(&sc->sc_irq) ||
 229             rman_manage_region(&sc->sc_irq, start, end))
 230                 panic("ocpbus_attach IRQ rman");
 231
 232         /* Set up I/O mem rman */
 233         sc->sc_mem.rm_type = RMAN_ARRAY;
 234         sc->sc_mem.rm_descr = "OCPBus Device Memory";
 235         error = rman_init(&sc->sc_mem);
 236         if (error) {
 237                 device_printf(dev, "rman_init() failed. error = %d\n", error);
 238                 return (error);
 239         }
 240
 241         error = rman_manage_region(&sc->sc_mem, CCSRBAR_VA,
 242             CCSRBAR_VA + CCSRBAR_SIZE - 1);
 243         if (error) {
 244                 device_printf(dev, "rman_manage_region() failed. error = %d\n",
 245                     error);
 246                 return (error);
 247         }
 248
 249         /*
 250          * Clear local access windows. Skip DRAM entries, so we don't shoot
 251          * ourselves in the foot.
 252          */
 253         law_max = law_getmax();
 254         for (i = 0; i < law_max; i++) {
 255                 sr = ccsr_read4(OCP85XX_LAWSR(i));
 256                 if ((sr & 0x80000000) == 0)
 257                         continue;
 258                 tgt = (sr & 0x01f00000) >> 20;
 259                 if (tgt == OCP85XX_TGTIF_RAM1 || tgt == OCP85XX_TGTIF_RAM2 ||
 260                     tgt == OCP85XX_TGTIF_RAM_INTL)
 261                         continue;
 262
 263                 ccsr_write4(OCP85XX_LAWSR(i), sr & 0x7fffffff);
 264         }
 265
 266         if (bootverbose)
 267                 device_printf(dev, "PORDEVSR=%08x, PORDEVSR2=%08x\n",
 268                     ccsr_read4(OCP85XX_PORDEVSR),
 269                     ccsr_read4(OCP85XX_PORDEVSR2));
 270
 271         for (i = PIC_IRQ_START; i < PIC_IRQ_START + 4; i++)
 272                 powerpc_config_intr(i, INTR_TRIGGER_LEVEL, INTR_POLARITY_LOW);
 273
 274         return (bus_generic_attach(dev));
 275 }
 276
 277 static int
 278 ocpbus_shutdown(device_t dev)
 279 {
 280
 281         return(0);
 282 }
 283
 284 struct ocp_resource {
 285         int     sr_devtype;
 286         int     sr_unit;
 287         int     sr_resource;
 288         int     sr_rid;
 289         int     sr_offset;
 290         int     sr_size;
 291 };
 292
 293 const struct ocp_resource mpc8555_resources[] = {
 294         {OCPBUS_DEVTYPE_PIC, 0, SYS_RES_MEMORY, 0, OCP85XX_OPENPIC_OFF,
 295             OCP85XX_OPENPIC_SIZE},
 296
 297         {OCPBUS_DEVTYPE_QUICC, 0, SYS_RES_MEMORY, 0, OCP85XX_QUICC_OFF,
 298             OCP85XX_QUICC_SIZE},
 299         {OCPBUS_DEVTYPE_QUICC, 0, SYS_RES_IRQ, 0, PIC_IRQ_INT(30), 1},
 300
 301         {OCPBUS_DEVTYPE_TSEC, 0, SYS_RES_MEMORY, 0, OCP85XX_TSEC0_OFF,
 302             OCP85XX_TSEC_SIZE},
 303         {OCPBUS_DEVTYPE_TSEC, 0, SYS_RES_IRQ, 0, PIC_IRQ_INT(13), 1},
 304         {OCPBUS_DEVTYPE_TSEC, 0, SYS_RES_IRQ, 1, PIC_IRQ_INT(14), 1},
 305         {OCPBUS_DEVTYPE_TSEC, 0, SYS_RES_IRQ, 2, PIC_IRQ_INT(18), 1},
 306         {OCPBUS_DEVTYPE_TSEC, 1, SYS_RES_MEMORY, 0, OCP85XX_TSEC1_OFF,
 307             OCP85XX_TSEC_SIZE},
 308         {OCPBUS_DEVTYPE_TSEC, 1, SYS_RES_IRQ, 0, PIC_IRQ_INT(19), 1},
 309         {OCPBUS_DEVTYPE_TSEC, 1, SYS_RES_IRQ, 1, PIC_IRQ_INT(20), 1},
 310         {OCPBUS_DEVTYPE_TSEC, 1, SYS_RES_IRQ, 2, PIC_IRQ_INT(24), 1},
 311         {OCPBUS_DEVTYPE_TSEC, 2, SYS_RES_MEMORY, 0, OCP85XX_TSEC2_OFF,
 312             OCP85XX_TSEC_SIZE},
 313         {OCPBUS_DEVTYPE_TSEC, 2, SYS_RES_IRQ, 0, PIC_IRQ_INT(15), 1},
 314         {OCPBUS_DEVTYPE_TSEC, 2, SYS_RES_IRQ, 1, PIC_IRQ_INT(16), 1},
 315         {OCPBUS_DEVTYPE_TSEC, 2, SYS_RES_IRQ, 2, PIC_IRQ_INT(17), 1},
 316         {OCPBUS_DEVTYPE_TSEC, 3, SYS_RES_MEMORY, 0, OCP85XX_TSEC3_OFF,
 317             OCP85XX_TSEC_SIZE},
 318         {OCPBUS_DEVTYPE_TSEC, 3, SYS_RES_IRQ, 0, PIC_IRQ_INT(21), 1},
 319         {OCPBUS_DEVTYPE_TSEC, 3, SYS_RES_IRQ, 1, PIC_IRQ_INT(22), 1},
 320         {OCPBUS_DEVTYPE_TSEC, 3, SYS_RES_IRQ, 2, PIC_IRQ_INT(23), 1},
 321
 322         {OCPBUS_DEVTYPE_UART, 0, SYS_RES_MEMORY, 0, OCP85XX_UART0_OFF,
 323             OCP85XX_UART_SIZE},
 324         {OCPBUS_DEVTYPE_UART, 0, SYS_RES_IRQ, 0, PIC_IRQ_INT(26), 1},
 325         {OCPBUS_DEVTYPE_UART, 1, SYS_RES_MEMORY, 0, OCP85XX_UART1_OFF,
 326             OCP85XX_UART_SIZE},
 327         {OCPBUS_DEVTYPE_UART, 1, SYS_RES_IRQ, 0, PIC_IRQ_INT(26), 1},
 328
 329         {OCPBUS_DEVTYPE_PCIB, 0, SYS_RES_MEMORY, 0, OCP85XX_PCI0_OFF,
 330             OCP85XX_PCI_SIZE},
 331         {OCPBUS_DEVTYPE_PCIB, 0, SYS_RES_MEMORY, 1, 0, OCP85XX_TGTIF_PCI0},
 332         {OCPBUS_DEVTYPE_PCIB, 0, SYS_RES_IOPORT, 1, 0, OCP85XX_TGTIF_PCI0},
 333         {OCPBUS_DEVTYPE_PCIB, 1, SYS_RES_MEMORY, 0, OCP85XX_PCI1_OFF,
 334             OCP85XX_PCI_SIZE},
 335         {OCPBUS_DEVTYPE_PCIB, 1, SYS_RES_MEMORY, 1, 0, OCP85XX_TGTIF_PCI1},
 336         {OCPBUS_DEVTYPE_PCIB, 1, SYS_RES_IOPORT, 1, 0, OCP85XX_TGTIF_PCI1},
 337         {OCPBUS_DEVTYPE_PCIB, 2, SYS_RES_MEMORY, 0, OCP85XX_PCI2_OFF,
 338             OCP85XX_PCI_SIZE},
 339         {OCPBUS_DEVTYPE_PCIB, 2, SYS_RES_MEMORY, 1, 0, OCP85XX_TGTIF_PCI2},
 340         {OCPBUS_DEVTYPE_PCIB, 2, SYS_RES_IOPORT, 1, 0, OCP85XX_TGTIF_PCI2},
 341
 342         {OCPBUS_DEVTYPE_LBC, 0, SYS_RES_MEMORY, 0, OCP85XX_LBC_OFF,
 343             OCP85XX_LBC_SIZE},
 344
 345         {OCPBUS_DEVTYPE_I2C, 0, SYS_RES_MEMORY, 0, OCP85XX_I2C0_OFF,
 346             OCP85XX_I2C_SIZE},
 347         {OCPBUS_DEVTYPE_I2C, 0, SYS_RES_IRQ, 0, PIC_IRQ_INT(27), 1},
 348         {OCPBUS_DEVTYPE_I2C, 1, SYS_RES_MEMORY, 0, OCP85XX_I2C1_OFF,
 349             OCP85XX_I2C_SIZE},
 350         {OCPBUS_DEVTYPE_I2C, 1, SYS_RES_IRQ, 0, PIC_IRQ_INT(27), 1},
 351
 352         {OCPBUS_DEVTYPE_SEC, 0, SYS_RES_MEMORY, 0, OCP85XX_SEC_OFF,
 353             OCP85XX_SEC_SIZE},
 354         {OCPBUS_DEVTYPE_SEC, 0, SYS_RES_IRQ, 0, PIC_IRQ_INT(29), 1},
 355         {OCPBUS_DEVTYPE_SEC, 0, SYS_RES_IRQ, 1, PIC_IRQ_INT(42), 1},
 356
 357         {0}
 358 };
 359
 360 static int
 361 ocpbus_get_resource(device_t dev, device_t child, int type, int rid,
 362     u_long *startp, u_long *countp)
 363 {
 364         const struct ocp_resource *res;
 365         struct ocp_devinfo *dinfo;
 366         u_long start = 0, count = 0;
 367         int error;
 368
 369         dinfo = device_get_ivars(child);
 370
 371         /*
 372          * Lookup the correct values.
 373          */
 374         res = mpc8555_resources;
 375         for (; res->sr_devtype; res++) {
 376                 if (res->sr_devtype != dinfo->ocp_devtype)
 377                         continue;
 378                 if (res->sr_unit != dinfo->ocp_unit)
 379                         continue;
 380                 if (res->sr_rid != rid)
 381                         continue;
 382                 if (res->sr_resource != type)
 383                         continue;
 384
 385                 if (res->sr_offset != 0) {
 386                         error = 0;
 387                         switch (type) {
 388                         case SYS_RES_MEMORY:
 389                                 start = res->sr_offset + CCSRBAR_VA;
 390                                 break;
 391                         case SYS_RES_IRQ:
 392                                 start = res->sr_offset;
 393                                 break;
 394                         default:
 395                                 error = EINVAL;
 396                                 break;
 397                         }
 398                         count = res->sr_size;
 399                 } else
 400                         error = ocpbus_write_law(res->sr_size, type, &start,
 401                             &count);
 402
 403                 if (!error) {
 404                         if (startp != NULL)
 405                                 *startp = start;
 406                         if (countp != NULL)
 407                                 *countp = count;
 408                 }
 409                 return (error);
 410         }
 411
 412         return (ENOENT);
 413 }
 414
 415 static struct resource *
 416 ocpbus_alloc_resource(device_t dev, device_t child, int type, int *rid,
 417     u_long start, u_long end, u_long count, u_int flags)
 418 {
 419         struct ocpbus_softc *sc;
 420         struct resource *rv;
 421         int error;
 422
 423         sc = device_get_softc(dev);
 424
 425         switch (type) {
 426         case SYS_RES_IRQ:
 427                 if (start == 0ul && end == ~0ul) {
 428                         error = ocpbus_get_resource(dev, child, type, *rid,
 429                             &start, &count);
 430                         if (error)
 431                                 return (NULL);
 432                 }
 433
 434                 rv = rman_reserve_resource(&sc->sc_irq, start,
 435                     start + count - 1, count, flags, child);
 436                 if (rv == NULL)
 437                         return (NULL);
 438                 break;
 439
 440         case SYS_RES_MEMORY:
 441                 if (start != 0ul || end != ~0ul)
 442                         return (NULL);
 443
 444                 error = ocpbus_get_resource(dev, child, type, *rid, &start,
 445                     &count);
 446                 if (error)
 447                         return (NULL);
 448
 449                 rv = rman_reserve_resource(&sc->sc_mem, start,
 450                     start + count - 1, count, flags, child);
 451                 if (rv == NULL)
 452                         return (NULL);
 453
 454                 rman_set_bustag(rv, &bs_be_tag);
 455                 rman_set_bushandle(rv, rman_get_start(rv));
 456                 break;
 457
 458         default:
 459                 return (NULL);
 460         }
 461
 462         rman_set_rid(rv, *rid);
 463         return (rv);
 464 }
 465
 466 static int
 467 ocpbus_print_child(device_t dev, device_t child)
 468 {
 469         u_long size, start;
 470         int error, retval, rid;
 471
 472         retval = bus_print_child_header(dev, child);
 473
 474         rid = 0;
 475         while (1) {
 476                 error = ocpbus_get_resource(dev, child, SYS_RES_MEMORY, rid,
 477                     &start, &size);
 478                 if (error)
 479                         break;
 480                 retval += (rid == 0) ? printf(" iomem ") : printf(",");
 481                 retval += printf("%#lx", start);
 482                 if (size > 1)
 483                         retval += printf("-%#lx", start + size - 1);
 484                 rid++;
 485         }
 486
 487         /*
 488          * The SYS_RES_IOPORT resource of the PCIB has rid 1 because the
 489          * the SYS_RES_MEMORY resource related to the decoding window also
 490          * has rid 1. This is friendlier for the PCIB child...
 491          */
 492         rid = 1;
 493         while (1) {
 494                 error = ocpbus_get_resource(dev, child, SYS_RES_IOPORT, rid,
 495                     &start, &size);
 496                 if (error)
 497                         break;
 498                 retval += (rid == 1) ? printf(" ioport ") : printf(",");
 499                 retval += printf("%#lx", start);
 500                 if (size > 1)
 501                         retval += printf("-%#lx", start + size - 1);
 502                 rid++;
 503         }
 504
 505         rid = 0;
 506         while (1) {
 507                 error = ocpbus_get_resource(dev, child, SYS_RES_IRQ, rid,
 508                     &start, &size);
 509                 if (error)
 510                         break;
 511                 retval += (rid == 0) ? printf(" irq ") : printf(",");
 512                 retval += printf("%ld", start);
 513                 rid++;
 514         }
 515
 516         retval += bus_print_child_footer(dev, child);
 517         return (retval);
 518 }
 519
 520 static int
 521 ocpbus_read_ivar(device_t dev, device_t child, int index, uintptr_t *result)
 522 {
 523         struct ocp_devinfo *dinfo;
 524         struct bi_eth_addr *eth;
 525         int unit;
 526
 527         if (device_get_parent(child) != dev)
 528                 return (EINVAL);
 529
 530         dinfo = device_get_ivars(child);
 531
 532         switch (index) {
 533         case OCPBUS_IVAR_CLOCK:
 534                 *result = bootinfo->bi_bus_clk;
 535                 return (0);
 536         case OCPBUS_IVAR_DEVTYPE:
 537                 *result = dinfo->ocp_devtype;
 538                 return (0);
 539         case OCPBUS_IVAR_HWUNIT:
 540                 *result = dinfo->ocp_unit;
 541                 return (0);
 542         case OCPBUS_IVAR_MACADDR:
 543                 unit = device_get_unit(child);
 544                 if (unit > bootinfo->bi_eth_addr_no - 1)
 545                         return (EINVAL);
 546                 eth = bootinfo_eth() + unit;
 547                 *result = (uintptr_t)eth;
 548                 return (0);
 549         }
 550
 551         return (EINVAL);
 552 }
 553
 554 static int
 555 ocpbus_release_resource(device_t dev, device_t child, int type, int rid,
 556     struct resource *res)
 557 {
 558
 559         return (rman_release_resource(res));
 560 }
 561
 562 static int
 563 ocpbus_setup_intr(device_t dev, device_t child, struct resource *res, int flags,
 564     driver_filter_t *filter, driver_intr_t *ihand, void *arg, void **cookiep)
 565 {
 566         int error;
 567
 568         if (res == NULL)
 569                 panic("ocpbus_setup_intr: NULL irq resource!");
 570
 571         *cookiep = 0;
 572         if ((rman_get_flags(res) & RF_SHAREABLE) == 0)
 573                 flags |= INTR_EXCL;
 574
 575         /*
 576          * We depend here on rman_activate_resource() being idempotent.
 577          */
 578         error = rman_activate_resource(res);
 579         if (error)
 580                 return (error);
 581
 582         error = powerpc_setup_intr(device_get_nameunit(child),
 583             rman_get_start(res), filter, ihand, arg, flags, cookiep);
 584
 585         return (error);
 586 }
 587
 588 static int
 589 ocpbus_teardown_intr(device_t dev, device_t child, struct resource *res,
 590     void *cookie)
 591 {
 592
 593         return (powerpc_teardown_intr(cookie));
 594 }
 595
 596 static int
 597 ocpbus_config_intr(device_t dev, int irq, enum intr_trigger trig,
 598     enum intr_polarity pol)
 599 {
 600
 601         return (powerpc_config_intr(irq, trig, pol));
 602 }