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