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