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