Mirrors/u-boot
2
0
Fork 0
mirror of https://github.com/AsahiLinux/u-boot synced 2024-11-30 00:21:06 +00:00
Code Issues Projects Releases Packages Wiki Activity

Merge branch 'master' of git://git.denx.de/u-boot-usb

Browse source
This commit is contained in:
Wolfgang Denk 2008-12-05 00:24:32 +01:00
commit 26f6a2b7f3
12 changed files with 475 additions and 427 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

596
common/cmd_usb.c
View file

@ -36,178 +36,210 @@ static int usb_stor_curr_dev = -1; /* current device */
#endif #endif
/* some display routines (info command) */ /* some display routines (info command) */
char * usb_get_class_desc(unsigned char dclass) char *usb_get_class_desc(unsigned char dclass)
{ {
switch(dclass) { switch (dclass) {
case USB_CLASS_PER_INTERFACE: case USB_CLASS_PER_INTERFACE:
return("See Interface"); return "See Interface";
case USB_CLASS_AUDIO: case USB_CLASS_AUDIO:
return("Audio"); return "Audio";
case USB_CLASS_COMM: case USB_CLASS_COMM:
return("Communication"); return "Communication";
case USB_CLASS_HID: case USB_CLASS_HID:
return("Human Interface"); return "Human Interface";
case USB_CLASS_PRINTER: case USB_CLASS_PRINTER:
return("Printer"); return "Printer";
case USB_CLASS_MASS_STORAGE: case USB_CLASS_MASS_STORAGE:
return("Mass Storage"); return "Mass Storage";
case USB_CLASS_HUB: case USB_CLASS_HUB:
return("Hub"); return "Hub";
case USB_CLASS_DATA: case USB_CLASS_DATA:
return("CDC Data"); return "CDC Data";
case USB_CLASS_VENDOR_SPEC: case USB_CLASS_VENDOR_SPEC:
return("Vendor specific"); return "Vendor specific";
default : default:
return(""); return "";
} }
} }
void usb_display_class_sub(unsigned char dclass,unsigned char subclass,unsigned char proto) void usb_display_class_sub(unsigned char dclass, unsigned char subclass,
unsigned char proto)
{ {
switch(dclass) { switch (dclass) {
case USB_CLASS_PER_INTERFACE: case USB_CLASS_PER_INTERFACE:
printf("See Interface"); printf("See Interface");
break;
case USB_CLASS_HID:
printf("Human Interface, Subclass: ");
switch (subclass) {
case USB_SUB_HID_NONE:
printf("None");
break; break;
case USB_CLASS_HID: case USB_SUB_HID_BOOT:
printf("Human Interface, Subclass: "); printf("Boot ");
switch(subclass) { switch (proto) {
case USB_SUB_HID_NONE: case USB_PROT_HID_NONE:
printf("None"); printf("None");
break; break;
case USB_SUB_HID_BOOT: case USB_PROT_HID_KEYBOARD:
printf("Boot "); printf("Keyboard");
switch(proto) { break;
case USB_PROT_HID_NONE: case USB_PROT_HID_MOUSE:
printf("None"); printf("Mouse");
break; break;
case USB_PROT_HID_KEYBOARD: default:
printf("Keyboard"); printf("reserved");
break; break;
case USB_PROT_HID_MOUSE:
printf("Mouse");
break;
default:
printf("reserved");
}
break;
default:
printf("reserved");
}
break;
case USB_CLASS_MASS_STORAGE:
printf("Mass Storage, ");
switch(subclass) {
case US_SC_RBC:
printf("RBC ");
break;
case US_SC_8020:
printf("SFF-8020i (ATAPI)");
break;
case US_SC_QIC:
printf("QIC-157 (Tape)");
break;
case US_SC_UFI:
printf("UFI");
break;
case US_SC_8070:
printf("SFF-8070");
break;
case US_SC_SCSI:
printf("Transp. SCSI");
break;
default:
printf("reserved");
break;
}
printf(", ");
switch(proto) {
case US_PR_CB:
printf("Command/Bulk");
break;
case US_PR_CBI:
printf("Command/Bulk/Int");
break;
case US_PR_BULK:
printf("Bulk only");
break;
default:
printf("reserved");
} }
break; break;
default: default:
printf("%s",usb_get_class_desc(dclass)); printf("reserved");
break;
}
break;
case USB_CLASS_MASS_STORAGE:
printf("Mass Storage, ");
switch (subclass) {
case US_SC_RBC:
printf("RBC ");
break;
case US_SC_8020:
printf("SFF-8020i (ATAPI)");
break;
case US_SC_QIC:
printf("QIC-157 (Tape)");
break;
case US_SC_UFI:
printf("UFI");
break;
case US_SC_8070:
printf("SFF-8070");
break;
case US_SC_SCSI:
printf("Transp. SCSI");
break;
default:
printf("reserved");
break;
}
printf(", ");
switch (proto) {
case US_PR_CB:
printf("Command/Bulk");
break;
case US_PR_CBI:
printf("Command/Bulk/Int");
break;
case US_PR_BULK:
printf("Bulk only");
break;
default:
printf("reserved");
break;
}
break;
default:
printf("%s", usb_get_class_desc(dclass));
break;
} }
} }
void usb_display_string(struct usb_device *dev,int index) void usb_display_string(struct usb_device *dev, int index)
{ {
char buffer[256]; char buffer[256];
if (index!=0) { if (index != 0) {
if (usb_string(dev,index,&buffer[0],256)>0); if (usb_string(dev, index, &buffer[0], 256) > 0)
printf("String: \"%s\"",buffer); printf("String: \"%s\"", buffer);
} }
} }
void usb_display_desc(struct usb_device *dev) void usb_display_desc(struct usb_device *dev)
{ {
if (dev->descriptor.bDescriptorType==USB_DT_DEVICE) { if (dev->descriptor.bDescriptorType == USB_DT_DEVICE) {
printf("%d: %s, USB Revision %x.%x\n",dev->devnum,usb_get_class_desc(dev->config.if_desc[0].bInterfaceClass), printf("%d: %s, USB Revision %x.%x\n", dev->devnum,
(dev->descriptor.bcdUSB>>8) & 0xff,dev->descriptor.bcdUSB & 0xff); usb_get_class_desc(dev->config.if_desc[0].bInterfaceClass),
if (strlen(dev->mf) || strlen(dev->prod) || strlen(dev->serial)) (dev->descriptor.bcdUSB>>8) & 0xff,
printf(" - %s %s %s\n",dev->mf,dev->prod,dev->serial); dev->descriptor.bcdUSB & 0xff);
if (strlen(dev->mf) || strlen(dev->prod) ||
strlen(dev->serial))
printf(" - %s %s %s\n", dev->mf, dev->prod,
dev->serial);
if (dev->descriptor.bDeviceClass) { if (dev->descriptor.bDeviceClass) {
printf(" - Class: "); printf(" - Class: ");
usb_display_class_sub(dev->descriptor.bDeviceClass,dev->descriptor.bDeviceSubClass,dev->descriptor.bDeviceProtocol); usb_display_class_sub(dev->descriptor.bDeviceClass,
dev->descriptor.bDeviceSubClass,
dev->descriptor.bDeviceProtocol);
printf("\n"); printf("\n");
} else {
printf(" - Class: (from Interface) %s\n",
usb_get_class_desc(
dev->config.if_desc[0].bInterfaceClass));
} }
else { printf(" - PacketSize: %d Configurations: %d\n",
printf(" - Class: (from Interface) %s\n",usb_get_class_desc(dev->config.if_desc[0].bInterfaceClass)); dev->descriptor.bMaxPacketSize0,
} dev->descriptor.bNumConfigurations);
printf(" - PacketSize: %d Configurations: %d\n",dev->descriptor.bMaxPacketSize0,dev->descriptor.bNumConfigurations); printf(" - Vendor: 0x%04x Product 0x%04x Version %d.%d\n",
printf(" - Vendor: 0x%04x Product 0x%04x Version %d.%d\n",dev->descriptor.idVendor,dev->descriptor.idProduct,(dev->descriptor.bcdDevice>>8) & 0xff,dev->descriptor.bcdDevice & 0xff); dev->descriptor.idVendor, dev->descriptor.idProduct,
(dev->descriptor.bcdDevice>>8) & 0xff,
dev->descriptor.bcdDevice & 0xff);
} }
} }
void usb_display_conf_desc(struct usb_config_descriptor *config,struct usb_device *dev) void usb_display_conf_desc(struct usb_config_descriptor *config,
struct usb_device *dev)
{ {
printf(" Configuration: %d\n",config->bConfigurationValue); printf(" Configuration: %d\n", config->bConfigurationValue);
printf(" - Interfaces: %d %s%s%dmA\n",config->bNumInterfaces,(config->bmAttributes & 0x40) ? "Self Powered " : "Bus Powered ", printf(" - Interfaces: %d %s%s%dmA\n", config->bNumInterfaces,
(config->bmAttributes & 0x20) ? "Remote Wakeup " : "",config->MaxPower*2); (config->bmAttributes & 0x40) ? "Self Powered " : "Bus Powered ",
(config->bmAttributes & 0x20) ? "Remote Wakeup " : "",
config->MaxPower*2);
if (config->iConfiguration) { if (config->iConfiguration) {
printf(" - "); printf(" - ");
usb_display_string(dev,config->iConfiguration); usb_display_string(dev, config->iConfiguration);
printf("\n"); printf("\n");
} }
} }
void usb_display_if_desc(struct usb_interface_descriptor *ifdesc,struct usb_device *dev) void usb_display_if_desc(struct usb_interface_descriptor *ifdesc,
struct usb_device *dev)
{ {
printf(" Interface: %d\n",ifdesc->bInterfaceNumber); printf(" Interface: %d\n", ifdesc->bInterfaceNumber);
printf(" - Alternate Setting %d, Endpoints: %d\n",ifdesc->bAlternateSetting,ifdesc->bNumEndpoints); printf(" - Alternate Setting %d, Endpoints: %d\n",
ifdesc->bAlternateSetting, ifdesc->bNumEndpoints);
printf(" - Class "); printf(" - Class ");
usb_display_class_sub(ifdesc->bInterfaceClass,ifdesc->bInterfaceSubClass,ifdesc->bInterfaceProtocol); usb_display_class_sub(ifdesc->bInterfaceClass,
ifdesc->bInterfaceSubClass, ifdesc->bInterfaceProtocol);
printf("\n"); printf("\n");
if (ifdesc->iInterface) { if (ifdesc->iInterface) {
printf(" - "); printf(" - ");
usb_display_string(dev,ifdesc->iInterface); usb_display_string(dev, ifdesc->iInterface);
printf("\n"); printf("\n");
} }
} }
void usb_display_ep_desc(struct usb_endpoint_descriptor *epdesc) void usb_display_ep_desc(struct usb_endpoint_descriptor *epdesc)
{ {
printf(" - Endpoint %d %s ",epdesc->bEndpointAddress & 0xf,(epdesc->bEndpointAddress & 0x80) ? "In" : "Out"); printf(" - Endpoint %d %s ", epdesc->bEndpointAddress & 0xf,
switch((epdesc->bmAttributes & 0x03)) (epdesc->bEndpointAddress & 0x80) ? "In" : "Out");
{ switch ((epdesc->bmAttributes & 0x03)) {
case 0: printf("Control"); break; case 0:
case 1: printf("Isochronous"); break; printf("Control");
case 2: printf("Bulk"); break; break;
case 3: printf("Interrupt"); break; case 1:
printf("Isochronous");
break;
case 2:
printf("Bulk");
break;
case 3:
printf("Interrupt");
break;
} }
printf(" MaxPacket %d",epdesc->wMaxPacketSize); printf(" MaxPacket %d", epdesc->wMaxPacketSize);
if ((epdesc->bmAttributes & 0x03)==0x3) if ((epdesc->bmAttributes & 0x03) == 0x3)
printf(" Interval %dms",epdesc->bInterval); printf(" Interval %dms", epdesc->bInterval);
printf("\n"); printf("\n");
} }
@ -217,15 +249,15 @@ void usb_display_config(struct usb_device *dev)
struct usb_config_descriptor *config; struct usb_config_descriptor *config;
struct usb_interface_descriptor *ifdesc; struct usb_interface_descriptor *ifdesc;
struct usb_endpoint_descriptor *epdesc; struct usb_endpoint_descriptor *epdesc;
int i,ii; int i, ii;
config= &dev->config; config = &dev->config;
usb_display_conf_desc(config,dev); usb_display_conf_desc(config, dev);
for(i=0;i<config->no_of_if;i++) { for (i = 0; i < config->no_of_if; i++) {
ifdesc= &config->if_desc[i]; ifdesc = &config->if_desc[i];
usb_display_if_desc(ifdesc,dev); usb_display_if_desc(ifdesc, dev);
for(ii=0;ii<ifdesc->no_of_ep;ii++) { for (ii = 0; ii < ifdesc->no_of_ep; ii++) {
epdesc= &ifdesc->ep_desc[ii]; epdesc = &ifdesc->ep_desc[ii];
usb_display_ep_desc(epdesc); usb_display_ep_desc(epdesc);
} }
} }
@ -233,31 +265,33 @@ void usb_display_config(struct usb_device *dev)
} }
/* shows the device tree recursively */ /* shows the device tree recursively */
void usb_show_tree_graph(struct usb_device *dev,char *pre) void usb_show_tree_graph(struct usb_device *dev, char *pre)
{ {
int i,index; int i, index;
int has_child,last_child,port; int has_child, last_child, port;
index=strlen(pre); index = strlen(pre);
printf(" %s",pre); printf(" %s", pre);
/* check if the device has connected children */ /* check if the device has connected children */
has_child=0; has_child = 0;
for(i=0;i<dev->maxchild;i++) { for (i = 0; i < dev->maxchild; i++) {
if (dev->children[i]!=NULL) if (dev->children[i] != NULL)
has_child=1; has_child = 1;
} }
/* check if we are the last one */ /* check if we are the last one */
last_child=1; last_child = 1;
if (dev->parent!=NULL) { if (dev->parent != NULL) {
for(i=0;i<dev->parent->maxchild;i++) { for (i = 0; i < dev->parent->maxchild; i++) {
/* search for children */ /* search for children */
if (dev->parent->children[i]==dev) { if (dev->parent->children[i] == dev) {
/* found our pointer, see if we have a little sister */ /* found our pointer, see if we have a
port=i; * little sister
while(i++<dev->parent->maxchild) { */
if (dev->parent->children[i]!=NULL) { port = i;
while (i++ < dev->parent->maxchild) {
if (dev->parent->children[i] != NULL) {
/* found a sister */ /* found a sister */
last_child=0; last_child = 0;
break; break;
} /* if */ } /* if */
} /* while */ } /* while */
@ -265,28 +299,27 @@ void usb_show_tree_graph(struct usb_device *dev,char *pre)
} /* for all children of the parent */ } /* for all children of the parent */
printf("\b+-"); printf("\b+-");
/* correct last child */ /* correct last child */
if (last_child) { if (last_child)
pre[index-1]=' '; pre[index-1] = ' ';
}
} /* if not root hub */ } /* if not root hub */
else else
printf(" "); printf(" ");
printf("%d ",dev->devnum); printf("%d ", dev->devnum);
pre[index++]=' '; pre[index++] = ' ';
pre[index++]= has_child ? '|' : ' '; pre[index++] = has_child ? '|' : ' ';
pre[index]=0; pre[index] = 0;
printf(" %s (%s, %dmA)\n",usb_get_class_desc(dev->config.if_desc[0].bInterfaceClass), printf(" %s (%s, %dmA)\n", usb_get_class_desc(
dev->slow ? "1.5MBit/s" : "12MBit/s",dev->config.MaxPower * 2); dev->config.if_desc[0].bInterfaceClass),
if (strlen(dev->mf) || dev->slow ? "1.5MBit/s" : "12MBit/s",
strlen(dev->prod) || dev->config.MaxPower * 2);
strlen(dev->serial)) if (strlen(dev->mf) || strlen(dev->prod) || strlen(dev->serial))
printf(" %s %s %s %s\n",pre,dev->mf,dev->prod,dev->serial); printf(" %s %s %s %s\n", pre, dev->mf, dev->prod, dev->serial);
printf(" %s\n",pre); printf(" %s\n", pre);
if (dev->maxchild>0) { if (dev->maxchild > 0) {
for(i=0;i<dev->maxchild;i++) { for (i = 0; i < dev->maxchild; i++) {
if (dev->children[i]!=NULL) { if (dev->children[i] != NULL) {
usb_show_tree_graph(dev->children[i],pre); usb_show_tree_graph(dev->children[i], pre);
pre[index]=0; pre[index] = 0;
} }
} }
} }
@ -297,8 +330,8 @@ void usb_show_tree(struct usb_device *dev)
{ {
char preamble[32]; char preamble[32];
memset(preamble,0,32); memset(preamble, 0, 32);
usb_show_tree_graph(dev,&preamble[0]); usb_show_tree_graph(dev, &preamble[0]);
} }
@ -306,11 +339,11 @@ void usb_show_tree(struct usb_device *dev)
* usb boot command intepreter. Derived from diskboot * usb boot command intepreter. Derived from diskboot
*/ */
#ifdef CONFIG_USB_STORAGE #ifdef CONFIG_USB_STORAGE
int do_usbboot (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[]) int do_usbboot(cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{ {
char *boot_device = NULL; char *boot_device = NULL;
char *ep; char *ep;
int dev, part=1, rcode; int dev, part = 1, rcode;
ulong addr, cnt; ulong addr, cnt;
disk_partition_t info; disk_partition_t info;
image_header_t *hdr; image_header_t *hdr;
@ -322,95 +355,98 @@ int do_usbboot (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
switch (argc) { switch (argc) {
case 1: case 1:
addr = CONFIG_SYS_LOAD_ADDR; addr = CONFIG_SYS_LOAD_ADDR;
boot_device = getenv ("bootdevice"); boot_device = getenv("bootdevice");
break; break;
case 2: case 2:
addr = simple_strtoul(argv[1], NULL, 16); addr = simple_strtoul(argv[1], NULL, 16);
boot_device = getenv ("bootdevice"); boot_device = getenv("bootdevice");
break; break;
case 3: case 3:
addr = simple_strtoul(argv[1], NULL, 16); addr = simple_strtoul(argv[1], NULL, 16);
boot_device = argv[2]; boot_device = argv[2];
break; break;
default: default:
printf ("Usage:\n%s\n", cmdtp->usage); printf("Usage:\n%s\n", cmdtp->usage);
return 1; return 1;
} }
if (!boot_device) { if (!boot_device) {
puts ("\n** No boot device **\n"); puts("\n** No boot device **\n");
return 1; return 1;
} }
dev = simple_strtoul(boot_device, &ep, 16); dev = simple_strtoul(boot_device, &ep, 16);
stor_dev=usb_stor_get_dev(dev); stor_dev = usb_stor_get_dev(dev);
if (stor_dev->type == DEV_TYPE_UNKNOWN) { if (stor_dev->type == DEV_TYPE_UNKNOWN) {
printf ("\n** Device %d not available\n", dev); printf("\n** Device %d not available\n", dev);
return 1; return 1;
} }
if (stor_dev->block_read==NULL) { if (stor_dev->block_read == NULL) {
printf("storage device not initialized. Use usb scan\n"); printf("storage device not initialized. Use usb scan\n");
return 1; return 1;
} }
if (*ep) { if (*ep) {
if (*ep != ':') { if (*ep != ':') {
puts ("\n** Invalid boot device, use `dev[:part]' **\n"); puts("\n** Invalid boot device, use `dev[:part]' **\n");
return 1; return 1;
} }
part = simple_strtoul(++ep, NULL, 16); part = simple_strtoul(++ep, NULL, 16);
} }
if (get_partition_info (stor_dev, part, &info)) { if (get_partition_info(stor_dev, part, &info)) {
/* try to boot raw .... */ /* try to boot raw .... */
strncpy((char *)&info.type[0], BOOT_PART_TYPE, sizeof(BOOT_PART_TYPE)); strncpy((char *)&info.type[0], BOOT_PART_TYPE,
sizeof(BOOT_PART_TYPE));
strncpy((char *)&info.name[0], "Raw", 4); strncpy((char *)&info.name[0], "Raw", 4);
info.start=0; info.start = 0;
info.blksz=0x200; info.blksz = 0x200;
info.size=2880; info.size = 2880;
printf("error reading partinfo...try to boot raw\n"); printf("error reading partinfo...try to boot raw\n");
} }
if ((strncmp((char *)info.type, BOOT_PART_TYPE, sizeof(info.type)) != 0) && if ((strncmp((char *)info.type, BOOT_PART_TYPE,
(strncmp((char *)info.type, BOOT_PART_COMP, sizeof(info.type)) != 0)) { sizeof(info.type)) != 0) &&
printf ("\n** Invalid partition type \"%.32s\"" (strncmp((char *)info.type, BOOT_PART_COMP,
sizeof(info.type)) != 0)) {
printf("\n** Invalid partition type \"%.32s\""
" (expect \"" BOOT_PART_TYPE "\")\n", " (expect \"" BOOT_PART_TYPE "\")\n",
info.type); info.type);
return 1; return 1;
} }
printf ("\nLoading from USB device %d, partition %d: " printf("\nLoading from USB device %d, partition %d: "
"Name: %.32s Type: %.32s\n", "Name: %.32s Type: %.32s\n",
dev, part, info.name, info.type); dev, part, info.name, info.type);
debug ("First Block: %ld, # of blocks: %ld, Block Size: %ld\n", debug("First Block: %ld, # of blocks: %ld, Block Size: %ld\n",
info.start, info.size, info.blksz); info.start, info.size, info.blksz);
if (stor_dev->block_read(dev, info.start, 1, (ulong *)addr) != 1) { if (stor_dev->block_read(dev, info.start, 1, (ulong *)addr) != 1) {
printf ("** Read error on %d:%d\n", dev, part); printf("** Read error on %d:%d\n", dev, part);
return 1; return 1;
} }
switch (genimg_get_format ((void *)addr)) { switch (genimg_get_format((void *)addr)) {
case IMAGE_FORMAT_LEGACY: case IMAGE_FORMAT_LEGACY:
hdr = (image_header_t *)addr; hdr = (image_header_t *)addr;
if (!image_check_hcrc (hdr)) { if (!image_check_hcrc(hdr)) {
puts ("\n** Bad Header Checksum **\n"); puts("\n** Bad Header Checksum **\n");
return 1; return 1;
} }
image_print_contents (hdr); image_print_contents(hdr);
cnt = image_get_image_size (hdr); cnt = image_get_image_size(hdr);
break; break;
#if defined(CONFIG_FIT) #if defined(CONFIG_FIT)
case IMAGE_FORMAT_FIT: case IMAGE_FORMAT_FIT:
fit_hdr = (const void *)addr; fit_hdr = (const void *)addr;
puts ("Fit image detected...\n"); puts("Fit image detected...\n");
cnt = fit_get_size (fit_hdr); cnt = fit_get_size(fit_hdr);
break; break;
#endif #endif
default: default:
puts ("** Unknown image type\n"); puts("** Unknown image type\n");
return 1; return 1;
} }
@ -418,36 +454,38 @@ int do_usbboot (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
cnt /= info.blksz; cnt /= info.blksz;
cnt -= 1; cnt -= 1;
if (stor_dev->block_read (dev, info.start+1, cnt, if (stor_dev->block_read(dev, info.start+1, cnt,
(ulong *)(addr+info.blksz)) != cnt) { (ulong *)(addr+info.blksz)) != cnt) {
printf ("\n** Read error on %d:%d\n", dev, part); printf("\n** Read error on %d:%d\n", dev, part);
return 1; return 1;
} }
#if defined(CONFIG_FIT) #if defined(CONFIG_FIT)
/* This cannot be done earlier, we need complete FIT image in RAM first */ /* This cannot be done earlier, we need complete FIT image in RAM
if (genimg_get_format ((void *)addr) == IMAGE_FORMAT_FIT) { * first
if (!fit_check_format (fit_hdr)) { */
puts ("** Bad FIT image format\n"); if (genimg_get_format((void *)addr) == IMAGE_FORMAT_FIT) {
if (!fit_check_format(fit_hdr)) {
puts("** Bad FIT image format\n");
return 1; return 1;
} }
fit_print_contents (fit_hdr); fit_print_contents(fit_hdr);
} }
#endif #endif
/* Loading ok, update default load address */ /* Loading ok, update default load address */
load_addr = addr; load_addr = addr;
flush_cache (addr, (cnt+1)*info.blksz); flush_cache(addr, (cnt+1)*info.blksz);
/* Check if we should attempt an auto-start */ /* Check if we should attempt an auto-start */
if (((ep = getenv("autostart")) != NULL) && (strcmp(ep,"yes") == 0)) { if (((ep = getenv("autostart")) != NULL) && (strcmp(ep, "yes") == 0)) {
char *local_args[2]; char *local_args[2];
extern int do_bootm (cmd_tbl_t *, int, int, char *[]); extern int do_bootm(cmd_tbl_t *, int, int, char *[]);
local_args[0] = argv[0]; local_args[0] = argv[0];
local_args[1] = NULL; local_args[1] = NULL;
printf ("Automatic boot of image at addr 0x%08lX ...\n", addr); printf("Automatic boot of image at addr 0x%08lX ...\n", addr);
rcode=do_bootm (cmdtp, 0, 1, local_args); rcode = do_bootm(cmdtp, 0, 1, local_args);
return rcode; return rcode;
} }
return 0; return 0;
@ -455,10 +493,10 @@ int do_usbboot (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
#endif /* CONFIG_USB_STORAGE */ #endif /* CONFIG_USB_STORAGE */
/********************************************************************************* /******************************************************************************
* usb command intepreter * usb command intepreter
*/ */
int do_usb (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[]) int do_usb(cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{ {
int i; int i;
@ -469,7 +507,7 @@ int do_usb (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
#endif #endif
if ((strncmp(argv[1], "reset", 5) == 0) || if ((strncmp(argv[1], "reset", 5) == 0) ||
(strncmp(argv[1], "start", 5) == 0)){ (strncmp(argv[1], "start", 5) == 0)) {
usb_stop(); usb_stop();
printf("(Re)start USB...\n"); printf("(Re)start USB...\n");
i = usb_init(); i = usb_init();
@ -480,16 +518,17 @@ int do_usb (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
#endif #endif
return 0; return 0;
} }
if (strncmp(argv[1],"stop",4) == 0) { if (strncmp(argv[1], "stop", 4) == 0) {
#ifdef CONFIG_USB_KEYBOARD #ifdef CONFIG_USB_KEYBOARD
if (argc==2) { if (argc == 2) {
if (usb_kbd_deregister()!=0) { if (usb_kbd_deregister() != 0) {
printf("USB not stopped: usbkbd still using USB\n"); printf("USB not stopped: usbkbd still"
" using USB\n");
return 1; return 1;
} }
} } else {
else { /* forced stop, switch console in to serial */ /* forced stop, switch console in to serial */
console_assign(stdin,"serial"); console_assign(stdin, "serial");
usb_kbd_deregister(); usb_kbd_deregister();
} }
#endif #endif
@ -501,40 +540,38 @@ int do_usb (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
printf("USB is stopped. Please issue 'usb start' first.\n"); printf("USB is stopped. Please issue 'usb start' first.\n");
return 1; return 1;
} }
if (strncmp(argv[1],"tree",4) == 0) { if (strncmp(argv[1], "tree", 4) == 0) {
printf("\nDevice Tree:\n"); printf("\nDevice Tree:\n");
usb_show_tree(usb_get_dev_index(0)); usb_show_tree(usb_get_dev_index(0));
return 0; return 0;
} }
if (strncmp(argv[1],"inf",3) == 0) { if (strncmp(argv[1], "inf", 3) == 0) {
int d; int d;
if (argc==2) { if (argc == 2) {
for(d=0;d<USB_MAX_DEVICE;d++) { for (d = 0; d < USB_MAX_DEVICE; d++) {
dev=usb_get_dev_index(d); dev = usb_get_dev_index(d);
if (dev==NULL) if (dev == NULL)
break; break;
usb_display_desc(dev); usb_display_desc(dev);
usb_display_config(dev); usb_display_config(dev);
} }
return 0; return 0;
} } else {
else {
int d; int d;
i=simple_strtoul(argv[2], NULL, 16); i = simple_strtoul(argv[2], NULL, 16);
printf("config for device %d\n",i); printf("config for device %d\n", i);
for(d=0;d<USB_MAX_DEVICE;d++) { for (d = 0; d < USB_MAX_DEVICE; d++) {
dev=usb_get_dev_index(d); dev = usb_get_dev_index(d);
if (dev==NULL) if (dev == NULL)
break; break;
if (dev->devnum==i) if (dev->devnum == i)
break; break;
} }
if (dev==NULL) { if (dev == NULL) {
printf("*** NO Device avaiable ***\n"); printf("*** NO Device avaiable ***\n");
return 0; return 0;
} } else {
else {
usb_display_desc(dev); usb_display_desc(dev);
usb_display_config(dev); usb_display_config(dev);
} }
@ -542,37 +579,28 @@ int do_usb (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
return 0; return 0;
} }
#ifdef CONFIG_USB_STORAGE #ifdef CONFIG_USB_STORAGE
if (strncmp(argv[1], "scan", 4) == 0) { if (strncmp(argv[1], "stor", 4) == 0)
printf(" NOTE: this command is obsolete and will be phased out\n");
printf(" please use 'usb storage' for USB storage devices information\n\n");
usb_stor_info();
return 0;
}
if (strncmp(argv[1], "stor", 4) == 0) {
return usb_stor_info(); return usb_stor_info();
}
if (strncmp(argv[1],"part",4) == 0) { if (strncmp(argv[1], "part", 4) == 0) {
int devno, ok = 0; int devno, ok = 0;
if (argc==2) { if (argc == 2) {
for (devno=0; devno<USB_MAX_STOR_DEV; ++devno) { for (devno = 0; devno < USB_MAX_STOR_DEV; ++devno) {
stor_dev=usb_stor_get_dev(devno); stor_dev = usb_stor_get_dev(devno);
if (stor_dev->type!=DEV_TYPE_UNKNOWN) { if (stor_dev->type != DEV_TYPE_UNKNOWN) {
ok++; ok++;
if (devno) if (devno)
printf("\n"); printf("\n");
printf("print_part of %x\n",devno); printf("print_part of %x\n", devno);
print_part(stor_dev); print_part(stor_dev);
} }
} }
} } else {
else { devno = simple_strtoul(argv[2], NULL, 16);
devno=simple_strtoul(argv[2], NULL, 16); stor_dev = usb_stor_get_dev(devno);
stor_dev=usb_stor_get_dev(devno); if (stor_dev->type != DEV_TYPE_UNKNOWN) {
if (stor_dev->type!=DEV_TYPE_UNKNOWN) {
ok++; ok++;
printf("print_part of %x\n",devno); printf("print_part of %x\n", devno);
print_part(stor_dev); print_part(stor_dev);
} }
} }
@ -582,22 +610,24 @@ int do_usb (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
} }
return 0; return 0;
} }
if (strcmp(argv[1],"read") == 0) { if (strcmp(argv[1], "read") == 0) {
if (usb_stor_curr_dev<0) { if (usb_stor_curr_dev < 0) {
printf("no current device selected\n"); printf("no current device selected\n");
return 1; return 1;
} }
if (argc==5) { if (argc == 5) {
unsigned long addr = simple_strtoul(argv[2], NULL, 16); unsigned long addr = simple_strtoul(argv[2], NULL, 16);
unsigned long blk = simple_strtoul(argv[3], NULL, 16); unsigned long blk = simple_strtoul(argv[3], NULL, 16);
unsigned long cnt = simple_strtoul(argv[4], NULL, 16); unsigned long cnt = simple_strtoul(argv[4], NULL, 16);
unsigned long n; unsigned long n;
printf ("\nUSB read: device %d block # %ld, count %ld ... ", printf("\nUSB read: device %d block # %ld, count %ld"
usb_stor_curr_dev, blk, cnt); " ... ", usb_stor_curr_dev, blk, cnt);
stor_dev=usb_stor_get_dev(usb_stor_curr_dev); stor_dev = usb_stor_get_dev(usb_stor_curr_dev);
n = stor_dev->block_read(usb_stor_curr_dev, blk, cnt, (ulong *)addr); n = stor_dev->block_read(usb_stor_curr_dev, blk, cnt,
printf ("%ld blocks read: %s\n",n,(n==cnt) ? "OK" : "ERROR"); (ulong *)addr);
if (n==cnt) printf("%ld blocks read: %s\n", n,
(n == cnt) ? "OK" : "ERROR");
if (n == cnt)
return 0; return 0;
return 1; return 1;
} }
@ -605,34 +635,31 @@ int do_usb (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
if (strncmp(argv[1], "dev", 3) == 0) { if (strncmp(argv[1], "dev", 3) == 0) {
if (argc == 3) { if (argc == 3) {
int dev = (int)simple_strtoul(argv[2], NULL, 10); int dev = (int)simple_strtoul(argv[2], NULL, 10);
printf ("\nUSB device %d: ", dev); printf("\nUSB device %d: ", dev);
if (dev >= USB_MAX_STOR_DEV) { if (dev >= USB_MAX_STOR_DEV) {
printf("unknown device\n"); printf("unknown device\n");
return 1; return 1;
} }
printf ("\n Device %d: ", dev); printf("\n Device %d: ", dev);
stor_dev=usb_stor_get_dev(dev); stor_dev = usb_stor_get_dev(dev);
dev_print(stor_dev); dev_print(stor_dev);
if (stor_dev->type == DEV_TYPE_UNKNOWN) { if (stor_dev->type == DEV_TYPE_UNKNOWN)
return 1; return 1;
}
usb_stor_curr_dev = dev; usb_stor_curr_dev = dev;
printf("... is now current device\n"); printf("... is now current device\n");
return 0; return 0;
} } else {
else { printf("\nUSB device %d: ", usb_stor_curr_dev);
printf ("\nUSB device %d: ", usb_stor_curr_dev); stor_dev = usb_stor_get_dev(usb_stor_curr_dev);
stor_dev=usb_stor_get_dev(usb_stor_curr_dev);
dev_print(stor_dev); dev_print(stor_dev);
if (stor_dev->type == DEV_TYPE_UNKNOWN) { if (stor_dev->type == DEV_TYPE_UNKNOWN)
return 1; return 1;
}
return 0; return 0;
} }
return 0; return 0;
} }
#endif /* CONFIG_USB_STORAGE */ #endif /* CONFIG_USB_STORAGE */
printf ("Usage:\n%s\n", cmdtp->usage); printf("Usage:\n%s\n", cmdtp->usage);
return 1; return 1;
} }
@ -646,7 +673,8 @@ U_BOOT_CMD(
"usb info [dev] - show available USB devices\n" "usb info [dev] - show available USB devices\n"
"usb storage - show details of USB storage devices\n" "usb storage - show details of USB storage devices\n"
"usb dev [dev] - show or set current USB storage device\n" "usb dev [dev] - show or set current USB storage device\n"
"usb part [dev] - print partition table of one or all USB storage devices\n" "usb part [dev] - print partition table of one or all USB storage"
" devices\n"
"usb read addr blk# cnt - read `cnt' blocks starting at block `blk#'\n" "usb read addr blk# cnt - read `cnt' blocks starting at block `blk#'\n"
" to memory address `addr'\n" " to memory address `addr'\n"
); );

40
common/usb.c
View file

@ -58,7 +58,7 @@
#undef USB_DEBUG #undef USB_DEBUG
#ifdef USB_DEBUG #ifdef USB_DEBUG
#define USB_PRINTF(fmt, args...) printf (fmt , ##args) #define USB_PRINTF(fmt, args...) printf(fmt , ##args)
#else #else
#define USB_PRINTF(fmt, args...) #define USB_PRINTF(fmt, args...)
#endif #endif
@ -87,11 +87,12 @@ static int hub_port_reset(struct usb_device *dev, int port,
* wait_ms * wait_ms
*/ */
void __inline__ wait_ms(unsigned long ms) inline void wait_ms(unsigned long ms)
{ {
while (ms-- > 0) while (ms-- > 0)
udelay(1000); udelay(1000);
} }
/*************************************************************************** /***************************************************************************
* Init USB Device * Init USB Device
*/ */
@ -245,9 +246,9 @@ int usb_maxpacket(struct usb_device *dev, unsigned long pipe)
{ {
/* direction is out -> use emaxpacket out */ /* direction is out -> use emaxpacket out */
if ((pipe & USB_DIR_IN) == 0) if ((pipe & USB_DIR_IN) == 0)
return(dev->epmaxpacketout[((pipe>>15) & 0xf)]); return dev->epmaxpacketout[((pipe>>15) & 0xf)];
else else
return(dev->epmaxpacketin[((pipe>>15) & 0xf)]); return dev->epmaxpacketin[((pipe>>15) & 0xf)];
} }
/* The routine usb_set_maxpacket_ep() is extracted from the loop of routine /* The routine usb_set_maxpacket_ep() is extracted from the loop of routine
@ -269,7 +270,7 @@ usb_set_maxpacket_ep(struct usb_device *dev, struct usb_endpoint_descriptor *ep)
USB_ENDPOINT_XFER_CONTROL) { USB_ENDPOINT_XFER_CONTROL) {
/* Control => bidirectional */ /* Control => bidirectional */
dev->epmaxpacketout[b] = ep->wMaxPacketSize; dev->epmaxpacketout[b] = ep->wMaxPacketSize;
dev->epmaxpacketin [b] = ep->wMaxPacketSize; dev->epmaxpacketin[b] = ep->wMaxPacketSize;
USB_PRINTF("##Control EP epmaxpacketout/in[%d] = %d\n", USB_PRINTF("##Control EP epmaxpacketout/in[%d] = %d\n",
b, dev->epmaxpacketin[b]); b, dev->epmaxpacketin[b]);
} else { } else {
@ -779,13 +780,13 @@ int usb_new_device(struct usb_device *dev)
* invalid header while reading 8 bytes as device descriptor. */ * invalid header while reading 8 bytes as device descriptor. */
dev->descriptor.bMaxPacketSize0 = 8; /* Start off at 8 bytes */ dev->descriptor.bMaxPacketSize0 = 8; /* Start off at 8 bytes */
dev->maxpacketsize = PACKET_SIZE_8; dev->maxpacketsize = PACKET_SIZE_8;
dev->epmaxpacketin [0] = 8; dev->epmaxpacketin[0] = 8;
dev->epmaxpacketout[0] = 8; dev->epmaxpacketout[0] = 8;
err = usb_get_descriptor(dev, USB_DT_DEVICE, 0, &dev->descriptor, 8); err = usb_get_descriptor(dev, USB_DT_DEVICE, 0, &dev->descriptor, 8);
if (err < 8) { if (err < 8) {
printf("\n USB device not responding, " \ printf("\n USB device not responding, " \
"giving up (status=%lX)\n",dev->status); "giving up (status=%lX)\n", dev->status);
return 1; return 1;
} }
#else #else
@ -793,7 +794,8 @@ int usb_new_device(struct usb_device *dev)
* reset of the device (Linux uses the same sequence) * reset of the device (Linux uses the same sequence)
* Some equipment is said to work only with such init sequence; this * Some equipment is said to work only with such init sequence; this
* patch is based on the work by Alan Stern: * patch is based on the work by Alan Stern:
* http://sourceforge.net/mailarchive/forum.php?thread_id=5729457&forum_id=5398 * http://sourceforge.net/mailarchive/forum.php?
* thread_id=5729457&forum_id=5398
*/ */
struct usb_device_descriptor *desc; struct usb_device_descriptor *desc;
int port = -1; int port = -1;
@ -809,7 +811,7 @@ int usb_new_device(struct usb_device *dev)
dev->descriptor.bMaxPacketSize0 = 64; /* Start off at 64 bytes */ dev->descriptor.bMaxPacketSize0 = 64; /* Start off at 64 bytes */
/* Default to 64 byte max packet size */ /* Default to 64 byte max packet size */
dev->maxpacketsize = PACKET_SIZE_64; dev->maxpacketsize = PACKET_SIZE_64;
dev->epmaxpacketin [0] = 64; dev->epmaxpacketin[0] = 64;
dev->epmaxpacketout[0] = 64; dev->epmaxpacketout[0] = 64;
err = usb_get_descriptor(dev, USB_DT_DEVICE, 0, desc, 64); err = usb_get_descriptor(dev, USB_DT_DEVICE, 0, desc, 64);
@ -844,13 +846,21 @@ int usb_new_device(struct usb_device *dev)
} }
#endif #endif
dev->epmaxpacketin [0] = dev->descriptor.bMaxPacketSize0; dev->epmaxpacketin[0] = dev->descriptor.bMaxPacketSize0;
dev->epmaxpacketout[0] = dev->descriptor.bMaxPacketSize0; dev->epmaxpacketout[0] = dev->descriptor.bMaxPacketSize0;
switch (dev->descriptor.bMaxPacketSize0) { switch (dev->descriptor.bMaxPacketSize0) {
case 8: dev->maxpacketsize = PACKET_SIZE_8; break; case 8:
case 16: dev->maxpacketsize = PACKET_SIZE_16; break; dev->maxpacketsize = PACKET_SIZE_8;
case 32: dev->maxpacketsize = PACKET_SIZE_32; break; break;
case 64: dev->maxpacketsize = PACKET_SIZE_64; break; case 16:
dev->maxpacketsize = PACKET_SIZE_16;
break;
case 32:
dev->maxpacketsize = PACKET_SIZE_32;
break;
case 64:
dev->maxpacketsize = PACKET_SIZE_64;
break;
} }
dev->devnum = addr; dev->devnum = addr;
@ -947,7 +957,7 @@ void usb_scan_devices(void)
#undef USB_HUB_DEBUG #undef USB_HUB_DEBUG
#ifdef USB_HUB_DEBUG #ifdef USB_HUB_DEBUG
#define USB_HUB_PRINTF(fmt, args...) printf (fmt , ##args) #define USB_HUB_PRINTF(fmt, args...) printf(fmt , ##args)
#else #else
#define USB_HUB_PRINTF(fmt, args...) #define USB_HUB_PRINTF(fmt, args...)
#endif #endif

21
drivers/usb/Makefile
View file

@ -25,15 +25,22 @@ include $(TOPDIR)/config.mk
LIB := $(obj)libusb.a LIB := $(obj)libusb.a
COBJS-$(CONFIG_USB_R8A66597_HCD) += r8a66597-hcd.o # core
COBJS-y += isp116x-hcd.o
COBJS-y += sl811_usb.o
COBJS-y += usb_ohci.o
COBJS-y += usbdcore.o COBJS-y += usbdcore.o
COBJS-$(CONFIG_USB_OHCI_NEW) += usb_ohci.o
# host
COBJS-$(CONFIG_USB_ISP116X_HCD) += isp116x-hcd.o
COBJS-$(CONFIG_USB_R8A66597_HCD) += r8a66597-hcd.o
COBJS-$(CONFIG_USB_SL811HS) += sl811_usb.o
# device
ifdef CONFIG_USB_DEVICE
COBJS-y += usbdcore_ep0.o COBJS-y += usbdcore_ep0.o
COBJS-y += usbdcore_mpc8xx.o COBJS-$(CONFIG_OMAP1510) += usbdcore_omap1510.o
COBJS-y += usbdcore_omap1510.o COBJS-$(CONFIG_OMAP1610) += usbdcore_omap1510.o
COBJS-$(CONFIG_MPC885_FAMILY) += usbdcore_mpc8xx.o
endif
COBJS := $(COBJS-y) COBJS := $(COBJS-y)
SRCS := $(COBJS:.o=.c) SRCS := $(COBJS:.o=.c)

4
drivers/usb/isp116x-hcd.c
View file

@ -56,8 +56,6 @@
*/ */
#include <common.h> #include <common.h>
#ifdef CONFIG_USB_ISP116X_HCD
#include <asm/io.h> #include <asm/io.h>
#include <usb.h> #include <usb.h>
#include <malloc.h> #include <malloc.h>
@ -1441,5 +1439,3 @@ int usb_lowlevel_stop(void)
return 0; return 0;
} }
#endif /* CONFIG_USB_ISP116X_HCD */

3
drivers/usb/sl811_usb.c
View file

@ -36,7 +36,6 @@
*/ */
#include <common.h> #include <common.h>
#ifdef CONFIG_USB_SL811HS
#include <mpc8xx.h> #include <mpc8xx.h>
#include <usb.h> #include <usb.h>
#include "sl811.h" #include "sl811.h"
@ -733,5 +732,3 @@ static int sl811_rh_submit_urb(struct usb_device *usb_dev, unsigned long pipe,
return status == 0 ? len : status; return status == 0 ? len : status;
} }
#endif /* CONFIG_USB_SL811HS */

4
drivers/usb/usb_ohci.c
View file

@ -46,9 +46,6 @@
*/ */
#include <common.h> #include <common.h>
#ifdef CONFIG_USB_OHCI_NEW
#include <asm/byteorder.h> #include <asm/byteorder.h>
#if defined(CONFIG_PCI_OHCI) #if defined(CONFIG_PCI_OHCI)
@ -2016,4 +2013,3 @@ int usb_lowlevel_stop(void)
ohci_inited = 0; ohci_inited = 0;
return 0; return 0;
} }
#endif /* CONFIG_USB_OHCI_NEW */

4
drivers/usb/usbdcore_ep0.c
View file

@ -51,8 +51,6 @@
*/ */
#include <common.h> #include <common.h>
#if defined(CONFIG_USB_DEVICE)
#include "usbdcore.h" #include "usbdcore.h"
#if 0 #if 0
@ -597,5 +595,3 @@ int ep0_recv_setup (struct urb *urb)
} }
return -1; return -1;
} }
#endif

4
drivers/usb/usbdcore_mpc8xx.c
View file

@ -58,8 +58,6 @@
*/ */
#include <common.h> #include <common.h>
#include <config.h> #include <config.h>
#if defined(CONFIG_MPC885_FAMILY) && defined(CONFIG_USB_DEVICE)
#include <commproc.h> #include <commproc.h>
#include "usbdcore.h" #include "usbdcore.h"
#include "usbdcore_mpc8xx.h" #include "usbdcore_mpc8xx.h"
@ -1398,5 +1396,3 @@ static u32 mpc8xx_udc_alloc (u32 data_size, u32 alignment)
return retaddr; return retaddr;
} }
#endif /* CONFIG_MPC885_FAMILY && CONFIG_USB_DEVICE) */

4
drivers/usb/usbdcore_omap1510.c
View file

@ -27,9 +27,6 @@
*/ */
#include <common.h> #include <common.h>
#if ((defined(CONFIG_OMAP1510) || defined(CONFIG_OMAP1610)) && defined(CONFIG_USB_DEVICE))
#include <asm/io.h> #include <asm/io.h>
#ifdef CONFIG_OMAP_SX1 #ifdef CONFIG_OMAP_SX1
#include <i2c.h> #include <i2c.h>
@ -1566,4 +1563,3 @@ void udc_unset_nak (int epid)
{ {
/* TODO: implement this functionality in omap1510 */ /* TODO: implement this functionality in omap1510 */
} }
#endif

4
fs/fat/fat.c
View file

@ -184,7 +184,7 @@ static void get_name (dir_entry *dirent, char *s_name)
if (*s_name == DELETED_FLAG) if (*s_name == DELETED_FLAG)
*s_name = '\0'; *s_name = '\0';
else if (*s_name == aRING) else if (*s_name == aRING)
*s_name = 'å'; *s_name = DELETED_FLAG;
downcase (s_name); downcase (s_name);
} }
@ -489,7 +489,7 @@ get_vfatname(fsdata *mydata, int curclust, __u8 *cluster,
l_name[idx] = '\0'; l_name[idx] = '\0';
if (*l_name == DELETED_FLAG) *l_name = '\0'; if (*l_name == DELETED_FLAG) *l_name = '\0';
else if (*l_name == aRING) *l_name = 'å'; else if (*l_name == aRING) *l_name = DELETED_FLAG;
downcase(l_name); downcase(l_name);
/* Return the real directory entry */ /* Return the real directory entry */

2
include/fat.h
View file

@ -67,7 +67,7 @@
#define ATTR_VFAT (ATTR_RO | ATTR_HIDDEN | ATTR_SYS | ATTR_VOLUME) #define ATTR_VFAT (ATTR_RO | ATTR_HIDDEN | ATTR_SYS | ATTR_VOLUME)
#define DELETED_FLAG ((char)0xe5) /* Marks deleted files when in name[0] */ #define DELETED_FLAG ((char)0xe5) /* Marks deleted files when in name[0] */
#define aRING 0x05 /* Used to represent 'å' in name[0] */ #define aRING 0x05 /* Used as special character in name[0] */
/* Indicates that the entry is the last long entry in a set of long /* Indicates that the entry is the last long entry in a set of long
* dir entries * dir entries

216
include/usb.h
View file

@ -43,89 +43,88 @@
/* String descriptor */ /* String descriptor */
struct usb_string_descriptor { struct usb_string_descriptor {
unsigned char bLength; unsigned char bLength;
unsigned char bDescriptorType; unsigned char bDescriptorType;
unsigned short wData[1]; unsigned short wData[1];
} __attribute__ ((packed)); } __attribute__ ((packed));
/* device request (setup) */ /* device request (setup) */
struct devrequest { struct devrequest {
unsigned char requesttype; unsigned char requesttype;
unsigned char request; unsigned char request;
unsigned short value; unsigned short value;
unsigned short index; unsigned short index;
unsigned short length; unsigned short length;
} __attribute__ ((packed)); } __attribute__ ((packed));
/* All standard descriptors have these 2 fields in common */ /* All standard descriptors have these 2 fields in common */
struct usb_descriptor_header { struct usb_descriptor_header {
unsigned char bLength; unsigned char bLength;
unsigned char bDescriptorType; unsigned char bDescriptorType;
} __attribute__ ((packed)); } __attribute__ ((packed));
/* Device descriptor */ /* Device descriptor */
struct usb_device_descriptor { struct usb_device_descriptor {
unsigned char bLength; unsigned char bLength;
unsigned char bDescriptorType; unsigned char bDescriptorType;
unsigned short bcdUSB; unsigned short bcdUSB;
unsigned char bDeviceClass; unsigned char bDeviceClass;
unsigned char bDeviceSubClass; unsigned char bDeviceSubClass;
unsigned char bDeviceProtocol; unsigned char bDeviceProtocol;
unsigned char bMaxPacketSize0; unsigned char bMaxPacketSize0;
unsigned short idVendor; unsigned short idVendor;
unsigned short idProduct; unsigned short idProduct;
unsigned short bcdDevice; unsigned short bcdDevice;
unsigned char iManufacturer; unsigned char iManufacturer;
unsigned char iProduct; unsigned char iProduct;
unsigned char iSerialNumber; unsigned char iSerialNumber;
unsigned char bNumConfigurations; unsigned char bNumConfigurations;
} __attribute__ ((packed)); } __attribute__ ((packed));
/* Endpoint descriptor */ /* Endpoint descriptor */
struct usb_endpoint_descriptor { struct usb_endpoint_descriptor {
unsigned char bLength; unsigned char bLength;
unsigned char bDescriptorType; unsigned char bDescriptorType;
unsigned char bEndpointAddress; unsigned char bEndpointAddress;
unsigned char bmAttributes; unsigned char bmAttributes;
unsigned short wMaxPacketSize; unsigned short wMaxPacketSize;
unsigned char bInterval; unsigned char bInterval;
unsigned char bRefresh; unsigned char bRefresh;
unsigned char bSynchAddress; unsigned char bSynchAddress;
} __attribute__ ((packed)); } __attribute__ ((packed));
/* Interface descriptor */ /* Interface descriptor */
struct usb_interface_descriptor { struct usb_interface_descriptor {
unsigned char bLength; unsigned char bLength;
unsigned char bDescriptorType; unsigned char bDescriptorType;
unsigned char bInterfaceNumber; unsigned char bInterfaceNumber;
unsigned char bAlternateSetting; unsigned char bAlternateSetting;
unsigned char bNumEndpoints; unsigned char bNumEndpoints;
unsigned char bInterfaceClass; unsigned char bInterfaceClass;
unsigned char bInterfaceSubClass; unsigned char bInterfaceSubClass;
unsigned char bInterfaceProtocol; unsigned char bInterfaceProtocol;
unsigned char iInterface; unsigned char iInterface;
unsigned char no_of_ep;
unsigned char num_altsetting;
unsigned char act_altsetting;
unsigned char no_of_ep;
unsigned char num_altsetting;
unsigned char act_altsetting;
struct usb_endpoint_descriptor ep_desc[USB_MAXENDPOINTS]; struct usb_endpoint_descriptor ep_desc[USB_MAXENDPOINTS];
} __attribute__ ((packed)); } __attribute__ ((packed));
/* Configuration descriptor information.. */ /* Configuration descriptor information.. */
struct usb_config_descriptor { struct usb_config_descriptor {
unsigned char bLength; unsigned char bLength;
unsigned char bDescriptorType; unsigned char bDescriptorType;
unsigned short wTotalLength; unsigned short wTotalLength;
unsigned char bNumInterfaces; unsigned char bNumInterfaces;
unsigned char bConfigurationValue; unsigned char bConfigurationValue;
unsigned char iConfiguration; unsigned char iConfiguration;
unsigned char bmAttributes; unsigned char bmAttributes;
unsigned char MaxPower; unsigned char MaxPower;
unsigned char no_of_if; /* number of interfaces */ unsigned char no_of_if; /* number of interfaces */
struct usb_interface_descriptor if_desc[USB_MAXINTERFACES]; struct usb_interface_descriptor if_desc[USB_MAXINTERFACES];
} __attribute__ ((packed)); } __attribute__ ((packed));
@ -138,19 +137,20 @@ enum {
}; };
struct usb_device { struct usb_device {
int devnum; /* Device number on USB bus */ int devnum; /* Device number on USB bus */
int slow; /* Slow device? */ int slow; /* Slow device? */
char mf[32]; /* manufacturer */ char mf[32]; /* manufacturer */
char prod[32]; /* product */ char prod[32]; /* product */
char serial[32]; /* serial number */ char serial[32]; /* serial number */
/* Maximum packet size; one of: PACKET_SIZE_* */ /* Maximum packet size; one of: PACKET_SIZE_* */
int maxpacketsize; int maxpacketsize;
/* one bit for each endpoint ([0] = IN, [1] = OUT) */ /* one bit for each endpoint ([0] = IN, [1] = OUT) */
unsigned int toggle[2]; unsigned int toggle[2];
/* endpoint halts; one bit per endpoint # & direction; */ /* endpoint halts; one bit per endpoint # & direction;
* [0] = IN, [1] = OUT
*/
unsigned int halted[2]; unsigned int halted[2];
/* [0] = IN, [1] = OUT */
int epmaxpacketin[16]; /* INput endpoint specific maximums */ int epmaxpacketin[16]; /* INput endpoint specific maximums */
int epmaxpacketout[16]; /* OUTput endpoint specific maximums */ int epmaxpacketout[16]; /* OUTput endpoint specific maximums */
@ -180,21 +180,22 @@ struct usb_device {
*/ */
#if defined(CONFIG_USB_UHCI) || defined(CONFIG_USB_OHCI) || \ #if defined(CONFIG_USB_UHCI) || defined(CONFIG_USB_OHCI) || \
defined(CONFIG_USB_OHCI_NEW) || defined (CONFIG_USB_SL811HS) || \ defined(CONFIG_USB_OHCI_NEW) || defined(CONFIG_USB_SL811HS) || \
defined(CONFIG_USB_ISP116X_HCD) || defined(CONFIG_USB_R8A66597_HCD) defined(CONFIG_USB_ISP116X_HCD) || defined(CONFIG_USB_R8A66597_HCD)
int usb_lowlevel_init(void); int usb_lowlevel_init(void);
int usb_lowlevel_stop(void); int usb_lowlevel_stop(void);
int submit_bulk_msg(struct usb_device *dev, unsigned long pipe, void *buffer,int transfer_len); int submit_bulk_msg(struct usb_device *dev, unsigned long pipe,
void *buffer, int transfer_len);
int submit_control_msg(struct usb_device *dev, unsigned long pipe, void *buffer, int submit_control_msg(struct usb_device *dev, unsigned long pipe, void *buffer,
int transfer_len,struct devrequest *setup); int transfer_len, struct devrequest *setup);
int submit_int_msg(struct usb_device *dev, unsigned long pipe, void *buffer, int submit_int_msg(struct usb_device *dev, unsigned long pipe, void *buffer,
int transfer_len, int interval); int transfer_len, int interval);
void usb_event_poll(void); void usb_event_poll(void);
/* Defines */ /* Defines */
#define USB_UHCI_VEND_ID 0x8086 #define USB_UHCI_VEND_ID 0x8086
#define USB_UHCI_DEV_ID 0x7112 #define USB_UHCI_DEV_ID 0x7112
#else #else
#error USB Lowlevel not defined #error USB Lowlevel not defined
@ -221,8 +222,9 @@ int usb_stop(void); /* stop the USB Controller */
int usb_set_protocol(struct usb_device *dev, int ifnum, int protocol); int usb_set_protocol(struct usb_device *dev, int ifnum, int protocol);
int usb_set_idle(struct usb_device *dev, int ifnum, int duration, int report_id); int usb_set_idle(struct usb_device *dev, int ifnum, int duration,
struct usb_device * usb_get_dev_index(int index); int report_id);
struct usb_device *usb_get_dev_index(int index);
int usb_control_msg(struct usb_device *dev, unsigned int pipe, int usb_control_msg(struct usb_device *dev, unsigned int pipe,
unsigned char request, unsigned char requesttype, unsigned char request, unsigned char requesttype,
unsigned short value, unsigned short index, unsigned short value, unsigned short index,
@ -230,14 +232,17 @@ int usb_control_msg(struct usb_device *dev, unsigned int pipe,
int usb_bulk_msg(struct usb_device *dev, unsigned int pipe, int usb_bulk_msg(struct usb_device *dev, unsigned int pipe,
void *data, int len, int *actual_length, int timeout); void *data, int len, int *actual_length, int timeout);
int usb_submit_int_msg(struct usb_device *dev, unsigned long pipe, int usb_submit_int_msg(struct usb_device *dev, unsigned long pipe,
void *buffer,int transfer_len, int interval); void *buffer, int transfer_len, int interval);
void usb_disable_asynch(int disable); void usb_disable_asynch(int disable);
int usb_maxpacket(struct usb_device *dev,unsigned long pipe); int usb_maxpacket(struct usb_device *dev, unsigned long pipe);
void __inline__ wait_ms(unsigned long ms); inline void wait_ms(unsigned long ms);
int usb_get_configuration_no(struct usb_device *dev,unsigned char *buffer,int cfgno); int usb_get_configuration_no(struct usb_device *dev, unsigned char *buffer,
int usb_get_report(struct usb_device *dev, int ifnum, unsigned char type, unsigned char id, void *buf, int size); int cfgno);
int usb_get_report(struct usb_device *dev, int ifnum, unsigned char type,
unsigned char id, void *buf, int size);
int usb_get_class_descriptor(struct usb_device *dev, int ifnum, int usb_get_class_descriptor(struct usb_device *dev, int ifnum,
unsigned char type, unsigned char id, void *buf, int size); unsigned char type, unsigned char id, void *buf,
int size);
int usb_clear_halt(struct usb_device *dev, int pipe); int usb_clear_halt(struct usb_device *dev, int pipe);
int usb_string(struct usb_device *dev, int index, char *buf, size_t size); int usb_string(struct usb_device *dev, int index, char *buf, size_t size);
int usb_set_interface(struct usb_device *dev, int interface, int alternate); int usb_set_interface(struct usb_device *dev, int interface, int alternate);
@ -247,7 +252,7 @@ int usb_set_interface(struct usb_device *dev, int interface, int alternate);
#define __swap_16(x) \ #define __swap_16(x) \
({ unsigned short x_ = (unsigned short)x; \ ({ unsigned short x_ = (unsigned short)x; \
(unsigned short)( \ (unsigned short)( \
((x_ & 0x00FFU) << 8) | ((x_ & 0xFF00U) >> 8) ); \ ((x_ & 0x00FFU) << 8) | ((x_ & 0xFF00U) >> 8)); \
}) })
#define __swap_32(x) \ #define __swap_32(x) \
({ unsigned long x_ = (unsigned long)x; \ ({ unsigned long x_ = (unsigned long)x; \
@ -255,7 +260,7 @@ int usb_set_interface(struct usb_device *dev, int interface, int alternate);
((x_ & 0x000000FFUL) << 24) | \ ((x_ & 0x000000FFUL) << 24) | \
((x_ & 0x0000FF00UL) << 8) | \ ((x_ & 0x0000FF00UL) << 8) | \
((x_ & 0x00FF0000UL) >> 8) | \ ((x_ & 0x00FF0000UL) >> 8) | \
((x_ & 0xFF000000UL) >> 24) ); \ ((x_ & 0xFF000000UL) >> 24)); \
}) })
#ifdef LITTLEENDIAN #ifdef LITTLEENDIAN
@ -286,12 +291,14 @@ int usb_set_interface(struct usb_device *dev, int interface, int alternate);
* unsigned int. The encoding is: * unsigned int. The encoding is:
* *
* - max size: bits 0-1 (00 = 8, 01 = 16, 10 = 32, 11 = 64) * - max size: bits 0-1 (00 = 8, 01 = 16, 10 = 32, 11 = 64)
* - direction: bit 7 (0 = Host-to-Device [Out], 1 = Device-to-Host [In]) * - direction: bit 7 (0 = Host-to-Device [Out],
* (1 = Device-to-Host [In])
* - device: bits 8-14 * - device: bits 8-14
* - endpoint: bits 15-18 * - endpoint: bits 15-18
* - Data0/1: bit 19 * - Data0/1: bit 19
* - speed: bit 26 (0 = Full, 1 = Low Speed) * - speed: bit 26 (0 = Full, 1 = Low Speed)
* - pipe type: bits 30-31 (00 = isochronous, 01 = interrupt, 10 = control, 11 = bulk) * - pipe type: bits 30-31 (00 = isochronous, 01 = interrupt,
* 10 = control, 11 = bulk)
* *
* Why? Because it's arbitrary, and whatever encoding we select is really * Why? Because it's arbitrary, and whatever encoding we select is really
* up to us. This one happens to share a lot of bit positions with the UHCI * up to us. This one happens to share a lot of bit positions with the UHCI
@ -300,24 +307,42 @@ int usb_set_interface(struct usb_device *dev, int interface, int alternate);
*/ */
/* Create various pipes... */ /* Create various pipes... */
#define create_pipe(dev,endpoint) \ #define create_pipe(dev,endpoint) \
(((dev)->devnum << 8) | (endpoint << 15) | ((dev)->slow << 26) | (dev)->maxpacketsize) (((dev)->devnum << 8) | (endpoint << 15) | \
#define default_pipe(dev) ((dev)->slow <<26) ((dev)->slow << 26) | (dev)->maxpacketsize)
#define default_pipe(dev) ((dev)->slow << 26)
#define usb_sndctrlpipe(dev,endpoint) ((PIPE_CONTROL << 30) | create_pipe(dev,endpoint)) #define usb_sndctrlpipe(dev, endpoint) ((PIPE_CONTROL << 30) | \
#define usb_rcvctrlpipe(dev,endpoint) ((PIPE_CONTROL << 30) | create_pipe(dev,endpoint) | USB_DIR_IN) create_pipe(dev, endpoint))
#define usb_sndisocpipe(dev,endpoint) ((PIPE_ISOCHRONOUS << 30) | create_pipe(dev,endpoint)) #define usb_rcvctrlpipe(dev, endpoint) ((PIPE_CONTROL << 30) | \
#define usb_rcvisocpipe(dev,endpoint) ((PIPE_ISOCHRONOUS << 30) | create_pipe(dev,endpoint) | USB_DIR_IN) create_pipe(dev, endpoint) | \
#define usb_sndbulkpipe(dev,endpoint) ((PIPE_BULK << 30) | create_pipe(dev,endpoint)) USB_DIR_IN)
#define usb_rcvbulkpipe(dev,endpoint) ((PIPE_BULK << 30) | create_pipe(dev,endpoint) | USB_DIR_IN) #define usb_sndisocpipe(dev, endpoint) ((PIPE_ISOCHRONOUS << 30) | \
#define usb_sndintpipe(dev,endpoint) ((PIPE_INTERRUPT << 30) | create_pipe(dev,endpoint)) create_pipe(dev, endpoint))
#define usb_rcvintpipe(dev,endpoint) ((PIPE_INTERRUPT << 30) | create_pipe(dev,endpoint) | USB_DIR_IN) #define usb_rcvisocpipe(dev, endpoint) ((PIPE_ISOCHRONOUS << 30) | \
#define usb_snddefctrl(dev) ((PIPE_CONTROL << 30) | default_pipe(dev)) create_pipe(dev, endpoint) | \
#define usb_rcvdefctrl(dev) ((PIPE_CONTROL << 30) | default_pipe(dev) | USB_DIR_IN) USB_DIR_IN)
#define usb_sndbulkpipe(dev, endpoint) ((PIPE_BULK << 30) | \
create_pipe(dev, endpoint))
#define usb_rcvbulkpipe(dev, endpoint) ((PIPE_BULK << 30) | \
create_pipe(dev, endpoint) | \
USB_DIR_IN)
#define usb_sndintpipe(dev, endpoint) ((PIPE_INTERRUPT << 30) | \
create_pipe(dev, endpoint))
#define usb_rcvintpipe(dev, endpoint) ((PIPE_INTERRUPT << 30) | \
create_pipe(dev, endpoint) | \
USB_DIR_IN)
#define usb_snddefctrl(dev) ((PIPE_CONTROL << 30) | \
default_pipe(dev))
#define usb_rcvdefctrl(dev) ((PIPE_CONTROL << 30) | \
default_pipe(dev) | \
USB_DIR_IN)
/* The D0/D1 toggle bits */ /* The D0/D1 toggle bits */
#define usb_gettoggle(dev, ep, out) (((dev)->toggle[out] >> ep) & 1) #define usb_gettoggle(dev, ep, out) (((dev)->toggle[out] >> ep) & 1)
#define usb_dotoggle(dev, ep, out) ((dev)->toggle[out] ^= (1 << ep)) #define usb_dotoggle(dev, ep, out) ((dev)->toggle[out] ^= (1 << ep))
#define usb_settoggle(dev, ep, out, bit) ((dev)->toggle[out] = ((dev)->toggle[out] & ~(1 << ep)) | ((bit) << ep)) #define usb_settoggle(dev, ep, out, bit) ((dev)->toggle[out] = \
((dev)->toggle[out] & \
~(1 << ep)) | ((bit) << ep))
/* Endpoint halt control/status */ /* Endpoint halt control/status */
#define usb_endpoint_out(ep_dir) (((ep_dir >> 7) & 1) ^ 1) #define usb_endpoint_out(ep_dir) (((ep_dir >> 7) & 1) ^ 1)
@ -325,7 +350,8 @@ int usb_set_interface(struct usb_device *dev, int interface, int alternate);
#define usb_endpoint_running(dev, ep, out) ((dev)->halted[out] &= ~(1 << (ep))) #define usb_endpoint_running(dev, ep, out) ((dev)->halted[out] &= ~(1 << (ep)))
#define usb_endpoint_halted(dev, ep, out) ((dev)->halted[out] & (1 << (ep))) #define usb_endpoint_halted(dev, ep, out) ((dev)->halted[out] & (1 << (ep)))
#define usb_packetid(pipe) (((pipe) & USB_DIR_IN) ? USB_PID_IN : USB_PID_OUT) #define usb_packetid(pipe) (((pipe) & USB_DIR_IN) ? USB_PID_IN : \
USB_PID_OUT)
#define usb_pipeout(pipe) ((((pipe) >> 7) & 1) ^ 1) #define usb_pipeout(pipe) ((((pipe) >> 7) & 1) ^ 1)
#define usb_pipein(pipe) (((pipe) >> 7) & 1) #define usb_pipein(pipe) (((pipe) >> 7) & 1)
@ -365,7 +391,7 @@ struct usb_hub_descriptor {
unsigned char bHubContrCurrent; unsigned char bHubContrCurrent;
unsigned char DeviceRemovable[(USB_MAXCHILDREN+1+7)/8]; unsigned char DeviceRemovable[(USB_MAXCHILDREN+1+7)/8];
unsigned char PortPowerCtrlMask[(USB_MAXCHILDREN+1+7)/8]; unsigned char PortPowerCtrlMask[(USB_MAXCHILDREN+1+7)/8];
/* DeviceRemovable and PortPwrCtrlMask want to be variable-length /* DeviceRemovable and PortPwrCtrlMask want to be variable-length
bitmaps that hold max 255 entries. (bit0 is ignored) */ bitmaps that hold max 255 entries. (bit0 is ignored) */
} __attribute__ ((packed)); } __attribute__ ((packed));