/*------------------------------------------------------------------------*
* usb_bus_resume
*
* This function is used to resume the USB controller.
*------------------------------------------------------------------------*/
static void
usb_bus_resume(struct usb_proc_msg *pm)
{
struct usb_bus *bus;
struct usb_device *udev;
usb_error_t err;
uint8_t do_unlock;
DPRINTF("\n");
bus = ((struct usb_bus_msg *)pm)->bus;
udev = bus->devices[USB_ROOT_HUB_ADDR];
if (udev == NULL || bus->bdev == NULL)
return;
USB_BUS_UNLOCK(bus);
do_unlock = usbd_enum_lock(udev);
#if 0
DEVMETHOD(usb_take_controller, NULL); /* dummy */
#endif
USB_TAKE_CONTROLLER(device_get_parent(bus->bdev));
USB_BUS_LOCK(bus);
bus->hw_power_state =
USB_HW_POWER_CONTROL |
USB_HW_POWER_BULK |
USB_HW_POWER_INTERRUPT |
USB_HW_POWER_ISOC |
USB_HW_POWER_NON_ROOT_HUB;
bus->no_explore = 0;
USB_BUS_UNLOCK(bus);
if (bus->methods->set_hw_power_sleep != NULL)
(bus->methods->set_hw_power_sleep) (bus, USB_HW_POWER_RESUME);
if (bus->methods->set_hw_power != NULL)
(bus->methods->set_hw_power) (bus);
/* restore USB configuration to index 0 */
err = usbd_set_config_index(udev, 0);
if (err)
device_printf(bus->bdev, "Could not configure root HUB\n");
/* probe and attach */
err = usb_probe_and_attach(udev, USB_IFACE_INDEX_ANY);
if (err) {
device_printf(bus->bdev, "Could not probe and "
"attach root HUB\n");
}
if (do_unlock)
usbd_enum_unlock(udev);
USB_BUS_LOCK(bus);
}
/*------------------------------------------------------------------------*
* usb_bus_suspend
*
* This function is used to suspend the USB controller.
*------------------------------------------------------------------------*/
static void
usb_bus_suspend(struct usb_proc_msg *pm)
{
struct usb_bus *bus;
struct usb_device *udev;
usb_error_t err;
uint8_t do_unlock;
DPRINTF("\n");
bus = ((struct usb_bus_msg *)pm)->bus;
udev = bus->devices[USB_ROOT_HUB_ADDR];
if (udev == NULL || bus->bdev == NULL)
return;
USB_BUS_UNLOCK(bus);
/*
* We use the shutdown event here because the suspend and
* resume events are reserved for the USB port suspend and
* resume. The USB system suspend is implemented like full
* shutdown and all connected USB devices will be disconnected
* subsequently. At resume all USB devices will be
* re-connected again.
*/
bus_generic_shutdown(bus->bdev);
do_unlock = usbd_enum_lock(udev);
err = usbd_set_config_index(udev, USB_UNCONFIG_INDEX);
if (err)
device_printf(bus->bdev, "Could not unconfigure root HUB\n");
USB_BUS_LOCK(bus);
bus->hw_power_state = 0;
bus->no_explore = 1;
USB_BUS_UNLOCK(bus);
if (bus->methods->set_hw_power != NULL)
(bus->methods->set_hw_power) (bus);
if (bus->methods->set_hw_power_sleep != NULL)
(bus->methods->set_hw_power_sleep) (bus, USB_HW_POWER_SUSPEND);
if (do_unlock)
usbd_enum_unlock(udev);
USB_BUS_LOCK(bus);
}
static usb_error_t
usb_check_alt_setting(struct usb_device *udev,
struct usb_interface *iface, uint8_t alt_index)
{
uint8_t do_unlock;
usb_error_t err = 0;
/* Prevent re-enumeration */
do_unlock = usbd_enum_lock(udev);
if (alt_index >= usbd_get_no_alts(udev->cdesc, iface->idesc))
err = USB_ERR_INVAL;
if (do_unlock)
usbd_enum_unlock(udev);
return (err);
}
/*------------------------------------------------------------------------*
* usb_handle_set_config
*
* Returns:
* 0: Success
* Else: Failure
*------------------------------------------------------------------------*/
static usb_error_t
usb_handle_set_config(struct usb_xfer *xfer, uint8_t conf_no)
{
struct usb_device *udev = xfer->xroot->udev;
usb_error_t err = 0;
uint8_t do_unlock;
/*
* We need to protect against other threads doing probe and
* attach:
*/
USB_XFER_UNLOCK(xfer);
/* Prevent re-enumeration */
do_unlock = usbd_enum_lock(udev);
if (conf_no == USB_UNCONFIG_NO) {
conf_no = USB_UNCONFIG_INDEX;
} else {
/*
* The relationship between config number and config index
* is very simple in our case:
*/
conf_no--;
}
if (usbd_set_config_index(udev, conf_no)) {
DPRINTF("set config %d failed\n", conf_no);
err = USB_ERR_STALLED;
goto done;
}
if (usb_probe_and_attach(udev, USB_IFACE_INDEX_ANY)) {
DPRINTF("probe and attach failed\n");
err = USB_ERR_STALLED;
goto done;
}
done:
if (do_unlock)
usbd_enum_unlock(udev);
USB_XFER_LOCK(xfer);
return (err);
}
/*------------------------------------------------------------------------*
* usb_bus_shutdown
*
* This function is used to shutdown the USB controller.
*------------------------------------------------------------------------*/
static void
usb_bus_shutdown(struct usb_proc_msg *pm)
{
struct usb_bus *bus;
struct usb_device *udev;
usb_error_t err;
uint8_t do_unlock;
bus = ((struct usb_bus_msg *)pm)->bus;
udev = bus->devices[USB_ROOT_HUB_ADDR];
if (udev == NULL || bus->bdev == NULL)
return;
USB_BUS_UNLOCK(bus);
bus_generic_shutdown(bus->bdev);
do_unlock = usbd_enum_lock(udev);
err = usbd_set_config_index(udev, USB_UNCONFIG_INDEX);
if (err)
device_printf(bus->bdev, "Could not unconfigure root HUB\n");
USB_BUS_LOCK(bus);
bus->hw_power_state = 0;
bus->no_explore = 1;
USB_BUS_UNLOCK(bus);
if (bus->methods->set_hw_power != NULL)
(bus->methods->set_hw_power) (bus);
if (bus->methods->set_hw_power_sleep != NULL)
(bus->methods->set_hw_power_sleep) (bus, USB_HW_POWER_SHUTDOWN);
if (do_unlock)
usbd_enum_unlock(udev);
USB_BUS_LOCK(bus);
}
static usb_error_t
usb_check_alt_setting(struct usb_device *udev,
struct usb_interface *iface, uint8_t alt_index)
{
uint8_t do_unlock;
usb_error_t err = 0;
/* automatic locking */
if (usbd_enum_is_locked(udev)) {
do_unlock = 0;
} else {
do_unlock = 1;
usbd_enum_lock(udev);
}
if (alt_index >= usbd_get_no_alts(udev->cdesc, iface->idesc))
err = USB_ERR_INVAL;
if (do_unlock)
usbd_enum_unlock(udev);
return (err);
}
/*------------------------------------------------------------------------*
* usb_handle_iface_request
*
* Returns:
* 0: Success
* Else: Failure
*------------------------------------------------------------------------*/
static usb_error_t
usb_handle_iface_request(struct usb_xfer *xfer,
void **ppdata, uint16_t *plen,
struct usb_device_request req, uint16_t off, uint8_t state)
{
struct usb_interface *iface;
struct usb_interface *iface_parent; /* parent interface */
struct usb_device *udev = xfer->xroot->udev;
int error;
uint8_t iface_index;
uint8_t temp_state;
if ((req.bmRequestType & 0x1F) == UT_INTERFACE) {
iface_index = req.wIndex[0]; /* unicast */
} else {
iface_index = 0; /* broadcast */
}
/*
* We need to protect against other threads doing probe and
* attach:
*/
USB_XFER_UNLOCK(xfer);
usbd_enum_lock(udev);
error = ENXIO;
tr_repeat:
iface = usbd_get_iface(udev, iface_index);
if ((iface == NULL) ||
(iface->idesc == NULL)) {
/* end of interfaces non-existing interface */
goto tr_stalled;
}
/* set initial state */
temp_state = state;
/* forward request to interface, if any */
if ((error != 0) &&
(error != ENOTTY) &&
(iface->subdev != NULL) &&
device_is_attached(iface->subdev)) {
#if 0
DEVMETHOD(usb_handle_request, NULL); /* dummy */
#endif
error = USB_HANDLE_REQUEST(iface->subdev,
&req, ppdata, plen,
off, &temp_state);
}
iface_parent = usbd_get_iface(udev, iface->parent_iface_index);
if ((iface_parent == NULL) ||
(iface_parent->idesc == NULL)) {
/* non-existing interface */
iface_parent = NULL;
}
/* forward request to parent interface, if any */
if ((error != 0) &&
(error != ENOTTY) &&
(iface_parent != NULL) &&
(iface_parent->subdev != NULL) &&
((req.bmRequestType & 0x1F) == UT_INTERFACE) &&
(iface_parent->subdev != iface->subdev) &&
device_is_attached(iface_parent->subdev)) {
error = USB_HANDLE_REQUEST(iface_parent->subdev,
&req, ppdata, plen, off, &temp_state);
}
if (error == 0) {
/* negativly adjust pointer and length */
*ppdata = ((uint8_t *)(*ppdata)) - off;
*plen += off;
if ((state == USB_HR_NOT_COMPLETE) &&
(temp_state == USB_HR_COMPLETE_OK))
goto tr_short;
else
goto tr_valid;
} else if (error == ENOTTY) {
goto tr_stalled;
}
if ((req.bmRequestType & 0x1F) != UT_INTERFACE) {
iface_index++; /* iterate */
goto tr_repeat;
}
if (state != USB_HR_NOT_COMPLETE) {
/* we are complete */
goto tr_valid;
}
switch (req.bmRequestType) {
case UT_WRITE_INTERFACE:
switch (req.bRequest) {
case UR_SET_INTERFACE:
/*
* We assume that the endpoints are the same
* accross the alternate settings.
*
* Reset the endpoints, because re-attaching
* only a part of the device is not possible.
*/
error = usb_check_alt_setting(udev,
iface, req.wValue[0]);
if (error) {
DPRINTF("alt setting does not exist %s\n",
usbd_errstr(error));
goto tr_stalled;
}
error = usb_reset_iface_endpoints(udev, iface_index);
if (error) {
DPRINTF("alt setting failed %s\n",
usbd_errstr(error));
goto tr_stalled;
}
/* update the current alternate setting */
iface->alt_index = req.wValue[0];
break;
default:
goto tr_stalled;
}
break;
case UT_READ_INTERFACE:
switch (req.bRequest) {
case UR_GET_INTERFACE:
*ppdata = &iface->alt_index;
*plen = 1;
break;
default:
goto tr_stalled;
}
break;
default:
goto tr_stalled;
}
tr_valid:
usbd_enum_unlock(udev);
USB_XFER_LOCK(xfer);
return (0);
tr_short:
usbd_enum_unlock(udev);
USB_XFER_LOCK(xfer);
return (USB_ERR_SHORT_XFER);
tr_stalled:
usbd_enum_unlock(udev);
USB_XFER_LOCK(xfer);
return (USB_ERR_STALLED);
}