e9738dbe2b
The USB bulk and control transfer functions in libpayload currently always return 0 for success and 1 for all errors. This is sufficient for current use cases (essentially just mass storage), but other classes (like certain Ethernet adapters) need to be able to tell if a transfer reached the intended amount of bytes, or if it fell short. This patch slightly changes that USB API to return -1 on errors, and the amount of transferred bytes on successes. All drivers in the current libpayload mainline are modified to conform to the new error detection model. Any third party users of this API will need to adapt their if (...<controller>->bulk/control(...)) checks to if (...<controller>->bulk/control(...) < 0) as well. The host controller drivers for OHCI and EHCI correctly implement the new behavior. UHCI and the XHCI stub just comply with the new API by returning 0 or -1, but do not actually count the returned bytes. Signed-off-by: Julius Werner <jwerner@chromium.org> Reviewed-on: https://gerrit.chromium.org/gerrit/48308 Reviewed-by: Gabe Black <gabeblack@chromium.org> Reviewed-by: Stefan Reinauer <reinauer@google.com> Tested-by: Gabe Black <gabeblack@chromium.org> Commit-Queue: Gabe Black <gabeblack@chromium.org> Updated the patch to support XHCI as well. Change-Id: Ic2ea2810c5edb992cbe185bc9711d2f8f557cae6 (cherry picked from commit e39e2d84762a3804653d950a228ed2269c651458) Signed-off-by: Isaac Christensen <isaac.christensen@se-eng.com> Reviewed-on: http://review.coreboot.org/6390 Tested-by: build bot (Jenkins) Reviewed-by: Ronald G. Minnich <rminnich@gmail.com> Reviewed-by: Patrick Georgi <patrick@georgi-clan.de>
579 lines
15 KiB
C
579 lines
15 KiB
C
/*
|
|
* This file is part of the libpayload project.
|
|
*
|
|
* Copyright (C) 2008-2010 coresystems GmbH
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
* 3. The name of the author may not be used to endorse or promote products
|
|
* derived from this software without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
* SUCH DAMAGE.
|
|
*/
|
|
|
|
//#define USB_DEBUG
|
|
|
|
#include <libpayload-config.h>
|
|
#include <usb/usb.h>
|
|
|
|
hci_t *usb_hcs = 0;
|
|
|
|
hci_t *
|
|
new_controller (void)
|
|
{
|
|
hci_t *controller = malloc (sizeof (hci_t));
|
|
|
|
if (controller) {
|
|
/* atomic */
|
|
controller->next = usb_hcs;
|
|
usb_hcs = controller;
|
|
/* atomic end */
|
|
}
|
|
|
|
return controller;
|
|
}
|
|
|
|
void
|
|
detach_controller (hci_t *controller)
|
|
{
|
|
if (controller == NULL)
|
|
return;
|
|
if (usb_hcs == controller) {
|
|
usb_hcs = controller->next;
|
|
} else {
|
|
hci_t *it = usb_hcs;
|
|
while (it != NULL) {
|
|
if (it->next == controller) {
|
|
it->next = controller->next;
|
|
return;
|
|
}
|
|
it = it->next;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Shut down all controllers
|
|
*/
|
|
int
|
|
usb_exit (void)
|
|
{
|
|
while (usb_hcs != NULL) {
|
|
usb_hcs->shutdown(usb_hcs);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Polls all hubs on all USB controllers, to find out about device changes
|
|
*/
|
|
void
|
|
usb_poll (void)
|
|
{
|
|
if (usb_hcs == 0)
|
|
return;
|
|
hci_t *controller = usb_hcs;
|
|
while (controller != NULL) {
|
|
int i;
|
|
for (i = 0; i < 128; i++) {
|
|
if (controller->devices[i] != 0) {
|
|
controller->devices[i]->poll (controller->devices[i]);
|
|
}
|
|
}
|
|
controller = controller->next;
|
|
}
|
|
}
|
|
|
|
void
|
|
init_device_entry (hci_t *controller, int i)
|
|
{
|
|
if (controller->devices[i] != 0)
|
|
usb_debug("warning: device %d reassigned?\n", i);
|
|
controller->devices[i] = malloc(sizeof(usbdev_t));
|
|
controller->devices[i]->controller = controller;
|
|
controller->devices[i]->address = -1;
|
|
controller->devices[i]->hub = -1;
|
|
controller->devices[i]->port = -1;
|
|
controller->devices[i]->init = usb_nop_init;
|
|
controller->devices[i]->init (controller->devices[i]);
|
|
}
|
|
|
|
void
|
|
set_feature (usbdev_t *dev, int endp, int feature, int rtype)
|
|
{
|
|
dev_req_t dr;
|
|
|
|
dr.bmRequestType = rtype;
|
|
dr.data_dir = host_to_device;
|
|
dr.bRequest = SET_FEATURE;
|
|
dr.wValue = feature;
|
|
dr.wIndex = endp;
|
|
dr.wLength = 0;
|
|
dev->controller->control (dev, OUT, sizeof (dr), &dr, 0, 0);
|
|
}
|
|
|
|
void
|
|
get_status (usbdev_t *dev, int intf, int rtype, int len, void *data)
|
|
{
|
|
dev_req_t dr;
|
|
|
|
dr.bmRequestType = rtype;
|
|
dr.data_dir = device_to_host;
|
|
dr.bRequest = GET_STATUS;
|
|
dr.wValue = 0;
|
|
dr.wIndex = intf;
|
|
dr.wLength = len;
|
|
dev->controller->control (dev, IN, sizeof (dr), &dr, len, data);
|
|
}
|
|
|
|
u8 *
|
|
get_descriptor (usbdev_t *dev, unsigned char bmRequestType, int descType,
|
|
int descIdx, int langID)
|
|
{
|
|
u8 buf[8];
|
|
u8 *result;
|
|
dev_req_t dr;
|
|
int size;
|
|
|
|
dr.bmRequestType = bmRequestType;
|
|
dr.data_dir = device_to_host; // always like this for descriptors
|
|
dr.bRequest = GET_DESCRIPTOR;
|
|
dr.wValue = (descType << 8) | descIdx;
|
|
dr.wIndex = langID;
|
|
dr.wLength = 8;
|
|
if (dev->controller->control (dev, IN, sizeof (dr), &dr, 8, buf) < 0) {
|
|
usb_debug ("getting descriptor size (type %x) failed\n",
|
|
descType);
|
|
}
|
|
|
|
if (descType == 1) {
|
|
device_descriptor_t *dd = (device_descriptor_t *) buf;
|
|
usb_debug ("maxPacketSize0: %x\n", dd->bMaxPacketSize0);
|
|
if (dd->bMaxPacketSize0 != 0)
|
|
dev->endpoints[0].maxpacketsize = dd->bMaxPacketSize0;
|
|
}
|
|
|
|
/* special case for configuration descriptors: they carry all their
|
|
subsequent descriptors with them, and keep the entire size at a
|
|
different location */
|
|
size = buf[0];
|
|
if (buf[1] == 2) {
|
|
int realsize = ((unsigned short *) (buf + 2))[0];
|
|
size = realsize;
|
|
}
|
|
result = malloc (size);
|
|
memset (result, 0, size);
|
|
dr.wLength = size;
|
|
if (dev->controller->
|
|
control (dev, IN, sizeof (dr), &dr, size, result) < 0) {
|
|
usb_debug ("getting descriptor (type %x, size %x) failed\n",
|
|
descType, size);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
void
|
|
set_configuration (usbdev_t *dev)
|
|
{
|
|
dev_req_t dr;
|
|
|
|
dr.bmRequestType = 0;
|
|
dr.bRequest = SET_CONFIGURATION;
|
|
dr.wValue = dev->configuration[5];
|
|
dr.wIndex = 0;
|
|
dr.wLength = 0;
|
|
dev->controller->control (dev, OUT, sizeof (dr), &dr, 0, 0);
|
|
}
|
|
|
|
int
|
|
clear_feature (usbdev_t *dev, int endp, int feature, int rtype)
|
|
{
|
|
dev_req_t dr;
|
|
|
|
dr.bmRequestType = rtype;
|
|
dr.data_dir = host_to_device;
|
|
dr.bRequest = CLEAR_FEATURE;
|
|
dr.wValue = feature;
|
|
dr.wIndex = endp;
|
|
dr.wLength = 0;
|
|
return dev->controller->control (dev, OUT, sizeof (dr), &dr, 0, 0) < 0;
|
|
}
|
|
|
|
int
|
|
clear_stall (endpoint_t *ep)
|
|
{
|
|
usbdev_t *dev = ep->dev;
|
|
int endp = ep->endpoint;
|
|
int rtype = gen_bmRequestType (host_to_device, standard_type,
|
|
endp ? endp_recp : dev_recp);
|
|
|
|
int ret = clear_feature (dev, endp, ENDPOINT_HALT, rtype);
|
|
ep->toggle = 0;
|
|
return ret;
|
|
}
|
|
|
|
/* returns free address or -1 */
|
|
static int
|
|
get_free_address (hci_t *controller)
|
|
{
|
|
int i;
|
|
for (i = 1; i < 128; i++) {
|
|
if (controller->devices[i] == 0)
|
|
return i;
|
|
}
|
|
usb_debug ("no free address found\n");
|
|
return -1; // no free address
|
|
}
|
|
|
|
int
|
|
generic_set_address (hci_t *controller, int speed, int hubport, int hubaddr)
|
|
{
|
|
int adr = get_free_address (controller); // address to set
|
|
dev_req_t dr;
|
|
|
|
memset (&dr, 0, sizeof (dr));
|
|
dr.data_dir = host_to_device;
|
|
dr.req_type = standard_type;
|
|
dr.req_recp = dev_recp;
|
|
dr.bRequest = SET_ADDRESS;
|
|
dr.wValue = adr;
|
|
dr.wIndex = 0;
|
|
dr.wLength = 0;
|
|
|
|
init_device_entry(controller, adr);
|
|
usbdev_t *dev = controller->devices[adr];
|
|
// dummy values for registering the address
|
|
dev->address = 0;
|
|
dev->hub = hubaddr;
|
|
dev->port = hubport;
|
|
dev->speed = speed;
|
|
dev->endpoints[0].dev = dev;
|
|
dev->endpoints[0].endpoint = 0;
|
|
dev->endpoints[0].maxpacketsize = 8;
|
|
dev->endpoints[0].toggle = 0;
|
|
dev->endpoints[0].direction = SETUP;
|
|
mdelay (50);
|
|
if (dev->controller->control (dev, OUT, sizeof (dr), &dr, 0, 0) < 0) {
|
|
return -1;
|
|
}
|
|
mdelay (50);
|
|
|
|
return adr;
|
|
}
|
|
|
|
/* Normalize bInterval to log2 of microframes */
|
|
static int
|
|
usb_decode_interval(const int speed, const endpoint_type type, const unsigned char bInterval)
|
|
{
|
|
#define LOG2(a) ((sizeof(unsigned) << 3) - __builtin_clz(a) - 1)
|
|
switch (speed) {
|
|
case LOW_SPEED:
|
|
switch (type) {
|
|
case ISOCHRONOUS: case INTERRUPT:
|
|
return LOG2(bInterval) + 3;
|
|
default:
|
|
return 0;
|
|
}
|
|
case FULL_SPEED:
|
|
switch (type) {
|
|
case ISOCHRONOUS:
|
|
return (bInterval - 1) + 3;
|
|
case INTERRUPT:
|
|
return LOG2(bInterval) + 3;
|
|
default:
|
|
return 0;
|
|
}
|
|
case HIGH_SPEED:
|
|
switch (type) {
|
|
case ISOCHRONOUS: case INTERRUPT:
|
|
return bInterval - 1;
|
|
default:
|
|
return LOG2(bInterval);
|
|
}
|
|
case SUPER_SPEED:
|
|
switch (type) {
|
|
case ISOCHRONOUS: case INTERRUPT:
|
|
return bInterval - 1;
|
|
default:
|
|
return 0;
|
|
}
|
|
default:
|
|
return 0;
|
|
}
|
|
#undef LOG2
|
|
}
|
|
|
|
static int
|
|
set_address (hci_t *controller, int speed, int hubport, int hubaddr)
|
|
{
|
|
int adr = controller->set_address(controller, speed, hubport, hubaddr);
|
|
if (adr < 0 || !controller->devices[adr]) {
|
|
usb_debug ("set_address failed\n");
|
|
return -1;
|
|
}
|
|
configuration_descriptor_t *cd;
|
|
device_descriptor_t *dd;
|
|
|
|
usbdev_t *dev = controller->devices[adr];
|
|
dev->address = adr;
|
|
dev->hub = hubaddr;
|
|
dev->port = hubport;
|
|
dev->speed = speed;
|
|
dev->descriptor = get_descriptor (dev, gen_bmRequestType
|
|
(device_to_host, standard_type, dev_recp), 1, 0, 0);
|
|
dd = (device_descriptor_t *) dev->descriptor;
|
|
|
|
usb_debug ("* found device (0x%04x:0x%04x, USB %x.%x)",
|
|
dd->idVendor, dd->idProduct,
|
|
dd->bcdUSB >> 8, dd->bcdUSB & 0xff);
|
|
dev->quirks = usb_quirk_check(dd->idVendor, dd->idProduct);
|
|
|
|
usb_debug ("\ndevice has %x configurations\n", dd->bNumConfigurations);
|
|
if (dd->bNumConfigurations == 0) {
|
|
/* device isn't usable */
|
|
usb_debug ("... no usable configuration!\n");
|
|
dev->address = 0;
|
|
return -1;
|
|
}
|
|
|
|
dev->configuration = get_descriptor (dev, gen_bmRequestType
|
|
(device_to_host, standard_type, dev_recp), 2, 0, 0);
|
|
cd = (configuration_descriptor_t *) dev->configuration;
|
|
interface_descriptor_t *interface =
|
|
(interface_descriptor_t *) (((char *) cd) + cd->bLength);
|
|
{
|
|
int i;
|
|
int num = cd->bNumInterfaces;
|
|
interface_descriptor_t *current = interface;
|
|
usb_debug ("device has %x interfaces\n", num);
|
|
if (num > 1) {
|
|
int interfaces = usb_interface_check(dd->idVendor, dd->idProduct);
|
|
if (interfaces) {
|
|
/* Well known device, don't warn */
|
|
num = interfaces;
|
|
} else {
|
|
|
|
usb_debug ("\nNOTICE: This driver defaults to using the first interface.\n"
|
|
"This might be the wrong choice and lead to limited functionality\n"
|
|
"of the device. Please report such a case to coreboot@coreboot.org\n"
|
|
"as you might be the first.\n");
|
|
/* we limit to the first interface, as there was no need to
|
|
* implement something else for the time being. If you need
|
|
* it, see the SetInterface and GetInterface functions in
|
|
* the USB specification, and adapt appropriately.
|
|
*/
|
|
num = (num > 1) ? 1 : num;
|
|
}
|
|
}
|
|
for (i = 0; i < num; i++) {
|
|
int j;
|
|
usb_debug (" #%x has %x endpoints, interface %x:%x, protocol %x\n",
|
|
current->bInterfaceNumber, current->bNumEndpoints, current->bInterfaceClass, current->bInterfaceSubClass, current->bInterfaceProtocol);
|
|
endpoint_descriptor_t *endp =
|
|
(endpoint_descriptor_t *) (((char *) current)
|
|
+ current->bLength);
|
|
/* Skip any non-endpoint descriptor */
|
|
if (endp->bDescriptorType != 0x05)
|
|
endp = (endpoint_descriptor_t *)(((char *)endp) + ((char *)endp)[0]);
|
|
|
|
memset (dev->endpoints, 0, sizeof (dev->endpoints));
|
|
dev->num_endp = 1; // 0 always exists
|
|
dev->endpoints[0].dev = dev;
|
|
dev->endpoints[0].maxpacketsize = dd->bMaxPacketSize0;
|
|
dev->endpoints[0].direction = SETUP;
|
|
dev->endpoints[0].type = CONTROL;
|
|
dev->endpoints[0].interval = usb_decode_interval(dev->speed, CONTROL, endp->bInterval);
|
|
for (j = 1; j <= current->bNumEndpoints; j++) {
|
|
#ifdef USB_DEBUG
|
|
static const char *transfertypes[4] = {
|
|
"control", "isochronous", "bulk", "interrupt"
|
|
};
|
|
usb_debug (" #%x: Endpoint %x (%s), max packet size %x, type %s\n", j, endp->bEndpointAddress & 0x7f, ((endp->bEndpointAddress & 0x80) != 0) ? "in" : "out", endp->wMaxPacketSize, transfertypes[endp->bmAttributes]);
|
|
#endif
|
|
endpoint_t *ep =
|
|
&dev->endpoints[dev->num_endp++];
|
|
ep->dev = dev;
|
|
ep->endpoint = endp->bEndpointAddress;
|
|
ep->toggle = 0;
|
|
ep->maxpacketsize = endp->wMaxPacketSize;
|
|
ep->direction =
|
|
((endp->bEndpointAddress & 0x80) ==
|
|
0) ? OUT : IN;
|
|
ep->type = endp->bmAttributes;
|
|
ep->interval = usb_decode_interval(dev->speed, ep->type, endp->bInterval);
|
|
endp = (endpoint_descriptor_t
|
|
*) (((char *) endp) + endp->bLength);
|
|
}
|
|
current = (interface_descriptor_t *) endp;
|
|
}
|
|
}
|
|
|
|
if (controller->finish_device_config &&
|
|
controller->finish_device_config(dev))
|
|
return adr; /* Device isn't configured correctly,
|
|
only control transfers may work. */
|
|
|
|
set_configuration(dev);
|
|
|
|
int class = dd->bDeviceClass;
|
|
if (class == 0)
|
|
class = interface->bInterfaceClass;
|
|
|
|
enum {
|
|
audio_device = 0x01,
|
|
comm_device = 0x02,
|
|
hid_device = 0x03,
|
|
physical_device = 0x05,
|
|
imaging_device = 0x06,
|
|
printer_device = 0x07,
|
|
msc_device = 0x08,
|
|
hub_device = 0x09,
|
|
cdc_device = 0x0a,
|
|
ccid_device = 0x0b,
|
|
security_device = 0x0d,
|
|
video_device = 0x0e,
|
|
healthcare_device = 0x0f,
|
|
diagnostic_device = 0xdc,
|
|
wireless_device = 0xe0,
|
|
misc_device = 0xef,
|
|
};
|
|
usb_debug(", class: ");
|
|
switch (class) {
|
|
case audio_device:
|
|
usb_debug("audio\n");
|
|
break;
|
|
case comm_device:
|
|
usb_debug("communication\n");
|
|
break;
|
|
case hid_device:
|
|
usb_debug ("HID\n");
|
|
#ifdef CONFIG_LP_USB_HID
|
|
controller->devices[adr]->init = usb_hid_init;
|
|
return adr;
|
|
#else
|
|
usb_debug ("NOTICE: USB HID support not compiled in\n");
|
|
#endif
|
|
break;
|
|
case physical_device:
|
|
usb_debug("physical\n");
|
|
break;
|
|
case imaging_device:
|
|
usb_debug("camera\n");
|
|
break;
|
|
case printer_device:
|
|
usb_debug("printer\n");
|
|
break;
|
|
case msc_device:
|
|
usb_debug ("MSC\n");
|
|
#ifdef CONFIG_LP_USB_MSC
|
|
controller->devices[adr]->init = usb_msc_init;
|
|
return adr;
|
|
#else
|
|
usb_debug ("NOTICE: USB MSC support not compiled in\n");
|
|
#endif
|
|
break;
|
|
case hub_device:
|
|
usb_debug ("hub\n");
|
|
#ifdef CONFIG_LP_USB_HUB
|
|
controller->devices[adr]->init = usb_hub_init;
|
|
return adr;
|
|
#else
|
|
usb_debug ("NOTICE: USB hub support not compiled in.\n");
|
|
#endif
|
|
break;
|
|
case cdc_device:
|
|
usb_debug("CDC\n");
|
|
break;
|
|
case ccid_device:
|
|
usb_debug("smartcard / CCID\n");
|
|
break;
|
|
case security_device:
|
|
usb_debug("content security\n");
|
|
break;
|
|
case video_device:
|
|
usb_debug("video\n");
|
|
break;
|
|
case healthcare_device:
|
|
usb_debug("healthcare\n");
|
|
break;
|
|
case diagnostic_device:
|
|
usb_debug("diagnostic\n");
|
|
break;
|
|
case wireless_device:
|
|
usb_debug("wireless\n");
|
|
break;
|
|
default:
|
|
usb_debug("unsupported class %x\n", class);
|
|
break;
|
|
}
|
|
controller->devices[adr]->init = usb_generic_init;
|
|
return adr;
|
|
}
|
|
|
|
/*
|
|
* Should be called by the hub drivers whenever a physical detach occurs
|
|
* and can be called by usb class drivers if they are unsatisfied with a
|
|
* malfunctioning device.
|
|
*/
|
|
void
|
|
usb_detach_device(hci_t *controller, int devno)
|
|
{
|
|
/* check if device exists, as we may have
|
|
been called yet by the usb class driver */
|
|
if (controller->devices[devno]) {
|
|
controller->devices[devno]->destroy (controller->devices[devno]);
|
|
free(controller->devices[devno]);
|
|
controller->devices[devno] = NULL;
|
|
if (controller->destroy_device)
|
|
controller->destroy_device(controller, devno);
|
|
}
|
|
}
|
|
|
|
int
|
|
usb_attach_device(hci_t *controller, int hubaddress, int port, int speed)
|
|
{
|
|
static const char* speeds[] = { "full", "low", "high" };
|
|
usb_debug ("%sspeed device\n", (speed <= 2) ? speeds[speed] : "invalid value - no");
|
|
int newdev = set_address (controller, speed, port, hubaddress);
|
|
if (newdev == -1)
|
|
return -1;
|
|
usbdev_t *newdev_t = controller->devices[newdev];
|
|
// determine responsible driver - current done in set_address
|
|
newdev_t->init (newdev_t);
|
|
/* init() may have called usb_detach_device() yet, so check */
|
|
return controller->devices[newdev] ? newdev : -1;
|
|
}
|
|
|
|
static void
|
|
usb_generic_destroy (usbdev_t *dev)
|
|
{
|
|
if (usb_generic_remove)
|
|
usb_generic_remove(dev);
|
|
}
|
|
|
|
void
|
|
usb_generic_init (usbdev_t *dev)
|
|
{
|
|
dev->data = NULL;
|
|
dev->destroy = usb_generic_destroy;
|
|
|
|
if (usb_generic_create)
|
|
usb_generic_create(dev);
|
|
}
|