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