sys/kern/subr_bus.c

   1 /*-
   2  * Copyright (c) 1997,1998 Doug Rabson
   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 THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  *
  26  * $FreeBSD$
  27  */
  28
  29 #include "opt_bus.h"
  30
  31 #include <sys/param.h>
  32 #include <sys/queue.h>
  33 #include <sys/malloc.h>
  34 #include <sys/kernel.h>
  35 #include <sys/module.h>
  36 #include <sys/kobj.h>
  37 #include <sys/bus_private.h>
  38 #include <sys/sysctl.h>
  39 #include <sys/systm.h>
  40 #include <machine/bus.h>
  41 #include <sys/rman.h>
  42 #include <machine/stdarg.h>     /* for device_printf() */
  43
  44 static MALLOC_DEFINE(M_BUS, "bus", "Bus data structures");
  45
  46 #ifdef BUS_DEBUG
  47
  48 static int bus_debug = 1;
  49 SYSCTL_INT(_debug, OID_AUTO, bus_debug, CTLFLAG_RW, &bus_debug, 0,
  50     "Debug bus code");
  51
  52 #define PDEBUG(a)       if (bus_debug) {printf("%s:%d: ", __func__, __LINE__), printf a, printf("\n");}
  53 #define DEVICENAME(d)   ((d)? device_get_name(d): "no device")
  54 #define DRIVERNAME(d)   ((d)? d->name : "no driver")
  55 #define DEVCLANAME(d)   ((d)? d->name : "no devclass")
  56
  57 /* Produce the indenting, indent*2 spaces plus a '.' ahead of that to
  58  * prevent syslog from deleting initial spaces
  59  */
  60 #define indentprintf(p) do { int iJ; printf("."); for (iJ=0; iJ<indent; iJ++) printf("  "); printf p ; } while (0)
  61
  62 static void print_device_short(device_t dev, int indent);
  63 static void print_device(device_t dev, int indent);
  64 void print_device_tree_short(device_t dev, int indent);
  65 void print_device_tree(device_t dev, int indent);
  66 static void print_driver_short(driver_t *driver, int indent);
  67 static void print_driver(driver_t *driver, int indent);
  68 static void print_driver_list(driver_list_t drivers, int indent);
  69 static void print_devclass_short(devclass_t dc, int indent);
  70 static void print_devclass(devclass_t dc, int indent);
  71 void print_devclass_list_short(void);
  72 void print_devclass_list(void);
  73
  74 #else
  75 /* Make the compiler ignore the function calls */
  76 #define PDEBUG(a)                       /* nop */
  77 #define DEVICENAME(d)                   /* nop */
  78 #define DRIVERNAME(d)                   /* nop */
  79 #define DEVCLANAME(d)                   /* nop */
  80
  81 #define print_device_short(d,i)         /* nop */
  82 #define print_device(d,i)               /* nop */
  83 #define print_device_tree_short(d,i)    /* nop */
  84 #define print_device_tree(d,i)          /* nop */
  85 #define print_driver_short(d,i)         /* nop */
  86 #define print_driver(d,i)               /* nop */
  87 #define print_driver_list(d,i)          /* nop */
  88 #define print_devclass_short(d,i)       /* nop */
  89 #define print_devclass(d,i)             /* nop */
  90 #define print_devclass_list_short()     /* nop */
  91 #define print_devclass_list()           /* nop */
  92 #endif
  93
  94 TAILQ_HEAD(,device)     bus_data_devices;
  95 static int bus_data_generation = 1;
  96
  97 kobj_method_t null_methods[] = {
  98         { 0, 0 }
  99 };
 100
 101 DEFINE_CLASS(null, null_methods, 0);
 102
 103 /*
 104  * Devclass implementation
 105  */
 106
 107 static devclass_list_t devclasses = TAILQ_HEAD_INITIALIZER(devclasses);
 108
 109 static devclass_t
 110 devclass_find_internal(const char *classname, int create)
 111 {
 112         devclass_t dc;
 113
 114         PDEBUG(("looking for %s", classname));
 115         if (!classname)
 116                 return (NULL);
 117
 118         TAILQ_FOREACH(dc, &devclasses, link) {
 119                 if (!strcmp(dc->name, classname))
 120                         return (dc);
 121         }
 122
 123         PDEBUG(("%s not found%s", classname, (create? ", creating": "")));
 124         if (create) {
 125                 dc = malloc(sizeof(struct devclass) + strlen(classname) + 1,
 126                     M_BUS, M_NOWAIT|M_ZERO);
 127                 if (!dc)
 128                         return (NULL);
 129                 dc->name = (char*) (dc + 1);
 130                 strcpy(dc->name, classname);
 131                 TAILQ_INIT(&dc->drivers);
 132                 TAILQ_INSERT_TAIL(&devclasses, dc, link);
 133
 134                 bus_data_generation_update();
 135         }
 136
 137         return (dc);
 138 }
 139
 140 devclass_t
 141 devclass_create(const char *classname)
 142 {
 143         return (devclass_find_internal(classname, TRUE));
 144 }
 145
 146 devclass_t
 147 devclass_find(const char *classname)
 148 {
 149         return (devclass_find_internal(classname, FALSE));
 150 }
 151
 152 int
 153 devclass_add_driver(devclass_t dc, driver_t *driver)
 154 {
 155         driverlink_t dl;
 156         int i;
 157
 158         PDEBUG(("%s", DRIVERNAME(driver)));
 159
 160         dl = malloc(sizeof *dl, M_BUS, M_NOWAIT|M_ZERO);
 161         if (!dl)
 162                 return (ENOMEM);
 163
 164         /*
 165          * Compile the driver's methods. Also increase the reference count
 166          * so that the class doesn't get freed when the last instance
 167          * goes. This means we can safely use static methods and avoids a
 168          * double-free in devclass_delete_driver.
 169          */
 170         kobj_class_compile((kobj_class_t) driver);
 171
 172         /*
 173          * Make sure the devclass which the driver is implementing exists.
 174          */
 175         devclass_find_internal(driver->name, TRUE);
 176
 177         dl->driver = driver;
 178         TAILQ_INSERT_TAIL(&dc->drivers, dl, link);
 179         driver->refs++;
 180
 181         /*
 182          * Call BUS_DRIVER_ADDED for any existing busses in this class.
 183          */
 184         for (i = 0; i < dc->maxunit; i++)
 185                 if (dc->devices[i])
 186                         BUS_DRIVER_ADDED(dc->devices[i], driver);
 187
 188         bus_data_generation_update();
 189         return (0);
 190 }
 191
 192 int
 193 devclass_delete_driver(devclass_t busclass, driver_t *driver)
 194 {
 195         devclass_t dc = devclass_find(driver->name);
 196         driverlink_t dl;
 197         device_t dev;
 198         int i;
 199         int error;
 200
 201         PDEBUG(("%s from devclass %s", driver->name, DEVCLANAME(busclass)));
 202
 203         if (!dc)
 204                 return (0);
 205
 206         /*
 207          * Find the link structure in the bus' list of drivers.
 208          */
 209         TAILQ_FOREACH(dl, &busclass->drivers, link) {
 210                 if (dl->driver == driver)
 211                         break;
 212         }
 213
 214         if (!dl) {
 215                 PDEBUG(("%s not found in %s list", driver->name,
 216                     busclass->name));
 217                 return (ENOENT);
 218         }
 219
 220         /*
 221          * Disassociate from any devices.  We iterate through all the
 222          * devices in the devclass of the driver and detach any which are
 223          * using the driver and which have a parent in the devclass which
 224          * we are deleting from.
 225          *
 226          * Note that since a driver can be in multiple devclasses, we
 227          * should not detach devices which are not children of devices in
 228          * the affected devclass.
 229          */
 230         for (i = 0; i < dc->maxunit; i++) {
 231                 if (dc->devices[i]) {
 232                         dev = dc->devices[i];
 233                         if (dev->driver == driver && dev->parent &&
 234                             dev->parent->devclass == busclass) {
 235                                 if ((error = device_detach(dev)) != 0)
 236                                         return (error);
 237                                 device_set_driver(dev, NULL);
 238                         }
 239                 }
 240         }
 241
 242         TAILQ_REMOVE(&busclass->drivers, dl, link);
 243         free(dl, M_BUS);
 244
 245         driver->refs--;
 246         if (driver->refs == 0)
 247                 kobj_class_free((kobj_class_t) driver);
 248
 249         bus_data_generation_update();
 250         return (0);
 251 }
 252
 253 static driverlink_t
 254 devclass_find_driver_internal(devclass_t dc, const char *classname)
 255 {
 256         driverlink_t dl;
 257
 258         PDEBUG(("%s in devclass %s", classname, DEVCLANAME(dc)));
 259
 260         TAILQ_FOREACH(dl, &dc->drivers, link) {
 261                 if (!strcmp(dl->driver->name, classname))
 262                         return (dl);
 263         }
 264
 265         PDEBUG(("not found"));
 266         return (NULL);
 267 }
 268
 269 driver_t *
 270 devclass_find_driver(devclass_t dc, const char *classname)
 271 {
 272         driverlink_t dl;
 273
 274         dl = devclass_find_driver_internal(dc, classname);
 275         if (dl)
 276                 return (dl->driver);
 277         return (NULL);
 278 }
 279
 280 const char *
 281 devclass_get_name(devclass_t dc)
 282 {
 283         return (dc->name);
 284 }
 285
 286 device_t
 287 devclass_get_device(devclass_t dc, int unit)
 288 {
 289         if (dc == NULL || unit < 0 || unit >= dc->maxunit)
 290                 return (NULL);
 291         return (dc->devices[unit]);
 292 }
 293
 294 void *
 295 devclass_get_softc(devclass_t dc, int unit)
 296 {
 297         device_t dev;
 298
 299         dev = devclass_get_device(dc, unit);
 300         if (!dev)
 301                 return (NULL);
 302
 303         return (device_get_softc(dev));
 304 }
 305
 306 int
 307 devclass_get_devices(devclass_t dc, device_t **devlistp, int *devcountp)
 308 {
 309         int i;
 310         int count;
 311         device_t *list;
 312
 313         count = 0;
 314         for (i = 0; i < dc->maxunit; i++)
 315                 if (dc->devices[i])
 316                         count++;
 317
 318         list = malloc(count * sizeof(device_t), M_TEMP, M_NOWAIT|M_ZERO);
 319         if (!list)
 320                 return (ENOMEM);
 321
 322         count = 0;
 323         for (i = 0; i < dc->maxunit; i++) {
 324                 if (dc->devices[i]) {
 325                         list[count] = dc->devices[i];
 326                         count++;
 327                 }
 328         }
 329
 330         *devlistp = list;
 331         *devcountp = count;
 332
 333         return (0);
 334 }
 335
 336 int
 337 devclass_get_maxunit(devclass_t dc)
 338 {
 339         return (dc->maxunit);
 340 }
 341
 342 int
 343 devclass_find_free_unit(devclass_t dc, int unit)
 344 {
 345         if (dc == NULL)
 346                 return (unit);
 347         while (unit < dc->maxunit && dc->devices[unit] != NULL)
 348                 unit++;
 349         return (unit);
 350 }
 351
 352 static int
 353 devclass_alloc_unit(devclass_t dc, int *unitp)
 354 {
 355         int unit = *unitp;
 356
 357         PDEBUG(("unit %d in devclass %s", unit, DEVCLANAME(dc)));
 358
 359         /* If we were given a wired unit number, check for existing device */
 360         /* XXX imp XXX */
 361         if (unit != -1) {
 362                 if (unit >= 0 && unit < dc->maxunit &&
 363                     dc->devices[unit] != NULL) {
 364                         printf("%s: %s%d already exists; skipping it\n",
 365                             dc->name, dc->name, *unitp);
 366                         return (EEXIST);
 367                 }
 368         } else {
 369                 /* Unwired device, find the next available slot for it */
 370                 unit = 0;
 371                 while (unit < dc->maxunit && dc->devices[unit] != NULL)
 372                         unit++;
 373         }
 374
 375         /*
 376          * We've selected a unit beyond the length of the table, so let's
 377          * extend the table to make room for all units up to and including
 378          * this one.
 379          */
 380         if (unit >= dc->maxunit) {
 381                 device_t *newlist;
 382                 int newsize;
 383
 384                 newsize = roundup((unit + 1), MINALLOCSIZE / sizeof(device_t));
 385                 newlist = malloc(sizeof(device_t) * newsize, M_BUS, M_NOWAIT);
 386                 if (!newlist)
 387                         return (ENOMEM);
 388                 bcopy(dc->devices, newlist, sizeof(device_t) * dc->maxunit);
 389                 bzero(newlist + dc->maxunit,
 390                     sizeof(device_t) * (newsize - dc->maxunit));
 391                 if (dc->devices)
 392                         free(dc->devices, M_BUS);
 393                 dc->devices = newlist;
 394                 dc->maxunit = newsize;
 395         }
 396         PDEBUG(("now: unit %d in devclass %s", unit, DEVCLANAME(dc)));
 397
 398         *unitp = unit;
 399         return (0);
 400 }
 401
 402 static int
 403 devclass_add_device(devclass_t dc, device_t dev)
 404 {
 405         int buflen, error;
 406
 407         PDEBUG(("%s in devclass %s", DEVICENAME(dev), DEVCLANAME(dc)));
 408
 409         buflen = strlen(dc->name) + 5;
 410         dev->nameunit = malloc(buflen, M_BUS, M_NOWAIT|M_ZERO);
 411         if (!dev->nameunit)
 412                 return (ENOMEM);
 413
 414         if ((error = devclass_alloc_unit(dc, &dev->unit)) != 0) {
 415                 free(dev->nameunit, M_BUS);
 416                 dev->nameunit = NULL;
 417                 return (error);
 418         }
 419         dc->devices[dev->unit] = dev;
 420         dev->devclass = dc;
 421         snprintf(dev->nameunit, buflen, "%s%d", dc->name, dev->unit);
 422
 423         return (0);
 424 }
 425
 426 static int
 427 devclass_delete_device(devclass_t dc, device_t dev)
 428 {
 429         if (!dc || !dev)
 430                 return (0);
 431
 432         PDEBUG(("%s in devclass %s", DEVICENAME(dev), DEVCLANAME(dc)));
 433
 434         if (dev->devclass != dc || dc->devices[dev->unit] != dev)
 435                 panic("devclass_delete_device: inconsistent device class");
 436         dc->devices[dev->unit] = NULL;
 437         if (dev->flags & DF_WILDCARD)
 438                 dev->unit = -1;
 439         dev->devclass = NULL;
 440         free(dev->nameunit, M_BUS);
 441         dev->nameunit = NULL;
 442
 443         return (0);
 444 }
 445
 446 static device_t
 447 make_device(device_t parent, const char *name, int unit)
 448 {
 449         device_t dev;
 450         devclass_t dc;
 451
 452         PDEBUG(("%s at %s as unit %d", name, DEVICENAME(parent), unit));
 453
 454         if (name) {
 455                 dc = devclass_find_internal(name, TRUE);
 456                 if (!dc) {
 457                         printf("make_device: can't find device class %s\n",
 458                             name);
 459                         return (NULL);
 460                 }
 461         } else {
 462                 dc = NULL;
 463         }
 464
 465         dev = malloc(sizeof(struct device), M_BUS, M_NOWAIT|M_ZERO);
 466         if (!dev)
 467                 return (NULL);
 468
 469         dev->parent = parent;
 470         TAILQ_INIT(&dev->children);
 471         kobj_init((kobj_t) dev, &null_class);
 472         dev->driver = NULL;
 473         dev->devclass = NULL;
 474         dev->unit = unit;
 475         dev->nameunit = NULL;
 476         dev->desc = NULL;
 477         dev->busy = 0;
 478         dev->devflags = 0;
 479         dev->flags = DF_ENABLED;
 480         dev->order = 0;
 481         if (unit == -1)
 482                 dev->flags |= DF_WILDCARD;
 483         if (name) {
 484                 dev->flags |= DF_FIXEDCLASS;
 485                 if (devclass_add_device(dc, dev)) {
 486                         kobj_delete((kobj_t) dev, M_BUS);
 487                         return (NULL);
 488                 }
 489         }
 490         dev->ivars = NULL;
 491         dev->softc = NULL;
 492
 493         dev->state = DS_NOTPRESENT;
 494
 495         TAILQ_INSERT_TAIL(&bus_data_devices, dev, devlink);
 496         bus_data_generation_update();
 497
 498         return (dev);
 499 }
 500
 501 static int
 502 device_print_child(device_t dev, device_t child)
 503 {
 504         int retval = 0;
 505
 506         if (device_is_alive(child))
 507                 retval += BUS_PRINT_CHILD(dev, child);
 508         else
 509                 retval += device_printf(child, " not found\n");
 510
 511         return (retval);
 512 }
 513
 514 device_t
 515 device_add_child(device_t dev, const char *name, int unit)
 516 {
 517         return (device_add_child_ordered(dev, 0, name, unit));
 518 }
 519
 520 device_t
 521 device_add_child_ordered(device_t dev, int order, const char *name, int unit)
 522 {
 523         device_t child;
 524         device_t place;
 525
 526         PDEBUG(("%s at %s with order %d as unit %d",
 527             name, DEVICENAME(dev), order, unit));
 528
 529         child = make_device(dev, name, unit);
 530         if (child == NULL)
 531                 return (child);
 532         child->order = order;
 533
 534         TAILQ_FOREACH(place, &dev->children, link) {
 535                 if (place->order > order)
 536                         break;
 537         }
 538
 539         if (place) {
 540                 /*
 541                  * The device 'place' is the first device whose order is
 542                  * greater than the new child.
 543                  */
 544                 TAILQ_INSERT_BEFORE(place, child, link);
 545         } else {
 546                 /*
 547                  * The new child's order is greater or equal to the order of
 548                  * any existing device. Add the child to the tail of the list.
 549                  */
 550                 TAILQ_INSERT_TAIL(&dev->children, child, link);
 551         }
 552
 553         bus_data_generation_update();
 554         return (child);
 555 }
 556
 557 int
 558 device_delete_child(device_t dev, device_t child)
 559 {
 560         int error;
 561         device_t grandchild;
 562
 563         PDEBUG(("%s from %s", DEVICENAME(child), DEVICENAME(dev)));
 564
 565         /* remove children first */
 566         while ( (grandchild = TAILQ_FIRST(&child->children)) ) {
 567                 error = device_delete_child(child, grandchild);
 568                 if (error)
 569                         return (error);
 570         }
 571
 572         if ((error = device_detach(child)) != 0)
 573                 return (error);
 574         if (child->devclass)
 575                 devclass_delete_device(child->devclass, child);
 576         TAILQ_REMOVE(&dev->children, child, link);
 577         TAILQ_REMOVE(&bus_data_devices, child, devlink);
 578         device_set_desc(child, NULL);
 579         free(child, M_BUS);
 580
 581         bus_data_generation_update();
 582         return (0);
 583 }
 584
 585 /*
 586  * Find only devices attached to this bus.
 587  */
 588 device_t
 589 device_find_child(device_t dev, const char *classname, int unit)
 590 {
 591         devclass_t dc;
 592         device_t child;
 593
 594         dc = devclass_find(classname);
 595         if (!dc)
 596                 return (NULL);
 597
 598         child = devclass_get_device(dc, unit);
 599         if (child && child->parent == dev)
 600                 return (child);
 601         return (NULL);
 602 }
 603
 604 static driverlink_t
 605 first_matching_driver(devclass_t dc, device_t dev)
 606 {
 607         if (dev->devclass)
 608                 return (devclass_find_driver_internal(dc, dev->devclass->name));
 609         return (TAILQ_FIRST(&dc->drivers));
 610 }
 611
 612 static driverlink_t
 613 next_matching_driver(devclass_t dc, device_t dev, driverlink_t last)
 614 {
 615         if (dev->devclass) {
 616                 driverlink_t dl;
 617                 for (dl = TAILQ_NEXT(last, link); dl; dl = TAILQ_NEXT(dl, link))
 618                         if (!strcmp(dev->devclass->name, dl->driver->name))
 619                                 return (dl);
 620                 return (NULL);
 621         }
 622         return (TAILQ_NEXT(last, link));
 623 }
 624
 625 static int
 626 device_probe_child(device_t dev, device_t child)
 627 {
 628         devclass_t dc;
 629         driverlink_t best = 0;
 630         driverlink_t dl;
 631         int result, pri = 0;
 632         int hasclass = (child->devclass != 0);
 633
 634         dc = dev->devclass;
 635         if (!dc)
 636                 panic("device_probe_child: parent device has no devclass");
 637
 638         if (child->state == DS_ALIVE)
 639                 return (0);
 640
 641         for (dl = first_matching_driver(dc, child);
 642              dl;
 643              dl = next_matching_driver(dc, child, dl)) {
 644                 PDEBUG(("Trying %s", DRIVERNAME(dl->driver)));
 645                 device_set_driver(child, dl->driver);
 646                 if (!hasclass)
 647                         device_set_devclass(child, dl->driver->name);
 648                 result = DEVICE_PROBE(child);
 649                 if (!hasclass)
 650                         device_set_devclass(child, 0);
 651
 652                 /*
 653                  * If the driver returns SUCCESS, there can be no higher match
 654                  * for this device.
 655                  */
 656                 if (result == 0) {
 657                         best = dl;
 658                         pri = 0;
 659                         break;
 660                 }
 661
 662                 /*
 663                  * The driver returned an error so it certainly doesn't match.
 664                  */
 665                 if (result > 0) {
 666                         device_set_driver(child, 0);
 667                         continue;
 668                 }
 669
 670                 /*
 671                  * A priority lower than SUCCESS, remember the best matching
 672                  * driver. Initialise the value of pri for the first match.
 673                  */
 674                 if (best == 0 || result > pri) {
 675                         best = dl;
 676                         pri = result;
 677                         continue;
 678                 }
 679         }
 680
 681         /*
 682          * If we found a driver, change state and initialise the devclass.
 683          */
 684         if (best) {
 685                 if (!child->devclass)
 686                         device_set_devclass(child, best->driver->name);
 687                 device_set_driver(child, best->driver);
 688                 if (pri < 0) {
 689                         /*
 690                          * A bit bogus. Call the probe method again to make
 691                          * sure that we have the right description.
 692                          */
 693                         DEVICE_PROBE(child);
 694                 }
 695                 child->state = DS_ALIVE;
 696
 697                 bus_data_generation_update();
 698                 return (0);
 699         }
 700
 701         return (ENXIO);
 702 }
 703
 704 device_t
 705 device_get_parent(device_t dev)
 706 {
 707         return (dev->parent);
 708 }
 709
 710 int
 711 device_get_children(device_t dev, device_t **devlistp, int *devcountp)
 712 {
 713         int count;
 714         device_t child;
 715         device_t *list;
 716
 717         count = 0;
 718         TAILQ_FOREACH(child, &dev->children, link) {
 719                 count++;
 720         }
 721
 722         list = malloc(count * sizeof(device_t), M_TEMP, M_NOWAIT|M_ZERO);
 723         if (!list)
 724                 return (ENOMEM);
 725
 726         count = 0;
 727         TAILQ_FOREACH(child, &dev->children, link) {
 728                 list[count] = child;
 729                 count++;
 730         }
 731
 732         *devlistp = list;
 733         *devcountp = count;
 734
 735         return (0);
 736 }
 737
 738 driver_t *
 739 device_get_driver(device_t dev)
 740 {
 741         return (dev->driver);
 742 }
 743
 744 devclass_t
 745 device_get_devclass(device_t dev)
 746 {
 747         return (dev->devclass);
 748 }
 749
 750 const char *
 751 device_get_name(device_t dev)
 752 {
 753         if (dev->devclass)
 754                 return (devclass_get_name(dev->devclass));
 755         return (NULL);
 756 }
 757
 758 const char *
 759 device_get_nameunit(device_t dev)
 760 {
 761         return (dev->nameunit);
 762 }
 763
 764 int
 765 device_get_unit(device_t dev)
 766 {
 767         return (dev->unit);
 768 }
 769
 770 const char *
 771 device_get_desc(device_t dev)
 772 {
 773         return (dev->desc);
 774 }
 775
 776 u_int32_t
 777 device_get_flags(device_t dev)
 778 {
 779         return (dev->devflags);
 780 }
 781
 782 int
 783 device_print_prettyname(device_t dev)
 784 {
 785         const char *name = device_get_name(dev);
 786
 787         if (name == 0)
 788                 return (printf("unknown: "));
 789         return (printf("%s%d: ", name, device_get_unit(dev)));
 790 }
 791
 792 int
 793 device_printf(device_t dev, const char * fmt, ...)
 794 {
 795         va_list ap;
 796         int retval;
 797
 798         retval = device_print_prettyname(dev);
 799         va_start(ap, fmt);
 800         retval += vprintf(fmt, ap);
 801         va_end(ap);
 802         return (retval);
 803 }
 804
 805 static void
 806 device_set_desc_internal(device_t dev, const char* desc, int copy)
 807 {
 808         if (dev->desc && (dev->flags & DF_DESCMALLOCED)) {
 809                 free(dev->desc, M_BUS);
 810                 dev->flags &= ~DF_DESCMALLOCED;
 811                 dev->desc = NULL;
 812         }
 813
 814         if (copy && desc) {
 815                 dev->desc = malloc(strlen(desc) + 1, M_BUS, M_NOWAIT);
 816                 if (dev->desc) {
 817                         strcpy(dev->desc, desc);
 818                         dev->flags |= DF_DESCMALLOCED;
 819                 }
 820         } else {
 821                 /* Avoid a -Wcast-qual warning */
 822                 dev->desc = (char *)(uintptr_t) desc;
 823         }
 824
 825         bus_data_generation_update();
 826 }
 827
 828 void
 829 device_set_desc(device_t dev, const char* desc)
 830 {
 831         device_set_desc_internal(dev, desc, FALSE);
 832 }
 833
 834 void
 835 device_set_desc_copy(device_t dev, const char* desc)
 836 {
 837         device_set_desc_internal(dev, desc, TRUE);
 838 }
 839
 840 void
 841 device_set_flags(device_t dev, u_int32_t flags)
 842 {
 843         dev->devflags = flags;
 844 }
 845
 846 void *
 847 device_get_softc(device_t dev)
 848 {
 849         return (dev->softc);
 850 }
 851
 852 void
 853 device_set_softc(device_t dev, void *softc)
 854 {
 855         if (dev->softc && !(dev->flags & DF_EXTERNALSOFTC))
 856                 free(dev->softc, M_BUS);
 857         dev->softc = softc;
 858         if (dev->softc)
 859                 dev->flags |= DF_EXTERNALSOFTC;
 860         else
 861                 dev->flags &= ~DF_EXTERNALSOFTC;
 862 }
 863
 864 void *
 865 device_get_ivars(device_t dev)
 866 {
 867         return (dev->ivars);
 868 }
 869
 870 void
 871 device_set_ivars(device_t dev, void * ivars)
 872 {
 873         if (!dev)
 874                 return;
 875
 876         dev->ivars = ivars;
 877
 878         return;
 879 }
 880
 881 device_state_t
 882 device_get_state(device_t dev)
 883 {
 884         return (dev->state);
 885 }
 886
 887 void
 888 device_enable(device_t dev)
 889 {
 890         dev->flags |= DF_ENABLED;
 891 }
 892
 893 void
 894 device_disable(device_t dev)
 895 {
 896         dev->flags &= ~DF_ENABLED;
 897 }
 898
 899 void
 900 device_busy(device_t dev)
 901 {
 902         if (dev->state < DS_ATTACHED)
 903                 panic("device_busy: called for unattached device");
 904         if (dev->busy == 0 && dev->parent)
 905                 device_busy(dev->parent);
 906         dev->busy++;
 907         dev->state = DS_BUSY;
 908 }
 909
 910 void
 911 device_unbusy(device_t dev)
 912 {
 913         if (dev->state != DS_BUSY)
 914                 panic("device_unbusy: called for non-busy device");
 915         dev->busy--;
 916         if (dev->busy == 0) {
 917                 if (dev->parent)
 918                         device_unbusy(dev->parent);
 919                 dev->state = DS_ATTACHED;
 920         }
 921 }
 922
 923 void
 924 device_quiet(device_t dev)
 925 {
 926         dev->flags |= DF_QUIET;
 927 }
 928
 929 void
 930 device_verbose(device_t dev)
 931 {
 932         dev->flags &= ~DF_QUIET;
 933 }
 934
 935 int
 936 device_is_quiet(device_t dev)
 937 {
 938         return ((dev->flags & DF_QUIET) != 0);
 939 }
 940
 941 int
 942 device_is_enabled(device_t dev)
 943 {
 944         return ((dev->flags & DF_ENABLED) != 0);
 945 }
 946
 947 int
 948 device_is_alive(device_t dev)
 949 {
 950         return (dev->state >= DS_ALIVE);
 951 }
 952
 953 int
 954 device_set_devclass(device_t dev, const char *classname)
 955 {
 956         devclass_t dc;
 957         int error;
 958
 959         if (!classname) {
 960                 if (dev->devclass)
 961                         devclass_delete_device(dev->devclass, dev);
 962                 return (0);
 963         }
 964
 965         if (dev->devclass) {
 966                 printf("device_set_devclass: device class already set\n");
 967                 return (EINVAL);
 968         }
 969
 970         dc = devclass_find_internal(classname, TRUE);
 971         if (!dc)
 972                 return (ENOMEM);
 973
 974         error = devclass_add_device(dc, dev);
 975
 976         bus_data_generation_update();
 977         return (error);
 978 }
 979
 980 int
 981 device_set_driver(device_t dev, driver_t *driver)
 982 {
 983         if (dev->state >= DS_ATTACHED)
 984                 return (EBUSY);
 985
 986         if (dev->driver == driver)
 987                 return (0);
 988
 989         if (dev->softc && !(dev->flags & DF_EXTERNALSOFTC)) {
 990                 free(dev->softc, M_BUS);
 991                 dev->softc = NULL;
 992         }
 993         kobj_delete((kobj_t) dev, 0);
 994         dev->driver = driver;
 995         if (driver) {
 996                 kobj_init((kobj_t) dev, (kobj_class_t) driver);
 997                 if (!(dev->flags & DF_EXTERNALSOFTC)) {
 998                         dev->softc = malloc(driver->size, M_BUS,
 999                             M_NOWAIT | M_ZERO);
1000                         if (!dev->softc) {
1001                                 kobj_init((kobj_t) dev, &null_class);
1002                                 dev->driver = NULL;
1003                                 return (ENOMEM);
1004                         }
1005                 }
1006         } else {
1007                 kobj_init((kobj_t) dev, &null_class);
1008         }
1009
1010         bus_data_generation_update();
1011         return (0);
1012 }
1013
1014 int
1015 device_probe_and_attach(device_t dev)
1016 {
1017         device_t bus = dev->parent;
1018         int error = 0;
1019         int hasclass = (dev->devclass != 0);
1020
1021         if (dev->state >= DS_ALIVE)
1022                 return (0);
1023
1024         if (dev->flags & DF_ENABLED) {
1025                 error = device_probe_child(bus, dev);
1026                 if (!error) {
1027                         if (!device_is_quiet(dev))
1028                                 device_print_child(bus, dev);
1029                         error = DEVICE_ATTACH(dev);
1030                         if (!error)
1031                                 dev->state = DS_ATTACHED;
1032                         else {
1033                                 printf("device_probe_and_attach: %s%d attach returned %d\n",
1034                                     dev->driver->name, dev->unit, error);
1035                                 /* Unset the class; set in device_probe_child */
1036                                 if (!hasclass)
1037                                         device_set_devclass(dev, 0);
1038                                 device_set_driver(dev, NULL);
1039                                 dev->state = DS_NOTPRESENT;
1040                         }
1041                 } else {
1042                         if (!(dev->flags & DF_DONENOMATCH)) {
1043                                 BUS_PROBE_NOMATCH(bus, dev);
1044                                 dev->flags |= DF_DONENOMATCH;
1045                         }
1046                 }
1047         } else {
1048                 if (bootverbose) {
1049                         device_print_prettyname(dev);
1050                         printf("not probed (disabled)\n");
1051                 }
1052         }
1053
1054         return (error);
1055 }
1056
1057 int
1058 device_detach(device_t dev)
1059 {
1060         int error;
1061
1062         PDEBUG(("%s", DEVICENAME(dev)));
1063         if (dev->state == DS_BUSY)
1064                 return (EBUSY);
1065         if (dev->state != DS_ATTACHED)
1066                 return (0);
1067
1068         if ((error = DEVICE_DETACH(dev)) != 0)
1069                 return (error);
1070         device_printf(dev, "detached\n");
1071         if (dev->parent)
1072                 BUS_CHILD_DETACHED(dev->parent, dev);
1073
1074         if (!(dev->flags & DF_FIXEDCLASS))
1075                 devclass_delete_device(dev->devclass, dev);
1076
1077         dev->state = DS_NOTPRESENT;
1078         device_set_driver(dev, NULL);
1079
1080         return (0);
1081 }
1082
1083 int
1084 device_shutdown(device_t dev)
1085 {
1086         if (dev->state < DS_ATTACHED)
1087                 return (0);
1088         return (DEVICE_SHUTDOWN(dev));
1089 }
1090
1091 int
1092 device_set_unit(device_t dev, int unit)
1093 {
1094         devclass_t dc;
1095         int err;
1096
1097         dc = device_get_devclass(dev);
1098         if (unit < dc->maxunit && dc->devices[unit])
1099                 return (EBUSY);
1100         err = devclass_delete_device(dc, dev);
1101         if (err)
1102                 return (err);
1103         dev->unit = unit;
1104         err = devclass_add_device(dc, dev);
1105         if (err)
1106                 return (err);
1107
1108         bus_data_generation_update();
1109         return (0);
1110 }
1111
1112 /*======================================*/
1113 /*
1114  * Some useful method implementations to make life easier for bus drivers.
1115  */
1116
1117 void
1118 resource_list_init(struct resource_list *rl)
1119 {
1120         SLIST_INIT(rl);
1121 }
1122
1123 void
1124 resource_list_free(struct resource_list *rl)
1125 {
1126         struct resource_list_entry *rle;
1127
1128         while ((rle = SLIST_FIRST(rl)) != NULL) {
1129                 if (rle->res)
1130                         panic("resource_list_free: resource entry is busy");
1131                 SLIST_REMOVE_HEAD(rl, link);
1132                 free(rle, M_BUS);
1133         }
1134 }
1135
1136 void
1137 resource_list_add(struct resource_list *rl, int type, int rid,
1138     u_long start, u_long end, u_long count)
1139 {
1140         struct resource_list_entry *rle;
1141
1142         rle = resource_list_find(rl, type, rid);
1143         if (!rle) {
1144                 rle = malloc(sizeof(struct resource_list_entry), M_BUS,
1145                     M_NOWAIT);
1146                 if (!rle)
1147                         panic("resource_list_add: can't record entry");
1148                 SLIST_INSERT_HEAD(rl, rle, link);
1149                 rle->type = type;
1150                 rle->rid = rid;
1151                 rle->res = NULL;
1152         }
1153
1154         if (rle->res)
1155                 panic("resource_list_add: resource entry is busy");
1156
1157         rle->start = start;
1158         rle->end = end;
1159         rle->count = count;
1160 }
1161
1162 struct resource_list_entry *
1163 resource_list_find(struct resource_list *rl, int type, int rid)
1164 {
1165         struct resource_list_entry *rle;
1166
1167         SLIST_FOREACH(rle, rl, link) {
1168                 if (rle->type == type && rle->rid == rid)
1169                         return (rle);
1170         }
1171         return (NULL);
1172 }
1173
1174 void
1175 resource_list_delete(struct resource_list *rl, int type, int rid)
1176 {
1177         struct resource_list_entry *rle = resource_list_find(rl, type, rid);
1178
1179         if (rle) {
1180                 if (rle->res != NULL)
1181                         panic("resource_list_delete: resource has not been released");
1182                 SLIST_REMOVE(rl, rle, resource_list_entry, link);
1183                 free(rle, M_BUS);
1184         }
1185 }
1186
1187 struct resource *
1188 resource_list_alloc(struct resource_list *rl, device_t bus, device_t child,
1189     int type, int *rid, u_long start, u_long end, u_long count, u_int flags)
1190 {
1191         struct resource_list_entry *rle = 0;
1192         int passthrough = (device_get_parent(child) != bus);
1193         int isdefault = (start == 0UL && end == ~0UL);
1194
1195         if (passthrough) {
1196                 return (BUS_ALLOC_RESOURCE(device_get_parent(bus), child,
1197                     type, rid, start, end, count, flags));
1198         }
1199
1200         rle = resource_list_find(rl, type, *rid);
1201
1202         if (!rle)
1203                 return (NULL);          /* no resource of that type/rid */
1204
1205         if (rle->res)
1206                 panic("resource_list_alloc: resource entry is busy");
1207
1208         if (isdefault) {
1209                 start = rle->start;
1210                 count = ulmax(count, rle->count);
1211                 end = ulmax(rle->end, start + count - 1);
1212         }
1213
1214         rle->res = BUS_ALLOC_RESOURCE(device_get_parent(bus), child,
1215             type, rid, start, end, count, flags);
1216
1217         /*
1218          * Record the new range.
1219          */
1220         if (rle->res) {
1221                 rle->start = rman_get_start(rle->res);
1222                 rle->end = rman_get_end(rle->res);
1223                 rle->count = count;
1224         }
1225
1226         return (rle->res);
1227 }
1228
1229 int
1230 resource_list_release(struct resource_list *rl, device_t bus, device_t child,
1231     int type, int rid, struct resource *res)
1232 {
1233         struct resource_list_entry *rle = 0;
1234         int passthrough = (device_get_parent(child) != bus);
1235         int error;
1236
1237         if (passthrough) {
1238                 return (BUS_RELEASE_RESOURCE(device_get_parent(bus), child,
1239                     type, rid, res));
1240         }
1241
1242         rle = resource_list_find(rl, type, rid);
1243
1244         if (!rle)
1245                 panic("resource_list_release: can't find resource");
1246         if (!rle->res)
1247                 panic("resource_list_release: resource entry is not busy");
1248
1249         error = BUS_RELEASE_RESOURCE(device_get_parent(bus), child,
1250             type, rid, res);
1251         if (error)
1252                 return (error);
1253
1254         rle->res = NULL;
1255         return (0);
1256 }
1257
1258 int
1259 resource_list_print_type(struct resource_list *rl, const char *name, int type,
1260     const char *format)
1261 {
1262         struct resource_list_entry *rle;
1263         int printed, retval;
1264
1265         printed = 0;
1266         retval = 0;
1267         /* Yes, this is kinda cheating */
1268         SLIST_FOREACH(rle, rl, link) {
1269                 if (rle->type == type) {
1270                         if (printed == 0)
1271                                 retval += printf(" %s ", name);
1272                         else
1273                                 retval += printf(",");
1274                         printed++;
1275                         retval += printf(format, rle->start);
1276                         if (rle->count > 1) {
1277                                 retval += printf("-");
1278                                 retval += printf(format, rle->start +
1279                                                  rle->count - 1);
1280                         }
1281                 }
1282         }
1283         return (retval);
1284 }
1285
1286 /*
1287  * Call DEVICE_IDENTIFY for each driver.
1288  */
1289 int
1290 bus_generic_probe(device_t dev)
1291 {
1292         devclass_t dc = dev->devclass;
1293         driverlink_t dl;
1294
1295         TAILQ_FOREACH(dl, &dc->drivers, link) {
1296                 DEVICE_IDENTIFY(dl->driver, dev);
1297         }
1298
1299         return (0);
1300 }
1301
1302 int
1303 bus_generic_attach(device_t dev)
1304 {
1305         device_t child;
1306
1307         TAILQ_FOREACH(child, &dev->children, link) {
1308                 device_probe_and_attach(child);
1309         }
1310
1311         return (0);
1312 }
1313
1314 int
1315 bus_generic_detach(device_t dev)
1316 {
1317         device_t child;
1318         int error;
1319
1320         if (dev->state != DS_ATTACHED)
1321                 return (EBUSY);
1322
1323         TAILQ_FOREACH(child, &dev->children, link) {
1324                 if ((error = device_detach(child)) != 0)
1325                         return (error);
1326         }
1327
1328         return (0);
1329 }
1330
1331 int
1332 bus_generic_shutdown(device_t dev)
1333 {
1334         device_t child;
1335
1336         TAILQ_FOREACH(child, &dev->children, link) {
1337                 device_shutdown(child);
1338         }
1339
1340         return (0);
1341 }
1342
1343 int
1344 bus_generic_suspend(device_t dev)
1345 {
1346         int             error;
1347         device_t        child, child2;
1348
1349         TAILQ_FOREACH(child, &dev->children, link) {
1350                 error = DEVICE_SUSPEND(child);
1351                 if (error) {
1352                         for (child2 = TAILQ_FIRST(&dev->children);
1353                              child2 && child2 != child;
1354                              child2 = TAILQ_NEXT(child2, link))
1355                                 DEVICE_RESUME(child2);
1356                         return (error);
1357                 }
1358         }
1359         return (0);
1360 }
1361
1362 int
1363 bus_generic_resume(device_t dev)
1364 {
1365         device_t        child;
1366
1367         TAILQ_FOREACH(child, &dev->children, link) {
1368                 DEVICE_RESUME(child);
1369                 /* if resume fails, there's nothing we can usefully do... */
1370         }
1371         return (0);
1372 }
1373
1374 int
1375 bus_print_child_header (device_t dev, device_t child)
1376 {
1377         int     retval = 0;
1378
1379         if (device_get_desc(child)) {
1380                 retval += device_printf(child, "<%s>", device_get_desc(child));
1381         } else {
1382                 retval += printf("%s", device_get_nameunit(child));
1383         }
1384
1385         return (retval);
1386 }
1387
1388 int
1389 bus_print_child_footer (device_t dev, device_t child)
1390 {
1391         return (printf(" on %s\n", device_get_nameunit(dev)));
1392 }
1393
1394 int
1395 bus_generic_print_child(device_t dev, device_t child)
1396 {
1397         int     retval = 0;
1398
1399         retval += bus_print_child_header(dev, child);
1400         retval += bus_print_child_footer(dev, child);
1401
1402         return (retval);
1403 }
1404
1405 int
1406 bus_generic_read_ivar(device_t dev, device_t child, int index,
1407     uintptr_t * result)
1408 {
1409         return (ENOENT);
1410 }
1411
1412 int
1413 bus_generic_write_ivar(device_t dev, device_t child, int index,
1414     uintptr_t value)
1415 {
1416         return (ENOENT);
1417 }
1418
1419 struct resource_list *
1420 bus_generic_get_resource_list (device_t dev, device_t child)
1421 {
1422         return (NULL);
1423 }
1424
1425 void
1426 bus_generic_driver_added(device_t dev, driver_t *driver)
1427 {
1428         device_t child;
1429
1430         DEVICE_IDENTIFY(driver, dev);
1431         TAILQ_FOREACH(child, &dev->children, link) {
1432                 if (child->state == DS_NOTPRESENT)
1433                         device_probe_and_attach(child);
1434         }
1435 }
1436
1437 int
1438 bus_generic_setup_intr(device_t dev, device_t child, struct resource *irq,
1439     int flags, driver_intr_t *intr, void *arg, void **cookiep)
1440 {
1441         /* Propagate up the bus hierarchy until someone handles it. */
1442         if (dev->parent)
1443                 return (BUS_SETUP_INTR(dev->parent, child, irq, flags,
1444                     intr, arg, cookiep));
1445         return (EINVAL);
1446 }
1447
1448 int
1449 bus_generic_teardown_intr(device_t dev, device_t child, struct resource *irq,
1450     void *cookie)
1451 {
1452         /* Propagate up the bus hierarchy until someone handles it. */
1453         if (dev->parent)
1454                 return (BUS_TEARDOWN_INTR(dev->parent, child, irq, cookie));
1455         return (EINVAL);
1456 }
1457
1458 struct resource *
1459 bus_generic_alloc_resource(device_t dev, device_t child, int type, int *rid,
1460     u_long start, u_long end, u_long count, u_int flags)
1461 {
1462         /* Propagate up the bus hierarchy until someone handles it. */
1463         if (dev->parent)
1464                 return (BUS_ALLOC_RESOURCE(dev->parent, child, type, rid,
1465                     start, end, count, flags));
1466         return (NULL);
1467 }
1468
1469 int
1470 bus_generic_release_resource(device_t dev, device_t child, int type, int rid,
1471     struct resource *r)
1472 {
1473         /* Propagate up the bus hierarchy until someone handles it. */
1474         if (dev->parent)
1475                 return (BUS_RELEASE_RESOURCE(dev->parent, child, type, rid,
1476                     r));
1477         return (EINVAL);
1478 }
1479
1480 int
1481 bus_generic_activate_resource(device_t dev, device_t child, int type, int rid,
1482     struct resource *r)
1483 {
1484         /* Propagate up the bus hierarchy until someone handles it. */
1485         if (dev->parent)
1486                 return (BUS_ACTIVATE_RESOURCE(dev->parent, child, type, rid,
1487                     r));
1488         return (EINVAL);
1489 }
1490
1491 int
1492 bus_generic_deactivate_resource(device_t dev, device_t child, int type,
1493     int rid, struct resource *r)
1494 {
1495         /* Propagate up the bus hierarchy until someone handles it. */
1496         if (dev->parent)
1497                 return (BUS_DEACTIVATE_RESOURCE(dev->parent, child, type, rid,
1498                     r));
1499         return (EINVAL);
1500 }
1501
1502 int
1503 bus_generic_rl_get_resource (device_t dev, device_t child, int type, int rid,
1504     u_long *startp, u_long *countp)
1505 {
1506         struct resource_list *          rl = NULL;
1507         struct resource_list_entry *    rle = NULL;
1508
1509         rl = BUS_GET_RESOURCE_LIST(dev, child);
1510         if (!rl)
1511                 return (EINVAL);
1512
1513         rle = resource_list_find(rl, type, rid);
1514         if (!rle)
1515                 return (ENOENT);
1516
1517         if (startp)
1518                 *startp = rle->start;
1519         if (countp)
1520                 *countp = rle->count;
1521
1522         return (0);
1523 }
1524
1525 int
1526 bus_generic_rl_set_resource (device_t dev, device_t child, int type, int rid,
1527     u_long start, u_long count)
1528 {
1529         struct resource_list *          rl = NULL;
1530
1531         rl = BUS_GET_RESOURCE_LIST(dev, child);
1532         if (!rl)
1533                 return (EINVAL);
1534
1535         resource_list_add(rl, type, rid, start, (start + count - 1), count);
1536
1537         return (0);
1538 }
1539
1540 void
1541 bus_generic_rl_delete_resource (device_t dev, device_t child, int type, int rid)
1542 {
1543         struct resource_list *          rl = NULL;
1544
1545         rl = BUS_GET_RESOURCE_LIST(dev, child);
1546         if (!rl)
1547                 return;
1548
1549         resource_list_delete(rl, type, rid);
1550
1551         return;
1552 }
1553
1554 int
1555 bus_generic_rl_release_resource (device_t dev, device_t child, int type,
1556     int rid, struct resource *r)
1557 {
1558         struct resource_list *          rl = NULL;
1559
1560         rl = BUS_GET_RESOURCE_LIST(dev, child);
1561         if (!rl)
1562                 return (EINVAL);
1563
1564         return (resource_list_release(rl, dev, child, type, rid, r));
1565 }
1566
1567 struct resource *
1568 bus_generic_rl_alloc_resource (device_t dev, device_t child, int type,
1569     int *rid, u_long start, u_long end, u_long count, u_int flags)
1570 {
1571         struct resource_list *          rl = NULL;
1572
1573         rl = BUS_GET_RESOURCE_LIST(dev, child);
1574         if (!rl)
1575                 return (NULL);
1576
1577         return (resource_list_alloc(rl, dev, child, type, rid,
1578             start, end, count, flags));
1579 }
1580
1581 /*
1582  * Some convenience functions to make it easier for drivers to use the
1583  * resource-management functions.  All these really do is hide the
1584  * indirection through the parent's method table, making for slightly
1585  * less-wordy code.  In the future, it might make sense for this code
1586  * to maintain some sort of a list of resources allocated by each device.
1587  */
1588 struct resource *
1589 bus_alloc_resource(device_t dev, int type, int *rid, u_long start, u_long end,
1590     u_long count, u_int flags)
1591 {
1592         if (dev->parent == 0)
1593                 return (0);
1594         return (BUS_ALLOC_RESOURCE(dev->parent, dev, type, rid, start, end,
1595             count, flags));
1596 }
1597
1598 int
1599 bus_activate_resource(device_t dev, int type, int rid, struct resource *r)
1600 {
1601         if (dev->parent == 0)
1602                 return (EINVAL);
1603         return (BUS_ACTIVATE_RESOURCE(dev->parent, dev, type, rid, r));
1604 }
1605
1606 int
1607 bus_deactivate_resource(device_t dev, int type, int rid, struct resource *r)
1608 {
1609         if (dev->parent == 0)
1610                 return (EINVAL);
1611         return (BUS_DEACTIVATE_RESOURCE(dev->parent, dev, type, rid, r));
1612 }
1613
1614 int
1615 bus_release_resource(device_t dev, int type, int rid, struct resource *r)
1616 {
1617         if (dev->parent == 0)
1618                 return (EINVAL);
1619         return (BUS_RELEASE_RESOURCE(dev->parent, dev, type, rid, r));
1620 }
1621
1622 int
1623 bus_setup_intr(device_t dev, struct resource *r, int flags,
1624     driver_intr_t handler, void *arg, void **cookiep)
1625 {
1626         if (dev->parent == 0)
1627                 return (EINVAL);
1628         return (BUS_SETUP_INTR(dev->parent, dev, r, flags,
1629             handler, arg, cookiep));
1630 }
1631
1632 int
1633 bus_teardown_intr(device_t dev, struct resource *r, void *cookie)
1634 {
1635         if (dev->parent == 0)
1636                 return (EINVAL);
1637         return (BUS_TEARDOWN_INTR(dev->parent, dev, r, cookie));
1638 }
1639
1640 int
1641 bus_set_resource(device_t dev, int type, int rid,
1642     u_long start, u_long count)
1643 {
1644         return (BUS_SET_RESOURCE(device_get_parent(dev), dev, type, rid,
1645             start, count));
1646 }
1647
1648 int
1649 bus_get_resource(device_t dev, int type, int rid,
1650     u_long *startp, u_long *countp)
1651 {
1652         return (BUS_GET_RESOURCE(device_get_parent(dev), dev, type, rid,
1653             startp, countp));
1654 }
1655
1656 u_long
1657 bus_get_resource_start(device_t dev, int type, int rid)
1658 {
1659         u_long start, count;
1660         int error;
1661
1662         error = BUS_GET_RESOURCE(device_get_parent(dev), dev, type, rid,
1663             &start, &count);
1664         if (error)
1665                 return (0);
1666         return (start);
1667 }
1668
1669 u_long
1670 bus_get_resource_count(device_t dev, int type, int rid)
1671 {
1672         u_long start, count;
1673         int error;
1674
1675         error = BUS_GET_RESOURCE(device_get_parent(dev), dev, type, rid,
1676             &start, &count);
1677         if (error)
1678                 return (0);
1679         return (count);
1680 }
1681
1682 void
1683 bus_delete_resource(device_t dev, int type, int rid)
1684 {
1685         BUS_DELETE_RESOURCE(device_get_parent(dev), dev, type, rid);
1686 }
1687
1688 static int
1689 root_print_child(device_t dev, device_t child)
1690 {
1691         int     retval = 0;
1692
1693         retval += bus_print_child_header(dev, child);
1694         retval += printf("\n");
1695
1696         return (retval);
1697 }
1698
1699 static int
1700 root_setup_intr(device_t dev, device_t child, driver_intr_t *intr, void *arg,
1701     void **cookiep)
1702 {
1703         /*
1704          * If an interrupt mapping gets to here something bad has happened.
1705          */
1706         panic("root_setup_intr");
1707 }
1708
1709 static kobj_method_t root_methods[] = {
1710         /* Device interface */
1711         KOBJMETHOD(device_shutdown,     bus_generic_shutdown),
1712         KOBJMETHOD(device_suspend,      bus_generic_suspend),
1713         KOBJMETHOD(device_resume,       bus_generic_resume),
1714
1715         /* Bus interface */
1716         KOBJMETHOD(bus_print_child,     root_print_child),
1717         KOBJMETHOD(bus_read_ivar,       bus_generic_read_ivar),
1718         KOBJMETHOD(bus_write_ivar,      bus_generic_write_ivar),
1719         KOBJMETHOD(bus_setup_intr,      root_setup_intr),
1720
1721         { 0, 0 }
1722 };
1723
1724 static driver_t root_driver = {
1725         "root",
1726         root_methods,
1727         1,                      /* no softc */
1728 };
1729
1730 device_t        root_bus;
1731 devclass_t      root_devclass;
1732
1733 static int
1734 root_bus_module_handler(module_t mod, int what, void* arg)
1735 {
1736         switch (what) {
1737         case MOD_LOAD:
1738                 TAILQ_INIT(&bus_data_devices);
1739                 kobj_class_compile((kobj_class_t) &root_driver);
1740                 root_bus = make_device(NULL, "root", 0);
1741                 root_bus->desc = "System root bus";
1742                 kobj_init((kobj_t) root_bus, (kobj_class_t) &root_driver);
1743                 root_bus->driver = &root_driver;
1744                 root_bus->state = DS_ATTACHED;
1745                 root_devclass = devclass_find_internal("root", FALSE);
1746                 return (0);
1747
1748         case MOD_SHUTDOWN:
1749                 device_shutdown(root_bus);
1750                 return (0);
1751         }
1752
1753         return (0);
1754 }
1755
1756 static moduledata_t root_bus_mod = {
1757         "rootbus",
1758         root_bus_module_handler,
1759         0
1760 };
1761 DECLARE_MODULE(rootbus, root_bus_mod, SI_SUB_DRIVERS, SI_ORDER_FIRST);
1762
1763 void
1764 root_bus_configure(void)
1765 {
1766         device_t dev;
1767
1768         PDEBUG(("."));
1769
1770         TAILQ_FOREACH(dev, &root_bus->children, link) {
1771                 device_probe_and_attach(dev);
1772         }
1773 }
1774
1775 int
1776 driver_module_handler(module_t mod, int what, void *arg)
1777 {
1778         int error, i;
1779         struct driver_module_data *dmd;
1780         devclass_t bus_devclass;
1781
1782         dmd = (struct driver_module_data *)arg;
1783         bus_devclass = devclass_find_internal(dmd->dmd_busname, TRUE);
1784         error = 0;
1785
1786         switch (what) {
1787         case MOD_LOAD:
1788                 if (dmd->dmd_chainevh)
1789                         error = dmd->dmd_chainevh(mod,what,dmd->dmd_chainarg);
1790
1791                 for (i = 0; !error && i < dmd->dmd_ndrivers; i++) {
1792                         PDEBUG(("Loading module: driver %s on bus %s",
1793                             DRIVERNAME(dmd->dmd_drivers[i]), dmd->dmd_busname));
1794                         error = devclass_add_driver(bus_devclass,
1795                             dmd->dmd_drivers[i]);
1796                 }
1797                 if (error)
1798                         break;
1799
1800                 /*
1801                  * The drivers loaded in this way are assumed to all
1802                  * implement the same devclass.
1803                  */
1804                 *dmd->dmd_devclass =
1805                     devclass_find_internal(dmd->dmd_drivers[0]->name, TRUE);
1806                 break;
1807
1808         case MOD_UNLOAD:
1809                 for (i = 0; !error && i < dmd->dmd_ndrivers; i++) {
1810                         PDEBUG(("Unloading module: driver %s from bus %s",
1811                             DRIVERNAME(dmd->dmd_drivers[i]),
1812                             dmd->dmd_busname));
1813                         error = devclass_delete_driver(bus_devclass,
1814                             dmd->dmd_drivers[i]);
1815                 }
1816
1817                 if (!error && dmd->dmd_chainevh)
1818                         error = dmd->dmd_chainevh(mod,what,dmd->dmd_chainarg);
1819                 break;
1820         }
1821
1822         return (error);
1823 }
1824
1825 #ifdef BUS_DEBUG
1826
1827 /* the _short versions avoid iteration by not calling anything that prints
1828  * more than oneliners. I love oneliners.
1829  */
1830
1831 static void
1832 print_device_short(device_t dev, int indent)
1833 {
1834         if (!dev)
1835                 return;
1836
1837         indentprintf(("device %d: <%s> %sparent,%schildren,%s%s%s%s,%sivars,%ssoftc,busy=%d\n",
1838             dev->unit, dev->desc,
1839             (dev->parent? "":"no "),
1840             (TAILQ_EMPTY(&dev->children)? "no ":""),
1841             (dev->flags&DF_ENABLED? "enabled,":"disabled,"),
1842             (dev->flags&DF_FIXEDCLASS? "fixed,":""),
1843             (dev->flags&DF_WILDCARD? "wildcard,":""),
1844             (dev->flags&DF_DESCMALLOCED? "descmalloced,":""),
1845             (dev->ivars? "":"no "),
1846             (dev->softc? "":"no "),
1847             dev->busy));
1848 }
1849
1850 static void
1851 print_device(device_t dev, int indent)
1852 {
1853         if (!dev)
1854                 return;
1855
1856         print_device_short(dev, indent);
1857
1858         indentprintf(("Parent:\n"));
1859         print_device_short(dev->parent, indent+1);
1860         indentprintf(("Driver:\n"));
1861         print_driver_short(dev->driver, indent+1);
1862         indentprintf(("Devclass:\n"));
1863         print_devclass_short(dev->devclass, indent+1);
1864 }
1865
1866 void
1867 print_device_tree_short(device_t dev, int indent)
1868 /* print the device and all its children (indented) */
1869 {
1870         device_t child;
1871
1872         if (!dev)
1873                 return;
1874
1875         print_device_short(dev, indent);
1876
1877         TAILQ_FOREACH(child, &dev->children, link) {
1878                 print_device_tree_short(child, indent+1);
1879         }
1880 }
1881
1882 void
1883 print_device_tree(device_t dev, int indent)
1884 /* print the device and all its children (indented) */
1885 {
1886         device_t child;
1887
1888         if (!dev)
1889                 return;
1890
1891         print_device(dev, indent);
1892
1893         TAILQ_FOREACH(child, &dev->children, link) {
1894                 print_device_tree(child, indent+1);
1895         }
1896 }
1897
1898 static void
1899 print_driver_short(driver_t *driver, int indent)
1900 {
1901         if (!driver)
1902                 return;
1903
1904         indentprintf(("driver %s: softc size = %d\n",
1905             driver->name, driver->size));
1906 }
1907
1908 static void
1909 print_driver(driver_t *driver, int indent)
1910 {
1911         if (!driver)
1912                 return;
1913
1914         print_driver_short(driver, indent);
1915 }
1916
1917
1918 static void
1919 print_driver_list(driver_list_t drivers, int indent)
1920 {
1921         driverlink_t driver;
1922
1923         TAILQ_FOREACH(driver, &drivers, link) {
1924                 print_driver(driver->driver, indent);
1925         }
1926 }
1927
1928 static void
1929 print_devclass_short(devclass_t dc, int indent)
1930 {
1931         if ( !dc )
1932                 return;
1933
1934         indentprintf(("devclass %s: max units = %d\n", dc->name, dc->maxunit));
1935 }
1936
1937 static void
1938 print_devclass(devclass_t dc, int indent)
1939 {
1940         int i;
1941
1942         if ( !dc )
1943                 return;
1944
1945         print_devclass_short(dc, indent);
1946         indentprintf(("Drivers:\n"));
1947         print_driver_list(dc->drivers, indent+1);
1948
1949         indentprintf(("Devices:\n"));
1950         for (i = 0; i < dc->maxunit; i++)
1951                 if (dc->devices[i])
1952                         print_device(dc->devices[i], indent+1);
1953 }
1954
1955 void
1956 print_devclass_list_short(void)
1957 {
1958         devclass_t dc;
1959
1960         printf("Short listing of devclasses, drivers & devices:\n");
1961         TAILQ_FOREACH(dc, &devclasses, link) {
1962                 print_devclass_short(dc, 0);
1963         }
1964 }
1965
1966 void
1967 print_devclass_list(void)
1968 {
1969         devclass_t dc;
1970
1971         printf("Full listing of devclasses, drivers & devices:\n");
1972         TAILQ_FOREACH(dc, &devclasses, link) {
1973                 print_devclass(dc, 0);
1974         }
1975 }
1976
1977 #endif
1978
1979 /*
1980  * User-space access to the device tree.
1981  *
1982  * We implement a small set of nodes:
1983  *
1984  * hw.bus                       Single integer read method to obtain the
1985  *                              current generation count.
1986  * hw.bus.devices               Reads the entire device tree in flat space.
1987  * hw.bus.rman                  Resource manager interface
1988  *
1989  * We might like to add the ability to scan devclasses and/or drivers to
1990  * determine what else is currently loaded/available.
1991  */
1992 SYSCTL_NODE(_hw, OID_AUTO, bus, CTLFLAG_RW, NULL, NULL);
1993
1994 static int
1995 sysctl_bus(SYSCTL_HANDLER_ARGS)
1996 {
1997         struct u_businfo        ubus;
1998
1999         ubus.ub_version = BUS_USER_VERSION;
2000         ubus.ub_generation = bus_data_generation;
2001
2002         return (SYSCTL_OUT(req, &ubus, sizeof(ubus)));
2003 }
2004 SYSCTL_NODE(_hw_bus, OID_AUTO, info, CTLFLAG_RW, sysctl_bus,
2005     "bus-related data");
2006
2007 static int
2008 sysctl_devices(SYSCTL_HANDLER_ARGS)
2009 {
2010         int                     *name = (int *)arg1;
2011         u_int                   namelen = arg2;
2012         int                     index;
2013         struct device           *dev;
2014         struct u_device         udev;   /* XXX this is a bit big */
2015         int                     error;
2016
2017         if (namelen != 2)
2018                 return (EINVAL);
2019
2020         if (bus_data_generation_check(name[0]))
2021                 return (EINVAL);
2022
2023         index = name[1];
2024
2025         /*
2026          * Scan the list of devices, looking for the requested index.
2027          */
2028         TAILQ_FOREACH(dev, &bus_data_devices, devlink) {
2029                 if (index-- == 0)
2030                         break;
2031         }
2032         if (dev == NULL)
2033                 return (ENOENT);
2034
2035         /*
2036          * Populate the return array.
2037          */
2038         udev.dv_handle = (uintptr_t)dev;
2039         udev.dv_parent = (uintptr_t)dev->parent;
2040         if (dev->nameunit == NULL) {
2041                 udev.dv_name[0] = 0;
2042         } else {
2043                 snprintf(udev.dv_name, 32, "%s", dev->nameunit);
2044         }
2045         if (dev->desc == NULL) {
2046                 udev.dv_desc[0] = 0;
2047         } else {
2048                 snprintf(udev.dv_desc, 32, "%s", dev->desc);
2049         }
2050         if ((dev->driver == NULL) || (dev->driver->name == NULL)) {
2051                 udev.dv_drivername[0] = 0;
2052         } else {
2053                 snprintf(udev.dv_drivername, 32, "%s", dev->driver->name);
2054         }
2055         error = SYSCTL_OUT(req, &udev, sizeof(udev));
2056         return (error);
2057 }
2058
2059 SYSCTL_NODE(_hw_bus, OID_AUTO, devices, CTLFLAG_RD, sysctl_devices,
2060     "system device tree");
2061
2062 /*
2063  * Sysctl interface for scanning the resource lists.
2064  *
2065  * We take two input parameters; the index into the list of resource
2066  * managers, and the resource offset into the list.
2067  */
2068 static int
2069 sysctl_rman(SYSCTL_HANDLER_ARGS)
2070 {
2071         int                     *name = (int *)arg1;
2072         u_int                   namelen = arg2;
2073         int                     rman_idx, res_idx;
2074         struct rman             *rm;
2075         struct resource         *res;
2076         struct u_rman           urm;
2077         struct u_resource       ures;
2078         int                     error;
2079
2080         if (namelen != 3)
2081                 return (EINVAL);
2082
2083         if (bus_data_generation_check(name[0]))
2084                 return (EINVAL);
2085         rman_idx = name[1];
2086         res_idx = name[2];
2087
2088         /*
2089          * Find the indexed resource manager
2090          */
2091         TAILQ_FOREACH(rm, &rman_head, rm_link) {
2092                 if (rman_idx-- == 0)
2093                         break;
2094         }
2095         if (rm == NULL)
2096                 return (ENOENT);
2097
2098         /*
2099          * If the resource index is -1, we want details on the
2100          * resource manager.
2101          */
2102         if (res_idx == -1) {
2103                 urm.rm_handle = (uintptr_t)rm;
2104                 snprintf(urm.rm_descr, RM_TEXTLEN, "%s", rm->rm_descr);
2105                 urm.rm_descr[RM_TEXTLEN - 1] = '\0';
2106                 urm.rm_start = rm->rm_start;
2107                 urm.rm_size = rm->rm_end - rm->rm_start + 1;
2108                 urm.rm_type = rm->rm_type;
2109
2110                 error = SYSCTL_OUT(req, &urm, sizeof(urm));
2111                 return (error);
2112         }
2113
2114         /*
2115          * Find the indexed resource and return it.
2116          */
2117         TAILQ_FOREACH(res, &rm->rm_list, r_link) {
2118                 if (res_idx-- == 0) {
2119                         ures.r_handle = (uintptr_t)res;
2120                         ures.r_parent = (uintptr_t)res->r_rm;
2121                         ures.r_device = (uintptr_t)res->r_dev;
2122                         if (res->r_dev != NULL) {
2123                                 if (device_get_name(res->r_dev) != NULL) {
2124                                         snprintf(ures.r_devname, RM_TEXTLEN,
2125                                             "%s%d",
2126                                             device_get_name(res->r_dev),
2127                                             device_get_unit(res->r_dev));
2128                                 } else {
2129                                         snprintf(ures.r_devname, RM_TEXTLEN,
2130                                             "nomatch");
2131                                 }
2132                         } else {
2133                                 ures.r_devname[0] = 0;
2134                         }
2135                         ures.r_start = res->r_start;
2136                         ures.r_size = res->r_end - res->r_start + 1;
2137                         ures.r_flags = res->r_flags;
2138
2139                         error = SYSCTL_OUT(req, &ures, sizeof(ures));
2140                         return (error);
2141                 }
2142         }
2143         return (ENOENT);
2144 }
2145
2146 SYSCTL_NODE(_hw_bus, OID_AUTO, rman, CTLFLAG_RD, sysctl_rman,
2147     "kernel resource manager");
2148
2149 int
2150 bus_data_generation_check(int generation)
2151 {
2152         if (generation != bus_data_generation)
2153                 return (1);
2154
2155         /* XXX generate optimised lists here? */
2156         return (0);
2157 }
2158
2159 void
2160 bus_data_generation_update(void)
2161 {
2162         bus_data_generation++;
2163 }