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