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 27 /* 28 * USBA: Solaris USB Architecture support 29 */ 30 #define USBA_FRAMEWORK 31 #include <sys/usb/usba/usba_impl.h> 32 #include <sys/usb/usba/hcdi_impl.h> 33 #include <sys/usb/hubd/hub.h> 34 #include <sys/fs/dv_node.h> 35 36 static int usba_str_startcmp(char *, char *); 37 38 /* 39 * USBA private variables and tunables 40 */ 41 static kmutex_t usba_mutex; 42 43 /* mutex to protect usba_root_hubs */ 44 static kmutex_t usba_hub_mutex; 45 46 typedef struct usba_root_hub_ent { 47 dev_info_t *dip; 48 struct usba_root_hub_ent *next; 49 }usba_root_hub_ent_t; 50 51 static usba_root_hub_ent_t *usba_root_hubs = NULL; 52 53 /* 54 * ddivs forced binding: 55 * 56 * usbc usbc_xhubs usbc_xaddress node name 57 * 58 * 0 x x class name or "device" 59 * 60 * 1 0 0 ddivs_usbc 61 * 1 0 >1 ddivs_usbc except device 62 * at usbc_xaddress 63 * 1 1 0 ddivs_usbc except hubs 64 * 1 1 >1 ddivs_usbc except hubs and 65 * device at usbc_xaddress 66 */ 67 uint_t usba_ddivs_usbc; 68 uint_t usba_ddivs_usbc_xhubs; 69 uint_t usba_ddivs_usbc_xaddress; 70 71 uint_t usba_ugen_force_binding; 72 73 /* 74 * compatible name handling 75 */ 76 /* 77 * allowing for 15 compat names, plus one force bind name and 78 * one possible specified client driver name 79 */ 80 #define USBA_MAX_COMPAT_NAMES 17 81 #define USBA_MAX_COMPAT_NAME_LEN 64 82 83 /* double linked list for usba_devices */ 84 usba_list_entry_t usba_device_list; 85 86 _NOTE(MUTEX_PROTECTS_DATA(usba_mutex, usba_device_list)) 87 88 /* 89 * modload support 90 */ 91 92 static struct modlmisc modlmisc = { 93 &mod_miscops, /* Type of module */ 94 "USBA: USB Architecture 2.0 1.66" 95 }; 96 97 static struct modlinkage modlinkage = { 98 MODREV_1, (void *)&modlmisc, NULL 99 }; 100 101 102 static usb_log_handle_t usba_log_handle; 103 uint_t usba_errlevel = USB_LOG_L4; 104 uint_t usba_errmask = (uint_t)-1; 105 106 extern usb_log_handle_t hubdi_log_handle; 107 108 int 109 _init(void) 110 { 111 int rval; 112 113 /* 114 * usbai providing log support needs to be init'ed first 115 * and destroyed last 116 */ 117 usba_usbai_initialization(); 118 usba_usba_initialization(); 119 usba_usbai_register_initialization(); 120 usba_hcdi_initialization(); 121 usba_hubdi_initialization(); 122 usba_whcdi_initialization(); 123 usba_devdb_initialization(); 124 125 if ((rval = mod_install(&modlinkage)) != 0) { 126 usba_devdb_destroy(); 127 usba_whcdi_destroy(); 128 usba_hubdi_destroy(); 129 usba_hcdi_destroy(); 130 usba_usbai_register_destroy(); 131 usba_usba_destroy(); 132 usba_usbai_destroy(); 133 } 134 135 return (rval); 136 } 137 138 int 139 _fini() 140 { 141 int rval; 142 143 if ((rval = mod_remove(&modlinkage)) == 0) { 144 usba_devdb_destroy(); 145 usba_whcdi_destroy(); 146 usba_hubdi_destroy(); 147 usba_hcdi_destroy(); 148 usba_usbai_register_destroy(); 149 usba_usba_destroy(); 150 usba_usbai_destroy(); 151 } 152 153 return (rval); 154 } 155 156 int 157 _info(struct modinfo *modinfop) 158 { 159 return (mod_info(&modlinkage, modinfop)); 160 } 161 162 boolean_t 163 usba_owns_ia(dev_info_t *dip) 164 { 165 int if_count = ddi_prop_get_int(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS, 166 "interface-count", 0); 167 168 return ((if_count) ? B_TRUE : B_FALSE); 169 } 170 171 /* 172 * common bus ctl for hcd, usb_mid, and hubd 173 */ 174 int 175 usba_bus_ctl(dev_info_t *dip, 176 dev_info_t *rdip, 177 ddi_ctl_enum_t op, 178 void *arg, 179 void *result) 180 { 181 dev_info_t *child_dip = (dev_info_t *)arg; 182 usba_device_t *usba_device; 183 usba_hcdi_t *usba_hcdi; 184 usba_hcdi_ops_t *usba_hcdi_ops; 185 186 USB_DPRINTF_L4(DPRINT_MASK_USBA, hubdi_log_handle, 187 "usba_bus_ctl: %s%d %s%d op=%d", ddi_node_name(rdip), 188 ddi_get_instance(rdip), ddi_node_name(dip), 189 ddi_get_instance(dip), op); 190 191 switch (op) { 192 193 case DDI_CTLOPS_REPORTDEV: 194 { 195 char *name, compat_name[64], *speed; 196 usba_device_t *hub_usba_device; 197 dev_info_t *hubdip; 198 199 usba_device = usba_get_usba_device(rdip); 200 201 /* find the parent hub */ 202 hubdip = ddi_get_parent(rdip); 203 while ((strcmp(ddi_driver_name(hubdip), "hubd") != 0) && 204 !(usba_is_root_hub(hubdip))) { 205 hubdip = ddi_get_parent(hubdip); 206 } 207 208 hub_usba_device = usba_get_usba_device(hubdip); 209 210 if (usba_device) { 211 if (usb_owns_device(rdip)) { 212 (void) snprintf(compat_name, 213 sizeof (compat_name), 214 "usb%x,%x", 215 usba_device->usb_dev_descr->idVendor, 216 usba_device->usb_dev_descr->idProduct); 217 } else if (usba_owns_ia(rdip)) { 218 (void) snprintf(compat_name, 219 sizeof (compat_name), 220 "usbia%x,%x.config%x.%x", 221 usba_device->usb_dev_descr->idVendor, 222 usba_device->usb_dev_descr->idProduct, 223 usba_device->usb_cfg_value, 224 usb_get_if_number(rdip)); 225 } else { 226 (void) snprintf(compat_name, 227 sizeof (compat_name), 228 "usbif%x,%x.config%x.%x", 229 usba_device->usb_dev_descr->idVendor, 230 usba_device->usb_dev_descr->idProduct, 231 usba_device->usb_cfg_value, 232 usb_get_if_number(rdip)); 233 } 234 switch (usba_device->usb_port_status) { 235 case USBA_HIGH_SPEED_DEV: 236 speed = "hi speed (USB 2.x)"; 237 238 break; 239 case USBA_LOW_SPEED_DEV: 240 speed = "low speed (USB 1.x)"; 241 242 break; 243 case USBA_FULL_SPEED_DEV: 244 default: 245 speed = "full speed (USB 1.x)"; 246 247 break; 248 } 249 250 cmn_err(CE_CONT, 251 "?USB %x.%x %s (%s) operating at %s on " 252 "USB %x.%x %s hub: " 253 "%s@%s, %s%d at bus address %d\n", 254 (usba_device->usb_dev_descr->bcdUSB & 0xff00) >> 8, 255 usba_device->usb_dev_descr->bcdUSB & 0xff, 256 (usb_owns_device(rdip) ? "device" : 257 ((usba_owns_ia(rdip) ? "interface-association" : 258 "interface"))), 259 compat_name, speed, 260 (hub_usba_device->usb_dev_descr->bcdUSB & 261 0xff00) >> 8, 262 hub_usba_device->usb_dev_descr->bcdUSB & 0xff, 263 usba_is_root_hub(hubdip) ? "root" : "external", 264 ddi_node_name(rdip), ddi_get_name_addr(rdip), 265 ddi_driver_name(rdip), 266 ddi_get_instance(rdip), usba_device->usb_addr); 267 268 name = kmem_alloc(MAXNAMELEN, KM_SLEEP); 269 (void) usba_get_mfg_prod_sn_str(rdip, name, MAXNAMELEN); 270 if (name[0] != '\0') { 271 cmn_err(CE_CONT, "?\t%s\n", name); 272 } 273 kmem_free(name, MAXNAMELEN); 274 275 } else { /* harden USBA against this case; if it happens */ 276 277 cmn_err(CE_CONT, 278 "?USB-device: %s@%s, %s%d\n", 279 ddi_node_name(rdip), ddi_get_name_addr(rdip), 280 ddi_driver_name(rdip), ddi_get_instance(rdip)); 281 } 282 283 return (DDI_SUCCESS); 284 } 285 286 case DDI_CTLOPS_INITCHILD: 287 { 288 int usb_addr; 289 uint_t n; 290 char name[32]; 291 int *data; 292 int rval; 293 int len = sizeof (usb_addr); 294 295 usba_hcdi = usba_hcdi_get_hcdi(dip); 296 usba_hcdi_ops = usba_hcdi->hcdi_ops; 297 ASSERT(usba_hcdi_ops != NULL); 298 299 /* 300 * as long as the dip exists, it should have 301 * usba_device structure associated with it 302 */ 303 usba_device = usba_get_usba_device(child_dip); 304 if (usba_device == NULL) { 305 306 USB_DPRINTF_L2(DPRINT_MASK_USBA, hubdi_log_handle, 307 "usba_bus_ctl: DDI_NOT_WELL_FORMED (%s (0x%p))", 308 ddi_node_name(child_dip), (void *)child_dip); 309 310 return (DDI_NOT_WELL_FORMED); 311 } 312 313 /* the dip should have an address and reg property */ 314 if (ddi_prop_op(DDI_DEV_T_NONE, child_dip, PROP_LEN_AND_VAL_BUF, 315 DDI_PROP_DONTPASS | DDI_PROP_CANSLEEP, "assigned-address", 316 (caddr_t)&usb_addr, &len) != DDI_SUCCESS) { 317 318 USB_DPRINTF_L2(DPRINT_MASK_USBA, hubdi_log_handle, 319 "usba_bus_ctl:\n\t" 320 "%s%d %s%d op=%d rdip = 0x%p dip = 0x%p", 321 ddi_node_name(rdip), ddi_get_instance(rdip), 322 ddi_node_name(dip), ddi_get_instance(dip), op, 323 (void *)rdip, (void *)dip); 324 325 USB_DPRINTF_L2(DPRINT_MASK_USBA, hubdi_log_handle, 326 "usba_bus_ctl: DDI_NOT_WELL_FORMED (%s (0x%p))", 327 ddi_node_name(child_dip), (void *)child_dip); 328 329 return (DDI_NOT_WELL_FORMED); 330 } 331 332 if ((rval = ddi_prop_lookup_int_array(DDI_DEV_T_ANY, child_dip, 333 DDI_PROP_DONTPASS, "reg", 334 &data, &n)) != DDI_SUCCESS) { 335 336 USB_DPRINTF_L2(DPRINT_MASK_USBA, hubdi_log_handle, 337 "usba_bus_ctl: %d, DDI_NOT_WELL_FORMED", rval); 338 339 return (DDI_NOT_WELL_FORMED); 340 } 341 342 343 /* 344 * if the configuration is 1, the unit address is 345 * just the interface number 346 */ 347 if ((n == 1) || ((n > 1) && (data[1] == 1))) { 348 (void) sprintf(name, "%x", data[0]); 349 } else { 350 (void) sprintf(name, "%x,%x", data[0], data[1]); 351 } 352 353 USB_DPRINTF_L3(DPRINT_MASK_USBA, 354 hubdi_log_handle, "usba_bus_ctl: name = %s", name); 355 356 ddi_prop_free(data); 357 ddi_set_name_addr(child_dip, name); 358 359 /* 360 * increment the reference count for each child using this 361 * usba_device structure 362 */ 363 mutex_enter(&usba_device->usb_mutex); 364 usba_device->usb_ref_count++; 365 366 USB_DPRINTF_L3(DPRINT_MASK_USBA, hubdi_log_handle, 367 "usba_bus_ctl: init usba_device = 0x%p ref_count = %d", 368 (void *)usba_device, usba_device->usb_ref_count); 369 370 mutex_exit(&usba_device->usb_mutex); 371 372 return (DDI_SUCCESS); 373 } 374 375 case DDI_CTLOPS_UNINITCHILD: 376 { 377 usba_device = usba_get_usba_device(child_dip); 378 379 if (usba_device != NULL) { 380 /* 381 * decrement the reference count for each child 382 * using this usba_device structure 383 */ 384 mutex_enter(&usba_device->usb_mutex); 385 usba_device->usb_ref_count--; 386 387 USB_DPRINTF_L3(DPRINT_MASK_USBA, hubdi_log_handle, 388 "usba_hcdi_bus_ctl: uninit usba_device=0x%p " 389 "ref_count=%d", 390 (void *)usba_device, usba_device->usb_ref_count); 391 392 mutex_exit(&usba_device->usb_mutex); 393 } 394 ddi_set_name_addr(child_dip, NULL); 395 396 return (DDI_SUCCESS); 397 } 398 399 case DDI_CTLOPS_IOMIN: 400 /* Do nothing */ 401 return (DDI_SUCCESS); 402 403 /* 404 * These ops correspond to functions that "shouldn't" be called 405 * by a USB client driver. So we whine when we're called. 406 */ 407 case DDI_CTLOPS_DMAPMAPC: 408 case DDI_CTLOPS_REPORTINT: 409 case DDI_CTLOPS_REGSIZE: 410 case DDI_CTLOPS_NREGS: 411 case DDI_CTLOPS_SIDDEV: 412 case DDI_CTLOPS_SLAVEONLY: 413 case DDI_CTLOPS_AFFINITY: 414 case DDI_CTLOPS_POKE: 415 case DDI_CTLOPS_PEEK: 416 cmn_err(CE_CONT, "%s%d: invalid op (%d) from %s%d", 417 ddi_node_name(dip), ddi_get_instance(dip), 418 op, ddi_node_name(rdip), ddi_get_instance(rdip)); 419 return (DDI_FAILURE); 420 421 /* 422 * Everything else (e.g. PTOB/BTOP/BTOPR requests) we pass up 423 */ 424 default: 425 return (ddi_ctlops(dip, rdip, op, arg, result)); 426 } 427 } 428 429 430 /* 431 * initialize and destroy USBA module 432 */ 433 void 434 usba_usba_initialization() 435 { 436 usba_log_handle = usb_alloc_log_hdl(NULL, "usba", &usba_errlevel, 437 &usba_errmask, NULL, 0); 438 439 USB_DPRINTF_L4(DPRINT_MASK_USBA, 440 usba_log_handle, "usba_usba_initialization"); 441 442 mutex_init(&usba_mutex, NULL, MUTEX_DRIVER, NULL); 443 mutex_init(&usba_hub_mutex, NULL, MUTEX_DRIVER, NULL); 444 usba_init_list(&usba_device_list, NULL, NULL); 445 } 446 447 448 void 449 usba_usba_destroy() 450 { 451 USB_DPRINTF_L4(DPRINT_MASK_USBA, usba_log_handle, "usba_usba_destroy"); 452 453 mutex_destroy(&usba_hub_mutex); 454 mutex_destroy(&usba_mutex); 455 usba_destroy_list(&usba_device_list); 456 457 usb_free_log_hdl(usba_log_handle); 458 } 459 460 461 /* 462 * usba_set_usb_address: 463 * set usb address in usba_device structure 464 */ 465 int 466 usba_set_usb_address(usba_device_t *usba_device) 467 { 468 usb_addr_t address; 469 uchar_t s = 8; 470 usba_hcdi_t *hcdi; 471 char *usb_address_in_use; 472 473 mutex_enter(&usba_device->usb_mutex); 474 475 hcdi = usba_hcdi_get_hcdi(usba_device->usb_root_hub_dip); 476 477 mutex_enter(&hcdi->hcdi_mutex); 478 usb_address_in_use = hcdi->hcdi_usb_address_in_use; 479 480 for (address = ROOT_HUB_ADDR + 1; 481 address <= USBA_MAX_ADDRESS; address++) { 482 if (usb_address_in_use[address/s] & (1 << (address % s))) { 483 continue; 484 } 485 usb_address_in_use[address/s] |= (1 << (address % s)); 486 hcdi->hcdi_device_count++; 487 HCDI_HOTPLUG_STATS_DATA(hcdi)->hcdi_device_count.value.ui64++; 488 mutex_exit(&hcdi->hcdi_mutex); 489 490 USB_DPRINTF_L3(DPRINT_MASK_USBA, usba_log_handle, 491 "usba_set_usb_address: %d", address); 492 493 usba_device->usb_addr = address; 494 495 mutex_exit(&usba_device->usb_mutex); 496 497 return (USB_SUCCESS); 498 } 499 500 usba_device->usb_addr = 0; 501 502 USB_DPRINTF_L2(DPRINT_MASK_USBA, usba_log_handle, 503 "no usb address available"); 504 505 mutex_exit(&hcdi->hcdi_mutex); 506 mutex_exit(&usba_device->usb_mutex); 507 508 return (USB_FAILURE); 509 } 510 511 512 /* 513 * usba_unset_usb_address: 514 * unset usb_address in usba_device structure 515 */ 516 void 517 usba_unset_usb_address(usba_device_t *usba_device) 518 { 519 usb_addr_t address; 520 usba_hcdi_t *hcdi; 521 uchar_t s = 8; 522 char *usb_address_in_use; 523 524 mutex_enter(&usba_device->usb_mutex); 525 address = usba_device->usb_addr; 526 hcdi = usba_hcdi_get_hcdi(usba_device->usb_root_hub_dip); 527 528 if (address > ROOT_HUB_ADDR) { 529 USB_DPRINTF_L3(DPRINT_MASK_USBA, usba_log_handle, 530 "usba_unset_usb_address: address=%d", address); 531 532 mutex_enter(&hcdi->hcdi_mutex); 533 usb_address_in_use = hcdi->hcdi_usb_address_in_use; 534 535 ASSERT(usb_address_in_use[address/s] & (1 << (address % s))); 536 537 usb_address_in_use[address/s] &= ~(1 << (address % s)); 538 539 hcdi->hcdi_device_count--; 540 HCDI_HOTPLUG_STATS_DATA(hcdi)->hcdi_device_count.value.ui64--; 541 542 mutex_exit(&hcdi->hcdi_mutex); 543 544 usba_device->usb_addr = 0; 545 } 546 mutex_exit(&usba_device->usb_mutex); 547 } 548 549 550 struct usba_evdata * 551 usba_get_evdata(dev_info_t *dip) 552 { 553 usba_evdata_t *evdata; 554 usba_device_t *usba_device = usba_get_usba_device(dip); 555 556 /* called when dip attaches */ 557 ASSERT(usba_device != NULL); 558 559 mutex_enter(&usba_device->usb_mutex); 560 evdata = usba_device->usb_evdata; 561 while (evdata) { 562 if (evdata->ev_dip == dip) { 563 mutex_exit(&usba_device->usb_mutex); 564 565 return (evdata); 566 } 567 evdata = evdata->ev_next; 568 } 569 570 evdata = kmem_zalloc(sizeof (usba_evdata_t), KM_SLEEP); 571 evdata->ev_dip = dip; 572 evdata->ev_next = usba_device->usb_evdata; 573 usba_device->usb_evdata = evdata; 574 mutex_exit(&usba_device->usb_mutex); 575 576 return (evdata); 577 } 578 579 580 /* 581 * allocate a usb device structure and link it in the list 582 */ 583 usba_device_t * 584 usba_alloc_usba_device(dev_info_t *root_hub_dip) 585 { 586 usba_device_t *usba_device; 587 int ep_idx; 588 ddi_iblock_cookie_t iblock_cookie = 589 usba_hcdi_get_hcdi(root_hub_dip)->hcdi_iblock_cookie; 590 591 /* 592 * create a new usba_device structure 593 */ 594 usba_device = kmem_zalloc(sizeof (usba_device_t), KM_SLEEP); 595 596 /* 597 * initialize usba_device 598 */ 599 mutex_init(&usba_device->usb_mutex, NULL, MUTEX_DRIVER, 600 iblock_cookie); 601 602 usba_init_list(&usba_device->usb_device_list, (usb_opaque_t)usba_device, 603 iblock_cookie); 604 usba_init_list(&usba_device->usb_allocated, (usb_opaque_t)usba_device, 605 iblock_cookie); 606 mutex_enter(&usba_device->usb_mutex); 607 usba_device->usb_root_hub_dip = root_hub_dip; 608 609 /* 610 * add to list of usba_devices 611 */ 612 usba_add_to_list(&usba_device_list, &usba_device->usb_device_list); 613 614 /* init mutex in each usba_ph_impl structure */ 615 for (ep_idx = 0; ep_idx < USBA_N_ENDPOINTS; ep_idx++) { 616 mutex_init(&usba_device->usb_ph_list[ep_idx].usba_ph_mutex, 617 NULL, MUTEX_DRIVER, iblock_cookie); 618 } 619 620 USB_DPRINTF_L2(DPRINT_MASK_USBA, usba_log_handle, 621 "allocated usba_device 0x%p", (void *)usba_device); 622 623 mutex_exit(&usba_device->usb_mutex); 624 625 return (usba_device); 626 } 627 628 629 /* free NDI event data associated with usba_device */ 630 void 631 usba_free_evdata(usba_evdata_t *evdata) 632 { 633 usba_evdata_t *next; 634 635 while (evdata) { 636 next = evdata->ev_next; 637 kmem_free(evdata, sizeof (usba_evdata_t)); 638 evdata = next; 639 } 640 } 641 642 643 /* 644 * free wireless usb specific structure 645 */ 646 void 647 usba_free_wireless_data(usba_wireless_data_t *wireless_data) 648 { 649 if (wireless_data == NULL) { 650 651 return; 652 } 653 654 if (wireless_data->wusb_bos) { 655 kmem_free(wireless_data->wusb_bos, 656 wireless_data->wusb_bos_length); 657 } 658 659 kmem_free(wireless_data, sizeof (usba_wireless_data_t)); 660 } 661 662 663 /* 664 * free usb device structure 665 */ 666 void 667 usba_free_usba_device(usba_device_t *usba_device) 668 { 669 int i, ep_idx; 670 usb_pipe_handle_t def_ph; 671 672 if (usba_device == NULL) { 673 674 return; 675 } 676 677 mutex_enter(&usba_device->usb_mutex); 678 if (usba_device->usb_ref_count) { 679 mutex_exit(&usba_device->usb_mutex); 680 681 return; 682 } 683 684 USB_DPRINTF_L3(DPRINT_MASK_USBA, usba_log_handle, 685 "usba_free_usba_device 0x%p, address=0x%x, ref cnt=%d", 686 (void *)usba_device, usba_device->usb_addr, 687 usba_device->usb_ref_count); 688 689 usba_free_evdata(usba_device->usb_evdata); 690 mutex_exit(&usba_device->usb_mutex); 691 692 def_ph = usba_usbdev_to_dflt_pipe_handle(usba_device); 693 if (def_ph != NULL) { 694 usba_pipe_handle_data_t *ph_data = usba_get_ph_data(def_ph); 695 696 if (ph_data) { 697 usb_pipe_close(ph_data->p_dip, def_ph, 698 USB_FLAGS_SLEEP | USBA_FLAGS_PRIVILEGED, 699 NULL, NULL); 700 } 701 } 702 703 mutex_enter(&usba_mutex); 704 705 /* destroy mutex in each usba_ph_impl structure */ 706 for (ep_idx = 0; ep_idx < USBA_N_ENDPOINTS; ep_idx++) { 707 mutex_destroy(&usba_device->usb_ph_list[ep_idx].usba_ph_mutex); 708 } 709 710 (void) usba_rm_from_list(&usba_device_list, 711 &usba_device->usb_device_list); 712 713 mutex_exit(&usba_mutex); 714 715 usba_destroy_list(&usba_device->usb_device_list); 716 usba_destroy_list(&usba_device->usb_allocated); 717 718 USB_DPRINTF_L2(DPRINT_MASK_USBA, usba_log_handle, 719 "deallocating usba_device = 0x%p, address = 0x%x", 720 (void *)usba_device, usba_device->usb_addr); 721 722 /* 723 * ohci allocates descriptors for root hub so we can't 724 * deallocate these here 725 */ 726 727 if (usba_device->usb_addr != ROOT_HUB_ADDR) { 728 if (usba_device->usb_cfg_array) { 729 USB_DPRINTF_L3(DPRINT_MASK_USBA, usba_log_handle, 730 "deallocating usb_config_array: 0x%p", 731 (void *)usba_device->usb_cfg_array); 732 mutex_enter(&usba_device->usb_mutex); 733 for (i = 0; 734 i < usba_device->usb_dev_descr->bNumConfigurations; 735 i++) { 736 if (usba_device->usb_cfg_array[i]) { 737 kmem_free( 738 usba_device->usb_cfg_array[i], 739 usba_device->usb_cfg_array_len[i]); 740 } 741 } 742 743 /* free the array pointers */ 744 kmem_free(usba_device->usb_cfg_array, 745 usba_device->usb_cfg_array_length); 746 kmem_free(usba_device->usb_cfg_array_len, 747 usba_device->usb_cfg_array_len_length); 748 749 mutex_exit(&usba_device->usb_mutex); 750 } 751 752 if (usba_device->usb_cfg_str_descr) { 753 USB_DPRINTF_L3(DPRINT_MASK_USBA, usba_log_handle, 754 "deallocating usb_cfg_str_descr: 0x%p", 755 (void *)usba_device->usb_cfg_str_descr); 756 for (i = 0; 757 i < usba_device->usb_dev_descr->bNumConfigurations; 758 i++) { 759 if (usba_device->usb_cfg_str_descr[i]) { 760 kmem_free( 761 usba_device->usb_cfg_str_descr[i], 762 strlen(usba_device-> 763 usb_cfg_str_descr[i]) + 1); 764 } 765 } 766 /* free the array pointers */ 767 kmem_free(usba_device->usb_cfg_str_descr, 768 sizeof (uchar_t *) * usba_device->usb_n_cfgs); 769 } 770 771 if (usba_device->usb_dev_descr) { 772 kmem_free(usba_device->usb_dev_descr, 773 sizeof (usb_dev_descr_t)); 774 } 775 776 if (usba_device->usb_mfg_str) { 777 kmem_free(usba_device->usb_mfg_str, 778 strlen(usba_device->usb_mfg_str) + 1); 779 } 780 781 if (usba_device->usb_product_str) { 782 kmem_free(usba_device->usb_product_str, 783 strlen(usba_device->usb_product_str) + 1); 784 } 785 786 if (usba_device->usb_serialno_str) { 787 kmem_free(usba_device->usb_serialno_str, 788 strlen(usba_device->usb_serialno_str) + 1); 789 } 790 791 if (usba_device->usb_wireless_data) { 792 mutex_enter(&usba_device->usb_mutex); 793 usba_free_wireless_data( 794 usba_device->usb_wireless_data); 795 mutex_exit(&usba_device->usb_mutex); 796 } 797 798 /* 799 * The device address on the wireless bus is assigned 800 * by the wireless host controller driver(whci or hwahc), 801 * not by USBA framework, so skip this for wireless 802 * USB devices. 803 */ 804 if (!usba_device->usb_is_wireless) { 805 usba_unset_usb_address(usba_device); 806 } 807 } 808 809 #ifndef __lock_lint 810 ASSERT(usba_device->usb_client_dev_data_list.cddl_next == NULL); 811 #endif 812 813 if (usba_device->usb_client_flags) { 814 #ifndef __lock_lint 815 int i; 816 817 for (i = 0; i < usba_device->usb_n_ifs; i++) { 818 ASSERT(usba_device->usb_client_flags[i] == 0); 819 } 820 #endif 821 kmem_free(usba_device->usb_client_flags, 822 usba_device->usb_n_ifs * USBA_CLIENT_FLAG_SIZE); 823 } 824 825 826 if (usba_device->usb_client_attach_list) { 827 kmem_free(usba_device->usb_client_attach_list, 828 usba_device->usb_n_ifs * 829 sizeof (*usba_device->usb_client_attach_list)); 830 } 831 if (usba_device->usb_client_ev_cb_list) { 832 kmem_free(usba_device->usb_client_ev_cb_list, 833 usba_device->usb_n_ifs * 834 sizeof (*usba_device->usb_client_ev_cb_list)); 835 } 836 837 /* 838 * finally ready to destroy the structure 839 */ 840 mutex_destroy(&usba_device->usb_mutex); 841 842 kmem_free((caddr_t)usba_device, sizeof (usba_device_t)); 843 } 844 845 846 /* clear the data toggle for all endpoints on this device */ 847 void 848 usba_clear_data_toggle(usba_device_t *usba_device) 849 { 850 int i; 851 852 if (usba_device != NULL) { 853 mutex_enter(&usba_device->usb_mutex); 854 for (i = 0; i < USBA_N_ENDPOINTS; i++) { 855 usba_device->usb_ph_list[i].usba_ph_flags &= 856 ~USBA_PH_DATA_TOGGLE; 857 } 858 mutex_exit(&usba_device->usb_mutex); 859 } 860 } 861 862 863 /* 864 * usba_create_child_devi(): 865 * create a child devinfo node, usba_device, attach properties. 866 * the usba_device structure is shared between all interfaces 867 */ 868 int 869 usba_create_child_devi(dev_info_t *dip, 870 char *node_name, 871 usba_hcdi_ops_t *usba_hcdi_ops, 872 dev_info_t *usb_root_hub_dip, 873 usb_port_status_t port_status, 874 usba_device_t *usba_device, 875 dev_info_t **child_dip) 876 { 877 int rval = USB_FAILURE; 878 int usba_device_allocated = 0; 879 usb_addr_t address; 880 881 USB_DPRINTF_L4(DPRINT_MASK_USBA, usba_log_handle, 882 "usba_create_child_devi: %s usba_device=0x%p " 883 "port status=0x%x", node_name, 884 (void *)usba_device, port_status); 885 886 ndi_devi_alloc_sleep(dip, node_name, (pnode_t)DEVI_SID_NODEID, 887 child_dip); 888 889 USB_DPRINTF_L3(DPRINT_MASK_USBA, usba_log_handle, 890 "child dip=0x%p", (void *)*child_dip); 891 892 if (usba_device == NULL) { 893 894 usba_device = usba_alloc_usba_device(usb_root_hub_dip); 895 896 /* grab the mutex to keep warlock happy */ 897 mutex_enter(&usba_device->usb_mutex); 898 usba_device->usb_hcdi_ops = usba_hcdi_ops; 899 usba_device->usb_port_status = port_status; 900 mutex_exit(&usba_device->usb_mutex); 901 902 usba_device_allocated++; 903 } else { 904 mutex_enter(&usba_device->usb_mutex); 905 if (usba_hcdi_ops) { 906 ASSERT(usba_device->usb_hcdi_ops == usba_hcdi_ops); 907 } 908 if (usb_root_hub_dip) { 909 ASSERT(usba_device->usb_root_hub_dip == 910 usb_root_hub_dip); 911 } 912 913 usba_device->usb_port_status = port_status; 914 915 mutex_exit(&usba_device->usb_mutex); 916 } 917 918 if (usba_device->usb_addr == 0) { 919 if (usba_set_usb_address(usba_device) == USB_FAILURE) { 920 address = 0; 921 922 USB_DPRINTF_L2(DPRINT_MASK_USBA, usba_log_handle, 923 "cannot set usb address for dip=0x%p", 924 (void *)*child_dip); 925 926 goto fail; 927 } 928 } 929 address = usba_device->usb_addr; 930 931 /* attach properties */ 932 rval = ndi_prop_update_int(DDI_DEV_T_NONE, *child_dip, 933 "assigned-address", address); 934 if (rval != DDI_PROP_SUCCESS) { 935 USB_DPRINTF_L2(DPRINT_MASK_USBA, usba_log_handle, 936 "cannot set usb address property for dip=0x%p", 937 (void *)*child_dip); 938 rval = USB_FAILURE; 939 940 goto fail; 941 } 942 943 /* 944 * store the usba_device point in the dip 945 */ 946 usba_set_usba_device(*child_dip, usba_device); 947 948 USB_DPRINTF_L4(DPRINT_MASK_USBA, usba_log_handle, 949 "usba_create_child_devi: devi=0x%p (%s) ud=0x%p", 950 (void *)*child_dip, ddi_driver_name(*child_dip), 951 (void *)usba_device); 952 953 return (USB_SUCCESS); 954 955 fail: 956 if (*child_dip) { 957 int rval = usba_destroy_child_devi(*child_dip, NDI_DEVI_REMOVE); 958 ASSERT(rval == USB_SUCCESS); 959 *child_dip = NULL; 960 } 961 962 if (usba_device_allocated) { 963 usba_free_usba_device(usba_device); 964 } else if (address && usba_device) { 965 usba_unset_usb_address(usba_device); 966 } 967 968 USB_DPRINTF_L2(DPRINT_MASK_USBA, usba_log_handle, 969 "usba_create_child_devi failed: rval=%d", rval); 970 971 return (rval); 972 } 973 974 975 int 976 usba_destroy_child_devi(dev_info_t *dip, uint_t flag) 977 { 978 usba_device_t *usba_device; 979 int rval = NDI_SUCCESS; 980 981 USB_DPRINTF_L2(DPRINT_MASK_USBA, usba_log_handle, 982 "usba_destroy_child_devi: %s%d (0x%p)", 983 ddi_driver_name(dip), ddi_get_instance(dip), (void *)dip); 984 985 usba_device = usba_get_usba_device(dip); 986 987 /* 988 * if the child hasn't been bound yet, we can just 989 * free the dip 990 */ 991 if (i_ddi_node_state(dip) < DS_INITIALIZED) { 992 /* 993 * do not call ndi_devi_free() since it might 994 * deadlock 995 */ 996 rval = ddi_remove_child(dip, 0); 997 998 } else { 999 char *devnm = kmem_alloc(MAXNAMELEN + 1, KM_SLEEP); 1000 dev_info_t *pdip = ddi_get_parent(dip); 1001 1002 (void) ddi_deviname(dip, devnm); 1003 1004 USB_DPRINTF_L3(DPRINT_MASK_USBA, usba_log_handle, 1005 "usba_destroy_child_devi:\n\t" 1006 "offlining dip 0x%p usba_device=0x%p (%s)", (void *)dip, 1007 (void *)usba_device, devnm); 1008 1009 (void) devfs_clean(pdip, NULL, DV_CLEAN_FORCE); 1010 rval = ndi_devi_unconfig_one(pdip, devnm + 1, NULL, 1011 flag | NDI_UNCONFIG | NDI_DEVI_OFFLINE); 1012 if (rval != NDI_SUCCESS) { 1013 USB_DPRINTF_L2(DPRINT_MASK_USBA, usba_log_handle, 1014 " ndi_devi_unconfig_one %s%d failed (%d)", 1015 ddi_driver_name(dip), ddi_get_instance(dip), 1016 rval); 1017 } 1018 kmem_free(devnm, MAXNAMELEN + 1); 1019 } 1020 1021 USB_DPRINTF_L4(DPRINT_MASK_USBA, usba_log_handle, 1022 "usba_destroy_child_devi: rval=%d", rval); 1023 1024 return (rval == NDI_SUCCESS ? USB_SUCCESS : USB_FAILURE); 1025 } 1026 1027 1028 /* 1029 * list management 1030 */ 1031 void 1032 usba_init_list(usba_list_entry_t *element, usb_opaque_t private, 1033 ddi_iblock_cookie_t iblock_cookie) 1034 { 1035 mutex_init(&element->list_mutex, NULL, MUTEX_DRIVER, 1036 iblock_cookie); 1037 mutex_enter(&element->list_mutex); 1038 element->private = private; 1039 mutex_exit(&element->list_mutex); 1040 } 1041 1042 1043 void 1044 usba_destroy_list(usba_list_entry_t *head) 1045 { 1046 mutex_enter(&head->list_mutex); 1047 ASSERT(head->next == NULL); 1048 ASSERT(head->prev == NULL); 1049 mutex_exit(&head->list_mutex); 1050 1051 mutex_destroy(&head->list_mutex); 1052 } 1053 1054 1055 void 1056 usba_add_to_list(usba_list_entry_t *head, usba_list_entry_t *element) 1057 { 1058 usba_list_entry_t *next; 1059 int remaining; 1060 1061 mutex_enter(&head->list_mutex); 1062 mutex_enter(&element->list_mutex); 1063 1064 remaining = head->count; 1065 1066 /* check if it is not in another list */ 1067 ASSERT(element->next == NULL); 1068 ASSERT(element->prev == NULL); 1069 1070 #ifdef DEBUG 1071 /* 1072 * only verify the list when not in interrupt context, we 1073 * have to trust the HCD 1074 */ 1075 if (!servicing_interrupt()) { 1076 1077 /* check if not already in this list */ 1078 for (next = head->next; (next != NULL); 1079 next = next->next) { 1080 if (next == element) { 1081 USB_DPRINTF_L0(DPRINT_MASK_USBA, 1082 usba_log_handle, 1083 "Attempt to corrupt USB list at 0x%p", 1084 (void *)head); 1085 ASSERT(next == element); 1086 1087 goto done; 1088 } 1089 remaining--; 1090 1091 /* 1092 * Detect incorrect circ links or found 1093 * unexpected elements. 1094 */ 1095 if ((next->next && (remaining == 0)) || 1096 ((next->next == NULL) && remaining)) { 1097 panic("Corrupted USB list at 0x%p", 1098 (void *)head); 1099 /*NOTREACHED*/ 1100 } 1101 } 1102 } 1103 #endif 1104 1105 if (head->next == NULL) { 1106 head->prev = head->next = element; 1107 } else { 1108 /* add to tail */ 1109 head->prev->next = element; 1110 element->prev = head->prev; 1111 head->prev = element; 1112 } 1113 1114 head->count++; 1115 1116 USB_DPRINTF_L4(DPRINT_MASK_USBA, usba_log_handle, 1117 "usba_add_to_list: head=0x%p element=0x%p count=%d", 1118 (void *)head, (void *)element, head->count); 1119 1120 done: 1121 mutex_exit(&head->list_mutex); 1122 mutex_exit(&element->list_mutex); 1123 } 1124 1125 1126 int 1127 usba_rm_from_list(usba_list_entry_t *head, usba_list_entry_t *element) 1128 { 1129 usba_list_entry_t *e; 1130 int found = 0; 1131 int remaining; 1132 1133 /* find the element in the list first */ 1134 mutex_enter(&head->list_mutex); 1135 1136 USB_DPRINTF_L4(DPRINT_MASK_USBA, usba_log_handle, 1137 "usba_rm_from_list: head=0x%p element=0x%p count=%d", 1138 (void *)head, (void *)element, head->count); 1139 1140 remaining = head->count; 1141 e = head->next; 1142 1143 while (e) { 1144 if (e == element) { 1145 found++; 1146 break; 1147 } 1148 e = e->next; 1149 1150 remaining--; 1151 1152 /* Detect incorrect circ links or found unexpected elements. */ 1153 if ((e && (remaining == 0)) || 1154 ((e == NULL) && (remaining))) { 1155 panic("Corrupted USB list at 0x%p", (void *)head); 1156 /*NOTREACHED*/ 1157 } 1158 } 1159 1160 if (!found) { 1161 mutex_exit(&head->list_mutex); 1162 1163 return (USB_FAILURE); 1164 } 1165 1166 /* now remove the element */ 1167 mutex_enter(&element->list_mutex); 1168 1169 if (element->next) { 1170 element->next->prev = element->prev; 1171 } 1172 if (element->prev) { 1173 element->prev->next = element->next; 1174 } 1175 if (head->next == element) { 1176 head->next = element->next; 1177 } 1178 if (head->prev == element) { 1179 head->prev = element->prev; 1180 } 1181 1182 element->prev = element->next = NULL; 1183 if (head->next == NULL) { 1184 ASSERT(head->prev == NULL); 1185 } else { 1186 ASSERT(head->next->prev == NULL); 1187 } 1188 if (head->prev == NULL) { 1189 ASSERT(head->next == NULL); 1190 } else { 1191 ASSERT(head->prev->next == NULL); 1192 } 1193 1194 head->count--; 1195 1196 USB_DPRINTF_L4(DPRINT_MASK_USBA, usba_log_handle, 1197 "usba_rm_from_list success: head=0x%p element=0x%p cnt=%d", 1198 (void *)head, (void *)element, head->count); 1199 1200 mutex_exit(&element->list_mutex); 1201 mutex_exit(&head->list_mutex); 1202 1203 return (USB_SUCCESS); 1204 } 1205 1206 1207 usba_list_entry_t * 1208 usba_rm_first_from_list(usba_list_entry_t *head) 1209 { 1210 usba_list_entry_t *element = NULL; 1211 1212 if (head) { 1213 mutex_enter(&head->list_mutex); 1214 element = head->next; 1215 if (element) { 1216 /* now remove the element */ 1217 mutex_enter(&element->list_mutex); 1218 head->next = element->next; 1219 if (head->next) { 1220 head->next->prev = NULL; 1221 } 1222 if (head->prev == element) { 1223 head->prev = element->next; 1224 } 1225 element->prev = element->next = NULL; 1226 mutex_exit(&element->list_mutex); 1227 head->count--; 1228 } 1229 if (head->next == NULL) { 1230 ASSERT(head->prev == NULL); 1231 } else { 1232 ASSERT(head->next->prev == NULL); 1233 } 1234 if (head->prev == NULL) { 1235 ASSERT(head->next == NULL); 1236 } else { 1237 ASSERT(head->prev->next == NULL); 1238 } 1239 USB_DPRINTF_L4(DPRINT_MASK_USBA, usba_log_handle, 1240 "usba_rm_first_from_list: head=0x%p el=0x%p cnt=%d", 1241 (void *)head, (void *)element, head->count); 1242 1243 mutex_exit(&head->list_mutex); 1244 } 1245 1246 return (element); 1247 } 1248 1249 1250 usb_opaque_t 1251 usba_rm_first_pvt_from_list(usba_list_entry_t *head) 1252 { 1253 usba_list_entry_t *element = usba_rm_first_from_list(head); 1254 usb_opaque_t private = NULL; 1255 1256 if (element) { 1257 mutex_enter(&element->list_mutex); 1258 private = element->private; 1259 mutex_exit(&element->list_mutex); 1260 } 1261 1262 return (private); 1263 } 1264 1265 1266 /* 1267 * move list to new list and zero original list 1268 */ 1269 void 1270 usba_move_list(usba_list_entry_t *head, usba_list_entry_t *new, 1271 ddi_iblock_cookie_t iblock_cookie) 1272 { 1273 usba_init_list(new, NULL, iblock_cookie); 1274 mutex_enter(&head->list_mutex); 1275 mutex_enter(&new->list_mutex); 1276 1277 new->next = head->next; 1278 new->prev = head->prev; 1279 new->count = head->count; 1280 new->private = head->private; 1281 1282 head->next = NULL; 1283 head->prev = NULL; 1284 head->count = 0; 1285 head->private = NULL; 1286 mutex_exit(&head->list_mutex); 1287 mutex_exit(&new->list_mutex); 1288 } 1289 1290 1291 int 1292 usba_check_in_list(usba_list_entry_t *head, usba_list_entry_t *element) 1293 { 1294 int rval = USB_FAILURE; 1295 int remaining; 1296 usba_list_entry_t *next; 1297 1298 mutex_enter(&head->list_mutex); 1299 remaining = head->count; 1300 1301 mutex_enter(&element->list_mutex); 1302 for (next = head->next; next != NULL; next = next->next) { 1303 if (next == element) { 1304 rval = USB_SUCCESS; 1305 break; 1306 } 1307 remaining--; 1308 1309 /* Detect incorrect circ links or found unexpected elements. */ 1310 if ((next->next && (remaining == 0)) || 1311 ((next->next == NULL) && remaining)) { 1312 panic("Corrupted USB list at 0x%p", (void *)head); 1313 /*NOTREACHED*/ 1314 } 1315 } 1316 mutex_exit(&element->list_mutex); 1317 mutex_exit(&head->list_mutex); 1318 1319 return (rval); 1320 } 1321 1322 1323 int 1324 usba_list_entry_leaks(usba_list_entry_t *head, char *what) 1325 { 1326 int count = 0; 1327 int remaining; 1328 usba_list_entry_t *next; 1329 1330 mutex_enter(&head->list_mutex); 1331 remaining = head->count; 1332 for (next = head->next; next != NULL; next = next->next) { 1333 USB_DPRINTF_L2(DPRINT_MASK_HCDI, usba_log_handle, 1334 "leaking %s 0x%p", what, (void *)next->private); 1335 count++; 1336 1337 remaining--; 1338 1339 /* Detect incorrect circ links or found unexpected elements. */ 1340 if ((next->next && (remaining == 0)) || 1341 ((next->next == NULL) && remaining)) { 1342 panic("Corrupted USB list at 0x%p", (void *)head); 1343 /*NOTREACHED*/ 1344 } 1345 } 1346 ASSERT(count == head->count); 1347 mutex_exit(&head->list_mutex); 1348 1349 if (count) { 1350 USB_DPRINTF_L2(DPRINT_MASK_HCDI, usba_log_handle, 1351 "usba_list_entry_count: leaking %d", count); 1352 } 1353 1354 return (count); 1355 } 1356 1357 1358 int 1359 usba_list_entry_count(usba_list_entry_t *head) 1360 { 1361 int count; 1362 1363 mutex_enter(&head->list_mutex); 1364 count = head->count; 1365 mutex_exit(&head->list_mutex); 1366 1367 return (count); 1368 } 1369 1370 /* add a new root hub to the usba_root_hubs list */ 1371 1372 void 1373 usba_add_root_hub(dev_info_t *dip) 1374 { 1375 usba_root_hub_ent_t *hub; 1376 1377 hub = (usba_root_hub_ent_t *) 1378 kmem_zalloc(sizeof (usba_root_hub_ent_t), KM_SLEEP); 1379 1380 mutex_enter(&usba_hub_mutex); 1381 hub->dip = dip; 1382 hub->next = usba_root_hubs; 1383 usba_root_hubs = hub; 1384 mutex_exit(&usba_hub_mutex); 1385 } 1386 1387 /* remove a root hub from the usba_root_hubs list */ 1388 1389 void 1390 usba_rem_root_hub(dev_info_t *dip) 1391 { 1392 usba_root_hub_ent_t **hubp, *hub; 1393 1394 mutex_enter(&usba_hub_mutex); 1395 hubp = &usba_root_hubs; 1396 while (*hubp) { 1397 if ((*hubp)->dip == dip) { 1398 hub = *hubp; 1399 *hubp = hub->next; 1400 kmem_free(hub, sizeof (struct usba_root_hub_ent)); 1401 mutex_exit(&usba_hub_mutex); 1402 1403 return; 1404 } 1405 hubp = &(*hubp)->next; 1406 } 1407 mutex_exit(&usba_hub_mutex); 1408 } 1409 1410 /* 1411 * check whether this dip is the root hub. Any root hub known by 1412 * usba is recorded in the linked list pointed to by usba_root_hubs 1413 */ 1414 int 1415 usba_is_root_hub(dev_info_t *dip) 1416 { 1417 usba_root_hub_ent_t *hub; 1418 1419 mutex_enter(&usba_hub_mutex); 1420 hub = usba_root_hubs; 1421 while (hub) { 1422 if (hub->dip == dip) { 1423 mutex_exit(&usba_hub_mutex); 1424 1425 return (1); 1426 } 1427 hub = hub->next; 1428 } 1429 mutex_exit(&usba_hub_mutex); 1430 1431 return (0); 1432 } 1433 1434 /* 1435 * check whether this dip is a wire adapter device 1436 */ 1437 int 1438 usba_is_wa(dev_info_t *dip) 1439 { 1440 if (dip) { 1441 usba_device_t *usba_device; 1442 1443 usba_device = usba_get_usba_device(dip); 1444 1445 return (usba_device->usb_is_wa? 1:0); 1446 } 1447 1448 return (0); 1449 } 1450 1451 /* 1452 * check whether this dip is a host wire adapter device node 1453 */ 1454 int 1455 usba_is_hwa(dev_info_t *dip) 1456 { 1457 dev_info_t *cdip; 1458 1459 if (dip == NULL) { 1460 1461 return (0); 1462 } 1463 1464 if (strcmp(ddi_driver_name(dip), "usb_mid") != 0) { 1465 1466 return (0); 1467 } 1468 1469 for (cdip = ddi_get_child(dip); cdip; 1470 cdip = ddi_get_next_sibling(cdip)) { 1471 if (strcmp(ddi_driver_name(cdip), "hwarc") == 0) { 1472 1473 return (1); 1474 } 1475 } 1476 1477 return (0); 1478 } 1479 1480 /* 1481 * get and store usba_device pointer in the devi 1482 */ 1483 usba_device_t * 1484 usba_get_usba_device(dev_info_t *dip) 1485 { 1486 /* 1487 * we cannot use parent_data in the usb node because its 1488 * bus parent (eg. PCI nexus driver) uses this data 1489 * 1490 * we cannot use driver data in the other usb nodes since 1491 * usb drivers may need to use this 1492 */ 1493 if (usba_is_root_hub(dip)) { 1494 usba_hcdi_t *hcdi = usba_hcdi_get_hcdi(dip); 1495 1496 return (hcdi->hcdi_usba_device); 1497 } else { 1498 1499 return (ddi_get_parent_data(dip)); 1500 } 1501 } 1502 1503 1504 /* 1505 * Retrieve the usba_device pointer from the dev without checking for 1506 * the root hub first. This function is only used in polled mode. 1507 */ 1508 usba_device_t * 1509 usba_polled_get_usba_device(dev_info_t *dip) 1510 { 1511 /* 1512 * Don't call usba_is_root_hub() to find out if this is 1513 * the root hub usba_is_root_hub() calls into the DDI 1514 * where there are locking issues. The dip sent in during 1515 * polled mode will never be the root hub, so just get 1516 * the usba_device pointer from the dip. 1517 */ 1518 return (ddi_get_parent_data(dip)); 1519 } 1520 1521 1522 void 1523 usba_set_usba_device(dev_info_t *dip, usba_device_t *usba_device) 1524 { 1525 if (usba_is_root_hub(dip)) { 1526 usba_hcdi_t *hcdi = usba_hcdi_get_hcdi(dip); 1527 /* no locking is needed here */ 1528 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(hcdi->hcdi_usba_device)) 1529 hcdi->hcdi_usba_device = usba_device; 1530 _NOTE(NOW_VISIBLE_TO_OTHER_THREADS(hcdi->hcdi_usba_device)) 1531 } else { 1532 ddi_set_parent_data(dip, usba_device); 1533 } 1534 } 1535 1536 1537 /* 1538 * usba_set_node_name() according to class, subclass, and protocol 1539 * following the 1275 USB binding tables. 1540 */ 1541 1542 /* device node table, refer to section 3.2.2.1 of 1275 binding */ 1543 static node_name_entry_t device_node_name_table[] = { 1544 { USB_CLASS_COMM, DONTCARE, DONTCARE, "communications" }, 1545 { USB_CLASS_HUB, DONTCARE, DONTCARE, "hub" }, 1546 { USB_CLASS_DIAG, DONTCARE, DONTCARE, "diagnostics" }, 1547 { USB_CLASS_MISC, DONTCARE, DONTCARE, "miscellaneous" }, 1548 { DONTCARE, DONTCARE, DONTCARE, "device" } 1549 }; 1550 1551 /* interface-association node table */ 1552 static node_name_entry_t ia_node_name_table[] = { 1553 { USB_CLASS_AUDIO, DONTCARE, DONTCARE, "audio" }, 1554 { USB_CLASS_VIDEO, DONTCARE, DONTCARE, "video" }, 1555 { USB_CLASS_WIRELESS, USB_SUBCLS_WUSB_2, USB_PROTO_WUSB_DWA, 1556 "device-wire-adaptor" }, 1557 { USB_CLASS_WIRELESS, DONTCARE, DONTCARE, "wireless-controller" }, 1558 { DONTCARE, DONTCARE, DONTCARE, "interface-association" } 1559 }; 1560 1561 /* interface node table, refer to section 3.3.2.1 */ 1562 static node_name_entry_t if_node_name_table[] = { 1563 { USB_CLASS_AUDIO, USB_SUBCLS_AUD_CONTROL, DONTCARE, "sound-control" }, 1564 { USB_CLASS_AUDIO, USB_SUBCLS_AUD_STREAMING, DONTCARE, "sound" }, 1565 { USB_CLASS_AUDIO, USB_SUBCLS_AUD_MIDI_STREAMING, DONTCARE, "midi" }, 1566 { USB_CLASS_AUDIO, DONTCARE, DONTCARE, "sound" }, 1567 1568 { USB_CLASS_COMM, USB_SUBCLS_CDCC_DIRECT_LINE, DONTCARE, "line" }, 1569 { USB_CLASS_COMM, USB_SUBCLS_CDCC_ABSTRCT_CTRL, DONTCARE, "modem" }, 1570 { USB_CLASS_COMM, USB_SUBCLS_CDCC_PHONE_CTRL, DONTCARE, "telephone" }, 1571 { USB_CLASS_COMM, USB_SUBCLS_CDCC_MULTCNL_ISDN, DONTCARE, "isdn" }, 1572 { USB_CLASS_COMM, USB_SUBCLS_CDCC_ISDN, DONTCARE, "isdn" }, 1573 { USB_CLASS_COMM, USB_SUBCLS_CDCC_ETHERNET, DONTCARE, "ethernet" }, 1574 { USB_CLASS_COMM, USB_SUBCLS_CDCC_ATM_NETWORK, DONTCARE, "atm-network" }, 1575 { USB_CLASS_COMM, DONTCARE, DONTCARE, "communications" }, 1576 1577 { USB_CLASS_HID, USB_SUBCLS_HID_1, USB_PROTO_HID_KEYBOARD, "keyboard" }, 1578 { USB_CLASS_HID, USB_SUBCLS_HID_1, USB_PROTO_HID_MOUSE, "mouse" }, 1579 { USB_CLASS_HID, DONTCARE, DONTCARE, "input" }, 1580 1581 { USB_CLASS_HUB, DONTCARE, DONTCARE, "hub" }, 1582 1583 { USB_CLASS_PHYSICAL, DONTCARE, DONTCARE, "physical" }, 1584 1585 { USB_CLASS_IMAGE, DONTCARE, DONTCARE, "image" }, 1586 1587 { USB_CLASS_PRINTER, DONTCARE, DONTCARE, "printer" }, 1588 1589 { USB_CLASS_MASS_STORAGE, DONTCARE, DONTCARE, "storage" }, 1590 1591 { USB_CLASS_CDC_DATA, DONTCARE, DONTCARE, "data" }, 1592 1593 { USB_CLASS_SECURITY, DONTCARE, DONTCARE, "security" }, 1594 1595 { USB_CLASS_VIDEO, USB_SUBCLS_VIDEO_CONTROL, DONTCARE, "video-control" }, 1596 { USB_CLASS_VIDEO, USB_SUBCLS_VIDEO_STREAM, DONTCARE, "video-stream" }, 1597 { USB_CLASS_VIDEO, DONTCARE, DONTCARE, "video" }, 1598 1599 { USB_CLASS_APP, USB_SUBCLS_APP_FIRMWARE, DONTCARE, "firmware" }, 1600 { USB_CLASS_APP, USB_SUBCLS_APP_IRDA, DONTCARE, "IrDa" }, 1601 { USB_CLASS_APP, USB_SUBCLS_APP_TEST, DONTCARE, "test" }, 1602 1603 { USB_CLASS_MISC, USB_SUBCLS_CBAF, USB_PROTO_CBAF, "wusb_ca"}, 1604 { USB_CLASS_WIRELESS, USB_SUBCLS_WUSB_1, USB_PROTO_WUSB_RC, "hwa-radio" }, 1605 { USB_CLASS_WIRELESS, USB_SUBCLS_WUSB_2, USB_PROTO_WUSB_HWA, "hwa-host" }, 1606 { USB_CLASS_WIRELESS, USB_SUBCLS_WUSB_2, USB_PROTO_WUSB_DWA, "dwa-control" }, 1607 { USB_CLASS_WIRELESS, USB_SUBCLS_WUSB_2, USB_PROTO_WUSB_DWA_ISO, "dwa-isoc" }, 1608 { USB_CLASS_WIRELESS, DONTCARE, DONTCARE, "wireless" }, 1609 1610 { DONTCARE, DONTCARE, DONTCARE, "interface" }, 1611 1612 }; 1613 1614 /* combined node table, refer to section 3.4.2.1 */ 1615 static node_name_entry_t combined_node_name_table[] = { 1616 { USB_CLASS_AUDIO, USB_SUBCLS_AUD_CONTROL, DONTCARE, "sound-control" }, 1617 { USB_CLASS_AUDIO, USB_SUBCLS_AUD_STREAMING, DONTCARE, "sound" }, 1618 { USB_CLASS_AUDIO, USB_SUBCLS_AUD_MIDI_STREAMING, DONTCARE, "midi" }, 1619 { USB_CLASS_AUDIO, DONTCARE, DONTCARE, "sound" }, 1620 1621 { USB_CLASS_COMM, USB_SUBCLS_CDCC_DIRECT_LINE, DONTCARE, "line" }, 1622 { USB_CLASS_COMM, USB_SUBCLS_CDCC_ABSTRCT_CTRL, DONTCARE, "modem" }, 1623 { USB_CLASS_COMM, USB_SUBCLS_CDCC_PHONE_CTRL, DONTCARE, "telephone" }, 1624 { USB_CLASS_COMM, USB_SUBCLS_CDCC_MULTCNL_ISDN, DONTCARE, "isdn" }, 1625 { USB_CLASS_COMM, USB_SUBCLS_CDCC_ISDN, DONTCARE, "isdn" }, 1626 { USB_CLASS_COMM, USB_SUBCLS_CDCC_ETHERNET, DONTCARE, "ethernet" }, 1627 { USB_CLASS_COMM, USB_SUBCLS_CDCC_ATM_NETWORK, DONTCARE, "atm-network" }, 1628 { USB_CLASS_COMM, DONTCARE, DONTCARE, "communications" }, 1629 1630 { USB_CLASS_HID, USB_SUBCLS_HID_1, USB_PROTO_HID_KEYBOARD, "keyboard" }, 1631 { USB_CLASS_HID, USB_SUBCLS_HID_1, USB_PROTO_HID_MOUSE, "mouse" }, 1632 { USB_CLASS_HID, DONTCARE, DONTCARE, "input" }, 1633 1634 { USB_CLASS_PHYSICAL, DONTCARE, DONTCARE, "physical" }, 1635 1636 { USB_CLASS_IMAGE, DONTCARE, DONTCARE, "image" }, 1637 1638 { USB_CLASS_PRINTER, DONTCARE, DONTCARE, "printer" }, 1639 1640 { USB_CLASS_MASS_STORAGE, USB_SUBCLS_MS_RBC_T10, DONTCARE, "storage" }, 1641 { USB_CLASS_MASS_STORAGE, USB_SUBCLS_MS_SFF8020I, DONTCARE, "cdrom" }, 1642 { USB_CLASS_MASS_STORAGE, USB_SUBCLS_MS_QIC_157, DONTCARE, "tape" }, 1643 { USB_CLASS_MASS_STORAGE, USB_SUBCLS_MS_UFI, DONTCARE, "floppy" }, 1644 { USB_CLASS_MASS_STORAGE, USB_SUBCLS_MS_SFF8070I, DONTCARE, "storage" }, 1645 { USB_CLASS_MASS_STORAGE, USB_SUBCLS_MS_SCSI, DONTCARE, "storage" }, 1646 { USB_CLASS_MASS_STORAGE, DONTCARE, DONTCARE, "storage" }, 1647 1648 { USB_CLASS_CDC_DATA, DONTCARE, DONTCARE, "data" }, 1649 1650 { USB_CLASS_SECURITY, DONTCARE, DONTCARE, "security" }, 1651 1652 { USB_CLASS_VIDEO, USB_SUBCLS_VIDEO_CONTROL, DONTCARE, "video-control" }, 1653 { USB_CLASS_VIDEO, USB_SUBCLS_VIDEO_STREAM, DONTCARE, "video-stream" }, 1654 { USB_CLASS_VIDEO, DONTCARE, DONTCARE, "video" }, 1655 1656 { USB_CLASS_APP, USB_SUBCLS_APP_FIRMWARE, DONTCARE, "firmware" }, 1657 { USB_CLASS_APP, USB_SUBCLS_APP_IRDA, DONTCARE, "IrDa" }, 1658 { USB_CLASS_APP, USB_SUBCLS_APP_TEST, DONTCARE, "test" }, 1659 1660 { USB_CLASS_COMM, DONTCARE, DONTCARE, "communications" }, 1661 { USB_CLASS_HUB, DONTCARE, DONTCARE, "hub" }, 1662 { USB_CLASS_DIAG, DONTCARE, DONTCARE, "diagnostics" }, 1663 { USB_CLASS_MISC, DONTCARE, DONTCARE, "miscellaneous" }, 1664 { DONTCARE, DONTCARE, DONTCARE, "device" } 1665 }; 1666 1667 static size_t device_node_name_table_size = 1668 sizeof (device_node_name_table)/sizeof (struct node_name_entry); 1669 static size_t ia_node_name_table_size = 1670 sizeof (ia_node_name_table)/sizeof (struct node_name_entry); 1671 static size_t if_node_name_table_size = 1672 sizeof (if_node_name_table)/sizeof (struct node_name_entry); 1673 static size_t combined_node_name_table_size = 1674 sizeof (combined_node_name_table)/sizeof (struct node_name_entry); 1675 1676 1677 static void 1678 usba_set_node_name(dev_info_t *dip, uint8_t class, uint8_t subclass, 1679 uint8_t protocol, uint_t flag) 1680 { 1681 int i; 1682 size_t size; 1683 node_name_entry_t *node_name_table; 1684 1685 switch (flag) { 1686 /* interface share node names with interface-association */ 1687 case FLAG_INTERFACE_ASSOCIATION_NODE: 1688 node_name_table = ia_node_name_table; 1689 size = ia_node_name_table_size; 1690 break; 1691 case FLAG_INTERFACE_NODE: 1692 node_name_table = if_node_name_table; 1693 size = if_node_name_table_size; 1694 break; 1695 case FLAG_DEVICE_NODE: 1696 node_name_table = device_node_name_table; 1697 size = device_node_name_table_size; 1698 break; 1699 case FLAG_COMBINED_NODE: 1700 node_name_table = combined_node_name_table; 1701 size = combined_node_name_table_size; 1702 break; 1703 default: 1704 1705 return; 1706 } 1707 1708 for (i = 0; i < size; i++) { 1709 int16_t c = node_name_table[i].class; 1710 int16_t s = node_name_table[i].subclass; 1711 int16_t p = node_name_table[i].protocol; 1712 1713 if (((c == DONTCARE) || (c == class)) && 1714 ((s == DONTCARE) || (s == subclass)) && 1715 ((p == DONTCARE) || (p == protocol))) { 1716 char *name = node_name_table[i].name; 1717 1718 (void) ndi_devi_set_nodename(dip, name, 0); 1719 break; 1720 } 1721 } 1722 } 1723 1724 1725 #ifdef DEBUG 1726 /* 1727 * walk the children of the parent of this devi and compare the 1728 * name and reg property of each child. If there is a match 1729 * return this node 1730 */ 1731 static dev_info_t * 1732 usba_find_existing_node(dev_info_t *odip) 1733 { 1734 dev_info_t *ndip, *child, *pdip; 1735 int *odata, *ndata; 1736 uint_t n_odata, n_ndata; 1737 int circular; 1738 1739 pdip = ddi_get_parent(odip); 1740 if (ddi_prop_lookup_int_array(DDI_DEV_T_ANY, 1741 odip, DDI_PROP_DONTPASS, "reg", 1742 &odata, &n_odata) != DDI_SUCCESS) { 1743 USB_DPRINTF_L2(DPRINT_MASK_HCDI, usba_log_handle, 1744 "usba_find_existing_node: " 1745 "%s: DDI_NOT_WELL_FORMED", ddi_driver_name(odip)); 1746 1747 return (NULL); 1748 } 1749 1750 ndi_devi_enter(pdip, &circular); 1751 ndip = (dev_info_t *)(DEVI(pdip)->devi_child); 1752 while ((child = ndip) != NULL) { 1753 1754 ndip = (dev_info_t *)(DEVI(child)->devi_sibling); 1755 1756 if (child == odip) { 1757 continue; 1758 } 1759 1760 if (strcmp(DEVI(child)->devi_node_name, 1761 DEVI(odip)->devi_node_name)) { 1762 continue; 1763 } 1764 1765 if (ddi_prop_lookup_int_array(DDI_DEV_T_ANY, 1766 child, DDI_PROP_DONTPASS, "reg", 1767 &ndata, &n_ndata) != DDI_SUCCESS) { 1768 1769 USB_DPRINTF_L2(DPRINT_MASK_HCDI, usba_log_handle, 1770 "usba_find_existing_node: " 1771 "%s DDI_NOT_WELL_FORMED", ddi_driver_name(child)); 1772 1773 } else if (n_ndata && n_odata && (bcmp(odata, ndata, 1774 max(n_odata, n_ndata) * sizeof (int)) == 0)) { 1775 1776 USB_DPRINTF_L3(DPRINT_MASK_HCDI, usba_log_handle, 1777 "usba_find_existing_node: found %s%d (%p)", 1778 ddi_driver_name(child), 1779 ddi_get_instance(child), (void *)child); 1780 1781 USB_DPRINTF_L3(DPRINT_MASK_HCDI, usba_log_handle, 1782 "usba_find_existing_node: " 1783 "reg: %x %x %x - %x %x %x", 1784 n_odata, odata[0], odata[1], 1785 n_ndata, ndata[0], ndata[1]); 1786 1787 ddi_prop_free(ndata); 1788 break; 1789 1790 } else { 1791 ddi_prop_free(ndata); 1792 } 1793 } 1794 1795 ndi_devi_exit(pdip, circular); 1796 1797 ddi_prop_free(odata); 1798 1799 return (child); 1800 } 1801 #endif 1802 1803 /* change all unprintable characters to spaces */ 1804 static void 1805 usba_filter_string(char *instr, char *outstr) 1806 { 1807 while (*instr) { 1808 if ((*instr >= ' ') && (*instr <= '~')) { 1809 *outstr = *instr; 1810 } else { 1811 *outstr = ' '; 1812 } 1813 outstr++; 1814 instr++; 1815 } 1816 *outstr = '\0'; 1817 } 1818 1819 1820 /* 1821 * lookup ugen binding specified in property in 1822 * hcd.conf files 1823 */ 1824 int 1825 usba_get_ugen_binding(dev_info_t *dip) 1826 { 1827 usba_device_t *usba_device = usba_get_usba_device(dip); 1828 usba_hcdi_t *hcdi = 1829 usba_hcdi_get_hcdi(usba_device->usb_root_hub_dip); 1830 1831 return (hcdi->hcdi_ugen_default_binding); 1832 } 1833 1834 1835 /* 1836 * driver binding support at device level 1837 */ 1838 dev_info_t * 1839 usba_ready_device_node(dev_info_t *child_dip) 1840 { 1841 int rval, i; 1842 int n = 0; 1843 usba_device_t *usba_device = usba_get_usba_device(child_dip); 1844 usb_dev_descr_t *usb_dev_descr; 1845 uint_t n_cfgs; /* number of configs */ 1846 uint_t n_ifs; /* number of interfaces */ 1847 uint_t port, bus_num; 1848 size_t usb_config_length; 1849 uchar_t *usb_config; 1850 int reg[1]; 1851 usb_addr_t address = usb_get_addr(child_dip); 1852 usb_if_descr_t if_descr; 1853 size_t size; 1854 int combined_node = 0; 1855 int is_hub; 1856 char *devprop_str; 1857 char *force_bind = NULL; 1858 char *usba_name_buf = NULL; 1859 char *usba_name[USBA_MAX_COMPAT_NAMES]; 1860 1861 usb_config = usb_get_raw_cfg_data(child_dip, &usb_config_length); 1862 1863 mutex_enter(&usba_device->usb_mutex); 1864 mutex_enter(&usba_mutex); 1865 1866 USB_DPRINTF_L4(DPRINT_MASK_USBA, usba_log_handle, 1867 "usba_ready_device_node: child=0x%p", (void *)child_dip); 1868 1869 port = usba_device->usb_port; 1870 usb_dev_descr = usba_device->usb_dev_descr; 1871 n_cfgs = usba_device->usb_n_cfgs; 1872 n_ifs = usba_device->usb_n_ifs; 1873 bus_num = usba_device->usb_addr; 1874 1875 if (address != ROOT_HUB_ADDR) { 1876 size = usb_parse_if_descr( 1877 usb_config, 1878 usb_config_length, 1879 0, /* interface index */ 1880 0, /* alt interface index */ 1881 &if_descr, 1882 USB_IF_DESCR_SIZE); 1883 1884 if (size != USB_IF_DESCR_SIZE) { 1885 USB_DPRINTF_L2(DPRINT_MASK_USBA, usba_log_handle, 1886 "parsing interface: " 1887 "size (%lu) != USB_IF_DESCR_SIZE (%d)", 1888 size, USB_IF_DESCR_SIZE); 1889 1890 mutex_exit(&usba_mutex); 1891 mutex_exit(&usba_device->usb_mutex); 1892 1893 return (child_dip); 1894 } 1895 } else { 1896 /* fake an interface descriptor for the root hub */ 1897 bzero(&if_descr, sizeof (if_descr)); 1898 1899 if_descr.bInterfaceClass = USB_CLASS_HUB; 1900 } 1901 1902 reg[0] = port; 1903 1904 mutex_exit(&usba_mutex); 1905 mutex_exit(&usba_device->usb_mutex); 1906 1907 rval = ndi_prop_update_int_array( 1908 DDI_DEV_T_NONE, child_dip, "reg", reg, 1); 1909 1910 if (rval != DDI_PROP_SUCCESS) { 1911 USB_DPRINTF_L2(DPRINT_MASK_USBA, usba_log_handle, 1912 "usba_ready_device_node: property update failed"); 1913 1914 return (child_dip); 1915 } 1916 1917 combined_node = ((n_cfgs == 1) && (n_ifs == 1) && 1918 ((usb_dev_descr->bDeviceClass == USB_CLASS_HUB) || 1919 (usb_dev_descr->bDeviceClass == 0))); 1920 1921 is_hub = (if_descr.bInterfaceClass == USB_CLASS_HUB) || 1922 (usb_dev_descr->bDeviceClass == USB_CLASS_HUB); 1923 1924 /* set node name */ 1925 if (combined_node) { 1926 usba_set_node_name(child_dip, 1927 if_descr.bInterfaceClass, 1928 if_descr.bInterfaceSubClass, 1929 if_descr.bInterfaceProtocol, 1930 FLAG_COMBINED_NODE); 1931 } else { 1932 usba_set_node_name(child_dip, 1933 usb_dev_descr->bDeviceClass, 1934 usb_dev_descr->bDeviceSubClass, 1935 usb_dev_descr->bDeviceProtocol, 1936 FLAG_DEVICE_NODE); 1937 } 1938 1939 /* 1940 * check force binding rules 1941 */ 1942 if ((address != ROOT_HUB_ADDR) && usba_ddivs_usbc && 1943 (address != usba_ddivs_usbc_xaddress) && 1944 (!(usba_ddivs_usbc_xhubs && is_hub))) { 1945 force_bind = "ddivs_usbc"; 1946 (void) ndi_devi_set_nodename(child_dip, "ddivs_usbc", 0); 1947 1948 } else if (usba_device->usb_preferred_driver) { 1949 force_bind = usba_device->usb_preferred_driver; 1950 1951 } else if ((address != ROOT_HUB_ADDR) && 1952 ((usba_ugen_force_binding == USBA_UGEN_DEVICE_BINDING) || 1953 ((usba_ugen_force_binding == USBA_UGEN_INTERFACE_BINDING) && 1954 combined_node)) && (!is_hub)) { 1955 force_bind = "ugen"; 1956 } 1957 1958 #ifdef DEBUG 1959 /* 1960 * check whether there is another dip with this name and address 1961 * If the dip contains usba_device, it is held by the previous 1962 * round of configuration. 1963 */ 1964 ASSERT(usba_find_existing_node(child_dip) == NULL); 1965 #endif 1966 1967 usba_name_buf = kmem_zalloc(USBA_MAX_COMPAT_NAMES * 1968 USBA_MAX_COMPAT_NAME_LEN, KM_SLEEP); 1969 1970 for (i = 0; i < USBA_MAX_COMPAT_NAMES; i++) { 1971 usba_name[i] = usba_name_buf + (i * USBA_MAX_COMPAT_NAME_LEN); 1972 } 1973 1974 if (force_bind) { 1975 (void) ndi_devi_set_nodename(child_dip, force_bind, 0); 1976 (void) strncpy(usba_name[n++], force_bind, 1977 USBA_MAX_COMPAT_NAME_LEN); 1978 } 1979 1980 /* 1981 * If the callback function of specified driver is registered, 1982 * it will be called here to check whether to take over the device. 1983 */ 1984 if (usb_cap.usba_dev_driver_cb != NULL) { 1985 char *dev_drv = NULL; 1986 usb_dev_str_t dev_str; 1987 char *pathname = kmem_alloc(MAXPATHLEN, KM_SLEEP); 1988 1989 dev_str.usb_mfg = usba_device->usb_mfg_str; 1990 dev_str.usb_product = usba_device->usb_product_str; 1991 dev_str.usb_serialno = usba_device->usb_serialno_str; 1992 1993 (void) ddi_pathname(child_dip, pathname); 1994 1995 if ((usb_cap.usba_dev_driver_cb(usb_dev_descr, &dev_str, 1996 pathname, bus_num, port, &dev_drv, NULL) == USB_SUCCESS) && 1997 (dev_drv != NULL)) { 1998 USB_DPRINTF_L3(DPRINT_MASK_USBA, usba_log_handle, 1999 "usba_ready_device_node: dev_driver=%s, port =%d," 2000 "bus =%d, path=%s\n\t", 2001 dev_drv, port, bus_num, pathname); 2002 2003 (void) strncpy(usba_name[n++], dev_drv, 2004 USBA_MAX_COMPAT_NAME_LEN); 2005 } 2006 kmem_free(pathname, MAXPATHLEN); 2007 } 2008 2009 /* create compatible names */ 2010 if (combined_node) { 2011 2012 /* 1. usbVID,PID.REV */ 2013 (void) sprintf(usba_name[n++], 2014 "usb%x,%x.%x", 2015 usb_dev_descr->idVendor, 2016 usb_dev_descr->idProduct, 2017 usb_dev_descr->bcdDevice); 2018 2019 /* 2. usbVID,PID */ 2020 (void) sprintf(usba_name[n++], 2021 "usb%x,%x", 2022 usb_dev_descr->idVendor, 2023 usb_dev_descr->idProduct); 2024 2025 if (usb_dev_descr->bDeviceClass != 0) { 2026 /* 3. usbVID,classDC.DSC.DPROTO */ 2027 (void) sprintf(usba_name[n++], 2028 "usb%x,class%x.%x.%x", 2029 usb_dev_descr->idVendor, 2030 usb_dev_descr->bDeviceClass, 2031 usb_dev_descr->bDeviceSubClass, 2032 usb_dev_descr->bDeviceProtocol); 2033 2034 /* 4. usbVID,classDC.DSC */ 2035 (void) sprintf(usba_name[n++], 2036 "usb%x,class%x.%x", 2037 usb_dev_descr->idVendor, 2038 usb_dev_descr->bDeviceClass, 2039 usb_dev_descr->bDeviceSubClass); 2040 2041 /* 5. usbVID,classDC */ 2042 (void) sprintf(usba_name[n++], 2043 "usb%x,class%x", 2044 usb_dev_descr->idVendor, 2045 usb_dev_descr->bDeviceClass); 2046 2047 /* 6. usb,classDC.DSC.DPROTO */ 2048 (void) sprintf(usba_name[n++], 2049 "usb,class%x.%x.%x", 2050 usb_dev_descr->bDeviceClass, 2051 usb_dev_descr->bDeviceSubClass, 2052 usb_dev_descr->bDeviceProtocol); 2053 2054 /* 7. usb,classDC.DSC */ 2055 (void) sprintf(usba_name[n++], 2056 "usb,class%x.%x", 2057 usb_dev_descr->bDeviceClass, 2058 usb_dev_descr->bDeviceSubClass); 2059 2060 /* 8. usb,classDC */ 2061 (void) sprintf(usba_name[n++], 2062 "usb,class%x", 2063 usb_dev_descr->bDeviceClass); 2064 } 2065 2066 if (if_descr.bInterfaceClass != 0) { 2067 /* 9. usbifVID,classIC.ISC.IPROTO */ 2068 (void) sprintf(usba_name[n++], 2069 "usbif%x,class%x.%x.%x", 2070 usb_dev_descr->idVendor, 2071 if_descr.bInterfaceClass, 2072 if_descr.bInterfaceSubClass, 2073 if_descr.bInterfaceProtocol); 2074 2075 /* 10. usbifVID,classIC.ISC */ 2076 (void) sprintf(usba_name[n++], 2077 "usbif%x,class%x.%x", 2078 usb_dev_descr->idVendor, 2079 if_descr.bInterfaceClass, 2080 if_descr.bInterfaceSubClass); 2081 2082 /* 11. usbifVID,classIC */ 2083 (void) sprintf(usba_name[n++], 2084 "usbif%x,class%x", 2085 usb_dev_descr->idVendor, 2086 if_descr.bInterfaceClass); 2087 2088 /* 12. usbif,classIC.ISC.IPROTO */ 2089 (void) sprintf(usba_name[n++], 2090 "usbif,class%x.%x.%x", 2091 if_descr.bInterfaceClass, 2092 if_descr.bInterfaceSubClass, 2093 if_descr.bInterfaceProtocol); 2094 2095 /* 13. usbif,classIC.ISC */ 2096 (void) sprintf(usba_name[n++], 2097 "usbif,class%x.%x", 2098 if_descr.bInterfaceClass, 2099 if_descr.bInterfaceSubClass); 2100 2101 /* 14. usbif,classIC */ 2102 (void) sprintf(usba_name[n++], 2103 "usbif,class%x", 2104 if_descr.bInterfaceClass); 2105 } 2106 2107 /* 15. ugen or usb_mid */ 2108 if (usba_get_ugen_binding(child_dip) == 2109 USBA_UGEN_DEVICE_BINDING) { 2110 (void) sprintf(usba_name[n++], "ugen"); 2111 } else { 2112 (void) sprintf(usba_name[n++], "usb,device"); 2113 } 2114 2115 } else { 2116 if (n_cfgs > 1) { 2117 /* 1. usbVID,PID.REV.configCN */ 2118 (void) sprintf(usba_name[n++], 2119 "usb%x,%x.%x.config%x", 2120 usb_dev_descr->idVendor, 2121 usb_dev_descr->idProduct, 2122 usb_dev_descr->bcdDevice, 2123 usba_device->usb_cfg_value); 2124 } 2125 2126 /* 2. usbVID,PID.REV */ 2127 (void) sprintf(usba_name[n++], 2128 "usb%x,%x.%x", 2129 usb_dev_descr->idVendor, 2130 usb_dev_descr->idProduct, 2131 usb_dev_descr->bcdDevice); 2132 2133 /* 3. usbVID,PID.configCN */ 2134 if (n_cfgs > 1) { 2135 (void) sprintf(usba_name[n++], 2136 "usb%x,%x.%x", 2137 usb_dev_descr->idVendor, 2138 usb_dev_descr->idProduct, 2139 usba_device->usb_cfg_value); 2140 } 2141 2142 /* 4. usbVID,PID */ 2143 (void) sprintf(usba_name[n++], 2144 "usb%x,%x", 2145 usb_dev_descr->idVendor, 2146 usb_dev_descr->idProduct); 2147 2148 if (usb_dev_descr->bDeviceClass != 0) { 2149 /* 5. usbVID,classDC.DSC.DPROTO */ 2150 (void) sprintf(usba_name[n++], 2151 "usb%x,class%x.%x.%x", 2152 usb_dev_descr->idVendor, 2153 usb_dev_descr->bDeviceClass, 2154 usb_dev_descr->bDeviceSubClass, 2155 usb_dev_descr->bDeviceProtocol); 2156 2157 /* 6. usbVID,classDC.DSC */ 2158 (void) sprintf(usba_name[n++], 2159 "usb%x.class%x.%x", 2160 usb_dev_descr->idVendor, 2161 usb_dev_descr->bDeviceClass, 2162 usb_dev_descr->bDeviceSubClass); 2163 2164 /* 7. usbVID,classDC */ 2165 (void) sprintf(usba_name[n++], 2166 "usb%x.class%x", 2167 usb_dev_descr->idVendor, 2168 usb_dev_descr->bDeviceClass); 2169 2170 /* 8. usb,classDC.DSC.DPROTO */ 2171 (void) sprintf(usba_name[n++], 2172 "usb,class%x.%x.%x", 2173 usb_dev_descr->bDeviceClass, 2174 usb_dev_descr->bDeviceSubClass, 2175 usb_dev_descr->bDeviceProtocol); 2176 2177 /* 9. usb,classDC.DSC */ 2178 (void) sprintf(usba_name[n++], 2179 "usb,class%x.%x", 2180 usb_dev_descr->bDeviceClass, 2181 usb_dev_descr->bDeviceSubClass); 2182 2183 /* 10. usb,classDC */ 2184 (void) sprintf(usba_name[n++], 2185 "usb,class%x", 2186 usb_dev_descr->bDeviceClass); 2187 } 2188 2189 if (usba_get_ugen_binding(child_dip) == 2190 USBA_UGEN_DEVICE_BINDING) { 2191 /* 11. ugen */ 2192 (void) sprintf(usba_name[n++], "ugen"); 2193 } else { 2194 /* 11. usb,device */ 2195 (void) sprintf(usba_name[n++], "usb,device"); 2196 } 2197 } 2198 2199 for (i = 0; i < n; i += 2) { 2200 USB_DPRINTF_L3(DPRINT_MASK_USBA, usba_log_handle, 2201 "compatible name:\t%s\t%s", usba_name[i], 2202 (((i+1) < n)? usba_name[i+1] : "")); 2203 } 2204 2205 rval = ndi_prop_update_string_array(DDI_DEV_T_NONE, child_dip, 2206 "compatible", (char **)usba_name, n); 2207 2208 kmem_free(usba_name_buf, USBA_MAX_COMPAT_NAMES * 2209 USBA_MAX_COMPAT_NAME_LEN); 2210 2211 if (rval != DDI_PROP_SUCCESS) { 2212 2213 USB_DPRINTF_L2(DPRINT_MASK_USBA, usba_log_handle, 2214 "usba_ready_device_node: property update failed"); 2215 2216 return (child_dip); 2217 } 2218 2219 /* update the address property */ 2220 rval = ndi_prop_update_int(DDI_DEV_T_NONE, child_dip, 2221 "assigned-address", usba_device->usb_addr); 2222 if (rval != DDI_PROP_SUCCESS) { 2223 USB_DPRINTF_L2(DPRINT_MASK_USBA, usba_log_handle, 2224 "usba_ready_device_node: address update failed"); 2225 } 2226 2227 /* update the usb device properties (PSARC/2000/454) */ 2228 rval = ndi_prop_update_int(DDI_DEV_T_NONE, child_dip, 2229 "usb-vendor-id", usb_dev_descr->idVendor); 2230 if (rval != DDI_PROP_SUCCESS) { 2231 USB_DPRINTF_L2(DPRINT_MASK_USBA, usba_log_handle, 2232 "usba_ready_device_node: usb-vendor-id update failed"); 2233 } 2234 2235 rval = ndi_prop_update_int(DDI_DEV_T_NONE, child_dip, 2236 "usb-product-id", usb_dev_descr->idProduct); 2237 if (rval != DDI_PROP_SUCCESS) { 2238 USB_DPRINTF_L2(DPRINT_MASK_USBA, usba_log_handle, 2239 "usba_ready_device_node: usb-product-id update failed"); 2240 } 2241 2242 rval = ndi_prop_update_int(DDI_DEV_T_NONE, child_dip, 2243 "usb-revision-id", usb_dev_descr->bcdDevice); 2244 if (rval != DDI_PROP_SUCCESS) { 2245 USB_DPRINTF_L2(DPRINT_MASK_USBA, usba_log_handle, 2246 "usba_ready_device_node: usb-revision-id update failed"); 2247 } 2248 2249 rval = ndi_prop_update_int(DDI_DEV_T_NONE, child_dip, 2250 "usb-num-configs", usb_dev_descr->bNumConfigurations); 2251 if (rval != DDI_PROP_SUCCESS) { 2252 USB_DPRINTF_L2(DPRINT_MASK_USBA, usba_log_handle, 2253 "usba_ready_device_node: usb-num-configs update failed"); 2254 } 2255 2256 rval = ndi_prop_update_int(DDI_DEV_T_NONE, child_dip, 2257 "usb-release", usb_dev_descr->bcdUSB); 2258 if (rval != DDI_PROP_SUCCESS) { 2259 USB_DPRINTF_L2(DPRINT_MASK_USBA, usba_log_handle, 2260 "usba_ready_device_node: usb-release update failed"); 2261 } 2262 2263 rval = ndi_prop_update_byte_array(DDI_DEV_T_NONE, child_dip, 2264 "usb-dev-descriptor", (uchar_t *)usb_dev_descr, 2265 sizeof (usb_dev_descr_t)); 2266 if (rval != DDI_PROP_SUCCESS) { 2267 USB_DPRINTF_L2(DPRINT_MASK_USBA, usba_log_handle, 2268 "usba_ready_device_node: usb-descriptor update failed"); 2269 } 2270 2271 rval = ndi_prop_update_byte_array(DDI_DEV_T_NONE, child_dip, 2272 "usb-raw-cfg-descriptors", usb_config, usb_config_length); 2273 if (rval != DDI_PROP_SUCCESS) { 2274 USB_DPRINTF_L2(DPRINT_MASK_USBA, usba_log_handle, 2275 "usba_ready_device_node: usb-raw-cfg-descriptors update " 2276 "failed"); 2277 } 2278 2279 devprop_str = kmem_zalloc(USB_MAXSTRINGLEN, KM_SLEEP); 2280 2281 if (usba_device->usb_serialno_str) { 2282 usba_filter_string(usba_device->usb_serialno_str, devprop_str); 2283 rval = ndi_prop_update_string(DDI_DEV_T_NONE, child_dip, 2284 "usb-serialno", devprop_str); 2285 if (rval != DDI_PROP_SUCCESS) { 2286 USB_DPRINTF_L2(DPRINT_MASK_USBA, usba_log_handle, 2287 "usba_ready_device_node: " 2288 "usb-serialno update failed"); 2289 } 2290 } 2291 2292 if (usba_device->usb_mfg_str) { 2293 usba_filter_string(usba_device->usb_mfg_str, devprop_str); 2294 rval = ndi_prop_update_string(DDI_DEV_T_NONE, child_dip, 2295 "usb-vendor-name", devprop_str); 2296 if (rval != DDI_PROP_SUCCESS) { 2297 USB_DPRINTF_L2(DPRINT_MASK_USBA, usba_log_handle, 2298 "usba_ready_device_node: " 2299 "usb-vendor-name update failed"); 2300 } 2301 } 2302 2303 if (usba_device->usb_product_str) { 2304 usba_filter_string(usba_device->usb_product_str, devprop_str); 2305 rval = ndi_prop_update_string(DDI_DEV_T_NONE, child_dip, 2306 "usb-product-name", devprop_str); 2307 if (rval != DDI_PROP_SUCCESS) { 2308 USB_DPRINTF_L2(DPRINT_MASK_USBA, usba_log_handle, 2309 "usba_ready_device_node: " 2310 "usb-product-name update failed"); 2311 } 2312 } 2313 2314 kmem_free(devprop_str, USB_MAXSTRINGLEN); 2315 2316 if (!combined_node) { 2317 /* update the configuration property */ 2318 rval = ndi_prop_update_int(DDI_DEV_T_NONE, child_dip, 2319 "configuration#", usba_device->usb_cfg_value); 2320 if (rval != DDI_PROP_SUCCESS) { 2321 USB_DPRINTF_L2(DPRINT_MASK_USBA, usba_log_handle, 2322 "usba_ready_device_node: " 2323 "config prop update failed"); 2324 } 2325 } 2326 2327 if (usba_device->usb_port_status == USBA_LOW_SPEED_DEV) { 2328 /* create boolean property */ 2329 rval = ndi_prop_create_boolean(DDI_DEV_T_NONE, child_dip, 2330 "low-speed"); 2331 if (rval != DDI_PROP_SUCCESS) { 2332 USB_DPRINTF_L2(DPRINT_MASK_USBA, usba_log_handle, 2333 "usba_ready_device_node: " 2334 "low speed prop update failed"); 2335 } 2336 } 2337 2338 if (usba_device->usb_port_status == USBA_HIGH_SPEED_DEV) { 2339 /* create boolean property */ 2340 rval = ndi_prop_create_boolean(DDI_DEV_T_NONE, child_dip, 2341 "high-speed"); 2342 if (rval != DDI_PROP_SUCCESS) { 2343 USB_DPRINTF_L2(DPRINT_MASK_USBA, usba_log_handle, 2344 "usba_ready_device_node: " 2345 "high speed prop update failed"); 2346 } 2347 } 2348 2349 USB_DPRINTF_L4(DPRINT_MASK_USBA, usba_log_handle, 2350 "%s%d at port %d: %s, dip=0x%p", 2351 ddi_node_name(ddi_get_parent(child_dip)), 2352 ddi_get_instance(ddi_get_parent(child_dip)), 2353 port, ddi_node_name(child_dip), (void *)child_dip); 2354 2355 usba_set_usba_device(child_dip, usba_device); 2356 2357 ASSERT(!mutex_owned(&(usba_get_usba_device(child_dip)->usb_mutex))); 2358 2359 return (child_dip); 2360 } 2361 2362 2363 /* 2364 * driver binding at interface association level. the first arg is the parent 2365 * dip. if_count returns amount of interfaces which are associated within 2366 * this interface-association that starts from first_if. 2367 */ 2368 /*ARGSUSED*/ 2369 dev_info_t * 2370 usba_ready_interface_association_node(dev_info_t *dip, 2371 uint_t first_if, 2372 uint_t *if_count) 2373 { 2374 dev_info_t *child_dip = NULL; 2375 usba_device_t *child_ud = usba_get_usba_device(dip); 2376 usb_dev_descr_t *usb_dev_descr; 2377 size_t usb_cfg_length; 2378 uchar_t *usb_cfg; 2379 usb_ia_descr_t ia_descr; 2380 int i, n, rval; 2381 int reg[2]; 2382 size_t size; 2383 usb_port_status_t port_status; 2384 char *force_bind = NULL; 2385 char *usba_name_buf = NULL; 2386 char *usba_name[USBA_MAX_COMPAT_NAMES]; 2387 2388 usb_cfg = usb_get_raw_cfg_data(dip, &usb_cfg_length); 2389 2390 mutex_enter(&child_ud->usb_mutex); 2391 2392 usb_dev_descr = child_ud->usb_dev_descr; 2393 2394 /* 2395 * for each interface association, determine all compatible names 2396 */ 2397 USB_DPRINTF_L3(DPRINT_MASK_USBA, usba_log_handle, 2398 "usba_ready_ia_node: " 2399 "port %d, interface = %d, port_status = %x", 2400 child_ud->usb_port, first_if, child_ud->usb_port_status); 2401 2402 /* Parse the interface descriptor */ 2403 size = usb_parse_ia_descr( 2404 usb_cfg, 2405 usb_cfg_length, 2406 first_if, /* interface index */ 2407 &ia_descr, 2408 USB_IA_DESCR_SIZE); 2409 2410 *if_count = 1; 2411 if (size != USB_IA_DESCR_SIZE) { 2412 USB_DPRINTF_L2(DPRINT_MASK_USBA, usba_log_handle, 2413 "parsing ia: size (%lu) != USB_IA_DESCR_SIZE (%d)", 2414 size, USB_IA_DESCR_SIZE); 2415 mutex_exit(&child_ud->usb_mutex); 2416 2417 return (NULL); 2418 } 2419 2420 port_status = child_ud->usb_port_status; 2421 2422 /* create reg property */ 2423 reg[0] = first_if; 2424 reg[1] = child_ud->usb_cfg_value; 2425 2426 mutex_exit(&child_ud->usb_mutex); 2427 2428 /* clone this dip */ 2429 rval = usba_create_child_devi(dip, 2430 "interface-association", 2431 NULL, /* usba_hcdi ops */ 2432 NULL, /* root hub dip */ 2433 port_status, /* port status */ 2434 child_ud, /* share this usba_device */ 2435 &child_dip); 2436 2437 if (rval != USB_SUCCESS) { 2438 2439 goto fail; 2440 } 2441 2442 rval = ndi_prop_update_int_array( 2443 DDI_DEV_T_NONE, child_dip, "reg", reg, 2); 2444 2445 if (rval != DDI_PROP_SUCCESS) { 2446 2447 goto fail; 2448 } 2449 2450 usba_set_node_name(child_dip, ia_descr.bFunctionClass, 2451 ia_descr.bFunctionSubClass, ia_descr.bFunctionProtocol, 2452 FLAG_INTERFACE_ASSOCIATION_NODE); 2453 2454 /* check force binding */ 2455 if (usba_ugen_force_binding == 2456 USBA_UGEN_INTERFACE_ASSOCIATION_BINDING) { 2457 force_bind = "ugen"; 2458 } 2459 2460 /* 2461 * check whether there is another dip with this name and address 2462 */ 2463 ASSERT(usba_find_existing_node(child_dip) == NULL); 2464 2465 usba_name_buf = kmem_zalloc(USBA_MAX_COMPAT_NAMES * 2466 USBA_MAX_COMPAT_NAME_LEN, KM_SLEEP); 2467 2468 for (i = 0; i < USBA_MAX_COMPAT_NAMES; i++) { 2469 usba_name[i] = usba_name_buf + (i * USBA_MAX_COMPAT_NAME_LEN); 2470 } 2471 2472 n = 0; 2473 2474 if (force_bind) { 2475 (void) ndi_devi_set_nodename(child_dip, force_bind, 0); 2476 (void) strncpy(usba_name[n++], force_bind, 2477 USBA_MAX_COMPAT_NAME_LEN); 2478 } 2479 2480 /* 1) usbiaVID,PID.REV.configCN.FN */ 2481 (void) sprintf(usba_name[n++], 2482 "usbia%x,%x.%x.config%x.%x", 2483 usb_dev_descr->idVendor, 2484 usb_dev_descr->idProduct, 2485 usb_dev_descr->bcdDevice, 2486 child_ud->usb_cfg_value, 2487 first_if); 2488 2489 /* 2) usbiaVID,PID.configCN.FN */ 2490 (void) sprintf(usba_name[n++], 2491 "usbia%x,%x.config%x.%x", 2492 usb_dev_descr->idVendor, 2493 usb_dev_descr->idProduct, 2494 child_ud->usb_cfg_value, 2495 first_if); 2496 2497 2498 if (ia_descr.bFunctionClass) { 2499 /* 3) usbiaVID,classFC.FSC.FPROTO */ 2500 (void) sprintf(usba_name[n++], 2501 "usbia%x,class%x.%x.%x", 2502 usb_dev_descr->idVendor, 2503 ia_descr.bFunctionClass, 2504 ia_descr.bFunctionSubClass, 2505 ia_descr.bFunctionProtocol); 2506 2507 /* 4) usbiaVID,classFC.FSC */ 2508 (void) sprintf(usba_name[n++], 2509 "usbia%x,class%x.%x", 2510 usb_dev_descr->idVendor, 2511 ia_descr.bFunctionClass, 2512 ia_descr.bFunctionSubClass); 2513 2514 /* 5) usbiaVID,classFC */ 2515 (void) sprintf(usba_name[n++], 2516 "usbia%x,class%x", 2517 usb_dev_descr->idVendor, 2518 ia_descr.bFunctionClass); 2519 2520 /* 6) usbia,classFC.FSC.FPROTO */ 2521 (void) sprintf(usba_name[n++], 2522 "usbia,class%x.%x.%x", 2523 ia_descr.bFunctionClass, 2524 ia_descr.bFunctionSubClass, 2525 ia_descr.bFunctionProtocol); 2526 2527 /* 7) usbia,classFC.FSC */ 2528 (void) sprintf(usba_name[n++], 2529 "usbia,class%x.%x", 2530 ia_descr.bFunctionClass, 2531 ia_descr.bFunctionSubClass); 2532 2533 /* 8) usbia,classFC */ 2534 (void) sprintf(usba_name[n++], 2535 "usbia,class%x", 2536 ia_descr.bFunctionClass); 2537 } 2538 2539 if (usba_get_ugen_binding(child_dip) == 2540 USBA_UGEN_INTERFACE_ASSOCIATION_BINDING) { 2541 /* 9) ugen */ 2542 (void) sprintf(usba_name[n++], "ugen"); 2543 } else { 2544 2545 (void) sprintf(usba_name[n++], "usb,ia"); 2546 } 2547 2548 for (i = 0; i < n; i += 2) { 2549 USB_DPRINTF_L3(DPRINT_MASK_USBA, usba_log_handle, 2550 "compatible name:\t%s\t%s", usba_name[i], 2551 (((i+1) < n)? usba_name[i+1] : "")); 2552 } 2553 2554 /* create compatible property */ 2555 rval = ndi_prop_update_string_array(DDI_DEV_T_NONE, child_dip, 2556 "compatible", (char **)usba_name, n); 2557 2558 kmem_free(usba_name_buf, USBA_MAX_COMPAT_NAMES * 2559 USBA_MAX_COMPAT_NAME_LEN); 2560 2561 if (rval != DDI_PROP_SUCCESS) { 2562 2563 goto fail; 2564 } 2565 2566 /* update the address property */ 2567 rval = ndi_prop_update_int(DDI_DEV_T_NONE, child_dip, 2568 "assigned-address", child_ud->usb_addr); 2569 if (rval != DDI_PROP_SUCCESS) { 2570 USB_DPRINTF_L2(DPRINT_MASK_USBA, usba_log_handle, 2571 "usba_ready_interface_node: address update failed"); 2572 } 2573 2574 /* create property with first interface number */ 2575 rval = ndi_prop_update_int(DDI_DEV_T_NONE, child_dip, 2576 "interface", ia_descr.bFirstInterface); 2577 2578 if (rval != DDI_PROP_SUCCESS) { 2579 2580 goto fail; 2581 } 2582 2583 /* create property with the count of interfaces in this ia */ 2584 rval = ndi_prop_update_int(DDI_DEV_T_NONE, child_dip, 2585 "interface-count", ia_descr.bInterfaceCount); 2586 2587 if (rval != DDI_PROP_SUCCESS) { 2588 2589 goto fail; 2590 } 2591 2592 USB_DPRINTF_L2(DPRINT_MASK_USBA, usba_log_handle, 2593 "%s%d port %d: %s, dip = 0x%p", 2594 ddi_node_name(ddi_get_parent(dip)), 2595 ddi_get_instance(ddi_get_parent(dip)), 2596 child_ud->usb_port, ddi_node_name(child_dip), (void *)child_dip); 2597 2598 *if_count = ia_descr.bInterfaceCount; 2599 usba_set_usba_device(child_dip, child_ud); 2600 ASSERT(!mutex_owned(&(usba_get_usba_device(child_dip)->usb_mutex))); 2601 2602 return (child_dip); 2603 2604 fail: 2605 (void) usba_destroy_child_devi(child_dip, NDI_DEVI_REMOVE); 2606 2607 return (NULL); 2608 } 2609 2610 2611 /* 2612 * driver binding at interface level, the first arg will be the 2613 * the parent dip 2614 */ 2615 /*ARGSUSED*/ 2616 dev_info_t * 2617 usba_ready_interface_node(dev_info_t *dip, uint_t intf) 2618 { 2619 dev_info_t *child_dip = NULL; 2620 usba_device_t *child_ud = usba_get_usba_device(dip); 2621 usb_dev_descr_t *usb_dev_descr; 2622 size_t usb_cfg_length; 2623 uchar_t *usb_cfg; 2624 usb_if_descr_t if_descr; 2625 int i, n, rval; 2626 int reg[2]; 2627 size_t size; 2628 usb_port_status_t port_status; 2629 char *force_bind = NULL; 2630 char *usba_name_buf = NULL; 2631 char *usba_name[USBA_MAX_COMPAT_NAMES]; 2632 2633 usb_cfg = usb_get_raw_cfg_data(dip, &usb_cfg_length); 2634 2635 mutex_enter(&child_ud->usb_mutex); 2636 2637 usb_dev_descr = child_ud->usb_dev_descr; 2638 2639 /* 2640 * for each interface, determine all compatible names 2641 */ 2642 USB_DPRINTF_L3(DPRINT_MASK_USBA, usba_log_handle, 2643 "usba_ready_interface_node: " 2644 "port %d, interface = %d port status = %x", 2645 child_ud->usb_port, intf, child_ud->usb_port_status); 2646 2647 /* Parse the interface descriptor */ 2648 size = usb_parse_if_descr( 2649 usb_cfg, 2650 usb_cfg_length, 2651 intf, /* interface index */ 2652 0, /* alt interface index */ 2653 &if_descr, 2654 USB_IF_DESCR_SIZE); 2655 2656 if (size != USB_IF_DESCR_SIZE) { 2657 USB_DPRINTF_L2(DPRINT_MASK_USBA, usba_log_handle, 2658 "parsing interface: size (%lu) != USB_IF_DESCR_SIZE (%d)", 2659 size, USB_IF_DESCR_SIZE); 2660 mutex_exit(&child_ud->usb_mutex); 2661 2662 return (NULL); 2663 } 2664 2665 port_status = child_ud->usb_port_status; 2666 2667 /* create reg property */ 2668 reg[0] = intf; 2669 reg[1] = child_ud->usb_cfg_value; 2670 2671 mutex_exit(&child_ud->usb_mutex); 2672 2673 /* clone this dip */ 2674 rval = usba_create_child_devi(dip, 2675 "interface", 2676 NULL, /* usba_hcdi ops */ 2677 NULL, /* root hub dip */ 2678 port_status, /* port status */ 2679 child_ud, /* share this usba_device */ 2680 &child_dip); 2681 2682 if (rval != USB_SUCCESS) { 2683 2684 goto fail; 2685 } 2686 2687 rval = ndi_prop_update_int_array( 2688 DDI_DEV_T_NONE, child_dip, "reg", reg, 2); 2689 2690 if (rval != DDI_PROP_SUCCESS) { 2691 2692 goto fail; 2693 } 2694 2695 usba_set_node_name(child_dip, if_descr.bInterfaceClass, 2696 if_descr.bInterfaceSubClass, if_descr.bInterfaceProtocol, 2697 FLAG_INTERFACE_NODE); 2698 2699 /* check force binding */ 2700 if (usba_ugen_force_binding == USBA_UGEN_INTERFACE_BINDING) { 2701 force_bind = "ugen"; 2702 } 2703 2704 /* 2705 * check whether there is another dip with this name and address 2706 */ 2707 ASSERT(usba_find_existing_node(child_dip) == NULL); 2708 2709 usba_name_buf = kmem_zalloc(USBA_MAX_COMPAT_NAMES * 2710 USBA_MAX_COMPAT_NAME_LEN, KM_SLEEP); 2711 2712 for (i = 0; i < USBA_MAX_COMPAT_NAMES; i++) { 2713 usba_name[i] = usba_name_buf + (i * USBA_MAX_COMPAT_NAME_LEN); 2714 } 2715 2716 n = 0; 2717 2718 if (force_bind) { 2719 (void) ndi_devi_set_nodename(child_dip, force_bind, 0); 2720 (void) strncpy(usba_name[n++], force_bind, 2721 USBA_MAX_COMPAT_NAME_LEN); 2722 } 2723 2724 /* 1) usbifVID,PID.REV.configCN.IN */ 2725 (void) sprintf(usba_name[n++], 2726 "usbif%x,%x.%x.config%x.%x", 2727 usb_dev_descr->idVendor, 2728 usb_dev_descr->idProduct, 2729 usb_dev_descr->bcdDevice, 2730 child_ud->usb_cfg_value, 2731 intf); 2732 2733 /* 2) usbifVID,PID.configCN.IN */ 2734 (void) sprintf(usba_name[n++], 2735 "usbif%x,%x.config%x.%x", 2736 usb_dev_descr->idVendor, 2737 usb_dev_descr->idProduct, 2738 child_ud->usb_cfg_value, 2739 intf); 2740 2741 2742 if (if_descr.bInterfaceClass) { 2743 /* 3) usbifVID,classIC.ISC.IPROTO */ 2744 (void) sprintf(usba_name[n++], 2745 "usbif%x,class%x.%x.%x", 2746 usb_dev_descr->idVendor, 2747 if_descr.bInterfaceClass, 2748 if_descr.bInterfaceSubClass, 2749 if_descr.bInterfaceProtocol); 2750 2751 /* 4) usbifVID,classIC.ISC */ 2752 (void) sprintf(usba_name[n++], 2753 "usbif%x,class%x.%x", 2754 usb_dev_descr->idVendor, 2755 if_descr.bInterfaceClass, 2756 if_descr.bInterfaceSubClass); 2757 2758 /* 5) usbifVID,classIC */ 2759 (void) sprintf(usba_name[n++], 2760 "usbif%x,class%x", 2761 usb_dev_descr->idVendor, 2762 if_descr.bInterfaceClass); 2763 2764 /* 6) usbif,classIC.ISC.IPROTO */ 2765 (void) sprintf(usba_name[n++], 2766 "usbif,class%x.%x.%x", 2767 if_descr.bInterfaceClass, 2768 if_descr.bInterfaceSubClass, 2769 if_descr.bInterfaceProtocol); 2770 2771 /* 7) usbif,classIC.ISC */ 2772 (void) sprintf(usba_name[n++], 2773 "usbif,class%x.%x", 2774 if_descr.bInterfaceClass, 2775 if_descr.bInterfaceSubClass); 2776 2777 /* 8) usbif,classIC */ 2778 (void) sprintf(usba_name[n++], 2779 "usbif,class%x", 2780 if_descr.bInterfaceClass); 2781 } 2782 2783 if (usba_get_ugen_binding(child_dip) == 2784 USBA_UGEN_INTERFACE_BINDING) { 2785 /* 9) ugen */ 2786 (void) sprintf(usba_name[n++], "ugen"); 2787 } 2788 2789 for (i = 0; i < n; i += 2) { 2790 USB_DPRINTF_L3(DPRINT_MASK_USBA, usba_log_handle, 2791 "compatible name:\t%s\t%s", usba_name[i], 2792 (((i+1) < n)? usba_name[i+1] : "")); 2793 } 2794 2795 /* create compatible property */ 2796 rval = ndi_prop_update_string_array(DDI_DEV_T_NONE, child_dip, 2797 "compatible", (char **)usba_name, n); 2798 2799 kmem_free(usba_name_buf, USBA_MAX_COMPAT_NAMES * 2800 USBA_MAX_COMPAT_NAME_LEN); 2801 2802 if (rval != DDI_PROP_SUCCESS) { 2803 2804 goto fail; 2805 } 2806 2807 /* update the address property */ 2808 rval = ndi_prop_update_int(DDI_DEV_T_NONE, child_dip, 2809 "assigned-address", child_ud->usb_addr); 2810 if (rval != DDI_PROP_SUCCESS) { 2811 USB_DPRINTF_L2(DPRINT_MASK_USBA, usba_log_handle, 2812 "usba_ready_interface_node: address update failed"); 2813 } 2814 2815 /* create property with if number */ 2816 rval = ndi_prop_update_int(DDI_DEV_T_NONE, child_dip, 2817 "interface", intf); 2818 2819 if (rval != DDI_PROP_SUCCESS) { 2820 2821 goto fail; 2822 } 2823 2824 USB_DPRINTF_L2(DPRINT_MASK_USBA, usba_log_handle, 2825 "%s%d port %d: %s, dip = 0x%p", 2826 ddi_node_name(ddi_get_parent(dip)), 2827 ddi_get_instance(ddi_get_parent(dip)), 2828 child_ud->usb_port, ddi_node_name(child_dip), (void *)child_dip); 2829 2830 usba_set_usba_device(child_dip, child_ud); 2831 ASSERT(!mutex_owned(&(usba_get_usba_device(child_dip)->usb_mutex))); 2832 2833 return (child_dip); 2834 2835 fail: 2836 (void) usba_destroy_child_devi(child_dip, NDI_DEVI_REMOVE); 2837 2838 return (NULL); 2839 } 2840 2841 2842 /* 2843 * retrieve string descriptors for manufacturer, vendor and serial 2844 * number 2845 */ 2846 void 2847 usba_get_dev_string_descrs(dev_info_t *dip, usba_device_t *ud) 2848 { 2849 char *tmpbuf, *str; 2850 int l; 2851 usb_dev_descr_t *usb_dev_descr = ud->usb_dev_descr; 2852 2853 2854 USB_DPRINTF_L4(DPRINT_MASK_USBA, usba_log_handle, 2855 "usba_get_usb_string_descr: m=%d, p=%d, s=%d", 2856 usb_dev_descr->iManufacturer, 2857 usb_dev_descr->iProduct, 2858 usb_dev_descr->iSerialNumber); 2859 2860 tmpbuf = kmem_zalloc(USB_MAXSTRINGLEN, KM_SLEEP); 2861 2862 /* fetch manufacturer string */ 2863 if ((ud->usb_mfg_str == NULL) && usb_dev_descr->iManufacturer && 2864 (usb_get_string_descr(dip, USB_LANG_ID, 2865 usb_dev_descr->iManufacturer, tmpbuf, USB_MAXSTRINGLEN) == 2866 USB_SUCCESS)) { 2867 2868 l = strlen(tmpbuf); 2869 if (l > 0) { 2870 str = kmem_zalloc(l + 1, KM_SLEEP); 2871 mutex_enter(&ud->usb_mutex); 2872 ud->usb_mfg_str = str; 2873 (void) strcpy(ud->usb_mfg_str, tmpbuf); 2874 mutex_exit(&ud->usb_mutex); 2875 } 2876 } 2877 2878 /* fetch product string */ 2879 if ((ud->usb_product_str == NULL) && usb_dev_descr->iProduct && 2880 (usb_get_string_descr(dip, USB_LANG_ID, usb_dev_descr->iProduct, 2881 tmpbuf, USB_MAXSTRINGLEN) == 2882 USB_SUCCESS)) { 2883 2884 l = strlen(tmpbuf); 2885 if (l > 0) { 2886 str = kmem_zalloc(l + 1, KM_SLEEP); 2887 mutex_enter(&ud->usb_mutex); 2888 ud->usb_product_str = str; 2889 (void) strcpy(ud->usb_product_str, tmpbuf); 2890 mutex_exit(&ud->usb_mutex); 2891 } 2892 } 2893 2894 /* fetch device serial number string */ 2895 if ((ud->usb_serialno_str == NULL) && usb_dev_descr->iSerialNumber && 2896 (usb_get_string_descr(dip, USB_LANG_ID, 2897 usb_dev_descr->iSerialNumber, tmpbuf, USB_MAXSTRINGLEN) == 2898 USB_SUCCESS)) { 2899 2900 l = strlen(tmpbuf); 2901 if (l > 0) { 2902 str = kmem_zalloc(l + 1, KM_SLEEP); 2903 mutex_enter(&ud->usb_mutex); 2904 ud->usb_serialno_str = str; 2905 (void) strcpy(ud->usb_serialno_str, tmpbuf); 2906 mutex_exit(&ud->usb_mutex); 2907 } 2908 } 2909 2910 kmem_free(tmpbuf, USB_MAXSTRINGLEN); 2911 } 2912 2913 2914 /* 2915 * usba_str_startcmp: 2916 * Return the number of characters duplicated from the beginning of the 2917 * string. Return -1 if a complete duplicate. 2918 * 2919 * Arguments: 2920 * Two strings to compare. 2921 */ 2922 static int usba_str_startcmp(char *first, char *second) 2923 { 2924 int num_same_chars = 0; 2925 while (*first == *second++) { 2926 if (*first++ == '\0') { 2927 return (-1); 2928 } 2929 num_same_chars++; 2930 } 2931 2932 return (num_same_chars); 2933 } 2934 2935 2936 /* 2937 * usba_get_mfg_prod_sn_str: 2938 * Return a string containing mfg, product, serial number strings. 2939 * Remove duplicates if some strings are the same. 2940 * 2941 * Arguments: 2942 * dip - pointer to dev info 2943 * buffer - Where string is returned 2944 * buflen - Length of buffer 2945 * 2946 * Returns: 2947 * Same as second arg. 2948 */ 2949 char * 2950 usba_get_mfg_prod_sn_str( 2951 dev_info_t *dip, 2952 char *buffer, 2953 int buflen) 2954 { 2955 usba_device_t *usba_device = usba_get_usba_device(dip); 2956 int return_len = 0; 2957 int len = 0; 2958 int duplen; 2959 2960 buffer[0] = '\0'; 2961 buffer[buflen-1] = '\0'; 2962 2963 if ((usba_device->usb_mfg_str) && 2964 ((len = strlen(usba_device->usb_mfg_str)) != 0)) { 2965 (void) strncpy(buffer, usba_device->usb_mfg_str, buflen - 1); 2966 return_len = min(buflen - 1, len); 2967 } 2968 2969 /* Product string exists to append. */ 2970 if ((usba_device->usb_product_str) && 2971 ((len = strlen(usba_device->usb_product_str)) != 0)) { 2972 2973 /* Append only parts of string that don't match mfg string. */ 2974 duplen = usba_str_startcmp(buffer, 2975 usba_device->usb_product_str); 2976 2977 if (duplen != -1) { /* Not a complete match. */ 2978 if (return_len > 0) { 2979 buffer[return_len++] = ' '; 2980 } 2981 2982 /* Skip over the dup part of the concat'ed string. */ 2983 len -= duplen; 2984 (void) strncpy(&buffer[return_len], 2985 &usba_device->usb_product_str[duplen], 2986 buflen - return_len - 1); 2987 return_len = min(buflen - 1, return_len + len); 2988 } 2989 } 2990 2991 if ((usba_device->usb_serialno_str) && 2992 ((len = strlen(usba_device->usb_serialno_str)) != 0)) { 2993 if (return_len > 0) { 2994 buffer[return_len++] = ' '; 2995 } 2996 (void) strncpy(&buffer[return_len], 2997 usba_device->usb_serialno_str, 2998 buflen - return_len - 1); 2999 } 3000 3001 return (buffer); 3002 } 3003 3004 3005 /* 3006 * USB enumeration statistic functions 3007 */ 3008 3009 /* 3010 * Increments the hotplug statistics based on flags. 3011 */ 3012 void 3013 usba_update_hotplug_stats(dev_info_t *dip, usb_flags_t flags) 3014 { 3015 usba_device_t *usba_device = usba_get_usba_device(dip); 3016 usba_hcdi_t *hcdi = 3017 usba_hcdi_get_hcdi(usba_device->usb_root_hub_dip); 3018 3019 mutex_enter(&hcdi->hcdi_mutex); 3020 if (flags & USBA_TOTAL_HOTPLUG_SUCCESS) { 3021 hcdi->hcdi_total_hotplug_success++; 3022 HCDI_HOTPLUG_STATS_DATA(hcdi)-> 3023 hcdi_hotplug_total_success.value.ui64++; 3024 } 3025 if (flags & USBA_HOTPLUG_SUCCESS) { 3026 hcdi->hcdi_hotplug_success++; 3027 HCDI_HOTPLUG_STATS_DATA(hcdi)-> 3028 hcdi_hotplug_success.value.ui64++; 3029 } 3030 if (flags & USBA_TOTAL_HOTPLUG_FAILURE) { 3031 hcdi->hcdi_total_hotplug_failure++; 3032 HCDI_HOTPLUG_STATS_DATA(hcdi)-> 3033 hcdi_hotplug_total_failure.value.ui64++; 3034 } 3035 if (flags & USBA_HOTPLUG_FAILURE) { 3036 hcdi->hcdi_hotplug_failure++; 3037 HCDI_HOTPLUG_STATS_DATA(hcdi)-> 3038 hcdi_hotplug_failure.value.ui64++; 3039 } 3040 mutex_exit(&hcdi->hcdi_mutex); 3041 } 3042 3043 3044 /* 3045 * Retrieve the current enumeration statistics 3046 */ 3047 void 3048 usba_get_hotplug_stats(dev_info_t *dip, ulong_t *total_success, 3049 ulong_t *success, ulong_t *total_failure, ulong_t *failure, 3050 uchar_t *device_count) 3051 { 3052 usba_device_t *usba_device = usba_get_usba_device(dip); 3053 usba_hcdi_t *hcdi = 3054 usba_hcdi_get_hcdi(usba_device->usb_root_hub_dip); 3055 3056 mutex_enter(&hcdi->hcdi_mutex); 3057 *total_success = hcdi->hcdi_total_hotplug_success; 3058 *success = hcdi->hcdi_hotplug_success; 3059 *total_failure = hcdi->hcdi_total_hotplug_failure; 3060 *failure = hcdi->hcdi_hotplug_failure; 3061 *device_count = hcdi->hcdi_device_count; 3062 mutex_exit(&hcdi->hcdi_mutex); 3063 } 3064 3065 3066 /* 3067 * Reset the resetable hotplug stats 3068 */ 3069 void 3070 usba_reset_hotplug_stats(dev_info_t *dip) 3071 { 3072 usba_device_t *usba_device = usba_get_usba_device(dip); 3073 usba_hcdi_t *hcdi = 3074 usba_hcdi_get_hcdi(usba_device->usb_root_hub_dip); 3075 hcdi_hotplug_stats_t *hsp; 3076 3077 mutex_enter(&hcdi->hcdi_mutex); 3078 hcdi->hcdi_hotplug_success = 0; 3079 hcdi->hcdi_hotplug_failure = 0; 3080 3081 hsp = HCDI_HOTPLUG_STATS_DATA(hcdi); 3082 hsp->hcdi_hotplug_success.value.ui64 = 0; 3083 hsp->hcdi_hotplug_failure.value.ui64 = 0; 3084 mutex_exit(&hcdi->hcdi_mutex); 3085 } 3086 3087 3088 /* 3089 * usba_bind_driver(): 3090 * This function calls ndi_devi_bind_driver() which tries to 3091 * bind a driver to the device. If the driver binding fails 3092 * we get an rval of NDI_UNBOUD and report an error to the 3093 * syslog that the driver failed binding. 3094 * If rval is something other than NDI_UNBOUND we report an 3095 * error to the console. 3096 * 3097 * This function returns USB_SUCCESS if no errors were 3098 * encountered while binding. 3099 */ 3100 int 3101 usba_bind_driver(dev_info_t *dip) 3102 { 3103 int rval; 3104 char *name; 3105 uint8_t if_num = usba_get_ifno(dip); 3106 3107 USB_DPRINTF_L4(DPRINT_MASK_USBA, usba_log_handle, 3108 "usba_bind_driver: dip = 0x%p, if_num = 0x%x", (void *)dip, if_num); 3109 3110 name = kmem_zalloc(MAXNAMELEN, KM_SLEEP); 3111 3112 /* bind device to the driver */ 3113 if ((rval = ndi_devi_bind_driver(dip, 0)) != NDI_SUCCESS) { 3114 /* if we fail to bind report an error */ 3115 (void) usba_get_mfg_prod_sn_str(dip, name, MAXNAMELEN); 3116 if (name[0] != '\0') { 3117 if (!usb_owns_device(dip)) { 3118 USB_DPRINTF_L1(DPRINT_MASK_USBA, 3119 usba_log_handle, 3120 "no driver found for " 3121 "interface %d (nodename: '%s') of %s", 3122 if_num, ddi_node_name(dip), name); 3123 } else { 3124 USB_DPRINTF_L1(DPRINT_MASK_USBA, 3125 usba_log_handle, 3126 "no driver found for device %s", name); 3127 } 3128 } else { 3129 (void) ddi_pathname(dip, name); 3130 USB_DPRINTF_L1(DPRINT_MASK_USBA, 3131 usba_log_handle, 3132 "no driver found for device %s", name); 3133 } 3134 3135 kmem_free(name, MAXNAMELEN); 3136 3137 return (USB_FAILURE); 3138 } 3139 kmem_free(name, MAXNAMELEN); 3140 3141 return ((rval == NDI_SUCCESS) ? USB_SUCCESS : USB_FAILURE); 3142 } 3143 3144 3145 /* 3146 * usba_get_hc_dma_attr: 3147 * function returning dma attributes of the HCD 3148 * 3149 * Arguments: 3150 * dip - pointer to devinfo of the client 3151 * 3152 * Return Values: 3153 * hcdi_dma_attr 3154 */ 3155 ddi_dma_attr_t * 3156 usba_get_hc_dma_attr(dev_info_t *dip) 3157 { 3158 usba_device_t *usba_device = usba_get_usba_device(dip); 3159 usba_hcdi_t *hcdi = usba_hcdi_get_hcdi(usba_device->usb_root_hub_dip); 3160 3161 return (hcdi->hcdi_dma_attr); 3162 } 3163 3164 3165 /* 3166 * usba_check_for_leaks: 3167 * check usba_device structure for leaks 3168 * 3169 * Arguments: 3170 * usba_device - usba_device structure pointer 3171 */ 3172 void 3173 usba_check_for_leaks(usba_device_t *usba_device) 3174 { 3175 int i, ph_open_cnt, req_wrp_leaks, iface; 3176 int leaks = 0; 3177 3178 USB_DPRINTF_L4(DPRINT_MASK_USBA, usba_log_handle, 3179 "usba_check_for_leaks: %s%d usba_device=0x%p", 3180 ddi_driver_name(usba_device->usb_dip), 3181 ddi_get_instance(usba_device->usb_dip), (void *)usba_device); 3182 3183 /* 3184 * default pipe is still open 3185 * all other pipes should be closed 3186 */ 3187 for (ph_open_cnt = 0, i = 1; i < USBA_N_ENDPOINTS; i++) { 3188 usba_ph_impl_t *ph_impl = 3189 &usba_device->usb_ph_list[i]; 3190 if (ph_impl->usba_ph_data) { 3191 USB_DPRINTF_L2(DPRINT_MASK_USBA, 3192 usba_log_handle, 3193 "%s%d: leaking pipehandle=0x%p (0x%p) ep_addr=0x%x", 3194 ddi_driver_name(ph_impl->usba_ph_data->p_dip), 3195 ddi_get_instance(ph_impl->usba_ph_data->p_dip), 3196 (void *)ph_impl, 3197 (void *)ph_impl->usba_ph_data, 3198 ph_impl->usba_ph_ep.bEndpointAddress); 3199 ph_open_cnt++; 3200 leaks++; 3201 #ifndef DEBUG 3202 usb_pipe_close(ph_impl->usba_ph_data->p_dip, 3203 (usb_pipe_handle_t)ph_impl, USB_FLAGS_SLEEP, 3204 NULL, NULL); 3205 #endif 3206 } 3207 } 3208 req_wrp_leaks = usba_list_entry_leaks(&usba_device-> 3209 usb_allocated, "request wrappers"); 3210 3211 ASSERT(ph_open_cnt == 0); 3212 ASSERT(req_wrp_leaks == 0); 3213 3214 if (req_wrp_leaks) { 3215 usba_list_entry_t *entry; 3216 3217 while ((entry = usba_rm_first_from_list( 3218 &usba_device->usb_allocated)) != NULL) { 3219 usba_req_wrapper_t *wrp; 3220 3221 mutex_enter(&entry->list_mutex); 3222 wrp = (usba_req_wrapper_t *)entry->private; 3223 mutex_exit(&entry->list_mutex); 3224 leaks++; 3225 3226 USB_DPRINTF_L2(DPRINT_MASK_USBA, 3227 usba_log_handle, 3228 "%s%d: leaking request 0x%p", 3229 ddi_driver_name(wrp->wr_dip), 3230 ddi_get_instance(wrp->wr_dip), 3231 (void *)wrp->wr_req); 3232 3233 /* 3234 * put it back, usba_req_wrapper_free 3235 * expects it on the list 3236 */ 3237 usba_add_to_list(&usba_device->usb_allocated, 3238 &wrp->wr_allocated_list); 3239 3240 usba_req_wrapper_free(wrp); 3241 } 3242 } 3243 3244 mutex_enter(&usba_device->usb_mutex); 3245 for (iface = 0; iface < usba_device->usb_n_ifs; iface++) { 3246 USB_DPRINTF_L3(DPRINT_MASK_USBA, usba_log_handle, 3247 "usba_check_for_leaks: if=%d client_flags=0x%x", 3248 iface, usba_device->usb_client_flags[iface]); 3249 3250 if (usba_device->usb_client_flags[iface] & 3251 USBA_CLIENT_FLAG_DEV_DATA) { 3252 usb_client_dev_data_list_t *entry = 3253 usba_device->usb_client_dev_data_list.cddl_next; 3254 usb_client_dev_data_list_t *next; 3255 usb_client_dev_data_t *dev_data; 3256 3257 while (entry) { 3258 dev_info_t *dip = entry->cddl_dip; 3259 next = entry->cddl_next; 3260 dev_data = entry->cddl_dev_data; 3261 3262 3263 if (!i_ddi_devi_attached(dip)) { 3264 USB_DPRINTF_L2(DPRINT_MASK_USBA, 3265 usba_log_handle, 3266 "%s%d: leaking dev_data 0x%p", 3267 ddi_driver_name(dip), 3268 ddi_get_instance(dip), 3269 (void *)dev_data); 3270 3271 leaks++; 3272 3273 mutex_exit(&usba_device->usb_mutex); 3274 usb_free_dev_data(dip, dev_data); 3275 mutex_enter(&usba_device->usb_mutex); 3276 } 3277 3278 entry = next; 3279 } 3280 } 3281 if (usba_device->usb_client_flags[iface] & 3282 USBA_CLIENT_FLAG_ATTACH) { 3283 dev_info_t *dip = usba_device-> 3284 usb_client_attach_list[iface].dip; 3285 3286 USB_DPRINTF_L2(DPRINT_MASK_USBA, 3287 usba_log_handle, 3288 "%s%d: did no usb_client_detach", 3289 ddi_driver_name(dip), ddi_get_instance(dip)); 3290 leaks++; 3291 3292 mutex_exit(&usba_device->usb_mutex); 3293 usb_client_detach(dip, NULL); 3294 mutex_enter(&usba_device->usb_mutex); 3295 3296 usba_device-> 3297 usb_client_attach_list[iface].dip = NULL; 3298 3299 usba_device->usb_client_flags[iface] &= 3300 ~USBA_CLIENT_FLAG_ATTACH; 3301 3302 } 3303 if (usba_device->usb_client_flags[iface] & 3304 USBA_CLIENT_FLAG_EV_CBS) { 3305 dev_info_t *dip = 3306 usba_device->usb_client_ev_cb_list[iface]. 3307 dip; 3308 usb_event_t *ev_data = 3309 usba_device->usb_client_ev_cb_list[iface]. 3310 ev_data; 3311 3312 USB_DPRINTF_L2(DPRINT_MASK_USBA, 3313 usba_log_handle, 3314 "%s%d: did no usb_unregister_event_cbs", 3315 ddi_driver_name(dip), ddi_get_instance(dip)); 3316 leaks++; 3317 3318 mutex_exit(&usba_device->usb_mutex); 3319 usb_unregister_event_cbs(dip, ev_data); 3320 mutex_enter(&usba_device->usb_mutex); 3321 3322 usba_device->usb_client_ev_cb_list[iface]. 3323 dip = NULL; 3324 usba_device->usb_client_ev_cb_list[iface]. 3325 ev_data = NULL; 3326 usba_device->usb_client_flags[iface] &= 3327 ~USBA_CLIENT_FLAG_EV_CBS; 3328 } 3329 } 3330 mutex_exit(&usba_device->usb_mutex); 3331 3332 if (leaks) { 3333 USB_DPRINTF_L2(DPRINT_MASK_USBA, usba_log_handle, 3334 "all %d leaks fixed", leaks); 3335 } 3336 } 3337
Indexes created Wed Feb 10 05:47:18 UTC 2010
Terms of Use |
Privacy |
Trademarks |
Copyright Policy |
Site Guidelines |
Site Map |
Help
Your use of this web site or any of its content or software indicates your agreement to be bound by these Terms of Use.
© 2010, Oracle Corporation and/or its affiliates
