xref: /titanic_41/usr/src/uts/common/sys/sunddi.h (revision a69427bbac5cf9c05e74ba8e353ccdb34e353b60)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 
22 /*
23  * Copyright (c) 1990, 2010, Oracle and/or its affiliates. All rights reserved.
24  * Copyright 2012 Garrett D'Amore <garrett@damore.org>.  All rights reserved.
25  * Copyright (c) 2012 by Delphix. All rights reserved.
26  * Copyright 2016 Nexenta Systems, Inc.  All rights reserved.
27  */
28 
29 #ifndef	_SYS_SUNDDI_H
30 #define	_SYS_SUNDDI_H
31 
32 /*
33  * Sun Specific DDI definitions
34  */
35 
36 #include <sys/isa_defs.h>
37 #include <sys/dditypes.h>
38 #include <sys/ddipropdefs.h>
39 #include <sys/devops.h>
40 #include <sys/time.h>
41 #include <sys/cmn_err.h>
42 #include <sys/ddidevmap.h>
43 #include <sys/ddi_impldefs.h>
44 #include <sys/ddi_implfuncs.h>
45 #include <sys/ddi_isa.h>
46 #include <sys/model.h>
47 #include <sys/devctl.h>
48 #if defined(__i386) || defined(__amd64)
49 #include <sys/dma_engine.h>
50 #endif
51 #include <sys/sunpm.h>
52 #include <sys/nvpair.h>
53 #include <sys/sysevent.h>
54 #include <sys/thread.h>
55 #include <sys/stream.h>
56 #if defined(__GNUC__) && defined(_ASM_INLINES) && defined(_KERNEL)
57 #include <asm/sunddi.h>
58 #endif
59 #ifdef _KERNEL
60 #include <sys/ddi_obsolete.h>
61 #endif
62 #include <sys/u8_textprep.h>
63 #include <sys/kiconv.h>
64 
65 #ifdef	__cplusplus
66 extern "C" {
67 #endif
68 
69 /*
70  * Generic Sun DDI definitions.
71  */
72 
73 #define	DDI_SUCCESS	(0)	/* successful return */
74 #define	DDI_FAILURE	(-1)	/* unsuccessful return */
75 #define	DDI_NOT_WELL_FORMED (-2)  /* A dev_info node is not valid */
76 #define	DDI_EAGAIN	(-3)	/* not enough interrupt resources */
77 #define	DDI_EINVAL	(-4)	/* invalid request or arguments */
78 #define	DDI_ENOTSUP	(-5)	/* operation is not supported */
79 #define	DDI_EPENDING	(-6)	/* operation or an event is pending */
80 #define	DDI_EALREADY	(-7)	/* operation already in progress */
81 
82 /*
83  * General-purpose DDI error return value definitions
84  */
85 #define	DDI_ENOMEM		1	/* memory not available */
86 #define	DDI_EBUSY		2	/* busy */
87 #define	DDI_ETRANSPORT		3	/* transport down */
88 #define	DDI_ECONTEXT		4	/* context error */
89 
90 
91 /*
92  * General DDI sleep/nosleep allocation flags
93  */
94 #define	DDI_SLEEP	0
95 #define	DDI_NOSLEEP	1
96 
97 /*
98  * The following special nodeid values are reserved for use when creating
99  * nodes ONLY.  They specify the attributes of the DDI_NC_PSEUDO class node
100  * being created:
101  *
102  *  o	DEVI_PSEUDO_NODEID specifics a node without persistence.
103  *  o	DEVI_SID_NODEID specifies a node with persistence.
104  *  o	DEVI_SID_HIDDEN_NODEID specifies a hidden node with persistence.
105  *
106  * A node with the 'hidden' attribute will not show up in devinfo snapshots
107  * or in /devices file system.
108  *
109  * A node with the 'persistent' attribute will not be automatically removed by
110  * the framework in the current implementation - driver.conf nodes are without
111  * persistence.
112  *
113  * The actual nodeid value may be assigned by the framework and may be
114  * different than these special values. Drivers may not make assumptions
115  * about the nodeid value that is actually assigned to the node.
116  */
117 
118 #define	DEVI_PSEUDO_NODEID	((int)-1)
119 #define	DEVI_SID_NODEID		((int)-2)
120 #define	DEVI_SID_HIDDEN_NODEID	((int)-3)
121 #define	DEVI_SID_HP_NODEID	((int)-4)
122 #define	DEVI_SID_HP_HIDDEN_NODEID ((int)-5)
123 
124 #define	DEVI_PSEUDO_NEXNAME	"pseudo"
125 #define	DEVI_ISA_NEXNAME	"isa"
126 #define	DEVI_EISA_NEXNAME	"eisa"
127 
128 /*
129  * ddi_create_minor_node flags
130  */
131 #define	CLONE_DEV		1	/* device is a clone device */
132 #define	PRIVONLY_DEV		0x10	/* policy-based permissions only */
133 
134 /*
135  * Historical values used for the flag field in ddi_create_minor_node.
136  * Future use of flag bits should avoid these fields to keep binary
137  * compatibility
138  * #define	GLOBAL_DEV		0x2
139  * #define	NODEBOUND_DEV		0x4
140  * #define	NODESPECIFIC_DEV	0x6
141  * #define	ENUMERATED_DEV		0x8
142  */
143 
144 /*
145  * Device type defines which are used by the 'node_type' element of the
146  * ddi_minor_data structure
147  */
148 #define	DDI_NT_SERIAL	"ddi_serial"		/* Serial port */
149 #define	DDI_NT_SERIAL_MB "ddi_serial:mb"	/* the 'built-in' serial */
150 						/* ports (the old ttya, b */
151 						/* (,c ,d)) */
152 #define	DDI_NT_SERIAL_DO "ddi_serial:dialout"	/* dialout ports */
153 #define	DDI_NT_SERIAL_MB_DO "ddi_serial:dialout,mb" /* dialout for onboard */
154 						/* ports */
155 #define	DDI_NT_SERIAL_LOMCON "ddi_serial:lomcon" /* LOMlite2 console port */
156 
157 /*
158  * *_CHAN disk type devices have channel numbers or target numbers.
159  * (i.e. ipi and scsi devices)
160  */
161 #define	DDI_NT_BLOCK	"ddi_block"		/* hard disks */
162 /*
163  * The next define is for block type devices that can possible exist on
164  * a sub-bus like the scsi bus or the ipi channel.  The 'disks' program
165  * will pick up on this and create logical names like c0t0d0s0 instead of
166  * c0d0s0
167  */
168 #define	DDI_NT_BLOCK_CHAN	"ddi_block:channel"
169 #define	DDI_NT_BLOCK_WWN	"ddi_block:wwn"
170 #define	DDI_NT_CD	"ddi_block:cdrom"	/* rom drives (cd-rom) */
171 #define	DDI_NT_CD_CHAN	"ddi_block:cdrom:channel" /* rom drives (scsi type) */
172 #define	DDI_NT_FD	"ddi_block:diskette"	/* floppy disks */
173 
174 #define	DDI_NT_ENCLOSURE	"ddi_enclosure"
175 #define	DDI_NT_SCSI_ENCLOSURE	"ddi_enclosure:scsi"
176 
177 #define	DDI_NT_BLOCK_SAS	"ddi_block:sas"
178 #define	DDI_NT_BLOCK_BLKDEV	"ddi_block:blkdev"
179 
180 /*
181  * xVM virtual block devices
182  */
183 #define	DDI_NT_BLOCK_XVMD	"ddi_block:xvmd"
184 #define	DDI_NT_CD_XVMD		"ddi_block:cdrom:xvmd"
185 
186 
187 #define	DDI_NT_TAPE	"ddi_byte:tape"		/* tape drives */
188 
189 #define	DDI_NT_NET	"ddi_network"		/* DLPI network devices */
190 
191 #define	DDI_NT_NET_WIFI	"ddi_network:wifi"	/* wifi devices */
192 
193 #define	DDI_NT_DISPLAY	"ddi_display"		/* display devices */
194 
195 #define	DDI_NT_DISPLAY_DRM	"ddi_display:drm" /* drm display devices */
196 
197 #define	DDI_PSEUDO	"ddi_pseudo"		/* general pseudo devices */
198 
199 #define	DDI_NT_AUDIO	"ddi_audio"		/* audio device */
200 
201 #define	DDI_NT_MOUSE	"ddi_mouse"		/* mouse device */
202 
203 #define	DDI_NT_KEYBOARD	"ddi_keyboard"		/* keyboard device */
204 
205 #define	DDI_NT_PARALLEL "ddi_parallel"		/* parallel port */
206 
207 #define	DDI_NT_PRINTER	"ddi_printer"		/* printer device */
208 
209 #define	DDI_NT_UGEN	"ddi_generic:usb"	/* USB generic drv */
210 
211 #define	DDI_NT_SMP	"ddi_sas_smp" 		/* smp devcies */
212 
213 #define	DDI_NT_NEXUS	"ddi_ctl:devctl"	/* nexus drivers */
214 
215 #define	DDI_NT_NVME_NEXUS	"ddi_ctl:devctl:nvme"	/* nexus drivers */
216 
217 #define	DDI_NT_SCSI_NEXUS	"ddi_ctl:devctl:scsi"	/* nexus drivers */
218 
219 #define	DDI_NT_SATA_NEXUS	"ddi_ctl:devctl:sata"	/* nexus drivers */
220 
221 #define	DDI_NT_IB_NEXUS		"ddi_ctl:devctl:ib"	/* nexus drivers */
222 
223 #define	DDI_NT_ATTACHMENT_POINT	"ddi_ctl:attachment_point" /* attachment pt */
224 
225 #define	DDI_NT_NVME_ATTACHMENT_POINT	"ddi_ctl:attachment_point:nvme"
226 						/* nvme attachment pt */
227 
228 #define	DDI_NT_SCSI_ATTACHMENT_POINT	"ddi_ctl:attachment_point:scsi"
229 						/* scsi attachment pt */
230 
231 #define	DDI_NT_SATA_ATTACHMENT_POINT	"ddi_ctl:attachment_point:sata"
232 						/* sata attachment pt */
233 
234 #define	DDI_NT_SDCARD_ATTACHMENT_POINT	"ddi_ctl:attachment_point:sdcard"
235 						/* sdcard attachment pt */
236 
237 #define	DDI_NT_PCI_ATTACHMENT_POINT	"ddi_ctl:attachment_point:pci"
238 						/* PCI attachment pt */
239 #define	DDI_NT_SBD_ATTACHMENT_POINT	"ddi_ctl:attachment_point:sbd"
240 						/* generic bd attachment pt */
241 #define	DDI_NT_FC_ATTACHMENT_POINT	"ddi_ctl:attachment_point:fc"
242 						/* FC attachment pt */
243 #define	DDI_NT_USB_ATTACHMENT_POINT	"ddi_ctl:attachment_point:usb"
244 						/* USB devices */
245 #define	DDI_NT_BLOCK_FABRIC		"ddi_block:fabric"
246 						/* Fabric Devices */
247 #define	DDI_NT_IB_ATTACHMENT_POINT	"ddi_ctl:attachment_point:ib"
248 						/* IB devices */
249 
250 #define	DDI_NT_AV_ASYNC "ddi_av:async"		/* asynchronous AV device */
251 #define	DDI_NT_AV_ISOCH "ddi_av:isoch"		/* isochronous AV device */
252 
253 /* Device types used for agpgart driver related devices */
254 #define	DDI_NT_AGP_PSEUDO	"ddi_agp:pseudo" /* agpgart pseudo device */
255 #define	DDI_NT_AGP_MASTER	"ddi_agp:master" /* agp master device */
256 #define	DDI_NT_AGP_TARGET	"ddi_agp:target" /* agp target device */
257 #define	DDI_NT_AGP_CPUGART	"ddi_agp:cpugart" /* amd64 on-cpu gart device */
258 
259 #define	DDI_NT_REGACC		"ddi_tool_reg"	/* tool register access */
260 #define	DDI_NT_INTRCTL		"ddi_tool_intr"	/* tool intr access */
261 
262 /*
263  * DDI event definitions
264  */
265 #define	EC_DEVFS	"EC_devfs"	/* Event class devfs */
266 #define	EC_DDI		"EC_ddi"	/* Event class ddi */
267 
268 /* Class devfs subclasses */
269 #define	ESC_DEVFS_MINOR_CREATE	"ESC_devfs_minor_create"
270 #define	ESC_DEVFS_MINOR_REMOVE	"ESC_devfs_minor_remove"
271 #define	ESC_DEVFS_DEVI_ADD	"ESC_devfs_devi_add"
272 #define	ESC_DEVFS_DEVI_REMOVE	"ESC_devfs_devi_remove"
273 #define	ESC_DEVFS_INSTANCE_MOD	"ESC_devfs_instance_mod"
274 #define	ESC_DEVFS_BRANCH_ADD	"ESC_devfs_branch_add"
275 #define	ESC_DEVFS_BRANCH_REMOVE	"ESC_devfs_branch_remove"
276 #define	ESC_DEVFS_START		"ESC_devfs_start"
277 
278 /* Class ddi subclasses */
279 #define	ESC_DDI_INITIATOR_REGISTER	"ESC_ddi_initiator_register"
280 #define	ESC_DDI_INITIATOR_UNREGISTER	"ESC_ddi_initiator_unregister"
281 
282 /* DDI/NDI event publisher */
283 #define	EP_DDI	SUNW_KERN_PUB"ddi"
284 
285 /*
286  * devfs event class attributes
287  *
288  * The following attributes are private to EC_DEVFS event data.
289  */
290 #define	DEVFS_DRIVER_NAME	"di.driver"
291 #define	DEVFS_INSTANCE		"di.instance"
292 #define	DEVFS_PATHNAME		"di.path"
293 #define	DEVFS_DEVI_CLASS	"di.devi_class"
294 #define	DEVFS_BRANCH_EVENT	"di.branch_event"
295 #define	DEVFS_MINOR_NAME	"mi.name"
296 #define	DEVFS_MINOR_NODETYPE	"mi.nodetype"
297 #define	DEVFS_MINOR_ISCLONE	"mi.isclone"
298 #define	DEVFS_MINOR_MAJNUM	"mi.majorno"
299 #define	DEVFS_MINOR_MINORNUM	"mi.minorno"
300 
301 /*
302  * ddi event class payload
303  *
304  * The following attributes are private to EC_DDI event data.
305  */
306 #define	DDI_DRIVER_NAME		"ddi.driver"
307 #define	DDI_DRIVER_MAJOR	"ddi.major"
308 #define	DDI_INSTANCE		"ddi.instance"
309 #define	DDI_PATHNAME		"ddi.path"
310 #define	DDI_CLASS		"ddi.class"
311 
312 /*
313  * Fault-related definitions
314  *
315  * The specific numeric values have been chosen to be ordered, but
316  * not consecutive, to allow for future interpolation if required.
317  */
318 typedef enum {
319     DDI_SERVICE_LOST = -32,
320     DDI_SERVICE_DEGRADED = -16,
321     DDI_SERVICE_UNAFFECTED = 0,
322     DDI_SERVICE_RESTORED = 16
323 } ddi_fault_impact_t;
324 
325 typedef enum {
326     DDI_DATAPATH_FAULT = -32,
327     DDI_DEVICE_FAULT = -16,
328     DDI_EXTERNAL_FAULT = 0
329 } ddi_fault_location_t;
330 
331 typedef enum {
332     DDI_DEVSTATE_OFFLINE = -32,
333     DDI_DEVSTATE_DOWN = -16,
334     DDI_DEVSTATE_QUIESCED = 0,
335     DDI_DEVSTATE_DEGRADED = 16,
336     DDI_DEVSTATE_UP = 32
337 } ddi_devstate_t;
338 
339 #if defined(_KERNEL) || defined(_FAKE_KERNEL)
340 
341 /*
342  * Common property definitions
343  */
344 #define	DDI_FORCEATTACH		"ddi-forceattach"
345 #define	DDI_NO_AUTODETACH	"ddi-no-autodetach"
346 #define	DDI_VHCI_CLASS		"ddi-vhci-class"
347 #define	DDI_NO_ROOT_SUPPORT	"ddi-no-root-support"
348 #define	DDI_OPEN_RETURNS_EINTR	"ddi-open-returns-eintr"
349 #define	DDI_DEVID_REGISTRANT	"ddi-devid-registrant"
350 
351 /*
352  * Values that the function supplied to the dev_info
353  * tree traversal functions defined below must return.
354  */
355 
356 /*
357  * Continue search, if appropriate.
358  */
359 #define	DDI_WALK_CONTINUE	0
360 
361 /*
362  * Terminate current depth of traversal. That is, terminate
363  * the current traversal of children nodes, but continue
364  * traversing sibling nodes and their children (if any).
365  */
366 
367 #define	DDI_WALK_PRUNECHILD	-1
368 
369 /*
370  * Terminate current width of traversal. That is, terminate
371  * the current traversal of sibling nodes, but continue with
372  * traversing children nodes and their siblings (if appropriate).
373  */
374 
375 #define	DDI_WALK_PRUNESIB	-2
376 
377 /*
378  * Terminate the entire search.
379  */
380 
381 #define	DDI_WALK_TERMINATE	-3
382 
383 /*
384  * Terminate the entire search because an error occurred in function
385  */
386 #define	DDI_WALK_ERROR		-4
387 
388 /*
389  * Drivers that are prepared to support full driver layering
390  * should create and export a null-valued property of the following
391  * name.
392  *
393  * Such drivers should be prepared to be called with FKLYR in
394  * the 'flag' argument of their open(9E), close(9E) routines, and
395  * with FKIOCTL in the 'mode' argument of their ioctl(9E) routines.
396  *
397  * See ioctl(9E) and ddi_copyin(9F) for details.
398  */
399 #define	DDI_KERNEL_IOCTL	"ddi-kernel-ioctl"
400 
401 /*
402  * Model definitions for ddi_mmap_get_model(9F) and ddi_model_convert_from(9F).
403  */
404 #define	DDI_MODEL_MASK		DATAMODEL_MASK	/* Note: 0x0FF00000 */
405 #define	DDI_MODEL_ILP32		DATAMODEL_ILP32
406 #define	DDI_MODEL_LP64		DATAMODEL_LP64
407 #define	DDI_MODEL_NATIVE	DATAMODEL_NATIVE
408 #define	DDI_MODEL_NONE		DATAMODEL_NONE
409 
410 /* if set to B_TRUE is DER_MODE is equivalent to DERE_PANIC */
411 extern boolean_t ddi_err_panic;
412 
413 /*
414  * Defines for ddi_err().
415  */
416 typedef enum {
417 	DER_INVALID = 0,	/* must be 0 */
418 	DER_CONT = 1,
419 	DER_CONS,
420 	DER_LOG,
421 	DER_VERB,
422 	DER_NOTE,
423 	DER_WARN,
424 	DER_PANIC,
425 	DER_MODE,
426 	DER_DEBUG
427 } ddi_err_t;
428 
429 extern void ddi_err(ddi_err_t de, dev_info_t *rdip, const char *fmt, ...);
430 
431 
432 extern char *ddi_strdup(const char *str, int flag);
433 extern char *strdup(const char *str);
434 extern void strfree(char *str);
435 
436 /*
437  * Functions and data references which really should be in <sys/ddi.h>
438  */
439 
440 extern int maxphys;
441 extern void minphys(struct buf *);
442 extern int physio(int (*)(struct buf *), struct buf *, dev_t,
443 	int, void (*)(struct buf *), struct uio *);
444 extern void disksort(struct diskhd *, struct buf *);
445 
446 extern size_t strlen(const char *) __PURE;
447 extern size_t strnlen(const char *, size_t) __PURE;
448 extern char *strcpy(char *, const char *);
449 extern char *strncpy(char *, const char *, size_t);
450 /* Need to be consistent with <string.h> C++ definition for strchr() */
451 #if __cplusplus >= 199711L
452 extern const char *strchr(const char *, int);
453 #ifndef	_STRCHR_INLINE
454 #define	_STRCHR_INLINE
455 extern	"C++" {
strchr(char * __s,int __c)456 	inline char *strchr(char *__s, int __c) {
457 		return (char *)strchr((const char *)__s, __c);
458 	}
459 }
460 #endif	/* _STRCHR_INLINE */
461 #else
462 extern char *strchr(const char *, int);
463 #endif	/* __cplusplus >= 199711L */
464 #define	DDI_STRSAME(s1, s2)	((*(s1) == *(s2)) && (strcmp((s1), (s2)) == 0))
465 extern int strcmp(const char *, const char *) __PURE;
466 extern int strncmp(const char *, const char *, size_t) __PURE;
467 extern char *strncat(char *, const char *, size_t);
468 extern size_t strlcat(char *, const char *, size_t);
469 extern size_t strlcpy(char *, const char *, size_t);
470 extern size_t strspn(const char *, const char *);
471 extern size_t strcspn(const char *, const char *);
472 extern char *strsep(char **, const char *);
473 extern int bcmp(const void *, const void *, size_t) __PURE;
474 extern int stoi(char **);
475 extern void numtos(ulong_t, char *);
476 extern void bcopy(const void *, void *, size_t);
477 extern void bzero(void *, size_t);
478 
479 extern void *memcpy(void *, const  void  *, size_t);
480 extern void *memset(void *, int, size_t);
481 extern void *memmove(void *, const void *, size_t);
482 extern int memcmp(const void *, const void *, size_t) __PURE;
483 /* Need to be consistent with <string.h> C++ definition for memchr() */
484 #if __cplusplus >= 199711L
485 extern const void *memchr(const void *, int, size_t);
486 #ifndef	_MEMCHR_INLINE
487 #define	_MEMCHR_INLINE
488 extern "C++" {
memchr(void * __s,int __c,size_t __n)489 	inline void *memchr(void * __s, int __c, size_t __n) {
490 		return (void *)memchr((const void *)__s, __c, __n);
491 	}
492 }
493 #endif  /* _MEMCHR_INLINE */
494 #else
495 extern void *memchr(const void *, int, size_t);
496 #endif /* __cplusplus >= 199711L */
497 
498 extern int ddi_strtol(const char *, char **, int, long *);
499 extern int ddi_strtoul(const char *, char **, int, unsigned long *);
500 extern int ddi_strtoll(const char *, char **, int, longlong_t *);
501 extern int ddi_strtoull(const char *, char **, int, u_longlong_t *);
502 
503 /*
504  * kiconv functions and their macros.
505  */
506 #define	KICONV_IGNORE_NULL	(0x0001)
507 #define	KICONV_REPLACE_INVALID	(0x0002)
508 
509 extern kiconv_t kiconv_open(const char *, const char *);
510 extern size_t kiconv(kiconv_t, char **, size_t *, char **, size_t *, int *);
511 extern int kiconv_close(kiconv_t);
512 extern size_t kiconvstr(const char *, const char *, char *, size_t *, char *,
513     size_t *, int, int *);
514 
515 #endif /* _KERNEL || _FAKE_KERNEL */
516 #ifdef	_KERNEL
517 
518 /*
519  * ddi_map_regs
520  *
521  *	Map in the register set given by rnumber.
522  *	The register number determine which register
523  *	set will be mapped if more than one exists.
524  *	The parent driver gets the information
525  *	from parent private data and sets up the
526  *	appropriate mappings and returns the kernel
527  *	virtual address of the register set in *kaddrp.
528  *	The offset specifies an offset into the register
529  *	space to start from and len indicates the size
530  *	of the area to map. If len and offset are 0 then
531  *	the entire space is mapped.  It returns DDI_SUCCESS on
532  *	success or DDI_FAILURE otherwise.
533  *
534  */
535 int
536 ddi_map_regs(dev_info_t *dip, uint_t rnumber, caddr_t *kaddrp,
537     off_t offset, off_t len);
538 
539 /*
540  * ddi_unmap_regs
541  *
542  *	Undo mappings set up by ddi_map_regs.
543  *	The register number determines which register
544  *	set will be unmapped if more than one exists.
545  *	This is provided for drivers preparing
546  *	to detach themselves from the system to
547  *	allow them to release allocated mappings.
548  *
549  *	The kaddrp and len specify the area to be
550  *	unmapped. *kaddrp was returned from ddi_map_regs
551  *	and len should match what ddi_map_regs was called
552  *	with.
553  */
554 
555 void
556 ddi_unmap_regs(dev_info_t *dip, uint_t rnumber, caddr_t *kaddrp,
557     off_t offset, off_t len);
558 
559 int
560 ddi_map(dev_info_t *dp, ddi_map_req_t *mp, off_t offset, off_t len,
561     caddr_t *addrp);
562 
563 int
564 ddi_apply_range(dev_info_t *dip, dev_info_t *rdip, struct regspec *rp);
565 
566 /*
567  * ddi_rnumber_to_regspec: Not for use by leaf drivers.
568  */
569 struct regspec *
570 ddi_rnumber_to_regspec(dev_info_t *dip, int rnumber);
571 
572 int
573 ddi_bus_map(dev_info_t *dip, dev_info_t *rdip, ddi_map_req_t *mp, off_t offset,
574     off_t len, caddr_t *vaddrp);
575 
576 int
577 nullbusmap(dev_info_t *dip, dev_info_t *rdip, ddi_map_req_t *mp, off_t offset,
578     off_t len, caddr_t *vaddrp);
579 
580 int ddi_peek8(dev_info_t *dip, int8_t *addr, int8_t *val_p);
581 int ddi_peek16(dev_info_t *dip, int16_t *addr, int16_t *val_p);
582 int ddi_peek32(dev_info_t *dip, int32_t *addr, int32_t *val_p);
583 int ddi_peek64(dev_info_t *dip, int64_t *addr, int64_t *val_p);
584 
585 int ddi_poke8(dev_info_t *dip, int8_t *addr, int8_t val);
586 int ddi_poke16(dev_info_t *dip, int16_t *addr, int16_t val);
587 int ddi_poke32(dev_info_t *dip, int32_t *addr, int32_t val);
588 int ddi_poke64(dev_info_t *dip, int64_t *addr, int64_t val);
589 
590 /*
591  * Peek and poke to and from a uio structure in xfersize pieces,
592  * using the parent nexi.
593  */
594 int ddi_peekpokeio(dev_info_t *devi, struct uio *uio, enum uio_rw rw,
595     caddr_t addr, size_t len, uint_t xfersize);
596 
597 /*
598  * Pagesize conversions using the parent nexi
599  */
600 unsigned long ddi_btop(dev_info_t *dip, unsigned long bytes);
601 unsigned long ddi_btopr(dev_info_t *dip, unsigned long bytes);
602 unsigned long ddi_ptob(dev_info_t *dip, unsigned long pages);
603 
604 /*
605  * There are no more "block" interrupt functions, per se.
606  * All thread of control should be done with MP/MT lockings.
607  *
608  * However, there are certain times in which a driver needs
609  * absolutely a critical guaranteed non-preemptable time
610  * in which to execute a few instructions.
611  *
612  * The following pair of functions attempt to guarantee this,
613  * but they are dangerous to use. That is, use them with
614  * extreme care. They do not guarantee to stop other processors
615  * from executing, but they do guarantee that the caller
616  * of ddi_enter_critical will continue to run until the
617  * caller calls ddi_exit_critical. No intervening DDI functions
618  * may be called between an entry and an exit from a critical
619  * region.
620  *
621  * ddi_enter_critical returns an integer identifier which must
622  * be passed to ddi_exit_critical.
623  *
624  * Be very sparing in the use of these functions since it is
625  * likely that absolutely nothing else can occur in the system
626  * whilst in the critical region.
627  */
628 
629 unsigned int
630 ddi_enter_critical(void);
631 
632 void
633 ddi_exit_critical(unsigned int);
634 
635 /*
636  * devmap functions
637  */
638 int
639 devmap_setup(dev_t dev, offset_t off, ddi_as_handle_t as, caddr_t *addrp,
640     size_t len, uint_t prot, uint_t maxprot, uint_t flags, struct cred *cred);
641 
642 int
643 ddi_devmap_segmap(dev_t dev, off_t off, ddi_as_handle_t as, caddr_t *addrp,
644     off_t len, uint_t prot, uint_t maxprot, uint_t flags, struct cred *cred);
645 
646 int
647 devmap_load(devmap_cookie_t dhp, offset_t offset, size_t len, uint_t type,
648     uint_t rw);
649 
650 int
651 devmap_unload(devmap_cookie_t dhp, offset_t offset, size_t len);
652 
653 int
654 devmap_devmem_setup(devmap_cookie_t dhp, dev_info_t *dip,
655     struct devmap_callback_ctl *callback_ops,
656     uint_t rnumber, offset_t roff, size_t len, uint_t maxprot,
657     uint_t flags, ddi_device_acc_attr_t *accattrp);
658 
659 int
660 devmap_umem_setup(devmap_cookie_t dhp, dev_info_t *dip,
661     struct devmap_callback_ctl *callback_ops,
662     ddi_umem_cookie_t cookie, offset_t off, size_t len, uint_t maxprot,
663     uint_t flags, ddi_device_acc_attr_t *accattrp);
664 
665 int
666 devmap_devmem_remap(devmap_cookie_t dhp, dev_info_t *dip,
667     uint_t rnumber, offset_t roff, size_t len, uint_t maxprot,
668     uint_t flags, ddi_device_acc_attr_t *accattrp);
669 
670 int
671 devmap_umem_remap(devmap_cookie_t dhp, dev_info_t *dip,
672     ddi_umem_cookie_t cookie, offset_t off, size_t len, uint_t maxprot,
673     uint_t flags, ddi_device_acc_attr_t *accattrp);
674 
675 void
676 devmap_set_ctx_timeout(devmap_cookie_t dhp, clock_t ticks);
677 
678 int
679 devmap_default_access(devmap_cookie_t dhp, void *pvtp, offset_t off,
680     size_t len, uint_t type, uint_t rw);
681 
682 int
683 devmap_do_ctxmgt(devmap_cookie_t dhp, void *pvtp, offset_t off, size_t len,
684     uint_t type, uint_t rw, int (*ctxmgt)(devmap_cookie_t, void *, offset_t,
685     size_t, uint_t, uint_t));
686 
687 
688 void *ddi_umem_alloc(size_t size, int flag, ddi_umem_cookie_t *cookiep);
689 
690 void ddi_umem_free(ddi_umem_cookie_t cookie);
691 
692 /*
693  * Functions to lock user memory and do repeated I/O or do devmap_umem_setup
694  */
695 int
696 ddi_umem_lock(caddr_t addr, size_t size, int flags, ddi_umem_cookie_t *cookie);
697 
698 void
699 ddi_umem_unlock(ddi_umem_cookie_t cookie);
700 
701 struct buf *
702 ddi_umem_iosetup(ddi_umem_cookie_t cookie, off_t off, size_t len, int direction,
703     dev_t dev, daddr_t blkno, int (*iodone)(struct buf *), int sleepflag);
704 
705 /*
706  * Mapping functions
707  */
708 int
709 ddi_segmap(dev_t dev, off_t offset, struct as *asp, caddr_t *addrp, off_t len,
710     uint_t prot, uint_t maxprot, uint_t flags, cred_t *credp);
711 
712 int
713 ddi_segmap_setup(dev_t dev, off_t offset, struct as *as, caddr_t *addrp,
714     off_t len, uint_t prot, uint_t maxprot, uint_t flags, cred_t *cred,
715     ddi_device_acc_attr_t *accattrp, uint_t rnumber);
716 
717 int
718 ddi_map_fault(dev_info_t *dip, struct hat *hat, struct seg *seg, caddr_t addr,
719     struct devpage *dp, pfn_t pfn, uint_t prot, uint_t lock);
720 
721 int
722 ddi_device_mapping_check(dev_t dev, ddi_device_acc_attr_t *accattrp,
723     uint_t rnumber, uint_t *hat_flags);
724 
725 /*
726  * Property functions:   See also, ddipropdefs.h.
727  *			In general, the underlying driver MUST be held
728  *			to call it's property functions.
729  */
730 
731 /*
732  * Used to create, modify, and lookup integer properties
733  */
734 int ddi_prop_get_int(dev_t match_dev, dev_info_t *dip, uint_t flags,
735     char *name, int defvalue);
736 int64_t ddi_prop_get_int64(dev_t match_dev, dev_info_t *dip, uint_t flags,
737     char *name, int64_t defvalue);
738 int ddi_prop_lookup_int_array(dev_t match_dev, dev_info_t *dip, uint_t flags,
739     char *name, int **data, uint_t *nelements);
740 int ddi_prop_lookup_int64_array(dev_t match_dev, dev_info_t *dip, uint_t flags,
741     char *name, int64_t **data, uint_t *nelements);
742 int ddi_prop_update_int(dev_t match_dev, dev_info_t *dip,
743     char *name, int data);
744 int ddi_prop_update_int64(dev_t match_dev, dev_info_t *dip,
745     char *name, int64_t data);
746 int ddi_prop_update_int_array(dev_t match_dev, dev_info_t *dip,
747     char *name, int *data, uint_t nelements);
748 int ddi_prop_update_int64_array(dev_t match_dev, dev_info_t *dip,
749     char *name, int64_t *data, uint_t nelements);
750 /*
751  * Used to create, modify, and lookup string properties
752  */
753 int ddi_prop_lookup_string(dev_t match_dev, dev_info_t *dip, uint_t flags,
754     char *name, char **data);
755 int ddi_prop_lookup_string_array(dev_t match_dev, dev_info_t *dip, uint_t flags,
756     char *name, char ***data, uint_t *nelements);
757 int ddi_prop_update_string(dev_t match_dev, dev_info_t *dip,
758     char *name, char *data);
759 int ddi_prop_update_string_array(dev_t match_dev, dev_info_t *dip,
760     char *name, char **data, uint_t nelements);
761 
762 /*
763  * Used to create, modify, and lookup byte properties
764  */
765 int ddi_prop_lookup_byte_array(dev_t match_dev, dev_info_t *dip, uint_t flags,
766     char *name, uchar_t **data, uint_t *nelements);
767 int ddi_prop_update_byte_array(dev_t match_dev, dev_info_t *dip,
768     char *name, uchar_t *data, uint_t nelements);
769 
770 /*
771  * Used to verify the existence of a property or to see if a boolean
772  * property exists.
773  */
774 int ddi_prop_exists(dev_t match_dev, dev_info_t *dip, uint_t flags, char *name);
775 
776 /*
777  * Used to free the data returned by the above property routines.
778  */
779 void ddi_prop_free(void *data);
780 
781 /*
782  * nopropop: For internal use in `dummy' cb_prop_op functions only
783  */
784 
785 int
786 nopropop(dev_t dev, dev_info_t *dip, ddi_prop_op_t prop_op, int mod_flags,
787     char *name, caddr_t valuep, int *lengthp);
788 
789 /*
790  * ddi_prop_op: The basic property operator for drivers.
791  *
792  * In ddi_prop_op, the type of valuep is interpreted based on prop_op:
793  *
794  *	prop_op			valuep
795  *	------			------
796  *
797  *	PROP_LEN		<unused>
798  *
799  *	PROP_LEN_AND_VAL_BUF	Pointer to callers buffer
800  *
801  *	PROP_LEN_AND_VAL_ALLOC	Address of callers pointer (will be set to
802  *				address of allocated buffer, if successful)
803  */
804 
805 int
806 ddi_prop_op(dev_t dev, dev_info_t *dip, ddi_prop_op_t prop_op, int mod_flags,
807     char *name, caddr_t valuep, int *lengthp);
808 
809 /* ddi_prop_op_size: for drivers that implement size in bytes */
810 int
811 ddi_prop_op_size(dev_t dev, dev_info_t *dip, ddi_prop_op_t prop_op,
812     int mod_flags, char *name, caddr_t valuep, int *lengthp,
813     uint64_t size64);
814 
815 /* ddi_prop_op_size_blksize: like ddi_prop_op_size, in blksize blocks */
816 int
817 ddi_prop_op_size_blksize(dev_t dev, dev_info_t *dip, ddi_prop_op_t prop_op,
818     int mod_flags, char *name, caddr_t valuep, int *lengthp,
819     uint64_t size64, uint_t blksize);
820 
821 /* ddi_prop_op_nblocks: for drivers that implement size in DEV_BSIZE blocks */
822 int
823 ddi_prop_op_nblocks(dev_t dev, dev_info_t *dip, ddi_prop_op_t prop_op,
824     int mod_flags, char *name, caddr_t valuep, int *lengthp,
825     uint64_t nblocks64);
826 
827 /* ddi_prop_op_nblocks_blksize: like ddi_prop_op_nblocks, in blksize blocks */
828 int
829 ddi_prop_op_nblocks_blksize(dev_t dev, dev_info_t *dip, ddi_prop_op_t prop_op,
830     int mod_flags, char *name, caddr_t valuep, int *lengthp,
831     uint64_t nblocks64, uint_t blksize);
832 
833 /*
834  * Variable length props...
835  */
836 
837 /*
838  * ddi_getlongprop:	Get variable length property len+val into a buffer
839  *		allocated by property provider via kmem_alloc. Requester
840  *		is responsible for freeing returned property via kmem_free.
841  *
842  * 	Arguments:
843  *
844  *	dev:	Input:	dev_t of property.
845  *	dip:	Input:	dev_info_t pointer of child.
846  *	flags:	Input:	Possible flag modifiers are:
847  *		DDI_PROP_DONTPASS:	Don't pass to parent if prop not found.
848  *		DDI_PROP_CANSLEEP:	Memory allocation may sleep.
849  *	name:	Input:	name of property.
850  *	valuep:	Output:	Addr of callers buffer pointer.
851  *	lengthp:Output:	*lengthp will contain prop length on exit.
852  *
853  * 	Possible Returns:
854  *
855  *		DDI_PROP_SUCCESS:	Prop found and returned.
856  *		DDI_PROP_NOT_FOUND:	Prop not found
857  *		DDI_PROP_UNDEFINED:	Prop explicitly undefined.
858  *		DDI_PROP_NO_MEMORY:	Prop found, but unable to alloc mem.
859  */
860 
861 int
862 ddi_getlongprop(dev_t dev, dev_info_t *dip, int flags,
863     char *name, caddr_t valuep, int *lengthp);
864 
865 /*
866  *
867  * ddi_getlongprop_buf:		Get long prop into pre-allocated callers
868  *				buffer. (no memory allocation by provider).
869  *
870  *	dev:	Input:	dev_t of property.
871  *	dip:	Input:	dev_info_t pointer of child.
872  *	flags:	Input:	DDI_PROP_DONTPASS or NULL
873  *	name:	Input:	name of property
874  *	valuep:	Input:	ptr to callers buffer.
875  *	lengthp:I/O:	ptr to length of callers buffer on entry,
876  *			actual length of property on exit.
877  *
878  *	Possible returns:
879  *
880  *		DDI_PROP_SUCCESS	Prop found and returned
881  *		DDI_PROP_NOT_FOUND	Prop not found
882  *		DDI_PROP_UNDEFINED	Prop explicitly undefined.
883  *		DDI_PROP_BUF_TOO_SMALL	Prop found, callers buf too small,
884  *					no value returned, but actual prop
885  *					length returned in *lengthp
886  *
887  */
888 
889 int
890 ddi_getlongprop_buf(dev_t dev, dev_info_t *dip, int flags,
891     char *name, caddr_t valuep, int *lengthp);
892 
893 /*
894  * Integer/boolean sized props.
895  *
896  * Call is value only... returns found boolean or int sized prop value or
897  * defvalue if prop not found or is wrong length or is explicitly undefined.
898  * Only flag is DDI_PROP_DONTPASS...
899  *
900  * By convention, this interface returns boolean (0) sized properties
901  * as value (int)1.
902  */
903 
904 int
905 ddi_getprop(dev_t dev, dev_info_t *dip, int flags, char *name, int defvalue);
906 
907 /*
908  * Get prop length interface: flags are 0 or DDI_PROP_DONTPASS
909  * if returns DDI_PROP_SUCCESS, length returned in *lengthp.
910  */
911 
912 int
913 ddi_getproplen(dev_t dev, dev_info_t *dip, int flags, char *name, int *lengthp);
914 
915 
916 /*
917  * Interface to create/modify a managed property on child's behalf...
918  * Only flag is DDI_PROP_CANSLEEP to allow memory allocation to sleep
919  * if no memory available for internal prop structure.  Long property
920  * (non integer sized) value references are not copied.
921  *
922  * Define property with DDI_DEV_T_NONE dev_t for properties not associated
923  * with any particular dev_t. Use the same dev_t when modifying or undefining
924  * a property.
925  *
926  * No guarantee on order of property search, so don't mix the same
927  * property name with wildcard and non-wildcard dev_t's.
928  */
929 
930 /*
931  * ddi_prop_create:	Define a managed property:
932  */
933 
934 int
935 ddi_prop_create(dev_t dev, dev_info_t *dip, int flag,
936     char *name, caddr_t value, int length);
937 
938 /*
939  * ddi_prop_modify:	Modify a managed property value
940  */
941 
942 int
943 ddi_prop_modify(dev_t dev, dev_info_t *dip, int flag,
944     char *name, caddr_t value, int length);
945 
946 /*
947  * ddi_prop_remove:	Undefine a managed property:
948  */
949 
950 int
951 ddi_prop_remove(dev_t dev, dev_info_t *dip, char *name);
952 
953 /*
954  * ddi_prop_remove_all:		Used before unloading a driver to remove
955  *				all properties. (undefines all dev_t's props.)
956  *				Also removes `undefined' prop defs.
957  */
958 
959 void
960 ddi_prop_remove_all(dev_info_t *dip);
961 
962 
963 /*
964  * ddi_prop_undefine:	Explicitly undefine a property.  Property
965  *			searches which match this property return
966  *			the error code DDI_PROP_UNDEFINED.
967  *
968  *			Use ddi_prop_remove to negate effect of
969  *			ddi_prop_undefine
970  */
971 
972 int
973 ddi_prop_undefine(dev_t dev, dev_info_t *dip, int flag, char *name);
974 
975 
976 /*
977  * ddi_prop_cache_invalidate
978  *			Invalidate a property in the current cached
979  *			devinfo snapshot - next cached snapshot will
980  *			return the latest property value available.
981  */
982 void
983 ddi_prop_cache_invalidate(dev_t dev, dev_info_t *dip, char *name, int flags);
984 
985 /*
986  * The default ddi_bus_prop_op wrapper...
987  */
988 
989 int
990 ddi_bus_prop_op(dev_t dev, dev_info_t *dip, dev_info_t *ch_dip,
991     ddi_prop_op_t prop_op, int mod_flags,
992     char *name, caddr_t valuep, int *lengthp);
993 
994 
995 /*
996  * Routines to traverse the tree of dev_info nodes.
997  * The general idea of these functions is to provide
998  * various tree traversal utilities. For each node
999  * that the tree traversal function finds, a caller
1000  * supplied function is called with arguments of
1001  * the current node and a caller supplied argument.
1002  * The caller supplied function should return one
1003  * of the integer values defined below which will
1004  * indicate to the tree traversal function whether
1005  * the traversal should be continued, and if so, how,
1006  * or whether the traversal should terminate.
1007  */
1008 
1009 /*
1010  * This general-purpose routine traverses the tree of dev_info nodes,
1011  * starting from the given node, and calls the given function for each
1012  * node that it finds with the current node and the pointer arg (which
1013  * can point to a structure of information that the function
1014  * needs) as arguments.
1015  *
1016  * It does the walk a layer at a time, not depth-first.
1017  *
1018  * The given function must return one of the values defined above.
1019  *
1020  */
1021 
1022 void
1023 ddi_walk_devs(dev_info_t *, int (*)(dev_info_t *, void *), void *);
1024 
1025 /*
1026  * Routines to get at elements of the dev_info structure
1027  */
1028 
1029 /*
1030  * ddi_node_name gets the device's 'name' from the device node.
1031  *
1032  * ddi_binding_name gets the string the OS used to bind the node to a driver,
1033  * in certain cases, the binding name may be different from the node name,
1034  * if the node name does not name a specific device driver.
1035  *
1036  * ddi_get_name is a synonym for ddi_binding_name().
1037  */
1038 char *
1039 ddi_get_name(dev_info_t *dip);
1040 
1041 char *
1042 ddi_binding_name(dev_info_t *dip);
1043 
1044 const char *
1045 ddi_driver_name(dev_info_t *dip);
1046 
1047 major_t
1048 ddi_driver_major(dev_info_t *dip);
1049 
1050 major_t
1051 ddi_compatible_driver_major(dev_info_t *dip, char **formp);
1052 
1053 char *
1054 ddi_node_name(dev_info_t *dip);
1055 
1056 int
1057 ddi_get_nodeid(dev_info_t *dip);
1058 
1059 int
1060 ddi_get_instance(dev_info_t *dip);
1061 
1062 struct dev_ops *
1063 ddi_get_driver(dev_info_t *dip);
1064 
1065 void
1066 ddi_set_driver(dev_info_t *dip, struct dev_ops *devo);
1067 
1068 void
1069 ddi_set_driver_private(dev_info_t *dip, void *data);
1070 
1071 void *
1072 ddi_get_driver_private(dev_info_t *dip);
1073 
1074 /*
1075  * ddi_dev_is_needed tells system that a device is about to use a
1076  * component. Returns when component is ready.
1077  */
1078 int
1079 ddi_dev_is_needed(dev_info_t *dip, int cmpt, int level);
1080 
1081 /*
1082  * check if DDI_SUSPEND may result in power being removed from a device.
1083  */
1084 int
1085 ddi_removing_power(dev_info_t *dip);
1086 
1087 /*
1088  *  (Obsolete) power entry point
1089  */
1090 int
1091 ddi_power(dev_info_t *dip, int cmpt, int level);
1092 
1093 /*
1094  * ddi_get_parent requires that the branch of the tree with the
1095  * node be held (ddi_hold_installed_driver) or that the devinfo tree
1096  * lock be held
1097  */
1098 dev_info_t *
1099 ddi_get_parent(dev_info_t *dip);
1100 
1101 /*
1102  * ddi_get_child and ddi_get_next_sibling require that the devinfo
1103  * tree lock be held
1104  */
1105 dev_info_t *
1106 ddi_get_child(dev_info_t *dip);
1107 
1108 dev_info_t *
1109 ddi_get_next_sibling(dev_info_t *dip);
1110 
1111 dev_info_t *
1112 ddi_get_next(dev_info_t *dip);
1113 
1114 void
1115 ddi_set_next(dev_info_t *dip, dev_info_t *nextdip);
1116 
1117 /*
1118  * dev_info manipulation functions
1119  */
1120 
1121 /*
1122  * Add and remove child devices. These are part of the system framework.
1123  *
1124  * ddi_add_child creates a dev_info structure with the passed name,
1125  * nodeid and instance arguments and makes it a child of pdip. Devices
1126  * that are known directly by the hardware have real nodeids; devices
1127  * that are software constructs use the defined DEVI_PSEUDO_NODEID
1128  * for the node id.
1129  *
1130  * ddi_remove_node removes the node from the tree. This fails if this
1131  * child has children. Parent and driver private data should already
1132  * be released (freed) prior to calling this function.  If flag is
1133  * non-zero, the child is removed from it's linked list of instances.
1134  */
1135 dev_info_t *
1136 ddi_add_child(dev_info_t *pdip, char *name, uint_t nodeid, uint_t instance);
1137 
1138 int
1139 ddi_remove_child(dev_info_t *dip, int flag);
1140 
1141 /*
1142  * Given the major number for a driver, make sure that dev_info nodes
1143  * are created form the driver's hwconf file, the driver for the named
1144  * device is loaded and attached, as well as any drivers for parent devices.
1145  * Return a pointer to the driver's dev_ops struct with the dev_ops held.
1146  * Note - Callers must release the dev_ops with ddi_rele_driver.
1147  *
1148  * When a driver is held, the branch of the devinfo tree from any of the
1149  * drivers devinfos to the root node are automatically held.  This only
1150  * applies to tree traversals up (and back down) the tree following the
1151  * parent pointers.
1152  *
1153  * Use of this interface is discouraged, it may be removed in a future release.
1154  */
1155 struct dev_ops *
1156 ddi_hold_installed_driver(major_t major);
1157 
1158 void
1159 ddi_rele_driver(major_t major);
1160 
1161 /*
1162  * Attach and hold the specified instance of a driver.  The flags argument
1163  * should be zero.
1164  */
1165 dev_info_t *
1166 ddi_hold_devi_by_instance(major_t major, int instance, int flags);
1167 
1168 void
1169 ddi_release_devi(dev_info_t *);
1170 
1171 /*
1172  * Associate a streams queue with a devinfo node
1173  */
1174 void
1175 ddi_assoc_queue_with_devi(queue_t *, dev_info_t *);
1176 
1177 /*
1178  * Given the identifier string passed, make sure that dev_info nodes
1179  * are created form the driver's hwconf file, the driver for the named
1180  * device is loaded and attached, as well as any drivers for parent devices.
1181  *
1182  * Note that the driver is not held and is subject to being removed the instant
1183  * this call completes.  You probably really want ddi_hold_installed_driver.
1184  */
1185 int
1186 ddi_install_driver(char *idstring);
1187 
1188 /*
1189  * Routines that return specific nodes
1190  */
1191 
1192 dev_info_t *
1193 ddi_root_node(void);
1194 
1195 /*
1196  * Given a name and an instance number, find and return the
1197  * dev_info from the current state of the device tree.
1198  *
1199  * If instance number is -1, return the first named instance.
1200  *
1201  * If attached is 1, exclude all nodes that are < DS_ATTACHED
1202  *
1203  * Requires that the devinfo tree be locked.
1204  * If attached is 1, the driver must be held.
1205  */
1206 dev_info_t *
1207 ddi_find_devinfo(char *name, int instance, int attached);
1208 
1209 /*
1210  * Synchronization of I/O with respect to various
1211  * caches and system write buffers.
1212  *
1213  * Done at varying points during an I/O transfer (including at the
1214  * removal of an I/O mapping).
1215  *
1216  * Due to the support of systems with write buffers which may
1217  * not be able to be turned off, this function *must* used at
1218  * any point in which data consistency might be required.
1219  *
1220  * Generally this means that if a memory object has multiple mappings
1221  * (both for I/O, as described by the handle, and the IU, via, e.g.
1222  * a call to ddi_dma_kvaddrp), and one mapping may have been
1223  * used to modify the memory object, this function must be called
1224  * to ensure that the modification of the memory object is
1225  * complete, as well as possibly to inform other mappings of
1226  * the object that any cached references to the object are
1227  * now stale (and flush or invalidate these stale cache references
1228  * as necessary).
1229  *
1230  * The function ddi_dma_sync() provides the general interface with
1231  * respect to this capability. Generally, ddi_dma_free() (below) may
1232  * be used in preference to ddi_dma_sync() as ddi_dma_free() calls
1233  * ddi_dma_sync().
1234  *
1235  * Returns 0 if all caches that exist and are specified by cache_flags
1236  * are successfully operated on, else -1.
1237  *
1238  * The argument offset specifies an offset into the mapping of the mapped
1239  * object in which to perform the synchronization. It will be silently
1240  * truncated to the granularity of underlying cache line sizes as
1241  * appropriate.
1242  *
1243  * The argument len specifies a length starting from offset in which to
1244  * perform the synchronization. A value of (uint_t) -1 means that the length
1245  * proceeds from offset to the end of the mapping. The length argument
1246  * will silently rounded up to the granularity of underlying cache line
1247  * sizes  as appropriate.
1248  *
1249  * The argument flags specifies what to synchronize (the device's view of
1250  * the object or the cpu's view of the object).
1251  *
1252  * Inquiring minds want to know when ddi_dma_sync should be used:
1253  *
1254  * +	When an object is mapped for dma, assume that an
1255  *	implicit ddi_dma_sync() is done for you.
1256  *
1257  * +	When an object is unmapped (ddi_dma_free()), assume
1258  *	that an implicit ddi_dma_sync() is done for you.
1259  *
1260  * +	At any time between the two times above that the
1261  *	memory object may have been modified by either
1262  *	the DMA device or a processor and you wish that
1263  *	the change be noticed by the master that didn't
1264  *	do the modifying.
1265  *
1266  * Clearly, only the third case above requires the use of ddi_dma_sync.
1267  *
1268  * Inquiring minds also want to know which flag to use:
1269  *
1270  * +	If you *modify* with a cpu the object, you use
1271  *	ddi_dma_sync(...DDI_DMA_SYNC_FORDEV) (you are making sure
1272  *	that the DMA device sees the changes you made).
1273  *
1274  * +	If you are checking, with the processor, an area
1275  *	of the object that the DMA device *may* have modified,
1276  *	you use ddi_dma_sync(....DDI_DMA_SYNC_FORCPU) (you are
1277  *	making sure that the processor(s) will see the changes
1278  *	that the DMA device may have made).
1279  */
1280 
1281 int
1282 ddi_dma_sync(ddi_dma_handle_t handle, off_t offset, size_t len, uint_t flags);
1283 
1284 /*
1285  * Return the allowable DMA burst size for the object mapped by handle.
1286  * The burst sizes will returned in an integer that encodes power
1287  * of two burst sizes that are allowed in bit encoded format. For
1288  * example, a transfer that could allow 1, 2, 4, 8 and 32 byte bursts
1289  * would be encoded as 0x2f. A transfer that could be allowed as solely
1290  * a halfword (2 byte) transfers would be returned as 0x2.
1291  */
1292 
1293 int
1294 ddi_dma_burstsizes(ddi_dma_handle_t handle);
1295 
1296 /*
1297  * Merge DMA attributes
1298  */
1299 
1300 void
1301 ddi_dma_attr_merge(ddi_dma_attr_t *attr, ddi_dma_attr_t *mod);
1302 
1303 /*
1304  * Allocate a DMA handle
1305  */
1306 
1307 int
1308 ddi_dma_alloc_handle(dev_info_t *dip, ddi_dma_attr_t *attr,
1309     int (*waitfp)(caddr_t), caddr_t arg,
1310     ddi_dma_handle_t *handlep);
1311 
1312 /*
1313  * Free DMA handle
1314  */
1315 
1316 void
1317 ddi_dma_free_handle(ddi_dma_handle_t *handlep);
1318 
1319 /*
1320  * Allocate memory for DMA transfers
1321  */
1322 
1323 int
1324 ddi_dma_mem_alloc(ddi_dma_handle_t handle, size_t length,
1325     ddi_device_acc_attr_t *accattrp, uint_t xfermodes,
1326     int (*waitfp)(caddr_t), caddr_t arg, caddr_t *kaddrp,
1327     size_t *real_length, ddi_acc_handle_t *handlep);
1328 
1329 /*
1330  * Free DMA memory
1331  */
1332 
1333 void
1334 ddi_dma_mem_free(ddi_acc_handle_t *hp);
1335 
1336 /*
1337  * bind address to a DMA handle
1338  */
1339 
1340 int
1341 ddi_dma_addr_bind_handle(ddi_dma_handle_t handle, struct as *as,
1342     caddr_t addr, size_t len, uint_t flags,
1343     int (*waitfp)(caddr_t), caddr_t arg,
1344     ddi_dma_cookie_t *cookiep, uint_t *ccountp);
1345 
1346 /*
1347  * bind buffer to DMA handle
1348  */
1349 
1350 int
1351 ddi_dma_buf_bind_handle(ddi_dma_handle_t handle, struct buf *bp,
1352     uint_t flags, int (*waitfp)(caddr_t), caddr_t arg,
1353     ddi_dma_cookie_t *cookiep, uint_t *ccountp);
1354 
1355 /*
1356  * unbind mapping object to handle
1357  */
1358 
1359 int
1360 ddi_dma_unbind_handle(ddi_dma_handle_t handle);
1361 
1362 /*
1363  * get next DMA cookie
1364  */
1365 
1366 void
1367 ddi_dma_nextcookie(ddi_dma_handle_t handle, ddi_dma_cookie_t *cookiep);
1368 
1369 /*
1370  * get number of DMA windows
1371  */
1372 
1373 int
1374 ddi_dma_numwin(ddi_dma_handle_t handle, uint_t *nwinp);
1375 
1376 /*
1377  * get specific DMA window
1378  */
1379 
1380 int
1381 ddi_dma_getwin(ddi_dma_handle_t handle, uint_t win, off_t *offp,
1382     size_t *lenp, ddi_dma_cookie_t *cookiep, uint_t *ccountp);
1383 
1384 /*
1385  * activate 64 bit SBus support
1386  */
1387 
1388 int
1389 ddi_dma_set_sbus64(ddi_dma_handle_t handle, ulong_t burstsizes);
1390 
1391 /*
1392  * Miscellaneous functions
1393  */
1394 
1395 /*
1396  * ddi_report_dev:	Report a successful attach.
1397  */
1398 
1399 void
1400 ddi_report_dev(dev_info_t *dev);
1401 
1402 /*
1403  * ddi_dev_regsize
1404  *
1405  *	If the device has h/w register(s), report
1406  *	the size, in bytes, of the specified one into *resultp.
1407  *
1408  *	Returns DDI_FAILURE if there are not registers,
1409  *	or the specified register doesn't exist.
1410  */
1411 
1412 int
1413 ddi_dev_regsize(dev_info_t *dev, uint_t rnumber, off_t *resultp);
1414 
1415 /*
1416  * ddi_dev_nregs
1417  *
1418  *	If the device has h/w register(s), report
1419  *	how many of them that there are into resultp.
1420  *	Return DDI_FAILURE if the device has no registers.
1421  */
1422 
1423 int
1424 ddi_dev_nregs(dev_info_t *dev, int *resultp);
1425 
1426 /*
1427  * ddi_dev_is_sid
1428  *
1429  *	If the device is self-identifying, i.e.,
1430  *	has already been probed by a smart PROM
1431  *	(and thus registers are known to be valid)
1432  *	return DDI_SUCCESS, else DDI_FAILURE.
1433  */
1434 
1435 
1436 int
1437 ddi_dev_is_sid(dev_info_t *dev);
1438 
1439 /*
1440  * ddi_slaveonly
1441  *
1442  *	If the device is on a bus that precludes
1443  *	the device from being either a dma master or
1444  *	a dma slave, return DDI_SUCCESS.
1445  */
1446 
1447 int
1448 ddi_slaveonly(dev_info_t *);
1449 
1450 
1451 /*
1452  * ddi_dev_affinity
1453  *
1454  *	Report, via DDI_SUCCESS, whether there exists
1455  *	an 'affinity' between two dev_info_t's. An
1456  *	affinity is defined to be either a parent-child,
1457  *	or a sibling relationship such that the siblings
1458  *	or in the same part of the bus they happen to be
1459  *	on.
1460  */
1461 
1462 int
1463 ddi_dev_affinity(dev_info_t *deva, dev_info_t *devb);
1464 
1465 
1466 /*
1467  * ddi_set_callback
1468  *
1469  *	Set a function/arg pair into the callback list identified
1470  *	by listid. *listid must always initially start out as zero.
1471  */
1472 
1473 void
1474 ddi_set_callback(int (*funcp)(caddr_t), caddr_t arg, uintptr_t *listid);
1475 
1476 /*
1477  * ddi_run_callback
1478  *
1479  *	Run the callback list identified by listid.
1480  */
1481 
1482 void
1483 ddi_run_callback(uintptr_t *listid);
1484 
1485 /*
1486  * More miscellaneous
1487  */
1488 
1489 int
1490 nochpoll(dev_t dev, short events, int anyyet, short *reventsp,
1491     struct pollhead **phpp);
1492 
1493 dev_info_t *
1494 nodevinfo(dev_t dev, int otyp);
1495 
1496 int
1497 ddi_no_info(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg, void **result);
1498 
1499 int
1500 ddi_getinfo_1to1(dev_info_t *dip, ddi_info_cmd_t infocmd,
1501     void *arg, void **result);
1502 
1503 int
1504 ddifail(dev_info_t *devi, ddi_attach_cmd_t cmd);
1505 
1506 int
1507 ddi_no_dma_map(dev_info_t *dip, dev_info_t *rdip,
1508     struct ddi_dma_req *dmareqp, ddi_dma_handle_t *handlep);
1509 
1510 int
1511 ddi_no_dma_allochdl(dev_info_t *dip, dev_info_t *rdip, ddi_dma_attr_t *attr,
1512     int (*waitfp)(caddr_t), caddr_t arg, ddi_dma_handle_t *handlep);
1513 
1514 int
1515 ddi_no_dma_freehdl(dev_info_t *dip, dev_info_t *rdip,
1516     ddi_dma_handle_t handle);
1517 
1518 int
1519 ddi_no_dma_bindhdl(dev_info_t *dip, dev_info_t *rdip,
1520     ddi_dma_handle_t handle, struct ddi_dma_req *dmareq,
1521     ddi_dma_cookie_t *cp, uint_t *ccountp);
1522 
1523 int
1524 ddi_no_dma_unbindhdl(dev_info_t *dip, dev_info_t *rdip,
1525     ddi_dma_handle_t handle);
1526 
1527 int
1528 ddi_no_dma_flush(dev_info_t *dip, dev_info_t *rdip,
1529     ddi_dma_handle_t handle, off_t off, size_t len,
1530     uint_t cache_flags);
1531 
1532 int
1533 ddi_no_dma_win(dev_info_t *dip, dev_info_t *rdip,
1534     ddi_dma_handle_t handle, uint_t win, off_t *offp,
1535     size_t *lenp, ddi_dma_cookie_t *cookiep, uint_t *ccountp);
1536 
1537 int
1538 ddi_no_dma_mctl(register dev_info_t *dip, dev_info_t *rdip,
1539     ddi_dma_handle_t handle, enum ddi_dma_ctlops request,
1540     off_t *offp, size_t *lenp, caddr_t *objp, uint_t flags);
1541 
1542 void
1543 ddivoid();
1544 
1545 cred_t *
1546 ddi_get_cred(void);
1547 
1548 time_t
1549 ddi_get_time(void);
1550 
1551 pid_t
1552 ddi_get_pid(void);
1553 
1554 kt_did_t
1555 ddi_get_kt_did(void);
1556 
1557 boolean_t
1558 ddi_can_receive_sig(void);
1559 
1560 void
1561 swab(void *src, void *dst, size_t nbytes);
1562 
1563 int
1564 ddi_create_minor_node(dev_info_t *dip, char *name, int spec_type,
1565     minor_t minor_num, char *node_type, int flag);
1566 
1567 int
1568 ddi_create_priv_minor_node(dev_info_t *dip, char *name, int spec_type,
1569     minor_t minor_num, char *node_type, int flag,
1570     const char *rdpriv, const char *wrpriv, mode_t priv_mode);
1571 
1572 void
1573 ddi_remove_minor_node(dev_info_t *dip, char *name);
1574 
1575 int
1576 ddi_in_panic(void);
1577 
1578 int
1579 ddi_streams_driver(dev_info_t *dip);
1580 
1581 /*
1582  * DDI wrappers for ffs and fls
1583  */
1584 int
1585 ddi_ffs(long mask);
1586 
1587 int
1588 ddi_fls(long mask);
1589 
1590 /*
1591  * The ddi_soft_state* routines comprise generic storage management utilities
1592  * for driver soft state structures.  Two types of soft_state indexes are
1593  * supported: 'integer index', and 'string index'.
1594  */
1595 typedef	struct __ddi_soft_state_bystr	ddi_soft_state_bystr;
1596 
1597 /*
1598  * Initialize a soft_state set, establishing the 'size' of soft state objects
1599  * in the set.
1600  *
1601  * For an 'integer indexed' soft_state set, the initial set will accommodate
1602  * 'n_items' objects - 'n_items' is a hint (i.e. zero is allowed), allocations
1603  * that exceed 'n_items' have additional overhead.
1604  *
1605  * For a 'string indexed' soft_state set, 'n_items' should be the typical
1606  * number of soft state objects in the set - 'n_items' is a hint, there may
1607  * be additional overhead if the hint is too small (and wasted memory if the
1608  * hint is too big).
1609  */
1610 int
1611 ddi_soft_state_init(void **state_p, size_t size, size_t n_items);
1612 int
1613 ddi_soft_state_bystr_init(ddi_soft_state_bystr **state_p,
1614     size_t size, int n_items);
1615 
1616 /*
1617  * Allocate a soft state object associated with either 'integer index' or
1618  * 'string index' from a soft_state set.
1619  */
1620 int
1621 ddi_soft_state_zalloc(void *state, int item);
1622 int
1623 ddi_soft_state_bystr_zalloc(ddi_soft_state_bystr *state, const char *str);
1624 
1625 /*
1626  * Get the pointer to the allocated soft state object associated with
1627  * either 'integer index' or 'string index'.
1628  */
1629 void *
1630 ddi_get_soft_state(void *state, int item);
1631 void *
1632 ddi_soft_state_bystr_get(ddi_soft_state_bystr *state, const char *str);
1633 
1634 /*
1635  * Free the soft state object associated with either 'integer index'
1636  * or 'string index'.
1637  */
1638 void
1639 ddi_soft_state_free(void *state, int item);
1640 void
1641 ddi_soft_state_bystr_free(ddi_soft_state_bystr *state, const char *str);
1642 
1643 /*
1644  * Free the soft state set and any associated soft state objects.
1645  */
1646 void
1647 ddi_soft_state_fini(void **state_p);
1648 void
1649 ddi_soft_state_bystr_fini(ddi_soft_state_bystr **state_p);
1650 
1651 /*
1652  * The ddi_strid_* routines provide string-to-index management utilities.
1653  */
1654 typedef	struct __ddi_strid	ddi_strid;
1655 int
1656 ddi_strid_init(ddi_strid **strid_p, int n_items);
1657 id_t
1658 ddi_strid_alloc(ddi_strid *strid, char *str);
1659 id_t
1660 ddi_strid_str2id(ddi_strid *strid, char *str);
1661 char *
1662 ddi_strid_id2str(ddi_strid *strid, id_t id);
1663 void
1664 ddi_strid_free(ddi_strid *strid, id_t id);
1665 void
1666 ddi_strid_fini(ddi_strid **strid_p);
1667 
1668 /*
1669  * Set the addr field of the name in dip to name
1670  */
1671 void
1672 ddi_set_name_addr(dev_info_t *dip, char *name);
1673 
1674 /*
1675  * Get the address part of the name.
1676  */
1677 char *
1678 ddi_get_name_addr(dev_info_t *dip);
1679 
1680 void
1681 ddi_set_parent_data(dev_info_t *dip, void *pd);
1682 
1683 void *
1684 ddi_get_parent_data(dev_info_t *dip);
1685 
1686 int
1687 ddi_initchild(dev_info_t *parent, dev_info_t *proto);
1688 
1689 int
1690 ddi_uninitchild(dev_info_t *dip);
1691 
1692 major_t
1693 ddi_name_to_major(char *name);
1694 
1695 char *
1696 ddi_major_to_name(major_t major);
1697 
1698 char *
1699 ddi_deviname(dev_info_t *dip, char *name);
1700 
1701 char *
1702 ddi_pathname(dev_info_t *dip, char *path);
1703 
1704 char *
1705 ddi_pathname_minor(struct ddi_minor_data *dmdp, char *path);
1706 
1707 char *
1708 ddi_pathname_obp(dev_info_t *dip, char *path);
1709 
1710 int
1711 ddi_pathname_obp_set(dev_info_t *dip, char *component);
1712 
1713 int
1714 ddi_dev_pathname(dev_t devt, int spec_type, char *name);
1715 
1716 dev_t
1717 ddi_pathname_to_dev_t(char *pathname);
1718 
1719 /*
1720  * High resolution system timer functions.
1721  *
1722  * These functions are already in the kernel (see sys/time.h).
1723  * The ddi supports the notion of a hrtime_t type and the
1724  * functions gethrtime, hrtadd, hrtsub and hrtcmp.
1725  */
1726 
1727 
1728 /*
1729  * Nexus wrapper functions
1730  *
1731  * These functions are for entries in a bus nexus driver's bus_ops
1732  * structure for when the driver doesn't have such a function and
1733  * doesn't wish to prohibit such a function from existing. They
1734  * may also be called to start passing a request up the dev_info
1735  * tree.
1736  */
1737 
1738 /*
1739  * bus_ctl wrapper
1740  */
1741 
1742 int
1743 ddi_ctlops(dev_info_t *d, dev_info_t *r, ddi_ctl_enum_t o, void *a, void *v);
1744 
1745 /*
1746  * bus_dma_map wrapper
1747  */
1748 
1749 int
1750 ddi_dma_allochdl(dev_info_t *dip, dev_info_t *rdip, ddi_dma_attr_t *attr,
1751     int (*waitfp)(caddr_t), caddr_t arg, ddi_dma_handle_t *handlep);
1752 
1753 int
1754 ddi_dma_freehdl(dev_info_t *dip, dev_info_t *rdip,
1755     ddi_dma_handle_t handle);
1756 
1757 int
1758 ddi_dma_bindhdl(dev_info_t *dip, dev_info_t *rdip,
1759     ddi_dma_handle_t handle, struct ddi_dma_req *dmareq,
1760     ddi_dma_cookie_t *cp, uint_t *ccountp);
1761 
1762 int
1763 ddi_dma_unbindhdl(dev_info_t *dip, dev_info_t *rdip,
1764     ddi_dma_handle_t handle);
1765 
1766 int
1767 ddi_dma_flush(dev_info_t *dip, dev_info_t *rdip,
1768     ddi_dma_handle_t handle, off_t off, size_t len,
1769     uint_t cache_flags);
1770 
1771 int
1772 ddi_dma_win(dev_info_t *dip, dev_info_t *rdip,
1773     ddi_dma_handle_t handle, uint_t win, off_t *offp,
1774     size_t *lenp, ddi_dma_cookie_t *cookiep, uint_t *ccountp);
1775 
1776 /*
1777  * bus_dma_ctl wrapper
1778  */
1779 
1780 int
1781 ddi_dma_mctl(dev_info_t *dip, dev_info_t *rdip, ddi_dma_handle_t handle,
1782     enum ddi_dma_ctlops request, off_t *offp, size_t *lenp,
1783     caddr_t *objp, uint_t flags);
1784 
1785 /*
1786  * dvma support for networking drivers
1787  */
1788 
1789 unsigned long
1790 dvma_pagesize(dev_info_t *dip);
1791 
1792 int
1793 dvma_reserve(dev_info_t *dip,  ddi_dma_lim_t *limp, uint_t pages,
1794     ddi_dma_handle_t *handlep);
1795 
1796 void
1797 dvma_release(ddi_dma_handle_t h);
1798 
1799 void
1800 dvma_kaddr_load(ddi_dma_handle_t h, caddr_t a, uint_t len, uint_t index,
1801     ddi_dma_cookie_t *cp);
1802 
1803 void
1804 dvma_unload(ddi_dma_handle_t h, uint_t objindex, uint_t type);
1805 
1806 void
1807 dvma_sync(ddi_dma_handle_t h, uint_t objindex, uint_t type);
1808 
1809 /*
1810  * Layered driver support
1811  */
1812 
1813 extern int ddi_copyin(const void *, void *, size_t, int);
1814 extern int ddi_copyout(const void *, void *, size_t, int);
1815 
1816 /*
1817  * Send signals to processes
1818  */
1819 extern void *proc_ref(void);
1820 extern void proc_unref(void *pref);
1821 extern int proc_signal(void *pref, int sig);
1822 
1823 /* I/O port access routines */
1824 extern uint8_t inb(int port);
1825 extern uint16_t inw(int port);
1826 extern uint32_t inl(int port);
1827 extern void outb(int port, uint8_t value);
1828 extern void outw(int port, uint16_t value);
1829 extern void outl(int port, uint32_t value);
1830 
1831 /*
1832  * Console bell routines
1833  */
1834 extern void ddi_ring_console_bell(clock_t duration);
1835 extern void ddi_set_console_bell(void (*bellfunc)(clock_t duration));
1836 
1837 /*
1838  * Fault-related functions
1839  */
1840 extern int ddi_check_acc_handle(ddi_acc_handle_t);
1841 extern int ddi_check_dma_handle(ddi_dma_handle_t);
1842 extern void ddi_dev_report_fault(dev_info_t *, ddi_fault_impact_t,
1843     ddi_fault_location_t, const char *);
1844 extern ddi_devstate_t ddi_get_devstate(dev_info_t *);
1845 
1846 /*
1847  * Miscellaneous redefines
1848  */
1849 #define	uiophysio	physio
1850 
1851 /*
1852  * utilities - "reg" mapping and all common portable data access functions
1853  */
1854 
1855 /*
1856  * error code from ddi_regs_map_setup
1857  */
1858 
1859 #define	DDI_REGS_ACC_CONFLICT	(-10)
1860 
1861 /*
1862  * Device address advance flags
1863  */
1864 
1865 #define	 DDI_DEV_NO_AUTOINCR	0x0000
1866 #define	 DDI_DEV_AUTOINCR	0x0001
1867 
1868 int
1869 ddi_regs_map_setup(dev_info_t *dip, uint_t rnumber, caddr_t *addrp,
1870     offset_t offset, offset_t len, ddi_device_acc_attr_t *accattrp,
1871     ddi_acc_handle_t *handle);
1872 
1873 void
1874 ddi_regs_map_free(ddi_acc_handle_t *handle);
1875 
1876 /*
1877  * these are the prototypes for the common portable data access functions
1878  */
1879 
1880 uint8_t
1881 ddi_get8(ddi_acc_handle_t handle, uint8_t *addr);
1882 
1883 uint16_t
1884 ddi_get16(ddi_acc_handle_t handle, uint16_t *addr);
1885 
1886 uint32_t
1887 ddi_get32(ddi_acc_handle_t handle, uint32_t *addr);
1888 
1889 uint64_t
1890 ddi_get64(ddi_acc_handle_t handle, uint64_t *addr);
1891 
1892 void
1893 ddi_rep_get8(ddi_acc_handle_t handle, uint8_t *host_addr, uint8_t *dev_addr,
1894     size_t repcount, uint_t flags);
1895 
1896 void
1897 ddi_rep_get16(ddi_acc_handle_t handle, uint16_t *host_addr, uint16_t *dev_addr,
1898     size_t repcount, uint_t flags);
1899 
1900 void
1901 ddi_rep_get32(ddi_acc_handle_t handle, uint32_t *host_addr, uint32_t *dev_addr,
1902     size_t repcount, uint_t flags);
1903 
1904 void
1905 ddi_rep_get64(ddi_acc_handle_t handle, uint64_t *host_addr, uint64_t *dev_addr,
1906     size_t repcount, uint_t flags);
1907 
1908 void
1909 ddi_put8(ddi_acc_handle_t handle, uint8_t *addr, uint8_t value);
1910 
1911 void
1912 ddi_put16(ddi_acc_handle_t handle, uint16_t *addr, uint16_t value);
1913 
1914 void
1915 ddi_put32(ddi_acc_handle_t handle, uint32_t *addr, uint32_t value);
1916 
1917 void
1918 ddi_put64(ddi_acc_handle_t handle, uint64_t *addr, uint64_t value);
1919 
1920 void
1921 ddi_rep_put8(ddi_acc_handle_t handle, uint8_t *host_addr, uint8_t *dev_addr,
1922     size_t repcount, uint_t flags);
1923 void
1924 ddi_rep_put16(ddi_acc_handle_t handle, uint16_t *host_addr, uint16_t *dev_addr,
1925     size_t repcount, uint_t flags);
1926 void
1927 ddi_rep_put32(ddi_acc_handle_t handle, uint32_t *host_addr, uint32_t *dev_addr,
1928     size_t repcount, uint_t flags);
1929 
1930 void
1931 ddi_rep_put64(ddi_acc_handle_t handle, uint64_t *host_addr, uint64_t *dev_addr,
1932     size_t repcount, uint_t flags);
1933 
1934 /*
1935  * these are special device handling functions
1936  */
1937 int
1938 ddi_device_zero(ddi_acc_handle_t handle, caddr_t dev_addr,
1939     size_t bytecount, ssize_t dev_advcnt, uint_t dev_datasz);
1940 
1941 int
1942 ddi_device_copy(
1943     ddi_acc_handle_t src_handle, caddr_t src_addr, ssize_t src_advcnt,
1944     ddi_acc_handle_t dest_handle, caddr_t dest_addr, ssize_t dest_advcnt,
1945     size_t bytecount, uint_t dev_datasz);
1946 
1947 /*
1948  * these are software byte swapping functions
1949  */
1950 uint16_t
1951 ddi_swap16(uint16_t value);
1952 
1953 uint32_t
1954 ddi_swap32(uint32_t value);
1955 
1956 uint64_t
1957 ddi_swap64(uint64_t value);
1958 
1959 /*
1960  * these are the prototypes for PCI local bus functions
1961  */
1962 /*
1963  * PCI power management capabilities reporting in addition to those
1964  * provided by the PCI Power Management Specification.
1965  */
1966 #define	PCI_PM_IDLESPEED	0x1		/* clock for idle dev - cap  */
1967 #define	PCI_PM_IDLESPEED_ANY	(void *)-1	/* any clock for idle dev */
1968 #define	PCI_PM_IDLESPEED_NONE	(void *)-2	/* regular clock for idle dev */
1969 
1970 int
1971 pci_config_setup(dev_info_t *dip, ddi_acc_handle_t *handle);
1972 
1973 void
1974 pci_config_teardown(ddi_acc_handle_t *handle);
1975 
1976 uint8_t
1977 pci_config_get8(ddi_acc_handle_t handle, off_t offset);
1978 
1979 uint16_t
1980 pci_config_get16(ddi_acc_handle_t handle, off_t offset);
1981 
1982 uint32_t
1983 pci_config_get32(ddi_acc_handle_t handle, off_t offset);
1984 
1985 uint64_t
1986 pci_config_get64(ddi_acc_handle_t handle, off_t offset);
1987 
1988 void
1989 pci_config_put8(ddi_acc_handle_t handle, off_t offset, uint8_t value);
1990 
1991 void
1992 pci_config_put16(ddi_acc_handle_t handle, off_t offset, uint16_t value);
1993 
1994 void
1995 pci_config_put32(ddi_acc_handle_t handle, off_t offset, uint32_t value);
1996 
1997 void
1998 pci_config_put64(ddi_acc_handle_t handle, off_t offset, uint64_t value);
1999 
2000 int
2001 pci_report_pmcap(dev_info_t *dip, int cap, void *arg);
2002 
2003 int
2004 pci_restore_config_regs(dev_info_t *dip);
2005 
2006 int
2007 pci_save_config_regs(dev_info_t *dip);
2008 
2009 void
2010 pci_ereport_setup(dev_info_t *dip);
2011 
2012 void
2013 pci_ereport_teardown(dev_info_t *dip);
2014 
2015 void
2016 pci_ereport_post(dev_info_t *dip, ddi_fm_error_t *derr, uint16_t *status);
2017 
2018 #if defined(__i386) || defined(__amd64)
2019 int
2020 pci_peekpoke_check(dev_info_t *, dev_info_t *, ddi_ctl_enum_t, void *, void *,
2021     int (*handler)(dev_info_t *, dev_info_t *, ddi_ctl_enum_t, void *, void *),
2022     kmutex_t *, kmutex_t *, void (*scan)(dev_info_t *, ddi_fm_error_t *));
2023 #endif
2024 
2025 void
2026 pci_target_enqueue(uint64_t, char *, char *, uint64_t);
2027 
2028 void
2029 pci_targetq_init(void);
2030 
2031 int
2032 pci_post_suspend(dev_info_t *dip);
2033 
2034 int
2035 pci_pre_resume(dev_info_t *dip);
2036 
2037 /*
2038  * the prototype for the C Language Type Model inquiry.
2039  */
2040 model_t	ddi_mmap_get_model(void);
2041 model_t	ddi_model_convert_from(model_t);
2042 
2043 /*
2044  * these are the prototypes for device id functions.
2045  */
2046 int
2047 ddi_devid_valid(ddi_devid_t devid);
2048 
2049 int
2050 ddi_devid_register(dev_info_t *dip, ddi_devid_t devid);
2051 
2052 void
2053 ddi_devid_unregister(dev_info_t *dip);
2054 
2055 int
2056 ddi_devid_init(dev_info_t *dip, ushort_t devid_type, ushort_t nbytes,
2057     void *id, ddi_devid_t *ret_devid);
2058 
2059 int
2060 ddi_devid_get(dev_info_t *dip, ddi_devid_t *ret_devid);
2061 
2062 size_t
2063 ddi_devid_sizeof(ddi_devid_t devid);
2064 
2065 void
2066 ddi_devid_free(ddi_devid_t devid);
2067 
2068 int
2069 ddi_devid_compare(ddi_devid_t id1, ddi_devid_t id2);
2070 
2071 int
2072 ddi_devid_scsi_encode(int version, char *driver_name,
2073     uchar_t *inq, size_t inq_len, uchar_t *inq80, size_t inq80_len,
2074     uchar_t *inq83, size_t inq83_len, ddi_devid_t *ret_devid);
2075 
2076 int
2077 ddi_devid_smp_encode(int version, char *driver_name,
2078     char *wwnstr, uchar_t *srmir_buf, size_t srmir_len,
2079     ddi_devid_t *ret_devid);
2080 
2081 char
2082 *ddi_devid_to_guid(ddi_devid_t devid);
2083 
2084 void
2085 ddi_devid_free_guid(char *guid);
2086 
2087 int
2088 ddi_lyr_get_devid(dev_t dev, ddi_devid_t *ret_devid);
2089 
2090 int
2091 ddi_lyr_get_minor_name(dev_t dev, int spec_type, char **minor_name);
2092 
2093 int
2094 ddi_lyr_devid_to_devlist(ddi_devid_t devid, char *minor_name, int *retndevs,
2095     dev_t **retdevs);
2096 
2097 void
2098 ddi_lyr_free_devlist(dev_t *devlist, int ndevs);
2099 
2100 char *
2101 ddi_devid_str_encode(ddi_devid_t devid, char *minor_name);
2102 
2103 int
2104 ddi_devid_str_decode(char *devidstr, ddi_devid_t *devidp, char **minor_namep);
2105 
2106 void
2107 ddi_devid_str_free(char *devidstr);
2108 
2109 int
2110 ddi_devid_str_compare(char *id1_str, char *id2_str);
2111 
2112 /*
2113  * Event to post to when a devinfo node is removed.
2114  */
2115 #define	DDI_DEVI_REMOVE_EVENT		"DDI:DEVI_REMOVE"
2116 #define	DDI_DEVI_INSERT_EVENT		"DDI:DEVI_INSERT"
2117 #define	DDI_DEVI_BUS_RESET_EVENT	"DDI:DEVI_BUS_RESET"
2118 #define	DDI_DEVI_DEVICE_RESET_EVENT	"DDI:DEVI_DEVICE_RESET"
2119 
2120 /*
2121  * Invoke bus nexus driver's implementation of the
2122  * (*bus_remove_eventcall)() interface to remove a registered
2123  * callback handler for "event".
2124  */
2125 int
2126 ddi_remove_event_handler(ddi_callback_id_t id);
2127 
2128 /*
2129  * Invoke bus nexus driver's implementation of the
2130  * (*bus_add_eventcall)() interface to register a callback handler
2131  * for "event".
2132  */
2133 int
2134 ddi_add_event_handler(dev_info_t *dip, ddi_eventcookie_t event,
2135     void (*handler)(dev_info_t *, ddi_eventcookie_t, void *, void *),
2136     void *arg, ddi_callback_id_t *id);
2137 
2138 /*
2139  * Return a handle for event "name" by calling up the device tree
2140  * hierarchy via  (*bus_get_eventcookie)() interface until claimed
2141  * by a bus nexus or top of dev_info tree is reached.
2142  */
2143 int
2144 ddi_get_eventcookie(dev_info_t *dip, char *name,
2145     ddi_eventcookie_t *event_cookiep);
2146 
2147 /*
2148  * log a system event
2149  */
2150 int
2151 ddi_log_sysevent(dev_info_t *dip, char *vendor, char *class_name,
2152     char *subclass_name, nvlist_t *attr_list, sysevent_id_t *eidp,
2153     int sleep_flag);
2154 
2155 /*
2156  * ddi_log_sysevent() vendors
2157  */
2158 #define	DDI_VENDOR_SUNW		"SUNW"
2159 
2160 /*
2161  * Opaque task queue handle.
2162  */
2163 typedef struct ddi_taskq ddi_taskq_t;
2164 
2165 /*
2166  * Use default system priority.
2167  */
2168 #define	TASKQ_DEFAULTPRI -1
2169 
2170 /*
2171  * Create a task queue
2172  */
2173 ddi_taskq_t *ddi_taskq_create(dev_info_t *dip, const char *name,
2174     int nthreads, pri_t pri, uint_t cflags);
2175 
2176 /*
2177  * destroy a task queue
2178  */
2179 void ddi_taskq_destroy(ddi_taskq_t *tq);
2180 
2181 /*
2182  * Dispatch a task to a task queue
2183  */
2184 int ddi_taskq_dispatch(ddi_taskq_t *tq, void (* func)(void *),
2185 	void *arg, uint_t dflags);
2186 
2187 /*
2188  * Wait for all previously scheduled tasks to complete.
2189  */
2190 void ddi_taskq_wait(ddi_taskq_t *tq);
2191 
2192 /*
2193  * Suspend all task execution.
2194  */
2195 void ddi_taskq_suspend(ddi_taskq_t *tq);
2196 
2197 /*
2198  * Resume task execution.
2199  */
2200 void ddi_taskq_resume(ddi_taskq_t *tq);
2201 
2202 /*
2203  * Is task queue suspended?
2204  */
2205 boolean_t ddi_taskq_suspended(ddi_taskq_t *tq);
2206 
2207 /*
2208  * Parse an interface name of the form <alphanumeric>##<numeric> where
2209  * <numeric> is maximal.
2210  */
2211 int ddi_parse(const char *, char *, uint_t *);
2212 
2213 /*
2214  * DDI interrupt priority level
2215  */
2216 #define	DDI_IPL_0	(0)	/* kernel context */
2217 #define	DDI_IPL_1	(1)	/* interrupt priority level 1 */
2218 #define	DDI_IPL_2	(2)	/* interrupt priority level 2 */
2219 #define	DDI_IPL_3	(3)	/* interrupt priority level 3 */
2220 #define	DDI_IPL_4	(4)	/* interrupt priority level 4 */
2221 #define	DDI_IPL_5	(5)	/* interrupt priority level 5 */
2222 #define	DDI_IPL_6	(6)	/* interrupt priority level 6 */
2223 #define	DDI_IPL_7	(7)	/* interrupt priority level 7 */
2224 #define	DDI_IPL_8	(8)	/* interrupt priority level 8 */
2225 #define	DDI_IPL_9	(9)	/* interrupt priority level 9 */
2226 #define	DDI_IPL_10	(10)	/* interrupt priority level 10 */
2227 
2228 /*
2229  * DDI periodic timeout interface
2230  */
2231 ddi_periodic_t ddi_periodic_add(void (*)(void *), void *, hrtime_t, int);
2232 void ddi_periodic_delete(ddi_periodic_t);
2233 
2234 /*
2235  * Default quiesce(9E) implementation for drivers that don't need to do
2236  * anything.
2237  */
2238 int ddi_quiesce_not_needed(dev_info_t *);
2239 
2240 /*
2241  * Default quiesce(9E) initialization function for drivers that should
2242  * implement quiesce but haven't yet.
2243  */
2244 int ddi_quiesce_not_supported(dev_info_t *);
2245 
2246 /*
2247  * DDI generic callback interface
2248  */
2249 
2250 typedef struct __ddi_cb **ddi_cb_handle_t;
2251 
2252 int	ddi_cb_register(dev_info_t *dip, ddi_cb_flags_t flags,
2253 	    ddi_cb_func_t cbfunc, void *arg1, void *arg2,
2254 	    ddi_cb_handle_t *ret_hdlp);
2255 int	ddi_cb_unregister(ddi_cb_handle_t hdl);
2256 
2257 /* Notify DDI of memory added */
2258 void ddi_mem_update(uint64_t addr, uint64_t size);
2259 
2260 /* Path alias interfaces */
2261 typedef struct plat_alias {
2262 	char *pali_current;
2263 	uint64_t pali_naliases;
2264 	char **pali_aliases;
2265 } plat_alias_t;
2266 
2267 typedef struct alias_pair {
2268 	char *pair_alias;
2269 	char *pair_curr;
2270 } alias_pair_t;
2271 
2272 extern boolean_t ddi_aliases_present;
2273 
2274 typedef struct ddi_alias {
2275 	alias_pair_t	*dali_alias_pairs;
2276 	alias_pair_t	*dali_curr_pairs;
2277 	int		dali_num_pairs;
2278 	mod_hash_t	*dali_alias_TLB;
2279 	mod_hash_t	*dali_curr_TLB;
2280 } ddi_alias_t;
2281 
2282 extern ddi_alias_t ddi_aliases;
2283 
2284 void ddi_register_aliases(plat_alias_t *pali, uint64_t npali);
2285 dev_info_t *ddi_alias_redirect(char *alias);
2286 char *ddi_curr_redirect(char *curr);
2287 
2288 #endif	/* _KERNEL */
2289 
2290 #ifdef	__cplusplus
2291 }
2292 #endif
2293 
2294 #endif	/* _SYS_SUNDDI_H */
2295