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