usb_mid.c revision 7c478bd95313f5f23a4c958a745db2134aa03244
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License, Version 1.0 only
* (the "License"). You may not use this file except in compliance
* with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*
* Copyright 2005 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#pragma ident "%Z%%M% %I% %E% SMI"
/*
* usb multi interface and common class driver
*
* this driver attempts to attach each interface to a driver
* and may eventually handle common class features such as
* shared endpoints
*/
#define DEBUG 1
#endif
void usba_free_evdata(usba_evdata_t *);
/* Debugging support */
static uint_t usb_mid_bus_config_debug = 0;
/*
* Hotplug support
* Leaf ops (hotplug controls for client devices)
*/
static int usb_mid_poll(dev_t, short, int, short *,
struct pollhead **);
static struct cb_ops usb_mid_cb_ops = {
nodev, /* strategy */
nodev, /* print */
nodev, /* dump */
usb_mid_read, /* read */
usb_mid_write, /* write */
nodev, /* devmap */
nodev, /* mmap */
nodev, /* segmap */
usb_mid_poll, /* poll */
ddi_prop_op, /* prop_op */
NULL,
};
char *eventname,
void *bus_impldata),
void *bus_impldata);
void *arg,
dev_info_t **child);
void *arg);
/*
* autoconfiguration data and routines.
*/
void *, void **);
/* other routines */
ddi_ctl_enum_t, void *, void *);
static int usb_mid_power(dev_info_t *, int, int);
/*
* Busops vector
*/
static struct bus_ops usb_mid_busops = {
nullbusmap, /* bus_map */
NULL, /* bus_get_intrspec */
NULL, /* bus_add_intrspec */
NULL, /* bus_remove_intrspec */
NULL, /* XXXX bus_map_fault */
ddi_dma_map, /* bus_dma_map */
ddi_dma_mctl, /* bus_dma_ctl */
usb_mid_bus_ctl, /* bus_ctl */
ddi_bus_prop_op, /* bus_prop_op */
usb_mid_busop_post_event, /* bus_post_event */
NULL, /* bus_intr_ctl */
usb_mid_bus_config, /* bus_config */
usb_mid_bus_unconfig, /* bus_unconfig */
NULL, /* bus_fm_init */
NULL, /* bus_fm_fini */
NULL, /* bus_fm_access_enter */
NULL, /* bus_fm_access_exit */
NULL /* bus_power */
};
static struct dev_ops usb_mid_ops = {
DEVO_REV, /* devo_rev, */
0, /* refcnt */
usb_mid_info, /* info */
nulldev, /* identify */
nulldev, /* probe */
usb_mid_attach, /* attach */
usb_mid_detach, /* detach */
nodev, /* reset */
&usb_mid_cb_ops, /* driver operations */
&usb_mid_busops, /* bus operations */
usb_mid_power /* power */
};
&mod_driverops, /* Type of module. This one is a driver */
"USB Multi Interface Driver %I%", /* Name of the module. */
&usb_mid_ops, /* driver ops */
};
static struct modlinkage modlinkage = {
};
#define USB_MID_INITIAL_SOFT_SPACE 4
static void *usb_mid_statep;
/*
* prototypes
*/
/* usbai private */
/*
* event definition
*/
static ndi_event_definition_t usb_mid_ndi_event_defs[] = {
};
#define USB_MID_N_NDI_EVENTS \
(sizeof (usb_mid_ndi_event_defs) / sizeof (ndi_event_definition_t))
static ndi_event_set_t usb_mid_ndi_events = {
/*
* standard driver entry points
*/
int
_init(void)
{
int rval;
if (rval != 0) {
return (rval);
}
return (rval);
}
return (rval);
}
int
_fini(void)
{
int rval;
if (rval) {
return (rval);
}
return (rval);
}
int
{
}
/*ARGSUSED*/
static int
{
int instance =
int error = DDI_FAILURE;
switch (infocmd) {
case DDI_INFO_DEVT2DEVINFO:
error = DDI_SUCCESS;
}
} else {
}
break;
case DDI_INFO_DEVT2INSTANCE:
error = DDI_SUCCESS;
break;
default:
break;
}
return (error);
}
/*
*/
static void
{
/* if child successfully attached, set power */
/*
* Check if the child created wants to be power managed.
* If yes, the childs power level gets automatically tracked
* by DDI_CTLOPS_POWER busctl.
* If no, we set power of the new child by default
* to USB_DEV_OS_FULL_PWR. Because we should never suspend.
*/
}
}
static void
{
/*
* if the device is successfully detached,
* mark component as idle
*/
/* check for leaks except when where is a ugen open */
(usb_mid->mi_ugen_open_count == 0)) {
}
}
}
/*
* bus ctl support. we handle notifications here and the
*/
/*ARGSUSED*/
static int
void *arg,
void *result)
{
struct attachspec *as;
struct detachspec *ds;
"usb_mid_bus_ctl:\n\t"
"dip = 0x%p, rdip = 0x%p, op = 0x%x, arg = 0x%p",
switch (op) {
case DDI_CTLOPS_ATTACH:
case DDI_PRE :
/* nothing to do basically */
"DDI_PRE DDI_CTLOPS_ATTACH");
break;
case DDI_POST :
(struct attachspec *)arg);
break;
}
break;
case DDI_CTLOPS_DETACH:
case DDI_PRE :
/* nothing to do basically */
"DDI_PRE DDI_CTLOPS_DETACH");
break;
case DDI_POST :
(struct detachspec *)arg);
break;
}
break;
default:
/* pass to root hub to handle */
}
return (DDI_SUCCESS);
}
/*
* bus enumeration entry points
*/
static int
{
"usb_mid_bus_config: op=%d", op);
if (usb_mid_bus_config_debug) {
flag |= NDI_DEVI_DEBUG;
}
/* enumerate each interface below us */
return (rval);
}
static int
void *arg)
{
int interface, circular_count;
int rval = NDI_SUCCESS;
"usb_mid_bus_unconfig: op=%d", op);
if (usb_mid_bus_config_debug) {
flag |= NDI_DEVI_DEBUG;
}
/*
* first offline and if offlining successful, then
* remove children
*/
if (op == BUS_UNCONFIG_ALL) {
}
(flag & NDI_AUTODETACH) == 0) {
flag |= NDI_DEVI_REMOVE;
}
/* update children's list */
/* now search if this dip still exists */
/* we lost the dip on this interface */
} else if (cdip) {
/*
* keep in DS_INITALIZED to prevent parent
* from detaching
*/
}
}
"usb_mid_bus_config: rval=%d", rval);
return (rval);
}
/*
* functions to handle power transition for OS levels 0 -> 3
*/
static int
{
int rval;
switch (usb_mid->mi_dev_state) {
case USB_DEV_ONLINE:
/* Issue USB D3 command to the device here */
/* FALLTHRU */
case USB_DEV_DISCONNECTED:
case USB_DEV_SUSPENDED:
/* allow a disconnected/cpr'ed device to go to low pwr */
return (USB_SUCCESS);
case USB_DEV_PWRED_DOWN:
default:
return (USB_FAILURE);
}
}
/* ARGSUSED */
static int
{
int rval;
/* Issue USB D2 command to the device here */
return (USB_FAILURE);
}
/* ARGSUSED */
static int
{
int rval;
/* Issue USB D1 command to the device here */
return (USB_FAILURE);
}
static int
{
int rval;
switch (usb_mid->mi_dev_state) {
case USB_DEV_PWRED_DOWN:
/* Issue USB D0 command to the device here */
/* FALLTHRU */
case USB_DEV_ONLINE:
/* we are already in full power */
/* FALLTHRU */
case USB_DEV_DISCONNECTED:
case USB_DEV_SUSPENDED:
/* allow a disconnected/cpr'ed device to go to low power */
return (USB_SUCCESS);
default:
"usb_mid_pwrlvl3: Illegal state (%s)",
return (USB_FAILURE);
}
}
/* power entry point */
/* ARGSUSED */
static int
{
int rval = DDI_FAILURE;
/* check if we are transitioning to a legal power level */
"usb_mid_power: illegal power level = %d "
return (rval);
}
switch (level) {
case USB_DEV_OS_PWR_OFF:
break;
case USB_DEV_OS_PWR_1:
break;
case USB_DEV_OS_PWR_2:
break;
case USB_DEV_OS_FULL_PWR:
break;
}
}
/*
*/
static int
{
switch (cmd) {
case DDI_ATTACH:
break;
case DDI_RESUME:
instance);
if (usb_mid->mi_ugen_hdl) {
}
return (DDI_SUCCESS);
default:
return (DDI_FAILURE);
}
/*
* Attach:
*
* Allocate soft state and initialize
*/
goto fail;
}
goto fail;
}
/* allocate handle for logging of messages */
0);
/* attach client driver to USBA */
"usb_client_attach failed");
goto fail;
}
0) != USB_SUCCESS) {
"usb_get_dev_data failed");
goto fail;
}
DDI_NT_NEXUS, 0) != DDI_SUCCESS) {
"cannot create devctl minor node");
goto fail;
}
/*
* allocate array for keeping track of child dips
*/
KM_SLEEP);
/*
* Event handling: definition and registration
* get event handle for events that we have defined
*/
/* bind event set to the handle */
NDI_SLEEP)) {
"usb_mid_attach: binding event set failed");
goto fail;
}
/*
* now create components to power manage this device
* before attaching children
*/
/* event registration for events from our parent */
return (DDI_SUCCESS);
fail:
instance);
if (usb_mid) {
}
return (DDI_FAILURE);
}
/* detach or suspend this instance */
static int
{
"usb_mid_detach: cmd = 0x%x", cmd);
switch (cmd) {
case DDI_DETACH:
case DDI_SUSPEND:
/* nothing to do */
if (usb_mid->mi_ugen_hdl) {
}
return (DDI_SUCCESS);
default:
return (DDI_FAILURE);
}
/* NOTREACHED */
}
/*
* usb_mid_cleanup:
* cleanup usb_mid and deallocate. this function is called for
* handling attach failures and detaching including dynamic
* reconfiguration
*/
/*ARGSUSED*/
static int
{
int rval;
"usb_mid_cleanup:");
goto done;
}
/*
* deallocate events, if events are still registered
* (ie. children still attached) then we have to fail the detach
*/
if (usb_mid->mi_ndi_event_hdl &&
"usb_mid_cleanup: ndi_event_free_hdl failed");
return (DDI_FAILURE);
}
/*
* Disable the event callbacks, after this point, event
* callbacks will never get called. Note we shouldn't hold
* mutex while unregistering events because there may be a
* competing event callback thread. Event callbacks are done
* with ndi mutex held and this can cause a potential deadlock.
* Note that cleanup can't fail after deregistration of events.
*/
}
(void) pm_busy_component(dip, 0);
if (midpm->mip_wakeup_enabled) {
/* First bring the device to full power */
if (rval != DDI_SUCCESS) {
"usb_cleanup: disable remote "
"wakeup failed, rval=%d", rval);
}
}
(void) pm_idle_component(dip, 0);
} else {
}
if (midpm) {
}
/* free children list */
if (usb_mid->mi_children_dips) {
}
if (usb_mid->mi_child_events) {
}
}
done:
if (usb_mid->mi_ugen_hdl) {
}
return (DDI_SUCCESS);
}
int
{
char *name;
int rval = USB_SUCCESS;
/* bind device to the driver */
/* if we fail to bind report an error */
if (name[0] != '\0') {
if (!usb_owns_device(dip)) {
"no driver found for "
"interface %d (nodename: '%s') of %s",
} else {
"no driver found for device %s", name);
}
} else {
"no driver found for device %s", name);
}
rval = USB_FAILURE;
}
return (rval);
}
static void
{
int rval;
"usb_mid_ugen_attach: get handle");
USB_UGEN_REMOVE_CHILDREN : 0);
"failed to create ugen support (%d)", rval);
} else {
}
}
}
/*
* usb_mid_create_children:
*/
static void
{
uint_t i;
uint_t ugen_bound = 0;
uint_t bound_children = 0;
"usb_mid_attach_child_drivers: port = %d, address = %d",
if (usb_mid->mi_removed_children) {
return;
}
"usb_mid_create_children: #interfaces = %d", n_ifs);
/*
* create all children if not already present
*/
for (i = 0; i < n_ifs; i++) {
continue;
}
USB_SUCCESS) {
"ugen") == 0) {
ugen_bound++;
}
}
}
}
/*
* if there are no ugen interface children, create ugen support at
* device level, use a separate thread because we may be at interrupt
* level
*/
/*
* we only need to remove the children if there are
* multiple configurations which would fail if there
* are child interfaces
*/
"can't support ugen for multiple "
"configurations devices that have attached "
"child interface drivers");
} else {
}
}
}
/*
* event support
*/
static int
{
"usb_mid_busop_get_eventcookie: dip=0x%p, rdip=0x%p, "
"(dip=%s%d rdip=%s%d)",
/* return event cookie, iblock cookie, and level */
}
static int
void *bus_impldata),
{
"usb_mid_busop_add_eventcall: dip=0x%p, rdip=0x%p "
"cookie=0x%p, cb=0x%p, arg=0x%p",
"(dip=%s%d rdip=%s%d event=%s)",
/* Set flag on children registering events */
break;
break;
default:
break;
}
/* add callback (perform registration) */
}
static int
{
"usb_mid_busop_remove_eventcall: dip=0x%p, rdip=0x%p "
"(dip=%s%d rdip=%s%d event=%s)",
cb->ndi_evtcb_cookie));
/* remove event registration from our event set */
}
static int
void *bus_impldata)
{
"usb_mid_busop_post_event: dip=0x%p, rdip=0x%p "
"cookie=0x%p, impl=0x%p",
"(dip=%s%d rdip=%s%d event=%s)",
/* post event to all children registered for this event */
cookie, bus_impldata));
}
/*
* usb_mid_restore_device_state
* set the original configuration of the device
*/
static int
{
"usb_mid_restore_device_state: usb_mid = %p", usb_mid);
/* First bring the device to full power */
(void) pm_busy_component(dip, 0);
/* change the device state from suspended to disconnected */
(void) pm_idle_component(dip, 0);
return (USB_FAILURE);
}
/*
* if the device had remote wakeup earlier,
* enable it again
*/
if (midpm->mip_wakeup_enabled) {
}
(void) pm_idle_component(dip, 0);
return (USB_SUCCESS);
}
/*
* usb_mid_event_cb()
* handle disconnect and connect events
*/
static void
void *arg, void *bus_impldata)
{
int i, tag;
"usb_mid_event_cb: dip=0x%p, cookie=0x%p, "
"arg=0x%p, impl=0x%p",
"(dip=%s%d event=%s)",
switch (tag) {
"usb_mid_event_cb: Device already disconnected");
} else {
/* we are disconnected so set our state now */
usb_mid->mi_child_events[i] &= ~
}
/* pass disconnect event to all the children */
(void) ndi_event_run_callbacks(
if (usb_mid->mi_ugen_hdl) {
(void) usb_ugen_disconnect_ev_cb(
}
}
break;
/* set our state *after* suspending children */
/* pass pre_suspend event to all the children */
usb_mid->mi_child_events[i] &= ~
}
break;
/*
* Check to see if this child has missed the disconnect
* event before it registered for event cb
*/
if (usb_mid->mi_child_events[i] &
usb_mid->mi_child_events[i] &=
usb_mid->mi_children_dips[i];
/* post the missed disconnect */
(void) ndi_event_do_callback(
}
}
/* pass reconnect event to all the children */
(void) ndi_event_run_callbacks(
if (usb_mid->mi_ugen_hdl) {
(void) usb_ugen_reconnect_ev_cb(
}
}
break;
/*
* Check to see if this child has missed the pre-suspend
* event before it registered for event cb
*/
if (usb_mid->mi_child_events[i] &
usb_mid->mi_child_events[i] &=
/* post the missed pre-suspend event */
(void) ndi_event_do_callback(
}
}
/* pass post_resume event to all the children */
break;
}
}
/*
* register and unregister for events from our parent
*
* Note: usb_mid doesn't use the cookie fields in usba_device structure.
*/
static void
{
int rval;
"usb_mid_register_events:");
/* get event cookie, discard level and icookie for now */
&cookie);
if (rval == DDI_SUCCESS) {
if (rval != DDI_SUCCESS) {
goto fail;
}
}
&cookie);
if (rval == DDI_SUCCESS) {
if (rval != DDI_SUCCESS) {
goto fail;
}
}
&cookie);
if (rval == DDI_SUCCESS) {
if (rval != DDI_SUCCESS) {
goto fail;
}
}
&cookie);
if (rval == DDI_SUCCESS) {
if (rval != DDI_SUCCESS) {
goto fail;
}
}
return;
fail:
}
static void
{
int rval;
"usb_mid_unregister_events:");
if (evdata) {
if (evdata->ev_rm_cb_id) {
}
if (evdata->ev_ins_cb_id) {
}
if (evdata->ev_resume_cb_id) {
rval =
}
if (evdata->ev_suspend_cb_id) {
rval =
}
}
/* clear event data for children, required for cfgmadm unconfigure */
}
/*
* create the pm components required for power management
*/
static void
{
"usb_mid_create_pm_components: Begin");
/* Allocate the PM state structure */
/*
* By not enabling parental notification, PM enforces
* "strict parental dependency" meaning, usb_mid won't
* power off until any of its children are in full power.
*/
/*
* there are 3 scenarios:
* 1. a well behaved device should have remote wakeup
* at interface and device level. If the interface
* wakes up, usb_mid will wake up
* 2. if the device doesn't have remote wake up and
* the interface has, PM will still work, ie.
* the interfaces wakes up and usb_mid wakes up
* 3. if neither the interface nor device has remote
* wakeup, the interface will wake up when it is opened
* and goes to sleep after being closed for a while
* In this case usb_mid should also go to sleep shortly
* thereafter
* In all scenarios it doesn't really matter whether
* remote wakeup at the device level is enabled or not
* but we do it anyways
*/
USB_SUCCESS) {
"usb_mid_create_pm_components: "
"Remote Wakeup Enabled");
}
USB_SUCCESS) {
}
"usb_mid_create_pm_components: End");
}
/*
* usb_mid_obtain_state:
*/
{
return (statep);
}
/*
* ugen support
*/
/* ARGSUSED3 */
static int
{
int rval;
return (ENXIO);
}
/* First bring the device to full power */
credp);
if (rval) {
} else {
/*
* since all ugen opens are exclusive we can count the
* opens
*/
}
return (rval);
}
/* ARGSUSED */
static int
{
int rval;
return (ENXIO);
}
credp);
if (rval == 0) {
}
return (rval);
}
static int
{
return (ENXIO);
}
}
static int
{
return (ENXIO);
}
}
static int
{
return (ENXIO);
}
}