1 /* 2 * (C) Copyright 2001 3 * Denis Peter, MPL AG Switzerland 4 * 5 * Most of this source has been derived from the Linux USB 6 * project. 7 * 8 * See file CREDITS for list of people who contributed to this 9 * project. 10 * 11 * This program is free software; you can redistribute it and/or 12 * modify it under the terms of the GNU General Public License as 13 * published by the Free Software Foundation; either version 2 of 14 * the License, or (at your option) any later version. 15 * 16 * This program is distributed in the hope that it will be useful, 17 * but WITHOUT ANY WARRANTY; without even the implied warranty of 18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 19 * GNU General Public License for more details. 20 * 21 * You should have received a copy of the GNU General Public License 22 * along with this program; if not, write to the Free Software 23 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, 24 * MA 02111-1307 USA 25 * 26 */ 27 28 29 /* 30 * How it works: 31 * 32 * Since this is a bootloader, the devices will not be automatic 33 * (re)configured on hotplug, but after a restart of the USB the 34 * device should work. 35 * 36 * For each transfer (except "Interrupt") we wait for completion. 37 */ 38 #include <common.h> 39 #include <command.h> 40 #include <asm/processor.h> 41 42 #if (CONFIG_COMMANDS & CFG_CMD_USB) 43 44 #include <usb.h> 45 #ifdef CONFIG_4xx 46 #include <405gp_pci.h> 47 #endif 48 49 50 51 #undef USB_DEBUG 52 53 #ifdef USB_DEBUG 54 #define USB_PRINTF(fmt,args...) printf (fmt ,##args) 55 #else 56 #define USB_PRINTF(fmt,args...) 57 #endif 58 59 static struct usb_device usb_dev[USB_MAX_DEVICE]; 60 static int dev_index; 61 static int running; 62 static int asynch_allowed; 63 static struct devrequest setup_packet; 64 65 /********************************************************************** 66 * some forward declerations... 67 */ 68 void usb_scan_devices(void); 69 70 int usb_hub_probe(struct usb_device *dev, int ifnum); 71 void usb_hub_reset(void); 72 73 /*********************************************************************** 74 * wait_ms 75 */ 76 77 void __inline__ wait_ms(unsigned long ms) 78 { 79 while(ms-->0) 80 udelay(1000); 81 } 82 /*************************************************************************** 83 * Init USB Device 84 */ 85 86 int usb_init(void) 87 { 88 int result; 89 90 running=0; 91 dev_index=0; 92 asynch_allowed=1; 93 usb_hub_reset(); 94 /* init low_level USB */ 95 printf("USB: "); 96 result = usb_lowlevel_init(); 97 /* if lowlevel init is OK, scan the bus for devices i.e. search HUBs and configure them */ 98 if(result==0) { 99 printf("scanning bus for devices... "); 100 running=1; 101 usb_scan_devices(); 102 return 0; 103 } 104 else { 105 printf("Error, couldn't init Lowlevel part\n"); 106 return -1; 107 } 108 } 109 110 /****************************************************************************** 111 * Stop USB this stops the LowLevel Part and deregisters USB devices. 112 */ 113 int usb_stop(void) 114 { 115 asynch_allowed=1; 116 usb_hub_reset(); 117 return usb_lowlevel_stop(); 118 } 119 120 /* 121 * disables the asynch behaviour of the control message. This is used for data 122 * transfers that uses the exclusiv access to the control and bulk messages. 123 */ 124 void usb_disable_asynch(int disable) 125 { 126 asynch_allowed=!disable; 127 } 128 129 130 /*------------------------------------------------------------------- 131 * Message wrappers. 132 * 133 */ 134 135 /* 136 * submits an Interrupt Message 137 */ 138 int usb_submit_int_msg(struct usb_device *dev, unsigned long pipe, 139 void *buffer,int transfer_len, int interval) 140 { 141 return submit_int_msg(dev,pipe,buffer,transfer_len,interval); 142 } 143 144 /* 145 * submits a control message and waits for comletion (at least timeout * 1ms) 146 * If timeout is 0, we don't wait for completion (used as example to set and 147 * clear keyboards LEDs). For data transfers, (storage transfers) we don't 148 * allow control messages with 0 timeout, by previousely resetting the flag 149 * asynch_allowed (usb_disable_asynch(1)). 150 * returns the transfered length if OK or -1 if error. The transfered length 151 * and the current status are stored in the dev->act_len and dev->status. 152 */ 153 int usb_control_msg(struct usb_device *dev, unsigned int pipe, 154 unsigned char request, unsigned char requesttype, 155 unsigned short value, unsigned short index, 156 void *data, unsigned short size, int timeout) 157 { 158 if((timeout==0)&&(!asynch_allowed)) /* request for a asynch control pipe is not allowed */ 159 return -1; 160 /* set setup command */ 161 setup_packet.requesttype = requesttype; 162 setup_packet.request = request; 163 setup_packet.value = swap_16(value); 164 setup_packet.index = swap_16(index); 165 setup_packet.length = swap_16(size); 166 USB_PRINTF("usb_control_msg: request: 0x%X, requesttype: 0x%X\nvalue 0x%X index 0x%X length 0x%X\n", 167 request,requesttype,value,index,size); 168 dev->status=USB_ST_NOT_PROC; /*not yet processed */ 169 170 submit_control_msg(dev,pipe,data,size,&setup_packet); 171 if(timeout==0) { 172 return (int)size; 173 } 174 while(timeout--) { 175 if(!((volatile unsigned long)dev->status & USB_ST_NOT_PROC)) 176 break; 177 wait_ms(1); 178 } 179 if(dev->status==0) 180 return dev->act_len; 181 else { 182 return -1; 183 } 184 } 185 186 /*------------------------------------------------------------------- 187 * submits bulk message, and waits for completion. returns 0 if Ok or 188 * -1 if Error. 189 * synchronous behavior 190 */ 191 int usb_bulk_msg(struct usb_device *dev, unsigned int pipe, 192 void *data, int len, int *actual_length, int timeout) 193 { 194 if (len < 0) 195 return -1; 196 dev->status=USB_ST_NOT_PROC; /*not yet processed */ 197 submit_bulk_msg(dev,pipe,data,len); 198 while(timeout--) { 199 if(!((volatile unsigned long)dev->status & USB_ST_NOT_PROC)) 200 break; 201 wait_ms(1); 202 } 203 *actual_length=dev->act_len; 204 if(dev->status==0) 205 return 0; 206 else 207 return -1; 208 } 209 210 211 /*------------------------------------------------------------------- 212 * Max Packet stuff 213 */ 214 215 /* 216 * returns the max packet size, depending on the pipe direction and 217 * the configurations values 218 */ 219 int usb_maxpacket(struct usb_device *dev,unsigned long pipe) 220 { 221 if((pipe & USB_DIR_IN)==0) /* direction is out -> use emaxpacket out */ 222 return(dev->epmaxpacketout[((pipe>>15) & 0xf)]); 223 else 224 return(dev->epmaxpacketin[((pipe>>15) & 0xf)]); 225 } 226 227 /* 228 * set the max packed value of all endpoints in the given configuration 229 */ 230 int usb_set_maxpacket(struct usb_device *dev) 231 { 232 int i,ii,b; 233 struct usb_endpoint_descriptor *ep; 234 235 for(i=0; i<dev->config.bNumInterfaces;i++) { 236 for(ii=0; ii<dev->config.if_desc[i].bNumEndpoints; ii++) { 237 ep=&dev->config.if_desc[i].ep_desc[ii]; 238 b=ep->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK; 239 240 if((ep->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK)==USB_ENDPOINT_XFER_CONTROL) { /* Control => bidirectional */ 241 dev->epmaxpacketout[b] = ep->wMaxPacketSize; 242 dev->epmaxpacketin [b] = ep->wMaxPacketSize; 243 USB_PRINTF("##Control EP epmaxpacketout/in[%d] = %d\n",b,dev->epmaxpacketin[b]); 244 } 245 else { 246 if ((ep->bEndpointAddress & 0x80)==0) { /* OUT Endpoint */ 247 if(ep->wMaxPacketSize > dev->epmaxpacketout[b]) { 248 dev->epmaxpacketout[b] = ep->wMaxPacketSize; 249 USB_PRINTF("##EP epmaxpacketout[%d] = %d\n",b,dev->epmaxpacketout[b]); 250 } 251 } 252 else { /* IN Endpoint */ 253 if(ep->wMaxPacketSize > dev->epmaxpacketin[b]) { 254 dev->epmaxpacketin[b] = ep->wMaxPacketSize; 255 USB_PRINTF("##EP epmaxpacketin[%d] = %d\n",b,dev->epmaxpacketin[b]); 256 } 257 } /* if out */ 258 } /* if control */ 259 } /* for each endpoint */ 260 } 261 return 0; 262 } 263 264 /******************************************************************************* 265 * Parse the config, located in buffer, and fills the dev->config structure. 266 * Note that all little/big endian swapping are done automatically. 267 */ 268 int usb_parse_config(struct usb_device *dev, unsigned char *buffer, int cfgno) 269 { 270 struct usb_descriptor_header *head; 271 int index,ifno,epno; 272 ifno=-1; 273 epno=-1; 274 275 dev->configno=cfgno; 276 head =(struct usb_descriptor_header *)&buffer[0]; 277 if(head->bDescriptorType!=USB_DT_CONFIG) { 278 printf(" ERROR: NOT USB_CONFIG_DESC %x\n",head->bDescriptorType); 279 return -1; 280 } 281 memcpy(&dev->config,buffer,buffer[0]); 282 dev->config.wTotalLength=swap_16(dev->config.wTotalLength); 283 dev->config.no_of_if=0; 284 285 index=dev->config.bLength; 286 /* Ok the first entry must be a configuration entry, now process the others */ 287 head=(struct usb_descriptor_header *)&buffer[index]; 288 while(index+1 < dev->config.wTotalLength) { 289 switch(head->bDescriptorType) { 290 case USB_DT_INTERFACE: 291 ifno=dev->config.no_of_if; 292 dev->config.no_of_if++; /* found an interface desc, increase numbers */ 293 memcpy(&dev->config.if_desc[ifno],&buffer[index],buffer[index]); /* copy new desc */ 294 dev->config.if_desc[ifno].no_of_ep=0; 295 296 break; 297 case USB_DT_ENDPOINT: 298 epno=dev->config.if_desc[ifno].no_of_ep; 299 dev->config.if_desc[ifno].no_of_ep++; /* found an endpoint */ 300 memcpy(&dev->config.if_desc[ifno].ep_desc[epno],&buffer[index],buffer[index]); 301 dev->config.if_desc[ifno].ep_desc[epno].wMaxPacketSize 302 =swap_16(dev->config.if_desc[ifno].ep_desc[epno].wMaxPacketSize); 303 USB_PRINTF("if %d, ep %d\n",ifno,epno); 304 break; 305 default: 306 if(head->bLength==0) 307 return 1; 308 USB_PRINTF("unknown Description Type : %x\n",head->bDescriptorType); 309 { 310 int i; 311 unsigned char *ch; 312 ch=(unsigned char *)head; 313 for(i=0;i<head->bLength; i++) 314 USB_PRINTF("%02X ",*ch++); 315 USB_PRINTF("\n\n\n"); 316 } 317 break; 318 } 319 index+=head->bLength; 320 head=(struct usb_descriptor_header *)&buffer[index]; 321 } 322 return 1; 323 } 324 325 /*********************************************************************** 326 * Clears an endpoint 327 * endp: endpoint number in bits 0-3; 328 * direction flag in bit 7 (1 = IN, 0 = OUT) 329 */ 330 int usb_clear_halt(struct usb_device *dev, int pipe) 331 { 332 int result; 333 unsigned short status; 334 int endp=usb_pipeendpoint(pipe)|(usb_pipein(pipe)<<7); 335 336 result = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), 337 USB_REQ_CLEAR_FEATURE, USB_RECIP_ENDPOINT, 0, endp, NULL, 0, USB_CNTL_TIMEOUT * 3); 338 339 /* don't clear if failed */ 340 if (result < 0) 341 return result; 342 result = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), 343 USB_REQ_GET_STATUS, USB_DIR_IN | USB_RECIP_ENDPOINT, 0, endp, 344 &status, sizeof(status), USB_CNTL_TIMEOUT * 3); 345 if (result < 0) 346 return result; 347 USB_PRINTF("usb_clear_halt: status 0x%x\n",status); 348 if (status & 1) 349 return -1; /* still halted */ 350 usb_endpoint_running(dev, usb_pipeendpoint(pipe), usb_pipeout(pipe)); 351 /* toggle is reset on clear */ 352 usb_settoggle(dev, usb_pipeendpoint(pipe), usb_pipeout(pipe), 0); 353 return 0; 354 } 355 356 357 /********************************************************************** 358 * get_descriptor type 359 */ 360 int usb_get_descriptor(struct usb_device *dev, unsigned char type, unsigned char index, void *buf, int size) 361 { 362 int res; 363 res = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), 364 USB_REQ_GET_DESCRIPTOR, USB_DIR_IN, 365 (type << 8) + index, 0, 366 buf, size, USB_CNTL_TIMEOUT); 367 return res; 368 } 369 370 /********************************************************************** 371 * gets configuration cfgno and store it in the buffer 372 */ 373 int usb_get_configuration_no(struct usb_device *dev,unsigned char *buffer,int cfgno) 374 { 375 int result; 376 unsigned int tmp; 377 struct usb_config_descriptor *config; 378 379 380 config=(struct usb_config_descriptor *)&buffer[0]; 381 result = usb_get_descriptor(dev, USB_DT_CONFIG, cfgno, buffer, 8); 382 if (result < 8) { 383 if (result < 0) 384 printf("unable to get descriptor, error %lX\n",dev->status); 385 else 386 printf("config descriptor too short (expected %i, got %i)\n",8,result); 387 return -1; 388 } 389 tmp=swap_16(config->wTotalLength); 390 391 result = usb_get_descriptor(dev, USB_DT_CONFIG, cfgno, buffer, tmp); 392 USB_PRINTF("get_conf_no %d Result %d, wLength %d\n",cfgno,result,tmp); 393 return result; 394 } 395 396 /******************************************************************** 397 * set address of a device to the value in dev->devnum. 398 * This can only be done by addressing the device via the default address (0) 399 */ 400 int usb_set_address(struct usb_device *dev) 401 { 402 int res; 403 404 USB_PRINTF("set address %d\n",dev->devnum); 405 res=usb_control_msg(dev, usb_snddefctrl(dev), 406 USB_REQ_SET_ADDRESS, 0, 407 (dev->devnum),0, 408 NULL,0, USB_CNTL_TIMEOUT); 409 return res; 410 } 411 412 /******************************************************************** 413 * set interface number to interface 414 */ 415 int usb_set_interface(struct usb_device *dev, int interface, int alternate) 416 { 417 struct usb_interface_descriptor *if_face = NULL; 418 int ret, i; 419 420 for (i=0; i<dev->config.bNumInterfaces; i++) { 421 if (dev->config.if_desc[i].bInterfaceNumber == interface) { 422 if_face = &dev->config.if_desc[i]; 423 break; 424 } 425 } 426 if (!if_face) { 427 printf("selecting invalid interface %d", interface); 428 return -1; 429 } 430 431 if ((ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), 432 USB_REQ_SET_INTERFACE, USB_RECIP_INTERFACE, alternate, 433 interface, NULL, 0, USB_CNTL_TIMEOUT * 5)) < 0) 434 return ret; 435 436 if_face->act_altsetting = (unsigned char)alternate; 437 usb_set_maxpacket(dev); 438 return 0; 439 } 440 441 /******************************************************************** 442 * set configuration number to configuration 443 */ 444 int usb_set_configuration(struct usb_device *dev, int configuration) 445 { 446 int res; 447 USB_PRINTF("set configuration %d\n",configuration); 448 /* set setup command */ 449 res=usb_control_msg(dev, usb_sndctrlpipe(dev,0), 450 USB_REQ_SET_CONFIGURATION, 0, 451 configuration,0, 452 NULL,0, USB_CNTL_TIMEOUT); 453 if(res==0) { 454 dev->toggle[0] = 0; 455 dev->toggle[1] = 0; 456 return 0; 457 } 458 else 459 return -1; 460 } 461 462 /******************************************************************** 463 * set protocol to protocol 464 */ 465 int usb_set_protocol(struct usb_device *dev, int ifnum, int protocol) 466 { 467 return usb_control_msg(dev, usb_sndctrlpipe(dev, 0), 468 USB_REQ_SET_PROTOCOL, USB_TYPE_CLASS | USB_RECIP_INTERFACE, 469 protocol, ifnum, NULL, 0, USB_CNTL_TIMEOUT); 470 } 471 472 /******************************************************************** 473 * set idle 474 */ 475 int usb_set_idle(struct usb_device *dev, int ifnum, int duration, int report_id) 476 { 477 return usb_control_msg(dev, usb_sndctrlpipe(dev, 0), 478 USB_REQ_SET_IDLE, USB_TYPE_CLASS | USB_RECIP_INTERFACE, 479 (duration << 8) | report_id, ifnum, NULL, 0, USB_CNTL_TIMEOUT); 480 } 481 482 /******************************************************************** 483 * get report 484 */ 485 int usb_get_report(struct usb_device *dev, int ifnum, unsigned char type, unsigned char id, void *buf, int size) 486 { 487 return usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), 488 USB_REQ_GET_REPORT, USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE, 489 (type << 8) + id, ifnum, buf, size, USB_CNTL_TIMEOUT); 490 } 491 492 /******************************************************************** 493 * get class descriptor 494 */ 495 int usb_get_class_descriptor(struct usb_device *dev, int ifnum, 496 unsigned char type, unsigned char id, void *buf, int size) 497 { 498 return usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), 499 USB_REQ_GET_DESCRIPTOR, USB_RECIP_INTERFACE | USB_DIR_IN, 500 (type << 8) + id, ifnum, buf, size, USB_CNTL_TIMEOUT); 501 } 502 503 /******************************************************************** 504 * get string index in buffer 505 */ 506 int usb_get_string(struct usb_device *dev, unsigned short langid, unsigned char index, void *buf, int size) 507 { 508 return usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), 509 USB_REQ_GET_DESCRIPTOR, USB_DIR_IN, 510 (USB_DT_STRING << 8) + index, langid, buf, size, USB_CNTL_TIMEOUT); 511 } 512 513 /******************************************************************** 514 * usb_string: 515 * Get string index and translate it to ascii. 516 * returns string length (> 0) or error (< 0) 517 */ 518 int usb_string(struct usb_device *dev, int index, char *buf, size_t size) 519 { 520 521 unsigned char mybuf[256]; 522 unsigned char *tbuf; 523 int err; 524 unsigned int u, idx; 525 526 if (size <= 0 || !buf || !index) 527 return -1; 528 buf[0] = 0; 529 tbuf=&mybuf[0]; 530 531 /* get langid for strings if it's not yet known */ 532 if (!dev->have_langid) { 533 err = usb_get_string(dev, 0, 0, tbuf, 4); 534 if (err < 0) { 535 USB_PRINTF("error getting string descriptor 0 (error=%x)\n",dev->status); 536 return -1; 537 } else if (tbuf[0] < 4) { 538 USB_PRINTF("string descriptor 0 too short\n"); 539 return -1; 540 } else { 541 dev->have_langid = -1; 542 dev->string_langid = tbuf[2] | (tbuf[3]<< 8); 543 /* always use the first langid listed */ 544 USB_PRINTF("USB device number %d default language ID 0x%x\n", 545 dev->devnum, dev->string_langid); 546 } 547 } 548 /* Just ask for a maximum length string and then take the length 549 * that was returned. */ 550 err = usb_get_string(dev, dev->string_langid, index, tbuf, 4); 551 if (err < 0) 552 return err; 553 u=tbuf[0]; 554 USB_PRINTF("Strn Len %d, index %d\n",u,index); 555 err = usb_get_string(dev, dev->string_langid, index, tbuf, u); 556 if (err < 0) 557 return err; 558 size--; /* leave room for trailing NULL char in output buffer */ 559 for (idx = 0, u = 2; u < err; u += 2) { 560 if (idx >= size) 561 break; 562 if (tbuf[u+1]) /* high byte */ 563 buf[idx++] = '?'; /* non-ASCII character */ 564 else 565 buf[idx++] = tbuf[u]; 566 } 567 buf[idx] = 0; 568 err = idx; 569 return err; 570 } 571 572 573 /******************************************************************** 574 * USB device handling: 575 * the USB device are static allocated [USB_MAX_DEVICE]. 576 */ 577 578 579 /* returns a pointer to the device with the index [index]. 580 * if the device is not assigned (dev->devnum==-1) returns NULL 581 */ 582 struct usb_device * usb_get_dev_index(int index) 583 { 584 if(usb_dev[index].devnum==-1) 585 return NULL; 586 else 587 return &usb_dev[index]; 588 } 589 590 591 /* returns a pointer of a new device structure or NULL, if 592 * no device struct is available 593 */ 594 struct usb_device * usb_alloc_new_device(void) 595 { 596 int i; 597 USB_PRINTF("New Device %d\n",dev_index); 598 if(dev_index==USB_MAX_DEVICE) { 599 printf("ERROR, to many USB Devices max=%d\n",USB_MAX_DEVICE); 600 return NULL; 601 } 602 usb_dev[dev_index].devnum=dev_index+1; /* default Address is 0, real addresses start with 1 */ 603 usb_dev[dev_index].maxchild=0; 604 for(i=0;i<USB_MAXCHILDREN;i++) 605 usb_dev[dev_index].children[i]=NULL; 606 usb_dev[dev_index].parent=NULL; 607 dev_index++; 608 return &usb_dev[dev_index-1]; 609 } 610 611 612 /* 613 * By the time we get here, the device has gotten a new device ID 614 * and is in the default state. We need to identify the thing and 615 * get the ball rolling.. 616 * 617 * Returns 0 for success, != 0 for error. 618 */ 619 int usb_new_device(struct usb_device *dev) 620 { 621 int addr, err; 622 int tmp; 623 unsigned char tmpbuf[256]; 624 625 dev->descriptor.bMaxPacketSize0 = 8; /* Start off at 8 bytes */ 626 dev->maxpacketsize = 0; /* Default to 8 byte max packet size */ 627 dev->epmaxpacketin [0] = 8; 628 dev->epmaxpacketout[0] = 8; 629 630 /* We still haven't set the Address yet */ 631 addr = dev->devnum; 632 dev->devnum = 0; 633 err = usb_get_descriptor(dev, USB_DT_DEVICE, 0, &dev->descriptor, 8); 634 if (err < 8) { 635 printf("\n USB device not responding, giving up (status=%lX)\n",dev->status); 636 return 1; 637 } 638 dev->epmaxpacketin [0] = dev->descriptor.bMaxPacketSize0; 639 dev->epmaxpacketout[0] = dev->descriptor.bMaxPacketSize0; 640 switch (dev->descriptor.bMaxPacketSize0) { 641 case 8: dev->maxpacketsize = 0; break; 642 case 16: dev->maxpacketsize = 1; break; 643 case 32: dev->maxpacketsize = 2; break; 644 case 64: dev->maxpacketsize = 3; break; 645 } 646 dev->devnum = addr; 647 648 err = usb_set_address(dev); /* set address */ 649 650 if (err < 0) { 651 printf("\n USB device not accepting new address (error=%lX)\n", dev->status); 652 return 1; 653 } 654 655 wait_ms(10); /* Let the SET_ADDRESS settle */ 656 657 tmp = sizeof(dev->descriptor); 658 659 err = usb_get_descriptor(dev, USB_DT_DEVICE, 0, &dev->descriptor, sizeof(dev->descriptor)); 660 if (err < tmp) { 661 if (err < 0) 662 printf("unable to get device descriptor (error=%d)\n",err); 663 else 664 printf("USB device descriptor short read (expected %i, got %i)\n",tmp,err); 665 return 1; 666 } 667 /* correct le values */ 668 dev->descriptor.bcdUSB=swap_16(dev->descriptor.bcdUSB); 669 dev->descriptor.idVendor=swap_16(dev->descriptor.idVendor); 670 dev->descriptor.idProduct=swap_16(dev->descriptor.idProduct); 671 dev->descriptor.bcdDevice=swap_16(dev->descriptor.bcdDevice); 672 /* only support for one config for now */ 673 usb_get_configuration_no(dev,&tmpbuf[0],0); 674 usb_parse_config(dev,&tmpbuf[0],0); 675 usb_set_maxpacket(dev); 676 /* we set the default configuration here */ 677 if (usb_set_configuration(dev, dev->config.bConfigurationValue)) { 678 printf("failed to set default configuration len %d, status %lX\n",dev->act_len,dev->status); 679 return -1; 680 } 681 USB_PRINTF("new device strings: Mfr=%d, Product=%d, SerialNumber=%d\n", 682 dev->descriptor.iManufacturer, dev->descriptor.iProduct, dev->descriptor.iSerialNumber); 683 memset(dev->mf, 0, sizeof(dev->mf)); 684 memset(dev->prod, 0, sizeof(dev->prod)); 685 memset(dev->serial, 0, sizeof(dev->serial)); 686 if (dev->descriptor.iManufacturer) 687 usb_string(dev, dev->descriptor.iManufacturer, dev->mf, sizeof(dev->mf)); 688 if (dev->descriptor.iProduct) 689 usb_string(dev, dev->descriptor.iProduct, dev->prod, sizeof(dev->prod)); 690 if (dev->descriptor.iSerialNumber) 691 usb_string(dev, dev->descriptor.iSerialNumber, dev->serial, sizeof(dev->serial)); 692 USB_PRINTF("Manufacturer %s\n", dev->mf); 693 USB_PRINTF("Product %s\n", dev->prod); 694 USB_PRINTF("SerialNumber %s\n", dev->serial); 695 /* now prode if the device is a hub */ 696 usb_hub_probe(dev,0); 697 return 0; 698 } 699 700 /* build device Tree */ 701 void usb_scan_devices(void) 702 { 703 int i; 704 struct usb_device *dev; 705 706 /* first make all devices unknown */ 707 for(i=0;i<USB_MAX_DEVICE;i++) { 708 memset(&usb_dev[i],0,sizeof(struct usb_device)); 709 usb_dev[i].devnum=-1; 710 } 711 dev_index=0; 712 /* device 0 is always present (root hub, so let it analyze) */ 713 dev=usb_alloc_new_device(); 714 usb_new_device(dev); 715 printf("%d USB Devices found\n",dev_index); 716 /* insert "driver" if possible */ 717 #ifdef CONFIG_USB_KEYBOARD 718 drv_usb_kbd_init(); 719 USB_PRINTF("scan end\n"); 720 #endif 721 } 722 723 724 /**************************************************************************** 725 * HUB "Driver" 726 * Probes device for being a hub and configurate it 727 */ 728 729 #undef USB_HUB_DEBUG 730 731 #ifdef USB_HUB_DEBUG 732 #define USB_HUB_PRINTF(fmt,args...) printf (fmt ,##args) 733 #else 734 #define USB_HUB_PRINTF(fmt,args...) 735 #endif 736 737 738 static struct usb_hub_device hub_dev[USB_MAX_HUB]; 739 static int usb_hub_index; 740 741 742 int usb_get_hub_descriptor(struct usb_device *dev, void *data, int size) 743 { 744 return usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), 745 USB_REQ_GET_DESCRIPTOR, USB_DIR_IN | USB_RT_HUB, 746 USB_DT_HUB << 8, 0, data, size, USB_CNTL_TIMEOUT); 747 } 748 749 int usb_clear_hub_feature(struct usb_device *dev, int feature) 750 { 751 return usb_control_msg(dev, usb_sndctrlpipe(dev, 0), 752 USB_REQ_CLEAR_FEATURE, USB_RT_HUB, feature, 0, NULL, 0, USB_CNTL_TIMEOUT); 753 } 754 755 int usb_clear_port_feature(struct usb_device *dev, int port, int feature) 756 { 757 return usb_control_msg(dev, usb_sndctrlpipe(dev, 0), 758 USB_REQ_CLEAR_FEATURE, USB_RT_PORT, feature, port, NULL, 0, USB_CNTL_TIMEOUT); 759 } 760 761 int usb_set_port_feature(struct usb_device *dev, int port, int feature) 762 { 763 return usb_control_msg(dev, usb_sndctrlpipe(dev, 0), 764 USB_REQ_SET_FEATURE, USB_RT_PORT, feature, port, NULL, 0, USB_CNTL_TIMEOUT); 765 } 766 767 int usb_get_hub_status(struct usb_device *dev, void *data) 768 { 769 return usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), 770 USB_REQ_GET_STATUS, USB_DIR_IN | USB_RT_HUB, 0, 0, 771 data, sizeof(struct usb_hub_status), USB_CNTL_TIMEOUT); 772 } 773 774 int usb_get_port_status(struct usb_device *dev, int port, void *data) 775 { 776 return usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), 777 USB_REQ_GET_STATUS, USB_DIR_IN | USB_RT_PORT, 0, port, 778 data, sizeof(struct usb_hub_status), USB_CNTL_TIMEOUT); 779 } 780 781 782 static void usb_hub_power_on(struct usb_hub_device *hub) 783 { 784 int i; 785 struct usb_device *dev; 786 787 dev=hub->pusb_dev; 788 /* Enable power to the ports */ 789 USB_HUB_PRINTF("enabling power on all ports\n"); 790 for (i = 0; i < dev->maxchild; i++) { 791 usb_set_port_feature(dev, i + 1, USB_PORT_FEAT_POWER); 792 USB_HUB_PRINTF("port %d returns %lX\n",i+1,dev->status); 793 wait_ms(hub->desc.bPwrOn2PwrGood * 2); 794 } 795 } 796 797 void usb_hub_reset(void) 798 { 799 usb_hub_index=0; 800 } 801 802 struct usb_hub_device *usb_hub_allocate(void) 803 { 804 if(usb_hub_index<USB_MAX_HUB) { 805 return &hub_dev[usb_hub_index++]; 806 } 807 printf("ERROR: USB_MAX_HUB (%d) reached\n",USB_MAX_HUB); 808 return NULL; 809 } 810 811 #define MAX_TRIES 5 812 813 void usb_hub_port_connect_change(struct usb_device *dev, int port) 814 { 815 struct usb_device *usb; 816 struct usb_port_status portsts; 817 unsigned short portstatus, portchange; 818 int tries; 819 820 /* Check status */ 821 if (usb_get_port_status(dev, port + 1, &portsts)<0) { 822 USB_HUB_PRINTF("get_port_status failed\n"); 823 return; 824 } 825 826 portstatus = swap_16(portsts.wPortStatus); 827 portchange = swap_16(portsts.wPortChange); 828 USB_HUB_PRINTF("portstatus %x, change %x, %s\n", portstatus, portchange, 829 portstatus&(1<<USB_PORT_FEAT_LOWSPEED) ? "Low Speed" : "High Speed"); 830 831 /* Clear the connection change status */ 832 usb_clear_port_feature(dev, port + 1, USB_PORT_FEAT_C_CONNECTION); 833 834 /* Disconnect any existing devices under this port */ 835 if (((!(portstatus & USB_PORT_STAT_CONNECTION)) && 836 (!(portstatus & USB_PORT_STAT_ENABLE)))|| (dev->children[port])) { 837 USB_HUB_PRINTF("usb_disconnect(&hub->children[port]);\n"); 838 /* Return now if nothing is connected */ 839 if (!(portstatus & USB_PORT_STAT_CONNECTION)) 840 return; 841 } 842 wait_ms(200); 843 844 /* Reset the port */ 845 846 for(tries=0;tries<MAX_TRIES;tries++) { 847 848 usb_set_port_feature(dev, port + 1, USB_PORT_FEAT_RESET); 849 wait_ms(200); 850 851 if (usb_get_port_status(dev, port + 1, &portsts)<0) { 852 USB_HUB_PRINTF("get_port_status failed status %lX\n",dev->status); 853 return; 854 } 855 portstatus = swap_16(portsts.wPortStatus); 856 portchange = swap_16(portsts.wPortChange); 857 USB_HUB_PRINTF("portstatus %x, change %x, %s\n", portstatus ,portchange, 858 portstatus&(1<<USB_PORT_FEAT_LOWSPEED) ? "Low Speed" : "High Speed"); 859 USB_HUB_PRINTF("STAT_C_CONNECTION = %d STAT_CONNECTION = %d USB_PORT_STAT_ENABLE %d\n", 860 (portchange & USB_PORT_STAT_C_CONNECTION) ? 1 : 0, 861 (portstatus & USB_PORT_STAT_CONNECTION) ? 1 : 0, 862 (portstatus & USB_PORT_STAT_ENABLE) ? 1 : 0); 863 if ((portchange & USB_PORT_STAT_C_CONNECTION) || 864 !(portstatus & USB_PORT_STAT_CONNECTION)) 865 return; 866 867 if (portstatus & USB_PORT_STAT_ENABLE) 868 break; 869 870 wait_ms(200); 871 } 872 873 if (tries==MAX_TRIES) { 874 USB_HUB_PRINTF("Cannot enable port %i after %i retries, disabling port.\n", port+1, MAX_TRIES); 875 USB_HUB_PRINTF("Maybe the USB cable is bad?\n"); 876 return; 877 } 878 879 usb_clear_port_feature(dev, port + 1, USB_PORT_FEAT_C_RESET); 880 wait_ms(200); 881 882 /* Allocate a new device struct for it */ 883 usb=usb_alloc_new_device(); 884 usb->slow = (portstatus & USB_PORT_STAT_LOW_SPEED) ? 1 : 0; 885 886 dev->children[port] = usb; 887 usb->parent=dev; 888 /* Run it through the hoops (find a driver, etc) */ 889 if (usb_new_device(usb)) { 890 /* Woops, disable the port */ 891 USB_HUB_PRINTF("hub: disabling port %d\n", port + 1); 892 usb_clear_port_feature(dev, port + 1, USB_PORT_FEAT_ENABLE); 893 } 894 } 895 896 897 int usb_hub_configure(struct usb_device *dev) 898 { 899 unsigned char buffer[256], *bitmap; 900 struct usb_hub_descriptor *descriptor; 901 struct usb_hub_status *hubsts; 902 int i; 903 struct usb_hub_device *hub; 904 905 /* "allocate" Hub device */ 906 hub=usb_hub_allocate(); 907 if(hub==NULL) 908 return -1; 909 hub->pusb_dev=dev; 910 /* Get the the hub descriptor */ 911 if (usb_get_hub_descriptor(dev, buffer, 4) < 0) { 912 USB_HUB_PRINTF("usb_hub_configure: failed to get hub descriptor, giving up %lX\n",dev->status); 913 return -1; 914 } 915 descriptor = (struct usb_hub_descriptor *)buffer; 916 if (usb_get_hub_descriptor(dev, buffer, descriptor->bLength) < 0) { 917 USB_HUB_PRINTF("usb_hub_configure: failed to get hub descriptor 2nd giving up %lX\n",dev->status); 918 return -1; 919 } 920 memcpy((unsigned char *)&hub->desc,buffer,descriptor->bLength); 921 /* adjust 16bit values */ 922 hub->desc.wHubCharacteristics=swap_16(descriptor->wHubCharacteristics); 923 /* set the bitmap */ 924 bitmap=(unsigned char *)&hub->desc.DeviceRemovable[0]; 925 memset(bitmap,0xff,(USB_MAXCHILDREN+1+7)/8); /* devices not removable by default */ 926 bitmap=(unsigned char *)&hub->desc.PortPowerCtrlMask[0]; 927 memset(bitmap,0xff,(USB_MAXCHILDREN+1+7)/8); /* PowerMask = 1B */ 928 for(i=0;i<((hub->desc.bNbrPorts + 1 + 7)/8);i++) { 929 hub->desc.DeviceRemovable[i]=descriptor->DeviceRemovable[i]; 930 } 931 for(i=0;i<((hub->desc.bNbrPorts + 1 + 7)/8);i++) { 932 hub->desc.DeviceRemovable[i]=descriptor->PortPowerCtrlMask[i]; 933 } 934 dev->maxchild = descriptor->bNbrPorts; 935 USB_HUB_PRINTF("%d ports detected\n", dev->maxchild); 936 937 switch (hub->desc.wHubCharacteristics & HUB_CHAR_LPSM) { 938 case 0x00: 939 USB_HUB_PRINTF("ganged power switching\n"); 940 break; 941 case 0x01: 942 USB_HUB_PRINTF("individual port power switching\n"); 943 break; 944 case 0x02: 945 case 0x03: 946 USB_HUB_PRINTF("unknown reserved power switching mode\n"); 947 break; 948 } 949 950 if (hub->desc.wHubCharacteristics & HUB_CHAR_COMPOUND) 951 USB_HUB_PRINTF("part of a compound device\n"); 952 else 953 USB_HUB_PRINTF("standalone hub\n"); 954 955 switch (hub->desc.wHubCharacteristics & HUB_CHAR_OCPM) { 956 case 0x00: 957 USB_HUB_PRINTF("global over-current protection\n"); 958 break; 959 case 0x08: 960 USB_HUB_PRINTF("individual port over-current protection\n"); 961 break; 962 case 0x10: 963 case 0x18: 964 USB_HUB_PRINTF("no over-current protection\n"); 965 break; 966 } 967 USB_HUB_PRINTF("power on to power good time: %dms\n", descriptor->bPwrOn2PwrGood * 2); 968 USB_HUB_PRINTF("hub controller current requirement: %dmA\n", descriptor->bHubContrCurrent); 969 for (i = 0; i < dev->maxchild; i++) 970 USB_HUB_PRINTF("port %d is%s removable\n", i + 1, 971 hub->desc.DeviceRemovable[(i + 1)/8] & (1 << ((i + 1)%8)) ? " not" : ""); 972 if (usb_get_hub_status(dev, buffer) < 0) { 973 USB_HUB_PRINTF("usb_hub_configure: failed to get Status %lX\n",dev->status); 974 return -1; 975 } 976 hubsts = (struct usb_hub_status *)buffer; 977 USB_HUB_PRINTF("get_hub_status returned status %X, change %X\n", 978 swap_16(hubsts->wHubStatus),swap_16(hubsts->wHubChange)); 979 USB_HUB_PRINTF("local power source is %s\n", 980 (swap_16(hubsts->wHubStatus) & HUB_STATUS_LOCAL_POWER) ? "lost (inactive)" : "good"); 981 USB_HUB_PRINTF("%sover-current condition exists\n", 982 (swap_16(hubsts->wHubStatus) & HUB_STATUS_OVERCURRENT) ? "" : "no "); 983 usb_hub_power_on(hub); 984 for (i = 0; i < dev->maxchild; i++) { 985 struct usb_port_status portsts; 986 unsigned short portstatus, portchange; 987 988 if (usb_get_port_status(dev, i + 1, &portsts) < 0) { 989 USB_HUB_PRINTF("get_port_status failed\n"); 990 continue; 991 } 992 portstatus = swap_16(portsts.wPortStatus); 993 portchange = swap_16(portsts.wPortChange); 994 USB_HUB_PRINTF("Port %d Status %X Change %X\n",i+1,portstatus,portchange); 995 if (portchange & USB_PORT_STAT_C_CONNECTION) { 996 USB_HUB_PRINTF("port %d connection change\n", i + 1); 997 usb_hub_port_connect_change(dev, i); 998 } 999 if (portchange & USB_PORT_STAT_C_ENABLE) { 1000 USB_HUB_PRINTF("port %d enable change, status %x\n", i + 1, portstatus); 1001 usb_clear_port_feature(dev, i + 1, USB_PORT_FEAT_C_ENABLE); 1002 1003 /* EM interference sometimes causes bad shielded USB devices to 1004 * be shutdown by the hub, this hack enables them again. 1005 * Works at least with mouse driver */ 1006 if (!(portstatus & USB_PORT_STAT_ENABLE) && 1007 (portstatus & USB_PORT_STAT_CONNECTION) && (dev->children[i])) { 1008 USB_HUB_PRINTF("already running port %i disabled by hub (EMI?), re-enabling...\n", 1009 i + 1); 1010 usb_hub_port_connect_change(dev, i); 1011 } 1012 } 1013 if (portstatus & USB_PORT_STAT_SUSPEND) { 1014 USB_HUB_PRINTF("port %d suspend change\n", i + 1); 1015 usb_clear_port_feature(dev, i + 1, USB_PORT_FEAT_SUSPEND); 1016 } 1017 1018 if (portchange & USB_PORT_STAT_C_OVERCURRENT) { 1019 USB_HUB_PRINTF("port %d over-current change\n", i + 1); 1020 usb_clear_port_feature(dev, i + 1, USB_PORT_FEAT_C_OVER_CURRENT); 1021 usb_hub_power_on(hub); 1022 } 1023 1024 if (portchange & USB_PORT_STAT_C_RESET) { 1025 USB_HUB_PRINTF("port %d reset change\n", i + 1); 1026 usb_clear_port_feature(dev, i + 1, USB_PORT_FEAT_C_RESET); 1027 } 1028 } /* end for i all ports */ 1029 1030 return 0; 1031 } 1032 1033 int usb_hub_probe(struct usb_device *dev, int ifnum) 1034 { 1035 struct usb_interface_descriptor *iface; 1036 struct usb_endpoint_descriptor *ep; 1037 int ret; 1038 1039 iface = &dev->config.if_desc[ifnum]; 1040 /* Is it a hub? */ 1041 if (iface->bInterfaceClass != USB_CLASS_HUB) 1042 return 0; 1043 /* Some hubs have a subclass of 1, which AFAICT according to the */ 1044 /* specs is not defined, but it works */ 1045 if ((iface->bInterfaceSubClass != 0) && 1046 (iface->bInterfaceSubClass != 1)) 1047 return 0; 1048 /* Multiple endpoints? What kind of mutant ninja-hub is this? */ 1049 if (iface->bNumEndpoints != 1) 1050 return 0; 1051 ep = &iface->ep_desc[0]; 1052 /* Output endpoint? Curiousier and curiousier.. */ 1053 if (!(ep->bEndpointAddress & USB_DIR_IN)) 1054 return 0; 1055 /* If it's not an interrupt endpoint, we'd better punt! */ 1056 if ((ep->bmAttributes & 3) != 3) 1057 return 0; 1058 /* We found a hub */ 1059 USB_HUB_PRINTF("USB hub found\n"); 1060 ret=usb_hub_configure(dev); 1061 return ret; 1062 } 1063 1064 #endif /* (CONFIG_COMMANDS & CFG_CMD_USB) */ 1065 1066 /* EOF */ 1067