Annotation of sys/kern/subr_autoconf.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: subr_autoconf.c,v 1.52 2007/05/30 05:36:36 deraadt Exp $ */
! 2: /* $NetBSD: subr_autoconf.c,v 1.21 1996/04/04 06:06:18 cgd Exp $ */
! 3:
! 4: /*
! 5: * Copyright (c) 1992, 1993
! 6: * The Regents of the University of California. All rights reserved.
! 7: *
! 8: * This software was developed by the Computer Systems Engineering group
! 9: * at Lawrence Berkeley Laboratory under DARPA contract BG 91-66 and
! 10: * contributed to Berkeley.
! 11: *
! 12: * All advertising materials mentioning features or use of this software
! 13: * must display the following acknowledgement:
! 14: * This product includes software developed by the University of
! 15: * California, Lawrence Berkeley Laboratories.
! 16: *
! 17: * Redistribution and use in source and binary forms, with or without
! 18: * modification, are permitted provided that the following conditions
! 19: * are met:
! 20: * 1. Redistributions of source code must retain the above copyright
! 21: * notice, this list of conditions and the following disclaimer.
! 22: * 2. Redistributions in binary form must reproduce the above copyright
! 23: * notice, this list of conditions and the following disclaimer in the
! 24: * documentation and/or other materials provided with the distribution.
! 25: * 3. Neither the name of the University nor the names of its contributors
! 26: * may be used to endorse or promote products derived from this software
! 27: * without specific prior written permission.
! 28: *
! 29: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
! 30: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
! 31: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
! 32: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
! 33: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
! 34: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
! 35: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
! 36: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
! 37: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
! 38: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
! 39: * SUCH DAMAGE.
! 40: *
! 41: * from: Header: subr_autoconf.c,v 1.12 93/02/01 19:31:48 torek Exp (LBL)
! 42: *
! 43: * @(#)subr_autoconf.c 8.1 (Berkeley) 6/10/93
! 44: */
! 45:
! 46: #include <sys/param.h>
! 47: #include <sys/device.h>
! 48: #include <sys/hotplug.h>
! 49: #include <sys/limits.h>
! 50: #include <sys/malloc.h>
! 51: #include <sys/systm.h>
! 52: /* Extra stuff from Matthias Drochner <drochner@zelux6.zel.kfa-juelich.de> */
! 53: #include <sys/queue.h>
! 54: #include <sys/proc.h>
! 55:
! 56: #include "hotplug.h"
! 57:
! 58: /*
! 59: * Autoconfiguration subroutines.
! 60: */
! 61:
! 62: typedef int (*cond_predicate_t)(struct device *, void *);
! 63:
! 64: /*
! 65: * ioconf.c exports exactly two names: cfdata and cfroots. All system
! 66: * devices and drivers are found via these tables.
! 67: */
! 68: extern short cfroots[];
! 69:
! 70: #define ROOT ((struct device *)NULL)
! 71:
! 72: struct matchinfo {
! 73: cfmatch_t fn;
! 74: struct device *parent;
! 75: void *match, *aux;
! 76: int indirect, pri;
! 77: };
! 78:
! 79: struct cftable_head allcftables;
! 80:
! 81: static struct cftable staticcftable = {
! 82: cfdata
! 83: };
! 84:
! 85: #ifndef AUTOCONF_VERBOSE
! 86: #define AUTOCONF_VERBOSE 0
! 87: #endif /* AUTOCONF_VERBOSE */
! 88: int autoconf_verbose = AUTOCONF_VERBOSE; /* trace probe calls */
! 89:
! 90: static void mapply(struct matchinfo *, struct cfdata *);
! 91:
! 92: struct deferred_config {
! 93: TAILQ_ENTRY(deferred_config) dc_queue;
! 94: struct device *dc_dev;
! 95: void (*dc_func)(struct device *);
! 96: };
! 97:
! 98: TAILQ_HEAD(, deferred_config) deferred_config_queue;
! 99:
! 100: void config_process_deferred_children(struct device *);
! 101:
! 102: struct devicelist alldevs; /* list of all devices */
! 103:
! 104: __volatile int config_pending; /* semaphore for mountroot */
! 105:
! 106: /*
! 107: * Initialize autoconfiguration data structures. This occurs before console
! 108: * initialization as that might require use of this subsystem. Furthermore
! 109: * this means that malloc et al. isn't yet available.
! 110: */
! 111: void
! 112: config_init(void)
! 113: {
! 114: TAILQ_INIT(&deferred_config_queue);
! 115: TAILQ_INIT(&alldevs);
! 116: TAILQ_INIT(&allcftables);
! 117: TAILQ_INSERT_TAIL(&allcftables, &staticcftable, list);
! 118: }
! 119:
! 120: /*
! 121: * Apply the matching function and choose the best. This is used
! 122: * a few times and we want to keep the code small.
! 123: */
! 124: void
! 125: mapply(struct matchinfo *m, struct cfdata *cf)
! 126: {
! 127: int pri;
! 128: void *match;
! 129:
! 130: if (m->indirect)
! 131: match = config_make_softc(m->parent, cf);
! 132: else
! 133: match = cf;
! 134:
! 135: if (autoconf_verbose) {
! 136: printf(">>> probing for %s", cf->cf_driver->cd_name);
! 137: if (cf->cf_fstate == FSTATE_STAR)
! 138: printf("*\n");
! 139: else
! 140: printf("%d\n", cf->cf_unit);
! 141: }
! 142: if (m->fn != NULL)
! 143: pri = (*m->fn)(m->parent, match, m->aux);
! 144: else {
! 145: if (cf->cf_attach->ca_match == NULL) {
! 146: panic("mapply: no match function for '%s' device",
! 147: cf->cf_driver->cd_name);
! 148: }
! 149: pri = (*cf->cf_attach->ca_match)(m->parent, match, m->aux);
! 150: }
! 151: if (autoconf_verbose)
! 152: printf(">>> %s probe returned %d\n", cf->cf_driver->cd_name,
! 153: pri);
! 154:
! 155: if (pri > m->pri) {
! 156: if (m->indirect && m->match)
! 157: free(m->match, M_DEVBUF);
! 158: m->match = match;
! 159: m->pri = pri;
! 160: } else {
! 161: if (m->indirect)
! 162: free(match, M_DEVBUF);
! 163: }
! 164: }
! 165:
! 166: /*
! 167: * Iterate over all potential children of some device, calling the given
! 168: * function (default being the child's match function) for each one.
! 169: * Nonzero returns are matches; the highest value returned is considered
! 170: * the best match. Return the `found child' if we got a match, or NULL
! 171: * otherwise. The `aux' pointer is simply passed on through.
! 172: *
! 173: * Note that this function is designed so that it can be used to apply
! 174: * an arbitrary function to all potential children (its return value
! 175: * can be ignored).
! 176: */
! 177: void *
! 178: config_search(cfmatch_t fn, struct device *parent, void *aux)
! 179: {
! 180: struct cfdata *cf;
! 181: short *p;
! 182: struct matchinfo m;
! 183: struct cftable *t;
! 184:
! 185: m.fn = fn;
! 186: m.parent = parent;
! 187: m.match = NULL;
! 188: m.aux = aux;
! 189: m.indirect = parent && parent->dv_cfdata->cf_driver->cd_indirect;
! 190: m.pri = 0;
! 191: TAILQ_FOREACH(t, &allcftables, list) {
! 192: for (cf = t->tab; cf->cf_driver; cf++) {
! 193: /*
! 194: * Skip cf if no longer eligible, otherwise scan
! 195: * through parents for one matching `parent',
! 196: * and try match function.
! 197: */
! 198: if (cf->cf_fstate == FSTATE_FOUND)
! 199: continue;
! 200: if (cf->cf_fstate == FSTATE_DNOTFOUND ||
! 201: cf->cf_fstate == FSTATE_DSTAR)
! 202: continue;
! 203: for (p = cf->cf_parents; *p >= 0; p++)
! 204: if (parent->dv_cfdata == &(t->tab)[*p])
! 205: mapply(&m, cf);
! 206: }
! 207: }
! 208: if (autoconf_verbose) {
! 209: if (m.match) {
! 210: if (m.indirect)
! 211: cf = ((struct device *)m.match)->dv_cfdata;
! 212: else
! 213: cf = (struct cfdata *)m.match;
! 214: printf(">>> %s probe won\n",
! 215: cf->cf_driver->cd_name);
! 216: } else
! 217: printf(">>> no winning probe\n");
! 218: }
! 219: return (m.match);
! 220: }
! 221:
! 222: /*
! 223: * Iterate over all potential children of some device, calling the given
! 224: * function for each one.
! 225: *
! 226: * Note that this function is designed so that it can be used to apply
! 227: * an arbitrary function to all potential children (its return value
! 228: * can be ignored).
! 229: */
! 230: void
! 231: config_scan(cfscan_t fn, struct device *parent)
! 232: {
! 233: struct cfdata *cf;
! 234: short *p;
! 235: void *match;
! 236: int indirect;
! 237: struct cftable *t;
! 238:
! 239: indirect = parent && parent->dv_cfdata->cf_driver->cd_indirect;
! 240: TAILQ_FOREACH(t, &allcftables, list) {
! 241: for (cf = t->tab; cf->cf_driver; cf++) {
! 242: /*
! 243: * Skip cf if no longer eligible, otherwise scan
! 244: * through parents for one matching `parent',
! 245: * and try match function.
! 246: */
! 247: if (cf->cf_fstate == FSTATE_FOUND)
! 248: continue;
! 249: if (cf->cf_fstate == FSTATE_DNOTFOUND ||
! 250: cf->cf_fstate == FSTATE_DSTAR)
! 251: continue;
! 252: for (p = cf->cf_parents; *p >= 0; p++)
! 253: if (parent->dv_cfdata == &(t->tab)[*p]) {
! 254: match = indirect?
! 255: config_make_softc(parent, cf) :
! 256: (void *)cf;
! 257: (*fn)(parent, match);
! 258: }
! 259: }
! 260: }
! 261: }
! 262:
! 263: /*
! 264: * Find the given root device.
! 265: * This is much like config_search, but there is no parent.
! 266: */
! 267: void *
! 268: config_rootsearch(cfmatch_t fn, char *rootname, void *aux)
! 269: {
! 270: struct cfdata *cf;
! 271: short *p;
! 272: struct matchinfo m;
! 273:
! 274: m.fn = fn;
! 275: m.parent = ROOT;
! 276: m.match = NULL;
! 277: m.aux = aux;
! 278: m.indirect = 0;
! 279: m.pri = 0;
! 280: /*
! 281: * Look at root entries for matching name. We do not bother
! 282: * with found-state here since only one root should ever be
! 283: * searched (and it must be done first).
! 284: */
! 285: for (p = cfroots; *p >= 0; p++) {
! 286: cf = &cfdata[*p];
! 287: if (strcmp(cf->cf_driver->cd_name, rootname) == 0)
! 288: mapply(&m, cf);
! 289: }
! 290: return (m.match);
! 291: }
! 292:
! 293: char *msgs[3] = { "", " not configured\n", " unsupported\n" };
! 294:
! 295: /*
! 296: * The given `aux' argument describes a device that has been found
! 297: * on the given parent, but not necessarily configured. Locate the
! 298: * configuration data for that device (using the submatch function
! 299: * provided, or using candidates' cd_match configuration driver
! 300: * functions) and attach it, and return true. If the device was
! 301: * not configured, call the given `print' function and return 0.
! 302: */
! 303: struct device *
! 304: config_found_sm(struct device *parent, void *aux, cfprint_t print,
! 305: cfmatch_t submatch)
! 306: {
! 307: void *match;
! 308:
! 309: if ((match = config_search(submatch, parent, aux)) != NULL)
! 310: return (config_attach(parent, match, aux, print));
! 311: if (print)
! 312: printf(msgs[(*print)(aux, parent->dv_xname)]);
! 313: return (NULL);
! 314: }
! 315:
! 316: /*
! 317: * As above, but for root devices.
! 318: */
! 319: struct device *
! 320: config_rootfound(char *rootname, void *aux)
! 321: {
! 322: void *match;
! 323:
! 324: if ((match = config_rootsearch((cfmatch_t)NULL, rootname, aux)) != NULL)
! 325: return (config_attach(ROOT, match, aux, (cfprint_t)NULL));
! 326: printf("root device %s not configured\n", rootname);
! 327: return (NULL);
! 328: }
! 329:
! 330: /*
! 331: * Attach a found device. Allocates memory for device variables.
! 332: */
! 333: struct device *
! 334: config_attach(struct device *parent, void *match, void *aux, cfprint_t print)
! 335: {
! 336: struct cfdata *cf;
! 337: struct device *dev;
! 338: struct cfdriver *cd;
! 339: struct cfattach *ca;
! 340: struct cftable *t;
! 341:
! 342: if (parent && parent->dv_cfdata->cf_driver->cd_indirect) {
! 343: dev = match;
! 344: cf = dev->dv_cfdata;
! 345: } else {
! 346: cf = match;
! 347: dev = config_make_softc(parent, cf);
! 348: }
! 349:
! 350: cd = cf->cf_driver;
! 351: ca = cf->cf_attach;
! 352:
! 353: cd->cd_devs[dev->dv_unit] = dev;
! 354:
! 355: /*
! 356: * If this is a "STAR" device and we used the last unit, prepare for
! 357: * another one.
! 358: */
! 359: if (cf->cf_fstate == FSTATE_STAR) {
! 360: if (dev->dv_unit == cf->cf_unit)
! 361: cf->cf_unit++;
! 362: } else
! 363: cf->cf_fstate = FSTATE_FOUND;
! 364:
! 365: TAILQ_INSERT_TAIL(&alldevs, dev, dv_list);
! 366: device_ref(dev);
! 367:
! 368: if (parent == ROOT)
! 369: printf("%s at root", dev->dv_xname);
! 370: else {
! 371: printf("%s at %s", dev->dv_xname, parent->dv_xname);
! 372: if (print)
! 373: (void) (*print)(aux, (char *)0);
! 374: }
! 375:
! 376: /*
! 377: * Before attaching, clobber any unfound devices that are
! 378: * otherwise identical, or bump the unit number on all starred
! 379: * cfdata for this device.
! 380: */
! 381: TAILQ_FOREACH(t, &allcftables, list) {
! 382: for (cf = t->tab; cf->cf_driver; cf++)
! 383: if (cf->cf_driver == cd &&
! 384: cf->cf_unit == dev->dv_unit) {
! 385: if (cf->cf_fstate == FSTATE_NOTFOUND)
! 386: cf->cf_fstate = FSTATE_FOUND;
! 387: if (cf->cf_fstate == FSTATE_STAR)
! 388: cf->cf_unit++;
! 389: }
! 390: }
! 391: device_register(dev, aux);
! 392: (*ca->ca_attach)(parent, dev, aux);
! 393: config_process_deferred_children(dev);
! 394: #if NHOTPLUG > 0
! 395: if (!cold)
! 396: hotplug_device_attach(cd->cd_class, dev->dv_xname);
! 397: #endif
! 398: return (dev);
! 399: }
! 400:
! 401: struct device *
! 402: config_make_softc(struct device *parent, struct cfdata *cf)
! 403: {
! 404: struct device *dev;
! 405: struct cfdriver *cd;
! 406: struct cfattach *ca;
! 407:
! 408: cd = cf->cf_driver;
! 409: ca = cf->cf_attach;
! 410: if (ca->ca_devsize < sizeof(struct device))
! 411: panic("config_make_softc");
! 412:
! 413: /* get memory for all device vars */
! 414: dev = (struct device *)malloc(ca->ca_devsize, M_DEVBUF, M_NOWAIT);
! 415: if (!dev)
! 416: panic("config_make_softc: allocation for device softc failed");
! 417: bzero(dev, ca->ca_devsize);
! 418: dev->dv_class = cd->cd_class;
! 419: dev->dv_cfdata = cf;
! 420: dev->dv_flags = DVF_ACTIVE; /* always initially active */
! 421:
! 422: /* If this is a STAR device, search for a free unit number */
! 423: if (cf->cf_fstate == FSTATE_STAR) {
! 424: for (dev->dv_unit = cf->cf_starunit1;
! 425: dev->dv_unit < cf->cf_unit; dev->dv_unit++)
! 426: if (cd->cd_ndevs == 0 ||
! 427: dev->dv_unit >= cd->cd_ndevs ||
! 428: cd->cd_devs[dev->dv_unit] == NULL)
! 429: break;
! 430: } else
! 431: dev->dv_unit = cf->cf_unit;
! 432:
! 433: /* Build the device name into dv_xname. */
! 434: if (snprintf(dev->dv_xname, sizeof(dev->dv_xname), "%s%d",
! 435: cd->cd_name, dev->dv_unit) >= sizeof(dev->dv_xname))
! 436: panic("config_make_softc: device name too long");
! 437: dev->dv_parent = parent;
! 438:
! 439: /* put this device in the devices array */
! 440: if (dev->dv_unit >= cd->cd_ndevs) {
! 441: /*
! 442: * Need to expand the array.
! 443: */
! 444: int old = cd->cd_ndevs, new;
! 445: void **nsp;
! 446:
! 447: if (old == 0)
! 448: new = MINALLOCSIZE / sizeof(void *);
! 449: else
! 450: new = old * 2;
! 451: while (new <= dev->dv_unit)
! 452: new *= 2;
! 453: cd->cd_ndevs = new;
! 454: nsp = malloc(new * sizeof(void *), M_DEVBUF, M_NOWAIT);
! 455: if (nsp == 0)
! 456: panic("config_make_softc: %sing dev array",
! 457: old != 0 ? "expand" : "creat");
! 458: bzero(nsp + old, (new - old) * sizeof(void *));
! 459: if (old != 0) {
! 460: bcopy(cd->cd_devs, nsp, old * sizeof(void *));
! 461: free(cd->cd_devs, M_DEVBUF);
! 462: }
! 463: cd->cd_devs = nsp;
! 464: }
! 465: if (cd->cd_devs[dev->dv_unit])
! 466: panic("config_make_softc: duplicate %s", dev->dv_xname);
! 467:
! 468: dev->dv_ref = 1;
! 469:
! 470: return (dev);
! 471: }
! 472:
! 473: /*
! 474: * Detach a device. Optionally forced (e.g. because of hardware
! 475: * removal) and quiet. Returns zero if successful, non-zero
! 476: * (an error code) otherwise.
! 477: *
! 478: * Note that this code wants to be run from a process context, so
! 479: * that the detach can sleep to allow processes which have a device
! 480: * open to run and unwind their stacks.
! 481: */
! 482: int
! 483: config_detach(struct device *dev, int flags)
! 484: {
! 485: struct cfdata *cf;
! 486: struct cfattach *ca;
! 487: struct cfdriver *cd;
! 488: int rv = 0, i;
! 489: #ifdef DIAGNOSTIC
! 490: struct device *d;
! 491: #endif
! 492: #if NHOTPLUG > 0
! 493: char devname[16];
! 494: #endif
! 495:
! 496: #if NHOTPLUG > 0
! 497: strlcpy(devname, dev->dv_xname, sizeof(devname));
! 498: #endif
! 499:
! 500: cf = dev->dv_cfdata;
! 501: #ifdef DIAGNOSTIC
! 502: if (cf->cf_fstate != FSTATE_FOUND && cf->cf_fstate != FSTATE_STAR)
! 503: panic("config_detach: bad device fstate");
! 504: #endif
! 505: ca = cf->cf_attach;
! 506: cd = cf->cf_driver;
! 507:
! 508: /*
! 509: * Ensure the device is deactivated. If the device doesn't
! 510: * have an activation entry point, we allow DVF_ACTIVE to
! 511: * remain set. Otherwise, if DVF_ACTIVE is still set, the
! 512: * device is busy, and the detach fails.
! 513: */
! 514: if (ca->ca_activate != NULL)
! 515: rv = config_deactivate(dev);
! 516:
! 517: /*
! 518: * Try to detach the device. If that's not possible, then
! 519: * we either panic() (for the forced but failed case), or
! 520: * return an error.
! 521: */
! 522: if (rv == 0) {
! 523: if (ca->ca_detach != NULL)
! 524: rv = (*ca->ca_detach)(dev, flags);
! 525: else
! 526: rv = EOPNOTSUPP;
! 527: }
! 528: if (rv != 0) {
! 529: if ((flags & DETACH_FORCE) == 0)
! 530: return (rv);
! 531: else
! 532: panic("config_detach: forced detach of %s failed (%d)",
! 533: dev->dv_xname, rv);
! 534: }
! 535:
! 536: /*
! 537: * The device has now been successfully detached.
! 538: */
! 539:
! 540: #ifdef DIAGNOSTIC
! 541: /*
! 542: * Sanity: If you're successfully detached, you should have no
! 543: * children. (Note that because children must be attached
! 544: * after parents, we only need to search the latter part of
! 545: * the list.)
! 546: */
! 547: for (d = TAILQ_NEXT(dev, dv_list); d != NULL;
! 548: d = TAILQ_NEXT(d, dv_list)) {
! 549: if (d->dv_parent == dev)
! 550: panic("config_detach: detached device has children");
! 551: }
! 552: #endif
! 553:
! 554: /*
! 555: * Mark cfdata to show that the unit can be reused, if possible.
! 556: * Note that we can only re-use a starred unit number if the unit
! 557: * being detached had the last assigned unit number.
! 558: */
! 559: for (cf = cfdata; cf->cf_driver; cf++) {
! 560: if (cf->cf_driver == cd) {
! 561: if (cf->cf_fstate == FSTATE_FOUND &&
! 562: cf->cf_unit == dev->dv_unit)
! 563: cf->cf_fstate = FSTATE_NOTFOUND;
! 564: if (cf->cf_fstate == FSTATE_STAR &&
! 565: cf->cf_unit == dev->dv_unit + 1)
! 566: cf->cf_unit--;
! 567: }
! 568: }
! 569:
! 570: /*
! 571: * Unlink from device list.
! 572: */
! 573: TAILQ_REMOVE(&alldevs, dev, dv_list);
! 574: device_unref(dev);
! 575:
! 576: /*
! 577: * Remove from cfdriver's array, tell the world, and free softc.
! 578: */
! 579: cd->cd_devs[dev->dv_unit] = NULL;
! 580: if ((flags & DETACH_QUIET) == 0)
! 581: printf("%s detached\n", dev->dv_xname);
! 582:
! 583: device_unref(dev);
! 584: /*
! 585: * If the device now has no units in use, deallocate its softc array.
! 586: */
! 587: for (i = 0; i < cd->cd_ndevs; i++)
! 588: if (cd->cd_devs[i] != NULL)
! 589: break;
! 590: if (i == cd->cd_ndevs) { /* nothing found; deallocate */
! 591: free(cd->cd_devs, M_DEVBUF);
! 592: cd->cd_devs = NULL;
! 593: cd->cd_ndevs = 0;
! 594: cf->cf_unit = 0;
! 595: }
! 596:
! 597: #if NHOTPLUG > 0
! 598: if (!cold)
! 599: hotplug_device_detach(cd->cd_class, devname);
! 600: #endif
! 601:
! 602: /*
! 603: * Return success.
! 604: */
! 605: return (0);
! 606: }
! 607:
! 608: int
! 609: config_activate(struct device *dev)
! 610: {
! 611: struct cfattach *ca = dev->dv_cfdata->cf_attach;
! 612: int rv = 0, oflags = dev->dv_flags;
! 613:
! 614: if (ca->ca_activate == NULL)
! 615: return (EOPNOTSUPP);
! 616:
! 617: if ((dev->dv_flags & DVF_ACTIVE) == 0) {
! 618: dev->dv_flags |= DVF_ACTIVE;
! 619: rv = (*ca->ca_activate)(dev, DVACT_ACTIVATE);
! 620: if (rv)
! 621: dev->dv_flags = oflags;
! 622: }
! 623: return (rv);
! 624: }
! 625:
! 626: int
! 627: config_deactivate(struct device *dev)
! 628: {
! 629: struct cfattach *ca = dev->dv_cfdata->cf_attach;
! 630: int rv = 0, oflags = dev->dv_flags;
! 631:
! 632: if (ca->ca_activate == NULL)
! 633: return (EOPNOTSUPP);
! 634:
! 635: if (dev->dv_flags & DVF_ACTIVE) {
! 636: dev->dv_flags &= ~DVF_ACTIVE;
! 637: rv = (*ca->ca_activate)(dev, DVACT_DEACTIVATE);
! 638: if (rv)
! 639: dev->dv_flags = oflags;
! 640: }
! 641: return (rv);
! 642: }
! 643:
! 644: /*
! 645: * Defer the configuration of the specified device until all
! 646: * of its parent's devices have been attached.
! 647: */
! 648: void
! 649: config_defer(struct device *dev, void (*func)(struct device *))
! 650: {
! 651: struct deferred_config *dc;
! 652:
! 653: if (dev->dv_parent == NULL)
! 654: panic("config_defer: can't defer config of a root device");
! 655:
! 656: #ifdef DIAGNOSTIC
! 657: for (dc = TAILQ_FIRST(&deferred_config_queue); dc != NULL;
! 658: dc = TAILQ_NEXT(dc, dc_queue)) {
! 659: if (dc->dc_dev == dev)
! 660: panic("config_defer: deferred twice");
! 661: }
! 662: #endif
! 663:
! 664: if ((dc = malloc(sizeof(*dc), M_DEVBUF, M_NOWAIT)) == NULL)
! 665: panic("config_defer: can't allocate defer structure");
! 666:
! 667: dc->dc_dev = dev;
! 668: dc->dc_func = func;
! 669: TAILQ_INSERT_TAIL(&deferred_config_queue, dc, dc_queue);
! 670: config_pending_incr();
! 671: }
! 672:
! 673: /*
! 674: * Process the deferred configuration queue for a device.
! 675: */
! 676: void
! 677: config_process_deferred_children(struct device *parent)
! 678: {
! 679: struct deferred_config *dc, *ndc;
! 680:
! 681: for (dc = TAILQ_FIRST(&deferred_config_queue);
! 682: dc != NULL; dc = ndc) {
! 683: ndc = TAILQ_NEXT(dc, dc_queue);
! 684: if (dc->dc_dev->dv_parent == parent) {
! 685: TAILQ_REMOVE(&deferred_config_queue, dc, dc_queue);
! 686: (*dc->dc_func)(dc->dc_dev);
! 687: free(dc, M_DEVBUF);
! 688: config_pending_decr();
! 689: }
! 690: }
! 691: }
! 692:
! 693: /*
! 694: * Manipulate the config_pending semaphore.
! 695: */
! 696: void
! 697: config_pending_incr(void)
! 698: {
! 699:
! 700: config_pending++;
! 701: }
! 702:
! 703: void
! 704: config_pending_decr(void)
! 705: {
! 706:
! 707: #ifdef DIAGNOSTIC
! 708: if (config_pending == 0)
! 709: panic("config_pending_decr: config_pending == 0");
! 710: #endif
! 711: config_pending--;
! 712: if (config_pending == 0)
! 713: wakeup((void *)&config_pending);
! 714: }
! 715:
! 716: int
! 717: config_detach_children(struct device *parent, int flags)
! 718: {
! 719: struct device *dev, *next_dev, *prev_dev;
! 720: int rv = 0;
! 721:
! 722: /*
! 723: * The config_detach routine may sleep, meaning devices
! 724: * may be added to the queue. However, all devices will
! 725: * be added to the tail of the queue, the queue won't
! 726: * be re-organized, and the subtree of parent here should be locked
! 727: * for purposes of adding/removing children.
! 728: *
! 729: * Note that we can not afford trying to walk the device list
! 730: * once - our ``next'' device might be a child of the device
! 731: * we are about to detach, so it would disappear.
! 732: * Just play it safe and restart from the parent.
! 733: */
! 734: for (prev_dev = NULL, dev = TAILQ_LAST(&alldevs, devicelist);
! 735: dev != NULL; dev = next_dev) {
! 736: if (dev->dv_parent == parent) {
! 737: if ((rv = config_detach(dev, flags)) != 0)
! 738: return (rv);
! 739: next_dev = prev_dev ? prev_dev : TAILQ_LAST(&alldevs,
! 740: devicelist);
! 741: } else {
! 742: prev_dev = dev;
! 743: next_dev = TAILQ_PREV(dev, devicelist, dv_list);
! 744: }
! 745: }
! 746:
! 747: return (0);
! 748: }
! 749:
! 750: int
! 751: config_activate_children(struct device *parent, enum devact act)
! 752: {
! 753: struct device *dev, *next_dev;
! 754: int rv = 0;
! 755:
! 756: /* The config_deactivate routine may sleep, meaning devices
! 757: may be added to the queue. However, all devices will
! 758: be added to the tail of the queue, the queue won't
! 759: be re-organized, and the subtree of parent here should be locked
! 760: for purposes of adding/removing children.
! 761: */
! 762: for (dev = TAILQ_FIRST(&alldevs);
! 763: dev != NULL; dev = next_dev) {
! 764: next_dev = TAILQ_NEXT(dev, dv_list);
! 765: if (dev->dv_parent == parent) {
! 766: switch (act) {
! 767: case DVACT_ACTIVATE:
! 768: rv = config_activate(dev);
! 769: break;
! 770: case DVACT_DEACTIVATE:
! 771: rv = config_deactivate(dev);
! 772: break;
! 773: default:
! 774: #ifdef DIAGNOSTIC
! 775: printf ("config_activate_children: shouldn't get here");
! 776: #endif
! 777: rv = EOPNOTSUPP;
! 778: break;
! 779:
! 780: }
! 781:
! 782: if (rv)
! 783: break;
! 784: }
! 785: }
! 786:
! 787: return (rv);
! 788: }
! 789:
! 790: /*
! 791: * Lookup a device in the cfdriver device array. Does not return a
! 792: * device if it is not active.
! 793: *
! 794: * Increments ref count on the device by one, reflecting the
! 795: * new reference created on the stack.
! 796: *
! 797: * Context: process only
! 798: */
! 799: struct device *
! 800: device_lookup(struct cfdriver *cd, int unit)
! 801: {
! 802: struct device *dv = NULL;
! 803:
! 804: if (unit >= 0 && unit < cd->cd_ndevs)
! 805: dv = (struct device *)(cd->cd_devs[unit]);
! 806:
! 807: if (!dv)
! 808: return (NULL);
! 809:
! 810: if (!(dv->dv_flags & DVF_ACTIVE))
! 811: dv = NULL;
! 812:
! 813: if (dv != NULL)
! 814: device_ref(dv);
! 815:
! 816: return (dv);
! 817: }
! 818:
! 819:
! 820: /*
! 821: * Increments the ref count on the device structure. The device
! 822: * structure is freed when the ref count hits 0.
! 823: *
! 824: * Context: process or interrupt
! 825: */
! 826: void
! 827: device_ref(struct device *dv)
! 828: {
! 829: dv->dv_ref++;
! 830: }
! 831:
! 832: /*
! 833: * Decrement the ref count on the device structure.
! 834: *
! 835: * free's the structure when the ref count hits zero.
! 836: *
! 837: * Context: process or interrupt
! 838: */
! 839: void
! 840: device_unref(struct device *dv)
! 841: {
! 842: dv->dv_ref--;
! 843: if (dv->dv_ref == 0) {
! 844: free(dv, M_DEVBUF);
! 845: }
! 846: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to subr_autoconf.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / kern