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