The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/sys/device.h

Version: -  FREEBSD  -  FREEBSD-13-STABLE  -  FREEBSD-13-0  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  l41  -  OPENBSD  -  linux-2.6  -  MK84  -  PLAN9  -  xnu-8792 
SearchContext: -  none  -  3  -  10 

    1 /* $NetBSD: device.h,v 1.185 2022/08/24 11:19:25 riastradh Exp $ */
    2 
    3 /*
    4  * Copyright (c) 2021 The NetBSD Foundation, Inc.
    5  * All rights reserved.
    6  *
    7  * Redistribution and use in source and binary forms, with or without
    8  * modification, are permitted provided that the following conditions
    9  * are met:
   10  * 1. Redistributions of source code must retain the above copyright
   11  *    notice, this list of conditions and the following disclaimer.
   12  * 2. Redistributions in binary form must reproduce the above copyright
   13  *    notice, this list of conditions and the following disclaimer in the
   14  *    documentation and/or other materials provided with the distribution.
   15  *
   16  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
   17  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
   18  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
   19  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
   20  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   21  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   22  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   23  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
   24  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   25  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   26  * POSSIBILITY OF SUCH DAMAGE.
   27  */
   28 
   29 /*
   30  * Copyright (c) 1996, 2000 Christopher G. Demetriou
   31  * All rights reserved.
   32  *
   33  * Redistribution and use in source and binary forms, with or without
   34  * modification, are permitted provided that the following conditions
   35  * are met:
   36  * 1. Redistributions of source code must retain the above copyright
   37  *    notice, this list of conditions and the following disclaimer.
   38  * 2. Redistributions in binary form must reproduce the above copyright
   39  *    notice, this list of conditions and the following disclaimer in the
   40  *    documentation and/or other materials provided with the distribution.
   41  * 3. All advertising materials mentioning features or use of this software
   42  *    must display the following acknowledgement:
   43  *          This product includes software developed for the
   44  *          NetBSD Project.  See http://www.NetBSD.org/ for
   45  *          information about NetBSD.
   46  * 4. The name of the author may not be used to endorse or promote products
   47  *    derived from this software without specific prior written permission.
   48  *
   49  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
   50  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
   51  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
   52  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
   53  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
   54  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
   55  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
   56  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
   57  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
   58  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   59  *
   60  * --(license Id: LICENSE.proto,v 1.1 2000/06/13 21:40:26 cgd Exp )--
   61  */
   62 
   63 /*
   64  * Copyright (c) 1992, 1993
   65  *      The Regents of the University of California.  All rights reserved.
   66  *
   67  * This software was developed by the Computer Systems Engineering group
   68  * at Lawrence Berkeley Laboratory under DARPA contract BG 91-66 and
   69  * contributed to Berkeley.
   70  *
   71  * All advertising materials mentioning features or use of this software
   72  * must display the following acknowledgement:
   73  *      This product includes software developed by the University of
   74  *      California, Lawrence Berkeley Laboratories.
   75  *
   76  * Redistribution and use in source and binary forms, with or without
   77  * modification, are permitted provided that the following conditions
   78  * are met:
   79  * 1. Redistributions of source code must retain the above copyright
   80  *    notice, this list of conditions and the following disclaimer.
   81  * 2. Redistributions in binary form must reproduce the above copyright
   82  *    notice, this list of conditions and the following disclaimer in the
   83  *    documentation and/or other materials provided with the distribution.
   84  * 3. Neither the name of the University nor the names of its contributors
   85  *    may be used to endorse or promote products derived from this software
   86  *    without specific prior written permission.
   87  *
   88  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
   89  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   90  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   91  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
   92  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   93  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   94  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   95  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   96  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   97  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   98  * SUCH DAMAGE.
   99  *
  100  *      @(#)device.h    8.2 (Berkeley) 2/17/94
  101  */
  102 
  103 #ifndef _SYS_DEVICE_H_
  104 #define _SYS_DEVICE_H_
  105 
  106 #include <sys/device_if.h>
  107 #include <sys/evcnt.h>
  108 #include <sys/queue.h>
  109 
  110 #if defined(_KERNEL) || defined(_KMEMUSER)
  111 #include <sys/mutex.h>
  112 #include <sys/condvar.h>
  113 #include <sys/pmf.h>
  114 #endif
  115 
  116 #include <prop/proplib.h>
  117 
  118 /*
  119  * Minimal device structures.
  120  * Note that all ``system'' device types are listed here.
  121  */
  122 typedef enum devclass {
  123         DV_DULL,                /* generic, no special info */
  124         DV_CPU,                 /* CPU (carries resource utilization) */
  125         DV_DISK,                /* disk drive (label, etc) */
  126         DV_IFNET,               /* network interface */
  127         DV_TAPE,                /* tape device */
  128         DV_TTY,                 /* serial line interface (?) */
  129         DV_AUDIODEV,            /* audio device */
  130         DV_DISPLAYDEV,          /* display device */
  131         DV_BUS,                 /* bus device */
  132         DV_VIRTUAL,             /* unbacked virtual device */
  133 } devclass_t;
  134 
  135 /*
  136  * Actions for ca_activate.
  137  */
  138 typedef enum devact {
  139         DVACT_DEACTIVATE        /* deactivate the device */
  140 } devact_t;
  141 
  142 typedef enum {
  143         DVA_SYSTEM,
  144         DVA_HARDWARE
  145 } devactive_t;
  146 
  147 typedef struct cfdata *cfdata_t;
  148 typedef struct cfdriver *cfdriver_t;
  149 typedef struct cfattach *cfattach_t;
  150 
  151 #if defined(_KERNEL) || defined(_KMEMUSER) || defined(_STANDALONE)
  152 /*
  153  * devhandle_t --
  154  *
  155  *      This is an abstraction of the device handles used by ACPI,
  156  *      OpenFirmware, and others, to support device enumeration and
  157  *      device tree linkage.  A devhandle_t can be safely passed
  158  *      by value.
  159  */
  160 struct devhandle {
  161         const struct devhandle_impl *   impl;
  162         union {
  163                 /*
  164                  * Storage for the device handle.  Which storage field
  165                  * is used is at the sole discretion of the type
  166                  * implementation.
  167                  */
  168                 void *                  pointer;
  169                 const void *            const_pointer;
  170                 uintptr_t               uintptr;
  171                 intptr_t                integer;
  172         };
  173 };
  174 typedef struct devhandle devhandle_t;
  175 #endif
  176 
  177 #if defined(_KERNEL) || defined(_KMEMUSER) 
  178 struct device_compatible_entry {
  179         union {
  180                 const char *compat;
  181                 uintptr_t id;
  182         };
  183         union {
  184                 const void *data;
  185                 uintptr_t value;
  186         };
  187 };
  188 
  189 #define DEVICE_COMPAT_EOL       { .compat = NULL }
  190 
  191 struct device_suspensor {
  192         const device_suspensor_t        *ds_delegator;
  193         char                            ds_name[32];
  194 };
  195 
  196 struct device_garbage {
  197         device_t        *dg_devs;
  198         int             dg_ndevs;
  199 };
  200 
  201 
  202 typedef enum {
  203         /* Used to represent invalid states. */
  204         DEVHANDLE_TYPE_INVALID          =       0,
  205 
  206         /* ACPI */
  207         DEVHANDLE_TYPE_ACPI             =       0x41435049,     /* 'ACPI' */
  208 
  209         /* OpenFirmware, FDT */
  210         DEVHANDLE_TYPE_OF               =       0x4f504657,     /* 'OPFW' */
  211 
  212         /* Sun OpenBoot */
  213         DEVHANDLE_TYPE_OPENBOOT         =       0x4f504254,     /* 'OPBT' */
  214 
  215         /* Private (opaque data) */
  216         DEVHANDLE_TYPE_PRIVATE          =       0x50525654,     /* 'PRVT' */
  217 
  218         /* Max value. */
  219         DEVHANDLE_TYPE_MAX              =       0xffffffff
  220 } devhandle_type_t;
  221 
  222 /* Device method call function signature. */
  223 typedef int (*device_call_t)(device_t, devhandle_t, void *);
  224 
  225 struct device_call_descriptor {
  226         const char *name;
  227         device_call_t call;
  228 };
  229 
  230 #define _DEVICE_CALL_REGISTER(_g_, _c_)                                 \
  231         __link_set_add_rodata(_g_, __CONCAT(_c_,_descriptor));
  232 #define DEVICE_CALL_REGISTER(_g_, _n_, _c_)                             \
  233 static const struct device_call_descriptor __CONCAT(_c_,_descriptor) = {\
  234         .name = (_n_), .call = (_c_)                                    \
  235 };                                                                      \
  236 _DEVICE_CALL_REGISTER(_g_, _c_)
  237 
  238 struct devhandle_impl {
  239         devhandle_type_t                type;
  240         const struct devhandle_impl *   super;
  241         device_call_t                   (*lookup_device_call)(devhandle_t,
  242                                             const char *, devhandle_t *);
  243 };
  244 
  245 /* Max size of a device external name (including terminating NUL) */
  246 #define DEVICE_XNAME_SIZE       16
  247 
  248 struct device;
  249 
  250 /*
  251  * struct cfattach::ca_flags (must not overlap with device_impl.h
  252  * struct device::dv_flags for now)
  253  */
  254 #define DVF_PRIV_ALLOC          0x0002  /* device private storage != device */
  255 #define DVF_DETACH_SHUTDOWN     0x0080  /* device detaches safely at shutdown */
  256 
  257 #ifdef _KERNEL
  258 TAILQ_HEAD(devicelist, device);
  259 #endif
  260 
  261 enum deviter_flags {
  262           DEVITER_F_RW =                0x1
  263         , DEVITER_F_SHUTDOWN =          0x2
  264         , DEVITER_F_LEAVES_FIRST =      0x4
  265         , DEVITER_F_ROOT_FIRST =        0x8
  266 };
  267 
  268 typedef enum deviter_flags deviter_flags_t;
  269 
  270 struct deviter {
  271         device_t        di_prev;
  272         deviter_flags_t di_flags;
  273         int             di_curdepth;
  274         int             di_maxdepth;
  275         devgen_t        di_gen;
  276 };
  277 
  278 typedef struct deviter deviter_t;
  279 
  280 struct shutdown_state {
  281         bool initialized;
  282         deviter_t di;
  283 };
  284 #endif
  285 
  286 /*
  287  * Description of a locator, as part of interface attribute definitions.
  288  */
  289 struct cflocdesc {
  290         const char *cld_name;
  291         const char *cld_defaultstr; /* NULL if no default */
  292         int cld_default;
  293 };
  294 
  295 /*
  296  * Description of an interface attribute, provided by potential
  297  * parent device drivers, referred to by child device configuration data.
  298  */
  299 struct cfiattrdata {
  300         const char *ci_name;
  301         int ci_loclen;
  302         const struct cflocdesc ci_locdesc[
  303 #if defined(__GNUC__) && __GNUC__ <= 2
  304                 0
  305 #endif
  306         ];
  307 };
  308 
  309 /*
  310  * Description of a configuration parent.  Each device attachment attaches
  311  * to an "interface attribute", which is given in this structure.  The parent
  312  * *must* carry this attribute.  Optionally, an individual device instance
  313  * may also specify a specific parent device instance.
  314  */
  315 struct cfparent {
  316         const char *cfp_iattr;          /* interface attribute */
  317         const char *cfp_parent;         /* optional specific parent */
  318         int cfp_unit;                   /* optional specific unit
  319                                            (DVUNIT_ANY to wildcard) */
  320 };
  321 
  322 /*
  323  * Configuration data (i.e., data placed in ioconf.c).
  324  */
  325 struct cfdata {
  326         const char *cf_name;            /* driver name */
  327         const char *cf_atname;          /* attachment name */
  328         unsigned int cf_unit:24;        /* unit number */
  329         unsigned char cf_fstate;        /* finding state (below) */
  330         int     *cf_loc;                /* locators (machine dependent) */
  331         int     cf_flags;               /* flags from config */
  332         const struct cfparent *cf_pspec;/* parent specification */
  333 };
  334 #define FSTATE_NOTFOUND         0       /* has not been found */
  335 #define FSTATE_FOUND            1       /* has been found */
  336 #define FSTATE_STAR             2       /* duplicable */
  337 #define FSTATE_DSTAR            3       /* has not been found, and disabled */
  338 #define FSTATE_DNOTFOUND        4       /* duplicate, and disabled */
  339 
  340 /*
  341  * Multiple configuration data tables may be maintained.  This structure
  342  * provides the linkage.
  343  */
  344 struct cftable {
  345         cfdata_t        ct_cfdata;      /* pointer to cfdata table */
  346         TAILQ_ENTRY(cftable) ct_list;   /* list linkage */
  347 };
  348 #ifdef _KERNEL
  349 TAILQ_HEAD(cftablelist, cftable);
  350 #endif
  351 
  352 typedef int (*cfsubmatch_t)(device_t, cfdata_t, const int *, void *);
  353 typedef int (*cfsearch_t)(device_t, cfdata_t, const int *, void *);
  354 
  355 /*
  356  * `configuration' attachment and driver (what the machine-independent
  357  * autoconf uses).  As devices are found, they are applied against all
  358  * the potential matches.  The one with the best match is taken, and a
  359  * device structure (plus any other data desired) is allocated.  Pointers
  360  * to these are placed into an array of pointers.  The array itself must
  361  * be dynamic since devices can be found long after the machine is up
  362  * and running.
  363  *
  364  * Devices can have multiple configuration attachments if they attach
  365  * to different attributes (busses, or whatever), to allow specification
  366  * of multiple match and attach functions.  There is only one configuration
  367  * driver per driver, so that things like unit numbers and the device
  368  * structure array will be shared.
  369  */
  370 struct cfattach {
  371         const char *ca_name;            /* name of attachment */
  372         LIST_ENTRY(cfattach) ca_list;   /* link on cfdriver's list */
  373         size_t    ca_devsize;           /* size of dev data (for alloc) */
  374         int       ca_flags;             /* flags for driver allocation etc */
  375         int     (*ca_match)(device_t, cfdata_t, void *);
  376         void    (*ca_attach)(device_t, device_t, void *);
  377         int     (*ca_detach)(device_t, int);
  378         int     (*ca_activate)(device_t, devact_t);
  379         /* technically, the next 2 belong into "struct cfdriver" */
  380         int     (*ca_rescan)(device_t, const char *,
  381                              const int *); /* scan for new children */
  382         void    (*ca_childdetached)(device_t, device_t);
  383 };
  384 LIST_HEAD(cfattachlist, cfattach);
  385 
  386 #define CFATTACH_DECL3_NEW(name, ddsize, matfn, attfn, detfn, actfn, \
  387         rescanfn, chdetfn, __flags) \
  388 struct cfattach __CONCAT(name,_ca) = {                                  \
  389         .ca_name                = ___STRING(name),                      \
  390         .ca_devsize             = ddsize,                               \
  391         .ca_flags               = (__flags) | DVF_PRIV_ALLOC,           \
  392         .ca_match               = matfn,                                \
  393         .ca_attach              = attfn,                                \
  394         .ca_detach              = detfn,                                \
  395         .ca_activate            = actfn,                                \
  396         .ca_rescan              = rescanfn,                             \
  397         .ca_childdetached       = chdetfn,                              \
  398 }
  399 
  400 #define CFATTACH_DECL2_NEW(name, ddsize, matfn, attfn, detfn, actfn,    \
  401         rescanfn, chdetfn)                                              \
  402         CFATTACH_DECL3_NEW(name, ddsize, matfn, attfn, detfn, actfn,    \
  403             rescanfn, chdetfn, 0)
  404 
  405 #define CFATTACH_DECL_NEW(name, ddsize, matfn, attfn, detfn, actfn)     \
  406         CFATTACH_DECL2_NEW(name, ddsize, matfn, attfn, detfn, actfn, NULL, NULL)
  407 
  408 /* Flags given to config_detach(), and the ca_detach function. */
  409 #define DETACH_FORCE    0x01            /* force detachment; hardware gone */
  410 #define DETACH_QUIET    0x02            /* don't print a notice */
  411 #define DETACH_SHUTDOWN 0x04            /* detach because of system shutdown */
  412 #define DETACH_POWEROFF 0x08            /* going to power off; power down devices */
  413 
  414 struct cfdriver {
  415         LIST_ENTRY(cfdriver) cd_list;   /* link on allcfdrivers */
  416         struct cfattachlist cd_attach;  /* list of all attachments */
  417         device_t *cd_devs;              /* devices found */
  418         const char *cd_name;            /* device name */
  419         enum    devclass cd_class;      /* device classification */
  420         int     cd_ndevs;               /* size of cd_devs array */
  421         const struct cfiattrdata * const *cd_attrs; /* attributes provided */
  422 };
  423 LIST_HEAD(cfdriverlist, cfdriver);
  424 
  425 #define CFDRIVER_DECL(name, class, attrs)                               \
  426 struct cfdriver __CONCAT(name,_cd) = {                                  \
  427         .cd_name                = ___STRING(name),                      \
  428         .cd_class               = class,                                \
  429         .cd_attrs               = attrs,                                \
  430 }
  431 
  432 /*
  433  * The cfattachinit is a data structure used to associate a list of
  434  * cfattach's with cfdrivers as found in the static kernel configuration.
  435  */
  436 struct cfattachinit {
  437         const char *cfai_name;           /* driver name */
  438         struct cfattach * const *cfai_list;/* list of attachments */
  439 };
  440 /*
  441  * the same, but with a non-constant list so it can be modified
  442  * for module bookkeeping
  443  */
  444 struct cfattachlkminit {
  445         const char *cfai_name;          /* driver name */
  446         struct cfattach **cfai_list;    /* list of attachments */
  447 };
  448 
  449 /*
  450  * Configuration printing functions, and their return codes.  The second
  451  * argument is NULL if the device was configured; otherwise it is the name
  452  * of the parent device.  The return value is ignored if the device was
  453  * configured, so most functions can return UNCONF unconditionally.
  454  */
  455 typedef int (*cfprint_t)(void *, const char *);         /* XXX const char * */
  456 #define QUIET   0               /* print nothing */
  457 #define UNCONF  1               /* print " not configured\n" */
  458 #define UNSUPP  2               /* print " not supported\n" */
  459 
  460 /*
  461  * Pseudo-device attach information (function + number of pseudo-devs).
  462  */
  463 struct pdevinit {
  464         void    (*pdev_attach)(int);
  465         int     pdev_count;
  466 };
  467 
  468 /* This allows us to wildcard a device unit. */
  469 #define DVUNIT_ANY      -1
  470 
  471 #if defined(_KERNEL) || defined(_KMEMUSER) || defined(_STANDALONE)
  472 /*
  473  * Arguments passed to config_search() and config_found().
  474  */
  475 struct cfargs {
  476         uintptr_t       cfargs_version; /* version field */
  477 
  478         /* version 1 fields */
  479         cfsubmatch_t    submatch;       /* submatch function (direct config) */
  480         cfsearch_t      search;         /* search function (indirect config) */
  481         const char *    iattr;          /* interface attribute */
  482         const int *     locators;       /* locators array */
  483         devhandle_t     devhandle;      /* devhandle_t (by value) */
  484 
  485         /* version 2 fields below here */
  486 };
  487 
  488 #define CFARGS_VERSION          1       /* current cfargs version */
  489 
  490 #define CFARGS_NONE             NULL    /* no cfargs to pass */
  491 
  492 /*
  493  * Construct a cfargs with this macro, like so:
  494  *
  495  *      CFARGS(.submatch = config_stdsubmatch,
  496  *             .devhandle = my_devhandle)
  497  *
  498  * You must supply at least one field.  If you don't need any, use the
  499  * CFARGS_NONE macro.
  500  */
  501 #define CFARGS(...)                                                     \
  502         &((const struct cfargs){                                        \
  503                 .cfargs_version = CFARGS_VERSION,                       \
  504                 __VA_ARGS__                                             \
  505         })
  506 #endif /* _KERNEL || _KMEMUSER || _STANDALONE */
  507 
  508 #ifdef _KERNEL
  509 
  510 extern struct cfdriverlist allcfdrivers;/* list of all cfdrivers */
  511 extern struct cftablelist allcftables;  /* list of all cfdata tables */
  512 extern device_t booted_device;          /* the device we booted from */
  513 extern const char *booted_method;       /* the method the device was found */
  514 extern int booted_partition;            /* the partition on that device */
  515 extern daddr_t booted_startblk;         /* or the start of a wedge */
  516 extern uint64_t booted_nblks;           /* and the size of that wedge */
  517 extern char *bootspec;                  /* and the device/wedge name */
  518 extern bool root_is_mounted;            /* true if root is mounted */
  519 
  520 struct vnode *opendisk(device_t);
  521 int getdisksize(struct vnode *, uint64_t *, unsigned int *);
  522 struct dkwedge_info;
  523 int getdiskinfo(struct vnode *, struct dkwedge_info *);
  524 
  525 void    config_init(void);
  526 int     config_init_component(struct cfdriver *const*,
  527                               const struct cfattachinit *, struct cfdata *);
  528 int     config_fini_component(struct cfdriver *const*,
  529                               const struct cfattachinit *, struct cfdata *);
  530 void    config_init_mi(void);
  531 void    drvctl_init(void);
  532 void    drvctl_fini(void);
  533 extern  int (*devmon_insert_vec)(const char *, prop_dictionary_t);
  534 
  535 int     config_cfdriver_attach(struct cfdriver *);
  536 int     config_cfdriver_detach(struct cfdriver *);
  537 
  538 int     config_cfattach_attach(const char *, struct cfattach *);
  539 int     config_cfattach_detach(const char *, struct cfattach *);
  540 
  541 int     config_cfdata_attach(cfdata_t, int);
  542 int     config_cfdata_detach(cfdata_t);
  543 
  544 struct cfdriver *config_cfdriver_lookup(const char *);
  545 struct cfattach *config_cfattach_lookup(const char *, const char *);
  546 const struct cfiattrdata *cfiattr_lookup(const char *, const struct cfdriver *);
  547 
  548 const char *cfdata_ifattr(const struct cfdata *);
  549 
  550 int     config_stdsubmatch(device_t, cfdata_t, const int *, void *);
  551 cfdata_t config_search(device_t, void *, const struct cfargs *);
  552 cfdata_t config_rootsearch(cfsubmatch_t, const char *, void *);
  553 device_t config_found(device_t, void *, cfprint_t, const struct cfargs *);
  554 device_t config_rootfound(const char *, void *);
  555 device_t config_attach(device_t, cfdata_t, void *, cfprint_t,
  556             const struct cfargs *);
  557 int     config_match(device_t, cfdata_t, void *);
  558 int     config_probe(device_t, cfdata_t, void *);
  559 
  560 bool    ifattr_match(const char *, const char *);
  561 
  562 device_t config_attach_pseudo(cfdata_t);
  563 
  564 int     config_detach(device_t, int);
  565 int     config_detach_children(device_t, int flags);
  566 void    config_detach_commit(device_t);
  567 bool    config_detach_all(int);
  568 int     config_deactivate(device_t);
  569 void    config_defer(device_t, void (*)(device_t));
  570 void    config_deferred(device_t);
  571 void    config_interrupts(device_t, void (*)(device_t));
  572 void    config_mountroot(device_t, void (*)(device_t));
  573 void    config_pending_incr(device_t);
  574 void    config_pending_decr(device_t);
  575 void    config_create_interruptthreads(void);
  576 void    config_create_mountrootthreads(void);
  577 
  578 int     config_finalize_register(device_t, int (*)(device_t));
  579 void    config_finalize(void);
  580 void    config_finalize_mountroot(void);
  581 
  582 void    config_twiddle_init(void);
  583 void    config_twiddle_fn(void *);
  584 
  585 void    null_childdetached(device_t, device_t);
  586 
  587 device_t        device_lookup(cfdriver_t, int);
  588 void            *device_lookup_private(cfdriver_t, int);
  589 
  590 device_t        device_lookup_acquire(cfdriver_t, int);
  591 void            device_release(device_t);
  592 
  593 void            device_register(device_t, void *);
  594 void            device_register_post_config(device_t, void *);
  595 
  596 devclass_t      device_class(device_t);
  597 cfdata_t        device_cfdata(device_t);
  598 cfdriver_t      device_cfdriver(device_t);
  599 cfattach_t      device_cfattach(device_t);
  600 int             device_unit(device_t);
  601 const char      *device_xname(device_t);
  602 device_t        device_parent(device_t);
  603 bool            device_is_active(device_t);
  604 bool            device_activation(device_t, devact_level_t);
  605 bool            device_is_enabled(device_t);
  606 bool            device_has_power(device_t);
  607 int             device_locator(device_t, u_int);
  608 void            *device_private(device_t);
  609 void            device_set_private(device_t, void *);
  610 prop_dictionary_t device_properties(device_t);
  611 void            device_set_handle(device_t, devhandle_t);
  612 devhandle_t     device_handle(device_t);
  613 
  614 bool            devhandle_is_valid(devhandle_t);
  615 devhandle_t     devhandle_invalid(void);
  616 devhandle_type_t devhandle_type(devhandle_t);
  617 int             devhandle_compare(devhandle_t, devhandle_t);
  618 
  619 device_call_t   devhandle_lookup_device_call(devhandle_t, const char *,
  620                     devhandle_t *);
  621 void            devhandle_impl_inherit(struct devhandle_impl *,
  622                     const struct devhandle_impl *);
  623 
  624 device_t        deviter_first(deviter_t *, deviter_flags_t);
  625 void            deviter_init(deviter_t *, deviter_flags_t);
  626 device_t        deviter_next(deviter_t *);
  627 void            deviter_release(deviter_t *);
  628 
  629 bool            device_active(device_t, devactive_t);
  630 bool            device_active_register(device_t,
  631                                        void (*)(device_t, devactive_t));
  632 void            device_active_deregister(device_t,
  633                                          void (*)(device_t, devactive_t));
  634 
  635 bool            device_is_a(device_t, const char *);
  636 bool            device_attached_to_iattr(device_t, const char *);
  637 
  638 device_t        device_find_by_xname(const char *);
  639 device_t        device_find_by_driver_unit(const char *, int);
  640 
  641 int             device_enumerate_children(device_t,
  642                     bool (*)(device_t, devhandle_t, void *), void *);
  643 
  644 int             device_compatible_match(const char **, int,
  645                                 const struct device_compatible_entry *);
  646 int             device_compatible_pmatch(const char **, int,
  647                                 const struct device_compatible_entry *);
  648 const struct device_compatible_entry *
  649                 device_compatible_lookup(const char **, int,
  650                                 const struct device_compatible_entry *);
  651 const struct device_compatible_entry *
  652                 device_compatible_plookup(const char **, int,
  653                                 const struct device_compatible_entry *);
  654 
  655 int             device_compatible_match_strlist(const char *, size_t,
  656                                 const struct device_compatible_entry *);
  657 int             device_compatible_pmatch_strlist(const char *, size_t,
  658                                 const struct device_compatible_entry *);
  659 const struct device_compatible_entry *
  660                 device_compatible_lookup_strlist(const char *, size_t,
  661                                 const struct device_compatible_entry *);
  662 const struct device_compatible_entry *
  663                 device_compatible_plookup_strlist(const char *, size_t,
  664                                 const struct device_compatible_entry *);
  665 
  666 int             device_compatible_match_id(uintptr_t const, uintptr_t const,
  667                                 const struct device_compatible_entry *);
  668 const struct device_compatible_entry *
  669                 device_compatible_lookup_id(uintptr_t const, uintptr_t const,
  670                                 const struct device_compatible_entry *);
  671 
  672 void            device_pmf_driver_child_register(device_t);
  673 void            device_pmf_driver_set_child_register(device_t,
  674                     void (*)(device_t));
  675 
  676 void            *device_pmf_bus_private(device_t);
  677 bool            device_pmf_bus_suspend(device_t, const pmf_qual_t *);
  678 bool            device_pmf_bus_resume(device_t, const pmf_qual_t *);
  679 bool            device_pmf_bus_shutdown(device_t, int);
  680 
  681 void            device_pmf_bus_register(device_t, void *,
  682                     bool (*)(device_t, const pmf_qual_t *),
  683                     bool (*)(device_t, const pmf_qual_t *),
  684                     bool (*)(device_t, int),
  685                     void (*)(device_t));
  686 void            device_pmf_bus_deregister(device_t);
  687 
  688 device_t        shutdown_first(struct shutdown_state *);
  689 device_t        shutdown_next(struct shutdown_state *);
  690 
  691 /*
  692  * device calls --
  693  *
  694  * This provides a generic mechanism for invoking special methods on
  695  * devices, often dependent on the device tree implementation used
  696  * by the platform.
  697  *
  698  * While individual subsystems may define their own device calls,
  699  * the ones prefixed with "device-" are reserved, and defined by
  700  * the device autoconfiguration subsystem.  It is the responsibility
  701  * of each device tree back end to implement these calls.
  702  *
  703  * We define a generic interface; individual device calls feature
  704  * type checking of the argument structure.  The argument structures
  705  * and the call binding data are automatically generated from device
  706  * call interface descriptions by gendevcalls.awk.
  707  */
  708 struct device_call_generic {
  709         const char *name;
  710         void *args;
  711 };
  712 
  713 int     device_call_generic(device_t, const struct device_call_generic *);
  714 
  715 #define device_call(dev, call)                                          \
  716         device_call_generic((dev), &(call)->generic)
  717 
  718 #endif /* _KERNEL */
  719 
  720 #endif /* !_SYS_DEVICE_H_ */

Cache object: b515d2732abc1bf884611bf8b75012aa


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.