sys/powerpc/powermac/uninorth.c

   1 /*-
   2  * Copyright (C) 2002 Benno Rice.
   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  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY Benno Rice ``AS IS'' AND ANY EXPRESS OR
  15  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  16  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  17  * IN NO EVENT SHALL TOOLS GMBH BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  18  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  20  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  21  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  22  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  23  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  24  *
  25  * $FreeBSD$
  26  */
  27
  28 #include <sys/param.h>
  29 #include <sys/systm.h>
  30 #include <sys/module.h>
  31 #include <sys/bus.h>
  32 #include <sys/conf.h>
  33 #include <sys/kernel.h>
  34
  35 #include <dev/ofw/openfirm.h>
  36 #include <dev/ofw/ofw_pci.h>
  37 #include <dev/ofw/ofw_bus.h>
  38 #include <dev/ofw/ofw_bus_subr.h>
  39
  40 #include <dev/pci/pcivar.h>
  41 #include <dev/pci/pcireg.h>
  42
  43 #include <machine/bus.h>
  44 #include <machine/intr_machdep.h>
  45 #include <machine/md_var.h>
  46 #include <machine/pio.h>
  47 #include <machine/resource.h>
  48
  49 #include <sys/rman.h>
  50
  51 #include <powerpc/powermac/uninorthvar.h>
  52
  53 #include <vm/vm.h>
  54 #include <vm/pmap.h>
  55
  56 /*
  57  * Driver for the Uninorth chip itself.
  58  */
  59
  60 static MALLOC_DEFINE(M_UNIN, "unin", "unin device information");
  61
  62 /*
  63  * Device interface.
  64  */
  65
  66 static int  unin_chip_probe(device_t);
  67 static int  unin_chip_attach(device_t);
  68
  69 /*
  70  * Bus interface.
  71  */
  72 static int  unin_chip_print_child(device_t dev, device_t child);
  73 static void unin_chip_probe_nomatch(device_t, device_t);
  74 static struct resource *unin_chip_alloc_resource(device_t, device_t, int, int *,
  75                                                  rman_res_t, rman_res_t,
  76                                                  rman_res_t, u_int);
  77 static int  unin_chip_activate_resource(device_t, device_t, int, int,
  78                                         struct resource *);
  79 static int  unin_chip_deactivate_resource(device_t, device_t, int, int,
  80                                           struct resource *);
  81 static int  unin_chip_release_resource(device_t, device_t, int, int,
  82                                        struct resource *);
  83 static struct resource_list *unin_chip_get_resource_list (device_t, device_t);
  84
  85 /*
  86  * OFW Bus interface
  87  */
  88
  89 static ofw_bus_get_devinfo_t unin_chip_get_devinfo;
  90
  91 /*
  92  * Local routines
  93  */
  94
  95 static void             unin_enable_gmac(device_t dev);
  96 static void             unin_enable_mpic(device_t dev);
  97
  98 /*
  99  * Driver methods.
 100  */
 101 static device_method_t unin_chip_methods[] = {
 102
 103         /* Device interface */
 104         DEVMETHOD(device_probe,         unin_chip_probe),
 105         DEVMETHOD(device_attach,        unin_chip_attach),
 106
 107         /* Bus interface */
 108         DEVMETHOD(bus_print_child,      unin_chip_print_child),
 109         DEVMETHOD(bus_probe_nomatch,    unin_chip_probe_nomatch),
 110         DEVMETHOD(bus_setup_intr,       bus_generic_setup_intr),
 111         DEVMETHOD(bus_teardown_intr,    bus_generic_teardown_intr),
 112
 113         DEVMETHOD(bus_alloc_resource,   unin_chip_alloc_resource),
 114         DEVMETHOD(bus_release_resource, unin_chip_release_resource),
 115         DEVMETHOD(bus_activate_resource, unin_chip_activate_resource),
 116         DEVMETHOD(bus_deactivate_resource, unin_chip_deactivate_resource),
 117         DEVMETHOD(bus_get_resource_list, unin_chip_get_resource_list),
 118
 119         DEVMETHOD(bus_child_pnpinfo_str, ofw_bus_gen_child_pnpinfo_str),
 120
 121         /* ofw_bus interface */
 122         DEVMETHOD(ofw_bus_get_devinfo,  unin_chip_get_devinfo),
 123         DEVMETHOD(ofw_bus_get_compat,   ofw_bus_gen_get_compat),
 124         DEVMETHOD(ofw_bus_get_model,    ofw_bus_gen_get_model),
 125         DEVMETHOD(ofw_bus_get_name,     ofw_bus_gen_get_name),
 126         DEVMETHOD(ofw_bus_get_node,     ofw_bus_gen_get_node),
 127         DEVMETHOD(ofw_bus_get_type,     ofw_bus_gen_get_type),
 128
 129         { 0, 0 }
 130 };
 131
 132 static driver_t unin_chip_driver = {
 133         "unin",
 134         unin_chip_methods,
 135         sizeof(struct unin_chip_softc)
 136 };
 137
 138 static devclass_t       unin_chip_devclass;
 139
 140 /*
 141  * Assume there is only one unin chip in a PowerMac, so that pmu.c functions can
 142  * suspend the chip after the whole rest of the device tree is suspended, not
 143  * earlier.
 144  */
 145 static device_t         unin_chip;
 146
 147 DRIVER_MODULE(unin, ofwbus, unin_chip_driver, unin_chip_devclass, 0, 0);
 148
 149 /*
 150  * Add an interrupt to the dev's resource list if present
 151  */
 152 static void
 153 unin_chip_add_intr(phandle_t devnode, struct unin_chip_devinfo *dinfo)
 154 {
 155         phandle_t iparent;
 156         int     *intr;
 157         int     i, nintr;
 158         int     icells;
 159
 160         if (dinfo->udi_ninterrupts >= 6) {
 161                 printf("unin: device has more than 6 interrupts\n");
 162                 return;
 163         }
 164
 165         nintr = OF_getprop_alloc(devnode, "interrupts", sizeof(*intr),
 166                 (void **)&intr);
 167         if (nintr == -1) {
 168                 nintr = OF_getprop_alloc(devnode, "AAPL,interrupts",
 169                         sizeof(*intr), (void **)&intr);
 170                 if (nintr == -1)
 171                         return;
 172         }
 173
 174         if (intr[0] == -1)
 175                 return;
 176
 177         if (OF_getprop(devnode, "interrupt-parent", &iparent, sizeof(iparent))
 178             <= 0)
 179                 panic("Interrupt but no interrupt parent!\n");
 180
 181         if (OF_searchprop(iparent, "#interrupt-cells", &icells, sizeof(icells))
 182             <= 0)
 183                 icells = 1;
 184
 185         for (i = 0; i < nintr; i+=icells) {
 186                 u_int irq = MAP_IRQ(iparent, intr[i]);
 187
 188                 resource_list_add(&dinfo->udi_resources, SYS_RES_IRQ,
 189                     dinfo->udi_ninterrupts, irq, irq, 1);
 190
 191                 if (icells > 1) {
 192                         powerpc_config_intr(irq,
 193                             (intr[i+1] & 1) ? INTR_TRIGGER_LEVEL :
 194                             INTR_TRIGGER_EDGE, INTR_POLARITY_LOW);
 195                 }
 196
 197                 dinfo->udi_interrupts[dinfo->udi_ninterrupts] = irq;
 198                 dinfo->udi_ninterrupts++;
 199         }
 200 }
 201
 202 static void
 203 unin_chip_add_reg(phandle_t devnode, struct unin_chip_devinfo *dinfo)
 204 {
 205         struct  unin_chip_reg *reg;
 206         int     i, nreg;
 207
 208         nreg = OF_getprop_alloc(devnode, "reg", sizeof(*reg), (void **)&reg);
 209         if (nreg == -1)
 210                 return;
 211
 212         for (i = 0; i < nreg; i++) {
 213                 resource_list_add(&dinfo->udi_resources, SYS_RES_MEMORY, i,
 214                                   reg[i].mr_base,
 215                                   reg[i].mr_base + reg[i].mr_size,
 216                                   reg[i].mr_size);
 217         }
 218 }
 219
 220 static void
 221 unin_update_reg(device_t dev, uint32_t regoff, uint32_t set, uint32_t clr)
 222 {
 223         volatile u_int *reg;
 224         struct unin_chip_softc *sc;
 225         u_int32_t tmpl;
 226
 227         sc = device_get_softc(dev);
 228         reg = (void *)(sc->sc_addr + regoff);
 229         tmpl = inl(reg);
 230         tmpl &= ~clr;
 231         tmpl |= set;
 232         outl(reg, tmpl);
 233 }
 234
 235 static void
 236 unin_enable_gmac(device_t dev)
 237 {
 238         unin_update_reg(dev, UNIN_CLOCKCNTL, UNIN_CLOCKCNTL_GMAC, 0);
 239 }
 240
 241 static void
 242 unin_enable_mpic(device_t dev)
 243 {
 244         unin_update_reg(dev, UNIN_TOGGLE_REG, UNIN_MPIC_RESET | UNIN_MPIC_OUTPUT_ENABLE, 0);
 245 }
 246
 247 static int
 248 unin_chip_probe(device_t dev)
 249 {
 250         const char      *name;
 251
 252         name = ofw_bus_get_name(dev);
 253
 254         if (name == NULL)
 255                 return (ENXIO);
 256
 257         if (strcmp(name, "uni-n") != 0 && strcmp(name, "u3") != 0
 258             && strcmp(name, "u4") != 0)
 259                 return (ENXIO);
 260
 261         device_set_desc(dev, "Apple UniNorth System Controller");
 262         return (0);
 263 }
 264
 265 static int
 266 unin_chip_attach(device_t dev)
 267 {
 268         struct unin_chip_softc *sc;
 269         struct unin_chip_devinfo *dinfo;
 270         phandle_t  root;
 271         phandle_t  child;
 272         phandle_t  iparent;
 273         device_t   cdev;
 274         cell_t     acells, scells;
 275         char compat[32];
 276         char name[32];
 277         u_int irq, reg[3];
 278         int error, i = 0;
 279
 280         sc = device_get_softc(dev);
 281         root = ofw_bus_get_node(dev);
 282
 283         if (OF_getprop(root, "reg", reg, sizeof(reg)) < 8)
 284                 return (ENXIO);
 285
 286         acells = scells = 1;
 287         OF_getprop(OF_parent(root), "#address-cells", &acells, sizeof(acells));
 288         OF_getprop(OF_parent(root), "#size-cells", &scells, sizeof(scells));
 289
 290         i = 0;
 291         sc->sc_physaddr = reg[i++];
 292         if (acells == 2) {
 293                 sc->sc_physaddr <<= 32;
 294                 sc->sc_physaddr |= reg[i++];
 295         }
 296         sc->sc_size = reg[i++];
 297         if (scells == 2) {
 298                 sc->sc_size <<= 32;
 299                 sc->sc_size |= reg[i++];
 300         }
 301
 302         sc->sc_mem_rman.rm_type = RMAN_ARRAY;
 303         sc->sc_mem_rman.rm_descr = "UniNorth Device Memory";
 304
 305         error = rman_init(&sc->sc_mem_rman);
 306
 307         if (error) {
 308                 device_printf(dev, "rman_init() failed. error = %d\n", error);
 309                 return (error);
 310         }
 311
 312         error = rman_manage_region(&sc->sc_mem_rman, sc->sc_physaddr,
 313                                    sc->sc_physaddr + sc->sc_size - 1);
 314         if (error) {
 315                 device_printf(dev,
 316                               "rman_manage_region() failed. error = %d\n",
 317                               error);
 318                 return (error);
 319         }
 320
 321         if (unin_chip == NULL)
 322                 unin_chip = dev;
 323
 324         /*
 325          * Iterate through the sub-devices
 326          */
 327         for (child = OF_child(root); child != 0; child = OF_peer(child)) {
 328                 dinfo = malloc(sizeof(*dinfo), M_UNIN, M_WAITOK | M_ZERO);
 329                 if (ofw_bus_gen_setup_devinfo(&dinfo->udi_obdinfo, child)
 330                     != 0)
 331                 {
 332                         free(dinfo, M_UNIN);
 333                         continue;
 334                 }
 335
 336                 resource_list_init(&dinfo->udi_resources);
 337                 dinfo->udi_ninterrupts = 0;
 338                 unin_chip_add_intr(child, dinfo);
 339
 340                 /*
 341                  * Some Apple machines do have a bug in OF, they miss
 342                  * the interrupt entries on the U3 I2C node. That means they
 343                  * do not have an entry with number of interrupts nor the
 344                  * entry of the interrupt parent handle.
 345                  * We define an interrupt and hardwire it to the /u3/mpic
 346                  * handle.
 347                  */
 348
 349                 if (OF_getprop(child, "name", name, sizeof(name)) <= 0)
 350                         device_printf(dev, "device has no name!\n");
 351                 if (dinfo->udi_ninterrupts == 0 &&
 352                     (strcmp(name, "i2c-bus") == 0 ||
 353                      strcmp(name, "i2c")  == 0)) {
 354                         if (OF_getprop(child, "interrupt-parent", &iparent,
 355                                        sizeof(iparent)) <= 0) {
 356                                 iparent = OF_finddevice("/u3/mpic");
 357                                 device_printf(dev, "Set /u3/mpic as iparent!\n");
 358                         }
 359                         /* Add an interrupt number 0 to the parent. */
 360                         irq = MAP_IRQ(iparent, 0);
 361                         resource_list_add(&dinfo->udi_resources, SYS_RES_IRQ,
 362                                           dinfo->udi_ninterrupts, irq, irq, 1);
 363                         dinfo->udi_interrupts[dinfo->udi_ninterrupts] = irq;
 364                         dinfo->udi_ninterrupts++;
 365                 }
 366
 367                 unin_chip_add_reg(child, dinfo);
 368
 369                 cdev = device_add_child(dev, NULL, -1);
 370                 if (cdev == NULL) {
 371                         device_printf(dev, "<%s>: device_add_child failed\n",
 372                                       dinfo->udi_obdinfo.obd_name);
 373                         resource_list_free(&dinfo->udi_resources);
 374                         ofw_bus_gen_destroy_devinfo(&dinfo->udi_obdinfo);
 375                         free(dinfo, M_UNIN);
 376                         continue;
 377                 }
 378
 379                 device_set_ivars(cdev, dinfo);
 380         }
 381
 382         /*
 383          * Only map the first page, since that is where the registers
 384          * of interest lie.
 385          */
 386         sc->sc_addr = (vm_offset_t)pmap_mapdev(sc->sc_physaddr, PAGE_SIZE);
 387
 388         sc->sc_version = *(u_int *)sc->sc_addr;
 389         device_printf(dev, "Version %d\n", sc->sc_version);
 390
 391         /*
 392          * Enable the GMAC Ethernet cell and the integrated OpenPIC
 393          * if Open Firmware says they are used.
 394          */
 395         for (child = OF_child(root); child; child = OF_peer(child)) {
 396                 memset(compat, 0, sizeof(compat));
 397                 OF_getprop(child, "compatible", compat, sizeof(compat));
 398                 if (strcmp(compat, "gmac") == 0)
 399                         unin_enable_gmac(dev);
 400                 if (strcmp(compat, "chrp,open-pic") == 0)
 401                         unin_enable_mpic(dev);
 402         }
 403
 404         /*
 405          * GMAC lives under the PCI bus, so just check if enet is gmac.
 406          */
 407         child = OF_finddevice("enet");
 408         memset(compat, 0, sizeof(compat));
 409         OF_getprop(child, "compatible", compat, sizeof(compat));
 410         if (strcmp(compat, "gmac") == 0)
 411                 unin_enable_gmac(dev);
 412
 413         return (bus_generic_attach(dev));
 414 }
 415
 416 static int
 417 unin_chip_print_child(device_t dev, device_t child)
 418 {
 419         struct unin_chip_devinfo *dinfo;
 420         struct resource_list *rl;
 421         int retval = 0;
 422
 423         dinfo = device_get_ivars(child);
 424         rl = &dinfo->udi_resources;
 425
 426         retval += bus_print_child_header(dev, child);
 427
 428         retval += resource_list_print_type(rl, "mem", SYS_RES_MEMORY, "%#jx");
 429         retval += resource_list_print_type(rl, "irq", SYS_RES_IRQ, "%jd");
 430
 431         retval += bus_print_child_footer(dev, child);
 432
 433         return (retval);
 434 }
 435
 436 static void
 437 unin_chip_probe_nomatch(device_t dev, device_t child)
 438 {
 439         struct unin_chip_devinfo *dinfo;
 440         struct resource_list *rl;
 441         const char *type;
 442
 443         if (bootverbose) {
 444                 dinfo = device_get_ivars(child);
 445                 rl = &dinfo->udi_resources;
 446
 447                 if ((type = ofw_bus_get_type(child)) == NULL)
 448                         type = "(unknown)";
 449                 device_printf(dev, "<%s, %s>", type, ofw_bus_get_name(child));
 450                 resource_list_print_type(rl, "mem", SYS_RES_MEMORY, "%#jx");
 451                 resource_list_print_type(rl, "irq", SYS_RES_IRQ, "%jd");
 452                 printf(" (no driver attached)\n");
 453         }
 454 }
 455
 456
 457 static struct resource *
 458 unin_chip_alloc_resource(device_t bus, device_t child, int type, int *rid,
 459                          rman_res_t start, rman_res_t end, rman_res_t count,
 460                          u_int flags)
 461 {
 462         struct          unin_chip_softc *sc;
 463         int             needactivate;
 464         struct          resource *rv;
 465         struct          rman *rm;
 466         u_long          adjstart, adjend, adjcount;
 467         struct          unin_chip_devinfo *dinfo;
 468         struct          resource_list_entry *rle;
 469
 470         sc = device_get_softc(bus);
 471         dinfo = device_get_ivars(child);
 472
 473         needactivate = flags & RF_ACTIVE;
 474         flags &= ~RF_ACTIVE;
 475
 476         switch (type) {
 477         case SYS_RES_MEMORY:
 478         case SYS_RES_IOPORT:
 479                 rle = resource_list_find(&dinfo->udi_resources, SYS_RES_MEMORY,
 480                                          *rid);
 481                 if (rle == NULL) {
 482                         device_printf(bus, "no rle for %s memory %d\n",
 483                                       device_get_nameunit(child), *rid);
 484                         return (NULL);
 485                 }
 486
 487                 rle->end = rle->end - 1; /* Hack? */
 488
 489                 if (start < rle->start)
 490                         adjstart = rle->start;
 491                 else if (start > rle->end)
 492                         adjstart = rle->end;
 493                 else
 494                         adjstart = start;
 495
 496                 if (end < rle->start)
 497                         adjend = rle->start;
 498                 else if (end > rle->end)
 499                         adjend = rle->end;
 500                 else
 501                         adjend = end;
 502
 503                 adjcount = adjend - adjstart;
 504
 505                 rm = &sc->sc_mem_rman;
 506                 break;
 507
 508         case SYS_RES_IRQ:
 509                 /* Check for passthrough from subattachments. */
 510                 if (device_get_parent(child) != bus)
 511                         return BUS_ALLOC_RESOURCE(device_get_parent(bus), child,
 512                                                   type, rid, start, end, count,
 513                                                   flags);
 514
 515                 rle = resource_list_find(&dinfo->udi_resources, SYS_RES_IRQ,
 516                     *rid);
 517                 if (rle == NULL) {
 518                         if (dinfo->udi_ninterrupts >= 6) {
 519                                 device_printf(bus,
 520                                               "%s has more than 6 interrupts\n",
 521                                               device_get_nameunit(child));
 522                                 return (NULL);
 523                         }
 524                         resource_list_add(&dinfo->udi_resources, SYS_RES_IRQ,
 525                                           dinfo->udi_ninterrupts, start, start,
 526                                           1);
 527
 528                         dinfo->udi_interrupts[dinfo->udi_ninterrupts] = start;
 529                         dinfo->udi_ninterrupts++;
 530                 }
 531
 532                 return (resource_list_alloc(&dinfo->udi_resources, bus, child,
 533                                             type, rid, start, end, count,
 534                                             flags));
 535         default:
 536                 device_printf(bus, "unknown resource request from %s\n",
 537                               device_get_nameunit(child));
 538                 return (NULL);
 539         }
 540
 541         rv = rman_reserve_resource(rm, adjstart, adjend, adjcount, flags,
 542                                    child);
 543         if (rv == NULL) {
 544                 device_printf(bus,
 545                               "failed to reserve resource %#lx - %#lx (%#lx)"
 546                               " for %s\n", adjstart, adjend, adjcount,
 547                               device_get_nameunit(child));
 548                 return (NULL);
 549         }
 550
 551         rman_set_rid(rv, *rid);
 552
 553         if (needactivate) {
 554                 if (bus_activate_resource(child, type, *rid, rv) != 0) {
 555                         device_printf(bus,
 556                                       "failed to activate resource for %s\n",
 557                                       device_get_nameunit(child));
 558                         rman_release_resource(rv);
 559                         return (NULL);
 560                 }
 561         }
 562
 563         return (rv);
 564 }
 565
 566 static int
 567 unin_chip_release_resource(device_t bus, device_t child, int type, int rid,
 568                            struct resource *res)
 569 {
 570         if (rman_get_flags(res) & RF_ACTIVE) {
 571                 int error = bus_deactivate_resource(child, type, rid, res);
 572                 if (error)
 573                         return error;
 574         }
 575
 576         return (rman_release_resource(res));
 577 }
 578
 579 static int
 580 unin_chip_activate_resource(device_t bus, device_t child, int type, int rid,
 581                             struct resource *res)
 582 {
 583         void    *p;
 584
 585         if (type == SYS_RES_IRQ)
 586                 return (bus_activate_resource(bus, type, rid, res));
 587
 588         if ((type == SYS_RES_MEMORY) || (type == SYS_RES_IOPORT)) {
 589                 vm_offset_t start;
 590
 591                 start = (vm_offset_t) rman_get_start(res);
 592
 593                 if (bootverbose)
 594                         printf("unin mapdev: start %zx, len %jd\n", start,
 595                                rman_get_size(res));
 596
 597                 p = pmap_mapdev(start, (vm_size_t) rman_get_size(res));
 598                 if (p == NULL)
 599                         return (ENOMEM);
 600                 rman_set_virtual(res, p);
 601                 rman_set_bustag(res, &bs_be_tag);
 602                 rman_set_bushandle(res, (u_long)p);
 603         }
 604
 605         return (rman_activate_resource(res));
 606 }
 607
 608
 609 static int
 610 unin_chip_deactivate_resource(device_t bus, device_t child, int type, int rid,
 611                               struct resource *res)
 612 {
 613         /*
 614          * If this is a memory resource, unmap it.
 615          */
 616         if ((type == SYS_RES_MEMORY) || (type == SYS_RES_IOPORT)) {
 617                 u_int32_t psize;
 618
 619                 psize = rman_get_size(res);
 620                 pmap_unmapdev((vm_offset_t)rman_get_virtual(res), psize);
 621         }
 622
 623         return (rman_deactivate_resource(res));
 624 }
 625
 626
 627 static struct resource_list *
 628 unin_chip_get_resource_list (device_t dev, device_t child)
 629 {
 630         struct unin_chip_devinfo *dinfo;
 631
 632         dinfo = device_get_ivars(child);
 633         return (&dinfo->udi_resources);
 634 }
 635
 636 static const struct ofw_bus_devinfo *
 637 unin_chip_get_devinfo(device_t dev, device_t child)
 638 {
 639         struct unin_chip_devinfo *dinfo;
 640
 641         dinfo = device_get_ivars(child);
 642         return (&dinfo->udi_obdinfo);
 643 }
 644
 645 int
 646 unin_chip_wake(device_t dev)
 647 {
 648
 649         if (dev == NULL)
 650                 dev = unin_chip;
 651         unin_update_reg(dev, UNIN_PWR_MGMT, UNIN_PWR_NORMAL, UNIN_PWR_MASK);
 652         DELAY(10);
 653         unin_update_reg(dev, UNIN_HWINIT_STATE, UNIN_RUNNING, 0);
 654         DELAY(100);
 655
 656         return (0);
 657 }
 658
 659 int
 660 unin_chip_sleep(device_t dev, int idle)
 661 {
 662         if (dev == NULL)
 663                 dev = unin_chip;
 664
 665         unin_update_reg(dev, UNIN_HWINIT_STATE, UNIN_SLEEPING, 0);
 666         DELAY(10);
 667         if (idle)
 668                 unin_update_reg(dev, UNIN_PWR_MGMT, UNIN_PWR_IDLE2, UNIN_PWR_MASK);
 669         else
 670                 unin_update_reg(dev, UNIN_PWR_MGMT, UNIN_PWR_SLEEP, UNIN_PWR_MASK);
 671         DELAY(10);
 672
 673         return (0);
 674 }