1 /* 2 * 3 * Most of this source has been derived from the Linux USB 4 * project: 5 * (C) Copyright Linus Torvalds 1999 6 * (C) Copyright Johannes Erdfelt 1999-2001 7 * (C) Copyright Andreas Gal 1999 8 * (C) Copyright Gregory P. Smith 1999 9 * (C) Copyright Deti Fliegl 1999 (new USB architecture) 10 * (C) Copyright Randy Dunlap 2000 11 * (C) Copyright David Brownell 2000 (kernel hotplug, usb_device_id) 12 * (C) Copyright Yggdrasil Computing, Inc. 2000 13 * (usb_device_id matching changes by Adam J. Richter) 14 * 15 * Adapted for U-Boot: 16 * (C) Copyright 2001 Denis Peter, MPL AG Switzerland 17 * 18 * See file CREDITS for list of people who contributed to this 19 * project. 20 * 21 * This program is free software; you can redistribute it and/or 22 * modify it under the terms of the GNU General Public License as 23 * published by the Free Software Foundation; either version 2 of 24 * the License, or (at your option) any later version. 25 * 26 * This program is distributed in the hope that it will be useful, 27 * but WITHOUT ANY WARRANTY; without even the implied warranty of 28 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 29 * GNU General Public License for more details. 30 * 31 * You should have received a copy of the GNU General Public License 32 * along with this program; if not, write to the Free Software 33 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, 34 * MA 02111-1307 USA 35 * 36 */ 37 38 /* 39 * How it works: 40 * 41 * Since this is a bootloader, the devices will not be automatic 42 * (re)configured on hotplug, but after a restart of the USB the 43 * device should work. 44 * 45 * For each transfer (except "Interrupt") we wait for completion. 46 */ 47 #include <common.h> 48 #include <command.h> 49 #include <asm/processor.h> 50 #include <linux/ctype.h> 51 #include <asm/byteorder.h> 52 53 #include <usb.h> 54 #ifdef CONFIG_4xx 55 #include <asm/4xx_pci.h> 56 #endif 57 58 #ifdef DEBUG 59 #define USB_DEBUG 60 #define USB_HUB_DEBUG 61 #endif 62 63 #ifdef USB_DEBUG 64 #define USB_PRINTF(fmt, args...) printf(fmt , ##args) 65 #else 66 #define USB_PRINTF(fmt, args...) 67 #endif 68 69 #define USB_BUFSIZ 512 70 71 static struct usb_device usb_dev[USB_MAX_DEVICE]; 72 static int dev_index; 73 static int running; 74 static int asynch_allowed; 75 static struct devrequest setup_packet; 76 77 char usb_started; /* flag for the started/stopped USB status */ 78 79 /********************************************************************** 80 * some forward declerations... 81 */ 82 void usb_scan_devices(void); 83 84 int usb_hub_probe(struct usb_device *dev, int ifnum); 85 void usb_hub_reset(void); 86 static int hub_port_reset(struct usb_device *dev, int port, 87 unsigned short *portstat); 88 89 /*********************************************************************** 90 * wait_ms 91 */ 92 93 inline void wait_ms(unsigned long ms) 94 { 95 while (ms-- > 0) 96 udelay(1000); 97 } 98 99 /*************************************************************************** 100 * Init USB Device 101 */ 102 103 int usb_init(void) 104 { 105 int result; 106 107 running = 0; 108 dev_index = 0; 109 asynch_allowed = 1; 110 usb_hub_reset(); 111 /* init low_level USB */ 112 printf("USB: "); 113 result = usb_lowlevel_init(); 114 /* if lowlevel init is OK, scan the bus for devices 115 * i.e. search HUBs and configure them */ 116 if (result == 0) { 117 printf("scanning bus for devices... "); 118 running = 1; 119 usb_scan_devices(); 120 usb_started = 1; 121 return 0; 122 } else { 123 printf("Error, couldn't init Lowlevel part\n"); 124 usb_started = 0; 125 return -1; 126 } 127 } 128 129 /****************************************************************************** 130 * Stop USB this stops the LowLevel Part and deregisters USB devices. 131 */ 132 int usb_stop(void) 133 { 134 int res = 0; 135 136 if (usb_started) { 137 asynch_allowed = 1; 138 usb_started = 0; 139 usb_hub_reset(); 140 res = usb_lowlevel_stop(); 141 } 142 return res; 143 } 144 145 /* 146 * disables the asynch behaviour of the control message. This is used for data 147 * transfers that uses the exclusiv access to the control and bulk messages. 148 */ 149 void usb_disable_asynch(int disable) 150 { 151 asynch_allowed = !disable; 152 } 153 154 155 /*------------------------------------------------------------------- 156 * Message wrappers. 157 * 158 */ 159 160 /* 161 * submits an Interrupt Message 162 */ 163 int usb_submit_int_msg(struct usb_device *dev, unsigned long pipe, 164 void *buffer, int transfer_len, int interval) 165 { 166 return submit_int_msg(dev, pipe, buffer, transfer_len, interval); 167 } 168 169 /* 170 * submits a control message and waits for comletion (at least timeout * 1ms) 171 * If timeout is 0, we don't wait for completion (used as example to set and 172 * clear keyboards LEDs). For data transfers, (storage transfers) we don't 173 * allow control messages with 0 timeout, by previousely resetting the flag 174 * asynch_allowed (usb_disable_asynch(1)). 175 * returns the transfered length if OK or -1 if error. The transfered length 176 * and the current status are stored in the dev->act_len and dev->status. 177 */ 178 int usb_control_msg(struct usb_device *dev, unsigned int pipe, 179 unsigned char request, unsigned char requesttype, 180 unsigned short value, unsigned short index, 181 void *data, unsigned short size, int timeout) 182 { 183 if ((timeout == 0) && (!asynch_allowed)) { 184 /* request for a asynch control pipe is not allowed */ 185 return -1; 186 } 187 188 /* set setup command */ 189 setup_packet.requesttype = requesttype; 190 setup_packet.request = request; 191 setup_packet.value = cpu_to_le16(value); 192 setup_packet.index = cpu_to_le16(index); 193 setup_packet.length = cpu_to_le16(size); 194 USB_PRINTF("usb_control_msg: request: 0x%X, requesttype: 0x%X, " \ 195 "value 0x%X index 0x%X length 0x%X\n", 196 request, requesttype, value, index, size); 197 dev->status = USB_ST_NOT_PROC; /*not yet processed */ 198 199 submit_control_msg(dev, pipe, data, size, &setup_packet); 200 if (timeout == 0) 201 return (int)size; 202 203 /* 204 * Wait for status to update until timeout expires, USB driver 205 * interrupt handler may set the status when the USB operation has 206 * been completed. 207 */ 208 while (timeout--) { 209 if (!((volatile unsigned long)dev->status & USB_ST_NOT_PROC)) 210 break; 211 wait_ms(1); 212 } 213 if (dev->status) 214 return -1; 215 216 return dev->act_len; 217 218 } 219 220 /*------------------------------------------------------------------- 221 * submits bulk message, and waits for completion. returns 0 if Ok or 222 * -1 if Error. 223 * synchronous behavior 224 */ 225 int usb_bulk_msg(struct usb_device *dev, unsigned int pipe, 226 void *data, int len, int *actual_length, int timeout) 227 { 228 if (len < 0) 229 return -1; 230 dev->status = USB_ST_NOT_PROC; /*not yet processed */ 231 submit_bulk_msg(dev, pipe, data, len); 232 while (timeout--) { 233 if (!((volatile unsigned long)dev->status & USB_ST_NOT_PROC)) 234 break; 235 wait_ms(1); 236 } 237 *actual_length = dev->act_len; 238 if (dev->status == 0) 239 return 0; 240 else 241 return -1; 242 } 243 244 245 /*------------------------------------------------------------------- 246 * Max Packet stuff 247 */ 248 249 /* 250 * returns the max packet size, depending on the pipe direction and 251 * the configurations values 252 */ 253 int usb_maxpacket(struct usb_device *dev, unsigned long pipe) 254 { 255 /* direction is out -> use emaxpacket out */ 256 if ((pipe & USB_DIR_IN) == 0) 257 return dev->epmaxpacketout[((pipe>>15) & 0xf)]; 258 else 259 return dev->epmaxpacketin[((pipe>>15) & 0xf)]; 260 } 261 262 /* The routine usb_set_maxpacket_ep() is extracted from the loop of routine 263 * usb_set_maxpacket(), because the optimizer of GCC 4.x chokes on this routine 264 * when it is inlined in 1 single routine. What happens is that the register r3 265 * is used as loop-count 'i', but gets overwritten later on. 266 * This is clearly a compiler bug, but it is easier to workaround it here than 267 * to update the compiler (Occurs with at least several GCC 4.{1,2},x 268 * CodeSourcery compilers like e.g. 2007q3, 2008q1, 2008q3 lite editions on ARM) 269 */ 270 static void __attribute__((noinline)) 271 usb_set_maxpacket_ep(struct usb_device *dev, struct usb_endpoint_descriptor *ep) 272 { 273 int b; 274 275 b = ep->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK; 276 277 if ((ep->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) == 278 USB_ENDPOINT_XFER_CONTROL) { 279 /* Control => bidirectional */ 280 dev->epmaxpacketout[b] = ep->wMaxPacketSize; 281 dev->epmaxpacketin[b] = ep->wMaxPacketSize; 282 USB_PRINTF("##Control EP epmaxpacketout/in[%d] = %d\n", 283 b, dev->epmaxpacketin[b]); 284 } else { 285 if ((ep->bEndpointAddress & 0x80) == 0) { 286 /* OUT Endpoint */ 287 if (ep->wMaxPacketSize > dev->epmaxpacketout[b]) { 288 dev->epmaxpacketout[b] = ep->wMaxPacketSize; 289 USB_PRINTF("##EP epmaxpacketout[%d] = %d\n", 290 b, dev->epmaxpacketout[b]); 291 } 292 } else { 293 /* IN Endpoint */ 294 if (ep->wMaxPacketSize > dev->epmaxpacketin[b]) { 295 dev->epmaxpacketin[b] = ep->wMaxPacketSize; 296 USB_PRINTF("##EP epmaxpacketin[%d] = %d\n", 297 b, dev->epmaxpacketin[b]); 298 } 299 } /* if out */ 300 } /* if control */ 301 } 302 303 /* 304 * set the max packed value of all endpoints in the given configuration 305 */ 306 int usb_set_maxpacket(struct usb_device *dev) 307 { 308 int i, ii; 309 310 for (i = 0; i < dev->config.desc.bNumInterfaces; i++) 311 for (ii = 0; ii < dev->config.if_desc[i].desc.bNumEndpoints; ii++) 312 usb_set_maxpacket_ep(dev, 313 &dev->config.if_desc[i].ep_desc[ii]); 314 315 return 0; 316 } 317 318 /******************************************************************************* 319 * Parse the config, located in buffer, and fills the dev->config structure. 320 * Note that all little/big endian swapping are done automatically. 321 */ 322 int usb_parse_config(struct usb_device *dev, unsigned char *buffer, int cfgno) 323 { 324 struct usb_descriptor_header *head; 325 int index, ifno, epno, curr_if_num; 326 int i; 327 unsigned char *ch; 328 329 ifno = -1; 330 epno = -1; 331 curr_if_num = -1; 332 333 dev->configno = cfgno; 334 head = (struct usb_descriptor_header *) &buffer[0]; 335 if (head->bDescriptorType != USB_DT_CONFIG) { 336 printf(" ERROR: NOT USB_CONFIG_DESC %x\n", 337 head->bDescriptorType); 338 return -1; 339 } 340 memcpy(&dev->config, buffer, buffer[0]); 341 le16_to_cpus(&(dev->config.desc.wTotalLength)); 342 dev->config.no_of_if = 0; 343 344 index = dev->config.desc.bLength; 345 /* Ok the first entry must be a configuration entry, 346 * now process the others */ 347 head = (struct usb_descriptor_header *) &buffer[index]; 348 while (index + 1 < dev->config.desc.wTotalLength) { 349 switch (head->bDescriptorType) { 350 case USB_DT_INTERFACE: 351 if (((struct usb_interface_descriptor *) \ 352 &buffer[index])->bInterfaceNumber != curr_if_num) { 353 /* this is a new interface, copy new desc */ 354 ifno = dev->config.no_of_if; 355 dev->config.no_of_if++; 356 memcpy(&dev->config.if_desc[ifno], 357 &buffer[index], buffer[index]); 358 dev->config.if_desc[ifno].no_of_ep = 0; 359 dev->config.if_desc[ifno].num_altsetting = 1; 360 curr_if_num = 361 dev->config.if_desc[ifno].desc.bInterfaceNumber; 362 } else { 363 /* found alternate setting for the interface */ 364 dev->config.if_desc[ifno].num_altsetting++; 365 } 366 break; 367 case USB_DT_ENDPOINT: 368 epno = dev->config.if_desc[ifno].no_of_ep; 369 /* found an endpoint */ 370 dev->config.if_desc[ifno].no_of_ep++; 371 memcpy(&dev->config.if_desc[ifno].ep_desc[epno], 372 &buffer[index], buffer[index]); 373 le16_to_cpus(&(dev->config.if_desc[ifno].ep_desc[epno].\ 374 wMaxPacketSize)); 375 USB_PRINTF("if %d, ep %d\n", ifno, epno); 376 break; 377 default: 378 if (head->bLength == 0) 379 return 1; 380 381 USB_PRINTF("unknown Description Type : %x\n", 382 head->bDescriptorType); 383 384 { 385 ch = (unsigned char *)head; 386 for (i = 0; i < head->bLength; i++) 387 USB_PRINTF("%02X ", *ch++); 388 USB_PRINTF("\n\n\n"); 389 } 390 break; 391 } 392 index += head->bLength; 393 head = (struct usb_descriptor_header *)&buffer[index]; 394 } 395 return 1; 396 } 397 398 /*********************************************************************** 399 * Clears an endpoint 400 * endp: endpoint number in bits 0-3; 401 * direction flag in bit 7 (1 = IN, 0 = OUT) 402 */ 403 int usb_clear_halt(struct usb_device *dev, int pipe) 404 { 405 int result; 406 int endp = usb_pipeendpoint(pipe)|(usb_pipein(pipe)<<7); 407 408 result = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), 409 USB_REQ_CLEAR_FEATURE, USB_RECIP_ENDPOINT, 0, 410 endp, NULL, 0, USB_CNTL_TIMEOUT * 3); 411 412 /* don't clear if failed */ 413 if (result < 0) 414 return result; 415 416 /* 417 * NOTE: we do not get status and verify reset was successful 418 * as some devices are reported to lock up upon this check.. 419 */ 420 421 usb_endpoint_running(dev, usb_pipeendpoint(pipe), usb_pipeout(pipe)); 422 423 /* toggle is reset on clear */ 424 usb_settoggle(dev, usb_pipeendpoint(pipe), usb_pipeout(pipe), 0); 425 return 0; 426 } 427 428 429 /********************************************************************** 430 * get_descriptor type 431 */ 432 int usb_get_descriptor(struct usb_device *dev, unsigned char type, 433 unsigned char index, void *buf, int size) 434 { 435 int res; 436 res = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), 437 USB_REQ_GET_DESCRIPTOR, USB_DIR_IN, 438 (type << 8) + index, 0, 439 buf, size, USB_CNTL_TIMEOUT); 440 return res; 441 } 442 443 /********************************************************************** 444 * gets configuration cfgno and store it in the buffer 445 */ 446 int usb_get_configuration_no(struct usb_device *dev, 447 unsigned char *buffer, int cfgno) 448 { 449 int result; 450 unsigned int tmp; 451 struct usb_configuration_descriptor *config; 452 453 config = (struct usb_configuration_descriptor *)&buffer[0]; 454 result = usb_get_descriptor(dev, USB_DT_CONFIG, cfgno, buffer, 9); 455 if (result < 9) { 456 if (result < 0) 457 printf("unable to get descriptor, error %lX\n", 458 dev->status); 459 else 460 printf("config descriptor too short " \ 461 "(expected %i, got %i)\n", 9, result); 462 return -1; 463 } 464 tmp = le16_to_cpu(config->wTotalLength); 465 466 if (tmp > USB_BUFSIZ) { 467 USB_PRINTF("usb_get_configuration_no: failed to get " \ 468 "descriptor - too long: %d\n", tmp); 469 return -1; 470 } 471 472 result = usb_get_descriptor(dev, USB_DT_CONFIG, cfgno, buffer, tmp); 473 USB_PRINTF("get_conf_no %d Result %d, wLength %d\n", 474 cfgno, result, tmp); 475 return result; 476 } 477 478 /******************************************************************** 479 * set address of a device to the value in dev->devnum. 480 * This can only be done by addressing the device via the default address (0) 481 */ 482 int usb_set_address(struct usb_device *dev) 483 { 484 int res; 485 486 USB_PRINTF("set address %d\n", dev->devnum); 487 res = usb_control_msg(dev, usb_snddefctrl(dev), 488 USB_REQ_SET_ADDRESS, 0, 489 (dev->devnum), 0, 490 NULL, 0, USB_CNTL_TIMEOUT); 491 return res; 492 } 493 494 /******************************************************************** 495 * set interface number to interface 496 */ 497 int usb_set_interface(struct usb_device *dev, int interface, int alternate) 498 { 499 struct usb_interface *if_face = NULL; 500 int ret, i; 501 502 for (i = 0; i < dev->config.desc.bNumInterfaces; i++) { 503 if (dev->config.if_desc[i].desc.bInterfaceNumber == interface) { 504 if_face = &dev->config.if_desc[i]; 505 break; 506 } 507 } 508 if (!if_face) { 509 printf("selecting invalid interface %d", interface); 510 return -1; 511 } 512 /* 513 * We should return now for devices with only one alternate setting. 514 * According to 9.4.10 of the Universal Serial Bus Specification 515 * Revision 2.0 such devices can return with a STALL. This results in 516 * some USB sticks timeouting during initialization and then being 517 * unusable in U-Boot. 518 */ 519 if (if_face->num_altsetting == 1) 520 return 0; 521 522 ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), 523 USB_REQ_SET_INTERFACE, USB_RECIP_INTERFACE, 524 alternate, interface, NULL, 0, 525 USB_CNTL_TIMEOUT * 5); 526 if (ret < 0) 527 return ret; 528 529 return 0; 530 } 531 532 /******************************************************************** 533 * set configuration number to configuration 534 */ 535 int usb_set_configuration(struct usb_device *dev, int configuration) 536 { 537 int res; 538 USB_PRINTF("set configuration %d\n", configuration); 539 /* set setup command */ 540 res = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), 541 USB_REQ_SET_CONFIGURATION, 0, 542 configuration, 0, 543 NULL, 0, USB_CNTL_TIMEOUT); 544 if (res == 0) { 545 dev->toggle[0] = 0; 546 dev->toggle[1] = 0; 547 return 0; 548 } else 549 return -1; 550 } 551 552 /******************************************************************** 553 * set protocol to protocol 554 */ 555 int usb_set_protocol(struct usb_device *dev, int ifnum, int protocol) 556 { 557 return usb_control_msg(dev, usb_sndctrlpipe(dev, 0), 558 USB_REQ_SET_PROTOCOL, USB_TYPE_CLASS | USB_RECIP_INTERFACE, 559 protocol, ifnum, NULL, 0, USB_CNTL_TIMEOUT); 560 } 561 562 /******************************************************************** 563 * set idle 564 */ 565 int usb_set_idle(struct usb_device *dev, int ifnum, int duration, int report_id) 566 { 567 return usb_control_msg(dev, usb_sndctrlpipe(dev, 0), 568 USB_REQ_SET_IDLE, USB_TYPE_CLASS | USB_RECIP_INTERFACE, 569 (duration << 8) | report_id, ifnum, NULL, 0, USB_CNTL_TIMEOUT); 570 } 571 572 /******************************************************************** 573 * get report 574 */ 575 int usb_get_report(struct usb_device *dev, int ifnum, unsigned char type, 576 unsigned char id, void *buf, int size) 577 { 578 return usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), 579 USB_REQ_GET_REPORT, 580 USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE, 581 (type << 8) + id, ifnum, buf, size, USB_CNTL_TIMEOUT); 582 } 583 584 /******************************************************************** 585 * get class descriptor 586 */ 587 int usb_get_class_descriptor(struct usb_device *dev, int ifnum, 588 unsigned char type, unsigned char id, void *buf, int size) 589 { 590 return usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), 591 USB_REQ_GET_DESCRIPTOR, USB_RECIP_INTERFACE | USB_DIR_IN, 592 (type << 8) + id, ifnum, buf, size, USB_CNTL_TIMEOUT); 593 } 594 595 /******************************************************************** 596 * get string index in buffer 597 */ 598 int usb_get_string(struct usb_device *dev, unsigned short langid, 599 unsigned char index, void *buf, int size) 600 { 601 int i; 602 int result; 603 604 for (i = 0; i < 3; ++i) { 605 /* some devices are flaky */ 606 result = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), 607 USB_REQ_GET_DESCRIPTOR, USB_DIR_IN, 608 (USB_DT_STRING << 8) + index, langid, buf, size, 609 USB_CNTL_TIMEOUT); 610 611 if (result > 0) 612 break; 613 } 614 615 return result; 616 } 617 618 619 static void usb_try_string_workarounds(unsigned char *buf, int *length) 620 { 621 int newlength, oldlength = *length; 622 623 for (newlength = 2; newlength + 1 < oldlength; newlength += 2) 624 if (!isprint(buf[newlength]) || buf[newlength + 1]) 625 break; 626 627 if (newlength > 2) { 628 buf[0] = newlength; 629 *length = newlength; 630 } 631 } 632 633 634 static int usb_string_sub(struct usb_device *dev, unsigned int langid, 635 unsigned int index, unsigned char *buf) 636 { 637 int rc; 638 639 /* Try to read the string descriptor by asking for the maximum 640 * possible number of bytes */ 641 rc = usb_get_string(dev, langid, index, buf, 255); 642 643 /* If that failed try to read the descriptor length, then 644 * ask for just that many bytes */ 645 if (rc < 2) { 646 rc = usb_get_string(dev, langid, index, buf, 2); 647 if (rc == 2) 648 rc = usb_get_string(dev, langid, index, buf, buf[0]); 649 } 650 651 if (rc >= 2) { 652 if (!buf[0] && !buf[1]) 653 usb_try_string_workarounds(buf, &rc); 654 655 /* There might be extra junk at the end of the descriptor */ 656 if (buf[0] < rc) 657 rc = buf[0]; 658 659 rc = rc - (rc & 1); /* force a multiple of two */ 660 } 661 662 if (rc < 2) 663 rc = -1; 664 665 return rc; 666 } 667 668 669 /******************************************************************** 670 * usb_string: 671 * Get string index and translate it to ascii. 672 * returns string length (> 0) or error (< 0) 673 */ 674 int usb_string(struct usb_device *dev, int index, char *buf, size_t size) 675 { 676 unsigned char mybuf[USB_BUFSIZ]; 677 unsigned char *tbuf; 678 int err; 679 unsigned int u, idx; 680 681 if (size <= 0 || !buf || !index) 682 return -1; 683 buf[0] = 0; 684 tbuf = &mybuf[0]; 685 686 /* get langid for strings if it's not yet known */ 687 if (!dev->have_langid) { 688 err = usb_string_sub(dev, 0, 0, tbuf); 689 if (err < 0) { 690 USB_PRINTF("error getting string descriptor 0 " \ 691 "(error=%lx)\n", dev->status); 692 return -1; 693 } else if (tbuf[0] < 4) { 694 USB_PRINTF("string descriptor 0 too short\n"); 695 return -1; 696 } else { 697 dev->have_langid = -1; 698 dev->string_langid = tbuf[2] | (tbuf[3] << 8); 699 /* always use the first langid listed */ 700 USB_PRINTF("USB device number %d default " \ 701 "language ID 0x%x\n", 702 dev->devnum, dev->string_langid); 703 } 704 } 705 706 err = usb_string_sub(dev, dev->string_langid, index, tbuf); 707 if (err < 0) 708 return err; 709 710 size--; /* leave room for trailing NULL char in output buffer */ 711 for (idx = 0, u = 2; u < err; u += 2) { 712 if (idx >= size) 713 break; 714 if (tbuf[u+1]) /* high byte */ 715 buf[idx++] = '?'; /* non-ASCII character */ 716 else 717 buf[idx++] = tbuf[u]; 718 } 719 buf[idx] = 0; 720 err = idx; 721 return err; 722 } 723 724 725 /******************************************************************** 726 * USB device handling: 727 * the USB device are static allocated [USB_MAX_DEVICE]. 728 */ 729 730 731 /* returns a pointer to the device with the index [index]. 732 * if the device is not assigned (dev->devnum==-1) returns NULL 733 */ 734 struct usb_device *usb_get_dev_index(int index) 735 { 736 if (usb_dev[index].devnum == -1) 737 return NULL; 738 else 739 return &usb_dev[index]; 740 } 741 742 743 /* returns a pointer of a new device structure or NULL, if 744 * no device struct is available 745 */ 746 struct usb_device *usb_alloc_new_device(void) 747 { 748 int i; 749 USB_PRINTF("New Device %d\n", dev_index); 750 if (dev_index == USB_MAX_DEVICE) { 751 printf("ERROR, too many USB Devices, max=%d\n", USB_MAX_DEVICE); 752 return NULL; 753 } 754 /* default Address is 0, real addresses start with 1 */ 755 usb_dev[dev_index].devnum = dev_index + 1; 756 usb_dev[dev_index].maxchild = 0; 757 for (i = 0; i < USB_MAXCHILDREN; i++) 758 usb_dev[dev_index].children[i] = NULL; 759 usb_dev[dev_index].parent = NULL; 760 dev_index++; 761 return &usb_dev[dev_index - 1]; 762 } 763 764 765 /* 766 * By the time we get here, the device has gotten a new device ID 767 * and is in the default state. We need to identify the thing and 768 * get the ball rolling.. 769 * 770 * Returns 0 for success, != 0 for error. 771 */ 772 int usb_new_device(struct usb_device *dev) 773 { 774 int addr, err; 775 int tmp; 776 unsigned char tmpbuf[USB_BUFSIZ]; 777 778 /* We still haven't set the Address yet */ 779 addr = dev->devnum; 780 dev->devnum = 0; 781 782 #ifdef CONFIG_LEGACY_USB_INIT_SEQ 783 /* this is the old and known way of initializing devices, it is 784 * different than what Windows and Linux are doing. Windows and Linux 785 * both retrieve 64 bytes while reading the device descriptor 786 * Several USB stick devices report ERR: CTL_TIMEOUT, caused by an 787 * invalid header while reading 8 bytes as device descriptor. */ 788 dev->descriptor.bMaxPacketSize0 = 8; /* Start off at 8 bytes */ 789 dev->maxpacketsize = PACKET_SIZE_8; 790 dev->epmaxpacketin[0] = 8; 791 dev->epmaxpacketout[0] = 8; 792 793 err = usb_get_descriptor(dev, USB_DT_DEVICE, 0, &dev->descriptor, 8); 794 if (err < 8) { 795 printf("\n USB device not responding, " \ 796 "giving up (status=%lX)\n", dev->status); 797 return 1; 798 } 799 #else 800 /* This is a Windows scheme of initialization sequence, with double 801 * reset of the device (Linux uses the same sequence) 802 * Some equipment is said to work only with such init sequence; this 803 * patch is based on the work by Alan Stern: 804 * http://sourceforge.net/mailarchive/forum.php? 805 * thread_id=5729457&forum_id=5398 806 */ 807 struct usb_device_descriptor *desc; 808 int port = -1; 809 struct usb_device *parent = dev->parent; 810 unsigned short portstatus; 811 812 /* send 64-byte GET-DEVICE-DESCRIPTOR request. Since the descriptor is 813 * only 18 bytes long, this will terminate with a short packet. But if 814 * the maxpacket size is 8 or 16 the device may be waiting to transmit 815 * some more, or keeps on retransmitting the 8 byte header. */ 816 817 desc = (struct usb_device_descriptor *)tmpbuf; 818 dev->descriptor.bMaxPacketSize0 = 64; /* Start off at 64 bytes */ 819 /* Default to 64 byte max packet size */ 820 dev->maxpacketsize = PACKET_SIZE_64; 821 dev->epmaxpacketin[0] = 64; 822 dev->epmaxpacketout[0] = 64; 823 824 err = usb_get_descriptor(dev, USB_DT_DEVICE, 0, desc, 64); 825 if (err < 0) { 826 USB_PRINTF("usb_new_device: usb_get_descriptor() failed\n"); 827 return 1; 828 } 829 830 dev->descriptor.bMaxPacketSize0 = desc->bMaxPacketSize0; 831 832 /* find the port number we're at */ 833 if (parent) { 834 int j; 835 836 for (j = 0; j < parent->maxchild; j++) { 837 if (parent->children[j] == dev) { 838 port = j; 839 break; 840 } 841 } 842 if (port < 0) { 843 printf("usb_new_device:cannot locate device's port.\n"); 844 return 1; 845 } 846 847 /* reset the port for the second time */ 848 err = hub_port_reset(dev->parent, port, &portstatus); 849 if (err < 0) { 850 printf("\n Couldn't reset port %i\n", port); 851 return 1; 852 } 853 } 854 #endif 855 856 dev->epmaxpacketin[0] = dev->descriptor.bMaxPacketSize0; 857 dev->epmaxpacketout[0] = dev->descriptor.bMaxPacketSize0; 858 switch (dev->descriptor.bMaxPacketSize0) { 859 case 8: 860 dev->maxpacketsize = PACKET_SIZE_8; 861 break; 862 case 16: 863 dev->maxpacketsize = PACKET_SIZE_16; 864 break; 865 case 32: 866 dev->maxpacketsize = PACKET_SIZE_32; 867 break; 868 case 64: 869 dev->maxpacketsize = PACKET_SIZE_64; 870 break; 871 } 872 dev->devnum = addr; 873 874 err = usb_set_address(dev); /* set address */ 875 876 if (err < 0) { 877 printf("\n USB device not accepting new address " \ 878 "(error=%lX)\n", dev->status); 879 return 1; 880 } 881 882 wait_ms(10); /* Let the SET_ADDRESS settle */ 883 884 tmp = sizeof(dev->descriptor); 885 886 err = usb_get_descriptor(dev, USB_DT_DEVICE, 0, 887 &dev->descriptor, sizeof(dev->descriptor)); 888 if (err < tmp) { 889 if (err < 0) 890 printf("unable to get device descriptor (error=%d)\n", 891 err); 892 else 893 printf("USB device descriptor short read " \ 894 "(expected %i, got %i)\n", tmp, err); 895 return 1; 896 } 897 /* correct le values */ 898 le16_to_cpus(&dev->descriptor.bcdUSB); 899 le16_to_cpus(&dev->descriptor.idVendor); 900 le16_to_cpus(&dev->descriptor.idProduct); 901 le16_to_cpus(&dev->descriptor.bcdDevice); 902 /* only support for one config for now */ 903 usb_get_configuration_no(dev, &tmpbuf[0], 0); 904 usb_parse_config(dev, &tmpbuf[0], 0); 905 usb_set_maxpacket(dev); 906 /* we set the default configuration here */ 907 if (usb_set_configuration(dev, dev->config.desc.bConfigurationValue)) { 908 printf("failed to set default configuration " \ 909 "len %d, status %lX\n", dev->act_len, dev->status); 910 return -1; 911 } 912 USB_PRINTF("new device strings: Mfr=%d, Product=%d, SerialNumber=%d\n", 913 dev->descriptor.iManufacturer, dev->descriptor.iProduct, 914 dev->descriptor.iSerialNumber); 915 memset(dev->mf, 0, sizeof(dev->mf)); 916 memset(dev->prod, 0, sizeof(dev->prod)); 917 memset(dev->serial, 0, sizeof(dev->serial)); 918 if (dev->descriptor.iManufacturer) 919 usb_string(dev, dev->descriptor.iManufacturer, 920 dev->mf, sizeof(dev->mf)); 921 if (dev->descriptor.iProduct) 922 usb_string(dev, dev->descriptor.iProduct, 923 dev->prod, sizeof(dev->prod)); 924 if (dev->descriptor.iSerialNumber) 925 usb_string(dev, dev->descriptor.iSerialNumber, 926 dev->serial, sizeof(dev->serial)); 927 USB_PRINTF("Manufacturer %s\n", dev->mf); 928 USB_PRINTF("Product %s\n", dev->prod); 929 USB_PRINTF("SerialNumber %s\n", dev->serial); 930 /* now prode if the device is a hub */ 931 usb_hub_probe(dev, 0); 932 return 0; 933 } 934 935 /* build device Tree */ 936 void usb_scan_devices(void) 937 { 938 int i; 939 struct usb_device *dev; 940 941 /* first make all devices unknown */ 942 for (i = 0; i < USB_MAX_DEVICE; i++) { 943 memset(&usb_dev[i], 0, sizeof(struct usb_device)); 944 usb_dev[i].devnum = -1; 945 } 946 dev_index = 0; 947 /* device 0 is always present (root hub, so let it analyze) */ 948 dev = usb_alloc_new_device(); 949 if (usb_new_device(dev)) 950 printf("No USB Device found\n"); 951 else 952 printf("%d USB Device(s) found\n", dev_index); 953 /* insert "driver" if possible */ 954 #ifdef CONFIG_USB_KEYBOARD 955 drv_usb_kbd_init(); 956 USB_PRINTF("scan end\n"); 957 #endif 958 } 959 960 961 /**************************************************************************** 962 * HUB "Driver" 963 * Probes device for being a hub and configurate it 964 */ 965 966 #ifdef USB_HUB_DEBUG 967 #define USB_HUB_PRINTF(fmt, args...) printf(fmt , ##args) 968 #else 969 #define USB_HUB_PRINTF(fmt, args...) 970 #endif 971 972 973 static struct usb_hub_device hub_dev[USB_MAX_HUB]; 974 static int usb_hub_index; 975 976 977 int usb_get_hub_descriptor(struct usb_device *dev, void *data, int size) 978 { 979 return usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), 980 USB_REQ_GET_DESCRIPTOR, USB_DIR_IN | USB_RT_HUB, 981 USB_DT_HUB << 8, 0, data, size, USB_CNTL_TIMEOUT); 982 } 983 984 int usb_clear_hub_feature(struct usb_device *dev, int feature) 985 { 986 return usb_control_msg(dev, usb_sndctrlpipe(dev, 0), 987 USB_REQ_CLEAR_FEATURE, USB_RT_HUB, feature, 988 0, NULL, 0, USB_CNTL_TIMEOUT); 989 } 990 991 int usb_clear_port_feature(struct usb_device *dev, int port, int feature) 992 { 993 return usb_control_msg(dev, usb_sndctrlpipe(dev, 0), 994 USB_REQ_CLEAR_FEATURE, USB_RT_PORT, feature, 995 port, NULL, 0, USB_CNTL_TIMEOUT); 996 } 997 998 int usb_set_port_feature(struct usb_device *dev, int port, int feature) 999 { 1000 return usb_control_msg(dev, usb_sndctrlpipe(dev, 0), 1001 USB_REQ_SET_FEATURE, USB_RT_PORT, feature, 1002 port, NULL, 0, USB_CNTL_TIMEOUT); 1003 } 1004 1005 int usb_get_hub_status(struct usb_device *dev, void *data) 1006 { 1007 return usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), 1008 USB_REQ_GET_STATUS, USB_DIR_IN | USB_RT_HUB, 0, 0, 1009 data, sizeof(struct usb_hub_status), USB_CNTL_TIMEOUT); 1010 } 1011 1012 int usb_get_port_status(struct usb_device *dev, int port, void *data) 1013 { 1014 return usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), 1015 USB_REQ_GET_STATUS, USB_DIR_IN | USB_RT_PORT, 0, port, 1016 data, sizeof(struct usb_hub_status), USB_CNTL_TIMEOUT); 1017 } 1018 1019 1020 static void usb_hub_power_on(struct usb_hub_device *hub) 1021 { 1022 int i; 1023 struct usb_device *dev; 1024 1025 dev = hub->pusb_dev; 1026 /* Enable power to the ports */ 1027 USB_HUB_PRINTF("enabling power on all ports\n"); 1028 for (i = 0; i < dev->maxchild; i++) { 1029 usb_set_port_feature(dev, i + 1, USB_PORT_FEAT_POWER); 1030 USB_HUB_PRINTF("port %d returns %lX\n", i + 1, dev->status); 1031 wait_ms(hub->desc.bPwrOn2PwrGood * 2); 1032 } 1033 } 1034 1035 void usb_hub_reset(void) 1036 { 1037 usb_hub_index = 0; 1038 } 1039 1040 struct usb_hub_device *usb_hub_allocate(void) 1041 { 1042 if (usb_hub_index < USB_MAX_HUB) 1043 return &hub_dev[usb_hub_index++]; 1044 1045 printf("ERROR: USB_MAX_HUB (%d) reached\n", USB_MAX_HUB); 1046 return NULL; 1047 } 1048 1049 #define MAX_TRIES 5 1050 1051 static inline char *portspeed(int portstatus) 1052 { 1053 if (portstatus & (1 << USB_PORT_FEAT_HIGHSPEED)) 1054 return "480 Mb/s"; 1055 else if (portstatus & (1 << USB_PORT_FEAT_LOWSPEED)) 1056 return "1.5 Mb/s"; 1057 else 1058 return "12 Mb/s"; 1059 } 1060 1061 static int hub_port_reset(struct usb_device *dev, int port, 1062 unsigned short *portstat) 1063 { 1064 int tries; 1065 struct usb_port_status portsts; 1066 unsigned short portstatus, portchange; 1067 1068 USB_HUB_PRINTF("hub_port_reset: resetting port %d...\n", port); 1069 for (tries = 0; tries < MAX_TRIES; tries++) { 1070 1071 usb_set_port_feature(dev, port + 1, USB_PORT_FEAT_RESET); 1072 wait_ms(200); 1073 1074 if (usb_get_port_status(dev, port + 1, &portsts) < 0) { 1075 USB_HUB_PRINTF("get_port_status failed status %lX\n", 1076 dev->status); 1077 return -1; 1078 } 1079 portstatus = le16_to_cpu(portsts.wPortStatus); 1080 portchange = le16_to_cpu(portsts.wPortChange); 1081 1082 USB_HUB_PRINTF("portstatus %x, change %x, %s\n", 1083 portstatus, portchange, 1084 portspeed(portstatus)); 1085 1086 USB_HUB_PRINTF("STAT_C_CONNECTION = %d STAT_CONNECTION = %d" \ 1087 " USB_PORT_STAT_ENABLE %d\n", 1088 (portchange & USB_PORT_STAT_C_CONNECTION) ? 1 : 0, 1089 (portstatus & USB_PORT_STAT_CONNECTION) ? 1 : 0, 1090 (portstatus & USB_PORT_STAT_ENABLE) ? 1 : 0); 1091 1092 if ((portchange & USB_PORT_STAT_C_CONNECTION) || 1093 !(portstatus & USB_PORT_STAT_CONNECTION)) 1094 return -1; 1095 1096 if (portstatus & USB_PORT_STAT_ENABLE) 1097 break; 1098 1099 wait_ms(200); 1100 } 1101 1102 if (tries == MAX_TRIES) { 1103 USB_HUB_PRINTF("Cannot enable port %i after %i retries, " \ 1104 "disabling port.\n", port + 1, MAX_TRIES); 1105 USB_HUB_PRINTF("Maybe the USB cable is bad?\n"); 1106 return -1; 1107 } 1108 1109 usb_clear_port_feature(dev, port + 1, USB_PORT_FEAT_C_RESET); 1110 *portstat = portstatus; 1111 return 0; 1112 } 1113 1114 1115 void usb_hub_port_connect_change(struct usb_device *dev, int port) 1116 { 1117 struct usb_device *usb; 1118 struct usb_port_status portsts; 1119 unsigned short portstatus, portchange; 1120 1121 /* Check status */ 1122 if (usb_get_port_status(dev, port + 1, &portsts) < 0) { 1123 USB_HUB_PRINTF("get_port_status failed\n"); 1124 return; 1125 } 1126 1127 portstatus = le16_to_cpu(portsts.wPortStatus); 1128 portchange = le16_to_cpu(portsts.wPortChange); 1129 USB_HUB_PRINTF("portstatus %x, change %x, %s\n", 1130 portstatus, portchange, portspeed(portstatus)); 1131 1132 /* Clear the connection change status */ 1133 usb_clear_port_feature(dev, port + 1, USB_PORT_FEAT_C_CONNECTION); 1134 1135 /* Disconnect any existing devices under this port */ 1136 if (((!(portstatus & USB_PORT_STAT_CONNECTION)) && 1137 (!(portstatus & USB_PORT_STAT_ENABLE))) || (dev->children[port])) { 1138 USB_HUB_PRINTF("usb_disconnect(&hub->children[port]);\n"); 1139 /* Return now if nothing is connected */ 1140 if (!(portstatus & USB_PORT_STAT_CONNECTION)) 1141 return; 1142 } 1143 wait_ms(200); 1144 1145 /* Reset the port */ 1146 if (hub_port_reset(dev, port, &portstatus) < 0) { 1147 printf("cannot reset port %i!?\n", port + 1); 1148 return; 1149 } 1150 1151 wait_ms(200); 1152 1153 /* Allocate a new device struct for it */ 1154 usb = usb_alloc_new_device(); 1155 1156 if (portstatus & USB_PORT_STAT_HIGH_SPEED) 1157 usb->speed = USB_SPEED_HIGH; 1158 else if (portstatus & USB_PORT_STAT_LOW_SPEED) 1159 usb->speed = USB_SPEED_LOW; 1160 else 1161 usb->speed = USB_SPEED_FULL; 1162 1163 dev->children[port] = usb; 1164 usb->parent = dev; 1165 /* Run it through the hoops (find a driver, etc) */ 1166 if (usb_new_device(usb)) { 1167 /* Woops, disable the port */ 1168 USB_HUB_PRINTF("hub: disabling port %d\n", port + 1); 1169 usb_clear_port_feature(dev, port + 1, USB_PORT_FEAT_ENABLE); 1170 } 1171 } 1172 1173 1174 int usb_hub_configure(struct usb_device *dev) 1175 { 1176 unsigned char buffer[USB_BUFSIZ], *bitmap; 1177 struct usb_hub_descriptor *descriptor; 1178 struct usb_hub_status *hubsts; 1179 int i; 1180 struct usb_hub_device *hub; 1181 1182 /* "allocate" Hub device */ 1183 hub = usb_hub_allocate(); 1184 if (hub == NULL) 1185 return -1; 1186 hub->pusb_dev = dev; 1187 /* Get the the hub descriptor */ 1188 if (usb_get_hub_descriptor(dev, buffer, 4) < 0) { 1189 USB_HUB_PRINTF("usb_hub_configure: failed to get hub " \ 1190 "descriptor, giving up %lX\n", dev->status); 1191 return -1; 1192 } 1193 descriptor = (struct usb_hub_descriptor *)buffer; 1194 1195 /* silence compiler warning if USB_BUFSIZ is > 256 [= sizeof(char)] */ 1196 i = descriptor->bLength; 1197 if (i > USB_BUFSIZ) { 1198 USB_HUB_PRINTF("usb_hub_configure: failed to get hub " \ 1199 "descriptor - too long: %d\n", 1200 descriptor->bLength); 1201 return -1; 1202 } 1203 1204 if (usb_get_hub_descriptor(dev, buffer, descriptor->bLength) < 0) { 1205 USB_HUB_PRINTF("usb_hub_configure: failed to get hub " \ 1206 "descriptor 2nd giving up %lX\n", dev->status); 1207 return -1; 1208 } 1209 memcpy((unsigned char *)&hub->desc, buffer, descriptor->bLength); 1210 /* adjust 16bit values */ 1211 hub->desc.wHubCharacteristics = 1212 le16_to_cpu(descriptor->wHubCharacteristics); 1213 /* set the bitmap */ 1214 bitmap = (unsigned char *)&hub->desc.DeviceRemovable[0]; 1215 /* devices not removable by default */ 1216 memset(bitmap, 0xff, (USB_MAXCHILDREN+1+7)/8); 1217 bitmap = (unsigned char *)&hub->desc.PortPowerCtrlMask[0]; 1218 memset(bitmap, 0xff, (USB_MAXCHILDREN+1+7)/8); /* PowerMask = 1B */ 1219 1220 for (i = 0; i < ((hub->desc.bNbrPorts + 1 + 7)/8); i++) 1221 hub->desc.DeviceRemovable[i] = descriptor->DeviceRemovable[i]; 1222 1223 for (i = 0; i < ((hub->desc.bNbrPorts + 1 + 7)/8); i++) 1224 hub->desc.PortPowerCtrlMask[i] = descriptor->PortPowerCtrlMask[i]; 1225 1226 dev->maxchild = descriptor->bNbrPorts; 1227 USB_HUB_PRINTF("%d ports detected\n", dev->maxchild); 1228 1229 switch (hub->desc.wHubCharacteristics & HUB_CHAR_LPSM) { 1230 case 0x00: 1231 USB_HUB_PRINTF("ganged power switching\n"); 1232 break; 1233 case 0x01: 1234 USB_HUB_PRINTF("individual port power switching\n"); 1235 break; 1236 case 0x02: 1237 case 0x03: 1238 USB_HUB_PRINTF("unknown reserved power switching mode\n"); 1239 break; 1240 } 1241 1242 if (hub->desc.wHubCharacteristics & HUB_CHAR_COMPOUND) 1243 USB_HUB_PRINTF("part of a compound device\n"); 1244 else 1245 USB_HUB_PRINTF("standalone hub\n"); 1246 1247 switch (hub->desc.wHubCharacteristics & HUB_CHAR_OCPM) { 1248 case 0x00: 1249 USB_HUB_PRINTF("global over-current protection\n"); 1250 break; 1251 case 0x08: 1252 USB_HUB_PRINTF("individual port over-current protection\n"); 1253 break; 1254 case 0x10: 1255 case 0x18: 1256 USB_HUB_PRINTF("no over-current protection\n"); 1257 break; 1258 } 1259 1260 USB_HUB_PRINTF("power on to power good time: %dms\n", 1261 descriptor->bPwrOn2PwrGood * 2); 1262 USB_HUB_PRINTF("hub controller current requirement: %dmA\n", 1263 descriptor->bHubContrCurrent); 1264 1265 for (i = 0; i < dev->maxchild; i++) 1266 USB_HUB_PRINTF("port %d is%s removable\n", i + 1, 1267 hub->desc.DeviceRemovable[(i + 1) / 8] & \ 1268 (1 << ((i + 1) % 8)) ? " not" : ""); 1269 1270 if (sizeof(struct usb_hub_status) > USB_BUFSIZ) { 1271 USB_HUB_PRINTF("usb_hub_configure: failed to get Status - " \ 1272 "too long: %d\n", descriptor->bLength); 1273 return -1; 1274 } 1275 1276 if (usb_get_hub_status(dev, buffer) < 0) { 1277 USB_HUB_PRINTF("usb_hub_configure: failed to get Status %lX\n", 1278 dev->status); 1279 return -1; 1280 } 1281 1282 hubsts = (struct usb_hub_status *)buffer; 1283 USB_HUB_PRINTF("get_hub_status returned status %X, change %X\n", 1284 le16_to_cpu(hubsts->wHubStatus), 1285 le16_to_cpu(hubsts->wHubChange)); 1286 USB_HUB_PRINTF("local power source is %s\n", 1287 (le16_to_cpu(hubsts->wHubStatus) & HUB_STATUS_LOCAL_POWER) ? \ 1288 "lost (inactive)" : "good"); 1289 USB_HUB_PRINTF("%sover-current condition exists\n", 1290 (le16_to_cpu(hubsts->wHubStatus) & HUB_STATUS_OVERCURRENT) ? \ 1291 "" : "no "); 1292 usb_hub_power_on(hub); 1293 1294 for (i = 0; i < dev->maxchild; i++) { 1295 struct usb_port_status portsts; 1296 unsigned short portstatus, portchange; 1297 1298 if (usb_get_port_status(dev, i + 1, &portsts) < 0) { 1299 USB_HUB_PRINTF("get_port_status failed\n"); 1300 continue; 1301 } 1302 1303 portstatus = le16_to_cpu(portsts.wPortStatus); 1304 portchange = le16_to_cpu(portsts.wPortChange); 1305 USB_HUB_PRINTF("Port %d Status %X Change %X\n", 1306 i + 1, portstatus, portchange); 1307 1308 if (portchange & USB_PORT_STAT_C_CONNECTION) { 1309 USB_HUB_PRINTF("port %d connection change\n", i + 1); 1310 usb_hub_port_connect_change(dev, i); 1311 } 1312 if (portchange & USB_PORT_STAT_C_ENABLE) { 1313 USB_HUB_PRINTF("port %d enable change, status %x\n", 1314 i + 1, portstatus); 1315 usb_clear_port_feature(dev, i + 1, 1316 USB_PORT_FEAT_C_ENABLE); 1317 1318 /* EM interference sometimes causes bad shielded USB 1319 * devices to be shutdown by the hub, this hack enables 1320 * them again. Works at least with mouse driver */ 1321 if (!(portstatus & USB_PORT_STAT_ENABLE) && 1322 (portstatus & USB_PORT_STAT_CONNECTION) && 1323 ((dev->children[i]))) { 1324 USB_HUB_PRINTF("already running port %i " \ 1325 "disabled by hub (EMI?), " \ 1326 "re-enabling...\n", i + 1); 1327 usb_hub_port_connect_change(dev, i); 1328 } 1329 } 1330 if (portstatus & USB_PORT_STAT_SUSPEND) { 1331 USB_HUB_PRINTF("port %d suspend change\n", i + 1); 1332 usb_clear_port_feature(dev, i + 1, 1333 USB_PORT_FEAT_SUSPEND); 1334 } 1335 1336 if (portchange & USB_PORT_STAT_C_OVERCURRENT) { 1337 USB_HUB_PRINTF("port %d over-current change\n", i + 1); 1338 usb_clear_port_feature(dev, i + 1, 1339 USB_PORT_FEAT_C_OVER_CURRENT); 1340 usb_hub_power_on(hub); 1341 } 1342 1343 if (portchange & USB_PORT_STAT_C_RESET) { 1344 USB_HUB_PRINTF("port %d reset change\n", i + 1); 1345 usb_clear_port_feature(dev, i + 1, 1346 USB_PORT_FEAT_C_RESET); 1347 } 1348 } /* end for i all ports */ 1349 1350 return 0; 1351 } 1352 1353 int usb_hub_probe(struct usb_device *dev, int ifnum) 1354 { 1355 struct usb_interface *iface; 1356 struct usb_endpoint_descriptor *ep; 1357 int ret; 1358 1359 iface = &dev->config.if_desc[ifnum]; 1360 /* Is it a hub? */ 1361 if (iface->desc.bInterfaceClass != USB_CLASS_HUB) 1362 return 0; 1363 /* Some hubs have a subclass of 1, which AFAICT according to the */ 1364 /* specs is not defined, but it works */ 1365 if ((iface->desc.bInterfaceSubClass != 0) && 1366 (iface->desc.bInterfaceSubClass != 1)) 1367 return 0; 1368 /* Multiple endpoints? What kind of mutant ninja-hub is this? */ 1369 if (iface->desc.bNumEndpoints != 1) 1370 return 0; 1371 ep = &iface->ep_desc[0]; 1372 /* Output endpoint? Curiousier and curiousier.. */ 1373 if (!(ep->bEndpointAddress & USB_DIR_IN)) 1374 return 0; 1375 /* If it's not an interrupt endpoint, we'd better punt! */ 1376 if ((ep->bmAttributes & 3) != 3) 1377 return 0; 1378 /* We found a hub */ 1379 USB_HUB_PRINTF("USB hub found\n"); 1380 ret = usb_hub_configure(dev); 1381 return ret; 1382 } 1383 1384 /* EOF */ 1385