17c478bd9Sstevel@tonic-gate /* 27c478bd9Sstevel@tonic-gate * CDDL HEADER START 37c478bd9Sstevel@tonic-gate * 47c478bd9Sstevel@tonic-gate * The contents of this file are subject to the terms of the 5055d7c80Scarlsonj * Common Development and Distribution License (the "License"). 6055d7c80Scarlsonj * You may not use this file except in compliance with the License. 77c478bd9Sstevel@tonic-gate * 87c478bd9Sstevel@tonic-gate * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 97c478bd9Sstevel@tonic-gate * or http://www.opensolaris.org/os/licensing. 107c478bd9Sstevel@tonic-gate * See the License for the specific language governing permissions 117c478bd9Sstevel@tonic-gate * and limitations under the License. 127c478bd9Sstevel@tonic-gate * 137c478bd9Sstevel@tonic-gate * When distributing Covered Code, include this CDDL HEADER in each 147c478bd9Sstevel@tonic-gate * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 157c478bd9Sstevel@tonic-gate * If applicable, add the following below this CDDL HEADER, with the 167c478bd9Sstevel@tonic-gate * fields enclosed by brackets "[]" replaced with your own identifying 177c478bd9Sstevel@tonic-gate * information: Portions Copyright [yyyy] [name of copyright owner] 187c478bd9Sstevel@tonic-gate * 197c478bd9Sstevel@tonic-gate * CDDL HEADER END 20055d7c80Scarlsonj */ 21055d7c80Scarlsonj /* 22*036aa261Sgc * Copyright 2007 Sun Microsystems, Inc. All rights reserved. 237c478bd9Sstevel@tonic-gate * Use is subject to license terms. 247c478bd9Sstevel@tonic-gate */ 257c478bd9Sstevel@tonic-gate 267c478bd9Sstevel@tonic-gate #pragma ident "%Z%%M% %I% %E% SMI" 277c478bd9Sstevel@tonic-gate 287c478bd9Sstevel@tonic-gate /* 297c478bd9Sstevel@tonic-gate * usb multi interface and common class driver 307c478bd9Sstevel@tonic-gate * 317c478bd9Sstevel@tonic-gate * this driver attempts to attach each interface to a driver 327c478bd9Sstevel@tonic-gate * and may eventually handle common class features such as 337c478bd9Sstevel@tonic-gate * shared endpoints 347c478bd9Sstevel@tonic-gate */ 357c478bd9Sstevel@tonic-gate 367c478bd9Sstevel@tonic-gate #if defined(lint) && !defined(DEBUG) 377c478bd9Sstevel@tonic-gate #define DEBUG 1 387c478bd9Sstevel@tonic-gate #endif 397c478bd9Sstevel@tonic-gate #include <sys/usb/usba/usbai_version.h> 407c478bd9Sstevel@tonic-gate #include <sys/usb/usba.h> 417c478bd9Sstevel@tonic-gate #include <sys/usb/usba/usba_types.h> 427c478bd9Sstevel@tonic-gate #include <sys/usb/usba/usba_impl.h> 437c478bd9Sstevel@tonic-gate #include <sys/usb/usba/usba_ugen.h> 447c478bd9Sstevel@tonic-gate #include <sys/usb/usb_mid/usb_midvar.h> 457c478bd9Sstevel@tonic-gate 467c478bd9Sstevel@tonic-gate void usba_free_evdata(usba_evdata_t *); 477c478bd9Sstevel@tonic-gate 487c478bd9Sstevel@tonic-gate /* Debugging support */ 494610e4a0Sfrits uint_t usb_mid_errlevel = USB_LOG_L4; 504610e4a0Sfrits uint_t usb_mid_errmask = (uint_t)DPRINT_MASK_ALL; 514610e4a0Sfrits uint_t usb_mid_instance_debug = (uint_t)-1; 524610e4a0Sfrits uint_t usb_mid_bus_config_debug = 0; 537c478bd9Sstevel@tonic-gate 547c478bd9Sstevel@tonic-gate _NOTE(DATA_READABLE_WITHOUT_LOCK(usb_mid_errlevel)) 557c478bd9Sstevel@tonic-gate _NOTE(DATA_READABLE_WITHOUT_LOCK(usb_mid_errmask)) 567c478bd9Sstevel@tonic-gate _NOTE(DATA_READABLE_WITHOUT_LOCK(usb_mid_instance_debug)) 577c478bd9Sstevel@tonic-gate 587c478bd9Sstevel@tonic-gate _NOTE(SCHEME_PROTECTS_DATA("unique", msgb)) 597c478bd9Sstevel@tonic-gate _NOTE(SCHEME_PROTECTS_DATA("unique", dev_info)) 607c478bd9Sstevel@tonic-gate _NOTE(SCHEME_PROTECTS_DATA("unique", usb_pipe_policy)) 617c478bd9Sstevel@tonic-gate 627c478bd9Sstevel@tonic-gate /* 637c478bd9Sstevel@tonic-gate * Hotplug support 647c478bd9Sstevel@tonic-gate * Leaf ops (hotplug controls for client devices) 657c478bd9Sstevel@tonic-gate */ 667c478bd9Sstevel@tonic-gate static int usb_mid_open(dev_t *, int, int, cred_t *); 677c478bd9Sstevel@tonic-gate static int usb_mid_close(dev_t, int, int, cred_t *); 687c478bd9Sstevel@tonic-gate static int usb_mid_read(dev_t, struct uio *, cred_t *); 697c478bd9Sstevel@tonic-gate static int usb_mid_write(dev_t, struct uio *, cred_t *); 707c478bd9Sstevel@tonic-gate static int usb_mid_poll(dev_t, short, int, short *, 717c478bd9Sstevel@tonic-gate struct pollhead **); 727c478bd9Sstevel@tonic-gate 737c478bd9Sstevel@tonic-gate static struct cb_ops usb_mid_cb_ops = { 747c478bd9Sstevel@tonic-gate usb_mid_open, 757c478bd9Sstevel@tonic-gate usb_mid_close, 767c478bd9Sstevel@tonic-gate nodev, /* strategy */ 777c478bd9Sstevel@tonic-gate nodev, /* print */ 787c478bd9Sstevel@tonic-gate nodev, /* dump */ 797c478bd9Sstevel@tonic-gate usb_mid_read, /* read */ 807c478bd9Sstevel@tonic-gate usb_mid_write, /* write */ 817c478bd9Sstevel@tonic-gate nodev, 827c478bd9Sstevel@tonic-gate nodev, /* devmap */ 837c478bd9Sstevel@tonic-gate nodev, /* mmap */ 847c478bd9Sstevel@tonic-gate nodev, /* segmap */ 857c478bd9Sstevel@tonic-gate usb_mid_poll, /* poll */ 867c478bd9Sstevel@tonic-gate ddi_prop_op, /* prop_op */ 877c478bd9Sstevel@tonic-gate NULL, 887c478bd9Sstevel@tonic-gate D_MP 897c478bd9Sstevel@tonic-gate }; 907c478bd9Sstevel@tonic-gate 917c478bd9Sstevel@tonic-gate static int usb_mid_busop_get_eventcookie(dev_info_t *dip, 927c478bd9Sstevel@tonic-gate dev_info_t *rdip, 937c478bd9Sstevel@tonic-gate char *eventname, 947c478bd9Sstevel@tonic-gate ddi_eventcookie_t *cookie); 957c478bd9Sstevel@tonic-gate static int usb_mid_busop_add_eventcall(dev_info_t *dip, 967c478bd9Sstevel@tonic-gate dev_info_t *rdip, 977c478bd9Sstevel@tonic-gate ddi_eventcookie_t cookie, 987c478bd9Sstevel@tonic-gate void (*callback)(dev_info_t *dip, 997c478bd9Sstevel@tonic-gate ddi_eventcookie_t cookie, void *arg, 1007c478bd9Sstevel@tonic-gate void *bus_impldata), 1017c478bd9Sstevel@tonic-gate void *arg, ddi_callback_id_t *cb_id); 1027c478bd9Sstevel@tonic-gate static int usb_mid_busop_remove_eventcall(dev_info_t *dip, 1037c478bd9Sstevel@tonic-gate ddi_callback_id_t cb_id); 1047c478bd9Sstevel@tonic-gate static int usb_mid_busop_post_event(dev_info_t *dip, 1057c478bd9Sstevel@tonic-gate dev_info_t *rdip, 1067c478bd9Sstevel@tonic-gate ddi_eventcookie_t cookie, 1077c478bd9Sstevel@tonic-gate void *bus_impldata); 1087c478bd9Sstevel@tonic-gate static int usb_mid_bus_config(dev_info_t *dip, 1097c478bd9Sstevel@tonic-gate uint_t flag, 1107c478bd9Sstevel@tonic-gate ddi_bus_config_op_t op, 1117c478bd9Sstevel@tonic-gate void *arg, 1127c478bd9Sstevel@tonic-gate dev_info_t **child); 1137c478bd9Sstevel@tonic-gate static int usb_mid_bus_unconfig(dev_info_t *dip, 1147c478bd9Sstevel@tonic-gate uint_t flag, 1157c478bd9Sstevel@tonic-gate ddi_bus_config_op_t op, 1167c478bd9Sstevel@tonic-gate void *arg); 1177c478bd9Sstevel@tonic-gate 1187c478bd9Sstevel@tonic-gate 1197c478bd9Sstevel@tonic-gate /* 1207c478bd9Sstevel@tonic-gate * autoconfiguration data and routines. 1217c478bd9Sstevel@tonic-gate */ 1227c478bd9Sstevel@tonic-gate static int usb_mid_info(dev_info_t *, ddi_info_cmd_t, 1237c478bd9Sstevel@tonic-gate void *, void **); 1247c478bd9Sstevel@tonic-gate static int usb_mid_attach(dev_info_t *, ddi_attach_cmd_t); 1257c478bd9Sstevel@tonic-gate static int usb_mid_detach(dev_info_t *, ddi_detach_cmd_t); 1267c478bd9Sstevel@tonic-gate 1277c478bd9Sstevel@tonic-gate /* other routines */ 1287c478bd9Sstevel@tonic-gate static void usb_mid_create_pm_components(dev_info_t *, usb_mid_t *); 1297c478bd9Sstevel@tonic-gate static int usb_mid_bus_ctl(dev_info_t *, dev_info_t *, 1307c478bd9Sstevel@tonic-gate ddi_ctl_enum_t, void *, void *); 1317c478bd9Sstevel@tonic-gate static int usb_mid_power(dev_info_t *, int, int); 1327c478bd9Sstevel@tonic-gate static int usb_mid_restore_device_state(dev_info_t *, usb_mid_t *); 1337c478bd9Sstevel@tonic-gate static usb_mid_t *usb_mid_obtain_state(dev_info_t *); 134d73ae94eSgc static void usb_mid_event_cb(dev_info_t *, ddi_eventcookie_t, void *, void *); 1357c478bd9Sstevel@tonic-gate 1367c478bd9Sstevel@tonic-gate /* 1377c478bd9Sstevel@tonic-gate * Busops vector 1387c478bd9Sstevel@tonic-gate */ 1397c478bd9Sstevel@tonic-gate static struct bus_ops usb_mid_busops = { 1407c478bd9Sstevel@tonic-gate BUSO_REV, 1417c478bd9Sstevel@tonic-gate nullbusmap, /* bus_map */ 1427c478bd9Sstevel@tonic-gate NULL, /* bus_get_intrspec */ 1437c478bd9Sstevel@tonic-gate NULL, /* bus_add_intrspec */ 1447c478bd9Sstevel@tonic-gate NULL, /* bus_remove_intrspec */ 1457c478bd9Sstevel@tonic-gate NULL, /* XXXX bus_map_fault */ 1467c478bd9Sstevel@tonic-gate ddi_dma_map, /* bus_dma_map */ 1477c478bd9Sstevel@tonic-gate ddi_dma_allochdl, 1487c478bd9Sstevel@tonic-gate ddi_dma_freehdl, 1497c478bd9Sstevel@tonic-gate ddi_dma_bindhdl, 1507c478bd9Sstevel@tonic-gate ddi_dma_unbindhdl, 1517c478bd9Sstevel@tonic-gate ddi_dma_flush, 1527c478bd9Sstevel@tonic-gate ddi_dma_win, 1537c478bd9Sstevel@tonic-gate ddi_dma_mctl, /* bus_dma_ctl */ 1547c478bd9Sstevel@tonic-gate usb_mid_bus_ctl, /* bus_ctl */ 1557c478bd9Sstevel@tonic-gate ddi_bus_prop_op, /* bus_prop_op */ 1567c478bd9Sstevel@tonic-gate usb_mid_busop_get_eventcookie, 1577c478bd9Sstevel@tonic-gate usb_mid_busop_add_eventcall, 1587c478bd9Sstevel@tonic-gate usb_mid_busop_remove_eventcall, 1597c478bd9Sstevel@tonic-gate usb_mid_busop_post_event, /* bus_post_event */ 1607c478bd9Sstevel@tonic-gate NULL, /* bus_intr_ctl */ 1617c478bd9Sstevel@tonic-gate usb_mid_bus_config, /* bus_config */ 1627c478bd9Sstevel@tonic-gate usb_mid_bus_unconfig, /* bus_unconfig */ 1637c478bd9Sstevel@tonic-gate NULL, /* bus_fm_init */ 1647c478bd9Sstevel@tonic-gate NULL, /* bus_fm_fini */ 1657c478bd9Sstevel@tonic-gate NULL, /* bus_fm_access_enter */ 1667c478bd9Sstevel@tonic-gate NULL, /* bus_fm_access_exit */ 1677c478bd9Sstevel@tonic-gate NULL /* bus_power */ 1687c478bd9Sstevel@tonic-gate }; 1697c478bd9Sstevel@tonic-gate 1707c478bd9Sstevel@tonic-gate 1717c478bd9Sstevel@tonic-gate static struct dev_ops usb_mid_ops = { 1727c478bd9Sstevel@tonic-gate DEVO_REV, /* devo_rev, */ 1737c478bd9Sstevel@tonic-gate 0, /* refcnt */ 1747c478bd9Sstevel@tonic-gate usb_mid_info, /* info */ 1757c478bd9Sstevel@tonic-gate nulldev, /* identify */ 1767c478bd9Sstevel@tonic-gate nulldev, /* probe */ 1777c478bd9Sstevel@tonic-gate usb_mid_attach, /* attach */ 1787c478bd9Sstevel@tonic-gate usb_mid_detach, /* detach */ 1797c478bd9Sstevel@tonic-gate nodev, /* reset */ 1807c478bd9Sstevel@tonic-gate &usb_mid_cb_ops, /* driver operations */ 1817c478bd9Sstevel@tonic-gate &usb_mid_busops, /* bus operations */ 1827c478bd9Sstevel@tonic-gate usb_mid_power /* power */ 1837c478bd9Sstevel@tonic-gate }; 1847c478bd9Sstevel@tonic-gate 1857c478bd9Sstevel@tonic-gate static struct modldrv modldrv = { 1867c478bd9Sstevel@tonic-gate &mod_driverops, /* Type of module. This one is a driver */ 1877c478bd9Sstevel@tonic-gate "USB Multi Interface Driver %I%", /* Name of the module. */ 1887c478bd9Sstevel@tonic-gate &usb_mid_ops, /* driver ops */ 1897c478bd9Sstevel@tonic-gate }; 1907c478bd9Sstevel@tonic-gate 1917c478bd9Sstevel@tonic-gate static struct modlinkage modlinkage = { 1927c478bd9Sstevel@tonic-gate MODREV_1, (void *)&modldrv, NULL 1937c478bd9Sstevel@tonic-gate }; 1947c478bd9Sstevel@tonic-gate 1957c478bd9Sstevel@tonic-gate #define USB_MID_INITIAL_SOFT_SPACE 4 1967c478bd9Sstevel@tonic-gate static void *usb_mid_statep; 1977c478bd9Sstevel@tonic-gate 1987c478bd9Sstevel@tonic-gate 1997c478bd9Sstevel@tonic-gate /* 2007c478bd9Sstevel@tonic-gate * prototypes 2017c478bd9Sstevel@tonic-gate */ 2027c478bd9Sstevel@tonic-gate static void usb_mid_create_children(usb_mid_t *usb_mid); 2037c478bd9Sstevel@tonic-gate static int usb_mid_cleanup(dev_info_t *dip, usb_mid_t *usb_mid); 2047c478bd9Sstevel@tonic-gate 2057c478bd9Sstevel@tonic-gate /* 2067c478bd9Sstevel@tonic-gate * event definition 2077c478bd9Sstevel@tonic-gate */ 2087c478bd9Sstevel@tonic-gate static ndi_event_definition_t usb_mid_ndi_event_defs[] = { 2097c478bd9Sstevel@tonic-gate {USBA_EVENT_TAG_HOT_REMOVAL, DDI_DEVI_REMOVE_EVENT, EPL_KERNEL, 2107c478bd9Sstevel@tonic-gate NDI_EVENT_POST_TO_ALL}, 2117c478bd9Sstevel@tonic-gate {USBA_EVENT_TAG_HOT_INSERTION, DDI_DEVI_INSERT_EVENT, EPL_KERNEL, 2127c478bd9Sstevel@tonic-gate NDI_EVENT_POST_TO_ALL}, 2137c478bd9Sstevel@tonic-gate {USBA_EVENT_TAG_POST_RESUME, USBA_POST_RESUME_EVENT, EPL_KERNEL, 2147c478bd9Sstevel@tonic-gate NDI_EVENT_POST_TO_ALL}, 2157c478bd9Sstevel@tonic-gate {USBA_EVENT_TAG_PRE_SUSPEND, USBA_PRE_SUSPEND_EVENT, EPL_KERNEL, 2167c478bd9Sstevel@tonic-gate NDI_EVENT_POST_TO_ALL} 2177c478bd9Sstevel@tonic-gate }; 2187c478bd9Sstevel@tonic-gate 2197c478bd9Sstevel@tonic-gate #define USB_MID_N_NDI_EVENTS \ 2207c478bd9Sstevel@tonic-gate (sizeof (usb_mid_ndi_event_defs) / sizeof (ndi_event_definition_t)) 2217c478bd9Sstevel@tonic-gate 2227c478bd9Sstevel@tonic-gate static ndi_event_set_t usb_mid_ndi_events = { 2237c478bd9Sstevel@tonic-gate NDI_EVENTS_REV1, USB_MID_N_NDI_EVENTS, usb_mid_ndi_event_defs}; 2247c478bd9Sstevel@tonic-gate 2257c478bd9Sstevel@tonic-gate 2267c478bd9Sstevel@tonic-gate /* 2277c478bd9Sstevel@tonic-gate * standard driver entry points 2287c478bd9Sstevel@tonic-gate */ 2297c478bd9Sstevel@tonic-gate int 2307c478bd9Sstevel@tonic-gate _init(void) 2317c478bd9Sstevel@tonic-gate { 2327c478bd9Sstevel@tonic-gate int rval; 2337c478bd9Sstevel@tonic-gate 2347c478bd9Sstevel@tonic-gate rval = ddi_soft_state_init(&usb_mid_statep, sizeof (struct usb_mid), 2357c478bd9Sstevel@tonic-gate USB_MID_INITIAL_SOFT_SPACE); 2367c478bd9Sstevel@tonic-gate if (rval != 0) { 2377c478bd9Sstevel@tonic-gate return (rval); 2387c478bd9Sstevel@tonic-gate } 2397c478bd9Sstevel@tonic-gate 2407c478bd9Sstevel@tonic-gate if ((rval = mod_install(&modlinkage)) != 0) { 2417c478bd9Sstevel@tonic-gate ddi_soft_state_fini(&usb_mid_statep); 2427c478bd9Sstevel@tonic-gate return (rval); 2437c478bd9Sstevel@tonic-gate } 2447c478bd9Sstevel@tonic-gate 2457c478bd9Sstevel@tonic-gate return (rval); 2467c478bd9Sstevel@tonic-gate } 2477c478bd9Sstevel@tonic-gate 2487c478bd9Sstevel@tonic-gate 2497c478bd9Sstevel@tonic-gate int 2507c478bd9Sstevel@tonic-gate _fini(void) 2517c478bd9Sstevel@tonic-gate { 2527c478bd9Sstevel@tonic-gate int rval; 2537c478bd9Sstevel@tonic-gate 2547c478bd9Sstevel@tonic-gate rval = mod_remove(&modlinkage); 2557c478bd9Sstevel@tonic-gate 2567c478bd9Sstevel@tonic-gate if (rval) { 2577c478bd9Sstevel@tonic-gate return (rval); 2587c478bd9Sstevel@tonic-gate } 2597c478bd9Sstevel@tonic-gate 2607c478bd9Sstevel@tonic-gate ddi_soft_state_fini(&usb_mid_statep); 2617c478bd9Sstevel@tonic-gate 2627c478bd9Sstevel@tonic-gate return (rval); 2637c478bd9Sstevel@tonic-gate } 2647c478bd9Sstevel@tonic-gate 2657c478bd9Sstevel@tonic-gate 2667c478bd9Sstevel@tonic-gate int 2677c478bd9Sstevel@tonic-gate _info(struct modinfo *modinfop) 2687c478bd9Sstevel@tonic-gate { 2697c478bd9Sstevel@tonic-gate return (mod_info(&modlinkage, modinfop)); 2707c478bd9Sstevel@tonic-gate } 2717c478bd9Sstevel@tonic-gate 2727c478bd9Sstevel@tonic-gate 2737c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 2747c478bd9Sstevel@tonic-gate static int 2757c478bd9Sstevel@tonic-gate usb_mid_info(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg, void **result) 2767c478bd9Sstevel@tonic-gate { 2777c478bd9Sstevel@tonic-gate usb_mid_t *usb_mid; 2787c478bd9Sstevel@tonic-gate int instance = 2797c478bd9Sstevel@tonic-gate USB_MID_MINOR_TO_INSTANCE(getminor((dev_t)arg)); 2807c478bd9Sstevel@tonic-gate int error = DDI_FAILURE; 2817c478bd9Sstevel@tonic-gate 2827c478bd9Sstevel@tonic-gate switch (infocmd) { 2837c478bd9Sstevel@tonic-gate case DDI_INFO_DEVT2DEVINFO: 2847c478bd9Sstevel@tonic-gate if ((usb_mid = ddi_get_soft_state(usb_mid_statep, 2857c478bd9Sstevel@tonic-gate instance)) != NULL) { 2867c478bd9Sstevel@tonic-gate *result = (void *)usb_mid->mi_dip; 2877c478bd9Sstevel@tonic-gate if (*result != NULL) { 2887c478bd9Sstevel@tonic-gate error = DDI_SUCCESS; 2897c478bd9Sstevel@tonic-gate } 2907c478bd9Sstevel@tonic-gate } else { 2917c478bd9Sstevel@tonic-gate *result = NULL; 2927c478bd9Sstevel@tonic-gate } 2937c478bd9Sstevel@tonic-gate break; 2947c478bd9Sstevel@tonic-gate 2957c478bd9Sstevel@tonic-gate case DDI_INFO_DEVT2INSTANCE: 2967c478bd9Sstevel@tonic-gate *result = (void *)(intptr_t)instance; 2977c478bd9Sstevel@tonic-gate error = DDI_SUCCESS; 2987c478bd9Sstevel@tonic-gate break; 2997c478bd9Sstevel@tonic-gate default: 3007c478bd9Sstevel@tonic-gate break; 3017c478bd9Sstevel@tonic-gate } 3027c478bd9Sstevel@tonic-gate 3037c478bd9Sstevel@tonic-gate return (error); 3047c478bd9Sstevel@tonic-gate } 3057c478bd9Sstevel@tonic-gate 3067c478bd9Sstevel@tonic-gate 3077c478bd9Sstevel@tonic-gate /* 3087c478bd9Sstevel@tonic-gate * child post attach/detach notification 3097c478bd9Sstevel@tonic-gate */ 3107c478bd9Sstevel@tonic-gate static void 3117c478bd9Sstevel@tonic-gate usb_mid_post_attach(usb_mid_t *usb_mid, uint8_t ifno, struct attachspec *as) 3127c478bd9Sstevel@tonic-gate { 3137c478bd9Sstevel@tonic-gate USB_DPRINTF_L2(DPRINT_MASK_PM, usb_mid->mi_log_handle, 3147c478bd9Sstevel@tonic-gate "usb_mid_post_attach: ifno = %d result = %d", ifno, as->result); 3157c478bd9Sstevel@tonic-gate 3167c478bd9Sstevel@tonic-gate /* if child successfully attached, set power */ 3177c478bd9Sstevel@tonic-gate if (as->result == DDI_SUCCESS) { 3187c478bd9Sstevel@tonic-gate /* 3197c478bd9Sstevel@tonic-gate * Check if the child created wants to be power managed. 3207c478bd9Sstevel@tonic-gate * If yes, the childs power level gets automatically tracked 3217c478bd9Sstevel@tonic-gate * by DDI_CTLOPS_POWER busctl. 3227c478bd9Sstevel@tonic-gate * If no, we set power of the new child by default 3237c478bd9Sstevel@tonic-gate * to USB_DEV_OS_FULL_PWR. Because we should never suspend. 3247c478bd9Sstevel@tonic-gate */ 3257c478bd9Sstevel@tonic-gate mutex_enter(&usb_mid->mi_mutex); 3267c478bd9Sstevel@tonic-gate usb_mid->mi_attach_count++; 3277c478bd9Sstevel@tonic-gate mutex_exit(&usb_mid->mi_mutex); 3287c478bd9Sstevel@tonic-gate } 3297c478bd9Sstevel@tonic-gate } 3307c478bd9Sstevel@tonic-gate 3317c478bd9Sstevel@tonic-gate 3327c478bd9Sstevel@tonic-gate static void 3337c478bd9Sstevel@tonic-gate usb_mid_post_detach(usb_mid_t *usb_mid, uint8_t ifno, struct detachspec *ds) 3347c478bd9Sstevel@tonic-gate { 3357c478bd9Sstevel@tonic-gate USB_DPRINTF_L2(DPRINT_MASK_PM, usb_mid->mi_log_handle, 3367c478bd9Sstevel@tonic-gate "usb_mid_post_detach: ifno = %d result = %d", ifno, ds->result); 3377c478bd9Sstevel@tonic-gate 3387c478bd9Sstevel@tonic-gate /* 3397c478bd9Sstevel@tonic-gate * if the device is successfully detached, 3407c478bd9Sstevel@tonic-gate * mark component as idle 3417c478bd9Sstevel@tonic-gate */ 3427c478bd9Sstevel@tonic-gate if (ds->result == DDI_SUCCESS) { 3437c478bd9Sstevel@tonic-gate usba_device_t *usba_device = 3447c478bd9Sstevel@tonic-gate usba_get_usba_device(usb_mid->mi_dip); 3457c478bd9Sstevel@tonic-gate 3467c478bd9Sstevel@tonic-gate mutex_enter(&usb_mid->mi_mutex); 3477c478bd9Sstevel@tonic-gate 3487c478bd9Sstevel@tonic-gate /* check for leaks except when where is a ugen open */ 3497c478bd9Sstevel@tonic-gate if ((ds->cmd == DDI_DETACH) && 3507c478bd9Sstevel@tonic-gate (--usb_mid->mi_attach_count == 0) && usba_device && 3517c478bd9Sstevel@tonic-gate (usb_mid->mi_ugen_open_count == 0)) { 3527c478bd9Sstevel@tonic-gate usba_check_for_leaks(usba_device); 3537c478bd9Sstevel@tonic-gate } 3547c478bd9Sstevel@tonic-gate mutex_exit(&usb_mid->mi_mutex); 3557c478bd9Sstevel@tonic-gate } 3567c478bd9Sstevel@tonic-gate } 3577c478bd9Sstevel@tonic-gate 3587c478bd9Sstevel@tonic-gate 3597c478bd9Sstevel@tonic-gate /* 3607c478bd9Sstevel@tonic-gate * bus ctl support. we handle notifications here and the 3617c478bd9Sstevel@tonic-gate * rest goes up to root hub/hcd 3627c478bd9Sstevel@tonic-gate */ 3637c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 3647c478bd9Sstevel@tonic-gate static int 3657c478bd9Sstevel@tonic-gate usb_mid_bus_ctl(dev_info_t *dip, 3667c478bd9Sstevel@tonic-gate dev_info_t *rdip, 3677c478bd9Sstevel@tonic-gate ddi_ctl_enum_t op, 3687c478bd9Sstevel@tonic-gate void *arg, 3697c478bd9Sstevel@tonic-gate void *result) 3707c478bd9Sstevel@tonic-gate { 3717c478bd9Sstevel@tonic-gate usba_device_t *hub_usba_device = usba_get_usba_device(rdip); 3727c478bd9Sstevel@tonic-gate dev_info_t *root_hub_dip = hub_usba_device->usb_root_hub_dip; 3737c478bd9Sstevel@tonic-gate usb_mid_t *usb_mid; 3747c478bd9Sstevel@tonic-gate struct attachspec *as; 3757c478bd9Sstevel@tonic-gate struct detachspec *ds; 3767c478bd9Sstevel@tonic-gate 3777c478bd9Sstevel@tonic-gate usb_mid = usb_mid_obtain_state(dip); 3787c478bd9Sstevel@tonic-gate 3797c478bd9Sstevel@tonic-gate USB_DPRINTF_L2(DPRINT_MASK_PM, usb_mid->mi_log_handle, 3807c478bd9Sstevel@tonic-gate "usb_mid_bus_ctl:\n\t" 3817c478bd9Sstevel@tonic-gate "dip = 0x%p, rdip = 0x%p, op = 0x%x, arg = 0x%p", 3827c478bd9Sstevel@tonic-gate dip, rdip, op, arg); 3837c478bd9Sstevel@tonic-gate 3847c478bd9Sstevel@tonic-gate switch (op) { 3857c478bd9Sstevel@tonic-gate case DDI_CTLOPS_ATTACH: 3867c478bd9Sstevel@tonic-gate as = (struct attachspec *)arg; 3877c478bd9Sstevel@tonic-gate 3887c478bd9Sstevel@tonic-gate switch (as->when) { 3897c478bd9Sstevel@tonic-gate case DDI_PRE : 3907c478bd9Sstevel@tonic-gate /* nothing to do basically */ 3917c478bd9Sstevel@tonic-gate USB_DPRINTF_L2(DPRINT_MASK_PM, usb_mid->mi_log_handle, 3927c478bd9Sstevel@tonic-gate "DDI_PRE DDI_CTLOPS_ATTACH"); 3937c478bd9Sstevel@tonic-gate break; 3947c478bd9Sstevel@tonic-gate case DDI_POST : 3957c478bd9Sstevel@tonic-gate usb_mid_post_attach(usb_mid, usba_get_ifno(rdip), 3967c478bd9Sstevel@tonic-gate (struct attachspec *)arg); 3977c478bd9Sstevel@tonic-gate break; 3987c478bd9Sstevel@tonic-gate } 3997c478bd9Sstevel@tonic-gate 4007c478bd9Sstevel@tonic-gate break; 4017c478bd9Sstevel@tonic-gate case DDI_CTLOPS_DETACH: 4027c478bd9Sstevel@tonic-gate ds = (struct detachspec *)arg; 4037c478bd9Sstevel@tonic-gate 4047c478bd9Sstevel@tonic-gate switch (ds->when) { 4057c478bd9Sstevel@tonic-gate case DDI_PRE : 4067c478bd9Sstevel@tonic-gate /* nothing to do basically */ 4077c478bd9Sstevel@tonic-gate USB_DPRINTF_L2(DPRINT_MASK_PM, usb_mid->mi_log_handle, 4087c478bd9Sstevel@tonic-gate "DDI_PRE DDI_CTLOPS_DETACH"); 4097c478bd9Sstevel@tonic-gate break; 4107c478bd9Sstevel@tonic-gate case DDI_POST : 4117c478bd9Sstevel@tonic-gate usb_mid_post_detach(usb_mid, usba_get_ifno(rdip), 4127c478bd9Sstevel@tonic-gate (struct detachspec *)arg); 4137c478bd9Sstevel@tonic-gate break; 4147c478bd9Sstevel@tonic-gate } 4157c478bd9Sstevel@tonic-gate 4167c478bd9Sstevel@tonic-gate break; 4177c478bd9Sstevel@tonic-gate default: 4187c478bd9Sstevel@tonic-gate /* pass to root hub to handle */ 4197c478bd9Sstevel@tonic-gate return (usba_bus_ctl(root_hub_dip, rdip, op, arg, result)); 4207c478bd9Sstevel@tonic-gate } 4217c478bd9Sstevel@tonic-gate 4227c478bd9Sstevel@tonic-gate return (DDI_SUCCESS); 4237c478bd9Sstevel@tonic-gate } 4247c478bd9Sstevel@tonic-gate 4257c478bd9Sstevel@tonic-gate 4267c478bd9Sstevel@tonic-gate /* 4277c478bd9Sstevel@tonic-gate * bus enumeration entry points 4287c478bd9Sstevel@tonic-gate */ 4297c478bd9Sstevel@tonic-gate static int 4307c478bd9Sstevel@tonic-gate usb_mid_bus_config(dev_info_t *dip, uint_t flag, ddi_bus_config_op_t op, 4317c478bd9Sstevel@tonic-gate void *arg, dev_info_t **child) 4327c478bd9Sstevel@tonic-gate { 4337c478bd9Sstevel@tonic-gate int rval, circ; 4347c478bd9Sstevel@tonic-gate usb_mid_t *usb_mid = usb_mid_obtain_state(dip); 4357c478bd9Sstevel@tonic-gate 4367c478bd9Sstevel@tonic-gate USB_DPRINTF_L2(DPRINT_MASK_ALL, usb_mid->mi_log_handle, 4377c478bd9Sstevel@tonic-gate "usb_mid_bus_config: op=%d", op); 4387c478bd9Sstevel@tonic-gate 4397c478bd9Sstevel@tonic-gate if (usb_mid_bus_config_debug) { 4407c478bd9Sstevel@tonic-gate flag |= NDI_DEVI_DEBUG; 4417c478bd9Sstevel@tonic-gate } 4427c478bd9Sstevel@tonic-gate 4437c478bd9Sstevel@tonic-gate ndi_devi_enter(dip, &circ); 4447c478bd9Sstevel@tonic-gate 4457c478bd9Sstevel@tonic-gate /* enumerate each interface below us */ 4467c478bd9Sstevel@tonic-gate mutex_enter(&usb_mid->mi_mutex); 4477c478bd9Sstevel@tonic-gate usb_mid_create_children(usb_mid); 4487c478bd9Sstevel@tonic-gate mutex_exit(&usb_mid->mi_mutex); 4497c478bd9Sstevel@tonic-gate 4507c478bd9Sstevel@tonic-gate rval = ndi_busop_bus_config(dip, flag, op, arg, child, 0); 4517c478bd9Sstevel@tonic-gate ndi_devi_exit(dip, circ); 4527c478bd9Sstevel@tonic-gate 4537c478bd9Sstevel@tonic-gate return (rval); 4547c478bd9Sstevel@tonic-gate } 4557c478bd9Sstevel@tonic-gate 4567c478bd9Sstevel@tonic-gate 4577c478bd9Sstevel@tonic-gate static int 4587c478bd9Sstevel@tonic-gate usb_mid_bus_unconfig(dev_info_t *dip, uint_t flag, ddi_bus_config_op_t op, 4597c478bd9Sstevel@tonic-gate void *arg) 4607c478bd9Sstevel@tonic-gate { 4617c478bd9Sstevel@tonic-gate usb_mid_t *usb_mid = usb_mid_obtain_state(dip); 4627c478bd9Sstevel@tonic-gate 4637c478bd9Sstevel@tonic-gate dev_info_t *cdip, *mdip; 4647c478bd9Sstevel@tonic-gate int interface, circular_count; 465d73ae94eSgc int rval = NDI_SUCCESS; 4667c478bd9Sstevel@tonic-gate 4677c478bd9Sstevel@tonic-gate USB_DPRINTF_L4(DPRINT_MASK_ALL, usb_mid->mi_log_handle, 4687c478bd9Sstevel@tonic-gate "usb_mid_bus_unconfig: op=%d", op); 4697c478bd9Sstevel@tonic-gate 4707c478bd9Sstevel@tonic-gate if (usb_mid_bus_config_debug) { 4717c478bd9Sstevel@tonic-gate flag |= NDI_DEVI_DEBUG; 4727c478bd9Sstevel@tonic-gate } 4737c478bd9Sstevel@tonic-gate 4747c478bd9Sstevel@tonic-gate /* 4757c478bd9Sstevel@tonic-gate * first offline and if offlining successful, then 4767c478bd9Sstevel@tonic-gate * remove children 4777c478bd9Sstevel@tonic-gate */ 4787c478bd9Sstevel@tonic-gate if (op == BUS_UNCONFIG_ALL) { 4797c478bd9Sstevel@tonic-gate flag &= ~(NDI_DEVI_REMOVE | NDI_UNCONFIG); 4807c478bd9Sstevel@tonic-gate } 4817c478bd9Sstevel@tonic-gate 4827c478bd9Sstevel@tonic-gate ndi_devi_enter(dip, &circular_count); 4837c478bd9Sstevel@tonic-gate rval = ndi_busop_bus_unconfig(dip, flag, op, arg); 4847c478bd9Sstevel@tonic-gate 4857c478bd9Sstevel@tonic-gate if (op == BUS_UNCONFIG_ALL && rval == NDI_SUCCESS && 4867c478bd9Sstevel@tonic-gate (flag & NDI_AUTODETACH) == 0) { 4877c478bd9Sstevel@tonic-gate flag |= NDI_DEVI_REMOVE; 4887c478bd9Sstevel@tonic-gate rval = ndi_busop_bus_unconfig(dip, flag, op, arg); 4897c478bd9Sstevel@tonic-gate } 4907c478bd9Sstevel@tonic-gate 4917c478bd9Sstevel@tonic-gate /* update children's list */ 4927c478bd9Sstevel@tonic-gate mutex_enter(&usb_mid->mi_mutex); 4937c478bd9Sstevel@tonic-gate for (interface = 0; usb_mid->mi_children_dips && 494d73ae94eSgc (interface < usb_mid->mi_n_ifs) && 495d73ae94eSgc (usb_mid->mi_children_ifs[interface]); interface++) { 4967c478bd9Sstevel@tonic-gate mdip = usb_mid->mi_children_dips[interface]; 4977c478bd9Sstevel@tonic-gate 4987c478bd9Sstevel@tonic-gate /* now search if this dip still exists */ 4997c478bd9Sstevel@tonic-gate for (cdip = ddi_get_child(dip); cdip && (cdip != mdip); 500d73ae94eSgc cdip = ddi_get_next_sibling(cdip)); 5017c478bd9Sstevel@tonic-gate 5027c478bd9Sstevel@tonic-gate if (cdip != mdip) { 5037c478bd9Sstevel@tonic-gate /* we lost the dip on this interface */ 5047c478bd9Sstevel@tonic-gate usb_mid->mi_children_dips[interface] = NULL; 5057c478bd9Sstevel@tonic-gate } else if (cdip) { 5067c478bd9Sstevel@tonic-gate /* 5077c478bd9Sstevel@tonic-gate * keep in DS_INITALIZED to prevent parent 5087c478bd9Sstevel@tonic-gate * from detaching 5097c478bd9Sstevel@tonic-gate */ 5107c478bd9Sstevel@tonic-gate (void) ddi_initchild(ddi_get_parent(cdip), cdip); 5117c478bd9Sstevel@tonic-gate } 5127c478bd9Sstevel@tonic-gate } 5137c478bd9Sstevel@tonic-gate mutex_exit(&usb_mid->mi_mutex); 5147c478bd9Sstevel@tonic-gate 5157c478bd9Sstevel@tonic-gate ndi_devi_exit(dip, circular_count); 5167c478bd9Sstevel@tonic-gate 5177c478bd9Sstevel@tonic-gate USB_DPRINTF_L4(DPRINT_MASK_ALL, usb_mid->mi_log_handle, 5187c478bd9Sstevel@tonic-gate "usb_mid_bus_config: rval=%d", rval); 5197c478bd9Sstevel@tonic-gate 5207c478bd9Sstevel@tonic-gate return (rval); 5217c478bd9Sstevel@tonic-gate } 5227c478bd9Sstevel@tonic-gate 5237c478bd9Sstevel@tonic-gate 5247c478bd9Sstevel@tonic-gate /* power entry point */ 5257c478bd9Sstevel@tonic-gate /* ARGSUSED */ 5267c478bd9Sstevel@tonic-gate static int 5277c478bd9Sstevel@tonic-gate usb_mid_power(dev_info_t *dip, int comp, int level) 5287c478bd9Sstevel@tonic-gate { 529d73ae94eSgc usb_mid_t *usb_mid; 530d73ae94eSgc usb_common_power_t *midpm; 531d73ae94eSgc int rval = DDI_FAILURE; 5327c478bd9Sstevel@tonic-gate 5337c478bd9Sstevel@tonic-gate usb_mid = usb_mid_obtain_state(dip); 5347c478bd9Sstevel@tonic-gate 5357c478bd9Sstevel@tonic-gate USB_DPRINTF_L4(DPRINT_MASK_PM, usb_mid->mi_log_handle, 5367c478bd9Sstevel@tonic-gate "usb_mid_power: Begin: usb_mid = %p, level = %d", usb_mid, level); 5377c478bd9Sstevel@tonic-gate 5387c478bd9Sstevel@tonic-gate mutex_enter(&usb_mid->mi_mutex); 5397c478bd9Sstevel@tonic-gate midpm = usb_mid->mi_pm; 5407c478bd9Sstevel@tonic-gate 5417c478bd9Sstevel@tonic-gate /* check if we are transitioning to a legal power level */ 542d73ae94eSgc if (USB_DEV_PWRSTATE_OK(midpm->uc_pwr_states, level)) { 5437c478bd9Sstevel@tonic-gate USB_DPRINTF_L2(DPRINT_MASK_PM, usb_mid->mi_log_handle, 5447c478bd9Sstevel@tonic-gate "usb_mid_power: illegal power level = %d " 545d73ae94eSgc "uc_pwr_states = %x", level, midpm->uc_pwr_states); 5467c478bd9Sstevel@tonic-gate 5477c478bd9Sstevel@tonic-gate mutex_exit(&usb_mid->mi_mutex); 5487c478bd9Sstevel@tonic-gate 5497c478bd9Sstevel@tonic-gate return (rval); 5507c478bd9Sstevel@tonic-gate } 5517c478bd9Sstevel@tonic-gate 552*036aa261Sgc rval = usba_common_power(dip, &(midpm->uc_current_power), 553*036aa261Sgc &(usb_mid->mi_dev_state), level); 5547c478bd9Sstevel@tonic-gate 5557c478bd9Sstevel@tonic-gate mutex_exit(&usb_mid->mi_mutex); 5567c478bd9Sstevel@tonic-gate 557d73ae94eSgc return (rval); 5587c478bd9Sstevel@tonic-gate } 5597c478bd9Sstevel@tonic-gate 5607c478bd9Sstevel@tonic-gate 5617c478bd9Sstevel@tonic-gate /* 5627c478bd9Sstevel@tonic-gate * attach/resume entry point 5637c478bd9Sstevel@tonic-gate */ 5647c478bd9Sstevel@tonic-gate static int 5657c478bd9Sstevel@tonic-gate usb_mid_attach(dev_info_t *dip, ddi_attach_cmd_t cmd) 5667c478bd9Sstevel@tonic-gate { 5677c478bd9Sstevel@tonic-gate int instance = ddi_get_instance(dip); 5687c478bd9Sstevel@tonic-gate usb_mid_t *usb_mid = NULL; 569d73ae94eSgc uint_t n_ifs, i; 5707c478bd9Sstevel@tonic-gate size_t size; 5717c478bd9Sstevel@tonic-gate 5727c478bd9Sstevel@tonic-gate switch (cmd) { 5737c478bd9Sstevel@tonic-gate case DDI_ATTACH: 5747c478bd9Sstevel@tonic-gate 5757c478bd9Sstevel@tonic-gate break; 5767c478bd9Sstevel@tonic-gate case DDI_RESUME: 5777c478bd9Sstevel@tonic-gate usb_mid = (usb_mid_t *)ddi_get_soft_state(usb_mid_statep, 5787c478bd9Sstevel@tonic-gate instance); 5797c478bd9Sstevel@tonic-gate (void) usb_mid_restore_device_state(dip, usb_mid); 5807c478bd9Sstevel@tonic-gate 5817c478bd9Sstevel@tonic-gate if (usb_mid->mi_ugen_hdl) { 5827c478bd9Sstevel@tonic-gate (void) usb_ugen_attach(usb_mid->mi_ugen_hdl, 5837c478bd9Sstevel@tonic-gate DDI_RESUME); 5847c478bd9Sstevel@tonic-gate } 5857c478bd9Sstevel@tonic-gate 5867c478bd9Sstevel@tonic-gate return (DDI_SUCCESS); 5877c478bd9Sstevel@tonic-gate default: 5887c478bd9Sstevel@tonic-gate 5897c478bd9Sstevel@tonic-gate return (DDI_FAILURE); 5907c478bd9Sstevel@tonic-gate } 5917c478bd9Sstevel@tonic-gate 5927c478bd9Sstevel@tonic-gate /* 5937c478bd9Sstevel@tonic-gate * Attach: 5947c478bd9Sstevel@tonic-gate * 5957c478bd9Sstevel@tonic-gate * Allocate soft state and initialize 5967c478bd9Sstevel@tonic-gate */ 5977c478bd9Sstevel@tonic-gate if (ddi_soft_state_zalloc(usb_mid_statep, instance) != DDI_SUCCESS) { 5987c478bd9Sstevel@tonic-gate goto fail; 5997c478bd9Sstevel@tonic-gate } 6007c478bd9Sstevel@tonic-gate 6017c478bd9Sstevel@tonic-gate usb_mid = ddi_get_soft_state(usb_mid_statep, instance); 6027c478bd9Sstevel@tonic-gate if (usb_mid == NULL) { 6037c478bd9Sstevel@tonic-gate 6047c478bd9Sstevel@tonic-gate goto fail; 6057c478bd9Sstevel@tonic-gate } 6067c478bd9Sstevel@tonic-gate 6077c478bd9Sstevel@tonic-gate /* allocate handle for logging of messages */ 6087c478bd9Sstevel@tonic-gate usb_mid->mi_log_handle = usb_alloc_log_hdl(dip, "mid", 6097c478bd9Sstevel@tonic-gate &usb_mid_errlevel, 6107c478bd9Sstevel@tonic-gate &usb_mid_errmask, &usb_mid_instance_debug, 6117c478bd9Sstevel@tonic-gate 0); 6127c478bd9Sstevel@tonic-gate 6137c478bd9Sstevel@tonic-gate usb_mid->mi_usba_device = usba_get_usba_device(dip); 6147c478bd9Sstevel@tonic-gate usb_mid->mi_dip = dip; 6157c478bd9Sstevel@tonic-gate usb_mid->mi_instance = instance; 6167c478bd9Sstevel@tonic-gate usb_mid->mi_n_ifs = usb_mid->mi_usba_device->usb_n_ifs; 6177c478bd9Sstevel@tonic-gate 6187c478bd9Sstevel@tonic-gate /* attach client driver to USBA */ 6197c478bd9Sstevel@tonic-gate if (usb_client_attach(dip, USBDRV_VERSION, 0) != USB_SUCCESS) { 6207c478bd9Sstevel@tonic-gate USB_DPRINTF_L2(DPRINT_MASK_ATTA, usb_mid->mi_log_handle, 6217c478bd9Sstevel@tonic-gate "usb_client_attach failed"); 6227c478bd9Sstevel@tonic-gate goto fail; 6237c478bd9Sstevel@tonic-gate } 6247c478bd9Sstevel@tonic-gate if (usb_get_dev_data(dip, &usb_mid->mi_dev_data, USB_PARSE_LVL_NONE, 6257c478bd9Sstevel@tonic-gate 0) != USB_SUCCESS) { 6267c478bd9Sstevel@tonic-gate USB_DPRINTF_L2(DPRINT_MASK_ATTA, usb_mid->mi_log_handle, 6277c478bd9Sstevel@tonic-gate "usb_get_dev_data failed"); 6287c478bd9Sstevel@tonic-gate goto fail; 6297c478bd9Sstevel@tonic-gate } 6307c478bd9Sstevel@tonic-gate 6317c478bd9Sstevel@tonic-gate mutex_init(&usb_mid->mi_mutex, NULL, MUTEX_DRIVER, 6327c478bd9Sstevel@tonic-gate usb_mid->mi_dev_data->dev_iblock_cookie); 6337c478bd9Sstevel@tonic-gate 6347c478bd9Sstevel@tonic-gate usb_free_dev_data(dip, usb_mid->mi_dev_data); 6357c478bd9Sstevel@tonic-gate usb_mid->mi_dev_data = NULL; 6367c478bd9Sstevel@tonic-gate 6377c478bd9Sstevel@tonic-gate usb_mid->mi_init_state |= USB_MID_LOCK_INIT; 6387c478bd9Sstevel@tonic-gate 6397c478bd9Sstevel@tonic-gate if (ddi_create_minor_node(dip, "usb_mid", S_IFCHR, 6407c478bd9Sstevel@tonic-gate instance << USB_MID_MINOR_INSTANCE_SHIFT, 6417c478bd9Sstevel@tonic-gate DDI_NT_NEXUS, 0) != DDI_SUCCESS) { 642d291d9f2Sfrits USB_DPRINTF_L2(DPRINT_MASK_ATTA, usb_mid->mi_log_handle, 6437c478bd9Sstevel@tonic-gate "cannot create devctl minor node"); 6447c478bd9Sstevel@tonic-gate goto fail; 6457c478bd9Sstevel@tonic-gate } 6467c478bd9Sstevel@tonic-gate 6477c478bd9Sstevel@tonic-gate usb_mid->mi_init_state |= USB_MID_MINOR_NODE_CREATED; 6487c478bd9Sstevel@tonic-gate 6497c478bd9Sstevel@tonic-gate /* 6507c478bd9Sstevel@tonic-gate * allocate array for keeping track of child dips 6517c478bd9Sstevel@tonic-gate */ 6527c478bd9Sstevel@tonic-gate n_ifs = usb_mid->mi_n_ifs; 6537c478bd9Sstevel@tonic-gate usb_mid->mi_cd_list_length = size = (sizeof (dev_info_t *)) * n_ifs; 6547c478bd9Sstevel@tonic-gate 6557c478bd9Sstevel@tonic-gate usb_mid->mi_children_dips = kmem_zalloc(size, KM_SLEEP); 6567c478bd9Sstevel@tonic-gate usb_mid->mi_child_events = kmem_zalloc(sizeof (uint8_t) * n_ifs, 6577c478bd9Sstevel@tonic-gate KM_SLEEP); 658d73ae94eSgc usb_mid->mi_children_ifs = kmem_zalloc(sizeof (uint_t) * n_ifs, 659d73ae94eSgc KM_SLEEP); 660d73ae94eSgc for (i = 0; i < n_ifs; i++) { 661d73ae94eSgc usb_mid->mi_children_ifs[i] = 1; 662d73ae94eSgc } 663d73ae94eSgc 6647c478bd9Sstevel@tonic-gate /* 6657c478bd9Sstevel@tonic-gate * Event handling: definition and registration 6667c478bd9Sstevel@tonic-gate * get event handle for events that we have defined 6677c478bd9Sstevel@tonic-gate */ 6687c478bd9Sstevel@tonic-gate (void) ndi_event_alloc_hdl(dip, 0, &usb_mid->mi_ndi_event_hdl, 6697c478bd9Sstevel@tonic-gate NDI_SLEEP); 6707c478bd9Sstevel@tonic-gate 6717c478bd9Sstevel@tonic-gate /* bind event set to the handle */ 6727c478bd9Sstevel@tonic-gate if (ndi_event_bind_set(usb_mid->mi_ndi_event_hdl, &usb_mid_ndi_events, 6737c478bd9Sstevel@tonic-gate NDI_SLEEP)) { 6747c478bd9Sstevel@tonic-gate USB_DPRINTF_L2(DPRINT_MASK_ATTA, usb_mid->mi_log_handle, 6757c478bd9Sstevel@tonic-gate "usb_mid_attach: binding event set failed"); 6767c478bd9Sstevel@tonic-gate 6777c478bd9Sstevel@tonic-gate goto fail; 6787c478bd9Sstevel@tonic-gate } 6797c478bd9Sstevel@tonic-gate 6807c478bd9Sstevel@tonic-gate usb_mid->mi_dev_state = USB_DEV_ONLINE; 6817c478bd9Sstevel@tonic-gate 6827c478bd9Sstevel@tonic-gate /* 6837c478bd9Sstevel@tonic-gate * now create components to power manage this device 6847c478bd9Sstevel@tonic-gate * before attaching children 6857c478bd9Sstevel@tonic-gate */ 6867c478bd9Sstevel@tonic-gate usb_mid_create_pm_components(dip, usb_mid); 6877c478bd9Sstevel@tonic-gate 6887c478bd9Sstevel@tonic-gate /* event registration for events from our parent */ 689d73ae94eSgc usba_common_register_events(usb_mid->mi_dip, 1, usb_mid_event_cb); 6907c478bd9Sstevel@tonic-gate 6917c478bd9Sstevel@tonic-gate usb_mid->mi_init_state |= USB_MID_EVENTS_REGISTERED; 6927c478bd9Sstevel@tonic-gate 6937c478bd9Sstevel@tonic-gate ddi_report_dev(dip); 6947c478bd9Sstevel@tonic-gate 6957c478bd9Sstevel@tonic-gate return (DDI_SUCCESS); 6967c478bd9Sstevel@tonic-gate 6977c478bd9Sstevel@tonic-gate fail: 698d291d9f2Sfrits USB_DPRINTF_L2(DPRINT_MASK_ATTA, NULL, "usb_mid%d cannot attach", 6997c478bd9Sstevel@tonic-gate instance); 7007c478bd9Sstevel@tonic-gate 7017c478bd9Sstevel@tonic-gate if (usb_mid) { 7027c478bd9Sstevel@tonic-gate (void) usb_mid_cleanup(dip, usb_mid); 7037c478bd9Sstevel@tonic-gate } 7047c478bd9Sstevel@tonic-gate 7057c478bd9Sstevel@tonic-gate return (DDI_FAILURE); 7067c478bd9Sstevel@tonic-gate } 7077c478bd9Sstevel@tonic-gate 7087c478bd9Sstevel@tonic-gate 7097c478bd9Sstevel@tonic-gate /* detach or suspend this instance */ 7107c478bd9Sstevel@tonic-gate static int 7117c478bd9Sstevel@tonic-gate usb_mid_detach(dev_info_t *dip, ddi_detach_cmd_t cmd) 7127c478bd9Sstevel@tonic-gate { 7137c478bd9Sstevel@tonic-gate usb_mid_t *usb_mid = usb_mid_obtain_state(dip); 7147c478bd9Sstevel@tonic-gate 7157c478bd9Sstevel@tonic-gate USB_DPRINTF_L4(DPRINT_MASK_ATTA, usb_mid->mi_log_handle, 7167c478bd9Sstevel@tonic-gate "usb_mid_detach: cmd = 0x%x", cmd); 7177c478bd9Sstevel@tonic-gate 7187c478bd9Sstevel@tonic-gate switch (cmd) { 7197c478bd9Sstevel@tonic-gate case DDI_DETACH: 7207c478bd9Sstevel@tonic-gate 7217c478bd9Sstevel@tonic-gate return (usb_mid_cleanup(dip, usb_mid)); 7227c478bd9Sstevel@tonic-gate case DDI_SUSPEND: 7237c478bd9Sstevel@tonic-gate /* nothing to do */ 7247c478bd9Sstevel@tonic-gate mutex_enter(&usb_mid->mi_mutex); 7257c478bd9Sstevel@tonic-gate usb_mid->mi_dev_state = USB_DEV_SUSPENDED; 7267c478bd9Sstevel@tonic-gate mutex_exit(&usb_mid->mi_mutex); 7277c478bd9Sstevel@tonic-gate 7287c478bd9Sstevel@tonic-gate if (usb_mid->mi_ugen_hdl) { 7297c478bd9Sstevel@tonic-gate int rval = usb_ugen_detach(usb_mid->mi_ugen_hdl, 7307c478bd9Sstevel@tonic-gate DDI_SUSPEND); 7317c478bd9Sstevel@tonic-gate return (rval == USB_SUCCESS ? DDI_SUCCESS : 7327c478bd9Sstevel@tonic-gate DDI_FAILURE); 7337c478bd9Sstevel@tonic-gate } 7347c478bd9Sstevel@tonic-gate 7357c478bd9Sstevel@tonic-gate return (DDI_SUCCESS); 7367c478bd9Sstevel@tonic-gate default: 7377c478bd9Sstevel@tonic-gate 7387c478bd9Sstevel@tonic-gate return (DDI_FAILURE); 7397c478bd9Sstevel@tonic-gate } 7407c478bd9Sstevel@tonic-gate 7417c478bd9Sstevel@tonic-gate _NOTE(NOT_REACHED) 7427c478bd9Sstevel@tonic-gate /* NOTREACHED */ 7437c478bd9Sstevel@tonic-gate } 7447c478bd9Sstevel@tonic-gate 7457c478bd9Sstevel@tonic-gate 7467c478bd9Sstevel@tonic-gate /* 7477c478bd9Sstevel@tonic-gate * usb_mid_cleanup: 7487c478bd9Sstevel@tonic-gate * cleanup usb_mid and deallocate. this function is called for 7497c478bd9Sstevel@tonic-gate * handling attach failures and detaching including dynamic 7507c478bd9Sstevel@tonic-gate * reconfiguration 7517c478bd9Sstevel@tonic-gate */ 7527c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 7537c478bd9Sstevel@tonic-gate static int 7547c478bd9Sstevel@tonic-gate usb_mid_cleanup(dev_info_t *dip, usb_mid_t *usb_mid) 7557c478bd9Sstevel@tonic-gate { 756d73ae94eSgc usb_common_power_t *midpm; 7577c478bd9Sstevel@tonic-gate int rval; 7587c478bd9Sstevel@tonic-gate 7597c478bd9Sstevel@tonic-gate USB_DPRINTF_L4(DPRINT_MASK_ATTA, usb_mid->mi_log_handle, 7607c478bd9Sstevel@tonic-gate "usb_mid_cleanup:"); 7617c478bd9Sstevel@tonic-gate 7627c478bd9Sstevel@tonic-gate if ((usb_mid->mi_init_state & USB_MID_LOCK_INIT) == 0) { 7637c478bd9Sstevel@tonic-gate 7647c478bd9Sstevel@tonic-gate goto done; 7657c478bd9Sstevel@tonic-gate } 7667c478bd9Sstevel@tonic-gate 7677c478bd9Sstevel@tonic-gate /* 7687c478bd9Sstevel@tonic-gate * deallocate events, if events are still registered 7697c478bd9Sstevel@tonic-gate * (ie. children still attached) then we have to fail the detach 7707c478bd9Sstevel@tonic-gate */ 7717c478bd9Sstevel@tonic-gate if (usb_mid->mi_ndi_event_hdl && 7727c478bd9Sstevel@tonic-gate (ndi_event_free_hdl(usb_mid->mi_ndi_event_hdl) != NDI_SUCCESS)) { 7737c478bd9Sstevel@tonic-gate 774d291d9f2Sfrits USB_DPRINTF_L2(DPRINT_MASK_ATTA, usb_mid->mi_log_handle, 7757c478bd9Sstevel@tonic-gate "usb_mid_cleanup: ndi_event_free_hdl failed"); 7767c478bd9Sstevel@tonic-gate 7777c478bd9Sstevel@tonic-gate return (DDI_FAILURE); 7787c478bd9Sstevel@tonic-gate } 7797c478bd9Sstevel@tonic-gate 7807c478bd9Sstevel@tonic-gate /* 7817c478bd9Sstevel@tonic-gate * Disable the event callbacks, after this point, event 7827c478bd9Sstevel@tonic-gate * callbacks will never get called. Note we shouldn't hold 7837c478bd9Sstevel@tonic-gate * mutex while unregistering events because there may be a 7847c478bd9Sstevel@tonic-gate * competing event callback thread. Event callbacks are done 7857c478bd9Sstevel@tonic-gate * with ndi mutex held and this can cause a potential deadlock. 7867c478bd9Sstevel@tonic-gate * Note that cleanup can't fail after deregistration of events. 7877c478bd9Sstevel@tonic-gate */ 7887c478bd9Sstevel@tonic-gate if (usb_mid->mi_init_state & USB_MID_EVENTS_REGISTERED) { 789d73ae94eSgc usba_common_unregister_events(usb_mid->mi_dip, 1); 7907c478bd9Sstevel@tonic-gate } 7917c478bd9Sstevel@tonic-gate 7927c478bd9Sstevel@tonic-gate midpm = usb_mid->mi_pm; 7937c478bd9Sstevel@tonic-gate 7947c478bd9Sstevel@tonic-gate mutex_enter(&usb_mid->mi_mutex); 7957c478bd9Sstevel@tonic-gate 7967c478bd9Sstevel@tonic-gate if ((midpm) && (usb_mid->mi_dev_state != USB_DEV_DISCONNECTED)) { 7977c478bd9Sstevel@tonic-gate 7987c478bd9Sstevel@tonic-gate mutex_exit(&usb_mid->mi_mutex); 7997c478bd9Sstevel@tonic-gate 8007c478bd9Sstevel@tonic-gate (void) pm_busy_component(dip, 0); 801d73ae94eSgc if (midpm->uc_wakeup_enabled) { 8027c478bd9Sstevel@tonic-gate 8037c478bd9Sstevel@tonic-gate /* First bring the device to full power */ 8047c478bd9Sstevel@tonic-gate (void) pm_raise_power(dip, 0, USB_DEV_OS_FULL_PWR); 8057c478bd9Sstevel@tonic-gate 8067c478bd9Sstevel@tonic-gate rval = usb_handle_remote_wakeup(dip, 8077c478bd9Sstevel@tonic-gate USB_REMOTE_WAKEUP_DISABLE); 8087c478bd9Sstevel@tonic-gate 8097c478bd9Sstevel@tonic-gate if (rval != DDI_SUCCESS) { 8107c478bd9Sstevel@tonic-gate USB_DPRINTF_L2(DPRINT_MASK_EVENTS, 8117c478bd9Sstevel@tonic-gate usb_mid->mi_log_handle, 8127c478bd9Sstevel@tonic-gate "usb_cleanup: disable remote " 8137c478bd9Sstevel@tonic-gate "wakeup failed, rval=%d", rval); 8147c478bd9Sstevel@tonic-gate } 8157c478bd9Sstevel@tonic-gate } 8167c478bd9Sstevel@tonic-gate 8177c478bd9Sstevel@tonic-gate (void) pm_lower_power(usb_mid->mi_dip, 0, USB_DEV_OS_PWR_OFF); 8187c478bd9Sstevel@tonic-gate (void) pm_idle_component(dip, 0); 8197c478bd9Sstevel@tonic-gate } else { 8207c478bd9Sstevel@tonic-gate mutex_exit(&usb_mid->mi_mutex); 8217c478bd9Sstevel@tonic-gate } 8227c478bd9Sstevel@tonic-gate 8237c478bd9Sstevel@tonic-gate if (midpm) { 824d73ae94eSgc kmem_free(midpm, sizeof (usb_common_power_t)); 8257c478bd9Sstevel@tonic-gate } 8267c478bd9Sstevel@tonic-gate 8277c478bd9Sstevel@tonic-gate /* free children list */ 8287c478bd9Sstevel@tonic-gate if (usb_mid->mi_children_dips) { 8297c478bd9Sstevel@tonic-gate kmem_free(usb_mid->mi_children_dips, 8307c478bd9Sstevel@tonic-gate usb_mid->mi_cd_list_length); 8317c478bd9Sstevel@tonic-gate } 8327c478bd9Sstevel@tonic-gate 8337c478bd9Sstevel@tonic-gate if (usb_mid->mi_child_events) { 8347c478bd9Sstevel@tonic-gate kmem_free(usb_mid->mi_child_events, sizeof (uint8_t) * 8357c478bd9Sstevel@tonic-gate usb_mid->mi_n_ifs); 8367c478bd9Sstevel@tonic-gate } 8377c478bd9Sstevel@tonic-gate 838d73ae94eSgc if (usb_mid->mi_children_ifs) { 839d73ae94eSgc kmem_free(usb_mid->mi_children_ifs, sizeof (uint_t) * 840d73ae94eSgc usb_mid->mi_n_ifs); 841d73ae94eSgc } 842d73ae94eSgc 8437c478bd9Sstevel@tonic-gate if (usb_mid->mi_init_state & USB_MID_MINOR_NODE_CREATED) { 8447c478bd9Sstevel@tonic-gate ddi_remove_minor_node(dip, NULL); 8457c478bd9Sstevel@tonic-gate } 8467c478bd9Sstevel@tonic-gate 8477c478bd9Sstevel@tonic-gate mutex_destroy(&usb_mid->mi_mutex); 8487c478bd9Sstevel@tonic-gate 8497c478bd9Sstevel@tonic-gate done: 8507c478bd9Sstevel@tonic-gate usb_client_detach(dip, usb_mid->mi_dev_data); 8517c478bd9Sstevel@tonic-gate 8527c478bd9Sstevel@tonic-gate if (usb_mid->mi_ugen_hdl) { 8537c478bd9Sstevel@tonic-gate (void) usb_ugen_detach(usb_mid->mi_ugen_hdl, DDI_DETACH); 8547c478bd9Sstevel@tonic-gate usb_ugen_release_hdl(usb_mid->mi_ugen_hdl); 8557c478bd9Sstevel@tonic-gate } 8567c478bd9Sstevel@tonic-gate 8577c478bd9Sstevel@tonic-gate usb_free_log_hdl(usb_mid->mi_log_handle); 8587c478bd9Sstevel@tonic-gate ddi_soft_state_free(usb_mid_statep, ddi_get_instance(dip)); 8597c478bd9Sstevel@tonic-gate 8607c478bd9Sstevel@tonic-gate ddi_prop_remove_all(dip); 8617c478bd9Sstevel@tonic-gate 8627c478bd9Sstevel@tonic-gate return (DDI_SUCCESS); 8637c478bd9Sstevel@tonic-gate } 8647c478bd9Sstevel@tonic-gate 8657c478bd9Sstevel@tonic-gate 8667c478bd9Sstevel@tonic-gate static void 8677c478bd9Sstevel@tonic-gate usb_mid_ugen_attach(usb_mid_t *usb_mid, boolean_t remove_children) 8687c478bd9Sstevel@tonic-gate { 8697c478bd9Sstevel@tonic-gate _NOTE(NO_COMPETING_THREADS_NOW); 8707c478bd9Sstevel@tonic-gate 8717c478bd9Sstevel@tonic-gate if (usb_mid->mi_ugen_hdl == NULL) { 8727c478bd9Sstevel@tonic-gate usb_ugen_info_t usb_ugen_info; 8737c478bd9Sstevel@tonic-gate int rval; 8747c478bd9Sstevel@tonic-gate usb_ugen_hdl_t hdl; 8757c478bd9Sstevel@tonic-gate 8767c478bd9Sstevel@tonic-gate USB_DPRINTF_L4(DPRINT_MASK_ATTA, usb_mid->mi_log_handle, 8777c478bd9Sstevel@tonic-gate "usb_mid_ugen_attach: get handle"); 8787c478bd9Sstevel@tonic-gate 8797c478bd9Sstevel@tonic-gate bzero(&usb_ugen_info, sizeof (usb_ugen_info)); 8807c478bd9Sstevel@tonic-gate 8817c478bd9Sstevel@tonic-gate usb_ugen_info.usb_ugen_flags = (remove_children ? 8827c478bd9Sstevel@tonic-gate USB_UGEN_REMOVE_CHILDREN : 0); 8837c478bd9Sstevel@tonic-gate usb_ugen_info.usb_ugen_minor_node_ugen_bits_mask = 8847c478bd9Sstevel@tonic-gate (dev_t)USB_MID_MINOR_UGEN_BITS_MASK; 8857c478bd9Sstevel@tonic-gate usb_ugen_info.usb_ugen_minor_node_instance_mask = 8867c478bd9Sstevel@tonic-gate (dev_t)~USB_MID_MINOR_UGEN_BITS_MASK; 8877c478bd9Sstevel@tonic-gate 8887c478bd9Sstevel@tonic-gate mutex_exit(&usb_mid->mi_mutex); 8897c478bd9Sstevel@tonic-gate hdl = usb_ugen_get_hdl(usb_mid->mi_dip, 8907c478bd9Sstevel@tonic-gate &usb_ugen_info); 8917c478bd9Sstevel@tonic-gate 8927c478bd9Sstevel@tonic-gate if ((rval = usb_ugen_attach(hdl, DDI_ATTACH)) != USB_SUCCESS) { 8937c478bd9Sstevel@tonic-gate USB_DPRINTF_L4(DPRINT_MASK_ATTA, usb_mid->mi_log_handle, 8947c478bd9Sstevel@tonic-gate "failed to create ugen support (%d)", rval); 8957c478bd9Sstevel@tonic-gate usb_ugen_release_hdl(hdl); 8967c478bd9Sstevel@tonic-gate 8977c478bd9Sstevel@tonic-gate mutex_enter(&usb_mid->mi_mutex); 8987c478bd9Sstevel@tonic-gate } else { 8997c478bd9Sstevel@tonic-gate mutex_enter(&usb_mid->mi_mutex); 9007c478bd9Sstevel@tonic-gate usb_mid->mi_ugen_hdl = hdl; 9017c478bd9Sstevel@tonic-gate } 9027c478bd9Sstevel@tonic-gate } 9037c478bd9Sstevel@tonic-gate 904055d7c80Scarlsonj #ifndef lint 9057c478bd9Sstevel@tonic-gate _NOTE(COMPETING_THREADS_NOW); 906055d7c80Scarlsonj #endif 9077c478bd9Sstevel@tonic-gate } 9087c478bd9Sstevel@tonic-gate 9097c478bd9Sstevel@tonic-gate 9107c478bd9Sstevel@tonic-gate /* 9117c478bd9Sstevel@tonic-gate * usb_mid_create_children: 9127c478bd9Sstevel@tonic-gate */ 9137c478bd9Sstevel@tonic-gate static void 9147c478bd9Sstevel@tonic-gate usb_mid_create_children(usb_mid_t *usb_mid) 9157c478bd9Sstevel@tonic-gate { 9167c478bd9Sstevel@tonic-gate usba_device_t *usba_device; 917d73ae94eSgc uint_t n_ifs, if_count; 918d73ae94eSgc uint_t i, j; 919d73ae94eSgc dev_info_t *cdip, *ia_dip; 9207c478bd9Sstevel@tonic-gate uint_t ugen_bound = 0; 9217c478bd9Sstevel@tonic-gate uint_t bound_children = 0; 9227c478bd9Sstevel@tonic-gate 9237c478bd9Sstevel@tonic-gate usba_device = usba_get_usba_device(usb_mid->mi_dip); 9247c478bd9Sstevel@tonic-gate 9257c478bd9Sstevel@tonic-gate USB_DPRINTF_L4(DPRINT_MASK_ATTA, usb_mid->mi_log_handle, 9267c478bd9Sstevel@tonic-gate "usb_mid_attach_child_drivers: port = %d, address = %d", 9277c478bd9Sstevel@tonic-gate usba_device->usb_port, usba_device->usb_addr); 9287c478bd9Sstevel@tonic-gate 9297c478bd9Sstevel@tonic-gate if (usb_mid->mi_removed_children) { 9307c478bd9Sstevel@tonic-gate 9317c478bd9Sstevel@tonic-gate return; 9327c478bd9Sstevel@tonic-gate } 9337c478bd9Sstevel@tonic-gate 9347c478bd9Sstevel@tonic-gate n_ifs = usb_mid->mi_n_ifs; 935d73ae94eSgc if_count = 1; 9367c478bd9Sstevel@tonic-gate 9377c478bd9Sstevel@tonic-gate USB_DPRINTF_L4(DPRINT_MASK_ATTA, usb_mid->mi_log_handle, 9387c478bd9Sstevel@tonic-gate "usb_mid_create_children: #interfaces = %d", n_ifs); 9397c478bd9Sstevel@tonic-gate 9407c478bd9Sstevel@tonic-gate /* 9417c478bd9Sstevel@tonic-gate * create all children if not already present 9427c478bd9Sstevel@tonic-gate */ 943d73ae94eSgc for (i = 0; i < n_ifs; i += if_count) { 944d73ae94eSgc 945d73ae94eSgc /* ignore since this if is included by an ia */ 946d73ae94eSgc if (usb_mid->mi_children_ifs[i] == 0) { 947d73ae94eSgc 948d73ae94eSgc continue; 949d73ae94eSgc } 950d73ae94eSgc 9517c478bd9Sstevel@tonic-gate if (usb_mid->mi_children_dips[i] != NULL) { 9524610e4a0Sfrits if (i_ddi_node_state( 9534610e4a0Sfrits usb_mid->mi_children_dips[i]) >= 9544610e4a0Sfrits DS_BOUND) { 9554610e4a0Sfrits bound_children++; 9564610e4a0Sfrits } 9577c478bd9Sstevel@tonic-gate 9587c478bd9Sstevel@tonic-gate continue; 9597c478bd9Sstevel@tonic-gate } 9607c478bd9Sstevel@tonic-gate 9617c478bd9Sstevel@tonic-gate mutex_exit(&usb_mid->mi_mutex); 962d73ae94eSgc ia_dip = usba_ready_interface_association_node(usb_mid->mi_dip, 963d73ae94eSgc i, &if_count); 964d73ae94eSgc 965d73ae94eSgc if (ia_dip != NULL) { 966d73ae94eSgc if (usba_bind_driver(ia_dip) == USB_SUCCESS) { 967d73ae94eSgc bound_children++; 968d73ae94eSgc if (strcmp(ddi_driver_name(ia_dip), 969d73ae94eSgc "ugen") == 0) { 970d73ae94eSgc ugen_bound++; 971d73ae94eSgc } 972d73ae94eSgc } 973d73ae94eSgc 974d73ae94eSgc /* 975d73ae94eSgc * IA node owns if_count interfaces. 976d73ae94eSgc * The rest interfaces own none. 977d73ae94eSgc */ 978d73ae94eSgc mutex_enter(&usb_mid->mi_mutex); 979d73ae94eSgc usb_mid->mi_children_dips[i] = ia_dip; 980d73ae94eSgc usb_mid->mi_children_ifs[i] = if_count; 981d73ae94eSgc for (j = i + 1; j < i + if_count; j++) { 982d73ae94eSgc usb_mid->mi_children_ifs[j] = 0; 983d73ae94eSgc } 984d73ae94eSgc 985d73ae94eSgc continue; 986d73ae94eSgc } 987d73ae94eSgc 9887c478bd9Sstevel@tonic-gate cdip = usba_ready_interface_node(usb_mid->mi_dip, i); 989d73ae94eSgc 9907c478bd9Sstevel@tonic-gate if (cdip != NULL) { 991d73ae94eSgc if (usba_bind_driver(cdip) == 9927c478bd9Sstevel@tonic-gate USB_SUCCESS) { 9937c478bd9Sstevel@tonic-gate bound_children++; 9947c478bd9Sstevel@tonic-gate if (strcmp(ddi_driver_name(cdip), 9957c478bd9Sstevel@tonic-gate "ugen") == 0) { 9967c478bd9Sstevel@tonic-gate ugen_bound++; 9977c478bd9Sstevel@tonic-gate } 9987c478bd9Sstevel@tonic-gate } 9997c478bd9Sstevel@tonic-gate 1000d73ae94eSgc /* 1001d73ae94eSgc * interface node owns 1 interface always. 1002d73ae94eSgc */ 1003d73ae94eSgc mutex_enter(&usb_mid->mi_mutex); 10047c478bd9Sstevel@tonic-gate usb_mid->mi_children_dips[i] = cdip; 1005d73ae94eSgc usb_mid->mi_children_ifs[i] = 1; 1006d73ae94eSgc mutex_exit(&usb_mid->mi_mutex); 10077c478bd9Sstevel@tonic-gate 10087c478bd9Sstevel@tonic-gate } 1009d73ae94eSgc 1010d73ae94eSgc mutex_enter(&usb_mid->mi_mutex); 10117c478bd9Sstevel@tonic-gate } 10127c478bd9Sstevel@tonic-gate 10137c478bd9Sstevel@tonic-gate usb_mid->mi_removed_children = (bound_children ? B_FALSE : B_TRUE); 10147c478bd9Sstevel@tonic-gate 10157c478bd9Sstevel@tonic-gate /* 10167c478bd9Sstevel@tonic-gate * if there are no ugen interface children, create ugen support at 10177c478bd9Sstevel@tonic-gate * device level, use a separate thread because we may be at interrupt 10187c478bd9Sstevel@tonic-gate * level 10197c478bd9Sstevel@tonic-gate */ 10207c478bd9Sstevel@tonic-gate if ((ugen_bound == 0) && (usb_mid->mi_ugen_hdl == NULL)) { 10217c478bd9Sstevel@tonic-gate /* 10227c478bd9Sstevel@tonic-gate * we only need to remove the children if there are 10237c478bd9Sstevel@tonic-gate * multiple configurations which would fail if there 10247c478bd9Sstevel@tonic-gate * are child interfaces 10257c478bd9Sstevel@tonic-gate */ 10267c478bd9Sstevel@tonic-gate if ((usb_mid->mi_removed_children == B_FALSE) && 10277c478bd9Sstevel@tonic-gate (usba_device->usb_n_cfgs > 1)) { 10287c478bd9Sstevel@tonic-gate USB_DPRINTF_L1(DPRINT_MASK_ATTA, 10297c478bd9Sstevel@tonic-gate usb_mid->mi_log_handle, 10307c478bd9Sstevel@tonic-gate "can't support ugen for multiple " 10317c478bd9Sstevel@tonic-gate "configurations devices that have attached " 10327c478bd9Sstevel@tonic-gate "child interface drivers"); 10337c478bd9Sstevel@tonic-gate } else { 10347c478bd9Sstevel@tonic-gate usb_mid_ugen_attach(usb_mid, 10357c478bd9Sstevel@tonic-gate usb_mid->mi_removed_children); 10367c478bd9Sstevel@tonic-gate } 10377c478bd9Sstevel@tonic-gate } 10387c478bd9Sstevel@tonic-gate } 10397c478bd9Sstevel@tonic-gate 10407c478bd9Sstevel@tonic-gate 10417c478bd9Sstevel@tonic-gate /* 10427c478bd9Sstevel@tonic-gate * event support 10437c478bd9Sstevel@tonic-gate */ 10447c478bd9Sstevel@tonic-gate static int 10457c478bd9Sstevel@tonic-gate usb_mid_busop_get_eventcookie(dev_info_t *dip, 10467c478bd9Sstevel@tonic-gate dev_info_t *rdip, char *eventname, ddi_eventcookie_t *cookie) 10477c478bd9Sstevel@tonic-gate { 10487c478bd9Sstevel@tonic-gate usb_mid_t *usb_mid = usb_mid_obtain_state(dip); 10497c478bd9Sstevel@tonic-gate 10507c478bd9Sstevel@tonic-gate USB_DPRINTF_L3(DPRINT_MASK_EVENTS, usb_mid->mi_log_handle, 10517c478bd9Sstevel@tonic-gate "usb_mid_busop_get_eventcookie: dip=0x%p, rdip=0x%p, " 10527c478bd9Sstevel@tonic-gate "event=%s", (void *)dip, (void *)rdip, eventname); 10537c478bd9Sstevel@tonic-gate USB_DPRINTF_L3(DPRINT_MASK_EVENTS, usb_mid->mi_log_handle, 10547c478bd9Sstevel@tonic-gate "(dip=%s%d rdip=%s%d)", 10557c478bd9Sstevel@tonic-gate ddi_driver_name(dip), ddi_get_instance(dip), 10567c478bd9Sstevel@tonic-gate ddi_driver_name(rdip), ddi_get_instance(rdip)); 10577c478bd9Sstevel@tonic-gate 10587c478bd9Sstevel@tonic-gate /* return event cookie, iblock cookie, and level */ 10597c478bd9Sstevel@tonic-gate return (ndi_event_retrieve_cookie(usb_mid->mi_ndi_event_hdl, 10607c478bd9Sstevel@tonic-gate rdip, eventname, cookie, NDI_EVENT_NOPASS)); 10617c478bd9Sstevel@tonic-gate } 10627c478bd9Sstevel@tonic-gate 10637c478bd9Sstevel@tonic-gate 10647c478bd9Sstevel@tonic-gate static int 10657c478bd9Sstevel@tonic-gate usb_mid_busop_add_eventcall(dev_info_t *dip, 10667c478bd9Sstevel@tonic-gate dev_info_t *rdip, 10677c478bd9Sstevel@tonic-gate ddi_eventcookie_t cookie, 10687c478bd9Sstevel@tonic-gate void (*callback)(dev_info_t *dip, 10697c478bd9Sstevel@tonic-gate ddi_eventcookie_t cookie, void *arg, 10707c478bd9Sstevel@tonic-gate void *bus_impldata), 10717c478bd9Sstevel@tonic-gate void *arg, ddi_callback_id_t *cb_id) 10727c478bd9Sstevel@tonic-gate { 10737c478bd9Sstevel@tonic-gate usb_mid_t *usb_mid = usb_mid_obtain_state(dip); 10747c478bd9Sstevel@tonic-gate int ifno = usba_get_ifno(rdip); 10757c478bd9Sstevel@tonic-gate 10767c478bd9Sstevel@tonic-gate USB_DPRINTF_L3(DPRINT_MASK_EVENTS, usb_mid->mi_log_handle, 10777c478bd9Sstevel@tonic-gate "usb_mid_busop_add_eventcall: dip=0x%p, rdip=0x%p " 10787c478bd9Sstevel@tonic-gate "cookie=0x%p, cb=0x%p, arg=0x%p", 10797c478bd9Sstevel@tonic-gate (void *)dip, (void *)rdip, (void *)cookie, (void *)callback, arg); 10807c478bd9Sstevel@tonic-gate USB_DPRINTF_L3(DPRINT_MASK_EVENTS, usb_mid->mi_log_handle, 10817c478bd9Sstevel@tonic-gate "(dip=%s%d rdip=%s%d event=%s)", 10827c478bd9Sstevel@tonic-gate ddi_driver_name(dip), ddi_get_instance(dip), 10837c478bd9Sstevel@tonic-gate ddi_driver_name(rdip), ddi_get_instance(rdip), 10847c478bd9Sstevel@tonic-gate ndi_event_cookie_to_name(usb_mid->mi_ndi_event_hdl, cookie)); 10857c478bd9Sstevel@tonic-gate 10867c478bd9Sstevel@tonic-gate /* Set flag on children registering events */ 10877c478bd9Sstevel@tonic-gate switch (ndi_event_cookie_to_tag(usb_mid->mi_ndi_event_hdl, cookie)) { 10887c478bd9Sstevel@tonic-gate case USBA_EVENT_TAG_HOT_REMOVAL: 10897c478bd9Sstevel@tonic-gate mutex_enter(&usb_mid->mi_mutex); 10907c478bd9Sstevel@tonic-gate usb_mid->mi_child_events[ifno] |= 10917c478bd9Sstevel@tonic-gate USB_MID_CHILD_EVENT_DISCONNECT; 10927c478bd9Sstevel@tonic-gate mutex_exit(&usb_mid->mi_mutex); 10937c478bd9Sstevel@tonic-gate 10947c478bd9Sstevel@tonic-gate break; 10957c478bd9Sstevel@tonic-gate case USBA_EVENT_TAG_PRE_SUSPEND: 10967c478bd9Sstevel@tonic-gate mutex_enter(&usb_mid->mi_mutex); 10977c478bd9Sstevel@tonic-gate usb_mid->mi_child_events[ifno] |= 10987c478bd9Sstevel@tonic-gate USB_MID_CHILD_EVENT_PRESUSPEND; 10997c478bd9Sstevel@tonic-gate mutex_exit(&usb_mid->mi_mutex); 11007c478bd9Sstevel@tonic-gate 11017c478bd9Sstevel@tonic-gate break; 11027c478bd9Sstevel@tonic-gate default: 11037c478bd9Sstevel@tonic-gate 11047c478bd9Sstevel@tonic-gate break; 11057c478bd9Sstevel@tonic-gate } 11067c478bd9Sstevel@tonic-gate /* add callback (perform registration) */ 11077c478bd9Sstevel@tonic-gate return (ndi_event_add_callback(usb_mid->mi_ndi_event_hdl, 11087c478bd9Sstevel@tonic-gate rdip, cookie, callback, arg, NDI_SLEEP, cb_id)); 11097c478bd9Sstevel@tonic-gate } 11107c478bd9Sstevel@tonic-gate 11117c478bd9Sstevel@tonic-gate 11127c478bd9Sstevel@tonic-gate static int 11137c478bd9Sstevel@tonic-gate usb_mid_busop_remove_eventcall(dev_info_t *dip, ddi_callback_id_t cb_id) 11147c478bd9Sstevel@tonic-gate { 11157c478bd9Sstevel@tonic-gate usb_mid_t *usb_mid = usb_mid_obtain_state(dip); 11167c478bd9Sstevel@tonic-gate ndi_event_callbacks_t *cb = (ndi_event_callbacks_t *)cb_id; 11177c478bd9Sstevel@tonic-gate 11187c478bd9Sstevel@tonic-gate ASSERT(cb); 11197c478bd9Sstevel@tonic-gate 11207c478bd9Sstevel@tonic-gate USB_DPRINTF_L3(DPRINT_MASK_EVENTS, usb_mid->mi_log_handle, 11217c478bd9Sstevel@tonic-gate "usb_mid_busop_remove_eventcall: dip=0x%p, rdip=0x%p " 11227c478bd9Sstevel@tonic-gate "cookie=0x%p", (void *)dip, cb->ndi_evtcb_dip, 11237c478bd9Sstevel@tonic-gate cb->ndi_evtcb_cookie); 11247c478bd9Sstevel@tonic-gate USB_DPRINTF_L3(DPRINT_MASK_EVENTS, usb_mid->mi_log_handle, 11257c478bd9Sstevel@tonic-gate "(dip=%s%d rdip=%s%d event=%s)", 11267c478bd9Sstevel@tonic-gate ddi_driver_name(dip), ddi_get_instance(dip), 11277c478bd9Sstevel@tonic-gate ddi_driver_name(cb->ndi_evtcb_dip), 11287c478bd9Sstevel@tonic-gate ddi_get_instance(cb->ndi_evtcb_dip), 11297c478bd9Sstevel@tonic-gate ndi_event_cookie_to_name(usb_mid->mi_ndi_event_hdl, 11307c478bd9Sstevel@tonic-gate cb->ndi_evtcb_cookie)); 11317c478bd9Sstevel@tonic-gate 11327c478bd9Sstevel@tonic-gate /* remove event registration from our event set */ 11337c478bd9Sstevel@tonic-gate return (ndi_event_remove_callback(usb_mid->mi_ndi_event_hdl, cb_id)); 11347c478bd9Sstevel@tonic-gate } 11357c478bd9Sstevel@tonic-gate 11367c478bd9Sstevel@tonic-gate 11377c478bd9Sstevel@tonic-gate static int 11387c478bd9Sstevel@tonic-gate usb_mid_busop_post_event(dev_info_t *dip, 11397c478bd9Sstevel@tonic-gate dev_info_t *rdip, 11407c478bd9Sstevel@tonic-gate ddi_eventcookie_t cookie, 11417c478bd9Sstevel@tonic-gate void *bus_impldata) 11427c478bd9Sstevel@tonic-gate { 11437c478bd9Sstevel@tonic-gate usb_mid_t *usb_mid = usb_mid_obtain_state(dip); 11447c478bd9Sstevel@tonic-gate 11457c478bd9Sstevel@tonic-gate USB_DPRINTF_L3(DPRINT_MASK_EVENTS, usb_mid->mi_log_handle, 11467c478bd9Sstevel@tonic-gate "usb_mid_busop_post_event: dip=0x%p, rdip=0x%p " 11477c478bd9Sstevel@tonic-gate "cookie=0x%p, impl=0x%p", 11487c478bd9Sstevel@tonic-gate (void *)dip, (void *)rdip, (void *)cookie, bus_impldata); 11497c478bd9Sstevel@tonic-gate USB_DPRINTF_L3(DPRINT_MASK_EVENTS, usb_mid->mi_log_handle, 11507c478bd9Sstevel@tonic-gate "(dip=%s%d rdip=%s%d event=%s)", 11517c478bd9Sstevel@tonic-gate ddi_driver_name(dip), ddi_get_instance(dip), 11527c478bd9Sstevel@tonic-gate ddi_driver_name(rdip), ddi_get_instance(rdip), 11537c478bd9Sstevel@tonic-gate ndi_event_cookie_to_name(usb_mid->mi_ndi_event_hdl, cookie)); 11547c478bd9Sstevel@tonic-gate 11557c478bd9Sstevel@tonic-gate /* post event to all children registered for this event */ 11567c478bd9Sstevel@tonic-gate return (ndi_event_run_callbacks(usb_mid->mi_ndi_event_hdl, rdip, 11577c478bd9Sstevel@tonic-gate cookie, bus_impldata)); 11587c478bd9Sstevel@tonic-gate } 11597c478bd9Sstevel@tonic-gate 11607c478bd9Sstevel@tonic-gate 11617c478bd9Sstevel@tonic-gate /* 11627c478bd9Sstevel@tonic-gate * usb_mid_restore_device_state 11637c478bd9Sstevel@tonic-gate * set the original configuration of the device 11647c478bd9Sstevel@tonic-gate */ 11657c478bd9Sstevel@tonic-gate static int 11667c478bd9Sstevel@tonic-gate usb_mid_restore_device_state(dev_info_t *dip, usb_mid_t *usb_mid) 11677c478bd9Sstevel@tonic-gate { 1168d73ae94eSgc usb_common_power_t *midpm; 11697c478bd9Sstevel@tonic-gate 11707c478bd9Sstevel@tonic-gate USB_DPRINTF_L4(DPRINT_MASK_EVENTS, usb_mid->mi_log_handle, 11717c478bd9Sstevel@tonic-gate "usb_mid_restore_device_state: usb_mid = %p", usb_mid); 11727c478bd9Sstevel@tonic-gate 11737c478bd9Sstevel@tonic-gate mutex_enter(&usb_mid->mi_mutex); 11747c478bd9Sstevel@tonic-gate midpm = usb_mid->mi_pm; 11757c478bd9Sstevel@tonic-gate mutex_exit(&usb_mid->mi_mutex); 11767c478bd9Sstevel@tonic-gate 11777c478bd9Sstevel@tonic-gate /* First bring the device to full power */ 11787c478bd9Sstevel@tonic-gate (void) pm_busy_component(dip, 0); 11797c478bd9Sstevel@tonic-gate (void) pm_raise_power(dip, 0, USB_DEV_OS_FULL_PWR); 11807c478bd9Sstevel@tonic-gate 11817c478bd9Sstevel@tonic-gate if (usb_check_same_device(dip, usb_mid->mi_log_handle, USB_LOG_L0, 11827c478bd9Sstevel@tonic-gate DPRINT_MASK_EVENTS, USB_CHK_VIDPID, NULL) != USB_SUCCESS) { 11837c478bd9Sstevel@tonic-gate 11847c478bd9Sstevel@tonic-gate /* change the device state from suspended to disconnected */ 11857c478bd9Sstevel@tonic-gate mutex_enter(&usb_mid->mi_mutex); 11867c478bd9Sstevel@tonic-gate usb_mid->mi_dev_state = USB_DEV_DISCONNECTED; 11877c478bd9Sstevel@tonic-gate mutex_exit(&usb_mid->mi_mutex); 11887c478bd9Sstevel@tonic-gate (void) pm_idle_component(dip, 0); 11897c478bd9Sstevel@tonic-gate 11907c478bd9Sstevel@tonic-gate return (USB_FAILURE); 11917c478bd9Sstevel@tonic-gate } 11927c478bd9Sstevel@tonic-gate 11937c478bd9Sstevel@tonic-gate /* 11947c478bd9Sstevel@tonic-gate * if the device had remote wakeup earlier, 11957c478bd9Sstevel@tonic-gate * enable it again 11967c478bd9Sstevel@tonic-gate */ 1197d73ae94eSgc if (midpm->uc_wakeup_enabled) { 11987c478bd9Sstevel@tonic-gate (void) usb_handle_remote_wakeup(usb_mid->mi_dip, 11997c478bd9Sstevel@tonic-gate USB_REMOTE_WAKEUP_ENABLE); 12007c478bd9Sstevel@tonic-gate } 12017c478bd9Sstevel@tonic-gate 12027c478bd9Sstevel@tonic-gate mutex_enter(&usb_mid->mi_mutex); 12037c478bd9Sstevel@tonic-gate usb_mid->mi_dev_state = USB_DEV_ONLINE; 12047c478bd9Sstevel@tonic-gate mutex_exit(&usb_mid->mi_mutex); 12057c478bd9Sstevel@tonic-gate 12067c478bd9Sstevel@tonic-gate (void) pm_idle_component(dip, 0); 12077c478bd9Sstevel@tonic-gate 12087c478bd9Sstevel@tonic-gate return (USB_SUCCESS); 12097c478bd9Sstevel@tonic-gate } 12107c478bd9Sstevel@tonic-gate 12117c478bd9Sstevel@tonic-gate 12127c478bd9Sstevel@tonic-gate /* 12137c478bd9Sstevel@tonic-gate * usb_mid_event_cb() 12147c478bd9Sstevel@tonic-gate * handle disconnect and connect events 12157c478bd9Sstevel@tonic-gate */ 12167c478bd9Sstevel@tonic-gate static void 12177c478bd9Sstevel@tonic-gate usb_mid_event_cb(dev_info_t *dip, ddi_eventcookie_t cookie, 12187c478bd9Sstevel@tonic-gate void *arg, void *bus_impldata) 12197c478bd9Sstevel@tonic-gate { 12207c478bd9Sstevel@tonic-gate int i, tag; 12217c478bd9Sstevel@tonic-gate usb_mid_t *usb_mid = usb_mid_obtain_state(dip); 12227c478bd9Sstevel@tonic-gate dev_info_t *child_dip; 12237c478bd9Sstevel@tonic-gate ddi_eventcookie_t rm_cookie, ins_cookie, suspend_cookie, resume_cookie; 12247c478bd9Sstevel@tonic-gate 12257c478bd9Sstevel@tonic-gate USB_DPRINTF_L4(DPRINT_MASK_EVENTS, usb_mid->mi_log_handle, 12267c478bd9Sstevel@tonic-gate "usb_mid_event_cb: dip=0x%p, cookie=0x%p, " 12277c478bd9Sstevel@tonic-gate "arg=0x%p, impl=0x%p", 12287c478bd9Sstevel@tonic-gate (void *)dip, (void *)cookie, arg, bus_impldata); 12297c478bd9Sstevel@tonic-gate USB_DPRINTF_L4(DPRINT_MASK_EVENTS, usb_mid->mi_log_handle, 12307c478bd9Sstevel@tonic-gate "(dip=%s%d event=%s)", 12317c478bd9Sstevel@tonic-gate ddi_driver_name(dip), ddi_get_instance(dip), 12327c478bd9Sstevel@tonic-gate ndi_event_cookie_to_name(usb_mid->mi_ndi_event_hdl, cookie)); 12337c478bd9Sstevel@tonic-gate 12347c478bd9Sstevel@tonic-gate tag = NDI_EVENT_TAG(cookie); 12357c478bd9Sstevel@tonic-gate rm_cookie = ndi_event_tag_to_cookie( 12367c478bd9Sstevel@tonic-gate usb_mid->mi_ndi_event_hdl, USBA_EVENT_TAG_HOT_REMOVAL); 12377c478bd9Sstevel@tonic-gate suspend_cookie = ndi_event_tag_to_cookie( 12387c478bd9Sstevel@tonic-gate usb_mid->mi_ndi_event_hdl, USBA_EVENT_TAG_PRE_SUSPEND); 12397c478bd9Sstevel@tonic-gate ins_cookie = ndi_event_tag_to_cookie( 12407c478bd9Sstevel@tonic-gate usb_mid->mi_ndi_event_hdl, USBA_EVENT_TAG_HOT_INSERTION); 12417c478bd9Sstevel@tonic-gate resume_cookie = ndi_event_tag_to_cookie( 12427c478bd9Sstevel@tonic-gate usb_mid->mi_ndi_event_hdl, USBA_EVENT_TAG_POST_RESUME); 12437c478bd9Sstevel@tonic-gate 12447c478bd9Sstevel@tonic-gate mutex_enter(&usb_mid->mi_mutex); 12457c478bd9Sstevel@tonic-gate switch (tag) { 12467c478bd9Sstevel@tonic-gate case USBA_EVENT_TAG_HOT_REMOVAL: 12477c478bd9Sstevel@tonic-gate if (usb_mid->mi_dev_state == USB_DEV_DISCONNECTED) { 12487c478bd9Sstevel@tonic-gate USB_DPRINTF_L2(DPRINT_MASK_EVENTS, 12497c478bd9Sstevel@tonic-gate usb_mid->mi_log_handle, 12507c478bd9Sstevel@tonic-gate "usb_mid_event_cb: Device already disconnected"); 12517c478bd9Sstevel@tonic-gate } else { 12527c478bd9Sstevel@tonic-gate /* we are disconnected so set our state now */ 12537c478bd9Sstevel@tonic-gate usb_mid->mi_dev_state = USB_DEV_DISCONNECTED; 12547c478bd9Sstevel@tonic-gate for (i = 0; i < usb_mid->mi_n_ifs; i++) { 12557c478bd9Sstevel@tonic-gate usb_mid->mi_child_events[i] &= ~ 12567c478bd9Sstevel@tonic-gate USB_MID_CHILD_EVENT_DISCONNECT; 12577c478bd9Sstevel@tonic-gate } 12587c478bd9Sstevel@tonic-gate mutex_exit(&usb_mid->mi_mutex); 12597c478bd9Sstevel@tonic-gate 12607c478bd9Sstevel@tonic-gate /* pass disconnect event to all the children */ 12617c478bd9Sstevel@tonic-gate (void) ndi_event_run_callbacks( 12627c478bd9Sstevel@tonic-gate usb_mid->mi_ndi_event_hdl, NULL, 12637c478bd9Sstevel@tonic-gate rm_cookie, bus_impldata); 12647c478bd9Sstevel@tonic-gate 12657c478bd9Sstevel@tonic-gate if (usb_mid->mi_ugen_hdl) { 12667c478bd9Sstevel@tonic-gate (void) usb_ugen_disconnect_ev_cb( 12677c478bd9Sstevel@tonic-gate usb_mid->mi_ugen_hdl); 12687c478bd9Sstevel@tonic-gate } 12697c478bd9Sstevel@tonic-gate mutex_enter(&usb_mid->mi_mutex); 12707c478bd9Sstevel@tonic-gate } 12717c478bd9Sstevel@tonic-gate break; 12727c478bd9Sstevel@tonic-gate case USBA_EVENT_TAG_PRE_SUSPEND: 12737c478bd9Sstevel@tonic-gate /* set our state *after* suspending children */ 12747c478bd9Sstevel@tonic-gate mutex_exit(&usb_mid->mi_mutex); 12757c478bd9Sstevel@tonic-gate 12767c478bd9Sstevel@tonic-gate /* pass pre_suspend event to all the children */ 12777c478bd9Sstevel@tonic-gate (void) ndi_event_run_callbacks(usb_mid->mi_ndi_event_hdl, 12787c478bd9Sstevel@tonic-gate NULL, suspend_cookie, bus_impldata); 12797c478bd9Sstevel@tonic-gate 12807c478bd9Sstevel@tonic-gate mutex_enter(&usb_mid->mi_mutex); 12817c478bd9Sstevel@tonic-gate for (i = 0; i < usb_mid->mi_n_ifs; i++) { 12827c478bd9Sstevel@tonic-gate usb_mid->mi_child_events[i] &= ~ 12837c478bd9Sstevel@tonic-gate USB_MID_CHILD_EVENT_PRESUSPEND; 12847c478bd9Sstevel@tonic-gate } 12857c478bd9Sstevel@tonic-gate break; 12867c478bd9Sstevel@tonic-gate case USBA_EVENT_TAG_HOT_INSERTION: 12877c478bd9Sstevel@tonic-gate mutex_exit(&usb_mid->mi_mutex); 12887c478bd9Sstevel@tonic-gate if (usb_mid_restore_device_state(dip, usb_mid) == USB_SUCCESS) { 12897c478bd9Sstevel@tonic-gate 12907c478bd9Sstevel@tonic-gate /* 12917c478bd9Sstevel@tonic-gate * Check to see if this child has missed the disconnect 12927c478bd9Sstevel@tonic-gate * event before it registered for event cb 12937c478bd9Sstevel@tonic-gate */ 12947c478bd9Sstevel@tonic-gate mutex_enter(&usb_mid->mi_mutex); 12957c478bd9Sstevel@tonic-gate for (i = 0; i < usb_mid->mi_n_ifs; i++) { 1296d73ae94eSgc if ((usb_mid->mi_child_events[i] & 1297d73ae94eSgc USB_MID_CHILD_EVENT_DISCONNECT) && 1298d73ae94eSgc usb_mid->mi_children_ifs[i]) { 12997c478bd9Sstevel@tonic-gate usb_mid->mi_child_events[i] &= 13007c478bd9Sstevel@tonic-gate ~USB_MID_CHILD_EVENT_DISCONNECT; 13017c478bd9Sstevel@tonic-gate child_dip = 13027c478bd9Sstevel@tonic-gate usb_mid->mi_children_dips[i]; 13037c478bd9Sstevel@tonic-gate mutex_exit(&usb_mid->mi_mutex); 13047c478bd9Sstevel@tonic-gate 13057c478bd9Sstevel@tonic-gate /* post the missed disconnect */ 13067c478bd9Sstevel@tonic-gate (void) ndi_event_do_callback( 13077c478bd9Sstevel@tonic-gate usb_mid->mi_ndi_event_hdl, 13087c478bd9Sstevel@tonic-gate child_dip, 13097c478bd9Sstevel@tonic-gate rm_cookie, 13107c478bd9Sstevel@tonic-gate bus_impldata); 13117c478bd9Sstevel@tonic-gate mutex_enter(&usb_mid->mi_mutex); 13127c478bd9Sstevel@tonic-gate } 13137c478bd9Sstevel@tonic-gate } 13147c478bd9Sstevel@tonic-gate mutex_exit(&usb_mid->mi_mutex); 13157c478bd9Sstevel@tonic-gate 13167c478bd9Sstevel@tonic-gate /* pass reconnect event to all the children */ 13177c478bd9Sstevel@tonic-gate (void) ndi_event_run_callbacks( 13187c478bd9Sstevel@tonic-gate usb_mid->mi_ndi_event_hdl, NULL, 13197c478bd9Sstevel@tonic-gate ins_cookie, bus_impldata); 13207c478bd9Sstevel@tonic-gate 13217c478bd9Sstevel@tonic-gate if (usb_mid->mi_ugen_hdl) { 13227c478bd9Sstevel@tonic-gate (void) usb_ugen_reconnect_ev_cb( 13237c478bd9Sstevel@tonic-gate usb_mid->mi_ugen_hdl); 13247c478bd9Sstevel@tonic-gate } 13257c478bd9Sstevel@tonic-gate } 13267c478bd9Sstevel@tonic-gate mutex_enter(&usb_mid->mi_mutex); 13277c478bd9Sstevel@tonic-gate break; 13287c478bd9Sstevel@tonic-gate case USBA_EVENT_TAG_POST_RESUME: 13297c478bd9Sstevel@tonic-gate /* 13307c478bd9Sstevel@tonic-gate * Check to see if this child has missed the pre-suspend 13317c478bd9Sstevel@tonic-gate * event before it registered for event cb 13327c478bd9Sstevel@tonic-gate */ 13337c478bd9Sstevel@tonic-gate for (i = 0; i < usb_mid->mi_n_ifs; i++) { 1334d73ae94eSgc if ((usb_mid->mi_child_events[i] & 1335d73ae94eSgc USB_MID_CHILD_EVENT_PRESUSPEND) && 1336d73ae94eSgc usb_mid->mi_children_ifs[i]) { 13377c478bd9Sstevel@tonic-gate usb_mid->mi_child_events[i] &= 13387c478bd9Sstevel@tonic-gate ~USB_MID_CHILD_EVENT_PRESUSPEND; 13397c478bd9Sstevel@tonic-gate child_dip = usb_mid->mi_children_dips[i]; 13407c478bd9Sstevel@tonic-gate mutex_exit(&usb_mid->mi_mutex); 13417c478bd9Sstevel@tonic-gate 13427c478bd9Sstevel@tonic-gate /* post the missed pre-suspend event */ 13437c478bd9Sstevel@tonic-gate (void) ndi_event_do_callback( 13447c478bd9Sstevel@tonic-gate usb_mid->mi_ndi_event_hdl, 13457c478bd9Sstevel@tonic-gate child_dip, suspend_cookie, 13467c478bd9Sstevel@tonic-gate bus_impldata); 13477c478bd9Sstevel@tonic-gate mutex_enter(&usb_mid->mi_mutex); 13487c478bd9Sstevel@tonic-gate } 13497c478bd9Sstevel@tonic-gate } 13507c478bd9Sstevel@tonic-gate mutex_exit(&usb_mid->mi_mutex); 13517c478bd9Sstevel@tonic-gate 13527c478bd9Sstevel@tonic-gate /* pass post_resume event to all the children */ 13537c478bd9Sstevel@tonic-gate (void) ndi_event_run_callbacks(usb_mid->mi_ndi_event_hdl, 13547c478bd9Sstevel@tonic-gate NULL, resume_cookie, bus_impldata); 13557c478bd9Sstevel@tonic-gate 13567c478bd9Sstevel@tonic-gate mutex_enter(&usb_mid->mi_mutex); 13577c478bd9Sstevel@tonic-gate break; 13587c478bd9Sstevel@tonic-gate } 13597c478bd9Sstevel@tonic-gate mutex_exit(&usb_mid->mi_mutex); 13607c478bd9Sstevel@tonic-gate 13617c478bd9Sstevel@tonic-gate } 13627c478bd9Sstevel@tonic-gate 13637c478bd9Sstevel@tonic-gate 13647c478bd9Sstevel@tonic-gate /* 13657c478bd9Sstevel@tonic-gate * create the pm components required for power management 13667c478bd9Sstevel@tonic-gate */ 13677c478bd9Sstevel@tonic-gate static void 13687c478bd9Sstevel@tonic-gate usb_mid_create_pm_components(dev_info_t *dip, usb_mid_t *usb_mid) 13697c478bd9Sstevel@tonic-gate { 1370d73ae94eSgc usb_common_power_t *midpm; 13717c478bd9Sstevel@tonic-gate uint_t pwr_states; 13727c478bd9Sstevel@tonic-gate 13737c478bd9Sstevel@tonic-gate USB_DPRINTF_L4(DPRINT_MASK_PM, usb_mid->mi_log_handle, 13747c478bd9Sstevel@tonic-gate "usb_mid_create_pm_components: Begin"); 13757c478bd9Sstevel@tonic-gate 13767c478bd9Sstevel@tonic-gate /* Allocate the PM state structure */ 1377d73ae94eSgc midpm = kmem_zalloc(sizeof (usb_common_power_t), KM_SLEEP); 13787c478bd9Sstevel@tonic-gate 13797c478bd9Sstevel@tonic-gate mutex_enter(&usb_mid->mi_mutex); 13807c478bd9Sstevel@tonic-gate usb_mid->mi_pm = midpm; 1381d73ae94eSgc midpm->uc_usb_statep = usb_mid; 1382d73ae94eSgc midpm->uc_pm_capabilities = 0; /* XXXX should this be 0?? */ 1383d73ae94eSgc midpm->uc_current_power = USB_DEV_OS_FULL_PWR; 13847c478bd9Sstevel@tonic-gate mutex_exit(&usb_mid->mi_mutex); 13857c478bd9Sstevel@tonic-gate 13867c478bd9Sstevel@tonic-gate /* 13877c478bd9Sstevel@tonic-gate * By not enabling parental notification, PM enforces 13887c478bd9Sstevel@tonic-gate * "strict parental dependency" meaning, usb_mid won't 13897c478bd9Sstevel@tonic-gate * power off until any of its children are in full power. 13907c478bd9Sstevel@tonic-gate */ 13917c478bd9Sstevel@tonic-gate 13927c478bd9Sstevel@tonic-gate /* 13937c478bd9Sstevel@tonic-gate * there are 3 scenarios: 13947c478bd9Sstevel@tonic-gate * 1. a well behaved device should have remote wakeup 13957c478bd9Sstevel@tonic-gate * at interface and device level. If the interface 13967c478bd9Sstevel@tonic-gate * wakes up, usb_mid will wake up 13977c478bd9Sstevel@tonic-gate * 2. if the device doesn't have remote wake up and 13987c478bd9Sstevel@tonic-gate * the interface has, PM will still work, ie. 13997c478bd9Sstevel@tonic-gate * the interfaces wakes up and usb_mid wakes up 14007c478bd9Sstevel@tonic-gate * 3. if neither the interface nor device has remote 14017c478bd9Sstevel@tonic-gate * wakeup, the interface will wake up when it is opened 14027c478bd9Sstevel@tonic-gate * and goes to sleep after being closed for a while 14037c478bd9Sstevel@tonic-gate * In this case usb_mid should also go to sleep shortly 14047c478bd9Sstevel@tonic-gate * thereafter 14057c478bd9Sstevel@tonic-gate * In all scenarios it doesn't really matter whether 14067c478bd9Sstevel@tonic-gate * remote wakeup at the device level is enabled or not 14077c478bd9Sstevel@tonic-gate * but we do it anyways 14087c478bd9Sstevel@tonic-gate */ 14097c478bd9Sstevel@tonic-gate if (usb_handle_remote_wakeup(dip, USB_REMOTE_WAKEUP_ENABLE) == 14107c478bd9Sstevel@tonic-gate USB_SUCCESS) { 14117c478bd9Sstevel@tonic-gate USB_DPRINTF_L3(DPRINT_MASK_PM, usb_mid->mi_log_handle, 14127c478bd9Sstevel@tonic-gate "usb_mid_create_pm_components: " 14137c478bd9Sstevel@tonic-gate "Remote Wakeup Enabled"); 1414d73ae94eSgc midpm->uc_wakeup_enabled = 1; 14157c478bd9Sstevel@tonic-gate } 14167c478bd9Sstevel@tonic-gate 14177c478bd9Sstevel@tonic-gate if (usb_create_pm_components(dip, &pwr_states) == 14187c478bd9Sstevel@tonic-gate USB_SUCCESS) { 1419d73ae94eSgc midpm->uc_pwr_states = (uint8_t)pwr_states; 14207c478bd9Sstevel@tonic-gate (void) pm_raise_power(dip, 0, USB_DEV_OS_FULL_PWR); 14217c478bd9Sstevel@tonic-gate } 14227c478bd9Sstevel@tonic-gate 14237c478bd9Sstevel@tonic-gate USB_DPRINTF_L4(DPRINT_MASK_PM, usb_mid->mi_log_handle, 14247c478bd9Sstevel@tonic-gate "usb_mid_create_pm_components: End"); 14257c478bd9Sstevel@tonic-gate } 14267c478bd9Sstevel@tonic-gate 14277c478bd9Sstevel@tonic-gate 14287c478bd9Sstevel@tonic-gate /* 14297c478bd9Sstevel@tonic-gate * usb_mid_obtain_state: 14307c478bd9Sstevel@tonic-gate */ 14317c478bd9Sstevel@tonic-gate usb_mid_t * 14327c478bd9Sstevel@tonic-gate usb_mid_obtain_state(dev_info_t *dip) 14337c478bd9Sstevel@tonic-gate { 14347c478bd9Sstevel@tonic-gate int instance = ddi_get_instance(dip); 14357c478bd9Sstevel@tonic-gate usb_mid_t *statep = ddi_get_soft_state(usb_mid_statep, instance); 14367c478bd9Sstevel@tonic-gate 14377c478bd9Sstevel@tonic-gate ASSERT(statep != NULL); 14387c478bd9Sstevel@tonic-gate 14397c478bd9Sstevel@tonic-gate return (statep); 14407c478bd9Sstevel@tonic-gate } 14417c478bd9Sstevel@tonic-gate 14427c478bd9Sstevel@tonic-gate 14437c478bd9Sstevel@tonic-gate /* 14447c478bd9Sstevel@tonic-gate * ugen support 14457c478bd9Sstevel@tonic-gate */ 14467c478bd9Sstevel@tonic-gate /* ARGSUSED3 */ 14477c478bd9Sstevel@tonic-gate static int 14487c478bd9Sstevel@tonic-gate usb_mid_open(dev_t *devp, int flags, int otyp, cred_t *credp) 14497c478bd9Sstevel@tonic-gate { 14507c478bd9Sstevel@tonic-gate struct usb_mid *usb_mid; 14517c478bd9Sstevel@tonic-gate int rval; 14527c478bd9Sstevel@tonic-gate 14537c478bd9Sstevel@tonic-gate if ((usb_mid = ddi_get_soft_state(usb_mid_statep, 14547c478bd9Sstevel@tonic-gate USB_MID_MINOR_TO_INSTANCE(getminor(*devp)))) == NULL) { 14557c478bd9Sstevel@tonic-gate 14567c478bd9Sstevel@tonic-gate return (ENXIO); 14577c478bd9Sstevel@tonic-gate } 14587c478bd9Sstevel@tonic-gate 14597c478bd9Sstevel@tonic-gate USB_DPRINTF_L4(DPRINT_MASK_CBOPS, usb_mid->mi_log_handle, 14607c478bd9Sstevel@tonic-gate "usb_mid_open: usb_mid = 0x%p *devp = 0x%lx", usb_mid, *devp); 14617c478bd9Sstevel@tonic-gate 14627c478bd9Sstevel@tonic-gate /* First bring the device to full power */ 14637c478bd9Sstevel@tonic-gate (void) pm_busy_component(usb_mid->mi_dip, 0); 14647c478bd9Sstevel@tonic-gate (void) pm_raise_power(usb_mid->mi_dip, 0, USB_DEV_OS_FULL_PWR); 14657c478bd9Sstevel@tonic-gate 14667c478bd9Sstevel@tonic-gate 14677c478bd9Sstevel@tonic-gate rval = usb_ugen_open(usb_mid->mi_ugen_hdl, devp, flags, otyp, 14687c478bd9Sstevel@tonic-gate credp); 14697c478bd9Sstevel@tonic-gate if (rval) { 14707c478bd9Sstevel@tonic-gate (void) pm_idle_component(usb_mid->mi_dip, 0); 14717c478bd9Sstevel@tonic-gate } else { 14727c478bd9Sstevel@tonic-gate /* 14737c478bd9Sstevel@tonic-gate * since all ugen opens are exclusive we can count the 14747c478bd9Sstevel@tonic-gate * opens 14757c478bd9Sstevel@tonic-gate */ 14767c478bd9Sstevel@tonic-gate mutex_enter(&usb_mid->mi_mutex); 14777c478bd9Sstevel@tonic-gate usb_mid->mi_ugen_open_count++; 14787c478bd9Sstevel@tonic-gate mutex_exit(&usb_mid->mi_mutex); 14797c478bd9Sstevel@tonic-gate } 14807c478bd9Sstevel@tonic-gate 14817c478bd9Sstevel@tonic-gate return (rval); 14827c478bd9Sstevel@tonic-gate } 14837c478bd9Sstevel@tonic-gate 14847c478bd9Sstevel@tonic-gate 14857c478bd9Sstevel@tonic-gate /* ARGSUSED */ 14867c478bd9Sstevel@tonic-gate static int 14877c478bd9Sstevel@tonic-gate usb_mid_close(dev_t dev, int flag, int otyp, cred_t *credp) 14887c478bd9Sstevel@tonic-gate { 14897c478bd9Sstevel@tonic-gate struct usb_mid *usb_mid; 14907c478bd9Sstevel@tonic-gate int rval; 14917c478bd9Sstevel@tonic-gate 14927c478bd9Sstevel@tonic-gate if ((usb_mid = ddi_get_soft_state(usb_mid_statep, 14937c478bd9Sstevel@tonic-gate USB_MID_MINOR_TO_INSTANCE(getminor(dev)))) == NULL) { 14947c478bd9Sstevel@tonic-gate 14957c478bd9Sstevel@tonic-gate return (ENXIO); 14967c478bd9Sstevel@tonic-gate } 14977c478bd9Sstevel@tonic-gate 14987c478bd9Sstevel@tonic-gate rval = usb_ugen_close(usb_mid->mi_ugen_hdl, dev, flag, otyp, 14997c478bd9Sstevel@tonic-gate credp); 15007c478bd9Sstevel@tonic-gate if (rval == 0) { 15017c478bd9Sstevel@tonic-gate (void) pm_idle_component(usb_mid->mi_dip, 0); 15027c478bd9Sstevel@tonic-gate mutex_enter(&usb_mid->mi_mutex); 15037c478bd9Sstevel@tonic-gate usb_mid->mi_ugen_open_count--; 15047c478bd9Sstevel@tonic-gate mutex_exit(&usb_mid->mi_mutex); 15057c478bd9Sstevel@tonic-gate } 15067c478bd9Sstevel@tonic-gate 15077c478bd9Sstevel@tonic-gate return (rval); 15087c478bd9Sstevel@tonic-gate } 15097c478bd9Sstevel@tonic-gate 15107c478bd9Sstevel@tonic-gate 15117c478bd9Sstevel@tonic-gate static int 15127c478bd9Sstevel@tonic-gate usb_mid_read(dev_t dev, struct uio *uio, cred_t *credp) 15137c478bd9Sstevel@tonic-gate { 15147c478bd9Sstevel@tonic-gate struct usb_mid *usb_mid; 15157c478bd9Sstevel@tonic-gate 15167c478bd9Sstevel@tonic-gate if ((usb_mid = ddi_get_soft_state(usb_mid_statep, 15177c478bd9Sstevel@tonic-gate USB_MID_MINOR_TO_INSTANCE(getminor(dev)))) == NULL) { 15187c478bd9Sstevel@tonic-gate 15197c478bd9Sstevel@tonic-gate return (ENXIO); 15207c478bd9Sstevel@tonic-gate } 15217c478bd9Sstevel@tonic-gate 15227c478bd9Sstevel@tonic-gate return (usb_ugen_read(usb_mid->mi_ugen_hdl, dev, uio, credp)); 15237c478bd9Sstevel@tonic-gate } 15247c478bd9Sstevel@tonic-gate 15257c478bd9Sstevel@tonic-gate 15267c478bd9Sstevel@tonic-gate static int 15277c478bd9Sstevel@tonic-gate usb_mid_write(dev_t dev, struct uio *uio, cred_t *credp) 15287c478bd9Sstevel@tonic-gate { 15297c478bd9Sstevel@tonic-gate struct usb_mid *usb_mid; 15307c478bd9Sstevel@tonic-gate 15317c478bd9Sstevel@tonic-gate if ((usb_mid = ddi_get_soft_state(usb_mid_statep, 15327c478bd9Sstevel@tonic-gate USB_MID_MINOR_TO_INSTANCE(getminor(dev)))) == NULL) { 15337c478bd9Sstevel@tonic-gate 15347c478bd9Sstevel@tonic-gate return (ENXIO); 15357c478bd9Sstevel@tonic-gate } 15367c478bd9Sstevel@tonic-gate 15377c478bd9Sstevel@tonic-gate return (usb_ugen_write(usb_mid->mi_ugen_hdl, dev, uio, credp)); 15387c478bd9Sstevel@tonic-gate } 15397c478bd9Sstevel@tonic-gate 15407c478bd9Sstevel@tonic-gate 15417c478bd9Sstevel@tonic-gate static int 15427c478bd9Sstevel@tonic-gate usb_mid_poll(dev_t dev, short events, int anyyet, short *reventsp, 15437c478bd9Sstevel@tonic-gate struct pollhead **phpp) 15447c478bd9Sstevel@tonic-gate { 15457c478bd9Sstevel@tonic-gate struct usb_mid *usb_mid; 15467c478bd9Sstevel@tonic-gate 15477c478bd9Sstevel@tonic-gate if ((usb_mid = ddi_get_soft_state(usb_mid_statep, 15487c478bd9Sstevel@tonic-gate USB_MID_MINOR_TO_INSTANCE(getminor(dev)))) == NULL) { 15497c478bd9Sstevel@tonic-gate 15507c478bd9Sstevel@tonic-gate return (ENXIO); 15517c478bd9Sstevel@tonic-gate } 15527c478bd9Sstevel@tonic-gate 15537c478bd9Sstevel@tonic-gate return (usb_ugen_poll(usb_mid->mi_ugen_hdl, dev, events, 15547c478bd9Sstevel@tonic-gate anyyet, reventsp, phpp)); 15557c478bd9Sstevel@tonic-gate } 1556