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