?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
autofs: disable by default
[unleashed.git] / include / sys / ddi_impldefs.h
blob96cd4708ddb79fa0abc7986cf7c9f42ee6a1ade7
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 * Copyright (c) 1991, 2010, Oracle and/or its affiliates. All rights reserved.
23 * Copyright 2012 Garrett D'Amore <garrett@damore.org>. All rights reserved.
24 * Copyright (c) 2016 by Delphix. All rights reserved.
25 */
26
27 #ifndef _SYS_DDI_IMPLDEFS_H
28 #define _SYS_DDI_IMPLDEFS_H
29
30 #include <sys/types.h>
31 #include <sys/param.h>
32 #include <sys/t_lock.h>
33 #include <sys/ddipropdefs.h>
34 #include <sys/devops.h>
35 #include <sys/autoconf.h>
36 #include <sys/mutex.h>
37 #include <vm/page.h>
38 #include <sys/dacf_impl.h>
39 #include <sys/ndifm.h>
40 #include <sys/epm.h>
41 #include <sys/ddidmareq.h>
42 #include <sys/ddi_intr.h>
43 #include <sys/ddi_hp.h>
44 #include <sys/ddi_hp_impl.h>
45 #include <sys/ddi_isa.h>
46 #include <sys/id_space.h>
47 #include <sys/modhash.h>
48 #include <sys/bitset.h>
49
50 #ifdef __cplusplus
51 extern "C" {
52 #endif
53
54 /*
55 * The device id implementation has been switched to be based on properties.
56 * For compatibility with di_devid libdevinfo interface the following
57 * must be defined:
58 */
59 #define DEVID_COMPATIBILITY ((ddi_devid_t)-1)
60
61 /*
62 * Definitions for node class.
63 * DDI_NC_PROM: a node with a nodeid that may be used in a promif call.
64 * DDI_NC_PSEUDO: a software created node with a software assigned nodeid.
65 */
66 typedef enum {
67 DDI_NC_PROM = 0,
68 DDI_NC_PSEUDO
69 } ddi_node_class_t;
70
71 /*
72 * Definitions for generic callback mechanism.
73 */
74 typedef enum {
75 DDI_CB_INTR_ADD, /* More available interrupts */
76 DDI_CB_INTR_REMOVE /* Fewer available interrupts */
77 } ddi_cb_action_t;
78
79 typedef enum {
80 DDI_CB_FLAG_INTR = 0x1 /* Driver is IRM aware */
81 } ddi_cb_flags_t;
82
83 #define DDI_CB_FLAG_VALID(f) ((f) & DDI_CB_FLAG_INTR)
84
85 typedef int (*ddi_cb_func_t)(dev_info_t *dip, ddi_cb_action_t action,
86 void *cbarg, void *arg1, void *arg2);
87
88 typedef struct ddi_cb {
89 uint64_t cb_flags;
90 dev_info_t *cb_dip;
91 ddi_cb_func_t cb_func;
92 void *cb_arg1;
93 void *cb_arg2;
94 } ddi_cb_t;
95
96 /*
97 * dev_info: The main device information structure this is intended to be
98 * opaque to drivers and drivers should use ddi functions to
99 * access *all* driver accessible fields.
100 *
101 * devi_parent_data includes property lists (interrupts, registers, etc.)
102 * devi_driver_data includes whatever the driver wants to place there.
103 */
104 struct devinfo_audit;
105
106 typedef struct devi_port {
107 union {
108 struct {
109 uint32_t type;
110 uint32_t pad;
111 } port;
112 uint64_t type64;
113 } info;
114 void *priv_p;
115 } devi_port_t;
116
117 typedef struct devi_bus_priv {
118 devi_port_t port_up;
119 devi_port_t port_down;
120 } devi_bus_priv_t;
121
122 #if defined(__x86)
123 struct iommulib_unit;
124 typedef struct iommulib_unit *iommulib_handle_t;
125 struct iommulib_nex;
126 typedef struct iommulib_nex *iommulib_nexhandle_t;
127 #endif
128
129 typedef uint8_t ndi_flavor_t;
130 struct ddi_hp_cn_handle;
131
132 struct in_node;
133
134 struct dev_info {
135
136 struct dev_info *devi_parent; /* my parent node in tree */
137 struct dev_info *devi_child; /* my child list head */
138 struct dev_info *devi_sibling; /* next element on my level */
139
140 char *devi_binding_name; /* name used to bind driver: */
141 /* shared storage, points to */
142 /* devi_node_name, devi_compat_names */
143 /* or devi_rebinding_name */
144
145 char *devi_addr; /* address part of name */
146
147 int devi_nodeid; /* device nodeid */
148 int devi_instance; /* device instance number */
149
150 struct dev_ops *devi_ops; /* driver operations */
151
152 void *devi_parent_data; /* parent private data */
153 void *devi_driver_data; /* driver private data */
154
155 ddi_prop_t *devi_drv_prop_ptr; /* head of driver prop list */
156 ddi_prop_t *devi_sys_prop_ptr; /* head of system prop list */
157
158 struct ddi_minor_data *devi_minor; /* head of minor list */
159 struct dev_info *devi_next; /* Next instance of this device */
160 kmutex_t devi_lock; /* Protects per-devinfo data */
161
162 /* logical parents for busop primitives */
163
164 struct dev_info *devi_bus_map_fault; /* bus_map_fault parent */
165 void *devi_obsolete; /* obsolete placeholder */
166 struct dev_info *devi_bus_dma_allochdl; /* bus_dma_newhdl parent */
167 struct dev_info *devi_bus_dma_freehdl; /* bus_dma_freehdl parent */
168 struct dev_info *devi_bus_dma_bindhdl; /* bus_dma_bindhdl parent */
169 struct dev_info *devi_bus_dma_unbindhdl; /* bus_dma_unbindhdl parent */
170 struct dev_info *devi_bus_dma_flush; /* bus_dma_flush parent */
171 struct dev_info *devi_bus_dma_win; /* bus_dma_win parent */
172 struct dev_info *devi_bus_dma_ctl; /* bus_dma_ctl parent */
173 struct dev_info *devi_bus_ctl; /* bus_ctl parent */
174
175 ddi_prop_t *devi_hw_prop_ptr; /* head of hw prop list */
176
177 char *devi_node_name; /* The 'name' of the node */
178 char *devi_compat_names; /* A list of driver names */
179 size_t devi_compat_length; /* Size of compat_names */
180
181 int (*devi_bus_dma_bindfunc)(dev_info_t *, dev_info_t *,
182 ddi_dma_handle_t, struct ddi_dma_req *, ddi_dma_cookie_t *,
183 uint_t *);
184 int (*devi_bus_dma_unbindfunc)(dev_info_t *, dev_info_t *,
185 ddi_dma_handle_t);
186
187 char *devi_devid_str; /* registered device id */
188
189 /*
190 * power management entries
191 * components exist even if the device is not currently power managed
192 */
193 struct pm_info *devi_pm_info; /* 0 => dev not power managed */
194 uint_t devi_pm_flags; /* pm flags */
195 int devi_pm_num_components; /* number of components */
196 size_t devi_pm_comp_size; /* size of devi_components */
197 struct pm_component *devi_pm_components; /* array of pm components */
198 struct dev_info *devi_pm_ppm; /* ppm attached to this one */
199 void *devi_pm_ppm_private; /* for use by ppm driver */
200 int devi_pm_dev_thresh; /* "device" threshold */
201 uint_t devi_pm_kidsupcnt; /* # of kids powered up */
202 struct pm_scan *devi_pm_scan; /* pm scan info */
203 uint_t devi_pm_noinvolpm; /* # of descendents no-invol */
204 uint_t devi_pm_volpmd; /* # of voluntarily pm'ed */
205 kmutex_t devi_pm_lock; /* pm lock for state */
206 kmutex_t devi_pm_busy_lock; /* for component busy count */
207
208 uint_t devi_state; /* device/bus state flags */
209 /* see below for definitions */
210 kcondvar_t devi_cv; /* cv */
211 int devi_ref; /* reference count */
212
213 dacf_rsrvlist_t *devi_dacf_tasks; /* dacf reservation queue */
214
215 ddi_node_class_t devi_node_class; /* Node class */
216 int devi_node_attributes; /* Node attributes: See below */
217
218 char *devi_device_class;
219
220 /*
221 * New mpxio kernel hooks entries
222 */
223 int devi_mdi_component; /* mpxio component type */
224 void *devi_mdi_client; /* mpxio client information */
225 void *devi_mdi_xhci; /* vhci/phci info */
226
227 ddi_prop_list_t *devi_global_prop_list; /* driver global properties */
228 major_t devi_major; /* driver major number */
229 ddi_node_state_t devi_node_state; /* state of node */
230 uint_t devi_flags; /* configuration flags */
231 int devi_circular; /* for recursive operations */
232 void *devi_busy_thread; /* thread operating on node */
233 void *devi_taskq; /* hotplug taskq */
234
235 /* device driver statistical and audit info */
236 struct devinfo_audit *devi_audit; /* last state change */
237
238 /*
239 * FMA support for resource caches and error handlers
240 */
241 struct i_ddi_fmhdl *devi_fmhdl;
242
243 uint_t devi_cpr_flags;
244
245 /* Owned by DDI interrupt framework */
246 devinfo_intr_t *devi_intr_p;
247
248 void *devi_nex_pm; /* nexus PM private */
249
250 char *devi_addr_buf; /* buffer for devi_addr */
251
252 char *devi_rebinding_name; /* binding_name of rebind */
253
254 /* For device contracts that have this dip's minor node as resource */
255 kmutex_t devi_ct_lock; /* contract lock */
256 kcondvar_t devi_ct_cv; /* contract cv */
257 int devi_ct_count; /* # of outstanding responses */
258 int devi_ct_neg; /* neg. occurred on dip */
259 list_t devi_ct;
260
261 /* owned by bus framework */
262 devi_bus_priv_t devi_bus; /* bus private data */
263
264 /* Declarations of the pure dynamic properties to snapshot */
265 struct i_ddi_prop_dyn *devi_prop_dyn_driver; /* prop_op */
266 struct i_ddi_prop_dyn *devi_prop_dyn_parent; /* bus_prop_op */
267
268 #if defined(__x86)
269 /* For x86 (Intel and AMD) IOMMU support */
270 void *devi_iommu;
271 iommulib_handle_t devi_iommulib_handle;
272 iommulib_nexhandle_t devi_iommulib_nex_handle;
273 #endif
274
275 /* Generic callback mechanism */
276 ddi_cb_t *devi_cb_p;
277
278 /* ndi 'flavors' */
279 ndi_flavor_t devi_flavor; /* flavor assigned by parent */
280 ndi_flavor_t devi_flavorv_n; /* number of child-flavors */
281 void **devi_flavorv; /* child-flavor specific data */
282
283 /* Owned by hotplug framework */
284 struct ddi_hp_cn_handle *devi_hp_hdlp; /* hotplug handle list */
285
286 struct in_node *devi_in_node; /* pointer to devinfo node's in_node_t */
287
288 /* detach event data */
289 char *devi_ev_path;
290 int devi_ev_instance;
291 };
292
293 #define DEVI(dev_info_type) ((struct dev_info *)(dev_info_type))
294
295 /*
296 * NB: The 'name' field, for compatibility with old code (both existing
297 * device drivers and userland code), is now defined as the name used
298 * to bind the node to a device driver, and not the device node name.
299 * If the device node name does not define a binding to a device driver,
300 * and the framework uses a different algorithm to create the binding to
301 * the driver, the node name and binding name will be different.
302 *
303 * Note that this implies that the node name plus instance number does
304 * NOT create a unique driver id; only the binding name plus instance
305 * number creates a unique driver id.
306 *
307 * New code should not use 'devi_name'; use 'devi_binding_name' or
308 * 'devi_node_name' and/or the routines that access those fields.
309 */
310
311 #define devi_name devi_binding_name
312
313 /*
314 * DDI_CF1, DDI_CF2 and DDI_DRV_UNLOADED are obsolete. They are kept
315 * around to allow legacy drivers to to compile.
316 */
317 #define DDI_CF1(devi) (DEVI(devi)->devi_addr != NULL)
318 #define DDI_CF2(devi) (DEVI(devi)->devi_ops != NULL)
319 #define DDI_DRV_UNLOADED(devi) (DEVI(devi)->devi_ops == &mod_nodev_ops)
320
321 /*
322 * The device state flags (devi_state) contains information regarding
323 * the state of the device (Online/Offline/Down). For bus nexus
324 * devices, the device state also contains state information regarding
325 * the state of the bus represented by this nexus node.
326 *
327 * Device state information is stored in bits [0-7], bus state in bits
328 * [8-15].
329 *
330 * NOTE: all devi_state updates should be protected by devi_lock.
331 */
332 #define DEVI_DEVICE_OFFLINE 0x00000001
333 #define DEVI_DEVICE_DOWN 0x00000002
334 #define DEVI_DEVICE_DEGRADED 0x00000004
335 #define DEVI_DEVICE_REMOVED 0x00000008 /* hardware removed */
336
337 #define DEVI_BUS_QUIESCED 0x00000100
338 #define DEVI_BUS_DOWN 0x00000200
339 #define DEVI_NDI_CONFIG 0x00000400 /* perform config when attaching */
340
341 #define DEVI_S_ATTACHING 0x00010000
342 #define DEVI_S_DETACHING 0x00020000
343 #define DEVI_S_ONLINING 0x00040000
344 #define DEVI_S_OFFLINING 0x00080000
345
346 #define DEVI_S_INVOKING_DACF 0x00100000 /* busy invoking a dacf task */
347
348 #define DEVI_S_UNBOUND 0x00200000
349 #define DEVI_S_REPORT 0x08000000 /* report status change */
350
351 #define DEVI_S_EVADD 0x10000000 /* state of devfs event */
352 #define DEVI_S_EVREMOVE 0x20000000 /* state of devfs event */
353 #define DEVI_S_NEED_RESET 0x40000000 /* devo_reset should be called */
354
355 /*
356 * Device state macros.
357 * o All SET/CLR/DONE users must protect context with devi_lock.
358 * o DEVI_SET_DEVICE_ONLINE users must do their own DEVI_SET_REPORT.
359 * o DEVI_SET_DEVICE_{DOWN|DEGRADED|UP} should only be used when !OFFLINE.
360 * o DEVI_SET_DEVICE_UP clears DOWN and DEGRADED.
361 */
362 #define DEVI_IS_DEVICE_OFFLINE(dip) \
363 ((DEVI(dip)->devi_state & DEVI_DEVICE_OFFLINE) == DEVI_DEVICE_OFFLINE)
364
365 #define DEVI_SET_DEVICE_ONLINE(dip) { \
366 ASSERT(mutex_owned(&DEVI(dip)->devi_lock)); \
367 if (DEVI(dip)->devi_state & DEVI_DEVICE_DEGRADED) { \
368 mutex_exit(&DEVI(dip)->devi_lock); \
369 e_ddi_undegrade_finalize(dip); \
370 mutex_enter(&DEVI(dip)->devi_lock); \
371 } \
372 /* setting ONLINE clears DOWN, DEGRADED, OFFLINE */ \
373 DEVI(dip)->devi_state &= ~(DEVI_DEVICE_DOWN | \
374 DEVI_DEVICE_DEGRADED | DEVI_DEVICE_OFFLINE); \
375 }
376
377 #define DEVI_SET_DEVICE_OFFLINE(dip) { \
378 ASSERT(mutex_owned(&DEVI(dip)->devi_lock)); \
379 DEVI(dip)->devi_state |= (DEVI_DEVICE_OFFLINE | DEVI_S_REPORT); \
380 }
381
382 #define DEVI_IS_DEVICE_DOWN(dip) \
383 ((DEVI(dip)->devi_state & DEVI_DEVICE_DOWN) == DEVI_DEVICE_DOWN)
384
385 #define DEVI_SET_DEVICE_DOWN(dip) { \
386 ASSERT(mutex_owned(&DEVI(dip)->devi_lock)); \
387 ASSERT(!DEVI_IS_DEVICE_OFFLINE(dip)); \
388 DEVI(dip)->devi_state |= (DEVI_DEVICE_DOWN | DEVI_S_REPORT); \
389 }
390
391 #define DEVI_IS_DEVICE_DEGRADED(dip) \
392 ((DEVI(dip)->devi_state & \
393 (DEVI_DEVICE_DEGRADED|DEVI_DEVICE_DOWN)) == DEVI_DEVICE_DEGRADED)
394
395 #define DEVI_SET_DEVICE_DEGRADED(dip) { \
396 ASSERT(mutex_owned(&DEVI(dip)->devi_lock)); \
397 ASSERT(!DEVI_IS_DEVICE_OFFLINE(dip)); \
398 mutex_exit(&DEVI(dip)->devi_lock); \
399 e_ddi_degrade_finalize(dip); \
400 mutex_enter(&DEVI(dip)->devi_lock); \
401 DEVI(dip)->devi_state |= (DEVI_DEVICE_DEGRADED | DEVI_S_REPORT); \
402 }
403
404 #define DEVI_SET_DEVICE_UP(dip) { \
405 ASSERT(mutex_owned(&DEVI(dip)->devi_lock)); \
406 ASSERT(!DEVI_IS_DEVICE_OFFLINE(dip)); \
407 if (DEVI(dip)->devi_state & DEVI_DEVICE_DEGRADED) { \
408 mutex_exit(&DEVI(dip)->devi_lock); \
409 e_ddi_undegrade_finalize(dip); \
410 mutex_enter(&DEVI(dip)->devi_lock); \
411 } \
412 DEVI(dip)->devi_state &= ~(DEVI_DEVICE_DEGRADED | DEVI_DEVICE_DOWN); \
413 DEVI(dip)->devi_state |= DEVI_S_REPORT; \
414 }
415
416 /* Device removal and insertion */
417 #define DEVI_IS_DEVICE_REMOVED(dip) \
418 ((DEVI(dip)->devi_state & DEVI_DEVICE_REMOVED) == DEVI_DEVICE_REMOVED)
419
420 #define DEVI_SET_DEVICE_REMOVED(dip) { \
421 ASSERT(mutex_owned(&DEVI(dip)->devi_lock)); \
422 DEVI(dip)->devi_state |= DEVI_DEVICE_REMOVED | DEVI_S_REPORT; \
423 }
424
425 #define DEVI_SET_DEVICE_REINSERTED(dip) { \
426 ASSERT(mutex_owned(&DEVI(dip)->devi_lock)); \
427 DEVI(dip)->devi_state &= ~DEVI_DEVICE_REMOVED; \
428 DEVI(dip)->devi_state |= DEVI_S_REPORT; \
429 }
430
431 /* Bus state change macros */
432 #define DEVI_IS_BUS_QUIESCED(dip) \
433 ((DEVI(dip)->devi_state & DEVI_BUS_QUIESCED) == DEVI_BUS_QUIESCED)
434
435 #define DEVI_SET_BUS_ACTIVE(dip) { \
436 ASSERT(mutex_owned(&DEVI(dip)->devi_lock)); \
437 DEVI(dip)->devi_state &= ~DEVI_BUS_QUIESCED; \
438 DEVI(dip)->devi_state |= DEVI_S_REPORT; \
439 }
440
441 #define DEVI_SET_BUS_QUIESCE(dip) { \
442 ASSERT(mutex_owned(&DEVI(dip)->devi_lock)); \
443 DEVI(dip)->devi_state |= (DEVI_BUS_QUIESCED | DEVI_S_REPORT); \
444 }
445
446 #define DEVI_IS_BUS_DOWN(dip) \
447 ((DEVI(dip)->devi_state & DEVI_BUS_DOWN) == DEVI_BUS_DOWN)
448
449 #define DEVI_SET_BUS_UP(dip) { \
450 ASSERT(mutex_owned(&DEVI(dip)->devi_lock)); \
451 DEVI(dip)->devi_state &= ~DEVI_BUS_DOWN; \
452 DEVI(dip)->devi_state |= DEVI_S_REPORT; \
453 }
454
455 #define DEVI_SET_BUS_DOWN(dip) { \
456 ASSERT(mutex_owned(&DEVI(dip)->devi_lock)); \
457 DEVI(dip)->devi_state |= (DEVI_BUS_DOWN | DEVI_S_REPORT); \
458 }
459
460 /* Status change report needed */
461 #define DEVI_NEED_REPORT(dip) \
462 ((DEVI(dip)->devi_state & DEVI_S_REPORT) == DEVI_S_REPORT)
463
464 #define DEVI_SET_REPORT(dip) { \
465 ASSERT(mutex_owned(&DEVI(dip)->devi_lock)); \
466 DEVI(dip)->devi_state |= DEVI_S_REPORT; \
467 }
468
469 #define DEVI_REPORT_DONE(dip) { \
470 ASSERT(mutex_owned(&DEVI(dip)->devi_lock)); \
471 DEVI(dip)->devi_state &= ~DEVI_S_REPORT; \
472 }
473
474 /* Do an NDI_CONFIG for its children */
475 #define DEVI_NEED_NDI_CONFIG(dip) \
476 ((DEVI(dip)->devi_state & DEVI_NDI_CONFIG) == DEVI_NDI_CONFIG)
477
478 #define DEVI_SET_NDI_CONFIG(dip) { \
479 ASSERT(mutex_owned(&DEVI(dip)->devi_lock)); \
480 DEVI(dip)->devi_state |= DEVI_NDI_CONFIG; \
481 }
482
483 #define DEVI_CLR_NDI_CONFIG(dip) { \
484 ASSERT(mutex_owned(&DEVI(dip)->devi_lock)); \
485 DEVI(dip)->devi_state &= ~DEVI_NDI_CONFIG; \
486 }
487
488 /* Attaching or detaching state */
489 #define DEVI_IS_ATTACHING(dip) \
490 ((DEVI(dip)->devi_state & DEVI_S_ATTACHING) == DEVI_S_ATTACHING)
491
492 #define DEVI_SET_ATTACHING(dip) { \
493 ASSERT(mutex_owned(&DEVI(dip)->devi_lock)); \
494 DEVI(dip)->devi_state |= DEVI_S_ATTACHING; \
495 }
496
497 #define DEVI_CLR_ATTACHING(dip) { \
498 ASSERT(mutex_owned(&DEVI(dip)->devi_lock)); \
499 DEVI(dip)->devi_state &= ~DEVI_S_ATTACHING; \
500 }
501
502 #define DEVI_IS_DETACHING(dip) \
503 ((DEVI(dip)->devi_state & DEVI_S_DETACHING) == DEVI_S_DETACHING)
504
505 #define DEVI_SET_DETACHING(dip) { \
506 ASSERT(mutex_owned(&DEVI(dip)->devi_lock)); \
507 DEVI(dip)->devi_state |= DEVI_S_DETACHING; \
508 }
509
510 #define DEVI_CLR_DETACHING(dip) { \
511 ASSERT(mutex_owned(&DEVI(dip)->devi_lock)); \
512 DEVI(dip)->devi_state &= ~DEVI_S_DETACHING; \
513 }
514
515 /* Onlining or offlining state */
516 #define DEVI_IS_ONLINING(dip) \
517 ((DEVI(dip)->devi_state & DEVI_S_ONLINING) == DEVI_S_ONLINING)
518
519 #define DEVI_SET_ONLINING(dip) { \
520 ASSERT(mutex_owned(&DEVI(dip)->devi_lock)); \
521 DEVI(dip)->devi_state |= DEVI_S_ONLINING; \
522 }
523
524 #define DEVI_CLR_ONLINING(dip) { \
525 ASSERT(mutex_owned(&DEVI(dip)->devi_lock)); \
526 DEVI(dip)->devi_state &= ~DEVI_S_ONLINING; \
527 }
528
529 #define DEVI_IS_OFFLINING(dip) \
530 ((DEVI(dip)->devi_state & DEVI_S_OFFLINING) == DEVI_S_OFFLINING)
531
532 #define DEVI_SET_OFFLINING(dip) { \
533 ASSERT(mutex_owned(&DEVI(dip)->devi_lock)); \
534 DEVI(dip)->devi_state |= DEVI_S_OFFLINING; \
535 }
536
537 #define DEVI_CLR_OFFLINING(dip) { \
538 ASSERT(mutex_owned(&DEVI(dip)->devi_lock)); \
539 DEVI(dip)->devi_state &= ~DEVI_S_OFFLINING; \
540 }
541
542 #define DEVI_IS_IN_RECONFIG(dip) \
543 (DEVI(dip)->devi_state & (DEVI_S_OFFLINING | DEVI_S_ONLINING))
544
545 /* Busy invoking a dacf task against this node */
546 #define DEVI_IS_INVOKING_DACF(dip) \
547 ((DEVI(dip)->devi_state & DEVI_S_INVOKING_DACF) == DEVI_S_INVOKING_DACF)
548
549 #define DEVI_SET_INVOKING_DACF(dip) { \
550 ASSERT(mutex_owned(&DEVI(dip)->devi_lock)); \
551 DEVI(dip)->devi_state |= DEVI_S_INVOKING_DACF; \
552 }
553
554 #define DEVI_CLR_INVOKING_DACF(dip) { \
555 ASSERT(mutex_owned(&DEVI(dip)->devi_lock)); \
556 DEVI(dip)->devi_state &= ~DEVI_S_INVOKING_DACF; \
557 }
558
559 /* Events for add/remove */
560 #define DEVI_EVADD(dip) \
561 ((DEVI(dip)->devi_state & DEVI_S_EVADD) == DEVI_S_EVADD)
562
563 #define DEVI_SET_EVADD(dip) { \
564 ASSERT(mutex_owned(&DEVI(dip)->devi_lock)); \
565 DEVI(dip)->devi_state &= ~DEVI_S_EVREMOVE; \
566 DEVI(dip)->devi_state |= DEVI_S_EVADD; \
567 }
568
569 #define DEVI_EVREMOVE(dip) \
570 ((DEVI(dip)->devi_state & DEVI_S_EVREMOVE) == DEVI_S_EVREMOVE)
571
572 #define DEVI_SET_EVREMOVE(dip) { \
573 ASSERT(mutex_owned(&DEVI(dip)->devi_lock)); \
574 DEVI(dip)->devi_state &= ~DEVI_S_EVADD; \
575 DEVI(dip)->devi_state |= DEVI_S_EVREMOVE; \
576 }
577
578 #define DEVI_SET_EVUNINIT(dip) { \
579 ASSERT(mutex_owned(&DEVI(dip)->devi_lock)); \
580 DEVI(dip)->devi_state &= ~(DEVI_S_EVADD | DEVI_S_EVREMOVE); \
581 }
582
583 /* Need to call the devo_reset entry point for this device at shutdown */
584 #define DEVI_NEED_RESET(dip) \
585 ((DEVI(dip)->devi_state & DEVI_S_NEED_RESET) == DEVI_S_NEED_RESET)
586
587 #define DEVI_SET_NEED_RESET(dip) { \
588 ASSERT(mutex_owned(&DEVI(dip)->devi_lock)); \
589 DEVI(dip)->devi_state |= DEVI_S_NEED_RESET; \
590 }
591
592 #define DEVI_CLR_NEED_RESET(dip) { \
593 ASSERT(mutex_owned(&DEVI(dip)->devi_lock)); \
594 DEVI(dip)->devi_state &= ~DEVI_S_NEED_RESET; \
595 }
596
597 /*
598 * devi_flags bits
599 *
600 * NOTE: all devi_state updates should be protected by devi_lock.
601 */
602 #define DEVI_BUSY 0x00000001 /* busy configuring children */
603 #define DEVI_MADE_CHILDREN 0x00000002 /* children made from specs */
604 #define DEVI_ATTACHED_CHILDREN 0x00000004 /* attached all existing children */
605 #define DEVI_BRANCH_HELD 0x00000008 /* branch rooted at this dip held */
606 #define DEVI_NO_BIND 0x00000010 /* prevent driver binding */
607 #define DEVI_CACHED_DEVID 0x00000020 /* devid cached in devid cache */
608 #define DEVI_PHCI_SIGNALS_VHCI 0x00000040 /* pHCI ndi_devi_exit signals vHCI */
609 #define DEVI_REBIND 0x00000080 /* post initchild driver rebind */
610 #define DEVI_RETIRED 0x00000100 /* device is retired */
611 #define DEVI_RETIRING 0x00000200 /* being evaluated for retire */
612 #define DEVI_R_CONSTRAINT 0x00000400 /* constraints have been applied */
613 #define DEVI_R_BLOCKED 0x00000800 /* constraints block retire */
614 #define DEVI_CT_NOP 0x00001000 /* NOP contract event occurred */
615 #define DEVI_PCI_DEVICE 0x00002000 /* dip is PCI */
616
617 #define DEVI_BUSY_CHANGING(dip) (DEVI(dip)->devi_flags & DEVI_BUSY)
618 #define DEVI_BUSY_OWNED(dip) (DEVI_BUSY_CHANGING(dip) && \
619 ((DEVI(dip))->devi_busy_thread == curthread))
620
621 #define DEVI_IS_PCI(dip) (DEVI(dip)->devi_flags & DEVI_PCI_DEVICE)
622 #define DEVI_SET_PCI(dip) (DEVI(dip)->devi_flags |= (DEVI_PCI_DEVICE))
623
624 char *i_ddi_devi_class(dev_info_t *);
625 int i_ddi_set_devi_class(dev_info_t *, char *, int);
626
627 /*
628 * This structure represents one piece of bus space occupied by a given
629 * device. It is used in an array for devices with multiple address windows.
630 */
631 struct regspec {
632 uint_t regspec_bustype; /* cookie for bus type it's on */
633 uint_t regspec_addr; /* address of reg relative to bus */
634 uint_t regspec_size; /* size of this register set */
635 };
636
637 /*
638 * This structure represents one piece of nexus bus space.
639 * It is used in an array for nexi with multiple bus spaces
640 * to define the childs offsets in the parents bus space.
641 */
642 struct rangespec {
643 uint_t rng_cbustype; /* Child's address, hi order */
644 uint_t rng_coffset; /* Child's address, lo order */
645 uint_t rng_bustype; /* Parent's address, hi order */
646 uint_t rng_offset; /* Parent's address, lo order */
647 uint_t rng_size; /* size of space for this entry */
648 };
649
650 #ifdef _KERNEL
651
652 typedef enum {
653 DDI_PRE = 0,
654 DDI_POST = 1
655 } ddi_pre_post_t;
656
657 /*
658 * This structure represents notification of a child attach event
659 * These could both be the same if attach/detach commands were in the
660 * same name space.
661 * Note that the target dip is passed as an arg already.
662 */
663 struct attachspec {
664 ddi_attach_cmd_t cmd; /* type of event */
665 ddi_pre_post_t when; /* one of DDI_PRE or DDI_POST */
666 dev_info_t *pdip; /* parent of attaching node */
667 int result; /* result of attach op (post command only) */
668 };
669
670 /*
671 * This structure represents notification of a child detach event
672 * Note that the target dip is passed as an arg already.
673 */
674 struct detachspec {
675 ddi_detach_cmd_t cmd; /* type of event */
676 ddi_pre_post_t when; /* one of DDI_PRE or DDI_POST */
677 dev_info_t *pdip; /* parent of detaching node */
678 int result; /* result of detach op (post command only) */
679 };
680
681 #endif /* _KERNEL */
682
683 typedef enum {
684 DDM_MINOR = 0,
685 DDM_ALIAS,
686 DDM_DEFAULT,
687 DDM_INTERNAL_PATH
688 } ddi_minor_type;
689
690 /* implementation flags for driver specified device access control */
691 #define DM_NO_FSPERM 0x1
692
693 struct devplcy;
694
695 struct ddi_minor {
696 char *name; /* name of node */
697 dev_t dev; /* device number */
698 int spec_type; /* block or char */
699 int flags; /* access flags */
700 char *node_type; /* block, byte, serial, network */
701 struct devplcy *node_priv; /* privilege for this minor */
702 mode_t priv_mode; /* default apparent privilege mode */
703 };
704
705 /*
706 * devi_node_attributes contains node attributes private to the
707 * ddi implementation. As a consumer, do not use these bit definitions
708 * directly, use the ndi functions that check for the existence of the
709 * specific node attributes.
710 *
711 * DDI_PERSISTENT indicates a 'persistent' node; one that is not
712 * automatically freed by the framework if the driver is unloaded
713 * or the driver fails to attach to this node.
714 *
715 * DDI_AUTO_ASSIGNED_NODEID indicates that the nodeid was auto-assigned
716 * by the framework and should be auto-freed if the node is removed.
717 *
718 * DDI_VHCI_NODE indicates that the node type is VHCI. This flag
719 * must be set by ndi_devi_config_vhci() routine only.
720 *
721 * DDI_HIDDEN_NODE indicates that the node should not show up in snapshots
722 * or in /devices.
723 *
724 * DDI_HOTPLUG_NODE indicates that the node created by nexus hotplug.
725 */
726 #define DDI_PERSISTENT 0x01
727 #define DDI_AUTO_ASSIGNED_NODEID 0x02
728 #define DDI_VHCI_NODE 0x04
729 #define DDI_HIDDEN_NODE 0x08
730 #define DDI_HOTPLUG_NODE 0x10
731
732 #define DEVI_VHCI_NODE(dip) \
733 (DEVI(dip)->devi_node_attributes & DDI_VHCI_NODE)
734
735 /*
736 * The ddi_minor_data structure gets filled in by ddi_create_minor_node.
737 * It then gets attached to the devinfo node as a property.
738 */
739 struct ddi_minor_data {
740 struct ddi_minor_data *next; /* next one in the chain */
741 dev_info_t *dip; /* pointer to devinfo node */
742 ddi_minor_type type; /* Following data type */
743 struct ddi_minor d_minor; /* Actual minor node data */
744 };
745
746 #define ddm_name d_minor.name
747 #define ddm_dev d_minor.dev
748 #define ddm_flags d_minor.flags
749 #define ddm_spec_type d_minor.spec_type
750 #define ddm_node_type d_minor.node_type
751 #define ddm_node_priv d_minor.node_priv
752 #define ddm_priv_mode d_minor.priv_mode
753
754 /*
755 * parent private data structure contains register, interrupt, property
756 * and range information.
757 */
758 struct ddi_parent_private_data {
759 int par_nreg; /* number of regs */
760 struct regspec *par_reg; /* array of regs */
761 int par_nintr; /* number of interrupts */
762 struct intrspec *par_intr; /* array of possible interrupts */
763 int par_nrng; /* number of ranges */
764 struct rangespec *par_rng; /* array of ranges */
765 };
766 #define DEVI_PD(d) \
767 ((struct ddi_parent_private_data *)DEVI((d))->devi_parent_data)
768
769 #define sparc_pd_getnreg(dev) (DEVI_PD(dev)->par_nreg)
770 #define sparc_pd_getnintr(dev) (DEVI_PD(dev)->par_nintr)
771 #define sparc_pd_getnrng(dev) (DEVI_PD(dev)->par_nrng)
772 #define sparc_pd_getreg(dev, n) (&DEVI_PD(dev)->par_reg[(n)])
773 #define sparc_pd_getintr(dev, n) (&DEVI_PD(dev)->par_intr[(n)])
774 #define sparc_pd_getrng(dev, n) (&DEVI_PD(dev)->par_rng[(n)])
775
776 #ifdef _KERNEL
777 /*
778 * This data structure is private to the indexed soft state allocator.
779 */
780 typedef struct i_ddi_soft_state {
781 void **array; /* the array of pointers */
782 kmutex_t lock; /* serialize access to this struct */
783 size_t size; /* how many bytes per state struct */
784 size_t n_items; /* how many structs herein */
785 struct i_ddi_soft_state *next; /* 'dirty' elements */
786 } i_ddi_soft_state;
787
788 /*
789 * This data structure is private to the stringhashed soft state allocator.
790 */
791 typedef struct i_ddi_soft_state_bystr {
792 size_t ss_size; /* how many bytes per state struct */
793 mod_hash_t *ss_mod_hash; /* hash implementation */
794 } i_ddi_soft_state_bystr;
795
796 /*
797 * This data structure is private to the ddi_strid_* implementation
798 */
799 typedef struct i_ddi_strid {
800 size_t strid_chunksz;
801 size_t strid_spacesz;
802 id_space_t *strid_space;
803 mod_hash_t *strid_byid;
804 mod_hash_t *strid_bystr;
805 } i_ddi_strid;
806 #endif /* _KERNEL */
807
808 /*
809 * Solaris DDI DMA implementation structure and function definitions.
810 *
811 * Note: no callers of DDI functions must depend upon data structures
812 * declared below. They are not guaranteed to remain constant.
813 */
814
815 /*
816 * Implementation DMA mapping structure.
817 *
818 * The publicly visible ddi_dma_req structure is filled
819 * in by a caller that wishes to map a memory object
820 * for DMA. Internal to this implementation of the public
821 * DDI DMA functions this request structure is put together
822 * with bus nexus specific functions that have additional
823 * information and constraints as to how to go about doing
824 * the requested mapping function
825 *
826 * In this implementation, some of the information from the
827 * original requester is retained throughout the lifetime
828 * of the I/O mapping being active.
829 */
830
831 /*
832 * This is the implementation specific description
833 * of how we've mapped an object for DMA.
834 */
835 #if defined(__sparc)
836 typedef struct ddi_dma_impl {
837 /*
838 * DMA mapping information
839 */
840 ulong_t dmai_mapping; /* mapping cookie */
841
842 /*
843 * Size of the current mapping, in bytes.
844 *
845 * Note that this is distinct from the size of the object being mapped
846 * for DVMA. We might have only a portion of the object mapped at any
847 * given point in time.
848 */
849 uint_t dmai_size;
850
851 /*
852 * Offset, in bytes, into object that is currently mapped.
853 */
854 off_t dmai_offset;
855
856 /*
857 * Information gathered from the original DMA mapping
858 * request and saved for the lifetime of the mapping.
859 */
860 uint_t dmai_minxfer;
861 uint_t dmai_burstsizes;
862 uint_t dmai_ndvmapages;
863 uint_t dmai_pool; /* cached DVMA space */
864 uint_t dmai_rflags; /* requester's flags + ours */
865 uint_t dmai_inuse; /* active handle? */
866 uint_t dmai_nwin;
867 uint_t dmai_winsize;
868 caddr_t dmai_nexus_private;
869 void *dmai_iopte;
870 uint_t *dmai_sbi;
871 void *dmai_minfo; /* random mapping information */
872 dev_info_t *dmai_rdip; /* original requester's dev_info_t */
873 ddi_dma_obj_t dmai_object; /* requester's object */
874 ddi_dma_attr_t dmai_attr; /* DMA attributes */
875 ddi_dma_cookie_t *dmai_cookie; /* pointer to first DMA cookie */
876
877 int (*dmai_fault_check)(struct ddi_dma_impl *handle);
878 void (*dmai_fault_notify)(struct ddi_dma_impl *handle);
879 int dmai_fault;
880 ndi_err_t dmai_error;
881
882 } ddi_dma_impl_t;
883
884 #elif defined(__x86)
885
886 /*
887 * ddi_dma_impl portion that genunix (sunddi.c) depends on. x86 rootnex
888 * implementation specific state is in dmai_private.
889 */
890 typedef struct ddi_dma_impl {
891 ddi_dma_cookie_t *dmai_cookie; /* array of DMA cookies */
892 void *dmai_private;
893
894 /*
895 * Information gathered from the original dma mapping
896 * request and saved for the lifetime of the mapping.
897 */
898 uint_t dmai_minxfer;
899 uint_t dmai_burstsizes;
900 uint_t dmai_rflags; /* requester's flags + ours */
901 int dmai_nwin;
902 dev_info_t *dmai_rdip; /* original requester's dev_info_t */
903
904 ddi_dma_attr_t dmai_attr; /* DMA attributes */
905
906 int (*dmai_fault_check)(struct ddi_dma_impl *handle);
907 void (*dmai_fault_notify)(struct ddi_dma_impl *handle);
908 int dmai_fault;
909 ndi_err_t dmai_error;
910 } ddi_dma_impl_t;
911
912 #else
913 #error "struct ddi_dma_impl not defined for this architecture"
914 #endif /* defined(__sparc) */
915
916 /*
917 * For now DMA segments share state with the DMA handle
918 */
919 typedef ddi_dma_impl_t ddi_dma_seg_impl_t;
920
921 /*
922 * These flags use reserved bits from the dma request flags.
923 *
924 * A note about the DMP_NOSYNC flags: the root nexus will
925 * set these as it sees best. If an intermediate nexus
926 * actually needs these operations, then during the unwind
927 * from the call to ddi_dma_bind, the nexus driver *must*
928 * clear the appropriate flag(s). This is because, as an
929 * optimization, ddi_dma_sync(9F) looks at these flags before
930 * deciding to spend the time going back up the tree.
931 */
932
933 #define _DMCM1 DDI_DMA_RDWR|DDI_DMA_REDZONE|DDI_DMA_PARTIAL
934 #define _DMCM2 DDI_DMA_CONSISTENT|DMP_VMEREQ
935 #define DMP_DDIFLAGS (_DMCM1|_DMCM2)
936 #define DMP_SHADOW 0x20
937 #define DMP_LKIOPB 0x40
938 #define DMP_LKSYSV 0x80
939 #define DMP_IOCACHE 0x100
940 #define DMP_USEHAT 0x200
941 #define DMP_PHYSADDR 0x400
942 #define DMP_INVALID 0x800
943 #define DMP_NOLIMIT 0x1000
944 #define DMP_VMEREQ 0x10000000
945 #define DMP_BYPASSNEXUS 0x20000000
946 #define DMP_NODEVSYNC 0x40000000
947 #define DMP_NOCPUSYNC 0x80000000
948 #define DMP_NOSYNC (DMP_NODEVSYNC|DMP_NOCPUSYNC)
949
950 /*
951 * In order to complete a device to device mapping that
952 * has percolated as high as an IU nexus (gone that high
953 * because the DMA request is a VADDR type), we define
954 * structure to use with the DDI_CTLOPS_DMAPMAPC request
955 * that re-traverses the request tree to finish the
956 * DMA 'mapping' for a device.
957 */
958 struct dma_phys_mapc {
959 struct ddi_dma_req *dma_req; /* original request */
960 ddi_dma_impl_t *mp; /* current handle, or none */
961 int nptes; /* number of ptes */
962 void *ptes; /* ptes already read */
963 };
964
965 #define MAXCALLBACK 20
966
967 /*
968 * Callback definitions
969 */
970 struct ddi_callback {
971 struct ddi_callback *c_nfree;
972 struct ddi_callback *c_nlist;
973 int (*c_call)();
974 int c_count;
975 caddr_t c_arg;
976 size_t c_size;
977 };
978
979 /*
980 * Pure dynamic property declaration. A pure dynamic property is a property
981 * for which a driver's prop_op(9E) implementation will return a value on
982 * demand, but the property name does not exist on a property list (global,
983 * driver, system, or hardware) - the person asking for the value must know
984 * the name and type information.
985 *
986 * For a pure dynamic property to show up in a di_init() devinfo shapshot, the
987 * devinfo driver must know name and type. The i_ddi_prop_dyn_t mechanism
988 * allows a driver to define an array of the name/type information of its
989 * dynamic properties. When a driver declares its dynamic properties in a
990 * i_ddi_prop_dyn_t array, and registers that array using
991 * i_ddi_prop_dyn_driver_set() the devinfo driver has sufficient information
992 * to represent the properties in a snapshot - calling the driver's
993 * prop_op(9E) to obtain values.
994 *
995 * The last element of a i_ddi_prop_dyn_t is detected via a NULL dp_name value.
996 *
997 * A pure dynamic property name associated with a minor_node/dev_t should be
998 * defined with a dp_spec_type of S_IFCHR or S_IFBLK, as appropriate. The
999 * driver's prop_op(9E) entry point will be called for all
1000 * ddi_create_minor_node(9F) nodes of the specified spec_type. For a driver
1001 * where not all minor_node/dev_t combinations support the same named
1002 * properties, it is the responsibility of the prop_op(9E) implementation to
1003 * sort out what combinations are appropriate.
1004 *
1005 * A pure dynamic property of a devinfo node should be defined with a
1006 * dp_spec_type of 0.
1007 *
1008 * NB: Public DDI property interfaces no longer support pure dynamic
1009 * properties, but they are still still used. A prime example is the cmlb
1010 * implementation of size(9P) properties. Using pure dynamic properties
1011 * reduces the space required to maintain per-partition information. Since
1012 * there are no public interfaces to create pure dynamic properties,
1013 * the i_ddi_prop_dyn_t mechanism should remain private.
1014 */
1015 typedef struct i_ddi_prop_dyn {
1016 char *dp_name; /* name of dynamic property */
1017 int dp_type; /* DDI_PROP_TYPE_ of property */
1018 int dp_spec_type; /* 0, S_IFCHR, S_IFBLK */
1019 } i_ddi_prop_dyn_t;
1020 void i_ddi_prop_dyn_driver_set(dev_info_t *,
1021 i_ddi_prop_dyn_t *);
1022 i_ddi_prop_dyn_t *i_ddi_prop_dyn_driver_get(dev_info_t *);
1023 void i_ddi_prop_dyn_parent_set(dev_info_t *,
1024 i_ddi_prop_dyn_t *);
1025 i_ddi_prop_dyn_t *i_ddi_prop_dyn_parent_get(dev_info_t *);
1026 void i_ddi_prop_dyn_cache_invalidate(dev_info_t *,
1027 i_ddi_prop_dyn_t *);
1028
1029 /*
1030 * Device id - Internal definition.
1031 */
1032 #define DEVID_MAGIC_MSB 0x69
1033 #define DEVID_MAGIC_LSB 0x64
1034 #define DEVID_REV_MSB 0x00
1035 #define DEVID_REV_LSB 0x01
1036 #define DEVID_HINT_SIZE 4
1037
1038 typedef struct impl_devid {
1039 uchar_t did_magic_hi; /* device id magic # (msb) */
1040 uchar_t did_magic_lo; /* device id magic # (lsb) */
1041 uchar_t did_rev_hi; /* device id revision # (msb) */
1042 uchar_t did_rev_lo; /* device id revision # (lsb) */
1043 uchar_t did_type_hi; /* device id type (msb) */
1044 uchar_t did_type_lo; /* device id type (lsb) */
1045 uchar_t did_len_hi; /* length of devid data (msb) */
1046 uchar_t did_len_lo; /* length of devid data (lsb) */
1047 char did_driver[DEVID_HINT_SIZE]; /* driver name - HINT */
1048 char did_id[1]; /* start of device id data */
1049 } impl_devid_t;
1050
1051 #define DEVID_GETTYPE(devid) ((ushort_t) \
1052 (((devid)->did_type_hi << NBBY) + \
1053 (devid)->did_type_lo))
1054
1055 #define DEVID_FORMTYPE(devid, type) (devid)->did_type_hi = hibyte((type)); \
1056 (devid)->did_type_lo = lobyte((type));
1057
1058 #define DEVID_GETLEN(devid) ((ushort_t) \
1059 (((devid)->did_len_hi << NBBY) + \
1060 (devid)->did_len_lo))
1061
1062 #define DEVID_FORMLEN(devid, len) (devid)->did_len_hi = hibyte((len)); \
1063 (devid)->did_len_lo = lobyte((len));
1064
1065 /*
1066 * Per PSARC/1995/352, a binary devid contains fields for <magic number>,
1067 * <revision>, <driver_hint>, <type>, <id_length>, and the <id> itself.
1068 * This proposal would encode the binary devid into a string consisting
1069 * of "<magic><revision>,<driver_hint>@<type><id>" as indicated below
1070 * (<id_length> is rederived from the length of the string
1071 * representation of the <id>):
1072 *
1073 * <magic> ->"id"
1074 *
1075 * <rev> ->"%d" // "0" -> type of DEVID_NONE "id0"
1076 * // NOTE: PSARC/1995/352 <revision> is "1".
1077 * // NOTE: support limited to 10 revisions
1078 * // in current implementation
1079 *
1080 * <driver_hint> ->"%s" // "sd"/"ssd"
1081 * // NOTE: driver names limited to 4
1082 * // characters for <revision> "1"
1083 *
1084 * <type> ->'w' | // DEVID_SCSI3_WWN <hex_id>
1085 * 'W' | // DEVID_SCSI3_WWN <ascii_id>
1086 * 't' | // DEVID_SCSI3_VPD_T10 <hex_id>
1087 * 'T' | // DEVID_SCSI3_VPD_T10 <ascii_id>
1088 * 'x' | // DEVID_SCSI3_VPD_EUI <hex_id>
1089 * 'X' | // DEVID_SCSI3_VPD_EUI <ascii_id>
1090 * 'n' | // DEVID_SCSI3_VPD_NAA <hex_id>
1091 * 'N' | // DEVID_SCSI3_VPD_NAA <ascii_id>
1092 * 's' | // DEVID_SCSI_SERIAL <hex_id>
1093 * 'S' | // DEVID_SCSI_SERIAL <ascii_id>
1094 * 'f' | // DEVID_FAB <hex_id>
1095 * 'F' | // DEVID_FAB <ascii_id>
1096 * 'e' | // DEVID_ENCAP <hex_id>
1097 * 'E' | // DEVID_ENCAP <ascii_id>
1098 * 'a' | // DEVID_ATA_SERIAL <hex_id>
1099 * 'A' | // DEVID_ATA_SERIAL <ascii_id>
1100 * 'u' | // unknown <hex_id>
1101 * 'U' // unknown <ascii_id>
1102 * // NOTE:lower case -> <hex_id>
1103 * // upper case -> <ascii_id>
1104 * // NOTE:this covers all types currently
1105 * // defined for <revision> 1.
1106 * // NOTE:a <type> can be added
1107 * // without changing the <revision>.
1108 *
1109 * <id> -> <ascii_id> | // <type> is upper case
1110 * <hex_id> // <type> is lower case
1111 *
1112 * <ascii_id> // only if all bytes of binary <id> field
1113 * // are in the set:
1114 * // [A-Z][a-z][0-9]+-.= and space and 0x00
1115 * // the encoded form is:
1116 * // [A-Z][a-z][0-9]+-.= and _ and ~
1117 * // NOTE: ' ' <=> '_', 0x00 <=> '~'
1118 * // these sets are chosen to avoid shell
1119 * // and conflicts with DDI node names.
1120 *
1121 * <hex_id> // if not <ascii_id>; each byte of binary
1122 * // <id> maps a to 2 digit ascii hex
1123 * // representation in the string.
1124 *
1125 * This encoding provides a meaningful correlation between the /devices
1126 * path and the devid string where possible.
1127 *
1128 * Fibre:
1129 * sbus@6,0/SUNW,socal@d,10000/sf@1,0/ssd@w21000020370bb488,0:c,raw
1130 * id1,ssd@w20000020370bb488:c,raw
1131 *
1132 * Copper:
1133 * sbus@7,0/SUNW,fas@3,8800000/sd@a,0:c
1134 * id1,sd@SIBM_____1XY210__________:c
1135 */
1136 /* determine if a byte of an id meets ASCII representation requirements */
1137 #define DEVID_IDBYTE_ISASCII(b) ( \
1138 (((b) >= 'a') && ((b) <= 'z')) || \
1139 (((b) >= 'A') && ((b) <= 'Z')) || \
1140 (((b) >= '0') && ((b) <= '9')) || \
1141 (b == '+') || (b == '-') || (b == '.') || (b == '=') || \
1142 (b == ' ') || (b == 0x00))
1143
1144 /* set type to lower case to indicate that the did_id field is ascii */
1145 #define DEVID_TYPE_SETASCII(c) (c - 0x20) /* 'a' -> 'A' */
1146
1147 /* determine from type if did_id field is binary or ascii */
1148 #define DEVID_TYPE_ISASCII(c) (((c) >= 'A') && ((c) <= 'Z'))
1149
1150 /* convert type field from binary to ascii */
1151 #define DEVID_TYPE_BINTOASCII(b) ( \
1152 ((b) == DEVID_SCSI3_WWN) ? 'w' : \
1153 ((b) == DEVID_SCSI3_VPD_T10) ? 't' : \
1154 ((b) == DEVID_SCSI3_VPD_EUI) ? 'x' : \
1155 ((b) == DEVID_SCSI3_VPD_NAA) ? 'n' : \
1156 ((b) == DEVID_SCSI_SERIAL) ? 's' : \
1157 ((b) == DEVID_FAB) ? 'f' : \
1158 ((b) == DEVID_ENCAP) ? 'e' : \
1159 ((b) == DEVID_ATA_SERIAL) ? 'a' : \
1160 'u') /* unknown */
1161
1162 /* convert type field from ascii to binary */
1163 #define DEVID_TYPE_ASCIITOBIN(c) ( \
1164 (((c) == 'w') || ((c) == 'W')) ? DEVID_SCSI3_WWN : \
1165 (((c) == 't') || ((c) == 'T')) ? DEVID_SCSI3_VPD_T10 : \
1166 (((c) == 'x') || ((c) == 'X')) ? DEVID_SCSI3_VPD_EUI : \
1167 (((c) == 'n') || ((c) == 'N')) ? DEVID_SCSI3_VPD_NAA : \
1168 (((c) == 's') || ((c) == 'S')) ? DEVID_SCSI_SERIAL : \
1169 (((c) == 'f') || ((c) == 'F')) ? DEVID_FAB : \
1170 (((c) == 'e') || ((c) == 'E')) ? DEVID_ENCAP : \
1171 (((c) == 'a') || ((c) == 'A')) ? DEVID_ATA_SERIAL : \
1172 DEVID_MAXTYPE +1) /* unknown */
1173
1174 /* determine if the type should be forced to hex encoding (non-ascii) */
1175 #define DEVID_TYPE_BIN_FORCEHEX(b) ( \
1176 ((b) == DEVID_SCSI3_WWN) || \
1177 ((b) == DEVID_SCSI3_VPD_EUI) || \
1178 ((b) == DEVID_SCSI3_VPD_NAA) || \
1179 ((b) == DEVID_FAB))
1180
1181 /* determine if the type is from a scsi3 vpd */
1182 #define IS_DEVID_SCSI3_VPD_TYPE(b) ( \
1183 ((b) == DEVID_SCSI3_VPD_T10) || \
1184 ((b) == DEVID_SCSI3_VPD_EUI) || \
1185 ((b) == DEVID_SCSI3_VPD_NAA))
1186
1187 /* convert rev field from binary to ascii (only supports 10 revs) */
1188 #define DEVID_REV_BINTOASCII(b) (b + '0')
1189
1190 /* convert rev field from ascii to binary (only supports 10 revs) */
1191 #define DEVID_REV_ASCIITOBIN(c) (c - '0')
1192
1193 /* name of devid property */
1194 #define DEVID_PROP_NAME "devid"
1195
1196 /*
1197 * prop_name used by pci_{save,restore}_config_regs()
1198 */
1199 #define SAVED_CONFIG_REGS "pci-config-regs"
1200 #define SAVED_CONFIG_REGS_MASK "pcie-config-regs-mask"
1201 #define SAVED_CONFIG_REGS_CAPINFO "pci-cap-info"
1202
1203 typedef struct pci_config_header_state {
1204 uint16_t chs_command;
1205 uint8_t chs_cache_line_size;
1206 uint8_t chs_latency_timer;
1207 uint8_t chs_header_type;
1208 uint8_t chs_sec_latency_timer;
1209 uint8_t chs_bridge_control;
1210 uint32_t chs_base0;
1211 uint32_t chs_base1;
1212 uint32_t chs_base2;
1213 uint32_t chs_base3;
1214 uint32_t chs_base4;
1215 uint32_t chs_base5;
1216 } pci_config_header_state_t;
1217
1218 #ifdef _KERNEL
1219
1220 typedef struct pci_cap_save_desc {
1221 uint16_t cap_offset;
1222 uint16_t cap_id;
1223 uint32_t cap_nregs;
1224 } pci_cap_save_desc_t;
1225
1226 typedef struct pci_cap_entry {
1227 uint16_t cap_id;
1228 uint16_t cap_reg;
1229 uint16_t cap_mask;
1230 uint32_t cap_ndwords;
1231 uint32_t (*cap_save_func)(ddi_acc_handle_t confhdl, uint16_t cap_ptr,
1232 uint32_t *regbuf, uint32_t ndwords);
1233 } pci_cap_entry_t;
1234
1235 #endif /* _KERNEL */
1236
1237 #ifdef __cplusplus
1238 }
1239 #endif
1240
1241 #endif /* _SYS_DDI_IMPLDEFS_H */
Unleashed OS