/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (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
* or http://www.opensolaris.org/os/licensing.
* 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 2009 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
* Copyright 2019 Joyent, Inc.
*/
/*
* USBA: Solaris USB Architecture support
*
* Utility functions
*/
#define USBA_FRAMEWORK
#include <sys/usb/usba/usba_impl.h>
#include <sys/usb/usba/hcdi_impl.h>
#include <sys/strsun.h>
extern void usba_free_evdata(usba_evdata_t *);
static mblk_t *usba_get_cfg_cloud(dev_info_t *, usb_pipe_handle_t, int);
/* local functions */
static int usba_sync_set_cfg(dev_info_t *, usba_ph_impl_t *,
usba_pipe_async_req_t *, usb_flags_t);
static int usba_sync_set_alt_if(dev_info_t *, usba_ph_impl_t *,
usba_pipe_async_req_t *, usb_flags_t);
static int usba_sync_clear_feature(dev_info_t *, usba_ph_impl_t *,
usba_pipe_async_req_t *, usb_flags_t);
/*
* Wrapper functions returning parsed standard descriptors without
* getting the config cloud first but by just providing the dip.
*
* The client can easily retrieve the device and config descriptor from
* the usb registration and no separate functions are provided
*
* These functions return failure if the full descriptor can not be
* retrieved. These functions will not access the device.
* The caller must allocate the buffer.
*/
/*
* usb_get_if_descr:
* Function to get the cooked interface descriptor
* This function will not access the device.
*
* Arguments:
* dip - pointer to devinfo of the client
* if_index - interface index
* alt_setting - alt interface setting
* descr - pointer to user allocated interface descr
*
* Return Values:
* USB_SUCCESS - descriptor is valid
* USB_FAILURE - full descriptor could not be retrieved
* USB_* - refer to usbai.h
*/
int
usb_get_if_descr(dev_info_t *dip,
uint_t if_index,
uint_t alt_setting,
usb_if_descr_t *descr)
{
uchar_t *usb_cfg; /* buf for config descriptor */
size_t size, cfg_length;
USB_DPRINTF_L4(DPRINT_MASK_USBA, usbai_log_handle,
"usb_get_if_descr: %s, index=0x%x, alt#=0x%x",
ddi_node_name(dip), if_index, alt_setting);
if ((dip == NULL) || (descr == NULL)) {
return (USB_INVALID_ARGS);
}
usb_cfg = usb_get_raw_cfg_data(dip, &cfg_length);
size = usb_parse_if_descr(usb_cfg, cfg_length,
if_index, /* interface index */
alt_setting, /* alt interface index */
descr,
USB_IF_DESCR_SIZE);
if (size != USB_IF_DESCR_SIZE) {
USB_DPRINTF_L2(DPRINT_MASK_USBAI, usbai_log_handle,
"parsing interface: size (%lu) != USB_IF_DESCR_SIZE (%d)",
size, USB_IF_DESCR_SIZE);
return (USB_FAILURE);
}
return (USB_SUCCESS);
}
/*
* usb_get_ep_descr:
* Function to get the cooked endpoint descriptor
* This function will not access the device.
*
* Arguments:
* dip - pointer to devinfo of the client
* if_index - interface index
* alt_setting - alternate interface setting
* endpoint_index - endpoint index
* descr - pointer to user allocated interface descr
*
* Return Values:
* USB_SUCCESS - descriptor is valid
* USB_FAILURE - full descriptor could not be retrieved
* USB_* - refer to usbai.h
*/
int
usb_get_ep_descr(dev_info_t *dip,
uint_t if_index,
uint_t alt_setting,
uint_t endpoint_index,
usb_ep_descr_t *descr)
{
uchar_t *usb_cfg; /* buf for config descriptor */
size_t size, cfg_length;
USB_DPRINTF_L4(DPRINT_MASK_USBA, usbai_log_handle,
"usb_get_ep_descr: %s, index=0x%x, alt#=0x%x",
ddi_node_name(dip), if_index, alt_setting);
if ((dip == NULL) || (descr == NULL)) {
return (USB_INVALID_ARGS);
}
usb_cfg = usb_get_raw_cfg_data(dip, &cfg_length);
size = usb_parse_ep_descr(usb_cfg, cfg_length,
if_index, /* interface index */
alt_setting, /* alt interface index */
endpoint_index, /* ep index */
descr, USB_EP_DESCR_SIZE);
if (size != USB_EP_DESCR_SIZE) {
USB_DPRINTF_L2(DPRINT_MASK_USBAI, usbai_log_handle,
"parsing endpoint: size (%lu) != USB_EP_DESCR_SIZE (%d)",
size, USB_EP_DESCR_SIZE);
return (USB_FAILURE);
}
return (USB_SUCCESS);
}
/*
* usb_lookup_ep_data:
* usb_get_ep_data (deprecated):
* Function to get specific endpoint descriptor data
* This function will not access the device.
*
* Arguments:
* dip - pointer to dev info
* usb_client_dev_data_t - pointer to registration data
* interface - requested interface
* alternate - requested alternate
* skip - how many to skip
* type - endpoint type
* direction - endpoint direction or USB_DIR_DONT_CARE
*
* Return Values:
* NULL or an endpoint descriptor pointer
*/
usb_ep_data_t *
usb_lookup_ep_data(dev_info_t *dip,
usb_client_dev_data_t *dev_datap,
uint_t interface,
uint_t alternate,
uint_t skip,
uint_t type,
uint_t dir)
{
usb_alt_if_data_t *altif_data;
int i;
USB_DPRINTF_L4(DPRINT_MASK_USBA, usbai_log_handle,
"usb_lookup_ep_data: "
"if=%d alt=%d skip=%d type=%d dir=%d",
interface, alternate, skip, type, dir);
if ((dip == NULL) || (dev_datap == NULL)) {
return (NULL);
}
altif_data = &dev_datap->dev_curr_cfg->
cfg_if[interface].if_alt[alternate];
USB_DPRINTF_L4(DPRINT_MASK_USBA, usbai_log_handle,
"altif=0x%p n_ep=%d", (void *)altif_data, altif_data->altif_n_ep);
for (i = 0; i < altif_data->altif_n_ep; i++) {
usb_ep_descr_t *ept = &altif_data->altif_ep[i].ep_descr;
uint8_t ept_type = ept->bmAttributes & USB_EP_ATTR_MASK;
uint8_t ept_dir = ept->bEndpointAddress & USB_EP_DIR_MASK;
if (ept->bLength == 0) {
continue;
}
if ((ept_type == type) &&
((type == USB_EP_ATTR_CONTROL) || (dir == ept_dir))) {
if (skip-- == 0) {
USB_DPRINTF_L4(DPRINT_MASK_USBA,
usbai_log_handle,
"usb_get_ep_data: data=0x%p",
(void *)&altif_data->altif_ep[i]);
return (&altif_data->altif_ep[i]);
}
}
}
USB_DPRINTF_L4(DPRINT_MASK_USBA, usbai_log_handle,
"usb_get_ep_data: returning NULL");
return (NULL);
}
/*ARGSUSED*/
usb_ep_data_t *
usb_get_ep_data(dev_info_t *dip,
usb_client_dev_data_t *dev_datap,
uint_t interface,
uint_t alternate,
uint_t type,
uint_t dir)
{
return (usb_lookup_ep_data(dip, dev_datap, interface,
alternate, 0, type, dir));
}
/*
* usb_get_string_descr:
* Function to read the string descriptor
* This function will access the device and block.
*
* Arguments:
* dip - pointer to devinfo of the client
* langid - LANGID to read different LOCALEs
* index - index to the string
* buf - user provided buffer for string descriptor
* buflen - user provided length of the buffer
*
* Return Values:
* USB_SUCCESS - descriptor is valid
* USB_FAILURE - full descriptor could not be retrieved
* USB_* - refer to usbai.h
*/
int
usb_get_string_descr(dev_info_t *dip,
uint16_t langid,
uint8_t index,
char *buf,
size_t buflen)
{
mblk_t *data = NULL;
uint16_t length;
int rval;
usb_cr_t completion_reason;
size_t len;
usb_cb_flags_t cb_flags;
USB_DPRINTF_L4(DPRINT_MASK_USBA, usbai_log_handle,
"usb_get_string_descr: %s, langid=0x%x index=0x%x",
ddi_node_name(dip), langid, index);
if ((dip == NULL) || (buf == NULL) || (buflen == 0) || (index == 0)) {
return (USB_INVALID_ARGS);
}
/*
* determine the length of the descriptor
*/
rval = usb_pipe_sync_ctrl_xfer(dip,
usba_get_dflt_pipe_handle(dip),
USB_DEV_REQ_DEV_TO_HOST,
USB_REQ_GET_DESCR,
(USB_DESCR_TYPE_STRING << 8) | (index & 0xff),
langid,
4,
&data, USB_ATTRS_SHORT_XFER_OK,
&completion_reason,
&cb_flags, USB_FLAGS_SLEEP);
if (rval != USB_SUCCESS) {
USB_DPRINTF_L2(DPRINT_MASK_USBA, usbai_log_handle,
"rval=%d cr=%d", rval, completion_reason);
goto done;
}
if (MBLKL(data) == 0) {
USB_DPRINTF_L2(DPRINT_MASK_USBA, usbai_log_handle,
"0 bytes received");
goto done;
}
ASSERT(data);
length = *(data->b_rptr);
freemsg(data);
data = NULL;
USB_DPRINTF_L4(DPRINT_MASK_USBA, usbai_log_handle,
"rval=%d, cr=%d, length=%d", rval, completion_reason, length);
/*
* if length is zero the next control request may fail.
* the HCD may not support a zero length control request
* and return an mblk_t which is NULL along with rval
* being USB_SUCCESS and "cr" being USB_CR_OK
*/
if (length < 2) {
rval = USB_FAILURE;
goto done;
}
rval = usb_pipe_sync_ctrl_xfer(dip,
usba_get_dflt_pipe_handle(dip),
USB_DEV_REQ_DEV_TO_HOST,
USB_REQ_GET_DESCR,
(USB_DESCR_TYPE_STRING << 8) | (index & 0xff),
langid,
length,
&data, USB_ATTRS_SHORT_XFER_OK,
&completion_reason,
&cb_flags, USB_FLAGS_SLEEP);
USB_DPRINTF_L4(DPRINT_MASK_USBA, usbai_log_handle,
"rval=%d, cb_flags=%d, cr=%d", rval, cb_flags, completion_reason);
if ((data == NULL) || (rval != USB_SUCCESS)) {
USB_DPRINTF_L2(DPRINT_MASK_USBA, usbai_log_handle,
"failed to get string descriptor (rval=%d cr=%d)",
rval, completion_reason);
goto done;
}
if ((length = MBLKL(data)) != 0) {
len = usba_ascii_string_descr(data->b_rptr, length, buf,
buflen);
USB_DPRINTF_L4(DPRINT_MASK_USBA,
usbai_log_handle, "buf=%s buflen=%lu", buf, len);
ASSERT(len <= buflen);
} else {
rval = USB_FAILURE;
}
done:
freemsg(data);
return (rval);
}
/*
* usb_get_dev_descr:
* utility function to get device descriptor from usba_device
*
* Arguments:
* dip - pointer to devinfo of the client
*
* Return Values:
* usb_dev_descr - device descriptor or NULL
*/
usb_dev_descr_t *
usb_get_dev_descr(dev_info_t *dip)
{
usba_device_t *usba_device;
usb_dev_descr_t *usb_dev_descr = NULL;
if (dip) {
USB_DPRINTF_L4(DPRINT_MASK_USBA, usbai_log_handle,
"usb_get_dev_descr: %s", ddi_node_name(dip));
usba_device = usba_get_usba_device(dip);
mutex_enter(&usba_device->usb_mutex);
usb_dev_descr = usba_device->usb_dev_descr;
mutex_exit(&usba_device->usb_mutex);
}
return (usb_dev_descr);
}
/*
* usb_get_raw_cfg_data:
* utility function to get raw config descriptor from usba_device
*
* Arguments:
* dip - pointer to devinfo of the client
* length - pointer to copy the cfg length
*
* Return Values:
* usb_cfg - raw config descriptor
*/
uchar_t *
usb_get_raw_cfg_data(dev_info_t *dip, size_t *length)
{
usba_device_t *usba_device;
uchar_t *usb_cfg;
USB_DPRINTF_L4(DPRINT_MASK_USBA, usbai_log_handle,
"usb_get_raw_cfg_data: %s", ddi_node_name(dip));
if ((dip == NULL) || (length == NULL)) {
return (NULL);
}
usba_device = usba_get_usba_device(dip);
mutex_enter(&usba_device->usb_mutex);
usb_cfg = usba_device->usb_cfg;
*length = usba_device->usb_cfg_length;
mutex_exit(&usba_device->usb_mutex);
return (usb_cfg);
}
/*
* usb_get_addr:
* utility function to return current usb address, mostly
* for debugging purposes
*
* Arguments:
* dip - pointer to devinfo of the client
*
* Return Values:
* address - USB Device Address
*/
int
usb_get_addr(dev_info_t *dip)
{
int address = 0;
USB_DPRINTF_L4(DPRINT_MASK_USBA, usbai_log_handle,
"usb_get_addr: %s", ddi_node_name(dip));
if (dip) {
usba_device_t *usba_device = usba_get_usba_device(dip);
mutex_enter(&usba_device->usb_mutex);
address = usba_device->usb_addr;
mutex_exit(&usba_device->usb_mutex);
}
return (address);
}
/*
* usb_set_cfg():
* set configuration, use with caution (issues USB_REQ_SET_CONFIG)
* Changing configuration will fail if pipes are still open or when
* invoked from a driver bound to an interface on a composite device.
*
* This function will access the device and block
*
* Arguments:
* dip - pointer to devinfo of the client
* cfg_index - config index
* cfg_value - config value to be set
* flags - USB_FLAGS_SLEEP:
* wait for completion
* cb - if USB_FLAGS_SLEEP has not been specified
* this callback function will be called on
* completion. This callback may be NULL
* and no notification of completion will then
* be provided.
* cb_arg - 2nd argument to callback function.
*
* Return Values:
* USB_SUCCESS: - new configuration was set
* USB_FAILURE: - new configuration could not be set
* USB_BUSY: - some pipes were open or there were children
* USB_* - refer to usbai.h
*/
int
usb_set_cfg(dev_info_t *dip,
uint_t cfg_index,
usb_flags_t usb_flags,
void (*cb)(
usb_pipe_handle_t ph,
usb_opaque_t arg,
int rval,
usb_cb_flags_t flags),
usb_opaque_t cb_arg)
{
usb_pipe_handle_t ph;
USB_DPRINTF_L4(DPRINT_MASK_USBA, usbai_log_handle,
"usb_set_cfg: %s%d, cfg_index = 0x%x, uf = 0x%x",
ddi_driver_name(dip), ddi_get_instance(dip), cfg_index,
usb_flags);
if (dip == NULL) {
return (USB_INVALID_ARGS);
}
if ((usb_flags & USB_FLAGS_SLEEP) && servicing_interrupt()) {
return (USB_INVALID_CONTEXT);
}
if (!usb_owns_device(dip)) {
return (USB_INVALID_PERM);
}
ph = usba_get_dflt_pipe_handle(dip);
if (usba_hold_ph_data(ph) == NULL) {
return (USB_INVALID_PIPE);
}
return (usba_pipe_setup_func_call(dip,
usba_sync_set_cfg, (usba_ph_impl_t *)ph,
(usb_opaque_t)((uintptr_t)cfg_index), usb_flags, cb, cb_arg));
}
static int
usba_sync_set_cfg(dev_info_t *dip,
usba_ph_impl_t *ph_impl,
usba_pipe_async_req_t *request,
usb_flags_t flags)
{
int rval;
usb_cr_t completion_reason;
usb_cb_flags_t cb_flags;
usba_device_t *usba_device;
int i, ph_open_cnt;
uint_t cfg_index = (uint_t)((uintptr_t)(request->arg));
size_t size;
usb_cfg_descr_t confdescr;
dev_info_t *pdip;
usba_device = usba_get_usba_device(dip);
/*
* default pipe is still open
* all other pipes should be closed
*/
for (ph_open_cnt = 0, i = 1; i < USBA_N_ENDPOINTS; i++) {
if (usba_device->usb_ph_list[i].usba_ph_data) {
ph_open_cnt++;
break;
}
}
if (ph_open_cnt || ddi_get_child(dip)) {
usba_release_ph_data(ph_impl);
return (USB_BUSY);
}
/*
* check if the configuration meets the
* power budget requirement
*/
if (usba_is_root_hub(dip)) {
/*
* root hub should never be multi-configured.
* the code is here just to ensure
*/
usba_release_ph_data(ph_impl);
return (USB_FAILURE);
}
pdip = ddi_get_parent(dip);
/*
* increase the power budget value back to the unconfigured
* state to eliminate the influence of the old configuration
* before checking the new configuration; but remember to
* make a decrement before leaving this routine to restore
* the power consumption state of the device no matter it
* is in the new or old configuration
*/
usba_hubdi_incr_power_budget(pdip, usba_device);
if ((usba_hubdi_check_power_budget(pdip, usba_device,
cfg_index)) != USB_SUCCESS) {
usba_hubdi_decr_power_budget(pdip, usba_device);
usba_release_ph_data(ph_impl);
return (USB_FAILURE);
}
size = usb_parse_cfg_descr(usba_device->usb_cfg_array[cfg_index],
USB_CFG_DESCR_SIZE, &confdescr, USB_CFG_DESCR_SIZE);
/* hubdi should ensure that this descriptor is correct */
ASSERT(size == USB_CFG_DESCR_SIZE);
/* set the configuration */
rval = usb_pipe_sync_ctrl_xfer(dip, (usb_pipe_handle_t)ph_impl,
USB_DEV_REQ_HOST_TO_DEV,
USB_REQ_SET_CFG,
confdescr.bConfigurationValue,
0,
0,
NULL, 0,
&completion_reason,
&cb_flags, flags | USBA_FLAGS_PRIVILEGED | USB_FLAGS_SLEEP);
if (rval == USB_SUCCESS) {
mutex_enter(&usba_device->usb_mutex);
usba_device->usb_cfg_value = confdescr.bConfigurationValue;
usba_device->usb_active_cfg_ndx = cfg_index;
usba_device->usb_cfg = usba_device->usb_cfg_array[cfg_index];
usba_device->usb_cfg_length = confdescr.wTotalLength;
mutex_exit(&usba_device->usb_mutex);
/* update the configuration property */
(void) ndi_prop_update_int(DDI_DEV_T_NONE, dip,
"configuration#", usba_device->usb_cfg_value);
}
/*
* usba_device->usb_cfg always stores current configuration
* descriptor no matter SET_CFG request succeeded or not,
* so usba_hubdi_decr_power_budget can be done regardless
* of rval above
*/
usba_hubdi_decr_power_budget(pdip, usba_device);
USB_DPRINTF_L4(DPRINT_MASK_USBA, usbai_log_handle,
"rval=%d, cb_flags=%d, cr=%d", rval, cb_flags, completion_reason);
usba_release_ph_data(ph_impl);
return (rval);
}
/*
* usb_get_cfg():
* get configuration value
*
* Arguments:
* dip - pointer to devinfo of the client
* cfg_value - current config value
* flags - none, always blocks
*
* Return Values:
* USB_SUCCESS: - config value was retrieved
* USB_FAILURE: - config value could not be retrieved
* USB_* - refer to usbai.h
*/
int
usb_get_cfg(dev_info_t *dip,
uint_t *cfgval,
usb_flags_t flags)
{
int rval;
usb_cr_t completion_reason;
mblk_t *data = NULL;
usb_cb_flags_t cb_flags;
usb_pipe_handle_t ph;
USB_DPRINTF_L4(DPRINT_MASK_USBA, usbai_log_handle,
"usb_get_cfg: %s uf = 0x%x", ddi_node_name(dip), flags);
if ((cfgval == NULL) || (dip == NULL)) {
return (USB_INVALID_ARGS);
}
ph = usba_get_dflt_pipe_handle(dip);
/*
* get the cfg value
*/
rval = usb_pipe_sync_ctrl_xfer(dip, ph,
USB_DEV_REQ_DEV_TO_HOST | USB_DEV_REQ_RCPT_DEV,
USB_REQ_GET_CFG,
0,
0,
1, /* returns one byte of data */
&data, 0,
&completion_reason,
&cb_flags, flags);
USB_DPRINTF_L4(DPRINT_MASK_USBA, usbai_log_handle,
"rval=%d cb_flags=%d cr=%d", rval, cb_flags, completion_reason);
if ((rval == USB_SUCCESS) && data &&
(MBLKL(data) == 1)) {
*cfgval = *(data->b_rptr);
} else {
*cfgval = 1;
if (rval == USB_SUCCESS) {
rval = USB_FAILURE;
}
}
USB_DPRINTF_L4(DPRINT_MASK_USBA, usbai_log_handle,
"usb_get_cfg: %s cfgval=%d", ddi_node_name(dip), *cfgval);
freemsg(data);
return (rval);
}
/*
* usb_get_current_cfgidx:
* get current current config index
*/
uint_t
usb_get_current_cfgidx(dev_info_t *dip)
{
usba_device_t *usba_device = usba_get_usba_device(dip);
uint_t ndx;
mutex_enter(&usba_device->usb_mutex);
ndx = usba_device->usb_active_cfg_ndx;
mutex_exit(&usba_device->usb_mutex);
return (ndx);
}
/*
* usb_get_if_number:
* get usb interface number of current OS device node.
*
* Arguments:
* dip - pointer to devinfo of the client
*
* Return Values:
* USB_COMBINED_NODE if the driver is responsible for the entire
* device and this dip doesn't correspond to a device node.
* USB_DEVICE_NODE if the driver is responsible for the entire device
* and this dip corresponds to a device node.
* interface number: otherwise.
*/
int
usb_get_if_number(dev_info_t *dip)
{
int interface_num;
usba_device_t *usba_device = usba_get_usba_device(dip);
usb_dev_descr_t *usb_dev_descr;
USB_DPRINTF_L4(DPRINT_MASK_USBA, usbai_log_handle,
"usb_get_if_number: dip = 0x%p", (void *)dip);
/* not quite right but we can't return a negative return value */
if (dip == NULL) {
return (0);
}
if (usba_device) {
usb_dev_descr = usba_device->usb_dev_descr;
} else {
return (0);
}
interface_num = ddi_prop_get_int(DDI_DEV_T_ANY, dip,
DDI_PROP_DONTPASS, "interface", USB_COMBINED_NODE);
if (interface_num == USB_COMBINED_NODE) {
if (!(((usb_dev_descr->bDeviceClass == USB_CLASS_HUB) ||
(usb_dev_descr->bDeviceClass == 0)) &&
(usba_device->usb_n_cfgs == 1) &&
(usba_device->usb_n_ifs == 1))) {
interface_num = USB_DEVICE_NODE;
}
}
return (interface_num);
}
boolean_t
usb_owns_device(dev_info_t *dip)
{
int interface_num = usb_get_if_number(dip);
return (interface_num < 0 ? B_TRUE : B_FALSE);
}
/* check whether the interface is in this interface association */
boolean_t
usba_check_if_in_ia(dev_info_t *dip, int n_if)
{
int first_if, if_count;
first_if = usb_get_if_number(dip);
if_count = ddi_prop_get_int(DDI_DEV_T_ANY, dip,
DDI_PROP_DONTPASS, "interface-count", -1);
if_count += first_if;
return ((n_if >= first_if && n_if < if_count) ? B_TRUE : B_FALSE);
}
uint8_t
usba_get_ifno(dev_info_t *dip)
{
int interface_num = usb_get_if_number(dip);
return (uint8_t)(interface_num < 0 ? 0 : interface_num);
}
/*
* usb_set_alt_if:
* set the alternate interface number. Issues USB_REQ_SET_IF
* This function will access the device
*
* Arguments:
* dip - pointer to devinfo of the client
* if_number - interface number
* alt_number - alternate interface number
* flags - USB_FLAGS_SLEEP:
* wait for completion
* cb - if USB_FLAGS_SLEEP has not been specified
* this callback function will be called on
* completion. This callback may be NULL
* and no notification of completion will then
* be provided.
* cb_arg - 2nd argument to callback function.
*
*
* return values:
* USB_SUCCESS - alternate was set
* USB_FAILURE - alternate could not be set because pipes
* were still open or some access error occurred
* USB_* - refer to usbai.h
*
* Note:
* we can't easily check if all pipes to endpoints for this interface
* are closed since we don't have a map of which endpoints belong
* to which interface. If we had this map, we would need to update
* this on each alternative or configuration switch
*/
int
usb_set_alt_if(dev_info_t *dip,
uint_t interface,
uint_t alt_number,
usb_flags_t usb_flags,
void (*cb)(
usb_pipe_handle_t ph,
usb_opaque_t arg,
int rval,
usb_cb_flags_t flags),
usb_opaque_t cb_arg)
{
usb_pipe_handle_t ph;
USB_DPRINTF_L4(DPRINT_MASK_USBA, usbai_log_handle,
"usb_set_alt_if: %s%d, if = %d alt = %d, uf = 0x%x",
ddi_driver_name(dip), ddi_get_instance(dip),
interface, alt_number, usb_flags);
if (dip == NULL) {
return (USB_INVALID_ARGS);
}
if ((usb_flags & USB_FLAGS_SLEEP) && servicing_interrupt()) {
return (USB_INVALID_CONTEXT);
}
ph = usba_get_dflt_pipe_handle(dip);
if (usba_hold_ph_data(ph) == NULL) {
return (USB_INVALID_PIPE);
}
return (usba_pipe_setup_func_call(dip,
usba_sync_set_alt_if, (usba_ph_impl_t *)ph,
(usb_opaque_t)((uintptr_t)((interface << 8) | alt_number)),
usb_flags, cb, cb_arg));
}
static int
usba_sync_set_alt_if(dev_info_t *dip,
usba_ph_impl_t *ph_impl,
usba_pipe_async_req_t *request,
usb_flags_t flags)
{
int rval;
usb_cr_t completion_reason;
usb_cb_flags_t cb_flags;
usb_opaque_t arg = request->arg;
int interface = ((uintptr_t)arg >> 8) & 0xff;
int alt_number = (uintptr_t)arg & 0xff;
usba_pipe_handle_data_t *ph_data = usba_get_ph_data(
(usb_pipe_handle_t)ph_impl);
USB_DPRINTF_L4(DPRINT_MASK_USBA, usbai_log_handle,
"usb_set_alt_if: %s, interface#=0x%x, alt#=0x%x, "
"uf=0x%x", ddi_node_name(dip), interface,
alt_number, flags);
/* if we don't own the device, we must own the interface or ia */
if (!usb_owns_device(dip) && !usba_check_if_in_ia(dip, interface) &&
(interface != usb_get_if_number(dip))) {
usba_release_ph_data(ph_data->p_ph_impl);
return (USB_INVALID_PERM);
}
/* set the alternate setting */
rval = usb_pipe_sync_ctrl_xfer(dip, usba_get_dflt_pipe_handle(dip),
USB_DEV_REQ_HOST_TO_DEV | USB_DEV_REQ_RCPT_IF,
USB_REQ_SET_IF,
alt_number,
interface,
0,
NULL, 0,
&completion_reason,
&cb_flags, flags | USB_FLAGS_SLEEP);
USB_DPRINTF_L4(DPRINT_MASK_USBA, usbai_log_handle,
"rval=%d, cb_flags=%d, cr=%d", rval, cb_flags, completion_reason);
usba_release_ph_data(ph_data->p_ph_impl);
return (rval);
}
/*
* usb_get_alt_if:
* get the alternate interface number. Issues USB_REQ_GET_IF
* This function will access the device and block
*
* Arguments:
* dip - pointer to devinfo of the client
* if_number - interface number
* alt_number - alternate interface number
* flags - none but USB_FLAGS_SLEEP may be passed
*
* return values:
* USB_SUCCESS: alternate was set
* USB_FAILURE: alternate could not be set because pipes
* were still open or some access error occurred
*/
int
usb_get_alt_if(dev_info_t *dip,
uint_t if_number,
uint_t *alt_number,
usb_flags_t flags)
{
int rval;
usb_cr_t completion_reason;
mblk_t *data = NULL;
usb_cb_flags_t cb_flags;
usb_pipe_handle_t ph;
USB_DPRINTF_L4(DPRINT_MASK_USBA, usbai_log_handle,
"usb_get_alt_if: %s, interface# = 0x%x, altp = 0x%p, "
"uf = 0x%x", ddi_node_name(dip), if_number,
(void *)alt_number, flags);
if ((alt_number == NULL) || (dip == NULL)) {
return (USB_INVALID_ARGS);
}
ph = usba_get_dflt_pipe_handle(dip);
/*
* get the alternate setting
*/
rval = usb_pipe_sync_ctrl_xfer(dip, ph,
USB_DEV_REQ_DEV_TO_HOST | USB_DEV_REQ_RCPT_IF,
USB_REQ_GET_IF,
0,
if_number,
1, /* returns one byte of data */
&data, 0,
&completion_reason,
&cb_flags, flags);
USB_DPRINTF_L4(DPRINT_MASK_USBA, usbai_log_handle,
"rval=%d cb_flags=%d cr=%d", rval, cb_flags, completion_reason);
if ((rval == USB_SUCCESS) && data &&
(MBLKL(data) == 1)) {
*alt_number = *(data->b_rptr);
} else {
*alt_number = 0;
if (rval == USB_SUCCESS) {
rval = USB_FAILURE;
}
}
freemsg(data);
return (rval);
}
/*
* usba_get_cfg_cloud:
* Get descriptor cloud for a given configuration.
*
* Arguments:
* dip - pointer to devinfo of the client
* default_ph - default pipe handle
* cfg - which configuration to retrieve raw cloud of
*
* Returns:
* on success: mblock containing the raw data. Caller must free.
* on failure: NULL
*/
static mblk_t *
usba_get_cfg_cloud(dev_info_t *dip, usb_pipe_handle_t default_ph, int cfg)
{
usb_cr_t completion_reason;
usb_cb_flags_t cb_flags;
usb_cfg_descr_t cfg_descr;
mblk_t *pdata = NULL;
if (usb_pipe_sync_ctrl_xfer(dip, default_ph,
USB_DEV_REQ_DEV_TO_HOST | USB_DEV_REQ_TYPE_STANDARD,
USB_REQ_GET_DESCR,
USB_DESCR_TYPE_SETUP_CFG | cfg,
0,
USB_CFG_DESCR_SIZE,
&pdata,
0,
&completion_reason,
&cb_flags,
0) != USB_SUCCESS) {
freemsg(pdata);
return (NULL);
}
(void) usb_parse_cfg_descr(pdata->b_rptr,
MBLKL(pdata), &cfg_descr, USB_CFG_DESCR_SIZE);
freemsg(pdata);
pdata = NULL;
if (usb_pipe_sync_ctrl_xfer(dip, default_ph,
USB_DEV_REQ_DEV_TO_HOST | USB_DEV_REQ_TYPE_STANDARD,
USB_REQ_GET_DESCR,
USB_DESCR_TYPE_SETUP_CFG | cfg,
0,
cfg_descr.wTotalLength,
&pdata,
0,
&completion_reason,
&cb_flags,
0) != USB_SUCCESS) {
freemsg(pdata);
return (NULL);
}
return (pdata);
}
/*
* usb_check_same_device:
* Check if the device connected to the port is the same as
* the previous device that was in the port. The previous device is
* represented by the dip on record for the port. Print a message
* if the device is different. If device_string arg is not NULL, it is
* included in the message. Can block.
*
* Arguments:
* dip - pointer to devinfo of the client
* log_handle - handle to which messages are logged
* log_level - one of USB_LOG_*
* log_mask - logging mask
* check_mask - one mask containing things to check:
* USB_CHK_BASIC: empty mask;
* these checks are always done.
* USB_CHK_VIDPID:
* check vid, pid only.
* USB_CHK_SERIAL: check match on device
* serial number.
* USB_CHK_CFG: check all raw config
* clouds for a match.
* NOTE: descr length and content always checked
* device_string - Device string to appear in error message
*
* return values:
* USB_SUCCESS: same device
* USB_INVALID_VERSION not same device
* USB_FAILURE: Failure processing request
* USB_INVALID_ARG: dip is invalid
*/
int
usb_check_same_device(dev_info_t *dip, usb_log_handle_t log_handle,
int log_level, int log_mask, uint_t check_mask, char *device_string)
{
usb_dev_descr_t usb_dev_descr;
usba_device_t *usba_device;
mblk_t *pdata = NULL;
uint16_t length;
int rval;
char *buf;
usb_cr_t completion_reason;
usb_cb_flags_t cb_flags;
boolean_t match = B_TRUE;
usb_pipe_handle_t def_ph;
if (dip == NULL) {
return (USB_INVALID_ARGS);
}
usba_device = usba_get_usba_device(dip);
length = usba_device->usb_dev_descr->bLength;
def_ph = usba_get_dflt_pipe_handle(dip);
ASSERT(def_ph);
/* get the "new" device descriptor */
rval = usb_pipe_sync_ctrl_xfer(dip, def_ph,
USB_DEV_REQ_DEV_TO_HOST |
USB_DEV_REQ_TYPE_STANDARD,
USB_REQ_GET_DESCR, /* bRequest */
USB_DESCR_TYPE_SETUP_DEV, /* wValue */
0, /* wIndex */
length, /* wLength */
&pdata, 0,
&completion_reason,
&cb_flags, USB_FLAGS_SLEEP);
if (rval != USB_SUCCESS) {
if (!((completion_reason == USB_CR_DATA_OVERRUN) && (pdata))) {
USB_DPRINTF_L3(DPRINT_MASK_USBA, usbai_log_handle,
"getting device descriptor failed (%d)", rval);
freemsg(pdata);
return (USB_FAILURE);
}
}
ASSERT(pdata != NULL);
(void) usb_parse_dev_descr(pdata->b_rptr,
MBLKL(pdata), &usb_dev_descr,
sizeof (usb_dev_descr_t));
freemsg(pdata);
pdata = NULL;
/* Always check the device descriptor length. */
if (usb_dev_descr.bLength != length) {
match = B_FALSE;
}
if ((match == B_TRUE) && (check_mask & USB_CHK_VIDPID)) {
match = (usba_device->usb_dev_descr->idVendor ==
usb_dev_descr.idVendor) &&
(usba_device->usb_dev_descr->idProduct ==
usb_dev_descr.idProduct);
} else if (bcmp((char *)usba_device->usb_dev_descr,
(char *)&usb_dev_descr, length) != 0) {
match = B_FALSE;
}
/* if requested & this device has a serial number check and compare */
if ((match == B_TRUE) && ((check_mask & USB_CHK_SERIAL) != 0) &&
(usba_device->usb_serialno_str != NULL)) {
buf = kmem_alloc(USB_MAXSTRINGLEN, KM_SLEEP);
if (usb_get_string_descr(dip, USB_LANG_ID,
usb_dev_descr.iSerialNumber, buf,
USB_MAXSTRINGLEN) == USB_SUCCESS) {
match =
(strcmp(buf, usba_device->usb_serialno_str) == 0);
}
kmem_free(buf, USB_MAXSTRINGLEN);
}
if ((match == B_TRUE) && (check_mask & USB_CHK_CFG)) {
uint8_t num_cfgs = usb_dev_descr.bNumConfigurations;
uint8_t cfg;
mblk_t *cloud;
for (cfg = 0; cfg < num_cfgs; cfg++) {
cloud = usba_get_cfg_cloud(dip, def_ph, cfg);
if (cloud == NULL) {
USB_DPRINTF_L3(DPRINT_MASK_USBA,
usbai_log_handle,
"Could not retrieve config cloud for "
"comparison");
break;
}
if (bcmp((char *)cloud->b_rptr,
usba_device->usb_cfg_array[cfg],
MBLKL(cloud)) != 0) {
freemsg(cloud);
break;
}
freemsg(cloud);
}
if (cfg != num_cfgs) {
match = B_FALSE;
}
}
if (match == B_FALSE) {
boolean_t allocated_here = (device_string == NULL);
if (allocated_here) {
device_string =
kmem_zalloc(USB_MAXSTRINGLEN, USB_FLAGS_SLEEP);
(void) usba_get_mfg_prod_sn_str(dip, device_string,
USB_MAXSTRINGLEN);
}
if (device_string[0] != '\0') {
(void) usb_log(log_handle, log_level, log_mask,
"Cannot access %s. Please reconnect.",
device_string);
} else {
(void) usb_log(log_handle, log_level, log_mask,
"Device is not identical to the "
"previous one this port.\n"
"Please disconnect and reconnect");
}
if (allocated_here) {
kmem_free(device_string, USB_MAXSTRINGLEN);
}
return (USB_INVALID_VERSION);
}
return (USB_SUCCESS);
}
/*
* usb_pipe_get_state:
* Return the state of the pipe
*
* Arguments:
* pipe_handle - pipe_handle pointer
* pipe_state - pointer to copy pipe state to
* flags:
* not used other than to check context
*
* Return Values:
* USB_SUCCESS - port state returned
* USB_* - refer to usbai.h
*/
int
usb_pipe_get_state(usb_pipe_handle_t pipe_handle,
usb_pipe_state_t *pipe_state,
usb_flags_t usb_flags)
{
usba_pipe_handle_data_t *ph_data = usba_hold_ph_data(pipe_handle);
USB_DPRINTF_L4(DPRINT_MASK_USBAI, usbai_log_handle,
"usb_pipe_get_state: ph_data=0x%p uf=0x%x", (void *)ph_data,
usb_flags);
if (pipe_state == NULL) {
if (ph_data) {
usba_release_ph_data(ph_data->p_ph_impl);
}
return (USB_INVALID_ARGS);
}
if (ph_data == NULL) {
*pipe_state = USB_PIPE_STATE_CLOSED;
return (USB_SUCCESS);
}
mutex_enter(&ph_data->p_mutex);
*pipe_state = usba_get_ph_state(ph_data);
mutex_exit(&ph_data->p_mutex);
usba_release_ph_data(ph_data->p_ph_impl);
return (USB_SUCCESS);
}
/*
* usba_pipe_get_policy:
* Return a pipe's policy
*
* Arguments:
* pipe_handle - pipe_handle pointer
*
* Return Values:
* On success: the pipe's policy
* On failure: NULL
*/
usb_pipe_policy_t
*usba_pipe_get_policy(usb_pipe_handle_t pipe_handle)
{
usb_pipe_policy_t *pp = NULL;
usba_pipe_handle_data_t *ph_data = usba_hold_ph_data(pipe_handle);
if (ph_data) {
pp = &ph_data->p_policy;
usba_release_ph_data(ph_data->p_ph_impl);
}
return (pp);
}
/*
* usb_ep_num:
* Return the endpoint number for a given pipe handle
*
* Arguments:
* pipe_handle - pipe_handle pointer
*
* Return Values:
* endpoint number
*/
int
usb_ep_num(usb_pipe_handle_t pipe_handle)
{
usba_pipe_handle_data_t *ph_data = usba_hold_ph_data(pipe_handle);
int ep_num;
if (ph_data == NULL) {
return (USB_INVALID_PIPE);
}
mutex_enter(&ph_data->p_mutex);
ep_num = ph_data->p_ep.bEndpointAddress & USB_EP_NUM_MASK;
mutex_exit(&ph_data->p_mutex);
usba_release_ph_data(ph_data->p_ph_impl);
return (ep_num);
}
/*
* usb_get_status
* Issues USB_REQ_GET_STATUS to device/endpoint/interface
* and report in "status" arg.
*
* status reported for a "device" is
* RemoteWakeup enabled
* SelfPowered device?
*
* status reported for an "interface" is NONE.
* status reported for an "endpoint" is
* HALT set (device STALLED?)
*
* Arguments:
* dip - pointer to devinfo of the client
* ph - pipe handle
* type - bmRequestType to be used
* what - 0 for device, otherwise interface or ep number
* status - user supplied pointer for storing the status
* flags - USB_FLAGS_SLEEP (mandatory)
*
* Return Values:
* valid usb_status_t or USB_FAILURE
*/
int
usb_get_status(dev_info_t *dip,
usb_pipe_handle_t ph,
uint_t type, /* bmRequestType */
uint_t what, /* 0, interface, ept number */
uint16_t *status,
usb_flags_t flags)
{
int rval;
usb_cr_t completion_reason;
mblk_t *data = NULL;
usb_cb_flags_t cb_flags;
USB_DPRINTF_L4(DPRINT_MASK_USBA, usbai_log_handle,
"usb_get_status: type = 0x%x, what = 0x%x, uf = 0x%x",
type, what, flags);
if ((status == NULL) || (dip == NULL)) {
return (USB_INVALID_ARGS);
}
if (ph == NULL) {
return (USB_INVALID_PIPE);
}
type |= USB_DEV_REQ_DEV_TO_HOST;
/* get the status */
rval = usb_pipe_sync_ctrl_xfer(dip, ph,
type,
USB_REQ_GET_STATUS,
0,
what,
USB_GET_STATUS_LEN, /* status is fixed 2 bytes long */
&data, 0,
&completion_reason, &cb_flags, flags);
USB_DPRINTF_L4(DPRINT_MASK_USBA, usbai_log_handle,
"rval=%d, cb_flags=%d, cr=%d", rval, cb_flags, completion_reason);
if ((rval == USB_SUCCESS) && data &&
(MBLKL(data) == USB_GET_STATUS_LEN)) {
*status = (*(data->b_rptr + 1) << 8) | *(data->b_rptr);
} else {
*status = 0;
if (rval == USB_SUCCESS) {
rval = USB_FAILURE;
}
}
freemsg(data);
return (rval);
}
/*
* usb_clear_feature:
* Issue USB_REQ_CLEAR_FEATURE to endpoint/device/interface
*
* Arguments:
* dip - pointer to devinfo of the client
* ph - pipe handle pointer
* type - bmRequestType to be used
* feature - feature to be cleared
* what - 0 for device, otherwise interface or ep number
* flags - none (but will sleep)
*
* Return Values:
* USB_SUCCESS - on doing a successful clear feature
* USB_FAILURE - on failure
* USB_* - refer to usbai.h
*/
int
usb_clear_feature(dev_info_t *dip,
usb_pipe_handle_t ph,
uint_t type, /* bmRequestType */
uint_t feature,
uint_t what, /* 0, interface, ept number */
usb_flags_t flags)
{
int rval;
usb_cr_t completion_reason;
usb_cb_flags_t cb_flags;
USB_DPRINTF_L4(DPRINT_MASK_USBA, usbai_log_handle,
"usb_clear_feature: type = 0x%x, feature = 0x%x, what = 0x%x "
"uf = 0x%x", type, feature, what, flags);
if (dip == NULL) {
return (USB_INVALID_ARGS);
}
if (ph == NULL) {
return (USB_INVALID_PIPE);
}
/* issue Clear feature */
rval = usb_pipe_sync_ctrl_xfer(dip, ph,
type,
USB_REQ_CLEAR_FEATURE,
feature,
what,
0,
NULL, 0,
&completion_reason,
&cb_flags, flags | USB_FLAGS_SLEEP);
USB_DPRINTF_L4(DPRINT_MASK_USBA, usbai_log_handle,
"rval=%d, cb_flags=%d, cr=%d", rval, cb_flags, completion_reason);
return (rval);
}
/*
* usb_clr_feature:
* Issue USB_REQ_CLEAR_FEATURE to endpoint/device/interface
*
* Arguments:
* dip - pointer to devinfo of the client
* type - bmRequestType to be used
* feature - feature to be cleared
* what - 0 for device, otherwise interface or ep number
* flags - USB_FLAGS_SLEEP:
* wait for completion
* cb - if USB_FLAGS_SLEEP has not been specified
* this callback function will be called on
* completion. This callback may be NULL
* and no notification of completion will then
* be provided.
* cb_arg - 2nd argument to callback function.
*
*
* Return Values:
* USB_SUCCESS - on doing a successful clear feature
* USB_FAILURE - on failure
* USB_* - refer to usbai.h
*/
int
usb_clr_feature(
dev_info_t *dip,
uint_t type, /* bmRequestType */
uint_t feature,
uint_t what, /* 0, interface, ept number */
usb_flags_t flags,
void (*cb)(
usb_pipe_handle_t ph,
usb_opaque_t arg,
int rval,
usb_cb_flags_t flags),
usb_opaque_t cb_arg)
{
usb_pipe_handle_t ph;
USB_DPRINTF_L4(DPRINT_MASK_USBA, usbai_log_handle,
"usb_clr_feature: type = 0x%x, feature = 0x%x, what = 0x%x "
"uf = 0x%x", type, feature, what, flags);
if (dip == NULL) {
return (USB_INVALID_ARGS);
}
if ((flags & USB_FLAGS_SLEEP) && servicing_interrupt()) {
return (USB_INVALID_CONTEXT);
}
ph = usba_get_dflt_pipe_handle(dip);
if (usba_hold_ph_data(ph) == NULL) {
return (USB_INVALID_PIPE);
}
return (usba_pipe_setup_func_call(dip,
usba_sync_clear_feature, (usba_ph_impl_t *)ph,
(usb_opaque_t)((uintptr_t)((type << 16 | feature << 8 | what))),
flags, cb, cb_arg));
}
static int
usba_sync_clear_feature(dev_info_t *dip,
usba_ph_impl_t *ph_impl,
usba_pipe_async_req_t *req,
usb_flags_t usb_flags)
{
uint_t n = (uint_t)((uintptr_t)(req->arg));
uint_t type = ((uint_t)n >> 16) & 0xff;
uint_t feature = ((uint_t)n >> 8) & 0xff;
uint_t what = (uint_t)n & 0xff;
int rval;
usba_device_t *usba_device;
usba_pipe_handle_data_t *ph_data;
usba_ph_impl_t *ph_im;
uchar_t ep_index;
usb_ep_descr_t *eptd;
USB_DPRINTF_L4(DPRINT_MASK_USBA, usbai_log_handle,
"usb_sync_clear_feature: "
"dip=0x%p ph=0x%p type=0x%x feature=0x%x what=0x%x fl=0x%x",
(void *)dip, (void *)ph_impl, type, feature, what, usb_flags);
rval = usb_clear_feature(dip, (usb_pipe_handle_t)ph_impl, type,
feature, what, usb_flags);
/*
* Reset data toggle to DATA0 for bulk and interrupt endpoint.
* Data toggle synchronization is not supported for isochronous
* transfer.Halt feature is not supported by control endpoint.
*
* From USB2.0 specification:
* 1.Section 5.8.5 Bulk Transfer Data Sequences
* Removal of the halt condition is achieved via software intervention
* through a separate control pipe. This recovery will reset the data
* toggle bit to DATA0 for the endpoint on both the host and the device.
*
* 2.Section 5.7.5 Interrupt Transfer Data Sequences
* Removal of the halt condition is achieved via software intervention
* through a separate control pipe. This recovery will reset the data
* toggle bit to DATA0 for the endpoint on both the host and the device.
*
* 3.Section 9.4.5
* If the condition causing a halt has been removed, clearing the Halt
* feature via a ClearFeature(ENDPOINT_HALT) request results in the
* endpoint no longer returning a STALL. For endpoints using data
* toggle, regardless of whether an endpoint has the Halt feature set, a
* ClearFeature(ENDPOINT_HALT) request always results in the data toggle
* being reinitialized to DATA0.
*
*/
if (rval == USB_SUCCESS && feature == 0) {
usba_device = usba_get_usba_device(dip);
ep_index = usb_get_ep_index((uint8_t)what);
ph_im = &usba_device->usb_ph_list[ep_index];
ph_data = usba_get_ph_data((usb_pipe_handle_t)ph_im);
eptd = &ph_data->p_ep;
if ((eptd->bmAttributes & USB_EP_ATTR_MASK) ==
USB_EP_ATTR_BULK || (eptd->bmAttributes &
USB_EP_ATTR_MASK) == USB_EP_ATTR_INTR)
usba_device->usb_hcdi_ops->
usba_hcdi_pipe_reset_data_toggle(ph_data);
}
usba_release_ph_data(ph_impl);
return (rval);
}
/*
* usb_async_req:
* function used to dispatch a request to the taskq
*
* Arguments:
* dip - pointer to devinfo node
* func - pointer to function issued by taskq
* flag - USB_FLAGS_SLEEP mostly
*
* Return Values:
* USB_SUCCESS - on doing a successful taskq invocation
* USB_FAILURE - on failure
* USB_* - refer to usbai.h
*/
int
usb_async_req(dev_info_t *dip,
void (*func)(void *),
void *arg,
usb_flags_t flag)
{
int tq_flag;
USB_DPRINTF_L4(DPRINT_MASK_USBA, usbai_log_handle,
"usb_async_req: dip=0x%p func=0x%p, arg=0x%p flag=0x%x",
(void *)dip, (void *)func, arg, flag);
if ((dip == NULL) || (func == NULL)) {
return (USB_INVALID_ARGS);
}
tq_flag = (flag & USB_FLAGS_SLEEP) ? TQ_SLEEP : TQ_NOSLEEP;
if (flag & USB_FLAGS_NOQUEUE) {
tq_flag |= TQ_NOQUEUE;
}
if (taskq_dispatch(system_taskq, func, arg,
tq_flag) == TASKQID_INVALID) {
USB_DPRINTF_L2(DPRINT_MASK_USBA, usbai_log_handle,
"usb_async_req: failure");
return (USB_FAILURE);
}
return (USB_SUCCESS);
}
/*
* usba_async_ph_req:
* function used to dispatch a request to the ph taskq
*
* Arguments:
* ph_data - pointer to pipe handle data
* func - pointer to function issued by taskq
* flag - USB_FLAGS_SLEEP or USB_FLAGS_NOSLEEP
*
* Return Values:
* USB_SUCCESS - on doing a successful taskq invocation
* USB_FAILURE - on failure
* USB_* - refer to usbai.h
*
* Note:
* If the caller specified USB_FLAGS_NOSLEEP, it must be
* capable of reliably recovering from a failure return
*/
int
usba_async_ph_req(usba_pipe_handle_data_t *ph_data,
void (*func)(void *),
void *arg,
usb_flags_t flag)
{
int tq_flag;
taskq_t *taskq;
USB_DPRINTF_L4(DPRINT_MASK_USBA, usbai_log_handle,
"usba_async_ph_req: ph_data=0x%p func=0x%p, arg=0x%p flag=0x%x",
(void *)ph_data, (void *)func, arg, flag);
if (func == NULL) {
return (USB_INVALID_ARGS);
}
tq_flag = (flag & USB_FLAGS_SLEEP) ? TQ_SLEEP : TQ_NOSLEEP;
if (ph_data && ph_data->p_taskq) {
taskq = ph_data->p_taskq;
} else {
taskq = system_taskq;
tq_flag |= TQ_NOQUEUE;
}
if (taskq_dispatch(taskq, func, arg, tq_flag) == TASKQID_INVALID) {
USB_DPRINTF_L2(DPRINT_MASK_USBA, usbai_log_handle,
"usba_async_ph_req: failure");
return (USB_FAILURE);
}
return (USB_SUCCESS);
}
/*
* utility functions to display CR, CB, return values
*/
typedef struct conv_table {
int what;
const char *name;
} conv_table_t;
static const char *
usba_get_name(conv_table_t *conv_table, int value)
{
int i;
for (i = 0; conv_table[i].name != NULL; i++) {
if (conv_table[i].what == value) {
return (conv_table[i].name);
}
}
return ("unknown");
}
static conv_table_t cr_table[] = {
{ USB_CR_OK, "<no errors detected>" },
{ USB_CR_CRC, "<crc error detected>" },
{ USB_CR_BITSTUFFING, "<Bit stuffing violation>" },
{ USB_CR_DATA_TOGGLE_MM, "<Data toggle PID did not match>" },
{ USB_CR_STALL, "<Endpoint returned stall PID>" },
{ USB_CR_DEV_NOT_RESP, "<Device not responding>" },
{ USB_CR_PID_CHECKFAILURE, "<Check bits on PID failed>" },
{ USB_CR_UNEXP_PID, "<Receive PID was not valid>" },
{ USB_CR_DATA_OVERRUN, "<Data size exceeded>" },
{ USB_CR_DATA_UNDERRUN, "<Less data recieved than requested>" },
{ USB_CR_BUFFER_OVERRUN, "<Memory write can't keep up>" },
{ USB_CR_BUFFER_UNDERRUN, "<Buffer underrun>" },
{ USB_CR_TIMEOUT, "<Command timed out>" },
{ USB_CR_NOT_ACCESSED, "<Not accessed by hardware>" },
{ USB_CR_NO_RESOURCES, "<No resources>" },
{ USB_CR_UNSPECIFIED_ERR, "<Unspecified usba or hcd error>" },
{ USB_CR_STOPPED_POLLING, "<Intr/ISOC IN polling stopped>" },
{ USB_CR_PIPE_CLOSING, "<Intr/ISOC IN pipe being closed>" },
{ USB_CR_PIPE_RESET, "<Intr/ISOC IN pipe reset>" },
{ USB_CR_NOT_SUPPORTED, "<Command not supported>" },
{ USB_CR_FLUSHED, "<Req was flushed>" },
{ USB_CR_HC_HARDWARE_ERR, "<USB host controller error>" },
{ 0, NULL }
};
const char *
usb_str_cr(usb_cr_t cr)
{
return (usba_get_name(cr_table, cr));
}
static conv_table_t cb_flags_table[] = {
{ USB_CB_NO_INFO, "<callback processed>" },
{ USB_CB_STALL_CLEARED, "<stall cleared>" },
{ USB_CB_FUNCTIONAL_STALL, "<functional stall>" },
{ USB_CB_PROTOCOL_STALL, "<protocol stall>" },
{ USB_CB_RESET_PIPE, "<pipe reset>" },
{ USB_CB_ASYNC_REQ_FAILED, "<thread could not be started>" },
{ USB_CB_NO_RESOURCES, "<no resources>" },
{ USB_CB_SUBMIT_FAILED, "<submit failed>" },
{ USB_CB_INTR_CONTEXT, "<Callback executing in interrupt context>" },
{ 0, NULL }
};
/*ARGSUSED*/
char *
usb_str_cb_flags(usb_cb_flags_t cb_flags, char *buffer, size_t length)
{
int i;
buffer[0] = '\0';
if (cb_flags == USB_CB_NO_INFO) {
(void) strncpy(buffer, cb_flags_table[0].name, length);
} else {
for (i = 0; cb_flags_table[i].name != NULL; i++) {
if (cb_flags & cb_flags_table[i].what) {
(void) strncpy(&buffer[strlen(buffer)],
cb_flags_table[0].name,
length - strlen(buffer) - 1);
}
}
}
return (buffer);
}
static conv_table_t pipe_state_table[] = {
{ USB_PIPE_STATE_CLOSED, "<closed>" },
{ USB_PIPE_STATE_IDLE, "<idle>" },
{ USB_PIPE_STATE_ACTIVE, "<active>" },
{ USB_PIPE_STATE_ERROR, "<error>" },
{ USB_PIPE_STATE_CLOSING, "<closing>" },
{ 0, NULL }
};
const char *
usb_str_pipe_state(usb_pipe_state_t state)
{
return (usba_get_name(pipe_state_table, state));
}
static conv_table_t dev_state[] = {
{ USB_DEV_ONLINE, "<online>" },
{ USB_DEV_DISCONNECTED, "<disconnected>" },
{ USB_DEV_SUSPENDED, "<suspended>" },
{ USB_DEV_PWRED_DOWN, "<powered down>" },
{ 0, NULL }
};
const char *
usb_str_dev_state(int state)
{
return (usba_get_name(dev_state, state));
}
static conv_table_t rval_table[] = {
{ USB_SUCCESS, "<success>" },
{ USB_FAILURE, "<failure>" },
{ USB_NO_RESOURCES, "<no resources>" },
{ USB_NO_BANDWIDTH, "<no bandwidth>" },
{ USB_NOT_SUPPORTED, "<not supported>" },
{ USB_PIPE_ERROR, "<pipe error>" },
{ USB_INVALID_PIPE, "<invalid pipe>" },
{ USB_NO_FRAME_NUMBER, "<no frame number>" },
{ USB_INVALID_START_FRAME, "<invalid frame>" },
{ USB_HC_HARDWARE_ERROR, "<hw error>" },
{ USB_INVALID_REQUEST, "<invalid request>" },
{ USB_INVALID_CONTEXT, "<invalid context>" },
{ USB_INVALID_VERSION, "<invalid version>" },
{ USB_INVALID_ARGS, "<invalid args>" },
{ USB_INVALID_PERM, "<invalid perms>" },
{ USB_BUSY, "<busy>" },
{ 0, NULL }
};
const char *
usb_str_rval(int rval)
{
return (usba_get_name(rval_table, rval));
}
/*
* function to convert USB return values to close errno
*/
static struct usb_rval2errno_entry {
int rval;
int Errno;
} usb_rval2errno_table[] = {
{ USB_SUCCESS, 0 },
{ USB_FAILURE, EIO },
{ USB_NO_RESOURCES, ENOMEM },
{ USB_NO_BANDWIDTH, EAGAIN },
{ USB_NOT_SUPPORTED, ENOTSUP },
{ USB_PIPE_ERROR, EIO },
{ USB_INVALID_PIPE, EINVAL },
{ USB_NO_FRAME_NUMBER, EINVAL },
{ USB_INVALID_START_FRAME, EINVAL },
{ USB_HC_HARDWARE_ERROR, EIO },
{ USB_INVALID_REQUEST, EINVAL },
{ USB_INVALID_CONTEXT, EINVAL },
{ USB_INVALID_VERSION, EINVAL },
{ USB_INVALID_ARGS, EINVAL },
{ USB_INVALID_PERM, EACCES },
{ USB_BUSY, EBUSY },
};
#define USB_RVAL2ERRNO_TABLE_SIZE (sizeof (usb_rval2errno_table) / \
sizeof (struct usb_rval2errno_entry))
int
usb_rval2errno(int rval)
{
int i;
for (i = 0; i < USB_RVAL2ERRNO_TABLE_SIZE; i++) {
if (usb_rval2errno_table[i].rval == rval) {
return (usb_rval2errno_table[i].Errno);
}
}
return (EIO);
}
/*
* serialization
*/
usb_serialization_t
usb_init_serialization(
dev_info_t *dip,
uint_t flag)
{
usba_serialization_impl_t *impl_tokenp = kmem_zalloc(
sizeof (usba_serialization_impl_t), KM_SLEEP);
usba_device_t *usba_device;
ddi_iblock_cookie_t cookie = NULL;
if (dip) {
usba_device = usba_get_usba_device(dip);
cookie = usba_hcdi_get_hcdi(
usba_device->usb_root_hub_dip)->hcdi_iblock_cookie;
}
impl_tokenp->s_dip = dip;
impl_tokenp->s_flag = flag;
mutex_init(&impl_tokenp->s_mutex, NULL, MUTEX_DRIVER, cookie);
cv_init(&impl_tokenp->s_cv, NULL, CV_DRIVER, NULL);
return ((usb_serialization_t)impl_tokenp);
}
void
usb_fini_serialization(
usb_serialization_t tokenp)
{
usba_serialization_impl_t *impl_tokenp;
if (tokenp) {
impl_tokenp = (usba_serialization_impl_t *)tokenp;
ASSERT(impl_tokenp->s_count == 0);
cv_destroy(&impl_tokenp->s_cv);
mutex_destroy(&impl_tokenp->s_mutex);
kmem_free(impl_tokenp, sizeof (usba_serialization_impl_t));
}
}
/*
* usb_serialize_access() permits single threaded access.
*
* If tokenp is initialized with USB_INIT_SER_CHECK_SAME_THREAD,
* it is reentrant with respect to thread. The thread must
* hold and release the same number of times.
*
* If tokenp is initialized without USB_INIT_SER_CHECK_SAME_THREAD,
* it is not reentrant by the same thread. It is something like
* a semaphore.
*/
int
usb_serialize_access(
usb_serialization_t tokenp, uint_t how_to_wait, uint_t delta_timeout)
{
int rval = 1; /* Must be initialized > 0 */
clock_t abs_timeout = 0;
usba_serialization_impl_t *impl_tokenp;
impl_tokenp = (usba_serialization_impl_t *)tokenp;
/*
* Convert delta timeout in ms to absolute timeout in ticks, if used.
*/
if ((how_to_wait == USB_TIMEDWAIT) ||
(how_to_wait == USB_TIMEDWAIT_SIG)) {
/* Convert timeout arg (in ms) to hz */
abs_timeout = ddi_get_lbolt() +
drv_usectohz(delta_timeout * 1000);
}
/* Get mutex after calc abs time, to count time waiting for mutex. */
mutex_enter(&impl_tokenp->s_mutex);
USB_DPRINTF_L4(DPRINT_MASK_USBA, usbai_log_handle,
"usb_serialize_access: tok=0x%p dip=0x%p cnt=%d thr=0x%p, "
"flg=0x%x, abs_tmo=0x%lx",
(void *)impl_tokenp, (void *)impl_tokenp->s_dip,
impl_tokenp->s_count, (void *)impl_tokenp->s_thread,
how_to_wait, abs_timeout);
if ((impl_tokenp->s_flag & USB_INIT_SER_CHECK_SAME_THREAD) == 0 ||
impl_tokenp->s_thread != curthread) {
/*
* There are three ways to break out of the loop:
* 1) Condition met (s_count == 0) - higher prio test
* 2) kill(2) signal received (rval == 0)
* 3) timeout occurred (rval == -1)
* If condition met, whether or not signal or timeout occurred
* take access. If condition not met, check other exit means.
*/
while (impl_tokenp->s_count != 0) {
/* cv_timedwait* returns -1 on timeout. */
/* cv_wait*_sig returns 0 on (kill(2)) signal. */
if (rval <= 0) {
mutex_exit(&impl_tokenp->s_mutex);
USB_DPRINTF_L4(DPRINT_MASK_USBA,
usbai_log_handle,
"usb_serialize_access: "
"tok=0x%p exit due to %s",
(void *)impl_tokenp,
((rval == 0) ? "signal" : "timeout"));
return (rval);
}
switch (how_to_wait) {
default:
how_to_wait = USB_WAIT;
/* FALLTHROUGH */
case USB_WAIT:
cv_wait(&impl_tokenp->s_cv,
&impl_tokenp->s_mutex);
break;
case USB_WAIT_SIG:
rval = cv_wait_sig(&impl_tokenp->s_cv,
&impl_tokenp->s_mutex);
break;
case USB_TIMEDWAIT:
rval = cv_timedwait(&impl_tokenp->s_cv,
&impl_tokenp->s_mutex, abs_timeout);
break;
case USB_TIMEDWAIT_SIG:
rval = cv_timedwait_sig(&impl_tokenp->s_cv,
&impl_tokenp->s_mutex, abs_timeout);
break;
}
}
impl_tokenp->s_thread = curthread;
}
impl_tokenp->s_count++;
ASSERT(!(impl_tokenp->s_count > 1 &&
(impl_tokenp->s_flag & USB_INIT_SER_CHECK_SAME_THREAD) == 0));
mutex_exit(&impl_tokenp->s_mutex);
USB_DPRINTF_L4(DPRINT_MASK_USBA, usbai_log_handle,
"usb_serialize_access exit: tok=0x%p thr=0x%p", (void *)impl_tokenp,
(void *)curthread);
return (1);
}
/*ARGSUSED*/
int
usb_try_serialize_access(
usb_serialization_t tokenp, uint_t flag)
{
usba_serialization_impl_t *impl_tokenp =
(usba_serialization_impl_t *)tokenp;
mutex_enter(&impl_tokenp->s_mutex);
USB_DPRINTF_L4(DPRINT_MASK_USBA, usbai_log_handle,
"usb_try_serialize_access: tok=0x%p dip=0x%p cnt=%d thr=0x%p",
(void *)impl_tokenp, (void *)impl_tokenp->s_dip,
impl_tokenp->s_count, (void *)curthread);
/*
* If lock is not taken (s_count is 0), take it.
* If lock is already taken, the thread is owner and lock
* is reentrant, take it.
* Otherwise, fail the access.
*/
if (!impl_tokenp->s_count || ((impl_tokenp->s_thread == curthread) &&
(impl_tokenp->s_flag & USB_INIT_SER_CHECK_SAME_THREAD))) {
impl_tokenp->s_thread = curthread;
impl_tokenp->s_count++;
USB_DPRINTF_L4(DPRINT_MASK_USBA, usbai_log_handle,
"usb_try_serialize_access success: tok=0x%p",
(void *)impl_tokenp);
mutex_exit(&impl_tokenp->s_mutex);
return (USB_SUCCESS);
}
USB_DPRINTF_L4(DPRINT_MASK_USBA, usbai_log_handle,
"usb_try_serialize_access failed: "
"tok=0x%p dip=0x%p cnt=%d thr=0x%p",
(void *)impl_tokenp, (void *)impl_tokenp->s_dip,
impl_tokenp->s_count, (void *)impl_tokenp->s_thread);
mutex_exit(&impl_tokenp->s_mutex);
return (USB_FAILURE);
}
void
usb_release_access(
usb_serialization_t tokenp)
{
usba_serialization_impl_t *impl_tokenp =
(usba_serialization_impl_t *)tokenp;
mutex_enter(&impl_tokenp->s_mutex);
USB_DPRINTF_L4(DPRINT_MASK_USBA, usbai_log_handle,
"usb_release_access: tok=0x%p dip=0x%p count=%d thr=0x%p",
(void *)impl_tokenp, (void *)impl_tokenp->s_dip,
impl_tokenp->s_count, (void *)curthread);
ASSERT(impl_tokenp->s_count > 0);
if (impl_tokenp->s_flag & USB_INIT_SER_CHECK_SAME_THREAD) {
if (impl_tokenp->s_thread != curthread) {
USB_DPRINTF_L2(DPRINT_MASK_USBA, usbai_log_handle,
"usb_release_access: release from wrong thread");
}
ASSERT(impl_tokenp->s_thread == curthread);
}
if (--impl_tokenp->s_count == 0) {
impl_tokenp->s_thread = NULL;
cv_broadcast(&impl_tokenp->s_cv);
}
mutex_exit(&impl_tokenp->s_mutex);
}
/*
* usb_fail_checkpoint:
* fail checkpoint as driver/device could not be quiesced
*/
/*ARGSUSED*/
void
usb_fail_checkpoint(dev_info_t *dip, usb_flags_t flags)
{
usba_device_t *usba_device = usba_get_usba_device(dip);
USB_DPRINTF_L2(DPRINT_MASK_USBA, usbai_log_handle,
"usb_fail_checkpoint: %s%d", ddi_driver_name(dip),
ddi_get_instance(dip));
mutex_enter(&usba_device->usb_mutex);
usba_device->usb_no_cpr++;
mutex_exit(&usba_device->usb_mutex);
}
_NOTE(SCHEME_PROTECTS_DATA("unique per call", iocblk))
_NOTE(SCHEME_PROTECTS_DATA("unique per call", datab))
/*
* usba_mk_mctl:
* create a USB style M_CTL message, given an iocblk and a buffer
* returns mblk_t * on success, NULL on failure
*/
mblk_t *
usba_mk_mctl(struct iocblk mctlmsg, void *buf, size_t len)
{
mblk_t *bp1, *bp2;
if ((bp1 = allocb(sizeof (struct iocblk), BPRI_HI)) != NULL) {
/* LINTED E_BAD_PTR_CAST_ALIGN */
*((struct iocblk *)bp1->b_datap->db_base) = mctlmsg;
bp1->b_datap->db_type = M_CTL;
bp1->b_wptr += sizeof (struct iocblk);
if (buf != NULL) {
if ((bp2 = allocb(len, BPRI_HI)) != NULL) {
bp1->b_cont = bp2;
bcopy(buf, bp2->b_datap->db_base, len);
bp2->b_wptr += len;
} else {
freemsg(bp1);
bp1 = NULL;
}
}
}
return (bp1);
}
#ifdef ALLOCB_TEST
#undef allocb
mblk_t *
usba_test_allocb(size_t size, uint_t pri)
{
if (ddi_get_lbolt() & 0x1) {
return (NULL);
} else {
return (allocb(size, pri));
}
}
#endif
/*
* usb common power management for usb_mid, usb_ia and maybe other simple
* drivers.
*/
/*
* functions to handle power transition for OS levels 0 -> 3
*/
static int
usb_common_pwrlvl0(dev_info_t *dip, uint8_t *pm, int *dev_state)
{
int rval;
switch (*dev_state) {
case USB_DEV_ONLINE:
/* Issue USB D3 command to the device here */
rval = usb_set_device_pwrlvl3(dip);
ASSERT(rval == USB_SUCCESS);
*dev_state = USB_DEV_PWRED_DOWN;
*pm = USB_DEV_OS_PWR_OFF;
/* 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
usb_common_pwrlvl1(dev_info_t *dip, uint8_t *pm, int *dev_state)
{
int rval;
/* Issue USB D2 command to the device here */
rval = usb_set_device_pwrlvl2(dip);
ASSERT(rval == USB_SUCCESS);
return (USB_FAILURE);
}
/* ARGSUSED */
static int
usb_common_pwrlvl2(dev_info_t *dip, uint8_t *pm, int *dev_state)
{
int rval;
/* Issue USB D1 command to the device here */
rval = usb_set_device_pwrlvl1(dip);
ASSERT(rval == USB_SUCCESS);
return (USB_FAILURE);
}
static int
usb_common_pwrlvl3(dev_info_t *dip, uint8_t *pm, int *dev_state)
{
int rval;
switch (*dev_state) {
case USB_DEV_PWRED_DOWN:
/* Issue USB D0 command to the device here */
rval = usb_set_device_pwrlvl0(dip);
ASSERT(rval == USB_SUCCESS);
*dev_state = USB_DEV_ONLINE;
*pm = USB_DEV_OS_FULL_PWR;
/* 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_DPRINTF_L2(DPRINT_MASK_USBA, usbai_log_handle,
"usb_common_pwrlvl3: Illegal state (%s)",
usb_str_dev_state(*dev_state));
return (USB_FAILURE);
}
}
/* power management */
int
usba_common_power(dev_info_t *dip, uint8_t *pm, int *dev_state, int level)
{
int rval = DDI_FAILURE;
switch (level) {
case USB_DEV_OS_PWR_OFF:
rval = usb_common_pwrlvl0(dip, pm, dev_state);
break;
case USB_DEV_OS_PWR_1:
rval = usb_common_pwrlvl1(dip, pm, dev_state);
break;
case USB_DEV_OS_PWR_2:
rval = usb_common_pwrlvl2(dip, pm, dev_state);
break;
case USB_DEV_OS_FULL_PWR:
rval = usb_common_pwrlvl3(dip, pm, dev_state);
break;
}
return ((rval == USB_SUCCESS) ? DDI_SUCCESS : DDI_FAILURE);
}
/*
* register and unregister for events from our parent for usb_mid and usb_ia
* and maybe other nexus driver.
*
* Note: The cookie fields in usba_device structure is not used. They are
* used/shared by children.
*/
void
usba_common_register_events(dev_info_t *dip, uint_t if_num,
void (*event_cb)(dev_info_t *, ddi_eventcookie_t, void *, void *))
{
int rval;
usba_evdata_t *evdata;
ddi_eventcookie_t cookie;
USB_DPRINTF_L4(DPRINT_MASK_USBA, usbai_log_handle,
"usb_common_register_events:");
evdata = usba_get_evdata(dip);
/* get event cookie, discard level and icookie for now */
rval = ddi_get_eventcookie(dip, DDI_DEVI_REMOVE_EVENT,
&cookie);
if (rval == DDI_SUCCESS) {
rval = ddi_add_event_handler(dip,
cookie, event_cb, NULL, &evdata->ev_rm_cb_id);
if (rval != DDI_SUCCESS) {
goto fail;
}
}
rval = ddi_get_eventcookie(dip, DDI_DEVI_INSERT_EVENT,
&cookie);
if (rval == DDI_SUCCESS) {
rval = ddi_add_event_handler(dip, cookie, event_cb,
NULL, &evdata->ev_ins_cb_id);
if (rval != DDI_SUCCESS) {
goto fail;
}
}
rval = ddi_get_eventcookie(dip, USBA_PRE_SUSPEND_EVENT, &cookie);
if (rval == DDI_SUCCESS) {
rval = ddi_add_event_handler(dip,
cookie, event_cb, NULL, &evdata->ev_suspend_cb_id);
if (rval != DDI_SUCCESS) {
goto fail;
}
}
rval = ddi_get_eventcookie(dip, USBA_POST_RESUME_EVENT, &cookie);
if (rval == DDI_SUCCESS) {
rval = ddi_add_event_handler(dip, cookie, event_cb, NULL,
&evdata->ev_resume_cb_id);
if (rval != DDI_SUCCESS) {
goto fail;
}
}
return;
fail:
usba_common_unregister_events(dip, if_num);
}
void
usba_common_unregister_events(dev_info_t *dip, uint_t if_num)
{
usba_evdata_t *evdata;
usba_device_t *usba_device = usba_get_usba_device(dip);
int i;
evdata = usba_get_evdata(dip);
if (evdata->ev_rm_cb_id != NULL) {
(void) ddi_remove_event_handler(evdata->ev_rm_cb_id);
evdata->ev_rm_cb_id = NULL;
}
if (evdata->ev_ins_cb_id != NULL) {
(void) ddi_remove_event_handler(evdata->ev_ins_cb_id);
evdata->ev_ins_cb_id = NULL;
}
if (evdata->ev_suspend_cb_id != NULL) {
(void) ddi_remove_event_handler(evdata->ev_suspend_cb_id);
evdata->ev_suspend_cb_id = NULL;
}
if (evdata->ev_resume_cb_id != NULL) {
(void) ddi_remove_event_handler(evdata->ev_resume_cb_id);
evdata->ev_resume_cb_id = NULL;
}
/* clear event data for children, required for cfgmadm unconfigure */
mutex_enter(&usba_device->usb_mutex);
if (usb_owns_device(dip)) {
usba_free_evdata(usba_device->usb_evdata);
usba_device->usb_evdata = NULL;
usba_device->rm_cookie = NULL;
usba_device->ins_cookie = NULL;
usba_device->suspend_cookie = NULL;
usba_device->resume_cookie = NULL;
} else {
for (i = 0; i < if_num; i++) {
usba_device->usb_client_flags[usba_get_ifno(dip) + i]
&= ~USBA_CLIENT_FLAG_EV_CBS;
}
}
mutex_exit(&usba_device->usb_mutex);
}