?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
backout 998: breaks common closed drivers
[illumos-gate.git] / usr / src / uts / common / io / usb / usb_mid / usb_mid.c
blob7c6b507b728f9ec4e9ea7089731b4c5bf06ce138
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 2008 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 */
25
26
27 /*
28 * usb multi interface and common class driver
29 *
30 * this driver attempts to attach each interface to a driver
31 * and may eventually handle common class features such as
32 * shared endpoints
33 */
34
35 #if defined(lint) && !defined(DEBUG)
36 #define DEBUG 1
37 #endif
38 #include <sys/usb/usba/usbai_version.h>
39 #include <sys/usb/usba.h>
40 #include <sys/usb/usba/usba_types.h>
41 #include <sys/usb/usba/usba_impl.h>
42 #include <sys/usb/usba/usba_ugen.h>
43 #include <sys/usb/usb_mid/usb_midvar.h>
44
45 void usba_free_evdata(usba_evdata_t *);
46
47 /* Debugging support */
48 uint_t usb_mid_errlevel = USB_LOG_L4;
49 uint_t usb_mid_errmask = (uint_t)DPRINT_MASK_ALL;
50 uint_t usb_mid_instance_debug = (uint_t)-1;
51 uint_t usb_mid_bus_config_debug = 0;
52
53 _NOTE(DATA_READABLE_WITHOUT_LOCK(usb_mid_errlevel))
54 _NOTE(DATA_READABLE_WITHOUT_LOCK(usb_mid_errmask))
55 _NOTE(DATA_READABLE_WITHOUT_LOCK(usb_mid_instance_debug))
56
57 _NOTE(SCHEME_PROTECTS_DATA("unique", msgb))
58 _NOTE(SCHEME_PROTECTS_DATA("unique", dev_info))
59 _NOTE(SCHEME_PROTECTS_DATA("unique", usb_pipe_policy))
60
61 /*
62 * Hotplug support
63 * Leaf ops (hotplug controls for client devices)
64 */
65 static int usb_mid_open(dev_t *, int, int, cred_t *);
66 static int usb_mid_close(dev_t, int, int, cred_t *);
67 static int usb_mid_read(dev_t, struct uio *, cred_t *);
68 static int usb_mid_write(dev_t, struct uio *, cred_t *);
69 static int usb_mid_poll(dev_t, short, int, short *,
70 struct pollhead **);
71
72 static struct cb_ops usb_mid_cb_ops = {
73 usb_mid_open,
74 usb_mid_close,
75 nodev, /* strategy */
76 nodev, /* print */
77 nodev, /* dump */
78 usb_mid_read, /* read */
79 usb_mid_write, /* write */
80 nodev,
81 nodev, /* devmap */
82 nodev, /* mmap */
83 nodev, /* segmap */
84 usb_mid_poll, /* poll */
85 ddi_prop_op, /* prop_op */
86 NULL,
87 D_MP
88 };
89
90 static int usb_mid_busop_get_eventcookie(dev_info_t *dip,
91 dev_info_t *rdip,
92 char *eventname,
93 ddi_eventcookie_t *cookie);
94 static int usb_mid_busop_add_eventcall(dev_info_t *dip,
95 dev_info_t *rdip,
96 ddi_eventcookie_t cookie,
97 void (*callback)(dev_info_t *dip,
98 ddi_eventcookie_t cookie, void *arg,
99 void *bus_impldata),
100 void *arg, ddi_callback_id_t *cb_id);
101 static int usb_mid_busop_remove_eventcall(dev_info_t *dip,
102 ddi_callback_id_t cb_id);
103 static int usb_mid_busop_post_event(dev_info_t *dip,
104 dev_info_t *rdip,
105 ddi_eventcookie_t cookie,
106 void *bus_impldata);
107 static int usb_mid_bus_config(dev_info_t *dip,
108 uint_t flag,
109 ddi_bus_config_op_t op,
110 void *arg,
111 dev_info_t **child);
112 static int usb_mid_bus_unconfig(dev_info_t *dip,
113 uint_t flag,
114 ddi_bus_config_op_t op,
115 void *arg);
116
117
118 /*
119 * autoconfiguration data and routines.
120 */
121 static int usb_mid_info(dev_info_t *, ddi_info_cmd_t,
122 void *, void **);
123 static int usb_mid_attach(dev_info_t *, ddi_attach_cmd_t);
124 static int usb_mid_detach(dev_info_t *, ddi_detach_cmd_t);
125
126 /* other routines */
127 static void usb_mid_create_pm_components(dev_info_t *, usb_mid_t *);
128 static int usb_mid_bus_ctl(dev_info_t *, dev_info_t *,
129 ddi_ctl_enum_t, void *, void *);
130 static int usb_mid_power(dev_info_t *, int, int);
131 static int usb_mid_restore_device_state(dev_info_t *, usb_mid_t *);
132 static usb_mid_t *usb_mid_obtain_state(dev_info_t *);
133 static void usb_mid_event_cb(dev_info_t *, ddi_eventcookie_t, void *, void *);
134
135 /*
136 * Busops vector
137 */
138 static struct bus_ops usb_mid_busops = {
139 BUSO_REV,
140 nullbusmap, /* bus_map */
141 NULL, /* bus_get_intrspec */
142 NULL, /* bus_add_intrspec */
143 NULL, /* bus_remove_intrspec */
144 NULL, /* XXXX bus_map_fault */
145 ddi_dma_map, /* bus_dma_map */
146 ddi_dma_allochdl,
147 ddi_dma_freehdl,
148 ddi_dma_bindhdl,
149 ddi_dma_unbindhdl,
150 ddi_dma_flush,
151 ddi_dma_win,
152 ddi_dma_mctl, /* bus_dma_ctl */
153 usb_mid_bus_ctl, /* bus_ctl */
154 ddi_bus_prop_op, /* bus_prop_op */
155 usb_mid_busop_get_eventcookie,
156 usb_mid_busop_add_eventcall,
157 usb_mid_busop_remove_eventcall,
158 usb_mid_busop_post_event, /* bus_post_event */
159 NULL, /* bus_intr_ctl */
160 usb_mid_bus_config, /* bus_config */
161 usb_mid_bus_unconfig, /* bus_unconfig */
162 NULL, /* bus_fm_init */
163 NULL, /* bus_fm_fini */
164 NULL, /* bus_fm_access_enter */
165 NULL, /* bus_fm_access_exit */
166 NULL /* bus_power */
167 };
168
169
170 static struct dev_ops usb_mid_ops = {
171 DEVO_REV, /* devo_rev, */
172 0, /* refcnt */
173 usb_mid_info, /* info */
174 nulldev, /* identify */
175 nulldev, /* probe */
176 usb_mid_attach, /* attach */
177 usb_mid_detach, /* detach */
178 nodev, /* reset */
179 &usb_mid_cb_ops, /* driver operations */
180 &usb_mid_busops, /* bus operations */
181 usb_mid_power, /* power */
182 ddi_quiesce_not_needed, /* quiesce */
183 };
184
185 static struct modldrv modldrv = {
186 &mod_driverops, /* Type of module. This one is a driver */
187 "USB Multi Interface Driver", /* Name of the module. */
188 &usb_mid_ops, /* driver ops */
189 };
190
191 static struct modlinkage modlinkage = {
192 MODREV_1, (void *)&modldrv, NULL
193 };
194
195 #define USB_MID_INITIAL_SOFT_SPACE 4
196 static void *usb_mid_statep;
197
198
199 /*
200 * prototypes
201 */
202 static void usb_mid_create_children(usb_mid_t *usb_mid);
203 static int usb_mid_cleanup(dev_info_t *dip, usb_mid_t *usb_mid);
204
205 /*
206 * event definition
207 */
208 static ndi_event_definition_t usb_mid_ndi_event_defs[] = {
209 {USBA_EVENT_TAG_HOT_REMOVAL, DDI_DEVI_REMOVE_EVENT, EPL_KERNEL,
210 NDI_EVENT_POST_TO_ALL},
211 {USBA_EVENT_TAG_HOT_INSERTION, DDI_DEVI_INSERT_EVENT, EPL_KERNEL,
212 NDI_EVENT_POST_TO_ALL},
213 {USBA_EVENT_TAG_POST_RESUME, USBA_POST_RESUME_EVENT, EPL_KERNEL,
214 NDI_EVENT_POST_TO_ALL},
215 {USBA_EVENT_TAG_PRE_SUSPEND, USBA_PRE_SUSPEND_EVENT, EPL_KERNEL,
216 NDI_EVENT_POST_TO_ALL}
217 };
218
219 #define USB_MID_N_NDI_EVENTS \
220 (sizeof (usb_mid_ndi_event_defs) / sizeof (ndi_event_definition_t))
221
222 static ndi_event_set_t usb_mid_ndi_events = {
223 NDI_EVENTS_REV1, USB_MID_N_NDI_EVENTS, usb_mid_ndi_event_defs};
224
225
226 /*
227 * standard driver entry points
228 */
229 int
230 _init(void)
231 {
232 int rval;
233
234 rval = ddi_soft_state_init(&usb_mid_statep, sizeof (struct usb_mid),
235 USB_MID_INITIAL_SOFT_SPACE);
236 if (rval != 0) {
237 return (rval);
238 }
239
240 if ((rval = mod_install(&modlinkage)) != 0) {
241 ddi_soft_state_fini(&usb_mid_statep);
242 return (rval);
243 }
244
245 return (rval);
246 }
247
248
249 int
250 _fini(void)
251 {
252 int rval;
253
254 rval = mod_remove(&modlinkage);
255
256 if (rval) {
257 return (rval);
258 }
259
260 ddi_soft_state_fini(&usb_mid_statep);
261
262 return (rval);
263 }
264
265
266 int
267 _info(struct modinfo *modinfop)
268 {
269 return (mod_info(&modlinkage, modinfop));
270 }
271
272
273 /*ARGSUSED*/
274 static int
275 usb_mid_info(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg, void **result)
276 {
277 usb_mid_t *usb_mid;
278 int instance =
279 USB_MID_MINOR_TO_INSTANCE(getminor((dev_t)arg));
280 int error = DDI_FAILURE;
281
282 switch (infocmd) {
283 case DDI_INFO_DEVT2DEVINFO:
284 if ((usb_mid = ddi_get_soft_state(usb_mid_statep,
285 instance)) != NULL) {
286 *result = (void *)usb_mid->mi_dip;
287 if (*result != NULL) {
288 error = DDI_SUCCESS;
289 }
290 } else {
291 *result = NULL;
292 }
293 break;
294
295 case DDI_INFO_DEVT2INSTANCE:
296 *result = (void *)(intptr_t)instance;
297 error = DDI_SUCCESS;
298 break;
299 default:
300 break;
301 }
302
303 return (error);
304 }
305
306
307 /*
308 * child post attach/detach notification
309 */
310 static void
311 usb_mid_post_attach(usb_mid_t *usb_mid, uint8_t ifno, struct attachspec *as)
312 {
313 USB_DPRINTF_L2(DPRINT_MASK_PM, usb_mid->mi_log_handle,
314 "usb_mid_post_attach: ifno = %d result = %d", ifno, as->result);
315
316 /* if child successfully attached, set power */
317 if (as->result == DDI_SUCCESS) {
318 /*
319 * Check if the child created wants to be power managed.
320 * If yes, the childs power level gets automatically tracked
321 * by DDI_CTLOPS_POWER busctl.
322 * If no, we set power of the new child by default
323 * to USB_DEV_OS_FULL_PWR. Because we should never suspend.
324 */
325 mutex_enter(&usb_mid->mi_mutex);
326 usb_mid->mi_attach_count++;
327 mutex_exit(&usb_mid->mi_mutex);
328 }
329 }
330
331
332 static void
333 usb_mid_post_detach(usb_mid_t *usb_mid, uint8_t ifno, struct detachspec *ds)
334 {
335 USB_DPRINTF_L2(DPRINT_MASK_PM, usb_mid->mi_log_handle,
336 "usb_mid_post_detach: ifno = %d result = %d", ifno, ds->result);
337
338 /*
339 * if the device is successfully detached,
340 * mark component as idle
341 */
342 if (ds->result == DDI_SUCCESS) {
343 usba_device_t *usba_device =
344 usba_get_usba_device(usb_mid->mi_dip);
345
346 mutex_enter(&usb_mid->mi_mutex);
347
348 /* check for leaks except when where is a ugen open */
349 if ((ds->cmd == DDI_DETACH) &&
350 (--usb_mid->mi_attach_count == 0) && usba_device &&
351 (usb_mid->mi_ugen_open_count == 0)) {
352 usba_check_for_leaks(usba_device);
353 }
354 mutex_exit(&usb_mid->mi_mutex);
355 }
356 }
357
358
359 /*
360 * bus ctl support. we handle notifications here and the
361 * rest goes up to root hub/hcd
362 */
363 /*ARGSUSED*/
364 static int
365 usb_mid_bus_ctl(dev_info_t *dip,
366 dev_info_t *rdip,
367 ddi_ctl_enum_t op,
368 void *arg,
369 void *result)
370 {
371 usba_device_t *hub_usba_device = usba_get_usba_device(rdip);
372 dev_info_t *root_hub_dip = hub_usba_device->usb_root_hub_dip;
373 usb_mid_t *usb_mid;
374 struct attachspec *as;
375 struct detachspec *ds;
376
377 usb_mid = usb_mid_obtain_state(dip);
378
379 USB_DPRINTF_L2(DPRINT_MASK_PM, usb_mid->mi_log_handle,
380 "usb_mid_bus_ctl:\n\t"
381 "dip = 0x%p, rdip = 0x%p, op = 0x%x, arg = 0x%p",
382 (void *)dip, (void *)rdip, op, arg);
383
384 switch (op) {
385 case DDI_CTLOPS_ATTACH:
386 as = (struct attachspec *)arg;
387
388 switch (as->when) {
389 case DDI_PRE :
390 /* nothing to do basically */
391 USB_DPRINTF_L2(DPRINT_MASK_PM, usb_mid->mi_log_handle,
392 "DDI_PRE DDI_CTLOPS_ATTACH");
393 break;
394 case DDI_POST :
395 usb_mid_post_attach(usb_mid, usba_get_ifno(rdip),
396 (struct attachspec *)arg);
397 break;
398 }
399
400 break;
401 case DDI_CTLOPS_DETACH:
402 ds = (struct detachspec *)arg;
403
404 switch (ds->when) {
405 case DDI_PRE :
406 /* nothing to do basically */
407 USB_DPRINTF_L2(DPRINT_MASK_PM, usb_mid->mi_log_handle,
408 "DDI_PRE DDI_CTLOPS_DETACH");
409 break;
410 case DDI_POST :
411 usb_mid_post_detach(usb_mid, usba_get_ifno(rdip),
412 (struct detachspec *)arg);
413 break;
414 }
415
416 break;
417 default:
418 /* pass to root hub to handle */
419 return (usba_bus_ctl(root_hub_dip, rdip, op, arg, result));
420 }
421
422 return (DDI_SUCCESS);
423 }
424
425
426 /*
427 * bus enumeration entry points
428 */
429 static int
430 usb_mid_bus_config(dev_info_t *dip, uint_t flag, ddi_bus_config_op_t op,
431 void *arg, dev_info_t **child)
432 {
433 int rval, circ;
434 usb_mid_t *usb_mid = usb_mid_obtain_state(dip);
435
436 USB_DPRINTF_L2(DPRINT_MASK_ALL, usb_mid->mi_log_handle,
437 "usb_mid_bus_config: op=%d", op);
438
439 if (usb_mid_bus_config_debug) {
440 flag |= NDI_DEVI_DEBUG;
441 }
442
443 ndi_devi_enter(dip, &circ);
444
445 /* enumerate each interface below us */
446 mutex_enter(&usb_mid->mi_mutex);
447 usb_mid_create_children(usb_mid);
448 mutex_exit(&usb_mid->mi_mutex);
449
450 rval = ndi_busop_bus_config(dip, flag, op, arg, child, 0);
451 ndi_devi_exit(dip, circ);
452
453 return (rval);
454 }
455
456
457 static int
458 usb_mid_bus_unconfig(dev_info_t *dip, uint_t flag, ddi_bus_config_op_t op,
459 void *arg)
460 {
461 usb_mid_t *usb_mid = usb_mid_obtain_state(dip);
462
463 dev_info_t *cdip, *mdip;
464 int interface, circular_count;
465 int rval = NDI_SUCCESS;
466
467 USB_DPRINTF_L4(DPRINT_MASK_ALL, usb_mid->mi_log_handle,
468 "usb_mid_bus_unconfig: op=%d", op);
469
470 if (usb_mid_bus_config_debug) {
471 flag |= NDI_DEVI_DEBUG;
472 }
473
474 /*
475 * first offline and if offlining successful, then
476 * remove children
477 */
478 if (op == BUS_UNCONFIG_ALL) {
479 flag &= ~(NDI_DEVI_REMOVE | NDI_UNCONFIG);
480 }
481
482 ndi_devi_enter(dip, &circular_count);
483 rval = ndi_busop_bus_unconfig(dip, flag, op, arg);
484
485 if (op == BUS_UNCONFIG_ALL && rval == NDI_SUCCESS &&
486 (flag & NDI_AUTODETACH) == 0) {
487 flag |= NDI_DEVI_REMOVE;
488 rval = ndi_busop_bus_unconfig(dip, flag, op, arg);
489 }
490
491 /* update children's list */
492 mutex_enter(&usb_mid->mi_mutex);
493 for (interface = 0; usb_mid->mi_children_dips &&
494 (interface < usb_mid->mi_n_ifs) &&
495 (usb_mid->mi_children_ifs[interface]); interface++) {
496 mdip = usb_mid->mi_children_dips[interface];
497
498 /* now search if this dip still exists */
499 for (cdip = ddi_get_child(dip); cdip && (cdip != mdip); )
500 cdip = ddi_get_next_sibling(cdip);
501
502 if (cdip != mdip) {
503 /* we lost the dip on this interface */
504 usb_mid->mi_children_dips[interface] = NULL;
505 } else if (cdip) {
506 /*
507 * keep in DS_INITALIZED to prevent parent
508 * from detaching
509 */
510 (void) ddi_initchild(ddi_get_parent(cdip), cdip);
511 }
512 }
513 mutex_exit(&usb_mid->mi_mutex);
514
515 ndi_devi_exit(dip, circular_count);
516
517 USB_DPRINTF_L4(DPRINT_MASK_ALL, usb_mid->mi_log_handle,
518 "usb_mid_bus_config: rval=%d", rval);
519
520 return (rval);
521 }
522
523
524 /* power entry point */
525 /* ARGSUSED */
526 static int
527 usb_mid_power(dev_info_t *dip, int comp, int level)
528 {
529 usb_mid_t *usb_mid;
530 usb_common_power_t *midpm;
531 int rval = DDI_FAILURE;
532
533 usb_mid = usb_mid_obtain_state(dip);
534
535 USB_DPRINTF_L4(DPRINT_MASK_PM, usb_mid->mi_log_handle,
536 "usb_mid_power: Begin: usb_mid = %p, level = %d",
537 (void *)usb_mid, level);
538
539 mutex_enter(&usb_mid->mi_mutex);
540 midpm = usb_mid->mi_pm;
541
542 /* check if we are transitioning to a legal power level */
543 if (USB_DEV_PWRSTATE_OK(midpm->uc_pwr_states, level)) {
544 USB_DPRINTF_L2(DPRINT_MASK_PM, usb_mid->mi_log_handle,
545 "usb_mid_power: illegal power level = %d "
546 "uc_pwr_states = %x", level, midpm->uc_pwr_states);
547
548 mutex_exit(&usb_mid->mi_mutex);
549
550 return (rval);
551 }
552
553 rval = usba_common_power(dip, &(midpm->uc_current_power),
554 &(usb_mid->mi_dev_state), level);
555
556 mutex_exit(&usb_mid->mi_mutex);
557
558 return (rval);
559 }
560
561
562 /*
563 * attach/resume entry point
564 */
565 static int
566 usb_mid_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
567 {
568 int instance = ddi_get_instance(dip);
569 usb_mid_t *usb_mid = NULL;
570 uint_t n_ifs, i;
571 size_t size;
572
573 switch (cmd) {
574 case DDI_ATTACH:
575
576 break;
577 case DDI_RESUME:
578 usb_mid = (usb_mid_t *)ddi_get_soft_state(usb_mid_statep,
579 instance);
580 (void) usb_mid_restore_device_state(dip, usb_mid);
581
582 if (usb_mid->mi_ugen_hdl) {
583 (void) usb_ugen_attach(usb_mid->mi_ugen_hdl,
584 DDI_RESUME);
585 }
586
587 return (DDI_SUCCESS);
588 default:
589
590 return (DDI_FAILURE);
591 }
592
593 /*
594 * Attach:
595 *
596 * Allocate soft state and initialize
597 */
598 if (ddi_soft_state_zalloc(usb_mid_statep, instance) != DDI_SUCCESS) {
599 goto fail;
600 }
601
602 usb_mid = ddi_get_soft_state(usb_mid_statep, instance);
603 if (usb_mid == NULL) {
604
605 goto fail;
606 }
607
608 /* allocate handle for logging of messages */
609 usb_mid->mi_log_handle = usb_alloc_log_hdl(dip, "mid",
610 &usb_mid_errlevel,
611 &usb_mid_errmask, &usb_mid_instance_debug,
612 0);
613
614 usb_mid->mi_usba_device = usba_get_usba_device(dip);
615 usb_mid->mi_dip = dip;
616 usb_mid->mi_instance = instance;
617 usb_mid->mi_n_ifs = usb_mid->mi_usba_device->usb_n_ifs;
618
619 /* attach client driver to USBA */
620 if (usb_client_attach(dip, USBDRV_VERSION, 0) != USB_SUCCESS) {
621 USB_DPRINTF_L2(DPRINT_MASK_ATTA, usb_mid->mi_log_handle,
622 "usb_client_attach failed");
623 goto fail;
624 }
625 if (usb_get_dev_data(dip, &usb_mid->mi_dev_data, USB_PARSE_LVL_NONE,
626 0) != USB_SUCCESS) {
627 USB_DPRINTF_L2(DPRINT_MASK_ATTA, usb_mid->mi_log_handle,
628 "usb_get_dev_data failed");
629 goto fail;
630 }
631
632 mutex_init(&usb_mid->mi_mutex, NULL, MUTEX_DRIVER,
633 usb_mid->mi_dev_data->dev_iblock_cookie);
634
635 usb_free_dev_data(dip, usb_mid->mi_dev_data);
636 usb_mid->mi_dev_data = NULL;
637
638 usb_mid->mi_init_state |= USB_MID_LOCK_INIT;
639
640 if (ddi_create_minor_node(dip, "usb_mid", S_IFCHR,
641 instance << USB_MID_MINOR_INSTANCE_SHIFT,
642 DDI_NT_NEXUS, 0) != DDI_SUCCESS) {
643 USB_DPRINTF_L2(DPRINT_MASK_ATTA, usb_mid->mi_log_handle,
644 "cannot create devctl minor node");
645 goto fail;
646 }
647
648 usb_mid->mi_init_state |= USB_MID_MINOR_NODE_CREATED;
649
650 /*
651 * allocate array for keeping track of child dips
652 */
653 n_ifs = usb_mid->mi_n_ifs;
654 usb_mid->mi_cd_list_length = size = (sizeof (dev_info_t *)) * n_ifs;
655
656 usb_mid->mi_children_dips = kmem_zalloc(size, KM_SLEEP);
657 usb_mid->mi_child_events = kmem_zalloc(sizeof (uint8_t) * n_ifs,
658 KM_SLEEP);
659 usb_mid->mi_children_ifs = kmem_zalloc(sizeof (uint_t) * n_ifs,
660 KM_SLEEP);
661 for (i = 0; i < n_ifs; i++) {
662 usb_mid->mi_children_ifs[i] = 1;
663 }
664
665 /*
666 * Event handling: definition and registration
667 * get event handle for events that we have defined
668 */
669 (void) ndi_event_alloc_hdl(dip, 0, &usb_mid->mi_ndi_event_hdl,
670 NDI_SLEEP);
671
672 /* bind event set to the handle */
673 if (ndi_event_bind_set(usb_mid->mi_ndi_event_hdl, &usb_mid_ndi_events,
674 NDI_SLEEP)) {
675 USB_DPRINTF_L2(DPRINT_MASK_ATTA, usb_mid->mi_log_handle,
676 "usb_mid_attach: binding event set failed");
677
678 goto fail;
679 }
680
681 usb_mid->mi_dev_state = USB_DEV_ONLINE;
682
683 /*
684 * now create components to power manage this device
685 * before attaching children
686 */
687 usb_mid_create_pm_components(dip, usb_mid);
688
689 /* event registration for events from our parent */
690 usba_common_register_events(usb_mid->mi_dip, 1, usb_mid_event_cb);
691
692 usb_mid->mi_init_state |= USB_MID_EVENTS_REGISTERED;
693
694 ddi_report_dev(dip);
695
696 return (DDI_SUCCESS);
697
698 fail:
699 USB_DPRINTF_L2(DPRINT_MASK_ATTA, NULL, "usb_mid%d cannot attach",
700 instance);
701
702 if (usb_mid) {
703 (void) usb_mid_cleanup(dip, usb_mid);
704 }
705
706 return (DDI_FAILURE);
707 }
708
709
710 /* detach or suspend this instance */
711 static int
712 usb_mid_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
713 {
714 usb_mid_t *usb_mid = usb_mid_obtain_state(dip);
715
716 USB_DPRINTF_L4(DPRINT_MASK_ATTA, usb_mid->mi_log_handle,
717 "usb_mid_detach: cmd = 0x%x", cmd);
718
719 switch (cmd) {
720 case DDI_DETACH:
721
722 return (usb_mid_cleanup(dip, usb_mid));
723 case DDI_SUSPEND:
724 /* nothing to do */
725 mutex_enter(&usb_mid->mi_mutex);
726 usb_mid->mi_dev_state = USB_DEV_SUSPENDED;
727 mutex_exit(&usb_mid->mi_mutex);
728
729 if (usb_mid->mi_ugen_hdl) {
730 int rval = usb_ugen_detach(usb_mid->mi_ugen_hdl,
731 DDI_SUSPEND);
732 return (rval == USB_SUCCESS ? DDI_SUCCESS :
733 DDI_FAILURE);
734 }
735
736 return (DDI_SUCCESS);
737 default:
738
739 return (DDI_FAILURE);
740 }
741
742 _NOTE(NOT_REACHED)
743 /* NOTREACHED */
744 }
745
746 /*
747 * usb_mid_cleanup:
748 * cleanup usb_mid and deallocate. this function is called for
749 * handling attach failures and detaching including dynamic
750 * reconfiguration
751 */
752 /*ARGSUSED*/
753 static int
754 usb_mid_cleanup(dev_info_t *dip, usb_mid_t *usb_mid)
755 {
756 usb_common_power_t *midpm;
757 int rval;
758
759 USB_DPRINTF_L4(DPRINT_MASK_ATTA, usb_mid->mi_log_handle,
760 "usb_mid_cleanup:");
761
762 if ((usb_mid->mi_init_state & USB_MID_LOCK_INIT) == 0) {
763
764 goto done;
765 }
766
767 /*
768 * deallocate events, if events are still registered
769 * (ie. children still attached) then we have to fail the detach
770 */
771 if (usb_mid->mi_ndi_event_hdl &&
772 (ndi_event_free_hdl(usb_mid->mi_ndi_event_hdl) != NDI_SUCCESS)) {
773
774 USB_DPRINTF_L2(DPRINT_MASK_ATTA, usb_mid->mi_log_handle,
775 "usb_mid_cleanup: ndi_event_free_hdl failed");
776
777 return (DDI_FAILURE);
778 }
779
780 /*
781 * Disable the event callbacks, after this point, event
782 * callbacks will never get called. Note we shouldn't hold
783 * mutex while unregistering events because there may be a
784 * competing event callback thread. Event callbacks are done
785 * with ndi mutex held and this can cause a potential deadlock.
786 * Note that cleanup can't fail after deregistration of events.
787 */
788 if (usb_mid->mi_init_state & USB_MID_EVENTS_REGISTERED) {
789 usba_common_unregister_events(usb_mid->mi_dip, 1);
790 }
791
792 midpm = usb_mid->mi_pm;
793
794 mutex_enter(&usb_mid->mi_mutex);
795
796 if ((midpm) && (usb_mid->mi_dev_state != USB_DEV_DISCONNECTED)) {
797
798 mutex_exit(&usb_mid->mi_mutex);
799
800 (void) pm_busy_component(dip, 0);
801 if (midpm->uc_wakeup_enabled) {
802
803 /* First bring the device to full power */
804 (void) pm_raise_power(dip, 0, USB_DEV_OS_FULL_PWR);
805
806 rval = usb_handle_remote_wakeup(dip,
807 USB_REMOTE_WAKEUP_DISABLE);
808
809 if (rval != DDI_SUCCESS) {
810 USB_DPRINTF_L2(DPRINT_MASK_EVENTS,
811 usb_mid->mi_log_handle,
812 "usb_cleanup: disable remote "
813 "wakeup failed, rval=%d", rval);
814 }
815 }
816
817 (void) pm_lower_power(usb_mid->mi_dip, 0, USB_DEV_OS_PWR_OFF);
818 (void) pm_idle_component(dip, 0);
819 } else {
820 mutex_exit(&usb_mid->mi_mutex);
821 }
822
823 if (midpm) {
824 kmem_free(midpm, sizeof (usb_common_power_t));
825 }
826
827 /* free children list */
828 if (usb_mid->mi_children_dips) {
829 kmem_free(usb_mid->mi_children_dips,
830 usb_mid->mi_cd_list_length);
831 }
832
833 if (usb_mid->mi_child_events) {
834 kmem_free(usb_mid->mi_child_events, sizeof (uint8_t) *
835 usb_mid->mi_n_ifs);
836 }
837
838 if (usb_mid->mi_children_ifs) {
839 kmem_free(usb_mid->mi_children_ifs, sizeof (uint_t) *
840 usb_mid->mi_n_ifs);
841 }
842
843 if (usb_mid->mi_init_state & USB_MID_MINOR_NODE_CREATED) {
844 ddi_remove_minor_node(dip, NULL);
845 }
846
847 mutex_destroy(&usb_mid->mi_mutex);
848
849 done:
850 usb_client_detach(dip, usb_mid->mi_dev_data);
851
852 if (usb_mid->mi_ugen_hdl) {
853 (void) usb_ugen_detach(usb_mid->mi_ugen_hdl, DDI_DETACH);
854 usb_ugen_release_hdl(usb_mid->mi_ugen_hdl);
855 }
856
857 usb_free_log_hdl(usb_mid->mi_log_handle);
858 ddi_soft_state_free(usb_mid_statep, ddi_get_instance(dip));
859
860 ddi_prop_remove_all(dip);
861
862 return (DDI_SUCCESS);
863 }
864
865
866 static void
867 usb_mid_ugen_attach(usb_mid_t *usb_mid, boolean_t remove_children)
868 {
869 _NOTE(NO_COMPETING_THREADS_NOW);
870
871 if (usb_mid->mi_ugen_hdl == NULL) {
872 usb_ugen_info_t usb_ugen_info;
873 int rval;
874 usb_ugen_hdl_t hdl;
875
876 USB_DPRINTF_L4(DPRINT_MASK_ATTA, usb_mid->mi_log_handle,
877 "usb_mid_ugen_attach: get handle");
878
879 bzero(&usb_ugen_info, sizeof (usb_ugen_info));
880
881 usb_ugen_info.usb_ugen_flags = (remove_children ?
882 USB_UGEN_REMOVE_CHILDREN : 0);
883 usb_ugen_info.usb_ugen_minor_node_ugen_bits_mask =
884 (dev_t)USB_MID_MINOR_UGEN_BITS_MASK;
885 usb_ugen_info.usb_ugen_minor_node_instance_mask =
886 (dev_t)~USB_MID_MINOR_UGEN_BITS_MASK;
887
888 mutex_exit(&usb_mid->mi_mutex);
889 hdl = usb_ugen_get_hdl(usb_mid->mi_dip,
890 &usb_ugen_info);
891
892 if ((rval = usb_ugen_attach(hdl, DDI_ATTACH)) != USB_SUCCESS) {
893 USB_DPRINTF_L4(DPRINT_MASK_ATTA, usb_mid->mi_log_handle,
894 "failed to create ugen support (%d)", rval);
895 usb_ugen_release_hdl(hdl);
896
897 mutex_enter(&usb_mid->mi_mutex);
898 } else {
899 mutex_enter(&usb_mid->mi_mutex);
900 usb_mid->mi_ugen_hdl = hdl;
901 }
902 }
903
904 #ifndef lint
905 _NOTE(COMPETING_THREADS_NOW);
906 #endif
907 }
908
909
910 /*
911 * usb_mid_create_children:
912 */
913 static void
914 usb_mid_create_children(usb_mid_t *usb_mid)
915 {
916 usba_device_t *usba_device;
917 uint_t n_ifs, if_count;
918 uint_t i, j;
919 dev_info_t *cdip, *ia_dip;
920 uint_t ugen_bound = 0;
921 uint_t bound_children = 0;
922
923 usba_device = usba_get_usba_device(usb_mid->mi_dip);
924
925 USB_DPRINTF_L4(DPRINT_MASK_ATTA, usb_mid->mi_log_handle,
926 "usb_mid_attach_child_drivers: port = %d, address = %d",
927 usba_device->usb_port, usba_device->usb_addr);
928
929 if (usb_mid->mi_removed_children) {
930
931 return;
932 }
933
934 n_ifs = usb_mid->mi_n_ifs;
935 if_count = 1;
936
937 USB_DPRINTF_L4(DPRINT_MASK_ATTA, usb_mid->mi_log_handle,
938 "usb_mid_create_children: #interfaces = %d", n_ifs);
939
940 /*
941 * create all children if not already present
942 */
943 for (i = 0; i < n_ifs; i += if_count) {
944
945 /* ignore since this if is included by an ia */
946 if (usb_mid->mi_children_ifs[i] == 0) {
947
948 continue;
949 }
950
951 if (usb_mid->mi_children_dips[i] != NULL) {
952 if (i_ddi_node_state(
953 usb_mid->mi_children_dips[i]) >=
954 DS_BOUND) {
955 bound_children++;
956 }
957
958 continue;
959 }
960
961 mutex_exit(&usb_mid->mi_mutex);
962 ia_dip = usba_ready_interface_association_node(usb_mid->mi_dip,
963 i, &if_count);
964
965 if (ia_dip != NULL) {
966 if (usba_bind_driver(ia_dip) == USB_SUCCESS) {
967 bound_children++;
968 if (strcmp(ddi_driver_name(ia_dip),
969 "ugen") == 0) {
970 ugen_bound++;
971 }
972 }
973
974 /*
975 * IA node owns if_count interfaces.
976 * The rest interfaces own none.
977 */
978 mutex_enter(&usb_mid->mi_mutex);
979 usb_mid->mi_children_dips[i] = ia_dip;
980 usb_mid->mi_children_ifs[i] = if_count;
981 for (j = i + 1; j < i + if_count; j++) {
982 usb_mid->mi_children_ifs[j] = 0;
983 }
984
985 continue;
986 }
987
988 cdip = usba_ready_interface_node(usb_mid->mi_dip, i);
989
990 if (cdip != NULL) {
991 if (usba_bind_driver(cdip) ==
992 USB_SUCCESS) {
993 bound_children++;
994 if (strcmp(ddi_driver_name(cdip),
995 "ugen") == 0) {
996 ugen_bound++;
997 }
998 }
999
1000 /*
1001 * interface node owns 1 interface always.
1002 */
1003 mutex_enter(&usb_mid->mi_mutex);
1004 usb_mid->mi_children_dips[i] = cdip;
1005 usb_mid->mi_children_ifs[i] = 1;
1006 mutex_exit(&usb_mid->mi_mutex);
1007
1008 }
1009
1010 mutex_enter(&usb_mid->mi_mutex);
1011 }
1012
1013 usb_mid->mi_removed_children = (bound_children ? B_FALSE : B_TRUE);
1014
1015 /*
1016 * if there are no ugen interface children, create ugen support at
1017 * device level, use a separate thread because we may be at interrupt
1018 * level
1019 */
1020 if ((ugen_bound == 0) && (usb_mid->mi_ugen_hdl == NULL)) {
1021 /*
1022 * we only need to remove the children if there are
1023 * multiple configurations which would fail if there
1024 * are child interfaces
1025 */
1026 if ((usb_mid->mi_removed_children == B_FALSE) &&
1027 (usba_device->usb_n_cfgs > 1)) {
1028 USB_DPRINTF_L1(DPRINT_MASK_ATTA,
1029 usb_mid->mi_log_handle,
1030 "can't support ugen for multiple "
1031 "configurations devices that have attached "
1032 "child interface drivers");
1033 } else {
1034 usb_mid_ugen_attach(usb_mid,
1035 usb_mid->mi_removed_children);
1036 }
1037 }
1038 }
1039
1040
1041 /*
1042 * event support
1043 */
1044 static int
1045 usb_mid_busop_get_eventcookie(dev_info_t *dip,
1046 dev_info_t *rdip, char *eventname, ddi_eventcookie_t *cookie)
1047 {
1048 usb_mid_t *usb_mid = usb_mid_obtain_state(dip);
1049
1050 USB_DPRINTF_L3(DPRINT_MASK_EVENTS, usb_mid->mi_log_handle,
1051 "usb_mid_busop_get_eventcookie: dip=0x%p, rdip=0x%p, "
1052 "event=%s", (void *)dip, (void *)rdip, eventname);
1053 USB_DPRINTF_L3(DPRINT_MASK_EVENTS, usb_mid->mi_log_handle,
1054 "(dip=%s%d rdip=%s%d)",
1055 ddi_driver_name(dip), ddi_get_instance(dip),
1056 ddi_driver_name(rdip), ddi_get_instance(rdip));
1057
1058 /* return event cookie, iblock cookie, and level */
1059 return (ndi_event_retrieve_cookie(usb_mid->mi_ndi_event_hdl,
1060 rdip, eventname, cookie, NDI_EVENT_NOPASS));
1061 }
1062
1063
1064 static int
1065 usb_mid_busop_add_eventcall(dev_info_t *dip,
1066 dev_info_t *rdip,
1067 ddi_eventcookie_t cookie,
1068 void (*callback)(dev_info_t *dip,
1069 ddi_eventcookie_t cookie, void *arg,
1070 void *bus_impldata),
1071 void *arg, ddi_callback_id_t *cb_id)
1072 {
1073 usb_mid_t *usb_mid = usb_mid_obtain_state(dip);
1074 int ifno = usba_get_ifno(rdip);
1075
1076 USB_DPRINTF_L3(DPRINT_MASK_EVENTS, usb_mid->mi_log_handle,
1077 "usb_mid_busop_add_eventcall: dip=0x%p, rdip=0x%p "
1078 "cookie=0x%p, cb=0x%p, arg=0x%p",
1079 (void *)dip, (void *)rdip, (void *)cookie, (void *)callback, arg);
1080 USB_DPRINTF_L3(DPRINT_MASK_EVENTS, usb_mid->mi_log_handle,
1081 "(dip=%s%d rdip=%s%d event=%s)",
1082 ddi_driver_name(dip), ddi_get_instance(dip),
1083 ddi_driver_name(rdip), ddi_get_instance(rdip),
1084 ndi_event_cookie_to_name(usb_mid->mi_ndi_event_hdl, cookie));
1085
1086 /* Set flag on children registering events */
1087 switch (ndi_event_cookie_to_tag(usb_mid->mi_ndi_event_hdl, cookie)) {
1088 case USBA_EVENT_TAG_HOT_REMOVAL:
1089 mutex_enter(&usb_mid->mi_mutex);
1090 usb_mid->mi_child_events[ifno] |=
1091 USB_MID_CHILD_EVENT_DISCONNECT;
1092 mutex_exit(&usb_mid->mi_mutex);
1093
1094 break;
1095 case USBA_EVENT_TAG_PRE_SUSPEND:
1096 mutex_enter(&usb_mid->mi_mutex);
1097 usb_mid->mi_child_events[ifno] |=
1098 USB_MID_CHILD_EVENT_PRESUSPEND;
1099 mutex_exit(&usb_mid->mi_mutex);
1100
1101 break;
1102 default:
1103
1104 break;
1105 }
1106 /* add callback (perform registration) */
1107 return (ndi_event_add_callback(usb_mid->mi_ndi_event_hdl,
1108 rdip, cookie, callback, arg, NDI_SLEEP, cb_id));
1109 }
1110
1111
1112 static int
1113 usb_mid_busop_remove_eventcall(dev_info_t *dip, ddi_callback_id_t cb_id)
1114 {
1115 usb_mid_t *usb_mid = usb_mid_obtain_state(dip);
1116 ndi_event_callbacks_t *cb = (ndi_event_callbacks_t *)cb_id;
1117
1118 ASSERT(cb);
1119
1120 USB_DPRINTF_L3(DPRINT_MASK_EVENTS, usb_mid->mi_log_handle,
1121 "usb_mid_busop_remove_eventcall: dip=0x%p, rdip=0x%p "
1122 "cookie=0x%p", (void *)dip, (void *)cb->ndi_evtcb_dip,
1123 (void *)cb->ndi_evtcb_cookie);
1124 USB_DPRINTF_L3(DPRINT_MASK_EVENTS, usb_mid->mi_log_handle,
1125 "(dip=%s%d rdip=%s%d event=%s)",
1126 ddi_driver_name(dip), ddi_get_instance(dip),
1127 ddi_driver_name(cb->ndi_evtcb_dip),
1128 ddi_get_instance(cb->ndi_evtcb_dip),
1129 ndi_event_cookie_to_name(usb_mid->mi_ndi_event_hdl,
1130 cb->ndi_evtcb_cookie));
1131
1132 /* remove event registration from our event set */
1133 return (ndi_event_remove_callback(usb_mid->mi_ndi_event_hdl, cb_id));
1134 }
1135
1136
1137 static int
1138 usb_mid_busop_post_event(dev_info_t *dip,
1139 dev_info_t *rdip,
1140 ddi_eventcookie_t cookie,
1141 void *bus_impldata)
1142 {
1143 usb_mid_t *usb_mid = usb_mid_obtain_state(dip);
1144
1145 USB_DPRINTF_L3(DPRINT_MASK_EVENTS, usb_mid->mi_log_handle,
1146 "usb_mid_busop_post_event: dip=0x%p, rdip=0x%p "
1147 "cookie=0x%p, impl=0x%p",
1148 (void *)dip, (void *)rdip, (void *)cookie, bus_impldata);
1149 USB_DPRINTF_L3(DPRINT_MASK_EVENTS, usb_mid->mi_log_handle,
1150 "(dip=%s%d rdip=%s%d event=%s)",
1151 ddi_driver_name(dip), ddi_get_instance(dip),
1152 ddi_driver_name(rdip), ddi_get_instance(rdip),
1153 ndi_event_cookie_to_name(usb_mid->mi_ndi_event_hdl, cookie));
1154
1155 /* post event to all children registered for this event */
1156 return (ndi_event_run_callbacks(usb_mid->mi_ndi_event_hdl, rdip,
1157 cookie, bus_impldata));
1158 }
1159
1160
1161 /*
1162 * usb_mid_restore_device_state
1163 * set the original configuration of the device
1164 */
1165 static int
1166 usb_mid_restore_device_state(dev_info_t *dip, usb_mid_t *usb_mid)
1167 {
1168 usb_common_power_t *midpm;
1169
1170 USB_DPRINTF_L4(DPRINT_MASK_EVENTS, usb_mid->mi_log_handle,
1171 "usb_mid_restore_device_state: usb_mid = %p", (void *)usb_mid);
1172
1173 mutex_enter(&usb_mid->mi_mutex);
1174 midpm = usb_mid->mi_pm;
1175 mutex_exit(&usb_mid->mi_mutex);
1176
1177 /* First bring the device to full power */
1178 (void) pm_busy_component(dip, 0);
1179 (void) pm_raise_power(dip, 0, USB_DEV_OS_FULL_PWR);
1180
1181 if (usb_check_same_device(dip, usb_mid->mi_log_handle, USB_LOG_L0,
1182 DPRINT_MASK_EVENTS, USB_CHK_VIDPID, NULL) != USB_SUCCESS) {
1183
1184 /* change the device state from suspended to disconnected */
1185 mutex_enter(&usb_mid->mi_mutex);
1186 usb_mid->mi_dev_state = USB_DEV_DISCONNECTED;
1187 mutex_exit(&usb_mid->mi_mutex);
1188 (void) pm_idle_component(dip, 0);
1189
1190 return (USB_FAILURE);
1191 }
1192
1193 /*
1194 * if the device had remote wakeup earlier,
1195 * enable it again
1196 */
1197 if (midpm->uc_wakeup_enabled) {
1198 (void) usb_handle_remote_wakeup(usb_mid->mi_dip,
1199 USB_REMOTE_WAKEUP_ENABLE);
1200 }
1201
1202 mutex_enter(&usb_mid->mi_mutex);
1203 usb_mid->mi_dev_state = USB_DEV_ONLINE;
1204 mutex_exit(&usb_mid->mi_mutex);
1205
1206 (void) pm_idle_component(dip, 0);
1207
1208 return (USB_SUCCESS);
1209 }
1210
1211
1212 /*
1213 * usb_mid_event_cb()
1214 * handle disconnect and connect events
1215 */
1216 static void
1217 usb_mid_event_cb(dev_info_t *dip, ddi_eventcookie_t cookie,
1218 void *arg, void *bus_impldata)
1219 {
1220 int i, tag;
1221 usb_mid_t *usb_mid = usb_mid_obtain_state(dip);
1222 dev_info_t *child_dip;
1223 ddi_eventcookie_t rm_cookie, ins_cookie, suspend_cookie, resume_cookie;
1224
1225 USB_DPRINTF_L4(DPRINT_MASK_EVENTS, usb_mid->mi_log_handle,
1226 "usb_mid_event_cb: dip=0x%p, cookie=0x%p, "
1227 "arg=0x%p, impl=0x%p",
1228 (void *)dip, (void *)cookie, arg, bus_impldata);
1229 USB_DPRINTF_L4(DPRINT_MASK_EVENTS, usb_mid->mi_log_handle,
1230 "(dip=%s%d event=%s)",
1231 ddi_driver_name(dip), ddi_get_instance(dip),
1232 ndi_event_cookie_to_name(usb_mid->mi_ndi_event_hdl, cookie));
1233
1234 tag = NDI_EVENT_TAG(cookie);
1235 rm_cookie = ndi_event_tag_to_cookie(
1236 usb_mid->mi_ndi_event_hdl, USBA_EVENT_TAG_HOT_REMOVAL);
1237 suspend_cookie = ndi_event_tag_to_cookie(
1238 usb_mid->mi_ndi_event_hdl, USBA_EVENT_TAG_PRE_SUSPEND);
1239 ins_cookie = ndi_event_tag_to_cookie(
1240 usb_mid->mi_ndi_event_hdl, USBA_EVENT_TAG_HOT_INSERTION);
1241 resume_cookie = ndi_event_tag_to_cookie(
1242 usb_mid->mi_ndi_event_hdl, USBA_EVENT_TAG_POST_RESUME);
1243
1244 mutex_enter(&usb_mid->mi_mutex);
1245 switch (tag) {
1246 case USBA_EVENT_TAG_HOT_REMOVAL:
1247 if (usb_mid->mi_dev_state == USB_DEV_DISCONNECTED) {
1248 USB_DPRINTF_L2(DPRINT_MASK_EVENTS,
1249 usb_mid->mi_log_handle,
1250 "usb_mid_event_cb: Device already disconnected");
1251 } else {
1252 /* we are disconnected so set our state now */
1253 usb_mid->mi_dev_state = USB_DEV_DISCONNECTED;
1254 for (i = 0; i < usb_mid->mi_n_ifs; i++) {
1255 usb_mid->mi_child_events[i] &= ~
1256 USB_MID_CHILD_EVENT_DISCONNECT;
1257 }
1258 mutex_exit(&usb_mid->mi_mutex);
1259
1260 /* pass disconnect event to all the children */
1261 (void) ndi_event_run_callbacks(
1262 usb_mid->mi_ndi_event_hdl, NULL,
1263 rm_cookie, bus_impldata);
1264
1265 if (usb_mid->mi_ugen_hdl) {
1266 (void) usb_ugen_disconnect_ev_cb(
1267 usb_mid->mi_ugen_hdl);
1268 }
1269 mutex_enter(&usb_mid->mi_mutex);
1270 }
1271 break;
1272 case USBA_EVENT_TAG_PRE_SUSPEND:
1273 /* set our state *after* suspending children */
1274 mutex_exit(&usb_mid->mi_mutex);
1275
1276 /* pass pre_suspend event to all the children */
1277 (void) ndi_event_run_callbacks(usb_mid->mi_ndi_event_hdl,
1278 NULL, suspend_cookie, bus_impldata);
1279
1280 mutex_enter(&usb_mid->mi_mutex);
1281 for (i = 0; i < usb_mid->mi_n_ifs; i++) {
1282 usb_mid->mi_child_events[i] &= ~
1283 USB_MID_CHILD_EVENT_PRESUSPEND;
1284 }
1285 break;
1286 case USBA_EVENT_TAG_HOT_INSERTION:
1287 mutex_exit(&usb_mid->mi_mutex);
1288 if (usb_mid_restore_device_state(dip, usb_mid) == USB_SUCCESS) {
1289
1290 /*
1291 * Check to see if this child has missed the disconnect
1292 * event before it registered for event cb
1293 */
1294 mutex_enter(&usb_mid->mi_mutex);
1295 for (i = 0; i < usb_mid->mi_n_ifs; i++) {
1296 if ((usb_mid->mi_child_events[i] &
1297 USB_MID_CHILD_EVENT_DISCONNECT) &&
1298 usb_mid->mi_children_ifs[i]) {
1299 usb_mid->mi_child_events[i] &=
1300 ~USB_MID_CHILD_EVENT_DISCONNECT;
1301 child_dip =
1302 usb_mid->mi_children_dips[i];
1303 mutex_exit(&usb_mid->mi_mutex);
1304
1305 /* post the missed disconnect */
1306 (void) ndi_event_do_callback(
1307 usb_mid->mi_ndi_event_hdl,
1308 child_dip,
1309 rm_cookie,
1310 bus_impldata);
1311 mutex_enter(&usb_mid->mi_mutex);
1312 }
1313 }
1314 mutex_exit(&usb_mid->mi_mutex);
1315
1316 /* pass reconnect event to all the children */
1317 (void) ndi_event_run_callbacks(
1318 usb_mid->mi_ndi_event_hdl, NULL,
1319 ins_cookie, bus_impldata);
1320
1321 if (usb_mid->mi_ugen_hdl) {
1322 (void) usb_ugen_reconnect_ev_cb(
1323 usb_mid->mi_ugen_hdl);
1324 }
1325 }
1326 mutex_enter(&usb_mid->mi_mutex);
1327 break;
1328 case USBA_EVENT_TAG_POST_RESUME:
1329 /*
1330 * Check to see if this child has missed the pre-suspend
1331 * event before it registered for event cb
1332 */
1333 for (i = 0; i < usb_mid->mi_n_ifs; i++) {
1334 if ((usb_mid->mi_child_events[i] &
1335 USB_MID_CHILD_EVENT_PRESUSPEND) &&
1336 usb_mid->mi_children_ifs[i]) {
1337 usb_mid->mi_child_events[i] &=
1338 ~USB_MID_CHILD_EVENT_PRESUSPEND;
1339 child_dip = usb_mid->mi_children_dips[i];
1340 mutex_exit(&usb_mid->mi_mutex);
1341
1342 /* post the missed pre-suspend event */
1343 (void) ndi_event_do_callback(
1344 usb_mid->mi_ndi_event_hdl,
1345 child_dip, suspend_cookie,
1346 bus_impldata);
1347 mutex_enter(&usb_mid->mi_mutex);
1348 }
1349 }
1350 mutex_exit(&usb_mid->mi_mutex);
1351
1352 /* pass post_resume event to all the children */
1353 (void) ndi_event_run_callbacks(usb_mid->mi_ndi_event_hdl,
1354 NULL, resume_cookie, bus_impldata);
1355
1356 mutex_enter(&usb_mid->mi_mutex);
1357 break;
1358 }
1359 mutex_exit(&usb_mid->mi_mutex);
1360
1361 }
1362
1363
1364 /*
1365 * create the pm components required for power management
1366 */
1367 static void
1368 usb_mid_create_pm_components(dev_info_t *dip, usb_mid_t *usb_mid)
1369 {
1370 usb_common_power_t *midpm;
1371 uint_t pwr_states;
1372
1373 USB_DPRINTF_L4(DPRINT_MASK_PM, usb_mid->mi_log_handle,
1374 "usb_mid_create_pm_components: Begin");
1375
1376 /* Allocate the PM state structure */
1377 midpm = kmem_zalloc(sizeof (usb_common_power_t), KM_SLEEP);
1378
1379 mutex_enter(&usb_mid->mi_mutex);
1380 usb_mid->mi_pm = midpm;
1381 midpm->uc_usb_statep = usb_mid;
1382 midpm->uc_pm_capabilities = 0; /* XXXX should this be 0?? */
1383 midpm->uc_current_power = USB_DEV_OS_FULL_PWR;
1384 mutex_exit(&usb_mid->mi_mutex);
1385
1386 /*
1387 * By not enabling parental notification, PM enforces
1388 * "strict parental dependency" meaning, usb_mid won't
1389 * power off until any of its children are in full power.
1390 */
1391
1392 /*
1393 * there are 3 scenarios:
1394 * 1. a well behaved device should have remote wakeup
1395 * at interface and device level. If the interface
1396 * wakes up, usb_mid will wake up
1397 * 2. if the device doesn't have remote wake up and
1398 * the interface has, PM will still work, ie.
1399 * the interfaces wakes up and usb_mid wakes up
1400 * 3. if neither the interface nor device has remote
1401 * wakeup, the interface will wake up when it is opened
1402 * and goes to sleep after being closed for a while
1403 * In this case usb_mid should also go to sleep shortly
1404 * thereafter
1405 * In all scenarios it doesn't really matter whether
1406 * remote wakeup at the device level is enabled or not
1407 * but we do it anyways
1408 */
1409 if (usb_handle_remote_wakeup(dip, USB_REMOTE_WAKEUP_ENABLE) ==
1410 USB_SUCCESS) {
1411 USB_DPRINTF_L3(DPRINT_MASK_PM, usb_mid->mi_log_handle,
1412 "usb_mid_create_pm_components: "
1413 "Remote Wakeup Enabled");
1414 midpm->uc_wakeup_enabled = 1;
1415 }
1416
1417 if (usb_create_pm_components(dip, &pwr_states) ==
1418 USB_SUCCESS) {
1419 midpm->uc_pwr_states = (uint8_t)pwr_states;
1420 (void) pm_raise_power(dip, 0, USB_DEV_OS_FULL_PWR);
1421 }
1422
1423 USB_DPRINTF_L4(DPRINT_MASK_PM, usb_mid->mi_log_handle,
1424 "usb_mid_create_pm_components: End");
1425 }
1426
1427
1428 /*
1429 * usb_mid_obtain_state:
1430 */
1431 usb_mid_t *
1432 usb_mid_obtain_state(dev_info_t *dip)
1433 {
1434 int instance = ddi_get_instance(dip);
1435 usb_mid_t *statep = ddi_get_soft_state(usb_mid_statep, instance);
1436
1437 ASSERT(statep != NULL);
1438
1439 return (statep);
1440 }
1441
1442
1443 /*
1444 * ugen support
1445 */
1446 /* ARGSUSED3 */
1447 static int
1448 usb_mid_open(dev_t *devp, int flags, int otyp, cred_t *credp)
1449 {
1450 struct usb_mid *usb_mid;
1451 int rval;
1452
1453 if ((usb_mid = ddi_get_soft_state(usb_mid_statep,
1454 USB_MID_MINOR_TO_INSTANCE(getminor(*devp)))) == NULL) {
1455
1456 return (ENXIO);
1457 }
1458
1459 USB_DPRINTF_L4(DPRINT_MASK_CBOPS, usb_mid->mi_log_handle,
1460 "usb_mid_open: usb_mid = 0x%p *devp = 0x%lx",
1461 (void *)usb_mid, *devp);
1462
1463 /* First bring the device to full power */
1464 (void) pm_busy_component(usb_mid->mi_dip, 0);
1465 (void) pm_raise_power(usb_mid->mi_dip, 0, USB_DEV_OS_FULL_PWR);
1466
1467
1468 rval = usb_ugen_open(usb_mid->mi_ugen_hdl, devp, flags, otyp,
1469 credp);
1470 if (rval) {
1471 (void) pm_idle_component(usb_mid->mi_dip, 0);
1472 } else {
1473 /*
1474 * since all ugen opens are exclusive we can count the
1475 * opens
1476 */
1477 mutex_enter(&usb_mid->mi_mutex);
1478 usb_mid->mi_ugen_open_count++;
1479 mutex_exit(&usb_mid->mi_mutex);
1480 }
1481
1482 return (rval);
1483 }
1484
1485
1486 /* ARGSUSED */
1487 static int
1488 usb_mid_close(dev_t dev, int flag, int otyp, cred_t *credp)
1489 {
1490 struct usb_mid *usb_mid;
1491 int rval;
1492
1493 if ((usb_mid = ddi_get_soft_state(usb_mid_statep,
1494 USB_MID_MINOR_TO_INSTANCE(getminor(dev)))) == NULL) {
1495
1496 return (ENXIO);
1497 }
1498
1499 rval = usb_ugen_close(usb_mid->mi_ugen_hdl, dev, flag, otyp,
1500 credp);
1501 if (rval == 0) {
1502 (void) pm_idle_component(usb_mid->mi_dip, 0);
1503 mutex_enter(&usb_mid->mi_mutex);
1504 usb_mid->mi_ugen_open_count--;
1505 mutex_exit(&usb_mid->mi_mutex);
1506 }
1507
1508 return (rval);
1509 }
1510
1511
1512 static int
1513 usb_mid_read(dev_t dev, struct uio *uio, cred_t *credp)
1514 {
1515 struct usb_mid *usb_mid;
1516
1517 if ((usb_mid = ddi_get_soft_state(usb_mid_statep,
1518 USB_MID_MINOR_TO_INSTANCE(getminor(dev)))) == NULL) {
1519
1520 return (ENXIO);
1521 }
1522
1523 return (usb_ugen_read(usb_mid->mi_ugen_hdl, dev, uio, credp));
1524 }
1525
1526
1527 static int
1528 usb_mid_write(dev_t dev, struct uio *uio, cred_t *credp)
1529 {
1530 struct usb_mid *usb_mid;
1531
1532 if ((usb_mid = ddi_get_soft_state(usb_mid_statep,
1533 USB_MID_MINOR_TO_INSTANCE(getminor(dev)))) == NULL) {
1534
1535 return (ENXIO);
1536 }
1537
1538 return (usb_ugen_write(usb_mid->mi_ugen_hdl, dev, uio, credp));
1539 }
1540
1541
1542 static int
1543 usb_mid_poll(dev_t dev, short events, int anyyet, short *reventsp,
1544 struct pollhead **phpp)
1545 {
1546 struct usb_mid *usb_mid;
1547
1548 if ((usb_mid = ddi_get_soft_state(usb_mid_statep,
1549 USB_MID_MINOR_TO_INSTANCE(getminor(dev)))) == NULL) {
1550
1551 return (ENXIO);
1552 }
1553
1554 return (usb_ugen_poll(usb_mid->mi_ugen_hdl, dev, events,
1555 anyyet, reventsp, phpp));
1556 }
Community developed and maintained version of the OS/Net consolidation