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 2009 Sun Microsystems, Inc. All rights reserved. 23 * Use is subject to license terms. 24 */ 25 26 #include <sys/types.h> 27 #include <sys/param.h> 28 #include <sys/systm.h> 29 #include <sys/buf.h> 30 #include <sys/uio.h> 31 #include <sys/cred.h> 32 #include <sys/poll.h> 33 #include <sys/mman.h> 34 #include <sys/kmem.h> 35 #include <sys/model.h> 36 #include <sys/file.h> 37 #include <sys/proc.h> 38 #include <sys/open.h> 39 #include <sys/user.h> 40 #include <sys/t_lock.h> 41 #include <sys/vm.h> 42 #include <sys/stat.h> 43 #include <vm/hat.h> 44 #include <vm/seg.h> 45 #include <vm/as.h> 46 #include <sys/cmn_err.h> 47 #include <sys/debug.h> 48 #include <sys/avintr.h> 49 #include <sys/autoconf.h> 50 #include <sys/sunddi.h> 51 #include <sys/esunddi.h> 52 #include <sys/sunndi.h> 53 #include <sys/ddi.h> 54 #include <sys/kstat.h> 55 #include <sys/conf.h> 56 #include <sys/ddi_impldefs.h> /* include implementation structure defs */ 57 #include <sys/ndi_impldefs.h> 58 #include <sys/hwconf.h> 59 #include <sys/pathname.h> 60 #include <sys/modctl.h> 61 #include <sys/epm.h> 62 #include <sys/devctl.h> 63 #include <sys/callb.h> 64 #include <sys/bootconf.h> 65 #include <sys/dacf_impl.h> 66 #include <sys/nvpair.h> 67 #include <sys/sunmdi.h> 68 #include <sys/fs/dv_node.h> 69 #include <sys/sunldi_impl.h> 70 71 #ifdef __sparc 72 #include <sys/archsystm.h> /* getpil/setpil */ 73 #include <sys/membar.h> /* membar_sync */ 74 #endif 75 76 /* 77 * ndi property handling 78 */ 79 int 80 ndi_prop_update_int(dev_t match_dev, dev_info_t *dip, 81 char *name, int data) 82 { 83 return (ddi_prop_update_common(match_dev, dip, 84 DDI_PROP_HW_DEF | DDI_PROP_TYPE_INT | DDI_PROP_DONTSLEEP, 85 name, &data, 1, ddi_prop_fm_encode_ints)); 86 } 87 88 int 89 ndi_prop_update_int64(dev_t match_dev, dev_info_t *dip, 90 char *name, int64_t data) 91 { 92 return (ddi_prop_update_common(match_dev, dip, 93 DDI_PROP_HW_DEF | DDI_PROP_TYPE_INT64 | DDI_PROP_DONTSLEEP, 94 name, &data, 1, ddi_prop_fm_encode_int64)); 95 } 96 97 int 98 ndi_prop_create_boolean(dev_t match_dev, dev_info_t *dip, 99 char *name) 100 { 101 return (ddi_prop_update_common(match_dev, dip, 102 DDI_PROP_HW_DEF | DDI_PROP_TYPE_ANY | DDI_PROP_DONTSLEEP, 103 name, NULL, 0, ddi_prop_fm_encode_bytes)); 104 } 105 106 int 107 ndi_prop_update_int_array(dev_t match_dev, dev_info_t *dip, 108 char *name, int *data, uint_t nelements) 109 { 110 return (ddi_prop_update_common(match_dev, dip, 111 DDI_PROP_HW_DEF | DDI_PROP_TYPE_INT | DDI_PROP_DONTSLEEP, 112 name, data, nelements, ddi_prop_fm_encode_ints)); 113 } 114 115 int 116 ndi_prop_update_int64_array(dev_t match_dev, dev_info_t *dip, 117 char *name, int64_t *data, uint_t nelements) 118 { 119 return (ddi_prop_update_common(match_dev, dip, 120 DDI_PROP_HW_DEF | DDI_PROP_TYPE_INT64 | DDI_PROP_DONTSLEEP, 121 name, data, nelements, ddi_prop_fm_encode_int64)); 122 } 123 124 int 125 ndi_prop_update_string(dev_t match_dev, dev_info_t *dip, 126 char *name, char *data) 127 { 128 return (ddi_prop_update_common(match_dev, dip, 129 DDI_PROP_HW_DEF | DDI_PROP_TYPE_STRING | DDI_PROP_DONTSLEEP, 130 name, &data, 1, ddi_prop_fm_encode_string)); 131 } 132 133 int 134 ndi_prop_update_string_array(dev_t match_dev, dev_info_t *dip, 135 char *name, char **data, uint_t nelements) 136 { 137 return (ddi_prop_update_common(match_dev, dip, 138 DDI_PROP_HW_DEF | DDI_PROP_TYPE_STRING | DDI_PROP_DONTSLEEP, 139 name, data, nelements, 140 ddi_prop_fm_encode_strings)); 141 } 142 143 int 144 ndi_prop_update_byte_array(dev_t match_dev, dev_info_t *dip, 145 char *name, uchar_t *data, uint_t nelements) 146 { 147 if (nelements == 0) 148 return (DDI_PROP_INVAL_ARG); 149 150 return (ddi_prop_update_common(match_dev, dip, 151 DDI_PROP_HW_DEF | DDI_PROP_TYPE_BYTE | DDI_PROP_DONTSLEEP, 152 name, data, nelements, ddi_prop_fm_encode_bytes)); 153 } 154 155 int 156 ndi_prop_remove(dev_t dev, dev_info_t *dip, char *name) 157 { 158 return (ddi_prop_remove_common(dev, dip, name, DDI_PROP_HW_DEF)); 159 } 160 161 void 162 ndi_prop_remove_all(dev_info_t *dip) 163 { 164 i_ddi_prop_dyn_parent_set(dip, NULL); 165 ddi_prop_remove_all_common(dip, (int)DDI_PROP_HW_DEF); 166 } 167 168 /* 169 * Post an event notification to nexus driver responsible for handling 170 * the event. The responsible nexus is defined in the cookie passed in as 171 * the third parameter. 172 * The dip parameter is an artifact of an older implementation in which all 173 * requests to remove an eventcall would bubble up the tree. Today, this 174 * parameter is ignored. 175 * Input Parameters: 176 * dip - Ignored. 177 * rdip - device driver posting the event 178 * cookie - valid ddi_eventcookie_t, obtained by caller prior to 179 * invocation of this routine 180 * impl_data - used by framework 181 */ 182 /*ARGSUSED*/ 183 int 184 ndi_post_event(dev_info_t *dip, dev_info_t *rdip, 185 ddi_eventcookie_t cookie, void *impl_data) 186 { 187 dev_info_t *ddip; 188 189 ASSERT(cookie); 190 ddip = NDI_EVENT_DDIP(cookie); 191 192 /* 193 * perform sanity checks. These conditions should never be true. 194 */ 195 196 ASSERT(DEVI(ddip)->devi_ops->devo_bus_ops != NULL); 197 ASSERT(DEVI(ddip)->devi_ops->devo_bus_ops->busops_rev >= BUSO_REV_6); 198 ASSERT(DEVI(ddip)->devi_ops->devo_bus_ops->bus_post_event != NULL); 199 200 /* 201 * post the event to the responsible ancestor 202 */ 203 return ((*(DEVI(ddip)->devi_ops->devo_bus_ops->bus_post_event)) 204 (ddip, rdip, cookie, impl_data)); 205 } 206 207 /* 208 * Calls the bus nexus driver's implementation of the 209 * (*bus_remove_eventcall)() interface. 210 */ 211 int 212 ndi_busop_remove_eventcall(dev_info_t *ddip, ddi_callback_id_t id) 213 { 214 215 ASSERT(id); 216 /* check for a correct revno before calling up the device tree. */ 217 ASSERT(DEVI(ddip)->devi_ops->devo_bus_ops != NULL); 218 ASSERT(DEVI(ddip)->devi_ops->devo_bus_ops->busops_rev >= BUSO_REV_6); 219 220 if (DEVI(ddip)->devi_ops->devo_bus_ops->bus_remove_eventcall == NULL) 221 return (DDI_FAILURE); 222 223 /* 224 * request responsible nexus to remove the eventcall 225 */ 226 return ((*(DEVI(ddip)->devi_ops->devo_bus_ops->bus_remove_eventcall)) 227 (ddip, id)); 228 } 229 230 /* 231 * Calls the bus nexus driver's implementation of the 232 * (*bus_add_eventcall)() interface. The dip parameter is an 233 * artifact of an older implementation in which all requests to 234 * add an eventcall would bubble up the tree. Today, this parameter is 235 * ignored. 236 */ 237 /*ARGSUSED*/ 238 int 239 ndi_busop_add_eventcall(dev_info_t *dip, dev_info_t *rdip, 240 ddi_eventcookie_t cookie, void (*callback)(), void *arg, 241 ddi_callback_id_t *cb_id) 242 { 243 dev_info_t *ddip = (dev_info_t *)NDI_EVENT_DDIP(cookie); 244 245 /* 246 * check for a correct revno before calling up the device tree. 247 */ 248 ASSERT(DEVI(ddip)->devi_ops->devo_bus_ops != NULL); 249 ASSERT(DEVI(ddip)->devi_ops->devo_bus_ops->busops_rev >= BUSO_REV_6); 250 251 if (DEVI(ddip)->devi_ops->devo_bus_ops->bus_add_eventcall == NULL) 252 return (DDI_FAILURE); 253 254 /* 255 * request responsible ancestor to add the eventcall 256 */ 257 return ((*(DEVI(ddip)->devi_ops->devo_bus_ops->bus_add_eventcall)) 258 (ddip, rdip, cookie, callback, arg, cb_id)); 259 } 260 261 /* 262 * Calls the bus nexus driver's implementation of the 263 * (*bus_get_eventcookie)() interface up the device tree hierarchy. 264 */ 265 int 266 ndi_busop_get_eventcookie(dev_info_t *dip, dev_info_t *rdip, char *name, 267 ddi_eventcookie_t *event_cookiep) 268 { 269 dev_info_t *pdip = (dev_info_t *)DEVI(dip)->devi_parent; 270 271 /* Can not be called from rootnex. */ 272 ASSERT(pdip); 273 274 /* 275 * check for a correct revno before calling up the device tree. 276 */ 277 ASSERT(DEVI(pdip)->devi_ops->devo_bus_ops != NULL); 278 279 if ((DEVI(pdip)->devi_ops->devo_bus_ops->busops_rev < BUSO_REV_6) || 280 (DEVI(pdip)->devi_ops->devo_bus_ops->bus_get_eventcookie == NULL)) { 281 #ifdef DEBUG 282 if ((DEVI(pdip)->devi_ops->devo_bus_ops->busops_rev >= 283 BUSO_REV_3) && 284 (DEVI(pdip)->devi_ops->devo_bus_ops->bus_get_eventcookie)) { 285 cmn_err(CE_WARN, 286 "Warning: %s%d busops_rev=%d no longer supported" 287 " by the NDI event framework.\nBUSO_REV_6 or " 288 "greater must be used.", 289 DEVI(pdip)->devi_binding_name, 290 DEVI(pdip)->devi_instance, 291 DEVI(pdip)->devi_ops->devo_bus_ops->busops_rev); 292 } 293 #endif /* DEBUG */ 294 295 return (ndi_busop_get_eventcookie(pdip, rdip, name, 296 event_cookiep)); 297 } 298 299 return ((*(DEVI(pdip)->devi_ops->devo_bus_ops->bus_get_eventcookie)) 300 (pdip, rdip, name, event_cookiep)); 301 } 302 303 /* 304 * Copy in the devctl IOCTL data and return a handle to 305 * the data. 306 */ 307 int 308 ndi_dc_allochdl(void *iocarg, struct devctl_iocdata **rdcp) 309 { 310 struct devctl_iocdata *dcp; 311 char *cpybuf; 312 313 ASSERT(rdcp != NULL); 314 315 dcp = kmem_zalloc(sizeof (*dcp), KM_SLEEP); 316 317 if (get_udatamodel() == DATAMODEL_NATIVE) { 318 if (copyin(iocarg, dcp, sizeof (*dcp)) != 0) { 319 kmem_free(dcp, sizeof (*dcp)); 320 return (NDI_FAULT); 321 } 322 } 323 #ifdef _SYSCALL32_IMPL 324 else { 325 struct devctl_iocdata32 dcp32; 326 327 if (copyin(iocarg, &dcp32, sizeof (dcp32)) != 0) { 328 kmem_free(dcp, sizeof (*dcp)); 329 return (NDI_FAULT); 330 } 331 dcp->cmd = (uint_t)dcp32.cmd; 332 dcp->flags = (uint_t)dcp32.flags; 333 dcp->cpyout_buf = (uint_t *)(uintptr_t)dcp32.cpyout_buf; 334 dcp->nvl_user = (nvlist_t *)(uintptr_t)dcp32.nvl_user; 335 dcp->nvl_usersz = (size_t)dcp32.nvl_usersz; 336 dcp->c_nodename = (char *)(uintptr_t)dcp32.c_nodename; 337 dcp->c_unitaddr = (char *)(uintptr_t)dcp32.c_unitaddr; 338 } 339 #endif 340 if (dcp->c_nodename != NULL) { 341 cpybuf = kmem_alloc(MAXNAMELEN, KM_SLEEP); 342 if (copyinstr(dcp->c_nodename, cpybuf, MAXNAMELEN, 0) != 0) { 343 kmem_free(cpybuf, MAXNAMELEN); 344 kmem_free(dcp, sizeof (*dcp)); 345 return (NDI_FAULT); 346 } 347 cpybuf[MAXNAMELEN - 1] = '\0'; 348 dcp->c_nodename = cpybuf; 349 } 350 351 if (dcp->c_unitaddr != NULL) { 352 cpybuf = kmem_alloc(MAXNAMELEN, KM_SLEEP); 353 if (copyinstr(dcp->c_unitaddr, cpybuf, MAXNAMELEN, 0) != 0) { 354 kmem_free(cpybuf, MAXNAMELEN); 355 if (dcp->c_nodename != NULL) 356 kmem_free(dcp->c_nodename, MAXNAMELEN); 357 kmem_free(dcp, sizeof (*dcp)); 358 return (NDI_FAULT); 359 } 360 cpybuf[MAXNAMELEN - 1] = '\0'; 361 dcp->c_unitaddr = cpybuf; 362 } 363 364 /* 365 * copyin and unpack a user defined nvlist if one was passed 366 */ 367 if (dcp->nvl_user != NULL) { 368 if ((dcp->nvl_usersz == 0) || 369 (dcp->nvl_usersz > DEVCTL_MAX_NVL_USERSZ)) { 370 if (dcp->c_nodename != NULL) 371 kmem_free(dcp->c_nodename, MAXNAMELEN); 372 if (dcp->c_unitaddr != NULL) 373 kmem_free(dcp->c_unitaddr, MAXNAMELEN); 374 kmem_free(dcp, sizeof (*dcp)); 375 return (NDI_FAILURE); 376 } 377 cpybuf = kmem_alloc(dcp->nvl_usersz, KM_SLEEP); 378 if (copyin(dcp->nvl_user, cpybuf, dcp->nvl_usersz) != 0) { 379 kmem_free(cpybuf, dcp->nvl_usersz); 380 if (dcp->c_nodename != NULL) 381 kmem_free(dcp->c_nodename, MAXNAMELEN); 382 if (dcp->c_unitaddr != NULL) 383 kmem_free(dcp->c_unitaddr, MAXNAMELEN); 384 kmem_free(dcp, sizeof (*dcp)); 385 return (NDI_FAULT); 386 } 387 388 if (nvlist_unpack(cpybuf, dcp->nvl_usersz, &dcp->nvl_user, 389 KM_SLEEP)) { 390 kmem_free(cpybuf, dcp->nvl_usersz); 391 if (dcp->c_nodename != NULL) 392 kmem_free(dcp->c_nodename, MAXNAMELEN); 393 if (dcp->c_unitaddr != NULL) 394 kmem_free(dcp->c_unitaddr, MAXNAMELEN); 395 kmem_free(dcp, sizeof (*dcp)); 396 return (NDI_FAULT); 397 } 398 /* 399 * free the buffer containing the packed nvlist 400 */ 401 kmem_free(cpybuf, dcp->nvl_usersz); 402 403 } 404 405 *rdcp = dcp; 406 return (NDI_SUCCESS); 407 } 408 409 /* 410 * free all space allocated to a handle. 411 */ 412 void 413 ndi_dc_freehdl(struct devctl_iocdata *dcp) 414 { 415 ASSERT(dcp != NULL); 416 417 if (dcp->c_nodename != NULL) 418 kmem_free(dcp->c_nodename, MAXNAMELEN); 419 420 if (dcp->c_unitaddr != NULL) 421 kmem_free(dcp->c_unitaddr, MAXNAMELEN); 422 423 nvlist_free(dcp->nvl_user); 424 425 kmem_free(dcp, sizeof (*dcp)); 426 } 427 428 char * 429 ndi_dc_getname(struct devctl_iocdata *dcp) 430 { 431 ASSERT(dcp != NULL); 432 return (dcp->c_nodename); 433 434 } 435 436 char * 437 ndi_dc_getaddr(struct devctl_iocdata *dcp) 438 { 439 ASSERT(dcp != NULL); 440 return (dcp->c_unitaddr); 441 } 442 443 nvlist_t * 444 ndi_dc_get_ap_data(struct devctl_iocdata *dcp) 445 { 446 ASSERT(dcp != NULL); 447 448 return (dcp->nvl_user); 449 } 450 451 /* 452 * Transition the child named by "devname@devaddr" to the online state. 453 * For use by a driver's DEVCTL_DEVICE_ONLINE handler. 454 */ 455 int 456 ndi_devctl_device_online(dev_info_t *dip, struct devctl_iocdata *dcp, 457 uint_t flags) 458 { 459 int rval; 460 char *name; 461 dev_info_t *rdip; 462 463 if (ndi_dc_getname(dcp) == NULL || ndi_dc_getaddr(dcp) == NULL) 464 return (EINVAL); 465 466 name = kmem_alloc(MAXNAMELEN, KM_SLEEP); 467 (void) snprintf(name, MAXNAMELEN, "%s@%s", 468 ndi_dc_getname(dcp), ndi_dc_getaddr(dcp)); 469 470 if ((rval = ndi_devi_config_one(dip, name, &rdip, 471 flags | NDI_DEVI_ONLINE | NDI_CONFIG)) == NDI_SUCCESS) { 472 ndi_rele_devi(rdip); 473 474 /* 475 * Invalidate devfs cached directory contents. For the checks 476 * in the "if" condition see the comment in ndi_devi_online(). 477 */ 478 if (i_ddi_devi_attached(dip) && !DEVI_BUSY_OWNED(dip)) 479 (void) devfs_clean(dip, NULL, 0); 480 481 } else if (rval == NDI_BUSY) { 482 rval = EBUSY; 483 } else if (rval == NDI_FAILURE) { 484 rval = EIO; 485 } 486 487 NDI_DEBUG(flags, (CE_CONT, "%s%d: online: %s: %s\n", 488 ddi_driver_name(dip), ddi_get_instance(dip), name, 489 ((rval == NDI_SUCCESS) ? "ok" : "failed"))); 490 491 kmem_free(name, MAXNAMELEN); 492 493 return (rval); 494 } 495 496 /* 497 * Transition the child named by "devname@devaddr" to the offline state. 498 * For use by a driver's DEVCTL_DEVICE_OFFLINE handler. 499 */ 500 int 501 ndi_devctl_device_offline(dev_info_t *dip, struct devctl_iocdata *dcp, 502 uint_t flags) 503 { 504 int rval; 505 char *name; 506 507 if (ndi_dc_getname(dcp) == NULL || ndi_dc_getaddr(dcp) == NULL) 508 return (EINVAL); 509 510 name = kmem_alloc(MAXNAMELEN, KM_SLEEP); 511 (void) snprintf(name, MAXNAMELEN, "%s@%s", 512 ndi_dc_getname(dcp), ndi_dc_getaddr(dcp)); 513 514 (void) devfs_clean(dip, name, DV_CLEAN_FORCE); 515 rval = ndi_devi_unconfig_one(dip, name, NULL, 516 flags | NDI_DEVI_OFFLINE); 517 518 if (rval == NDI_BUSY) { 519 rval = EBUSY; 520 } else if (rval == NDI_FAILURE) { 521 rval = EIO; 522 } 523 524 NDI_DEBUG(flags, (CE_CONT, "%s%d: offline: %s: %s\n", 525 ddi_driver_name(dip), ddi_get_instance(dip), name, 526 (rval == NDI_SUCCESS) ? "ok" : "failed")); 527 528 kmem_free(name, MAXNAMELEN); 529 530 return (rval); 531 } 532 533 /* 534 * Remove the child named by "devname@devaddr". 535 * For use by a driver's DEVCTL_DEVICE_REMOVE handler. 536 */ 537 int 538 ndi_devctl_device_remove(dev_info_t *dip, struct devctl_iocdata *dcp, 539 uint_t flags) 540 { 541 int rval; 542 char *name; 543 544 if (ndi_dc_getname(dcp) == NULL || ndi_dc_getaddr(dcp) == NULL) 545 return (EINVAL); 546 547 name = kmem_alloc(MAXNAMELEN, KM_SLEEP); 548 (void) snprintf(name, MAXNAMELEN, "%s@%s", 549 ndi_dc_getname(dcp), ndi_dc_getaddr(dcp)); 550 551 (void) devfs_clean(dip, name, DV_CLEAN_FORCE); 552 553 rval = ndi_devi_unconfig_one(dip, name, NULL, flags | NDI_DEVI_REMOVE); 554 555 if (rval == NDI_BUSY) { 556 rval = EBUSY; 557 } else if (rval == NDI_FAILURE) { 558 rval = EIO; 559 } 560 561 NDI_DEBUG(flags, (CE_CONT, "%s%d: remove: %s: %s\n", 562 ddi_driver_name(dip), ddi_get_instance(dip), name, 563 (rval == NDI_SUCCESS) ? "ok" : "failed")); 564 565 kmem_free(name, MAXNAMELEN); 566 567 return (rval); 568 } 569 570 /* 571 * Return devctl state of the child named by "name@addr". 572 * For use by a driver's DEVCTL_DEVICE_GETSTATE handler. 573 */ 574 int 575 ndi_devctl_device_getstate(dev_info_t *parent, struct devctl_iocdata *dcp, 576 uint_t *state) 577 { 578 dev_info_t *dip; 579 char *name, *addr; 580 char *devname; 581 int devnamelen; 582 int circ; 583 584 if (parent == NULL || 585 ((name = ndi_dc_getname(dcp)) == NULL) || 586 ((addr = ndi_dc_getaddr(dcp)) == NULL)) 587 return (NDI_FAILURE); 588 589 devnamelen = strlen(name) + strlen(addr) + 2; 590 devname = kmem_alloc(devnamelen, KM_SLEEP); 591 if (strlen(addr) > 0) { 592 (void) snprintf(devname, devnamelen, "%s@%s", name, addr); 593 } else { 594 (void) snprintf(devname, devnamelen, "%s", name); 595 } 596 597 ndi_devi_enter(parent, &circ); 598 599 dip = ndi_devi_findchild(parent, devname); 600 kmem_free(devname, devnamelen); 601 602 if (dip == NULL) { 603 ndi_devi_exit(parent, circ); 604 return (NDI_FAILURE); 605 } 606 607 mutex_enter(&(DEVI(dip)->devi_lock)); 608 if (DEVI_IS_DEVICE_OFFLINE(dip)) { 609 *state = DEVICE_OFFLINE; 610 } else if (DEVI_IS_DEVICE_DOWN(dip)) { 611 *state = DEVICE_DOWN; 612 } else { 613 *state = DEVICE_ONLINE; 614 if (devi_stillreferenced(dip) == DEVI_REFERENCED) 615 *state |= DEVICE_BUSY; 616 } 617 618 mutex_exit(&(DEVI(dip)->devi_lock)); 619 ndi_devi_exit(parent, circ); 620 621 return (NDI_SUCCESS); 622 } 623 624 /* 625 * return the current state of the device "dip" 626 * 627 * recommend using ndi_devctl_ioctl() or 628 * ndi_devctl_device_getstate() instead 629 */ 630 int 631 ndi_dc_return_dev_state(dev_info_t *dip, struct devctl_iocdata *dcp) 632 { 633 dev_info_t *pdip; 634 uint_t devstate = 0; 635 int circ; 636 637 if ((dip == NULL) || (dcp == NULL)) 638 return (NDI_FAILURE); 639 640 pdip = ddi_get_parent(dip); 641 642 ndi_devi_enter(pdip, &circ); 643 mutex_enter(&(DEVI(dip)->devi_lock)); 644 if (DEVI_IS_DEVICE_OFFLINE(dip)) { 645 devstate = DEVICE_OFFLINE; 646 } else if (DEVI_IS_DEVICE_DOWN(dip)) { 647 devstate = DEVICE_DOWN; 648 } else { 649 devstate = DEVICE_ONLINE; 650 if (devi_stillreferenced(dip) == DEVI_REFERENCED) 651 devstate |= DEVICE_BUSY; 652 } 653 654 mutex_exit(&(DEVI(dip)->devi_lock)); 655 ndi_devi_exit(pdip, circ); 656 657 if (copyout(&devstate, dcp->cpyout_buf, sizeof (uint_t)) != 0) 658 return (NDI_FAULT); 659 660 return (NDI_SUCCESS); 661 } 662 663 /* 664 * Return device's bus state 665 * For use by a driver's DEVCTL_BUS_GETSTATE handler. 666 */ 667 int 668 ndi_devctl_bus_getstate(dev_info_t *dip, struct devctl_iocdata *dcp, 669 uint_t *state) 670 { 671 if ((dip == NULL) || (dcp == NULL)) 672 return (NDI_FAILURE); 673 674 return (ndi_get_bus_state(dip, state)); 675 } 676 677 /* 678 * Generic devctl ioctl handler 679 */ 680 int 681 ndi_devctl_ioctl(dev_info_t *dip, int cmd, intptr_t arg, int mode, uint_t flags) 682 { 683 _NOTE(ARGUNUSED(mode)) 684 struct devctl_iocdata *dcp; 685 uint_t state; 686 int rval = ENOTTY; 687 688 /* 689 * read devctl ioctl data 690 */ 691 if (ndi_dc_allochdl((void *)arg, &dcp) != NDI_SUCCESS) 692 return (EFAULT); 693 694 switch (cmd) { 695 696 case DEVCTL_BUS_GETSTATE: 697 rval = ndi_devctl_bus_getstate(dip, dcp, &state); 698 if (rval == NDI_SUCCESS) { 699 if (copyout(&state, dcp->cpyout_buf, 700 sizeof (uint_t)) != 0) 701 rval = NDI_FAULT; 702 } 703 break; 704 705 case DEVCTL_DEVICE_ONLINE: 706 rval = ndi_devctl_device_online(dip, dcp, flags); 707 break; 708 709 case DEVCTL_DEVICE_OFFLINE: 710 rval = ndi_devctl_device_offline(dip, dcp, flags); 711 break; 712 713 case DEVCTL_DEVICE_GETSTATE: 714 rval = ndi_devctl_device_getstate(dip, dcp, &state); 715 if (rval == NDI_SUCCESS) { 716 if (copyout(&state, dcp->cpyout_buf, 717 sizeof (uint_t)) != 0) 718 rval = NDI_FAULT; 719 } 720 break; 721 722 case DEVCTL_DEVICE_REMOVE: 723 rval = ndi_devctl_device_remove(dip, dcp, flags); 724 break; 725 726 case DEVCTL_BUS_DEV_CREATE: 727 rval = ndi_dc_devi_create(dcp, dip, 0, NULL); 728 break; 729 730 /* 731 * ioctls for which a generic implementation makes no sense 732 */ 733 case DEVCTL_BUS_RESET: 734 case DEVCTL_BUS_RESETALL: 735 case DEVCTL_DEVICE_RESET: 736 case DEVCTL_AP_CONNECT: 737 case DEVCTL_AP_DISCONNECT: 738 case DEVCTL_AP_INSERT: 739 case DEVCTL_AP_REMOVE: 740 case DEVCTL_AP_CONFIGURE: 741 case DEVCTL_AP_UNCONFIGURE: 742 case DEVCTL_AP_GETSTATE: 743 case DEVCTL_AP_CONTROL: 744 case DEVCTL_BUS_QUIESCE: 745 case DEVCTL_BUS_UNQUIESCE: 746 rval = ENOTSUP; 747 break; 748 } 749 750 ndi_dc_freehdl(dcp); 751 return (rval); 752 } 753 754 /* 755 * Copyout the state of the Attachment Point "ap" to the requesting 756 * user process. 757 */ 758 int 759 ndi_dc_return_ap_state(devctl_ap_state_t *ap, struct devctl_iocdata *dcp) 760 { 761 if ((ap == NULL) || (dcp == NULL)) 762 return (NDI_FAILURE); 763 764 765 if (get_udatamodel() == DATAMODEL_NATIVE) { 766 if (copyout(ap, dcp->cpyout_buf, 767 sizeof (devctl_ap_state_t)) != 0) 768 return (NDI_FAULT); 769 } 770 #ifdef _SYSCALL32_IMPL 771 else { 772 struct devctl_ap_state32 ap_state32; 773 774 ap_state32.ap_rstate = ap->ap_rstate; 775 ap_state32.ap_ostate = ap->ap_ostate; 776 ap_state32.ap_condition = ap->ap_condition; 777 ap_state32.ap_error_code = ap->ap_error_code; 778 ap_state32.ap_in_transition = ap->ap_in_transition; 779 ap_state32.ap_last_change = (time32_t)ap->ap_last_change; 780 if (copyout(&ap_state32, dcp->cpyout_buf, 781 sizeof (devctl_ap_state32_t)) != 0) 782 return (NDI_FAULT); 783 } 784 #endif 785 786 return (NDI_SUCCESS); 787 } 788 789 /* 790 * Copyout the bus state of the bus nexus device "dip" to the requesting 791 * user process. 792 */ 793 int 794 ndi_dc_return_bus_state(dev_info_t *dip, struct devctl_iocdata *dcp) 795 { 796 uint_t devstate = 0; 797 798 if ((dip == NULL) || (dcp == NULL)) 799 return (NDI_FAILURE); 800 801 if (ndi_get_bus_state(dip, &devstate) != NDI_SUCCESS) 802 return (NDI_FAILURE); 803 804 if (copyout(&devstate, dcp->cpyout_buf, sizeof (uint_t)) != 0) 805 return (NDI_FAULT); 806 807 return (NDI_SUCCESS); 808 } 809 810 static int 811 i_dc_devi_create(struct devctl_iocdata *, dev_info_t *, dev_info_t **); 812 813 /* 814 * create a child device node given the property definitions 815 * supplied by the userland process 816 */ 817 int 818 ndi_dc_devi_create(struct devctl_iocdata *dcp, dev_info_t *pdip, int flags, 819 dev_info_t **rdip) 820 { 821 dev_info_t *cdip; 822 int rv, circular = 0; 823 char devnm[MAXNAMELEN]; 824 int nmlen; 825 826 /* 827 * The child device may have been pre-constructed by an earlier 828 * call to this function with the flag DEVCTL_CONSTRUCT set. 829 */ 830 831 if ((cdip = (rdip != NULL) ? *rdip : NULL) == NULL) 832 if ((rv = i_dc_devi_create(dcp, pdip, &cdip)) != 0) 833 return (rv); 834 835 ASSERT(cdip != NULL); 836 837 /* 838 * Return the device node partially constructed if the 839 * DEVCTL_CONSTRUCT flag is set. 840 */ 841 if (flags & DEVCTL_CONSTRUCT) { 842 if (rdip == NULL) { 843 (void) ndi_devi_free(cdip); 844 return (EINVAL); 845 } 846 *rdip = cdip; 847 return (0); 848 } 849 850 /* 851 * Bring the node up to a named but OFFLINE state. The calling 852 * application will need to manage the node from here on. 853 */ 854 if (dcp->flags & DEVCTL_OFFLINE) { 855 /* 856 * In the unlikely event that the dip was somehow attached by 857 * the userland process (and device contracts or LDI opens 858 * were registered against the dip) after it was created by 859 * a previous DEVCTL_CONSTRUCT call, we start notify 860 * proceedings on this dip. Note that we don't need to 861 * return the dip after a failure of the notify since 862 * for a contract or LDI handle to be created the dip was 863 * already available to the user. 864 */ 865 if (e_ddi_offline_notify(cdip) == DDI_FAILURE) { 866 return (EBUSY); 867 } 868 869 /* 870 * hand set the OFFLINE flag to prevent any asynchronous 871 * autoconfiguration operations from attaching this node. 872 */ 873 mutex_enter(&(DEVI(cdip)->devi_lock)); 874 DEVI_SET_DEVICE_OFFLINE(cdip); 875 mutex_exit(&(DEVI(cdip)->devi_lock)); 876 877 e_ddi_offline_finalize(cdip, DDI_SUCCESS); 878 879 rv = ndi_devi_bind_driver(cdip, flags); 880 if (rv != NDI_SUCCESS) { 881 (void) ndi_devi_offline(cdip, NDI_DEVI_REMOVE); 882 return (ENXIO); 883 } 884 885 /* 886 * remove the dev_info node if it failed to bind to a 887 * driver above. 888 */ 889 if (i_ddi_node_state(cdip) < DS_BOUND) { 890 (void) ndi_devi_offline(cdip, NDI_DEVI_REMOVE); 891 return (ENXIO); 892 } 893 894 /* 895 * add the node to the per-driver list and INITCHILD it 896 * to give it a name. 897 */ 898 ndi_devi_enter(pdip, &circular); 899 if ((rv = ddi_initchild(pdip, cdip)) != DDI_SUCCESS) { 900 (void) ndi_devi_offline(cdip, NDI_DEVI_REMOVE); 901 ndi_devi_exit(pdip, circular); 902 return (EINVAL); 903 } 904 ndi_devi_exit(pdip, circular); 905 906 } else { 907 /* 908 * Attempt to bring the device ONLINE. If the request to 909 * fails, remove the dev_info node. 910 */ 911 if (ndi_devi_online(cdip, NDI_ONLINE_ATTACH) != NDI_SUCCESS) { 912 (void) ndi_devi_offline(cdip, NDI_DEVI_REMOVE); 913 return (ENXIO); 914 } 915 916 /* 917 * if the node was successfully added but there was 918 * no driver available for the device, remove the node 919 */ 920 if (i_ddi_node_state(cdip) < DS_BOUND) { 921 (void) ndi_devi_offline(cdip, NDI_DEVI_REMOVE); 922 return (ENODEV); 923 } 924 } 925 926 /* 927 * return a handle to the child device 928 * copy out the name of the newly attached child device if 929 * the IOCTL request has provided a copyout buffer. 930 */ 931 if (rdip != NULL) 932 *rdip = cdip; 933 934 if (dcp->cpyout_buf == NULL) 935 return (0); 936 937 ASSERT(ddi_node_name(cdip) != NULL); 938 ASSERT(ddi_get_name_addr(cdip) != NULL); 939 940 nmlen = snprintf(devnm, MAXNAMELEN, "%s@%s", 941 ddi_node_name(cdip), ddi_get_name_addr(cdip)); 942 943 if (copyout(&devnm, dcp->cpyout_buf, nmlen) != 0) { 944 (void) ndi_devi_offline(cdip, NDI_DEVI_REMOVE); 945 return (EFAULT); 946 } 947 return (0); 948 } 949 950 static int 951 i_dc_devi_create(struct devctl_iocdata *dcp, dev_info_t *pdip, 952 dev_info_t **rdip) 953 { 954 955 dev_info_t *cdip; 956 char *cname = NULL; 957 nvlist_t *nvlp = dcp->nvl_user; 958 nvpair_t *npp; 959 char *np; 960 int rv = 0; 961 962 ASSERT(rdip != NULL && *rdip == NULL); 963 964 if ((nvlp == NULL) || 965 (nvlist_lookup_string(nvlp, DC_DEVI_NODENAME, &cname) != 0)) 966 return (EINVAL); 967 968 /* 969 * construct a new dev_info node with a user-provided nodename 970 */ 971 ndi_devi_alloc_sleep(pdip, cname, (pnode_t)DEVI_SID_NODEID, &cdip); 972 973 /* 974 * create hardware properties for each member in the property 975 * list. 976 */ 977 for (npp = nvlist_next_nvpair(nvlp, NULL); (npp != NULL && !rv); 978 npp = nvlist_next_nvpair(nvlp, npp)) { 979 980 np = nvpair_name(npp); 981 982 /* 983 * skip the nodename property 984 */ 985 if (strcmp(np, DC_DEVI_NODENAME) == 0) 986 continue; 987 988 switch (nvpair_type(npp)) { 989 990 case DATA_TYPE_INT32: { 991 int32_t prop_val; 992 993 if ((rv = nvpair_value_int32(npp, &prop_val)) != 0) 994 break; 995 996 (void) ndi_prop_update_int(DDI_DEV_T_NONE, cdip, np, 997 (int)prop_val); 998 break; 999 } 1000 1001 case DATA_TYPE_STRING: { 1002 char *prop_val; 1003 1004 if ((rv = nvpair_value_string(npp, &prop_val)) != 0) 1005 break; 1006 1007 (void) ndi_prop_update_string(DDI_DEV_T_NONE, cdip, 1008 np, prop_val); 1009 break; 1010 } 1011 1012 case DATA_TYPE_BYTE_ARRAY: { 1013 uchar_t *val; 1014 uint_t nelms; 1015 1016 if ((rv = nvpair_value_byte_array(npp, &val, 1017 &nelms)) != 0) 1018 break; 1019 1020 (void) ndi_prop_update_byte_array(DDI_DEV_T_NONE, 1021 cdip, np, (uchar_t *)val, nelms); 1022 break; 1023 } 1024 1025 case DATA_TYPE_INT32_ARRAY: { 1026 int32_t *val; 1027 uint_t nelms; 1028 1029 if ((rv = nvpair_value_int32_array(npp, &val, 1030 &nelms)) != 0) 1031 break; 1032 1033 (void) ndi_prop_update_int_array(DDI_DEV_T_NONE, 1034 cdip, np, val, nelms); 1035 break; 1036 } 1037 1038 case DATA_TYPE_STRING_ARRAY: { 1039 char **val; 1040 uint_t nelms; 1041 1042 if ((rv = nvpair_value_string_array(npp, &val, 1043 &nelms)) != 0) 1044 break; 1045 1046 (void) ndi_prop_update_string_array(DDI_DEV_T_NONE, 1047 cdip, np, val, nelms); 1048 break; 1049 } 1050 1051 /* 1052 * unsupported property data type 1053 */ 1054 default: 1055 rv = EINVAL; 1056 } 1057 } 1058 1059 /* 1060 * something above failed 1061 * destroy the partially child device and abort the request 1062 */ 1063 if (rv != 0) { 1064 (void) ndi_devi_free(cdip); 1065 return (rv); 1066 } 1067 1068 *rdip = cdip; 1069 return (0); 1070 } 1071 1072 /* 1073 * return current soft bus state of bus nexus "dip" 1074 */ 1075 int 1076 ndi_get_bus_state(dev_info_t *dip, uint_t *rstate) 1077 { 1078 if (dip == NULL || rstate == NULL) 1079 return (NDI_FAILURE); 1080 1081 if (DEVI(dip)->devi_ops->devo_bus_ops == NULL) 1082 return (NDI_FAILURE); 1083 1084 mutex_enter(&(DEVI(dip)->devi_lock)); 1085 if (DEVI_IS_BUS_QUIESCED(dip)) 1086 *rstate = BUS_QUIESCED; 1087 else if (DEVI_IS_BUS_DOWN(dip)) 1088 *rstate = BUS_SHUTDOWN; 1089 else 1090 *rstate = BUS_ACTIVE; 1091 mutex_exit(&(DEVI(dip)->devi_lock)); 1092 return (NDI_SUCCESS); 1093 } 1094 1095 /* 1096 * Set the soft state of bus nexus "dip" 1097 */ 1098 int 1099 ndi_set_bus_state(dev_info_t *dip, uint_t state) 1100 { 1101 int rv = NDI_SUCCESS; 1102 1103 if (dip == NULL) 1104 return (NDI_FAILURE); 1105 1106 mutex_enter(&(DEVI(dip)->devi_lock)); 1107 1108 switch (state) { 1109 case BUS_QUIESCED: 1110 DEVI_SET_BUS_QUIESCE(dip); 1111 break; 1112 1113 case BUS_ACTIVE: 1114 DEVI_SET_BUS_ACTIVE(dip); 1115 DEVI_SET_BUS_UP(dip); 1116 break; 1117 1118 case BUS_SHUTDOWN: 1119 DEVI_SET_BUS_DOWN(dip); 1120 break; 1121 1122 default: 1123 rv = NDI_FAILURE; 1124 } 1125 1126 mutex_exit(&(DEVI(dip)->devi_lock)); 1127 return (rv); 1128 } 1129 1130 /* 1131 * These dummy functions are obsolete and may be removed. 1132 * Retained for existing driver compatibility only. 1133 * Drivers should be fixed not to use these functions. 1134 * Don't write new code using these obsolete interfaces. 1135 */ 1136 /*ARGSUSED*/ 1137 void 1138 i_ndi_block_device_tree_changes(uint_t *lkcnt) /* obsolete */ 1139 { 1140 /* obsolete dummy function */ 1141 } 1142 1143 /*ARGSUSED*/ 1144 void 1145 i_ndi_allow_device_tree_changes(uint_t lkcnt) /* obsolete */ 1146 { 1147 /* obsolete dummy function */ 1148 } 1149 1150 /* 1151 * Single thread entry into per-driver list 1152 */ 1153 /*ARGSUSED*/ 1154 void 1155 e_ddi_enter_driver_list(struct devnames *dnp, int *listcnt) /* obsolete */ 1156 { 1157 /* obsolete dummy function */ 1158 } 1159 1160 /* 1161 * release the per-driver list 1162 */ 1163 /*ARGSUSED*/ 1164 void 1165 e_ddi_exit_driver_list(struct devnames *dnp, int listcnt) /* obsolete */ 1166 { 1167 /* obsolete dummy function */ 1168 } 1169 1170 /* 1171 * Attempt to enter driver list 1172 */ 1173 /*ARGSUSED*/ 1174 int 1175 e_ddi_tryenter_driver_list(struct devnames *dnp, int *listcnt) /* obsolete */ 1176 { 1177 return (1); /* obsolete dummy function */ 1178 } 1179 1180 /* 1181 * ndi event handling support functions: 1182 * The NDI event support model is as follows: 1183 * 1184 * The nexus driver defines a set of events using some static structures (so 1185 * these structures can be shared by all instances of the nexus driver). 1186 * The nexus driver allocates an event handle and binds the event set 1187 * to this handle. The nexus driver's event busop functions can just 1188 * call the appropriate NDI event support function using this handle 1189 * as the first argument. 1190 * 1191 * The reasoning for tying events to the device tree is that the entity 1192 * generating the callback will typically be one of the device driver's 1193 * ancestors in the tree. 1194 */ 1195 static int ndi_event_debug = 0; 1196 1197 #ifdef DEBUG 1198 #define NDI_EVENT_DEBUG ndi_event_debug 1199 #endif /* DEBUG */ 1200 1201 /* 1202 * allocate a new ndi event handle 1203 */ 1204 int 1205 ndi_event_alloc_hdl(dev_info_t *dip, ddi_iblock_cookie_t cookie, 1206 ndi_event_hdl_t *handle, uint_t flag) 1207 { 1208 struct ndi_event_hdl *ndi_event_hdl; 1209 1210 ndi_event_hdl = kmem_zalloc(sizeof (struct ndi_event_hdl), 1211 ((flag & NDI_NOSLEEP) ? KM_NOSLEEP : KM_SLEEP)); 1212 1213 if (!ndi_event_hdl) { 1214 return (NDI_FAILURE); 1215 } 1216 1217 ndi_event_hdl->ndi_evthdl_dip = dip; 1218 ndi_event_hdl->ndi_evthdl_iblock_cookie = cookie; 1219 mutex_init(&ndi_event_hdl->ndi_evthdl_mutex, NULL, 1220 MUTEX_DRIVER, (void *)cookie); 1221 1222 mutex_init(&ndi_event_hdl->ndi_evthdl_cb_mutex, NULL, 1223 MUTEX_DRIVER, (void *)cookie); 1224 1225 *handle = (ndi_event_hdl_t)ndi_event_hdl; 1226 1227 return (NDI_SUCCESS); 1228 } 1229 1230 /* 1231 * free the ndi event handle 1232 */ 1233 int 1234 ndi_event_free_hdl(ndi_event_hdl_t handle) 1235 { 1236 struct ndi_event_hdl *ndi_event_hdl = (struct ndi_event_hdl *)handle; 1237 ndi_event_cookie_t *cookie; 1238 ndi_event_cookie_t *free; 1239 1240 ASSERT(handle); 1241 1242 mutex_enter(&ndi_event_hdl->ndi_evthdl_mutex); 1243 mutex_enter(&ndi_event_hdl->ndi_evthdl_cb_mutex); 1244 1245 cookie = ndi_event_hdl->ndi_evthdl_cookie_list; 1246 1247 /* deallocate all defined cookies */ 1248 while (cookie != NULL) { 1249 ASSERT(cookie->callback_list == NULL); 1250 free = cookie; 1251 cookie = cookie->next_cookie; 1252 1253 kmem_free(free, sizeof (ndi_event_cookie_t)); 1254 } 1255 1256 1257 mutex_exit(&ndi_event_hdl->ndi_evthdl_cb_mutex); 1258 mutex_exit(&ndi_event_hdl->ndi_evthdl_mutex); 1259 1260 /* destroy mutexes */ 1261 mutex_destroy(&ndi_event_hdl->ndi_evthdl_mutex); 1262 mutex_destroy(&ndi_event_hdl->ndi_evthdl_cb_mutex); 1263 1264 /* free event handle */ 1265 kmem_free(ndi_event_hdl, sizeof (struct ndi_event_hdl)); 1266 1267 return (NDI_SUCCESS); 1268 } 1269 1270 1271 /* 1272 * ndi_event_bind_set() adds a set of events to the NDI event 1273 * handle. 1274 * 1275 * Events generated by high level interrupts should not 1276 * be mixed in the same event set with events generated by 1277 * normal interrupts or kernel events. 1278 * 1279 * This function can be called multiple times to bind 1280 * additional sets to the event handle. 1281 * However, events generated by high level interrupts cannot 1282 * be bound to a handle that already has bound events generated 1283 * by normal interrupts or from kernel context and vice versa. 1284 */ 1285 int 1286 ndi_event_bind_set(ndi_event_hdl_t handle, 1287 ndi_event_set_t *ndi_events, 1288 uint_t flag) 1289 { 1290 struct ndi_event_hdl *ndi_event_hdl; 1291 ndi_event_cookie_t *next, *prev, *new_cookie; 1292 uint_t i, len; 1293 uint_t dup = 0; 1294 uint_t high_plevels, other_plevels; 1295 ndi_event_definition_t *ndi_event_defs; 1296 1297 int km_flag = ((flag & NDI_NOSLEEP) ? KM_NOSLEEP : KM_SLEEP); 1298 1299 ASSERT(handle); 1300 ASSERT(ndi_events); 1301 1302 /* 1303 * binding must be performed during attach/detach 1304 */ 1305 if (!DEVI_IS_ATTACHING(handle->ndi_evthdl_dip) && 1306 !DEVI_IS_DETACHING(handle->ndi_evthdl_dip)) { 1307 cmn_err(CE_WARN, "ndi_event_bind_set must be called within " 1308 "attach or detach"); 1309 return (NDI_FAILURE); 1310 } 1311 1312 /* 1313 * if it is not the correct version or the event set is 1314 * empty, bail out 1315 */ 1316 if (ndi_events->ndi_events_version != NDI_EVENTS_REV1) 1317 return (NDI_FAILURE); 1318 1319 ndi_event_hdl = (struct ndi_event_hdl *)handle; 1320 ndi_event_defs = ndi_events->ndi_event_defs; 1321 high_plevels = other_plevels = 0; 1322 1323 mutex_enter(&ndi_event_hdl->ndi_evthdl_mutex); 1324 1325 /* check for mixing events at high level with the other types */ 1326 for (i = 0; i < ndi_events->ndi_n_events; i++) { 1327 if (ndi_event_defs[i].ndi_event_plevel == EPL_HIGHLEVEL) { 1328 high_plevels++; 1329 } else { 1330 other_plevels++; 1331 } 1332 } 1333 1334 /* 1335 * bail out if high level events are mixed with other types in this 1336 * event set or the set is incompatible with the set in the handle 1337 */ 1338 if ((high_plevels && other_plevels) || 1339 (other_plevels && ndi_event_hdl->ndi_evthdl_high_plevels) || 1340 (high_plevels && ndi_event_hdl->ndi_evthdl_other_plevels)) { 1341 mutex_exit(&ndi_event_hdl->ndi_evthdl_mutex); 1342 1343 return (NDI_FAILURE); 1344 } 1345 1346 /* 1347 * check for duplicate events in both the existing handle 1348 * and the event set, add events if not duplicates 1349 */ 1350 next = ndi_event_hdl->ndi_evthdl_cookie_list; 1351 for (i = 0; i < ndi_events->ndi_n_events; i++) { 1352 while (next != NULL) { 1353 len = strlen(NDI_EVENT_NAME(next)) + 1; 1354 if (strncmp(NDI_EVENT_NAME(next), 1355 ndi_event_defs[i].ndi_event_name, len) == 0) { 1356 dup = 1; 1357 break; 1358 } 1359 1360 prev = next; 1361 next = next->next_cookie; 1362 } 1363 1364 if (dup == 0) { 1365 new_cookie = kmem_zalloc(sizeof (ndi_event_cookie_t), 1366 km_flag); 1367 1368 if (!new_cookie) 1369 return (NDI_FAILURE); 1370 1371 if (ndi_event_hdl->ndi_evthdl_n_events == 0) { 1372 ndi_event_hdl->ndi_evthdl_cookie_list = 1373 new_cookie; 1374 } else { 1375 prev->next_cookie = new_cookie; 1376 } 1377 1378 ndi_event_hdl->ndi_evthdl_n_events++; 1379 1380 /* 1381 * set up new cookie 1382 */ 1383 new_cookie->definition = &ndi_event_defs[i]; 1384 new_cookie->ddip = ndi_event_hdl->ndi_evthdl_dip; 1385 1386 } else { 1387 /* 1388 * event not added, must correct plevel numbers 1389 */ 1390 if (ndi_event_defs[i].ndi_event_plevel == 1391 EPL_HIGHLEVEL) { 1392 high_plevels--; 1393 } else { 1394 other_plevels--; 1395 } 1396 } 1397 1398 dup = 0; 1399 next = ndi_event_hdl->ndi_evthdl_cookie_list; 1400 prev = NULL; 1401 1402 } 1403 1404 ndi_event_hdl->ndi_evthdl_high_plevels += high_plevels; 1405 ndi_event_hdl->ndi_evthdl_other_plevels += other_plevels; 1406 1407 ASSERT((ndi_event_hdl->ndi_evthdl_high_plevels == 0) || 1408 (ndi_event_hdl->ndi_evthdl_other_plevels == 0)); 1409 1410 #ifdef NDI_EVENT_DEBUG 1411 if (ndi_event_debug) { 1412 ndi_event_dump_hdl(ndi_event_hdl, "ndi_event_bind_set"); 1413 } 1414 #endif /* NDI_EVENT_DEBUG */ 1415 1416 mutex_exit(&ndi_event_hdl->ndi_evthdl_mutex); 1417 1418 return (NDI_SUCCESS); 1419 } 1420 1421 /* 1422 * ndi_event_unbind_set() unbinds a set of events, previously 1423 * bound using ndi_event_bind_set(), from the NDI event 1424 * handle. 1425 * 1426 * This routine will unbind all events in the event set. If an event, 1427 * specified in the event set, is not found in the handle, this 1428 * routine will proceed onto the next member of the set as if the event 1429 * was never specified. 1430 * 1431 * The event set may be a subset of the set of events that 1432 * was previously bound to the handle. For example, events 1433 * can be individually unbound. 1434 * 1435 * An event cannot be unbound if callbacks are still 1436 * registered against the event. 1437 */ 1438 /*ARGSUSED*/ 1439 int 1440 ndi_event_unbind_set(ndi_event_hdl_t handle, ndi_event_set_t *ndi_events, 1441 uint_t flag) 1442 { 1443 ndi_event_definition_t *ndi_event_defs; 1444 int len; 1445 uint_t i; 1446 int rval; 1447 ndi_event_cookie_t *cookie_list; 1448 ndi_event_cookie_t *prev = NULL; 1449 1450 ASSERT(ndi_events); 1451 ASSERT(handle); 1452 1453 /* 1454 * binding must be performed during attach/detac 1455 */ 1456 if (!DEVI_IS_ATTACHING(handle->ndi_evthdl_dip) && 1457 !DEVI_IS_DETACHING(handle->ndi_evthdl_dip)) { 1458 cmn_err(CE_WARN, "ndi_event_bind_set must be called within " 1459 "attach or detach"); 1460 return (NDI_FAILURE); 1461 } 1462 1463 /* bail out if ndi_event_set is outdated */ 1464 if (ndi_events->ndi_events_version != NDI_EVENTS_REV1) { 1465 return (NDI_FAILURE); 1466 } 1467 1468 ASSERT(ndi_events->ndi_event_defs); 1469 1470 ndi_event_defs = ndi_events->ndi_event_defs; 1471 1472 mutex_enter(&handle->ndi_evthdl_mutex); 1473 mutex_enter(&handle->ndi_evthdl_cb_mutex); 1474 1475 /* 1476 * Verify that all events in the event set are eligible 1477 * for unbinding(ie. there are no outstanding callbacks). 1478 * If any one of the events are ineligible, fail entire 1479 * operation. 1480 */ 1481 1482 for (i = 0; i < ndi_events->ndi_n_events; i++) { 1483 cookie_list = handle->ndi_evthdl_cookie_list; 1484 while (cookie_list != NULL) { 1485 len = strlen(NDI_EVENT_NAME(cookie_list)) + 1; 1486 if (strncmp(NDI_EVENT_NAME(cookie_list), 1487 ndi_event_defs[i].ndi_event_name, len) == 0) { 1488 1489 ASSERT(cookie_list->callback_list == NULL); 1490 if (cookie_list->callback_list) { 1491 rval = NDI_FAILURE; 1492 goto done; 1493 } 1494 break; 1495 } else { 1496 cookie_list = cookie_list->next_cookie; 1497 } 1498 } 1499 } 1500 1501 /* 1502 * remove all events found within the handle 1503 * If an event is not found, this function will proceed as if the event 1504 * was never specified. 1505 */ 1506 1507 for (i = 0; i < ndi_events->ndi_n_events; i++) { 1508 cookie_list = handle->ndi_evthdl_cookie_list; 1509 prev = NULL; 1510 while (cookie_list != NULL) { 1511 len = strlen(NDI_EVENT_NAME(cookie_list)) + 1; 1512 if (strncmp(NDI_EVENT_NAME(cookie_list), 1513 ndi_event_defs[i].ndi_event_name, len) == 0) { 1514 1515 /* 1516 * can not unbind an event definition with 1517 * outstanding callbacks 1518 */ 1519 if (cookie_list->callback_list) { 1520 rval = NDI_FAILURE; 1521 goto done; 1522 } 1523 1524 /* remove this cookie from the list */ 1525 if (prev != NULL) { 1526 prev->next_cookie = 1527 cookie_list->next_cookie; 1528 } else { 1529 handle->ndi_evthdl_cookie_list = 1530 cookie_list->next_cookie; 1531 } 1532 1533 /* adjust plevel counts */ 1534 if (NDI_EVENT_PLEVEL(cookie_list) == 1535 EPL_HIGHLEVEL) { 1536 handle->ndi_evthdl_high_plevels--; 1537 } else { 1538 handle->ndi_evthdl_other_plevels--; 1539 } 1540 1541 /* adjust cookie count */ 1542 handle->ndi_evthdl_n_events--; 1543 1544 /* free the cookie */ 1545 kmem_free(cookie_list, 1546 sizeof (ndi_event_cookie_t)); 1547 1548 cookie_list = handle->ndi_evthdl_cookie_list; 1549 break; 1550 1551 } else { 1552 prev = cookie_list; 1553 cookie_list = cookie_list->next_cookie; 1554 } 1555 1556 } 1557 1558 } 1559 1560 #ifdef NDI_EVENT_DEBUG 1561 if (ndi_event_debug) { 1562 ndi_event_dump_hdl(handle, "ndi_event_unbind_set"); 1563 } 1564 #endif /* NDI_EVENT_DEBUG */ 1565 1566 rval = NDI_SUCCESS; 1567 1568 done: 1569 mutex_exit(&handle->ndi_evthdl_cb_mutex); 1570 mutex_exit(&handle->ndi_evthdl_mutex); 1571 1572 return (rval); 1573 } 1574 1575 /* 1576 * ndi_event_retrieve_cookie(): 1577 * Return an event cookie for eventname if this nexus driver 1578 * has defined the named event. The event cookie returned 1579 * by this function is used to register callback handlers 1580 * for the event. 1581 * 1582 * ndi_event_retrieve_cookie() is intended to be used in the 1583 * nexus driver's bus_get_eventcookie busop routine. 1584 * 1585 * If the event is not defined by this bus nexus driver, and flag 1586 * does not include NDI_EVENT_NOPASS, then ndi_event_retrieve_cookie() 1587 * will pass the request up the device tree hierarchy by calling 1588 * ndi_busop_get_eventcookie(9N). 1589 * If the event is not defined by this bus nexus driver, and flag 1590 * does include NDI_EVENT_NOPASS, ndi_event_retrieve_cookie() 1591 * will return NDI_FAILURE. The caller may then determine what further 1592 * action to take, such as using a different handle, passing the 1593 * request up the device tree using ndi_busop_get_eventcookie(9N), 1594 * or returning the failure to the caller, thus blocking the 1595 * progress of the request up the tree. 1596 */ 1597 int 1598 ndi_event_retrieve_cookie(ndi_event_hdl_t handle, 1599 dev_info_t *rdip, 1600 char *eventname, 1601 ddi_eventcookie_t *cookiep, 1602 uint_t flag) 1603 { 1604 struct ndi_event_hdl *ndi_event_hdl = (struct ndi_event_hdl *)handle; 1605 int len; 1606 ndi_event_cookie_t *cookie_list; 1607 1608 mutex_enter(&ndi_event_hdl->ndi_evthdl_mutex); 1609 1610 cookie_list = ndi_event_hdl->ndi_evthdl_cookie_list; 1611 /* 1612 * search the cookie list for the event name and return 1613 * cookie if found. 1614 */ 1615 while (cookie_list != NULL) { 1616 1617 len = strlen(NDI_EVENT_NAME(cookie_list)) + 1; 1618 if (strncmp(NDI_EVENT_NAME(cookie_list), eventname, 1619 len) == 0) { 1620 *cookiep = (ddi_eventcookie_t)cookie_list; 1621 1622 mutex_exit(&ndi_event_hdl->ndi_evthdl_mutex); 1623 return (NDI_SUCCESS); 1624 } 1625 1626 cookie_list = cookie_list->next_cookie; 1627 } 1628 1629 mutex_exit(&ndi_event_hdl->ndi_evthdl_mutex); 1630 /* 1631 * event was not found, pass up or return failure 1632 */ 1633 if ((flag & NDI_EVENT_NOPASS) == 0) { 1634 return (ndi_busop_get_eventcookie( 1635 ndi_event_hdl->ndi_evthdl_dip, rdip, eventname, cookiep)); 1636 } else { 1637 return (NDI_FAILURE); 1638 } 1639 } 1640 1641 /* 1642 * check whether this nexus defined this event and look up attributes 1643 */ 1644 static int 1645 ndi_event_is_defined(ndi_event_hdl_t handle, 1646 ddi_eventcookie_t cookie, int *attributes) 1647 { 1648 1649 struct ndi_event_hdl *ndi_event_hdl = (struct ndi_event_hdl *)handle; 1650 ndi_event_cookie_t *cookie_list; 1651 1652 ASSERT(mutex_owned(&handle->ndi_evthdl_mutex)); 1653 1654 cookie_list = ndi_event_hdl->ndi_evthdl_cookie_list; 1655 while (cookie_list != NULL) { 1656 if (cookie_list == NDI_EVENT(cookie)) { 1657 if (attributes) 1658 *attributes = 1659 NDI_EVENT_ATTRIBUTES(cookie_list); 1660 1661 return (NDI_SUCCESS); 1662 } 1663 1664 cookie_list = cookie_list->next_cookie; 1665 } 1666 1667 return (NDI_FAILURE); 1668 } 1669 1670 /* 1671 * ndi_event_add_callback(): adds an event callback registration 1672 * to the event cookie defining this event. 1673 * 1674 * Refer also to bus_add_eventcall(9n) and ndi_busop_add_eventcall(9n). 1675 * 1676 * ndi_event_add_callback(9n) is intended to be used in 1677 * the nexus driver's bus_add_eventcall(9n) busop function. 1678 * 1679 * If the event is not defined by this bus nexus driver, 1680 * ndi_event_add_callback() will return NDI_FAILURE. 1681 */ 1682 int 1683 ndi_event_add_callback(ndi_event_hdl_t handle, dev_info_t *child_dip, 1684 ddi_eventcookie_t cookie, 1685 void (*event_callback)(dev_info_t *, 1686 ddi_eventcookie_t, void *arg, void *impldata), 1687 void *arg, 1688 uint_t flag, 1689 ddi_callback_id_t *cb_id) 1690 { 1691 struct ndi_event_hdl *ndi_event_hdl = (struct ndi_event_hdl *)handle; 1692 int km_flag = ((flag & NDI_NOSLEEP) ? KM_NOSLEEP : KM_SLEEP); 1693 ndi_event_callbacks_t *cb; 1694 1695 mutex_enter(&ndi_event_hdl->ndi_evthdl_mutex); 1696 1697 /* 1698 * if the event was not bound to this handle, return failure 1699 */ 1700 if (ndi_event_is_defined(handle, cookie, NULL) != NDI_SUCCESS) { 1701 1702 mutex_exit(&ndi_event_hdl->ndi_evthdl_mutex); 1703 return (NDI_FAILURE); 1704 1705 } 1706 1707 mutex_exit(&ndi_event_hdl->ndi_evthdl_mutex); 1708 1709 /* 1710 * allocate space for a callback structure 1711 */ 1712 cb = kmem_zalloc(sizeof (ndi_event_callbacks_t), km_flag); 1713 if (cb == NULL) { 1714 return (NDI_FAILURE); 1715 } 1716 1717 mutex_enter(&ndi_event_hdl->ndi_evthdl_mutex); 1718 1719 /* initialize callback structure */ 1720 cb->ndi_evtcb_dip = child_dip; 1721 cb->ndi_evtcb_callback = event_callback; 1722 cb->ndi_evtcb_arg = arg; 1723 cb->ndi_evtcb_cookie = cookie; 1724 cb->devname = (char *)ddi_driver_name(child_dip); 1725 1726 *cb_id = (ddi_callback_id_t)cb; 1727 mutex_enter(&ndi_event_hdl->ndi_evthdl_cb_mutex); 1728 1729 /* add this callback structure to the list */ 1730 if (NDI_EVENT(cookie)->callback_list) { 1731 cb->ndi_evtcb_next = NDI_EVENT(cookie)->callback_list; 1732 NDI_EVENT(cookie)->callback_list->ndi_evtcb_prev = cb; 1733 NDI_EVENT(cookie)->callback_list = cb; 1734 } else { 1735 NDI_EVENT(cookie)->callback_list = cb; 1736 } 1737 #ifdef NDI_EVENT_DEBUG 1738 if (ndi_event_debug) { 1739 ndi_event_dump_hdl(ndi_event_hdl, "ndi_event_add_callback"); 1740 } 1741 #endif /* NDI_EVENT_DEBUG */ 1742 1743 mutex_exit(&ndi_event_hdl->ndi_evthdl_cb_mutex); 1744 mutex_exit(&ndi_event_hdl->ndi_evthdl_mutex); 1745 1746 return (NDI_SUCCESS); 1747 } 1748 1749 /* 1750 * ndi_event_remove_callback(): 1751 * 1752 * ndi_event_remove_callback() removes a callback that was 1753 * previously registered using ndi_event_add_callback(9N). 1754 * Refer also to bus_remove_eventcall(9n) and 1755 * ndi_busop_remove_eventcall(9n). 1756 * ndi_event_remove_callback(9n) is intended to be used in 1757 * the nexus driver's bus_remove_eventcall (9n) busop function. 1758 * If the event is not defined by this bus nexus driver, 1759 * ndi_event_remove_callback() will return NDI_FAILURE. 1760 */ 1761 static void do_ndi_event_remove_callback(struct ndi_event_hdl *ndi_event_hdl, 1762 ddi_callback_id_t cb_id); 1763 1764 int 1765 ndi_event_remove_callback(ndi_event_hdl_t handle, ddi_callback_id_t cb_id) 1766 { 1767 struct ndi_event_hdl *ndi_event_hdl = (struct ndi_event_hdl *)handle; 1768 1769 ASSERT(cb_id); 1770 1771 mutex_enter(&ndi_event_hdl->ndi_evthdl_mutex); 1772 mutex_enter(&ndi_event_hdl->ndi_evthdl_cb_mutex); 1773 1774 do_ndi_event_remove_callback(ndi_event_hdl, cb_id); 1775 1776 mutex_exit(&ndi_event_hdl->ndi_evthdl_cb_mutex); 1777 mutex_exit(&ndi_event_hdl->ndi_evthdl_mutex); 1778 1779 return (NDI_SUCCESS); 1780 } 1781 1782 /*ARGSUSED*/ 1783 static void 1784 do_ndi_event_remove_callback(struct ndi_event_hdl *ndi_event_hdl, 1785 ddi_callback_id_t cb_id) 1786 { 1787 ndi_event_callbacks_t *cb = (ndi_event_callbacks_t *)cb_id; 1788 ASSERT(cb); 1789 1790 ASSERT(mutex_owned(&ndi_event_hdl->ndi_evthdl_mutex)); 1791 ASSERT(mutex_owned(&ndi_event_hdl->ndi_evthdl_cb_mutex)); 1792 1793 /* remove from callback linked list */ 1794 if (cb->ndi_evtcb_prev) { 1795 cb->ndi_evtcb_prev->ndi_evtcb_next = cb->ndi_evtcb_next; 1796 } 1797 1798 if (cb->ndi_evtcb_next) { 1799 cb->ndi_evtcb_next->ndi_evtcb_prev = cb->ndi_evtcb_prev; 1800 } 1801 1802 if (NDI_EVENT(cb->ndi_evtcb_cookie)->callback_list == cb) { 1803 NDI_EVENT(cb->ndi_evtcb_cookie)->callback_list = 1804 cb->ndi_evtcb_next; 1805 } 1806 1807 kmem_free(cb, sizeof (ndi_event_callbacks_t)); 1808 } 1809 1810 /* 1811 * ndi_event_run_callbacks() performs event callbacks for the event 1812 * specified by cookie, if this is among those bound to the 1813 * supplied handle. 1814 * If the event is among those bound to the handle, none, 1815 * some, or all of the handlers registered for the event 1816 * will be called, according to the delivery attributes of 1817 * the event. 1818 * If the event attributes include NDI_EVENT_POST_TO_ALL 1819 * (the default), all the handlers for the event will be 1820 * called in an unspecified order. 1821 * If the event attributes include NDI_EVENT_POST_TO_TGT, only 1822 * the handlers (if any) registered by the driver identified by 1823 * rdip will be called. 1824 * If the event identified by cookie is not bound to the handle, 1825 * NDI_FAILURE will be returned. 1826 */ 1827 int 1828 ndi_event_run_callbacks(ndi_event_hdl_t handle, dev_info_t *child_dip, 1829 ddi_eventcookie_t cookie, void *bus_impldata) 1830 { 1831 struct ndi_event_hdl *ndi_event_hdl = (struct ndi_event_hdl *)handle; 1832 ndi_event_callbacks_t *next, *cb; 1833 int attributes; 1834 1835 mutex_enter(&ndi_event_hdl->ndi_evthdl_mutex); 1836 1837 /* if this is not our event, fail */ 1838 if (ndi_event_is_defined(handle, cookie, &attributes) != 1839 NDI_SUCCESS) { 1840 1841 mutex_exit(&ndi_event_hdl->ndi_evthdl_mutex); 1842 return (NDI_FAILURE); 1843 } 1844 1845 mutex_exit(&ndi_event_hdl->ndi_evthdl_mutex); 1846 1847 #ifdef NDI_EVENT_DEBUG 1848 if (ndi_event_debug) { 1849 cmn_err(CE_CONT, "ndi_event_run_callbacks:\n\t" 1850 "producer dip=%p (%s%d): cookie = %p, name = %s\n", 1851 (void *)ndi_event_hdl->ndi_evthdl_dip, 1852 ddi_node_name(ndi_event_hdl->ndi_evthdl_dip), 1853 ddi_get_instance(ndi_event_hdl->ndi_evthdl_dip), 1854 (void *)cookie, 1855 ndi_event_cookie_to_name(handle, cookie)); 1856 } 1857 #endif /* #ifdef NDI_EVENT_DEBUG */ 1858 1859 1860 /* 1861 * The callback handlers may call conversion functions. The conversion 1862 * functions may hold the ndi_evthdl_mutex during execution. Thus, to 1863 * avoid a recursive mutex problem, only the ndi_evthdl_cb_mutex is 1864 * held. The ndi_evthdl_mutex is not held when running the callbacks. 1865 */ 1866 mutex_enter(&ndi_event_hdl->ndi_evthdl_cb_mutex); 1867 1868 /* perform callbacks */ 1869 next = NDI_EVENT(cookie)->callback_list; 1870 while (next != NULL) { 1871 1872 cb = next; 1873 next = next->ndi_evtcb_next; 1874 1875 ASSERT(cb->ndi_evtcb_cookie == cookie); 1876 1877 if (attributes == NDI_EVENT_POST_TO_TGT && 1878 child_dip != cb->ndi_evtcb_dip) { 1879 continue; 1880 } 1881 1882 cb->ndi_evtcb_callback(cb->ndi_evtcb_dip, cb->ndi_evtcb_cookie, 1883 cb->ndi_evtcb_arg, bus_impldata); 1884 1885 #ifdef NDI_EVENT_DEBUG 1886 if (ndi_event_debug) { 1887 cmn_err(CE_CONT, 1888 "\t\tconsumer dip=%p (%s%d)\n", 1889 (void *)cb->ndi_evtcb_dip, 1890 ddi_node_name(cb->ndi_evtcb_dip), 1891 ddi_get_instance(cb->ndi_evtcb_dip)); 1892 } 1893 #endif 1894 1895 } 1896 1897 mutex_exit(&ndi_event_hdl->ndi_evthdl_cb_mutex); 1898 1899 #ifdef NDI_EVENT_DEBUG 1900 if (ndi_event_debug) { 1901 mutex_enter(&ndi_event_hdl->ndi_evthdl_mutex); 1902 ndi_event_dump_hdl(ndi_event_hdl, "ndi_event_run_callbacks"); 1903 mutex_exit(&ndi_event_hdl->ndi_evthdl_mutex); 1904 } 1905 #endif /* NDI_EVENT_DEBUG */ 1906 1907 return (NDI_SUCCESS); 1908 } 1909 1910 1911 /* 1912 * perform one callback for a specified cookie and just one target 1913 */ 1914 int 1915 ndi_event_do_callback(ndi_event_hdl_t handle, dev_info_t *child_dip, 1916 ddi_eventcookie_t cookie, void *bus_impldata) 1917 { 1918 struct ndi_event_hdl *ndi_event_hdl = (struct ndi_event_hdl *)handle; 1919 ndi_event_callbacks_t *next, *cb; 1920 int attributes; 1921 1922 mutex_enter(&ndi_event_hdl->ndi_evthdl_mutex); 1923 1924 /* if this is not our event, fail */ 1925 if (ndi_event_is_defined(handle, cookie, &attributes) != 1926 NDI_SUCCESS) { 1927 1928 mutex_exit(&ndi_event_hdl->ndi_evthdl_mutex); 1929 1930 return (NDI_FAILURE); 1931 } 1932 1933 mutex_exit(&ndi_event_hdl->ndi_evthdl_mutex); 1934 1935 #ifdef NDI_EVENT_DEBUG 1936 if (ndi_event_debug) { 1937 cmn_err(CE_CONT, "ndi_event_run_callbacks:\n\t" 1938 "producer dip=%p (%s%d): cookie = %p, name = %s\n", 1939 (void *)ndi_event_hdl->ndi_evthdl_dip, 1940 ddi_node_name(ndi_event_hdl->ndi_evthdl_dip), 1941 ddi_get_instance(ndi_event_hdl->ndi_evthdl_dip), 1942 (void *)cookie, 1943 ndi_event_cookie_to_name(handle, cookie)); 1944 } 1945 #endif 1946 1947 1948 /* 1949 * we only grab the cb mutex because the callback handlers 1950 * may call the conversion functions which would cause a recursive 1951 * mutex problem 1952 */ 1953 mutex_enter(&ndi_event_hdl->ndi_evthdl_cb_mutex); 1954 1955 /* perform callbacks */ 1956 for (next = NDI_EVENT(cookie)->callback_list; next != NULL; ) { 1957 cb = next; 1958 next = next->ndi_evtcb_next; 1959 1960 if (cb->ndi_evtcb_dip == child_dip) { 1961 cb->ndi_evtcb_callback(cb->ndi_evtcb_dip, 1962 cb->ndi_evtcb_cookie, cb->ndi_evtcb_arg, 1963 bus_impldata); 1964 1965 #ifdef NDI_EVENT_DEBUG 1966 if (ndi_event_debug) { 1967 cmn_err(CE_CONT, 1968 "\t\tconsumer dip=%p (%s%d)\n", 1969 (void *)cb->ndi_evtcb_dip, 1970 ddi_node_name(cb->ndi_evtcb_dip), 1971 ddi_get_instance(cb->ndi_evtcb_dip)); 1972 } 1973 #endif 1974 break; 1975 } 1976 } 1977 1978 mutex_exit(&ndi_event_hdl->ndi_evthdl_cb_mutex); 1979 1980 #ifdef NDI_EVENT_DEBUG 1981 if (ndi_event_debug) { 1982 mutex_enter(&ndi_event_hdl->ndi_evthdl_mutex); 1983 ndi_event_dump_hdl(ndi_event_hdl, "ndi_event_run_callbacks"); 1984 mutex_exit(&ndi_event_hdl->ndi_evthdl_mutex); 1985 } 1986 #endif /* NDI_EVENT_DEBUG */ 1987 1988 return (NDI_SUCCESS); 1989 } 1990 1991 1992 /* 1993 * ndi_event_tag_to_cookie: utility function to find an event cookie 1994 * given an event tag 1995 */ 1996 ddi_eventcookie_t 1997 ndi_event_tag_to_cookie(ndi_event_hdl_t handle, int event_tag) 1998 { 1999 struct ndi_event_hdl *ndi_event_hdl = (struct ndi_event_hdl *)handle; 2000 ndi_event_cookie_t *list; 2001 2002 mutex_enter(&ndi_event_hdl->ndi_evthdl_mutex); 2003 2004 list = ndi_event_hdl->ndi_evthdl_cookie_list; 2005 while (list != NULL) { 2006 if (NDI_EVENT_TAG(list) == event_tag) { 2007 mutex_exit(&ndi_event_hdl->ndi_evthdl_mutex); 2008 return ((ddi_eventcookie_t)list); 2009 } 2010 2011 list = list->next_cookie; 2012 } 2013 2014 mutex_exit(&ndi_event_hdl->ndi_evthdl_mutex); 2015 return (NULL); 2016 } 2017 2018 /* 2019 * ndi_event_cookie_to_tag: utility function to find a event tag 2020 * given an event_cookie 2021 */ 2022 int 2023 ndi_event_cookie_to_tag(ndi_event_hdl_t handle, ddi_eventcookie_t cookie) 2024 { 2025 struct ndi_event_hdl *ndi_event_hdl = (struct ndi_event_hdl *)handle; 2026 ndi_event_cookie_t *list; 2027 2028 mutex_enter(&ndi_event_hdl->ndi_evthdl_mutex); 2029 2030 list = ndi_event_hdl->ndi_evthdl_cookie_list; 2031 2032 while (list != NULL) { 2033 if ((ddi_eventcookie_t)list == cookie) { 2034 mutex_exit(&ndi_event_hdl->ndi_evthdl_mutex); 2035 return (NDI_EVENT_TAG(list)); 2036 } 2037 2038 list = list->next_cookie; 2039 } 2040 2041 mutex_exit(&ndi_event_hdl->ndi_evthdl_mutex); 2042 return (NDI_FAILURE); 2043 2044 } 2045 2046 /* 2047 * ndi_event_cookie_to_name: utility function to find an event name 2048 * given an event_cookie 2049 */ 2050 char * 2051 ndi_event_cookie_to_name(ndi_event_hdl_t handle, ddi_eventcookie_t cookie) 2052 { 2053 struct ndi_event_hdl *ndi_event_hdl = (struct ndi_event_hdl *)handle; 2054 ndi_event_cookie_t *list; 2055 2056 mutex_enter(&ndi_event_hdl->ndi_evthdl_mutex); 2057 2058 list = ndi_event_hdl->ndi_evthdl_cookie_list; 2059 2060 while (list != NULL) { 2061 if (list == NDI_EVENT(cookie)) { 2062 mutex_exit(&ndi_event_hdl->ndi_evthdl_mutex); 2063 return (NDI_EVENT_NAME(list)); 2064 } 2065 2066 list = list->next_cookie; 2067 } 2068 2069 mutex_exit(&ndi_event_hdl->ndi_evthdl_mutex); 2070 return (NULL); 2071 } 2072 2073 /* 2074 * ndi_event_tag_to_name: utility function to find an event name 2075 * given an event tag 2076 */ 2077 char * 2078 ndi_event_tag_to_name(ndi_event_hdl_t handle, int event_tag) 2079 { 2080 struct ndi_event_hdl *ndi_event_hdl = (struct ndi_event_hdl *)handle; 2081 ndi_event_cookie_t *list; 2082 2083 mutex_enter(&ndi_event_hdl->ndi_evthdl_mutex); 2084 2085 list = ndi_event_hdl->ndi_evthdl_cookie_list; 2086 2087 while (list) { 2088 if (NDI_EVENT_TAG(list) == event_tag) { 2089 mutex_exit(&ndi_event_hdl->ndi_evthdl_mutex); 2090 return (NDI_EVENT_NAME(list)); 2091 } 2092 2093 list = list->next_cookie; 2094 } 2095 2096 mutex_exit(&ndi_event_hdl->ndi_evthdl_mutex); 2097 2098 return (NULL); 2099 } 2100 2101 #ifdef NDI_EVENT_DEBUG 2102 void 2103 ndi_event_dump_hdl(struct ndi_event_hdl *hdl, char *location) 2104 { 2105 2106 2107 ndi_event_callbacks_t *next; 2108 ndi_event_cookie_t *list; 2109 2110 ASSERT(mutex_owned(&hdl->ndi_evthdl_mutex)); 2111 list = hdl->ndi_evthdl_cookie_list; 2112 2113 cmn_err(CE_CONT, "%s: event handle (%p): dip = %p (%s%d)\n", 2114 location, (void *)hdl, (void *)hdl->ndi_evthdl_dip, 2115 ddi_node_name(hdl->ndi_evthdl_dip), 2116 ddi_get_instance(hdl->ndi_evthdl_dip)); 2117 cmn_err(CE_CONT, "\thigh=%d other=%d n=%d\n", 2118 hdl->ndi_evthdl_high_plevels, hdl->ndi_evthdl_other_plevels, 2119 hdl->ndi_evthdl_n_events); 2120 2121 cmn_err(CE_CONT, "\tevent cookies:\n"); 2122 while (list) { 2123 cmn_err(CE_CONT, "\t\ttag=%d name=%s p=%d a=%x dd=%p\n", 2124 NDI_EVENT_TAG(list), NDI_EVENT_NAME(list), 2125 NDI_EVENT_PLEVEL(list), NDI_EVENT_ATTRIBUTES(list), 2126 (void *)NDI_EVENT_DDIP(list)); 2127 cmn_err(CE_CONT, "\t\tcallbacks:\n"); 2128 for (next = list->callback_list; next != NULL; 2129 next = next->ndi_evtcb_next) { 2130 cmn_err(CE_CONT, 2131 "\t\t dip=%p (%s%d) cookie=%p arg=%p\n", 2132 (void*)next->ndi_evtcb_dip, 2133 ddi_driver_name(next->ndi_evtcb_dip), 2134 ddi_get_instance(next->ndi_evtcb_dip), 2135 (void *)next->ndi_evtcb_cookie, 2136 next->ndi_evtcb_arg); 2137 } 2138 2139 list = list->next_cookie; 2140 } 2141 2142 cmn_err(CE_CONT, "\n"); 2143 } 2144 #endif 2145 2146 int 2147 ndi_dev_is_prom_node(dev_info_t *dip) 2148 { 2149 return (DEVI(dip)->devi_node_class == DDI_NC_PROM); 2150 } 2151 2152 int 2153 ndi_dev_is_pseudo_node(dev_info_t *dip) 2154 { 2155 /* 2156 * NOTE: this does NOT mean the pseudo branch of the device tree, 2157 * it means the node was created by software (DEVI_SID_NODEID || 2158 * DEVI_PSEUDO_NODEID || DEVI_SID_HIDDEN_NODEID) instead of being 2159 * generated from a PROM node. 2160 */ 2161 return (DEVI(dip)->devi_node_class == DDI_NC_PSEUDO); 2162 } 2163 2164 int 2165 ndi_dev_is_persistent_node(dev_info_t *dip) 2166 { 2167 return ((DEVI(dip)->devi_node_attributes & DDI_PERSISTENT) != 0); 2168 } 2169 2170 int 2171 ndi_dev_is_hidden_node(dev_info_t *dip) 2172 { 2173 return ((DEVI(dip)->devi_node_attributes & DDI_HIDDEN_NODE) != 0); 2174 } 2175 2176 int 2177 ndi_dev_is_hotplug_node(dev_info_t *dip) 2178 { 2179 return ((DEVI(dip)->devi_node_attributes & DDI_HOTPLUG_NODE) != 0); 2180 } 2181 2182 void 2183 ndi_devi_set_hidden(dev_info_t *dip) 2184 { 2185 DEVI(dip)->devi_node_attributes |= DDI_HIDDEN_NODE; 2186 } 2187 2188 void 2189 ndi_devi_clr_hidden(dev_info_t *dip) 2190 { 2191 DEVI(dip)->devi_node_attributes &= ~DDI_HIDDEN_NODE; 2192 } 2193 2194 int 2195 i_ndi_dev_is_auto_assigned_node(dev_info_t *dip) 2196 { 2197 return ((DEVI(dip)->devi_node_attributes & 2198 DDI_AUTO_ASSIGNED_NODEID) != 0); 2199 } 2200 2201 void 2202 i_ndi_set_node_class(dev_info_t *dip, ddi_node_class_t c) 2203 { 2204 DEVI(dip)->devi_node_class = c; 2205 } 2206 2207 ddi_node_class_t 2208 i_ndi_get_node_class(dev_info_t *dip) 2209 { 2210 return (DEVI(dip)->devi_node_class); 2211 } 2212 2213 void 2214 i_ndi_set_node_attributes(dev_info_t *dip, int p) 2215 { 2216 DEVI(dip)->devi_node_attributes = p; 2217 } 2218 2219 int 2220 i_ndi_get_node_attributes(dev_info_t *dip) 2221 { 2222 return (DEVI(dip)->devi_node_attributes); 2223 } 2224 2225 void 2226 i_ndi_set_nodeid(dev_info_t *dip, int n) 2227 { 2228 DEVI(dip)->devi_nodeid = n; 2229 } 2230 2231 void 2232 ndi_set_acc_fault(ddi_acc_handle_t ah) 2233 { 2234 i_ddi_acc_set_fault(ah); 2235 } 2236 2237 void 2238 ndi_clr_acc_fault(ddi_acc_handle_t ah) 2239 { 2240 i_ddi_acc_clr_fault(ah); 2241 } 2242 2243 void 2244 ndi_set_dma_fault(ddi_dma_handle_t dh) 2245 { 2246 i_ddi_dma_set_fault(dh); 2247 } 2248 2249 void 2250 ndi_clr_dma_fault(ddi_dma_handle_t dh) 2251 { 2252 i_ddi_dma_clr_fault(dh); 2253 } 2254 2255 /* 2256 * The default fault-handler, called when the event posted by 2257 * ddi_dev_report_fault() reaches rootnex. 2258 */ 2259 static void 2260 i_ddi_fault_handler(dev_info_t *dip, struct ddi_fault_event_data *fedp) 2261 { 2262 ASSERT(fedp); 2263 2264 mutex_enter(&(DEVI(dip)->devi_lock)); 2265 if (!DEVI_IS_DEVICE_OFFLINE(dip)) { 2266 switch (fedp->f_impact) { 2267 case DDI_SERVICE_LOST: 2268 DEVI_SET_DEVICE_DOWN(dip); 2269 break; 2270 2271 case DDI_SERVICE_DEGRADED: 2272 DEVI_SET_DEVICE_DEGRADED(dip); 2273 break; 2274 2275 case DDI_SERVICE_UNAFFECTED: 2276 default: 2277 break; 2278 2279 case DDI_SERVICE_RESTORED: 2280 DEVI_SET_DEVICE_UP(dip); 2281 break; 2282 } 2283 } 2284 mutex_exit(&(DEVI(dip)->devi_lock)); 2285 } 2286 2287 /* 2288 * The default fault-logger, called when the event posted by 2289 * ddi_dev_report_fault() reaches rootnex. 2290 */ 2291 /*ARGSUSED*/ 2292 static void 2293 i_ddi_fault_logger(dev_info_t *rdip, struct ddi_fault_event_data *fedp) 2294 { 2295 ddi_devstate_t newstate; 2296 const char *action; 2297 const char *servstate; 2298 const char *location; 2299 int bad; 2300 int changed; 2301 int level; 2302 int still; 2303 2304 ASSERT(fedp); 2305 2306 bad = 0; 2307 switch (fedp->f_location) { 2308 case DDI_DATAPATH_FAULT: 2309 location = "in datapath to"; 2310 break; 2311 case DDI_DEVICE_FAULT: 2312 location = "in"; 2313 break; 2314 case DDI_EXTERNAL_FAULT: 2315 location = "external to"; 2316 break; 2317 default: 2318 location = "somewhere near"; 2319 bad = 1; 2320 break; 2321 } 2322 2323 newstate = ddi_get_devstate(fedp->f_dip); 2324 switch (newstate) { 2325 case DDI_DEVSTATE_OFFLINE: 2326 servstate = "unavailable"; 2327 break; 2328 case DDI_DEVSTATE_DOWN: 2329 servstate = "unavailable"; 2330 break; 2331 case DDI_DEVSTATE_QUIESCED: 2332 servstate = "suspended"; 2333 break; 2334 case DDI_DEVSTATE_DEGRADED: 2335 servstate = "degraded"; 2336 break; 2337 default: 2338 servstate = "available"; 2339 break; 2340 } 2341 2342 changed = (newstate != fedp->f_oldstate); 2343 level = (newstate < fedp->f_oldstate) ? CE_WARN : CE_NOTE; 2344 switch (fedp->f_impact) { 2345 case DDI_SERVICE_LOST: 2346 case DDI_SERVICE_DEGRADED: 2347 case DDI_SERVICE_UNAFFECTED: 2348 /* fault detected; service [still] <servstate> */ 2349 action = "fault detected"; 2350 still = !changed; 2351 break; 2352 2353 case DDI_SERVICE_RESTORED: 2354 if (newstate != DDI_DEVSTATE_UP) { 2355 /* fault cleared; service still <servstate> */ 2356 action = "fault cleared"; 2357 still = 1; 2358 } else if (changed) { 2359 /* fault cleared; service <servstate> */ 2360 action = "fault cleared"; 2361 still = 0; 2362 } else { 2363 /* no fault; service <servstate> */ 2364 action = "no fault"; 2365 still = 0; 2366 } 2367 break; 2368 2369 default: 2370 bad = 1; 2371 still = 0; 2372 break; 2373 } 2374 2375 cmn_err(level, "!%s%d: %s %s device; service %s%s"+(bad|changed), 2376 ddi_driver_name(fedp->f_dip), ddi_get_instance(fedp->f_dip), 2377 bad ? "invalid report of fault" : action, 2378 location, still ? "still " : "", servstate); 2379 2380 cmn_err(level, "!%s%d: %s"+(bad|changed), 2381 ddi_driver_name(fedp->f_dip), ddi_get_instance(fedp->f_dip), 2382 fedp->f_message); 2383 } 2384 2385 /* 2386 * Platform-settable pointers to fault handler and logger functions. 2387 * These are called by the default rootnex event-posting code when 2388 * a fault event reaches rootnex. 2389 */ 2390 void (*plat_fault_handler)(dev_info_t *, struct ddi_fault_event_data *) = 2391 i_ddi_fault_handler; 2392 void (*plat_fault_logger)(dev_info_t *, struct ddi_fault_event_data *) = 2393 i_ddi_fault_logger; 2394 2395 /* 2396 * Rootnex event definitions ... 2397 */ 2398 enum rootnex_event_tags { 2399 ROOTNEX_FAULT_EVENT 2400 }; 2401 static ndi_event_hdl_t rootnex_event_hdl; 2402 static ndi_event_definition_t rootnex_event_set[] = { 2403 { 2404 ROOTNEX_FAULT_EVENT, 2405 DDI_DEVI_FAULT_EVENT, 2406 EPL_INTERRUPT, 2407 NDI_EVENT_POST_TO_ALL 2408 } 2409 }; 2410 static ndi_event_set_t rootnex_events = { 2411 NDI_EVENTS_REV1, 2412 sizeof (rootnex_event_set) / sizeof (rootnex_event_set[0]), 2413 rootnex_event_set 2414 }; 2415 2416 /* 2417 * Initialize rootnex event handle 2418 */ 2419 void 2420 i_ddi_rootnex_init_events(dev_info_t *dip) 2421 { 2422 if (ndi_event_alloc_hdl(dip, (ddi_iblock_cookie_t)(LOCK_LEVEL-1), 2423 &rootnex_event_hdl, NDI_SLEEP) == NDI_SUCCESS) { 2424 if (ndi_event_bind_set(rootnex_event_hdl, 2425 &rootnex_events, NDI_SLEEP) != NDI_SUCCESS) { 2426 (void) ndi_event_free_hdl(rootnex_event_hdl); 2427 rootnex_event_hdl = NULL; 2428 } 2429 } 2430 } 2431 2432 /* 2433 * Event-handling functions for rootnex 2434 * These provide the standard implementation of fault handling 2435 */ 2436 /*ARGSUSED*/ 2437 int 2438 i_ddi_rootnex_get_eventcookie(dev_info_t *dip, dev_info_t *rdip, 2439 char *eventname, ddi_eventcookie_t *cookiep) 2440 { 2441 if (rootnex_event_hdl == NULL) 2442 return (NDI_FAILURE); 2443 return (ndi_event_retrieve_cookie(rootnex_event_hdl, rdip, eventname, 2444 cookiep, NDI_EVENT_NOPASS)); 2445 } 2446 2447 /*ARGSUSED*/ 2448 int 2449 i_ddi_rootnex_add_eventcall(dev_info_t *dip, dev_info_t *rdip, 2450 ddi_eventcookie_t eventid, void (*handler)(dev_info_t *dip, 2451 ddi_eventcookie_t event, void *arg, void *impl_data), void *arg, 2452 ddi_callback_id_t *cb_id) 2453 { 2454 if (rootnex_event_hdl == NULL) 2455 return (NDI_FAILURE); 2456 return (ndi_event_add_callback(rootnex_event_hdl, rdip, 2457 eventid, handler, arg, NDI_SLEEP, cb_id)); 2458 } 2459 2460 /*ARGSUSED*/ 2461 int 2462 i_ddi_rootnex_remove_eventcall(dev_info_t *dip, ddi_callback_id_t cb_id) 2463 { 2464 if (rootnex_event_hdl == NULL) 2465 return (NDI_FAILURE); 2466 2467 return (ndi_event_remove_callback(rootnex_event_hdl, cb_id)); 2468 } 2469 2470 /*ARGSUSED*/ 2471 int 2472 i_ddi_rootnex_post_event(dev_info_t *dip, dev_info_t *rdip, 2473 ddi_eventcookie_t eventid, void *impl_data) 2474 { 2475 int tag; 2476 2477 if (rootnex_event_hdl == NULL) 2478 return (NDI_FAILURE); 2479 2480 tag = ndi_event_cookie_to_tag(rootnex_event_hdl, eventid); 2481 if (tag == ROOTNEX_FAULT_EVENT) { 2482 (*plat_fault_handler)(rdip, impl_data); 2483 (*plat_fault_logger)(rdip, impl_data); 2484 } 2485 return (ndi_event_run_callbacks(rootnex_event_hdl, rdip, 2486 eventid, impl_data)); 2487 } 2488 2489 /* 2490 * ndi_set_bus_private/ndi_get_bus_private: 2491 * Get/set device bus private data in devinfo. 2492 */ 2493 void 2494 ndi_set_bus_private(dev_info_t *dip, boolean_t up, uint32_t port_type, 2495 void *data) 2496 { 2497 if (up) { 2498 DEVI(dip)->devi_bus.port_up.info.port.type = port_type; 2499 DEVI(dip)->devi_bus.port_up.priv_p = data; 2500 } else { 2501 DEVI(dip)->devi_bus.port_down.info.port.type = port_type; 2502 DEVI(dip)->devi_bus.port_down.priv_p = data; 2503 } 2504 } 2505 2506 void * 2507 ndi_get_bus_private(dev_info_t *dip, boolean_t up) 2508 { 2509 if (up) 2510 return (DEVI(dip)->devi_bus.port_up.priv_p); 2511 else 2512 return (DEVI(dip)->devi_bus.port_down.priv_p); 2513 } 2514 2515 boolean_t 2516 ndi_port_type(dev_info_t *dip, boolean_t up, uint32_t port_type) 2517 { 2518 if (up) { 2519 return ((DEVI(dip)->devi_bus.port_up.info.port.type) == 2520 port_type); 2521 } else { 2522 return ((DEVI(dip)->devi_bus.port_down.info.port.type) == 2523 port_type); 2524 } 2525 } 2526 2527 /* Interfaces for 'self' to set/get a child's flavor */ 2528 void 2529 ndi_flavor_set(dev_info_t *child, ndi_flavor_t child_flavor) 2530 { 2531 DEVI(child)->devi_flavor = child_flavor; 2532 } 2533 2534 ndi_flavor_t 2535 ndi_flavor_get(dev_info_t *child) 2536 { 2537 return (DEVI(child)->devi_flavor); 2538 } 2539 2540 /* 2541 * Interfaces to maintain flavor-specific private data of flavored 2542 * children of self. 2543 * 2544 * The flavor count always includes the default (0) vanilla flavor, 2545 * but storage for the vanilla flavor data pointer is in the same 2546 * place that ddi_[sg]et_driver_private uses, so the flavorv 2547 * storage is just for flavors 1..{nflavors-1}. 2548 */ 2549 void 2550 ndi_flavorv_alloc(dev_info_t *self, int nflavors) 2551 { 2552 ASSERT(nflavors > 0 && (DEVI(self)->devi_flavorv == NULL || 2553 nflavors == DEVI(self)->devi_flavorv_n)); 2554 if (nflavors <= 1 || (DEVI(self)->devi_flavorv)) { 2555 return; 2556 } 2557 DEVI(self)->devi_flavorv = 2558 kmem_zalloc((nflavors - 1) * sizeof (void *), KM_SLEEP); 2559 DEVI(self)->devi_flavorv_n = nflavors; 2560 } 2561 2562 void 2563 ndi_flavorv_set(dev_info_t *self, ndi_flavor_t child_flavor, void *v) 2564 { 2565 if (child_flavor == NDI_FLAVOR_VANILLA) { 2566 ddi_set_driver_private(self, v); 2567 } else { 2568 ASSERT(child_flavor < DEVI(self)->devi_flavorv_n && 2569 DEVI(self)->devi_flavorv != NULL); 2570 if (child_flavor > DEVI(self)->devi_flavorv_n || 2571 DEVI(self)->devi_flavorv == NULL) { 2572 return; 2573 } 2574 DEVI(self)->devi_flavorv[child_flavor - 1] = v; 2575 } 2576 } 2577 2578 void * 2579 ndi_flavorv_get(dev_info_t *self, ndi_flavor_t child_flavor) 2580 { 2581 if (child_flavor == NDI_FLAVOR_VANILLA) { 2582 return (ddi_get_driver_private(self)); 2583 } else { 2584 ASSERT(child_flavor < DEVI(self)->devi_flavorv_n && 2585 DEVI(self)->devi_flavorv != NULL); 2586 if (child_flavor > DEVI(self)->devi_flavorv_n || 2587 DEVI(self)->devi_flavorv == NULL) { 2588 return (NULL); 2589 } 2590 return (DEVI(self)->devi_flavorv[child_flavor - 1]); 2591 } 2592 } 2593