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