1/* $NetBSD: device.h,v 1.190 2025/03/19 20:47:49 jakllsch 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 */
122typedef 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 */
138typedef enum devact {
139 DVACT_DEACTIVATE /* deactivate the device */
140} devact_t;
141
142typedef enum {
143 DVA_SYSTEM,
144 DVA_HARDWARE
145} devactive_t;
146
147typedef struct cfdata *cfdata_t;
148typedef struct cfdriver *cfdriver_t;
149typedef 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 */
160struct 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};
174typedef struct devhandle devhandle_t;
175#endif
176
177#if defined(_KERNEL) || defined(_KMEMUSER)
178struct 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
191struct device_suspensor {
192 const device_suspensor_t *ds_delegator;
193 char ds_name[32];
194};
195
196struct device_garbage {
197 device_t *dg_devs;
198 int dg_ndevs;
199};
200
201
202typedef 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. */
223typedef int (*device_call_t)(device_t, devhandle_t, void *);
224
225struct 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_) \
233static const struct device_call_descriptor __CONCAT(_c_,_descriptor) = {\
234 .name = (_n_), .call = (_c_) \
235}; \
236_DEVICE_CALL_REGISTER(_g_, _c_)
237
238struct 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
248struct 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
258TAILQ_HEAD(devicelist, device);
259#endif
260
261enum 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
268typedef enum deviter_flags deviter_flags_t;
269
270struct 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
278typedef struct deviter deviter_t;
279
280struct 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 */
289struct 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 */
299struct 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 */
315struct 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 */
325struct 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 */
344struct cftable {
345 cfdata_t ct_cfdata; /* pointer to cfdata table */
346 TAILQ_ENTRY(cftable) ct_list; /* list linkage */
347};
348#ifdef _KERNEL
349TAILQ_HEAD(cftablelist, cftable);
350#endif
351
352typedef int (*cfsubmatch_t)(device_t, cfdata_t, const int *, void *);
353typedef 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 */
370struct 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};
384LIST_HEAD(cfattachlist, cfattach);
385
386#define CFATTACH_DECL3_NEW(name, ddsize, matfn, attfn, detfn, actfn, \
387 rescanfn, chdetfn, __flags) \
388struct 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
414struct 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};
423LIST_HEAD(cfdriverlist, cfdriver);
424
425#define CFDRIVER_DECL(name, class, attrs) \
426struct 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 */
436struct cfattachinit {
437 const char *cfai_name; /* driver name */
438 struct cfattach * const *cfai_list;/* list of attachments */
439};
440
441/*
442 * Configuration printing functions, and their return codes. The second
443 * argument is NULL if the device was configured; otherwise it is the name
444 * of the parent device. The return value is ignored if the device was
445 * configured, so most functions can return UNCONF unconditionally.
446 */
447typedef int (*cfprint_t)(void *, const char *); /* XXX const char * */
448#define QUIET 0 /* print nothing */
449#define UNCONF 1 /* print " not configured\n" */
450#define UNSUPP 2 /* print " not supported\n" */
451
452/*
453 * Pseudo-device attach information (function + number of pseudo-devs).
454 */
455struct pdevinit {
456 void (*pdev_attach)(int);
457 int pdev_count;
458};
459
460/* This allows us to wildcard a device unit. */
461#define DVUNIT_ANY -1
462
463#if defined(_KERNEL) || defined(_KMEMUSER) || defined(_STANDALONE)
464/*
465 * Arguments passed to config_search() and config_found().
466 */
467struct cfargs {
468 uintptr_t cfargs_version; /* version field */
469
470 /* version 1 fields */
471 cfsubmatch_t submatch; /* submatch function (direct config) */
472 cfsearch_t search; /* search function (indirect config) */
473 const char * iattr; /* interface attribute */
474 const int * locators; /* locators array */
475 devhandle_t devhandle; /* devhandle_t (by value) */
476
477 /* version 2 fields below here */
478};
479
480#define CFARGS_VERSION 1 /* current cfargs version */
481
482#define CFARGS_NONE NULL /* no cfargs to pass */
483
484/*
485 * Construct a cfargs with this macro, like so:
486 *
487 * CFARGS(.submatch = config_stdsubmatch,
488 * .devhandle = my_devhandle)
489 *
490 * You must supply at least one field. If you don't need any, use the
491 * CFARGS_NONE macro.
492 */
493#define CFARGS(...) \
494 &((const struct cfargs){ \
495 .cfargs_version = CFARGS_VERSION, \
496 __VA_ARGS__ \
497 })
498#endif /* _KERNEL || _KMEMUSER || _STANDALONE */
499
500#ifdef _KERNEL
501
502extern struct cfdriverlist allcfdrivers;/* list of all cfdrivers */
503extern struct cftablelist allcftables; /* list of all cfdata tables */
504extern device_t booted_device; /* the device we booted from */
505extern const char *booted_method; /* the method the device was found */
506extern int booted_partition; /* the partition on that device */
507extern daddr_t booted_startblk; /* or the start of a wedge */
508extern uint64_t booted_nblks; /* and the size of that wedge */
509extern char *bootspec; /* and the device/wedge name */
510extern bool root_is_mounted; /* true if root is mounted */
511
512struct vnode *opendisk(device_t);
513int getdisksize(struct vnode *, uint64_t *, unsigned int *);
514struct dkwedge_info;
515int getdiskinfo(struct vnode *, struct dkwedge_info *);
516
517void config_init(void);
518int config_init_component(struct cfdriver *const*,
519 const struct cfattachinit *, struct cfdata *);
520int config_fini_component(struct cfdriver *const*,
521 const struct cfattachinit *, struct cfdata *);
522void config_init_mi(void);
523void drvctl_init(void);
524void drvctl_fini(void);
525extern int (*devmon_insert_vec)(const char *, prop_dictionary_t);
526
527int config_cfdriver_attach(struct cfdriver *);
528int config_cfdriver_detach(struct cfdriver *);
529
530int config_cfattach_attach(const char *, struct cfattach *);
531int config_cfattach_detach(const char *, struct cfattach *);
532
533int config_cfdata_attach(cfdata_t, int);
534int config_cfdata_detach(cfdata_t);
535
536struct cfdriver *config_cfdriver_lookup(const char *);
537struct cfattach *config_cfattach_lookup(const char *, const char *);
538const struct cfiattrdata *cfiattr_lookup(const char *, const struct cfdriver *);
539
540const char *cfdata_ifattr(const struct cfdata *);
541
542int config_stdsubmatch(device_t, cfdata_t, const int *, void *);
543cfdata_t config_search(device_t, void *, const struct cfargs *);
544cfdata_t config_rootsearch(cfsubmatch_t, const char *, void *);
545device_t config_found(device_t, void *, cfprint_t, const struct cfargs *);
546device_t config_rootfound(const char *, void *);
547device_t config_attach(device_t, cfdata_t, void *, cfprint_t,
548 const struct cfargs *);
549device_t config_found_acquire(device_t, void *, cfprint_t,
550 const struct cfargs *);
551device_t config_attach_acquire(device_t, cfdata_t, void *, cfprint_t,
552 const struct cfargs *);
553int config_match(device_t, cfdata_t, void *);
554int config_probe(device_t, cfdata_t, void *);
555
556bool ifattr_match(const char *, const char *);
557
558device_t config_attach_pseudo(cfdata_t);
559device_t config_attach_pseudo_acquire(cfdata_t, void *);
560
561int config_detach(device_t, int);
562int config_detach_release(device_t, int);
563int config_detach_children(device_t, int flags);
564void config_detach_commit(device_t);
565bool config_detach_all(int);
566int config_deactivate(device_t);
567void config_defer(device_t, void (*)(device_t));
568void config_deferred(device_t);
569void config_interrupts(device_t, void (*)(device_t));
570void config_mountroot(device_t, void (*)(device_t));
571void config_pending_incr(device_t);
572void config_pending_decr(device_t);
573void config_create_interruptthreads(void);
574void config_create_mountrootthreads(void);
575
576int config_finalize_register(device_t, int (*)(device_t));
577void config_finalize(void);
578void config_finalize_mountroot(void);
579
580void config_twiddle_init(void);
581void config_twiddle_fn(void *);
582
583void null_childdetached(device_t, device_t);
584
585device_t device_lookup(cfdriver_t, int);
586void *device_lookup_private(cfdriver_t, int);
587
588device_t device_lookup_acquire(cfdriver_t, int);
589void device_acquire(device_t);
590void device_release(device_t);
591
592void device_register(device_t, void *);
593void device_register_post_config(device_t, void *);
594
595devclass_t device_class(device_t);
596cfdata_t device_cfdata(device_t);
597cfdriver_t device_cfdriver(device_t);
598cfattach_t device_cfattach(device_t);
599int device_unit(device_t);
600const char *device_xname(device_t);
601device_t device_parent(device_t);
602bool device_is_active(device_t);
603bool device_activation(device_t, devact_level_t);
604bool device_is_enabled(device_t);
605bool device_has_power(device_t);
606int device_locator(device_t, u_int);
607void *device_private(device_t);
608void device_set_private(device_t, void *);
609prop_dictionary_t device_properties(device_t);
610void device_set_handle(device_t, devhandle_t);
611devhandle_t device_handle(device_t);
612
613bool devhandle_is_valid(devhandle_t);
614devhandle_t devhandle_invalid(void);
615devhandle_type_t devhandle_type(devhandle_t);
616int devhandle_compare(devhandle_t, devhandle_t);
617devhandle_t devhandle_subclass(devhandle_t, struct devhandle_impl *,
618 device_call_t (*)(devhandle_t, const char *,
619 devhandle_t *));
620
621device_call_t devhandle_lookup_device_call(devhandle_t, const char *,
622 devhandle_t *);
623void devhandle_impl_subclass(struct devhandle_impl *,
624 const struct devhandle_impl *,
625 device_call_t (*)(devhandle_t, const char *,
626 devhandle_t *));
627
628device_t deviter_first(deviter_t *, deviter_flags_t);
629void deviter_init(deviter_t *, deviter_flags_t);
630device_t deviter_next(deviter_t *);
631void deviter_release(deviter_t *);
632
633bool device_active(device_t, devactive_t);
634bool device_active_register(device_t,
635 void (*)(device_t, devactive_t));
636void device_active_deregister(device_t,
637 void (*)(device_t, devactive_t));
638
639bool device_is_a(device_t, const char *);
640bool device_attached_to_iattr(device_t, const char *);
641
642device_t device_find_by_xname(const char *);
643device_t device_find_by_driver_unit(const char *, int);
644
645int device_enumerate_children(device_t,
646 bool (*)(device_t, devhandle_t, void *), void *);
647
648int device_compatible_match(const char **, int,
649 const struct device_compatible_entry *);
650int device_compatible_pmatch(const char **, int,
651 const struct device_compatible_entry *);
652const struct device_compatible_entry *
653 device_compatible_lookup(const char **, int,
654 const struct device_compatible_entry *);
655const struct device_compatible_entry *
656 device_compatible_plookup(const char **, int,
657 const struct device_compatible_entry *);
658
659int device_compatible_match_strlist(const char *, size_t,
660 const struct device_compatible_entry *);
661int device_compatible_pmatch_strlist(const char *, size_t,
662 const struct device_compatible_entry *);
663const struct device_compatible_entry *
664 device_compatible_lookup_strlist(const char *, size_t,
665 const struct device_compatible_entry *);
666const struct device_compatible_entry *
667 device_compatible_plookup_strlist(const char *, size_t,
668 const struct device_compatible_entry *);
669
670int device_compatible_match_id(uintptr_t const, uintptr_t const,
671 const struct device_compatible_entry *);
672const struct device_compatible_entry *
673 device_compatible_lookup_id(uintptr_t const, uintptr_t const,
674 const struct device_compatible_entry *);
675
676void device_pmf_driver_child_register(device_t);
677void device_pmf_driver_set_child_register(device_t,
678 void (*)(device_t));
679
680void *device_pmf_bus_private(device_t);
681bool device_pmf_bus_suspend(device_t, const pmf_qual_t *);
682bool device_pmf_bus_resume(device_t, const pmf_qual_t *);
683bool device_pmf_bus_shutdown(device_t, int);
684
685void device_pmf_bus_register(device_t, void *,
686 bool (*)(device_t, const pmf_qual_t *),
687 bool (*)(device_t, const pmf_qual_t *),
688 bool (*)(device_t, int),
689 void (*)(device_t));
690void device_pmf_bus_deregister(device_t);
691
692device_t shutdown_first(struct shutdown_state *);
693device_t shutdown_next(struct shutdown_state *);
694
695/*
696 * device calls --
697 *
698 * This provides a generic mechanism for invoking special methods on
699 * devices, often dependent on the device tree implementation used
700 * by the platform.
701 *
702 * While individual subsystems may define their own device calls,
703 * the ones prefixed with "device-" are reserved, and defined by
704 * the device autoconfiguration subsystem. It is the responsibility
705 * of each device tree back end to implement these calls.
706 *
707 * We define a generic interface; individual device calls feature
708 * type checking of the argument structure. The argument structures
709 * and the call binding data are automatically generated from device
710 * call interface descriptions by gendevcalls.awk.
711 */
712struct device_call_generic {
713 const char *name;
714 void *args;
715};
716
717int device_call_generic(device_t, devhandle_t,
718 const struct device_call_generic *);
719
720#define device_call(dev, call) \
721 device_call_generic((dev), device_handle(dev), &(call)->generic)
722#define devhandle_call(handle, call) \
723 device_call_generic(NULL, (handle), &(call)->generic)
724
725#endif /* _KERNEL */
726
727#endif /* !_SYS_DEVICE_H_ */