#include <linux/ctype.h>
#include <asm/byteorder.h>
#include <asm/unaligned.h>
-#include <compiler.h>
#include <errno.h>
#include <usb.h>
#ifdef CONFIG_4xx
void *ctrl;
struct usb_device *dev;
int i, start_index = 0;
+ int controllers_initialized = 0;
int ret;
dev_index = 0;
ret = usb_lowlevel_init(i, USB_INIT_HOST, &ctrl);
if (ret == -ENODEV) { /* No such device. */
puts("Port not available.\n");
+ controllers_initialized++;
continue;
}
* lowlevel init is OK, now scan the bus for devices
* i.e. search HUBs and configure them
*/
+ controllers_initialized++;
start_index = dev_index;
printf("scanning bus %d for devices... ", i);
dev = usb_alloc_new_device(ctrl);
+ if (!dev)
+ break;
+
/*
* device 0 is always present
* (root hub, so let it analyze)
*/
- if (dev)
- usb_new_device(dev);
+ ret = usb_new_device(dev);
+ if (ret)
+ usb_free_device();
- if (start_index == dev_index)
+ if (start_index == dev_index) {
puts("No USB Device found\n");
- else
+ continue;
+ } else {
printf("%d USB Device(s) found\n",
dev_index - start_index);
+ }
usb_started = 1;
}
debug("scan end\n");
/* if we were not able to find at least one working bus, bail out */
- if (!usb_started) {
+ if (controllers_initialized == 0)
puts("USB error: all controllers failed lowlevel init\n");
- return -1;
- }
- return 0;
+ return usb_started ? 0 : -ENODEV;
}
/******************************************************************************
if ((timeout == 0) && (!asynch_allowed)) {
/* request for a asynch control pipe is not allowed */
- return -1;
+ return -EINVAL;
}
/* set setup command */
dev->status = USB_ST_NOT_PROC; /*not yet processed */
if (submit_control_msg(dev, pipe, data, size, setup_packet) < 0)
- return -1;
+ return -EIO;
if (timeout == 0)
return (int)size;
/*-------------------------------------------------------------------
* submits bulk message, and waits for completion. returns 0 if Ok or
- * -1 if Error.
+ * negative if Error.
* synchronous behavior
*/
int usb_bulk_msg(struct usb_device *dev, unsigned int pipe,
void *data, int len, int *actual_length, int timeout)
{
if (len < 0)
- return -1;
+ return -EINVAL;
dev->status = USB_ST_NOT_PROC; /*not yet processed */
if (submit_bulk_msg(dev, pipe, data, len) < 0)
- return -1;
+ return -EIO;
while (timeout--) {
if (!((volatile unsigned long)dev->status & USB_ST_NOT_PROC))
break;
if (dev->status == 0)
return 0;
else
- return -1;
+ return -EIO;
}
if (head->bDescriptorType != USB_DT_CONFIG) {
printf(" ERROR: NOT USB_CONFIG_DESC %x\n",
head->bDescriptorType);
- return -1;
+ return -EINVAL;
}
if (head->bLength != USB_DT_CONFIG_SIZE) {
printf("ERROR: Invalid USB CFG length (%d)\n", head->bLength);
- return -1;
+ return -EINVAL;
}
memcpy(&dev->config, head, USB_DT_CONFIG_SIZE);
dev->config.no_of_if = 0;
if (ifno >= USB_MAXINTERFACES) {
puts("Too many USB interfaces!\n");
/* try to go on with what we have */
- return 1;
+ return -EINVAL;
}
if_desc = &dev->config.if_desc[ifno];
dev->config.no_of_if++;
if (epno > USB_MAXENDPOINTS) {
printf("Interface %d has too many endpoints!\n",
if_desc->desc.bInterfaceNumber);
- return 1;
+ return -EINVAL;
}
/* found an endpoint */
if_desc->no_of_ep++;
break;
default:
if (head->bLength == 0)
- return 1;
+ return -EINVAL;
debug("unknown Description Type : %x\n",
head->bDescriptorType);
index += head->bLength;
head = (struct usb_descriptor_header *)&buffer[index];
}
- return 1;
+ return 0;
}
/***********************************************************************
else
printf("config descriptor too short " \
"(expected %i, got %i)\n", 9, result);
- return -1;
+ return -EIO;
}
length = le16_to_cpu(config->wTotalLength);
if (length > USB_BUFSIZ) {
printf("%s: failed to get descriptor - too long: %d\n",
__func__, length);
- return -1;
+ return -EIO;
}
result = usb_get_descriptor(dev, USB_DT_CONFIG, cfgno, buffer, length);
}
if (!if_face) {
printf("selecting invalid interface %d", interface);
- return -1;
+ return -EINVAL;
}
/*
* We should return now for devices with only one alternate setting.
dev->toggle[1] = 0;
return 0;
} else
- return -1;
+ return -EIO;
}
/********************************************************************
}
if (rc < 2)
- rc = -1;
+ rc = -EINVAL;
return rc;
}
unsigned int u, idx;
if (size <= 0 || !buf || !index)
- return -1;
+ return -EINVAL;
buf[0] = 0;
tbuf = &mybuf[0];
if (err < 0) {
debug("error getting string descriptor 0 " \
"(error=%lx)\n", dev->status);
- return -1;
+ return -EIO;
} else if (tbuf[0] < 4) {
debug("string descriptor 0 too short\n");
- return -1;
+ return -EIO;
} else {
dev->have_langid = -1;
dev->string_langid = tbuf[2] | (tbuf[3] << 8);
*/
if (usb_alloc_device(dev)) {
printf("Cannot allocate device context to get SLOT_ID\n");
- return -1;
+ return -EINVAL;
}
/* We still haven't set the Address yet */
if (err < 8) {
printf("\n USB device not responding, " \
"giving up (status=%lX)\n", dev->status);
- return 1;
+ return -EIO;
}
memcpy(&dev->descriptor, tmpbuf, 8);
#else
*/
#ifndef CONFIG_USB_XHCI
err = usb_get_descriptor(dev, USB_DT_DEVICE, 0, desc, 64);
- if (err < 0) {
+ /*
+ * Validate we've received only at least 8 bytes, not that we've
+ * received the entire descriptor. The reasoning is:
+ * - The code only uses fields in the first 8 bytes, so that's all we
+ * need to have fetched at this stage.
+ * - The smallest maxpacket size is 8 bytes. Before we know the actual
+ * maxpacket the device uses, the USB controller may only accept a
+ * single packet. Consequently we are only guaranteed to receive 1
+ * packet (at least 8 bytes) even in a non-error case.
+ *
+ * At least the DWC2 controller needs to be programmed with the number
+ * of packets in addition to the number of bytes. A request for 64
+ * bytes of data with the maxpacket guessed as 64 (above) yields a
+ * request for 1 packet.
+ */
+ if (err < 8) {
debug("usb_new_device: usb_get_descriptor() failed\n");
- return 1;
+ return -EIO;
}
dev->descriptor.bMaxPacketSize0 = desc->bMaxPacketSize0;
err = hub_port_reset(dev->parent, dev->portnr - 1, &portstatus);
if (err < 0) {
printf("\n Couldn't reset port %i\n", dev->portnr);
- return 1;
+ return -EIO;
}
+ } else {
+ usb_reset_root_port();
}
#endif
case 64:
dev->maxpacketsize = PACKET_SIZE_64;
break;
+ default:
+ printf("usb_new_device: invalid max packet size\n");
+ return -EIO;
}
dev->devnum = addr;
if (err < 0) {
printf("\n USB device not accepting new address " \
"(error=%lX)\n", dev->status);
- return 1;
+ return -EIO;
}
mdelay(10); /* Let the SET_ADDRESS settle */
else
printf("USB device descriptor short read " \
"(expected %i, got %i)\n", tmp, err);
- return 1;
+ return -EIO;
}
memcpy(&dev->descriptor, tmpbuf, sizeof(dev->descriptor));
/* correct le values */
printf("usb_new_device: Cannot read configuration, " \
"skipping device %04x:%04x\n",
dev->descriptor.idVendor, dev->descriptor.idProduct);
- return -1;
+ return -EIO;
}
usb_parse_config(dev, tmpbuf, 0);
usb_set_maxpacket(dev);
if (usb_set_configuration(dev, dev->config.desc.bConfigurationValue)) {
printf("failed to set default configuration " \
"len %d, status %lX\n", dev->act_len, dev->status);
- return -1;
+ return -EIO;
}
debug("new device strings: Mfr=%d, Product=%d, SerialNumber=%d\n",
dev->descriptor.iManufacturer, dev->descriptor.iProduct,
projects / people / ms / u-boot.git / blobdiff