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 * Copyright 2012 Garrett D'Amore <garrett@damore.org>. All rights reserved. 27 */ 28 29 30 /* 31 * usb interface association driver 32 * 33 * this driver attempts to the interface association node and 34 * creates/manages child nodes for the included interfaces. 35 */ 36 37 #if defined(lint) && !defined(DEBUG) 38 #define DEBUG 1 39 #endif 40 #include <sys/usb/usba/usbai_version.h> 41 #include <sys/usb/usba.h> 42 #include <sys/usb/usba/usba_types.h> 43 #include <sys/usb/usba/usba_impl.h> 44 #include <sys/usb/usb_ia/usb_iavar.h> 45 46 /* Debugging support */ 47 uint_t usb_ia_errlevel = USB_LOG_L4; 48 uint_t usb_ia_errmask = (uint_t)DPRINT_MASK_ALL; 49 uint_t usb_ia_instance_debug = (uint_t)-1; 50 uint_t usb_ia_bus_config_debug = 0; 51 52 _NOTE(DATA_READABLE_WITHOUT_LOCK(usb_ia_errlevel)) 53 _NOTE(DATA_READABLE_WITHOUT_LOCK(usb_ia_errmask)) 54 _NOTE(DATA_READABLE_WITHOUT_LOCK(usb_ia_instance_debug)) 55 56 _NOTE(SCHEME_PROTECTS_DATA("unique", msgb)) 57 _NOTE(SCHEME_PROTECTS_DATA("unique", dev_info)) 58 _NOTE(SCHEME_PROTECTS_DATA("unique", usb_pipe_policy)) 59 60 static struct cb_ops usb_ia_cb_ops = { 61 nodev, /* open */ 62 nodev, /* close */ 63 nodev, /* strategy */ 64 nodev, /* print */ 65 nodev, /* dump */ 66 nodev, /* read */ 67 nodev, /* write */ 68 nodev, /* ioctl */ 69 nodev, /* devmap */ 70 nodev, /* mmap */ 71 nodev, /* segmap */ 72 nochpoll, /* poll */ 73 ddi_prop_op, /* prop_op */ 74 NULL, /* aread */ 75 D_MP 76 }; 77 78 static int usb_ia_busop_get_eventcookie(dev_info_t *dip, 79 dev_info_t *rdip, 80 char *eventname, 81 ddi_eventcookie_t *cookie); 82 static int usb_ia_busop_add_eventcall(dev_info_t *dip, 83 dev_info_t *rdip, 84 ddi_eventcookie_t cookie, 85 void (*callback)(dev_info_t *dip, 86 ddi_eventcookie_t cookie, void *arg, 87 void *bus_impldata), 88 void *arg, ddi_callback_id_t *cb_id); 89 static int usb_ia_busop_remove_eventcall(dev_info_t *dip, 90 ddi_callback_id_t cb_id); 91 static int usb_ia_busop_post_event(dev_info_t *dip, 92 dev_info_t *rdip, 93 ddi_eventcookie_t cookie, 94 void *bus_impldata); 95 static int usb_ia_bus_config(dev_info_t *dip, 96 uint_t flag, 97 ddi_bus_config_op_t op, 98 void *arg, 99 dev_info_t **child); 100 static int usb_ia_bus_unconfig(dev_info_t *dip, 101 uint_t flag, 102 ddi_bus_config_op_t op, 103 void *arg); 104 105 /* 106 * autoconfiguration data and routines. 107 */ 108 static int usb_ia_info(dev_info_t *, ddi_info_cmd_t, 109 void *, void **); 110 static int usb_ia_attach(dev_info_t *, ddi_attach_cmd_t); 111 static int usb_ia_detach(dev_info_t *, ddi_detach_cmd_t); 112 113 /* other routines */ 114 static void usb_ia_create_pm_components(dev_info_t *, usb_ia_t *); 115 static int usb_ia_bus_ctl(dev_info_t *, dev_info_t *, 116 ddi_ctl_enum_t, void *, void *); 117 static int usb_ia_power(dev_info_t *, int, int); 118 static int usb_ia_restore_device_state(dev_info_t *, usb_ia_t *); 119 static usb_ia_t *usb_ia_obtain_state(dev_info_t *); 120 static void usb_ia_event_cb(dev_info_t *, ddi_eventcookie_t, void *, void *); 121 122 /* prototypes */ 123 static void usb_ia_create_children(usb_ia_t *); 124 static int usb_ia_cleanup(usb_ia_t *); 125 126 /* 127 * Busops vector 128 */ 129 static struct bus_ops usb_ia_busops = { 130 BUSO_REV, 131 nullbusmap, /* bus_map */ 132 NULL, /* bus_get_intrspec */ 133 NULL, /* bus_add_intrspec */ 134 NULL, /* bus_remove_intrspec */ 135 NULL, /* XXXX bus_map_fault */ 136 NULL, /* bus_dma_map */ 137 ddi_dma_allochdl, 138 ddi_dma_freehdl, 139 ddi_dma_bindhdl, 140 ddi_dma_unbindhdl, 141 ddi_dma_flush, 142 ddi_dma_win, 143 ddi_dma_mctl, /* bus_dma_ctl */ 144 usb_ia_bus_ctl, /* bus_ctl */ 145 ddi_bus_prop_op, /* bus_prop_op */ 146 usb_ia_busop_get_eventcookie, 147 usb_ia_busop_add_eventcall, 148 usb_ia_busop_remove_eventcall, 149 usb_ia_busop_post_event, /* bus_post_event */ 150 NULL, /* bus_intr_ctl */ 151 usb_ia_bus_config, /* bus_config */ 152 usb_ia_bus_unconfig, /* bus_unconfig */ 153 NULL, /* bus_fm_init */ 154 NULL, /* bus_fm_fini */ 155 NULL, /* bus_fm_access_enter */ 156 NULL, /* bus_fm_access_exit */ 157 NULL /* bus_power */ 158 }; 159 160 161 static struct dev_ops usb_ia_ops = { 162 DEVO_REV, /* devo_rev, */ 163 0, /* refcnt */ 164 usb_ia_info, /* info */ 165 nulldev, /* identify */ 166 nulldev, /* probe */ 167 usb_ia_attach, /* attach */ 168 usb_ia_detach, /* detach */ 169 nodev, /* reset */ 170 &usb_ia_cb_ops, /* driver operations */ 171 &usb_ia_busops, /* bus operations */ 172 usb_ia_power, /* power */ 173 ddi_quiesce_not_needed, /* devo_quiesce */ 174 }; 175 176 static struct modldrv modldrv = { 177 &mod_driverops, /* Type of module. This one is a driver */ 178 "USB Interface Association Driver", /* Name of the module. */ 179 &usb_ia_ops, /* driver ops */ 180 }; 181 182 static struct modlinkage modlinkage = { 183 MODREV_1, (void *)&modldrv, NULL 184 }; 185 186 #define USB_IA_INITIAL_SOFT_SPACE 4 187 static void *usb_ia_statep; 188 189 /* 190 * event definition 191 */ 192 static ndi_event_definition_t usb_ia_ndi_event_defs[] = { 193 {USBA_EVENT_TAG_HOT_REMOVAL, DDI_DEVI_REMOVE_EVENT, EPL_KERNEL, 194 NDI_EVENT_POST_TO_ALL}, 195 {USBA_EVENT_TAG_HOT_INSERTION, DDI_DEVI_INSERT_EVENT, EPL_KERNEL, 196 NDI_EVENT_POST_TO_ALL}, 197 {USBA_EVENT_TAG_POST_RESUME, USBA_POST_RESUME_EVENT, EPL_KERNEL, 198 NDI_EVENT_POST_TO_ALL}, 199 {USBA_EVENT_TAG_PRE_SUSPEND, USBA_PRE_SUSPEND_EVENT, EPL_KERNEL, 200 NDI_EVENT_POST_TO_ALL} 201 }; 202 203 #define USB_IA_N_NDI_EVENTS \ 204 (sizeof (usb_ia_ndi_event_defs) / sizeof (ndi_event_definition_t)) 205 206 static ndi_event_set_t usb_ia_ndi_events = { 207 NDI_EVENTS_REV1, USB_IA_N_NDI_EVENTS, usb_ia_ndi_event_defs}; 208 209 210 /* 211 * standard driver entry points 212 */ 213 int 214 _init(void) 215 { 216 int rval; 217 218 rval = ddi_soft_state_init(&usb_ia_statep, sizeof (struct usb_ia), 219 USB_IA_INITIAL_SOFT_SPACE); 220 if (rval != 0) { 221 return (rval); 222 } 223 224 if ((rval = mod_install(&modlinkage)) != 0) { 225 ddi_soft_state_fini(&usb_ia_statep); 226 return (rval); 227 } 228 229 return (rval); 230 } 231 232 233 int 234 _fini(void) 235 { 236 int rval; 237 238 rval = mod_remove(&modlinkage); 239 240 if (rval) { 241 return (rval); 242 } 243 244 ddi_soft_state_fini(&usb_ia_statep); 245 246 return (rval); 247 } 248 249 250 int 251 _info(struct modinfo *modinfop) 252 { 253 return (mod_info(&modlinkage, modinfop)); 254 } 255 256 257 /*ARGSUSED*/ 258 static int 259 usb_ia_info(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg, void **result) 260 { 261 usb_ia_t *usb_ia; 262 int instance = getminor((dev_t)arg); 263 int error = DDI_FAILURE; 264 265 switch (infocmd) { 266 case DDI_INFO_DEVT2DEVINFO: 267 if ((usb_ia = ddi_get_soft_state(usb_ia_statep, 268 instance)) != NULL) { 269 *result = (void *)usb_ia->ia_dip; 270 if (*result != NULL) { 271 error = DDI_SUCCESS; 272 } 273 } else { 274 *result = NULL; 275 } 276 break; 277 278 case DDI_INFO_DEVT2INSTANCE: 279 *result = (void *)(intptr_t)instance; 280 error = DDI_SUCCESS; 281 break; 282 default: 283 break; 284 } 285 286 return (error); 287 } 288 289 290 /* 291 * child post attach/detach notification 292 */ 293 static void 294 usb_ia_post_attach(usb_ia_t *usb_ia, uint8_t ifno, struct attachspec *as) 295 { 296 USB_DPRINTF_L4(DPRINT_MASK_PM, usb_ia->ia_log_handle, 297 "usb_ia_post_attach: ifno = %d result = %d", ifno, as->result); 298 299 } 300 301 302 static void 303 usb_ia_post_detach(usb_ia_t *usb_ia, uint8_t ifno, struct detachspec *ds) 304 { 305 USB_DPRINTF_L4(DPRINT_MASK_PM, usb_ia->ia_log_handle, 306 "usb_ia_post_detach: ifno = %d result = %d", ifno, ds->result); 307 308 } 309 310 311 /* 312 * bus ctl support. we handle notifications here and the 313 * rest goes up to root hub/hcd 314 */ 315 /*ARGSUSED*/ 316 static int 317 usb_ia_bus_ctl(dev_info_t *dip, 318 dev_info_t *rdip, 319 ddi_ctl_enum_t op, 320 void *arg, 321 void *result) 322 { 323 usba_device_t *hub_usba_device = usba_get_usba_device(rdip); 324 dev_info_t *root_hub_dip = hub_usba_device->usb_root_hub_dip; 325 usb_ia_t *usb_ia; 326 struct attachspec *as; 327 struct detachspec *ds; 328 329 usb_ia = usb_ia_obtain_state(dip); 330 331 USB_DPRINTF_L4(DPRINT_MASK_PM, usb_ia->ia_log_handle, 332 "usb_ia_bus_ctl:\n\t" 333 "dip = 0x%p, rdip = 0x%p, op = 0x%x, arg = 0x%p", 334 (void *)dip, (void *)rdip, op, arg); 335 336 switch (op) { 337 case DDI_CTLOPS_ATTACH: 338 as = (struct attachspec *)arg; 339 340 switch (as->when) { 341 case DDI_PRE : 342 /* nothing to do basically */ 343 USB_DPRINTF_L2(DPRINT_MASK_PM, usb_ia->ia_log_handle, 344 "DDI_PRE DDI_CTLOPS_ATTACH"); 345 break; 346 case DDI_POST : 347 usb_ia_post_attach(usb_ia, usba_get_ifno(rdip), 348 (struct attachspec *)arg); 349 break; 350 } 351 352 break; 353 case DDI_CTLOPS_DETACH: 354 ds = (struct detachspec *)arg; 355 356 switch (ds->when) { 357 case DDI_PRE : 358 /* nothing to do basically */ 359 USB_DPRINTF_L2(DPRINT_MASK_PM, usb_ia->ia_log_handle, 360 "DDI_PRE DDI_CTLOPS_DETACH"); 361 break; 362 case DDI_POST : 363 usb_ia_post_detach(usb_ia, usba_get_ifno(rdip), 364 (struct detachspec *)arg); 365 break; 366 } 367 368 break; 369 default: 370 /* pass to root hub to handle */ 371 return (usba_bus_ctl(root_hub_dip, rdip, op, arg, result)); 372 } 373 374 return (DDI_SUCCESS); 375 } 376 377 378 /* 379 * bus enumeration entry points 380 */ 381 static int 382 usb_ia_bus_config(dev_info_t *dip, uint_t flag, ddi_bus_config_op_t op, 383 void *arg, dev_info_t **child) 384 { 385 int rval, circ; 386 usb_ia_t *usb_ia = usb_ia_obtain_state(dip); 387 388 USB_DPRINTF_L4(DPRINT_MASK_ALL, usb_ia->ia_log_handle, 389 "usb_ia_bus_config: op=%d", op); 390 391 if (usb_ia_bus_config_debug) { 392 flag |= NDI_DEVI_DEBUG; 393 } 394 395 ndi_devi_enter(dip, &circ); 396 397 /* enumerate each interface below us */ 398 mutex_enter(&usb_ia->ia_mutex); 399 usb_ia_create_children(usb_ia); 400 mutex_exit(&usb_ia->ia_mutex); 401 402 rval = ndi_busop_bus_config(dip, flag, op, arg, child, 0); 403 ndi_devi_exit(dip, circ); 404 405 return (rval); 406 } 407 408 409 static int 410 usb_ia_bus_unconfig(dev_info_t *dip, uint_t flag, ddi_bus_config_op_t op, 411 void *arg) 412 { 413 usb_ia_t *usb_ia = usb_ia_obtain_state(dip); 414 415 dev_info_t *cdip, *mdip; 416 int interface, circular_count; 417 int rval = NDI_SUCCESS; 418 419 USB_DPRINTF_L4(DPRINT_MASK_ALL, usb_ia->ia_log_handle, 420 "usb_ia_bus_unconfig: op=%d", op); 421 422 if (usb_ia_bus_config_debug) { 423 flag |= NDI_DEVI_DEBUG; 424 } 425 426 /* 427 * first offline and if offlining successful, then 428 * remove children 429 */ 430 if (op == BUS_UNCONFIG_ALL) { 431 flag &= ~(NDI_DEVI_REMOVE | NDI_UNCONFIG); 432 } 433 434 ndi_devi_enter(dip, &circular_count); 435 rval = ndi_busop_bus_unconfig(dip, flag, op, arg); 436 437 if (op == BUS_UNCONFIG_ALL && rval == NDI_SUCCESS && 438 (flag & NDI_AUTODETACH) == 0) { 439 flag |= NDI_DEVI_REMOVE; 440 rval = ndi_busop_bus_unconfig(dip, flag, op, arg); 441 } 442 443 /* update children's list */ 444 mutex_enter(&usb_ia->ia_mutex); 445 for (interface = 0; usb_ia->ia_children_dips && 446 (interface < usb_ia->ia_n_ifs); interface++) { 447 mdip = usb_ia->ia_children_dips[interface]; 448 449 /* now search if this dip still exists */ 450 for (cdip = ddi_get_child(dip); cdip && (cdip != mdip); ) 451 cdip = ddi_get_next_sibling(cdip); 452 453 if (cdip != mdip) { 454 /* we lost the dip on this interface */ 455 usb_ia->ia_children_dips[interface] = NULL; 456 } else if (cdip) { 457 /* 458 * keep in DS_INITALIZED to prevent parent 459 * from detaching 460 */ 461 (void) ddi_initchild(ddi_get_parent(cdip), cdip); 462 } 463 } 464 mutex_exit(&usb_ia->ia_mutex); 465 466 ndi_devi_exit(dip, circular_count); 467 468 USB_DPRINTF_L4(DPRINT_MASK_ALL, usb_ia->ia_log_handle, 469 "usb_ia_bus_config: rval=%d", rval); 470 471 return (rval); 472 } 473 474 475 /* power entry point */ 476 /* ARGSUSED */ 477 static int 478 usb_ia_power(dev_info_t *dip, int comp, int level) 479 { 480 usb_ia_t *usb_ia; 481 usb_common_power_t *pm; 482 int rval = DDI_FAILURE; 483 484 usb_ia = usb_ia_obtain_state(dip); 485 486 USB_DPRINTF_L4(DPRINT_MASK_PM, usb_ia->ia_log_handle, 487 "usb_ia_power: Begin: usb_ia = %p, level = %d", 488 (void *)usb_ia, level); 489 490 mutex_enter(&usb_ia->ia_mutex); 491 pm = usb_ia->ia_pm; 492 493 /* check if we are transitioning to a legal power level */ 494 if (USB_DEV_PWRSTATE_OK(pm->uc_pwr_states, level)) { 495 USB_DPRINTF_L2(DPRINT_MASK_PM, usb_ia->ia_log_handle, 496 "usb_ia_power: illegal power level = %d " 497 "uc_pwr_states = %x", level, pm->uc_pwr_states); 498 499 mutex_exit(&usb_ia->ia_mutex); 500 501 return (rval); 502 } 503 504 rval = usba_common_power(dip, &(pm->uc_current_power), 505 &(usb_ia->ia_dev_state), level); 506 507 mutex_exit(&usb_ia->ia_mutex); 508 509 return (rval); 510 } 511 512 /* 513 * attach/resume entry point 514 */ 515 static int 516 usb_ia_attach(dev_info_t *dip, ddi_attach_cmd_t cmd) 517 { 518 int instance = ddi_get_instance(dip); 519 usb_ia_t *usb_ia = NULL; 520 uint_t n_ifs; 521 size_t size; 522 523 switch (cmd) { 524 case DDI_ATTACH: 525 526 break; 527 case DDI_RESUME: 528 usb_ia = ddi_get_soft_state(usb_ia_statep, instance); 529 (void) usb_ia_restore_device_state(dip, usb_ia); 530 531 return (DDI_SUCCESS); 532 default: 533 534 return (DDI_FAILURE); 535 } 536 537 /* 538 * Attach: 539 * 540 * Allocate soft state and initialize 541 */ 542 if (ddi_soft_state_zalloc(usb_ia_statep, instance) != DDI_SUCCESS) { 543 goto fail; 544 } 545 546 usb_ia = ddi_get_soft_state(usb_ia_statep, instance); 547 if (usb_ia == NULL) { 548 549 goto fail; 550 } 551 552 /* allocate handle for logging of messages */ 553 usb_ia->ia_log_handle = usb_alloc_log_hdl(dip, "ia", 554 &usb_ia_errlevel, 555 &usb_ia_errmask, &usb_ia_instance_debug, 556 0); 557 558 usb_ia->ia_dip = dip; 559 usb_ia->ia_instance = instance; 560 usb_ia->ia_first_if = ddi_prop_get_int(DDI_DEV_T_ANY, dip, 561 DDI_PROP_DONTPASS, "interface", -1); 562 usb_ia->ia_n_ifs = ddi_prop_get_int(DDI_DEV_T_ANY, dip, 563 DDI_PROP_DONTPASS, "interface-count", -1); 564 565 if (usb_ia->ia_first_if < 0 || usb_ia->ia_n_ifs < 0) { 566 USB_DPRINTF_L2(DPRINT_MASK_ATTA, usb_ia->ia_log_handle, 567 "interface-association property failed"); 568 569 goto fail; 570 } 571 572 /* attach client driver to USBA */ 573 if (usb_client_attach(dip, USBDRV_VERSION, 0) != USB_SUCCESS) { 574 USB_DPRINTF_L2(DPRINT_MASK_ATTA, usb_ia->ia_log_handle, 575 "usb_client_attach failed"); 576 goto fail; 577 } 578 if (usb_get_dev_data(dip, &usb_ia->ia_dev_data, USB_PARSE_LVL_NONE, 579 0) != USB_SUCCESS) { 580 USB_DPRINTF_L2(DPRINT_MASK_ATTA, usb_ia->ia_log_handle, 581 "usb_get_dev_data failed"); 582 goto fail; 583 } 584 585 mutex_init(&usb_ia->ia_mutex, NULL, MUTEX_DRIVER, 586 usb_ia->ia_dev_data->dev_iblock_cookie); 587 588 usb_free_dev_data(dip, usb_ia->ia_dev_data); 589 usb_ia->ia_dev_data = NULL; 590 591 usb_ia->ia_init_state |= USB_IA_LOCK_INIT; 592 593 if (ddi_create_minor_node(dip, "usb_ia", S_IFCHR, instance, 594 DDI_NT_NEXUS, 0) != DDI_SUCCESS) { 595 USB_DPRINTF_L2(DPRINT_MASK_ATTA, usb_ia->ia_log_handle, 596 "cannot create devctl minor node"); 597 goto fail; 598 } 599 600 usb_ia->ia_init_state |= USB_IA_MINOR_NODE_CREATED; 601 602 /* 603 * allocate array for keeping track of child dips 604 */ 605 n_ifs = usb_ia->ia_n_ifs; 606 usb_ia->ia_cd_list_length = size = (sizeof (dev_info_t *)) * n_ifs; 607 608 usb_ia->ia_children_dips = kmem_zalloc(size, KM_SLEEP); 609 usb_ia->ia_child_events = kmem_zalloc(sizeof (uint8_t) * n_ifs, 610 KM_SLEEP); 611 /* 612 * Event handling: definition and registration 613 * get event handle for events that we have defined 614 */ 615 (void) ndi_event_alloc_hdl(dip, 0, &usb_ia->ia_ndi_event_hdl, 616 NDI_SLEEP); 617 618 /* bind event set to the handle */ 619 if (ndi_event_bind_set(usb_ia->ia_ndi_event_hdl, &usb_ia_ndi_events, 620 NDI_SLEEP)) { 621 USB_DPRINTF_L2(DPRINT_MASK_ATTA, usb_ia->ia_log_handle, 622 "usb_ia_attach: binding event set failed"); 623 624 goto fail; 625 } 626 627 usb_ia->ia_dev_state = USB_DEV_ONLINE; 628 629 /* 630 * now create components to power manage this device 631 * before attaching children 632 */ 633 usb_ia_create_pm_components(dip, usb_ia); 634 635 /* event registration for events from our parent */ 636 usba_common_register_events(dip, n_ifs, usb_ia_event_cb); 637 638 usb_ia->ia_init_state |= USB_IA_EVENTS_REGISTERED; 639 640 ddi_report_dev(dip); 641 642 return (DDI_SUCCESS); 643 644 fail: 645 USB_DPRINTF_L2(DPRINT_MASK_ATTA, NULL, "usb_ia%d cannot attach", 646 instance); 647 648 if (usb_ia) { 649 (void) usb_ia_cleanup(usb_ia); 650 } 651 652 return (DDI_FAILURE); 653 } 654 655 656 /* detach or suspend this instance */ 657 static int 658 usb_ia_detach(dev_info_t *dip, ddi_detach_cmd_t cmd) 659 { 660 usb_ia_t *usb_ia = usb_ia_obtain_state(dip); 661 662 USB_DPRINTF_L4(DPRINT_MASK_ATTA, usb_ia->ia_log_handle, 663 "usb_ia_detach: cmd = 0x%x", cmd); 664 665 switch (cmd) { 666 case DDI_DETACH: 667 668 return (usb_ia_cleanup(usb_ia)); 669 case DDI_SUSPEND: 670 /* nothing to do */ 671 mutex_enter(&usb_ia->ia_mutex); 672 usb_ia->ia_dev_state = USB_DEV_SUSPENDED; 673 mutex_exit(&usb_ia->ia_mutex); 674 675 return (DDI_SUCCESS); 676 default: 677 678 return (DDI_FAILURE); 679 } 680 681 _NOTE(NOT_REACHED) 682 /* NOTREACHED */ 683 } 684 685 686 /* 687 * usb_ia_cleanup: 688 * cleanup usb_ia and deallocate. this function is called for 689 * handling attach failures and detaching including dynamic 690 * reconfiguration 691 */ 692 /*ARGSUSED*/ 693 static int 694 usb_ia_cleanup(usb_ia_t *usb_ia) 695 { 696 usb_common_power_t *iapm; 697 int rval; 698 dev_info_t *dip = usb_ia->ia_dip; 699 700 USB_DPRINTF_L4(DPRINT_MASK_ATTA, usb_ia->ia_log_handle, 701 "usb_ia_cleanup:"); 702 703 if ((usb_ia->ia_init_state & USB_IA_LOCK_INIT) == 0) { 704 705 goto done; 706 } 707 708 /* 709 * deallocate events, if events are still registered 710 * (ie. children still attached) then we have to fail the detach 711 */ 712 if (usb_ia->ia_ndi_event_hdl && 713 (ndi_event_free_hdl(usb_ia->ia_ndi_event_hdl) != NDI_SUCCESS)) { 714 715 USB_DPRINTF_L2(DPRINT_MASK_ATTA, usb_ia->ia_log_handle, 716 "usb_ia_cleanup: ndi_event_free_hdl failed"); 717 718 return (DDI_FAILURE); 719 } 720 721 /* 722 * Disable the event callbacks, after this point, event 723 * callbacks will never get called. Note we shouldn't hold 724 * mutex while unregistering events because there may be a 725 * competing event callback thread. Event callbacks are done 726 * with ndi mutex held and this can cause a potential deadlock. 727 * Note that cleanup can't fail after deregistration of events. 728 */ 729 if (usb_ia->ia_init_state & USB_IA_EVENTS_REGISTERED) { 730 731 usba_common_unregister_events(usb_ia->ia_dip, usb_ia->ia_n_ifs); 732 } 733 734 iapm = usb_ia->ia_pm; 735 736 mutex_enter(&usb_ia->ia_mutex); 737 738 if ((iapm) && (usb_ia->ia_dev_state != USB_DEV_DISCONNECTED)) { 739 740 mutex_exit(&usb_ia->ia_mutex); 741 742 (void) pm_busy_component(dip, 0); 743 if (iapm->uc_wakeup_enabled) { 744 745 /* First bring the device to full power */ 746 (void) pm_raise_power(dip, 0, USB_DEV_OS_FULL_PWR); 747 748 rval = usb_handle_remote_wakeup(dip, 749 USB_REMOTE_WAKEUP_DISABLE); 750 751 if (rval != DDI_SUCCESS) { 752 USB_DPRINTF_L2(DPRINT_MASK_EVENTS, 753 usb_ia->ia_log_handle, 754 "usb_cleanup: disable remote " 755 "wakeup failed, rval=%d", rval); 756 } 757 } 758 759 (void) pm_lower_power(usb_ia->ia_dip, 0, USB_DEV_OS_PWR_OFF); 760 (void) pm_idle_component(dip, 0); 761 } else { 762 mutex_exit(&usb_ia->ia_mutex); 763 } 764 765 if (iapm) { 766 kmem_free(iapm, sizeof (usb_common_power_t)); 767 } 768 769 /* free children list */ 770 if (usb_ia->ia_children_dips) { 771 kmem_free(usb_ia->ia_children_dips, 772 usb_ia->ia_cd_list_length); 773 } 774 775 if (usb_ia->ia_child_events) { 776 kmem_free(usb_ia->ia_child_events, sizeof (uint8_t) * 777 usb_ia->ia_n_ifs); 778 } 779 780 if (usb_ia->ia_init_state & USB_IA_MINOR_NODE_CREATED) { 781 ddi_remove_minor_node(dip, NULL); 782 } 783 784 mutex_destroy(&usb_ia->ia_mutex); 785 786 done: 787 usb_client_detach(dip, usb_ia->ia_dev_data); 788 789 usb_free_log_hdl(usb_ia->ia_log_handle); 790 ddi_soft_state_free(usb_ia_statep, ddi_get_instance(dip)); 791 792 ddi_prop_remove_all(dip); 793 794 return (DDI_SUCCESS); 795 } 796 797 /* 798 * usb_ia_create_children: 799 */ 800 static void 801 usb_ia_create_children(usb_ia_t *usb_ia) 802 { 803 usba_device_t *usba_device; 804 uint_t n_ifs, first_if; 805 uint_t i; 806 dev_info_t *cdip; 807 808 usba_device = usba_get_usba_device(usb_ia->ia_dip); 809 810 USB_DPRINTF_L4(DPRINT_MASK_ATTA, usb_ia->ia_log_handle, 811 "usb_ia_attach_child_drivers: port = %d, address = %d", 812 usba_device->usb_port, usba_device->usb_addr); 813 814 n_ifs = usb_ia->ia_n_ifs; 815 first_if = usb_ia->ia_first_if; 816 817 /* 818 * create all children if not already present 819 */ 820 for (i = 0; i < n_ifs; i++) { 821 if (usb_ia->ia_children_dips[i] != NULL) { 822 823 continue; 824 } 825 826 mutex_exit(&usb_ia->ia_mutex); 827 cdip = usba_ready_interface_node(usb_ia->ia_dip, first_if + i); 828 mutex_enter(&usb_ia->ia_mutex); 829 830 if (cdip != NULL) { 831 (void) usba_bind_driver(cdip); 832 usb_ia->ia_children_dips[i] = cdip; 833 } 834 } 835 836 } 837 838 839 /* 840 * event support 841 */ 842 static int 843 usb_ia_busop_get_eventcookie(dev_info_t *dip, 844 dev_info_t *rdip, char *eventname, ddi_eventcookie_t *cookie) 845 { 846 usb_ia_t *usb_ia = usb_ia_obtain_state(dip); 847 848 USB_DPRINTF_L4(DPRINT_MASK_EVENTS, usb_ia->ia_log_handle, 849 "usb_ia_busop_get_eventcookie: dip=0x%p, rdip=0x%p, " 850 "event=%s", (void *)dip, (void *)rdip, eventname); 851 USB_DPRINTF_L3(DPRINT_MASK_EVENTS, usb_ia->ia_log_handle, 852 "(dip=%s%d rdip=%s%d)", 853 ddi_driver_name(dip), ddi_get_instance(dip), 854 ddi_driver_name(rdip), ddi_get_instance(rdip)); 855 856 /* return event cookie, iblock cookie, and level */ 857 return (ndi_event_retrieve_cookie(usb_ia->ia_ndi_event_hdl, 858 rdip, eventname, cookie, NDI_EVENT_NOPASS)); 859 } 860 861 862 static int 863 usb_ia_busop_add_eventcall(dev_info_t *dip, 864 dev_info_t *rdip, 865 ddi_eventcookie_t cookie, 866 void (*callback)(dev_info_t *dip, 867 ddi_eventcookie_t cookie, void *arg, 868 void *bus_impldata), 869 void *arg, ddi_callback_id_t *cb_id) 870 { 871 int ifno; 872 usb_ia_t *usb_ia = usb_ia_obtain_state(dip); 873 874 mutex_enter(&usb_ia->ia_mutex); 875 ifno = usba_get_ifno(rdip)- usb_ia->ia_first_if; 876 mutex_exit(&usb_ia->ia_mutex); 877 878 if (ifno < 0) { 879 ifno = 0; 880 } 881 882 USB_DPRINTF_L4(DPRINT_MASK_EVENTS, usb_ia->ia_log_handle, 883 "usb_ia_busop_add_eventcall: dip=0x%p, rdip=0x%p " 884 "cookie=0x%p, cb=0x%p, arg=0x%p", 885 (void *)dip, (void *)rdip, (void *)cookie, (void *)callback, arg); 886 USB_DPRINTF_L3(DPRINT_MASK_EVENTS, usb_ia->ia_log_handle, 887 "(dip=%s%d rdip=%s%d event=%s)", 888 ddi_driver_name(dip), ddi_get_instance(dip), 889 ddi_driver_name(rdip), ddi_get_instance(rdip), 890 ndi_event_cookie_to_name(usb_ia->ia_ndi_event_hdl, cookie)); 891 892 /* Set flag on children registering events */ 893 switch (ndi_event_cookie_to_tag(usb_ia->ia_ndi_event_hdl, cookie)) { 894 case USBA_EVENT_TAG_HOT_REMOVAL: 895 mutex_enter(&usb_ia->ia_mutex); 896 usb_ia->ia_child_events[ifno] |= 897 USB_IA_CHILD_EVENT_DISCONNECT; 898 mutex_exit(&usb_ia->ia_mutex); 899 900 break; 901 case USBA_EVENT_TAG_PRE_SUSPEND: 902 mutex_enter(&usb_ia->ia_mutex); 903 usb_ia->ia_child_events[ifno] |= 904 USB_IA_CHILD_EVENT_PRESUSPEND; 905 mutex_exit(&usb_ia->ia_mutex); 906 907 break; 908 default: 909 910 break; 911 } 912 /* add callback (perform registration) */ 913 return (ndi_event_add_callback(usb_ia->ia_ndi_event_hdl, 914 rdip, cookie, callback, arg, NDI_SLEEP, cb_id)); 915 } 916 917 918 static int 919 usb_ia_busop_remove_eventcall(dev_info_t *dip, ddi_callback_id_t cb_id) 920 { 921 usb_ia_t *usb_ia = usb_ia_obtain_state(dip); 922 ndi_event_callbacks_t *cb = (ndi_event_callbacks_t *)cb_id; 923 924 ASSERT(cb); 925 926 USB_DPRINTF_L4(DPRINT_MASK_EVENTS, usb_ia->ia_log_handle, 927 "usb_ia_busop_remove_eventcall: dip=0x%p, rdip=0x%p " 928 "cookie=0x%p", (void *)dip, (void *)cb->ndi_evtcb_dip, 929 (void *)cb->ndi_evtcb_cookie); 930 USB_DPRINTF_L3(DPRINT_MASK_EVENTS, usb_ia->ia_log_handle, 931 "(dip=%s%d rdip=%s%d event=%s)", 932 ddi_driver_name(dip), ddi_get_instance(dip), 933 ddi_driver_name(cb->ndi_evtcb_dip), 934 ddi_get_instance(cb->ndi_evtcb_dip), 935 ndi_event_cookie_to_name(usb_ia->ia_ndi_event_hdl, 936 cb->ndi_evtcb_cookie)); 937 938 /* remove event registration from our event set */ 939 return (ndi_event_remove_callback(usb_ia->ia_ndi_event_hdl, cb_id)); 940 } 941 942 943 static int 944 usb_ia_busop_post_event(dev_info_t *dip, 945 dev_info_t *rdip, 946 ddi_eventcookie_t cookie, 947 void *bus_impldata) 948 { 949 usb_ia_t *usb_ia = usb_ia_obtain_state(dip); 950 951 USB_DPRINTF_L4(DPRINT_MASK_EVENTS, usb_ia->ia_log_handle, 952 "usb_ia_busop_post_event: dip=0x%p, rdip=0x%p " 953 "cookie=0x%p, impl=0x%p", 954 (void *)dip, (void *)rdip, (void *)cookie, bus_impldata); 955 USB_DPRINTF_L3(DPRINT_MASK_EVENTS, usb_ia->ia_log_handle, 956 "(dip=%s%d rdip=%s%d event=%s)", 957 ddi_driver_name(dip), ddi_get_instance(dip), 958 ddi_driver_name(rdip), ddi_get_instance(rdip), 959 ndi_event_cookie_to_name(usb_ia->ia_ndi_event_hdl, cookie)); 960 961 /* post event to all children registered for this event */ 962 return (ndi_event_run_callbacks(usb_ia->ia_ndi_event_hdl, rdip, 963 cookie, bus_impldata)); 964 } 965 966 967 /* 968 * usb_ia_restore_device_state 969 * set the original configuration of the device 970 */ 971 static int 972 usb_ia_restore_device_state(dev_info_t *dip, usb_ia_t *usb_ia) 973 { 974 usb_common_power_t *iapm; 975 976 USB_DPRINTF_L4(DPRINT_MASK_EVENTS, usb_ia->ia_log_handle, 977 "usb_ia_restore_device_state: usb_ia = %p", (void *)usb_ia); 978 979 mutex_enter(&usb_ia->ia_mutex); 980 iapm = usb_ia->ia_pm; 981 mutex_exit(&usb_ia->ia_mutex); 982 983 /* First bring the device to full power */ 984 (void) pm_busy_component(dip, 0); 985 (void) pm_raise_power(dip, 0, USB_DEV_OS_FULL_PWR); 986 987 if (usb_check_same_device(dip, usb_ia->ia_log_handle, USB_LOG_L0, 988 DPRINT_MASK_EVENTS, USB_CHK_VIDPID, NULL) != USB_SUCCESS) { 989 990 /* change the device state from suspended to disconnected */ 991 mutex_enter(&usb_ia->ia_mutex); 992 usb_ia->ia_dev_state = USB_DEV_DISCONNECTED; 993 mutex_exit(&usb_ia->ia_mutex); 994 (void) pm_idle_component(dip, 0); 995 996 return (USB_FAILURE); 997 } 998 999 /* 1000 * if the device had remote wakeup earlier, 1001 * enable it again 1002 */ 1003 if (iapm->uc_wakeup_enabled) { 1004 (void) usb_handle_remote_wakeup(usb_ia->ia_dip, 1005 USB_REMOTE_WAKEUP_ENABLE); 1006 } 1007 1008 mutex_enter(&usb_ia->ia_mutex); 1009 usb_ia->ia_dev_state = USB_DEV_ONLINE; 1010 mutex_exit(&usb_ia->ia_mutex); 1011 1012 (void) pm_idle_component(dip, 0); 1013 1014 return (USB_SUCCESS); 1015 } 1016 1017 1018 /* 1019 * usb_ia_event_cb() 1020 * handle disconnect and connect events 1021 */ 1022 static void 1023 usb_ia_event_cb(dev_info_t *dip, ddi_eventcookie_t cookie, 1024 void *arg, void *bus_impldata) 1025 { 1026 int i, tag; 1027 usb_ia_t *usb_ia = usb_ia_obtain_state(dip); 1028 dev_info_t *child_dip; 1029 ddi_eventcookie_t rm_cookie, ins_cookie, suspend_cookie, resume_cookie; 1030 1031 USB_DPRINTF_L4(DPRINT_MASK_EVENTS, usb_ia->ia_log_handle, 1032 "usb_ia_event_cb: dip=0x%p, cookie=0x%p, " 1033 "arg=0x%p, impl=0x%p", 1034 (void *)dip, (void *)cookie, arg, bus_impldata); 1035 USB_DPRINTF_L4(DPRINT_MASK_EVENTS, usb_ia->ia_log_handle, 1036 "(dip=%s%d event=%s)", 1037 ddi_driver_name(dip), ddi_get_instance(dip), 1038 ndi_event_cookie_to_name(usb_ia->ia_ndi_event_hdl, cookie)); 1039 1040 tag = NDI_EVENT_TAG(cookie); 1041 rm_cookie = ndi_event_tag_to_cookie( 1042 usb_ia->ia_ndi_event_hdl, USBA_EVENT_TAG_HOT_REMOVAL); 1043 suspend_cookie = ndi_event_tag_to_cookie( 1044 usb_ia->ia_ndi_event_hdl, USBA_EVENT_TAG_PRE_SUSPEND); 1045 ins_cookie = ndi_event_tag_to_cookie( 1046 usb_ia->ia_ndi_event_hdl, USBA_EVENT_TAG_HOT_INSERTION); 1047 resume_cookie = ndi_event_tag_to_cookie( 1048 usb_ia->ia_ndi_event_hdl, USBA_EVENT_TAG_POST_RESUME); 1049 1050 mutex_enter(&usb_ia->ia_mutex); 1051 switch (tag) { 1052 case USBA_EVENT_TAG_HOT_REMOVAL: 1053 if (usb_ia->ia_dev_state == USB_DEV_DISCONNECTED) { 1054 USB_DPRINTF_L2(DPRINT_MASK_EVENTS, 1055 usb_ia->ia_log_handle, 1056 "usb_ia_event_cb: Device already disconnected"); 1057 } else { 1058 /* we are disconnected so set our state now */ 1059 usb_ia->ia_dev_state = USB_DEV_DISCONNECTED; 1060 for (i = 0; i < usb_ia->ia_n_ifs; i++) { 1061 usb_ia->ia_child_events[i] &= ~ 1062 USB_IA_CHILD_EVENT_DISCONNECT; 1063 } 1064 mutex_exit(&usb_ia->ia_mutex); 1065 1066 /* pass disconnect event to all the children */ 1067 (void) ndi_event_run_callbacks( 1068 usb_ia->ia_ndi_event_hdl, NULL, 1069 rm_cookie, bus_impldata); 1070 1071 mutex_enter(&usb_ia->ia_mutex); 1072 } 1073 break; 1074 case USBA_EVENT_TAG_PRE_SUSPEND: 1075 /* set our state *after* suspending children */ 1076 mutex_exit(&usb_ia->ia_mutex); 1077 1078 /* pass pre_suspend event to all the children */ 1079 (void) ndi_event_run_callbacks(usb_ia->ia_ndi_event_hdl, 1080 NULL, suspend_cookie, bus_impldata); 1081 1082 mutex_enter(&usb_ia->ia_mutex); 1083 for (i = 0; i < usb_ia->ia_n_ifs; i++) { 1084 usb_ia->ia_child_events[i] &= ~ 1085 USB_IA_CHILD_EVENT_PRESUSPEND; 1086 } 1087 break; 1088 case USBA_EVENT_TAG_HOT_INSERTION: 1089 mutex_exit(&usb_ia->ia_mutex); 1090 if (usb_ia_restore_device_state(dip, usb_ia) == USB_SUCCESS) { 1091 1092 /* 1093 * Check to see if this child has missed the disconnect 1094 * event before it registered for event cb 1095 */ 1096 mutex_enter(&usb_ia->ia_mutex); 1097 for (i = 0; i < usb_ia->ia_n_ifs; i++) { 1098 if (usb_ia->ia_child_events[i] & 1099 USB_IA_CHILD_EVENT_DISCONNECT) { 1100 usb_ia->ia_child_events[i] &= 1101 ~USB_IA_CHILD_EVENT_DISCONNECT; 1102 child_dip = 1103 usb_ia->ia_children_dips[i]; 1104 mutex_exit(&usb_ia->ia_mutex); 1105 1106 /* post the missed disconnect */ 1107 (void) ndi_event_do_callback( 1108 usb_ia->ia_ndi_event_hdl, 1109 child_dip, 1110 rm_cookie, 1111 bus_impldata); 1112 mutex_enter(&usb_ia->ia_mutex); 1113 } 1114 } 1115 mutex_exit(&usb_ia->ia_mutex); 1116 1117 /* pass reconnect event to all the children */ 1118 (void) ndi_event_run_callbacks( 1119 usb_ia->ia_ndi_event_hdl, NULL, 1120 ins_cookie, bus_impldata); 1121 1122 } 1123 mutex_enter(&usb_ia->ia_mutex); 1124 break; 1125 case USBA_EVENT_TAG_POST_RESUME: 1126 /* 1127 * Check to see if this child has missed the pre-suspend 1128 * event before it registered for event cb 1129 */ 1130 for (i = 0; i < usb_ia->ia_n_ifs; i++) { 1131 if (usb_ia->ia_child_events[i] & 1132 USB_IA_CHILD_EVENT_PRESUSPEND) { 1133 usb_ia->ia_child_events[i] &= 1134 ~USB_IA_CHILD_EVENT_PRESUSPEND; 1135 child_dip = usb_ia->ia_children_dips[i]; 1136 mutex_exit(&usb_ia->ia_mutex); 1137 1138 /* post the missed pre-suspend event */ 1139 (void) ndi_event_do_callback( 1140 usb_ia->ia_ndi_event_hdl, 1141 child_dip, suspend_cookie, 1142 bus_impldata); 1143 mutex_enter(&usb_ia->ia_mutex); 1144 } 1145 } 1146 mutex_exit(&usb_ia->ia_mutex); 1147 1148 /* pass post_resume event to all the children */ 1149 (void) ndi_event_run_callbacks(usb_ia->ia_ndi_event_hdl, 1150 NULL, resume_cookie, bus_impldata); 1151 1152 mutex_enter(&usb_ia->ia_mutex); 1153 break; 1154 } 1155 mutex_exit(&usb_ia->ia_mutex); 1156 1157 } 1158 1159 /* 1160 * create the pm components required for power management 1161 */ 1162 static void 1163 usb_ia_create_pm_components(dev_info_t *dip, usb_ia_t *usb_ia) 1164 { 1165 usb_common_power_t *iapm; 1166 uint_t pwr_states; 1167 1168 USB_DPRINTF_L4(DPRINT_MASK_PM, usb_ia->ia_log_handle, 1169 "usb_ia_create_pm_components: Begin"); 1170 1171 /* Allocate the PM state structure */ 1172 iapm = kmem_zalloc(sizeof (usb_common_power_t), KM_SLEEP); 1173 1174 mutex_enter(&usb_ia->ia_mutex); 1175 usb_ia->ia_pm = iapm; 1176 iapm->uc_usb_statep = usb_ia; 1177 iapm->uc_pm_capabilities = 0; /* XXXX should this be 0?? */ 1178 iapm->uc_current_power = USB_DEV_OS_FULL_PWR; 1179 mutex_exit(&usb_ia->ia_mutex); 1180 1181 /* 1182 * By not enabling parental notification, PM enforces 1183 * "strict parental dependency" meaning, usb_ia won't 1184 * power off until any of its children are in full power. 1185 */ 1186 1187 /* 1188 * there are 3 scenarios: 1189 * 1. a well behaved device should have remote wakeup 1190 * at interface and device level. If the interface 1191 * wakes up, usb_ia will wake up 1192 * 2. if the device doesn't have remote wake up and 1193 * the interface has, PM will still work, ie. 1194 * the interfaces wakes up and usb_ia wakes up 1195 * 3. if neither the interface nor device has remote 1196 * wakeup, the interface will wake up when it is opened 1197 * and goes to sleep after being closed for a while 1198 * In this case usb_ia should also go to sleep shortly 1199 * thereafter 1200 * In all scenarios it doesn't really matter whether 1201 * remote wakeup at the device level is enabled or not 1202 * but we do it anyways 1203 */ 1204 if (usb_handle_remote_wakeup(dip, USB_REMOTE_WAKEUP_ENABLE) == 1205 USB_SUCCESS) { 1206 USB_DPRINTF_L3(DPRINT_MASK_PM, usb_ia->ia_log_handle, 1207 "usb_ia_create_pm_components: " 1208 "Remote Wakeup Enabled"); 1209 iapm->uc_wakeup_enabled = 1; 1210 } 1211 1212 if (usb_create_pm_components(dip, &pwr_states) == 1213 USB_SUCCESS) { 1214 iapm->uc_pwr_states = (uint8_t)pwr_states; 1215 (void) pm_raise_power(dip, 0, USB_DEV_OS_FULL_PWR); 1216 } 1217 1218 USB_DPRINTF_L4(DPRINT_MASK_PM, usb_ia->ia_log_handle, 1219 "usb_ia_create_pm_components: End"); 1220 } 1221 1222 1223 /* 1224 * usb_ia_obtain_state: 1225 */ 1226 static usb_ia_t * 1227 usb_ia_obtain_state(dev_info_t *dip) 1228 { 1229 int instance = ddi_get_instance(dip); 1230 usb_ia_t *statep = ddi_get_soft_state(usb_ia_statep, instance); 1231 1232 ASSERT(statep != NULL); 1233 1234 return (statep); 1235 } 1236