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 /* Note: 29 * Currently only the CBI transport protocoll has been implemented, and it 30 * is only tested with a TEAC USB Floppy. Other Massstorages with CBI or CB 31 * transport protocoll may work as well. 32 */ 33 34 35 36 #include <common.h> 37 #include <command.h> 38 #include <asm/processor.h> 39 40 41 #if (CONFIG_COMMANDS & CFG_CMD_USB) 42 #include <usb.h> 43 44 #ifdef CONFIG_USB_STORAGE 45 46 #undef USB_STOR_DEBUG 47 48 #ifdef USB_STOR_DEBUG 49 #define USB_STOR_PRINTF(fmt,args...) printf (fmt ,##args) 50 #else 51 #define USB_STOR_PRINTF(fmt,args...) 52 #endif 53 54 #include <scsi.h> 55 /* direction table -- this indicates the direction of the data 56 * transfer for each command code -- a 1 indicates input 57 */ 58 unsigned char us_direction[256/8] = { 59 0x28, 0x81, 0x14, 0x14, 0x20, 0x01, 0x90, 0x77, 60 0x0C, 0x20, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 61 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 62 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 63 }; 64 #define US_DIRECTION(x) ((us_direction[x>>3] >> (x & 7)) & 1) 65 66 static unsigned char usb_stor_buf[512]; 67 static ccb usb_ccb; 68 69 /* 70 * CBI style 71 */ 72 73 #define US_CBI_ADSC 0 74 75 76 #define USB_MAX_STOR_DEV 5 77 static int usb_max_devs; /* number of highest available usb device */ 78 79 static block_dev_desc_t usb_dev_desc[USB_MAX_STOR_DEV]; 80 81 struct us_data; 82 typedef int (*trans_cmnd)(ccb*, struct us_data*); 83 typedef int (*trans_reset)(struct us_data*); 84 85 struct us_data { 86 struct usb_device *pusb_dev; /* this usb_device */ 87 unsigned int flags; /* from filter initially */ 88 unsigned char ifnum; /* interface number */ 89 unsigned char ep_in; /* in endpoint */ 90 unsigned char ep_out; /* out ....... */ 91 unsigned char ep_int; /* interrupt . */ 92 unsigned char subclass; /* as in overview */ 93 unsigned char protocol; /* .............. */ 94 unsigned char attention_done; /* force attn on first cmd */ 95 unsigned short ip_data; /* interrupt data */ 96 int action; /* what to do */ 97 int ip_wanted; /* needed */ 98 int *irq_handle; /* for USB int requests */ 99 unsigned int irqpipe; /* pipe for release_irq */ 100 unsigned char irqmaxp; /* max packed for irq Pipe */ 101 unsigned char irqinterval; /* Intervall for IRQ Pipe */ 102 ccb *srb; /* current srb */ 103 trans_reset transport_reset; /* reset routine */ 104 trans_cmnd transport; /* transport routine */ 105 }; 106 107 static struct us_data usb_stor[USB_MAX_STOR_DEV]; 108 109 110 111 #define USB_STOR_TRANSPORT_GOOD 0 112 #define USB_STOR_TRANSPORT_FAILED -1 113 #define USB_STOR_TRANSPORT_ERROR -2 114 115 116 117 118 119 120 int usb_stor_get_info(struct usb_device *dev, struct us_data *us, block_dev_desc_t *dev_desc); 121 int usb_storage_probe(struct usb_device *dev, unsigned int ifnum,struct us_data *ss); 122 unsigned long usb_stor_read(int device, unsigned long blknr, unsigned long blkcnt, unsigned long *buffer); 123 struct usb_device * usb_get_dev_index(int index); 124 void uhci_show_temp_int_td(void); 125 126 block_dev_desc_t *usb_stor_get_dev(int index) 127 { 128 return &usb_dev_desc[index]; 129 } 130 131 132 void usb_show_progress(void) 133 { 134 printf("."); 135 } 136 137 /********************************************************************************* 138 * (re)-scan the usb and reports device info 139 * to the user if mode = 1 140 * returns current device or -1 if no 141 */ 142 int usb_stor_scan(int mode) 143 { 144 unsigned char i; 145 struct usb_device *dev; 146 147 if(mode==1) { 148 printf("scanning bus for storage devices...\n"); 149 } 150 usb_disable_asynch(1); /* asynch transfer not allowed */ 151 152 for(i=0;i<USB_MAX_STOR_DEV;i++) { 153 memset(&usb_dev_desc[i],0,sizeof(block_dev_desc_t)); 154 usb_dev_desc[i].target=0xff; 155 usb_dev_desc[i].if_type=IF_TYPE_USB; 156 usb_dev_desc[i].dev=i; 157 usb_dev_desc[i].part_type=PART_TYPE_UNKNOWN; 158 usb_dev_desc[i].block_read=usb_stor_read; 159 } 160 usb_max_devs=0; 161 for(i=0;i<USB_MAX_DEVICE;i++) { 162 dev=usb_get_dev_index(i); /* get device */ 163 USB_STOR_PRINTF("i=%d\n",i); 164 if(dev==NULL) { 165 break; /* no more devices avaiable */ 166 } 167 if(usb_storage_probe(dev,0,&usb_stor[usb_max_devs])) { /* ok, it is a storage devices */ 168 /* get info and fill it in */ 169 170 if(usb_stor_get_info(dev, &usb_stor[usb_max_devs], &usb_dev_desc[usb_max_devs])) { 171 if(mode==1) { 172 printf (" Device %d: ", usb_max_devs); 173 dev_print(&usb_dev_desc[usb_max_devs]); 174 } /* if mode */ 175 usb_max_devs++; 176 } /* if get info ok */ 177 } /* if storage device */ 178 if(usb_max_devs==USB_MAX_STOR_DEV) { 179 printf("max USB Storage Device reached: %d stopping\n",usb_max_devs); 180 break; 181 } 182 } /* for */ 183 usb_disable_asynch(0); /* asynch transfer allowed */ 184 if(usb_max_devs>0) 185 return 0; 186 else 187 return-1; 188 } 189 190 static int usb_stor_irq(struct usb_device *dev) 191 { 192 struct us_data *us; 193 us=(struct us_data *)dev->privptr; 194 195 if(us->ip_wanted) { 196 us->ip_wanted=0; 197 } 198 return 0; 199 } 200 201 202 #ifdef USB_STOR_DEBUG 203 204 static void usb_show_srb(ccb * pccb) 205 { 206 int i; 207 printf("SRB: len %d datalen 0x%lX\n ",pccb->cmdlen,pccb->datalen); 208 for(i=0;i<12;i++) { 209 printf("%02X ",pccb->cmd[i]); 210 } 211 printf("\n"); 212 } 213 214 static void display_int_status(unsigned long tmp) 215 { 216 printf("Status: %s %s %s %s %s %s %s\n", 217 (tmp & USB_ST_ACTIVE) ? "Active" : "", 218 (tmp & USB_ST_STALLED) ? "Stalled" : "", 219 (tmp & USB_ST_BUF_ERR) ? "Buffer Error" : "", 220 (tmp & USB_ST_BABBLE_DET) ? "Babble Det" : "", 221 (tmp & USB_ST_NAK_REC) ? "NAKed" : "", 222 (tmp & USB_ST_CRC_ERR) ? "CRC Error" : "", 223 (tmp & USB_ST_BIT_ERR) ? "Bitstuff Error" : ""); 224 } 225 #endif 226 /*********************************************************************** 227 * Data transfer routines 228 ***********************************************************************/ 229 230 static int us_one_transfer(struct us_data *us, int pipe, char *buf, int length) 231 { 232 int max_size; 233 int this_xfer; 234 int result; 235 int partial; 236 int maxtry; 237 int stat; 238 239 /* determine the maximum packet size for these transfers */ 240 max_size = usb_maxpacket(us->pusb_dev, pipe) * 16; 241 242 /* while we have data left to transfer */ 243 while (length) { 244 245 /* calculate how long this will be -- maximum or a remainder */ 246 this_xfer = length > max_size ? max_size : length; 247 length -= this_xfer; 248 249 /* setup the retry counter */ 250 maxtry = 10; 251 252 /* set up the transfer loop */ 253 do { 254 /* transfer the data */ 255 USB_STOR_PRINTF("Bulk xfer 0x%x(%d) try #%d\n", 256 (unsigned int)buf, this_xfer, 11 - maxtry); 257 result = usb_bulk_msg(us->pusb_dev, pipe, buf, 258 this_xfer, &partial, USB_CNTL_TIMEOUT*5); 259 USB_STOR_PRINTF("bulk_msg returned %d xferred %d/%d\n", 260 result, partial, this_xfer); 261 if(us->pusb_dev->status!=0) { 262 /* if we stall, we need to clear it before we go on */ 263 #ifdef USB_STOR_DEBUG 264 display_int_status(us->pusb_dev->status); 265 #endif 266 if (us->pusb_dev->status & USB_ST_STALLED) { 267 USB_STOR_PRINTF("stalled ->clearing endpoint halt for pipe 0x%x\n", pipe); 268 stat = us->pusb_dev->status; 269 usb_clear_halt(us->pusb_dev, pipe); 270 us->pusb_dev->status=stat; 271 if(this_xfer == partial) { 272 USB_STOR_PRINTF("bulk transferred with error %X, but data ok\n",us->pusb_dev->status); 273 return 0; 274 } 275 else 276 return result; 277 } 278 if (us->pusb_dev->status & USB_ST_NAK_REC) { 279 USB_STOR_PRINTF("Device NAKed bulk_msg\n"); 280 return result; 281 } 282 if(this_xfer == partial) { 283 USB_STOR_PRINTF("bulk transferred with error %d, but data ok\n",us->pusb_dev->status); 284 return 0; 285 } 286 /* if our try counter reaches 0, bail out */ 287 USB_STOR_PRINTF("bulk transferred with error %d, data %d\n",us->pusb_dev->status,partial); 288 if (!maxtry--) 289 return result; 290 } 291 /* update to show what data was transferred */ 292 this_xfer -= partial; 293 buf += partial; 294 /* continue until this transfer is done */ 295 } while ( this_xfer ); 296 } 297 298 /* if we get here, we're done and successful */ 299 return 0; 300 } 301 302 /* FIXME: this reset function doesn't really reset the port, and it 303 * should. Actually it should probably do what it's doing here, and 304 * reset the port physically 305 */ 306 static int usb_stor_CB_reset(struct us_data *us) 307 { 308 unsigned char cmd[12]; 309 int result; 310 311 USB_STOR_PRINTF("CB_reset\n"); 312 memset(cmd, 0xFF, sizeof(cmd)); 313 cmd[0] = SCSI_SEND_DIAG; 314 cmd[1] = 4; 315 result = usb_control_msg(us->pusb_dev, usb_sndctrlpipe(us->pusb_dev,0), 316 US_CBI_ADSC, USB_TYPE_CLASS | USB_RECIP_INTERFACE, 317 0, us->ifnum, cmd, sizeof(cmd), USB_CNTL_TIMEOUT*5); 318 319 /* long wait for reset */ 320 wait_ms(1500); 321 USB_STOR_PRINTF("CB_reset result %d: status %X clearing endpoint halt\n",result,us->pusb_dev->status); 322 usb_clear_halt(us->pusb_dev, usb_rcvbulkpipe(us->pusb_dev, us->ep_in)); 323 usb_clear_halt(us->pusb_dev, usb_rcvbulkpipe(us->pusb_dev, us->ep_out)); 324 325 USB_STOR_PRINTF("CB_reset done\n"); 326 return 0; 327 } 328 329 /* FIXME: we also need a CBI_command which sets up the completion 330 * interrupt, and waits for it 331 */ 332 int usb_stor_CB_comdat(ccb *srb, struct us_data *us) 333 { 334 int result; 335 int dir_in,retry; 336 unsigned int pipe; 337 unsigned long status; 338 339 retry=5; 340 dir_in=US_DIRECTION(srb->cmd[0]); 341 342 if(dir_in) 343 pipe=usb_rcvbulkpipe(us->pusb_dev, us->ep_in); 344 else 345 pipe=usb_sndbulkpipe(us->pusb_dev, us->ep_out); 346 while(retry--) { 347 USB_STOR_PRINTF("CBI gets a command: Try %d\n",5-retry); 348 #ifdef USB_STOR_DEBUG 349 usb_show_srb(srb); 350 #endif 351 /* let's send the command via the control pipe */ 352 result = usb_control_msg(us->pusb_dev, usb_sndctrlpipe(us->pusb_dev,0), 353 US_CBI_ADSC, USB_TYPE_CLASS | USB_RECIP_INTERFACE, 354 0, us->ifnum, 355 srb->cmd, srb->cmdlen, USB_CNTL_TIMEOUT*5); 356 USB_STOR_PRINTF("CB_transport: control msg returned %d, status %X\n",result,us->pusb_dev->status); 357 /* check the return code for the command */ 358 if (result < 0) { 359 if(us->pusb_dev->status & USB_ST_STALLED) { 360 status=us->pusb_dev->status; 361 USB_STOR_PRINTF(" stall during command found, clear pipe\n"); 362 usb_clear_halt(us->pusb_dev, usb_sndctrlpipe(us->pusb_dev,0)); 363 us->pusb_dev->status=status; 364 } 365 USB_STOR_PRINTF(" error during command %02X Stat = %X\n",srb->cmd[0],us->pusb_dev->status); 366 return result; 367 } 368 /* transfer the data payload for this command, if one exists*/ 369 370 USB_STOR_PRINTF("CB_transport: control msg returned %d, direction is %s to go 0x%lx\n",result,dir_in ? "IN" : "OUT",srb->datalen); 371 if (srb->datalen) { 372 result = us_one_transfer(us, pipe, srb->pdata,srb->datalen); 373 USB_STOR_PRINTF("CBI attempted to transfer data, result is %d status %lX, len %d\n", result,us->pusb_dev->status,us->pusb_dev->act_len); 374 if(!(us->pusb_dev->status & USB_ST_NAK_REC)) 375 break; 376 } /* if (srb->datalen) */ 377 else 378 break; 379 } 380 /* return result */ 381 382 return result; 383 } 384 385 386 int usb_stor_CBI_get_status(ccb *srb, struct us_data *us) 387 { 388 int timeout; 389 390 us->ip_wanted=1; 391 submit_int_msg(us->pusb_dev,us->irqpipe, 392 (void *)&us->ip_data,us->irqmaxp ,us->irqinterval); 393 timeout=1000; 394 while(timeout--) { 395 if((volatile int *)us->ip_wanted==0) 396 break; 397 wait_ms(10); 398 } 399 if (us->ip_wanted) { 400 printf(" Did not get interrupt on CBI\n"); 401 us->ip_wanted = 0; 402 return USB_STOR_TRANSPORT_ERROR; 403 } 404 USB_STOR_PRINTF("Got interrupt data 0x%x, transfered %d status 0x%lX\n", us->ip_data,us->pusb_dev->irq_act_len,us->pusb_dev->irq_status); 405 /* UFI gives us ASC and ASCQ, like a request sense */ 406 if (us->subclass == US_SC_UFI) { 407 if (srb->cmd[0] == SCSI_REQ_SENSE || 408 srb->cmd[0] == SCSI_INQUIRY) 409 return USB_STOR_TRANSPORT_GOOD; /* Good */ 410 else 411 if (us->ip_data) 412 return USB_STOR_TRANSPORT_FAILED; 413 else 414 return USB_STOR_TRANSPORT_GOOD; 415 } 416 /* otherwise, we interpret the data normally */ 417 switch (us->ip_data) { 418 case 0x0001: 419 return USB_STOR_TRANSPORT_GOOD; 420 case 0x0002: 421 return USB_STOR_TRANSPORT_FAILED; 422 default: 423 return USB_STOR_TRANSPORT_ERROR; 424 } /* switch */ 425 return USB_STOR_TRANSPORT_ERROR; 426 } 427 428 #define USB_TRANSPORT_UNKNOWN_RETRY 5 429 #define USB_TRANSPORT_NOT_READY_RETRY 10 430 431 int usb_stor_CB_transport(ccb *srb, struct us_data *us) 432 { 433 int result,status; 434 ccb *psrb; 435 ccb reqsrb; 436 int retry,notready; 437 438 psrb=&reqsrb; 439 status=USB_STOR_TRANSPORT_GOOD; 440 retry=0; 441 notready=0; 442 /* issue the command */ 443 do_retry: 444 result=usb_stor_CB_comdat(srb,us); 445 USB_STOR_PRINTF("command / Data returned %d, status %X\n",result,us->pusb_dev->status); 446 /* if this is an CBI Protocol, get IRQ */ 447 if(us->protocol==US_PR_CBI) { 448 status=usb_stor_CBI_get_status(srb,us); 449 /* if the status is error, report it */ 450 if(status==USB_STOR_TRANSPORT_ERROR) { 451 USB_STOR_PRINTF(" USB CBI Command Error\n"); 452 return status; 453 } 454 srb->sense_buf[12]=(unsigned char)(us->ip_data>>8); 455 srb->sense_buf[13]=(unsigned char)(us->ip_data&0xff); 456 if(!us->ip_data) { 457 /* if the status is good, report it */ 458 if(status==USB_STOR_TRANSPORT_GOOD) { 459 USB_STOR_PRINTF(" USB CBI Command Good\n"); 460 return status; 461 } 462 } 463 } 464 /* do we have to issue an auto request? */ 465 /* HERE we have to check the result */ 466 if((result<0) && !(us->pusb_dev->status & USB_ST_STALLED)) { 467 USB_STOR_PRINTF("ERROR %X\n",us->pusb_dev->status); 468 us->transport_reset(us); 469 return USB_STOR_TRANSPORT_ERROR; 470 } 471 if((us->protocol==US_PR_CBI) && 472 ((srb->cmd[0]==SCSI_REQ_SENSE) || 473 (srb->cmd[0]==SCSI_INQUIRY))) { /* do not issue an autorequest after request sense */ 474 USB_STOR_PRINTF("No auto request and good\n"); 475 return USB_STOR_TRANSPORT_GOOD; 476 } 477 /* issue an request_sense */ 478 memset(&psrb->cmd[0],0,12); 479 psrb->cmd[0]=SCSI_REQ_SENSE; 480 psrb->cmd[1]=srb->lun<<5; 481 psrb->cmd[4]=18; 482 psrb->datalen=18; 483 psrb->pdata=&srb->sense_buf[0]; 484 psrb->cmdlen=12; 485 /* issue the command */ 486 result=usb_stor_CB_comdat(psrb,us); 487 USB_STOR_PRINTF("auto request returned %d\n",result); 488 /* if this is an CBI Protocol, get IRQ */ 489 if(us->protocol==US_PR_CBI) { 490 status=usb_stor_CBI_get_status(psrb,us); 491 } 492 if((result<0)&&!(us->pusb_dev->status & USB_ST_STALLED)) { 493 USB_STOR_PRINTF(" AUTO REQUEST ERROR %d\n",us->pusb_dev->status); 494 return USB_STOR_TRANSPORT_ERROR; 495 } 496 USB_STOR_PRINTF("autorequest returned 0x%02X 0x%02X 0x%02X 0x%02X\n",srb->sense_buf[0],srb->sense_buf[2],srb->sense_buf[12],srb->sense_buf[13]); 497 /* Check the auto request result */ 498 if((srb->sense_buf[2]==0) && 499 (srb->sense_buf[12]==0) && 500 (srb->sense_buf[13]==0)) /* ok, no sense */ 501 return USB_STOR_TRANSPORT_GOOD; 502 /* Check the auto request result */ 503 switch(srb->sense_buf[2]) { 504 case 0x01: /* Recovered Error */ 505 return USB_STOR_TRANSPORT_GOOD; 506 break; 507 case 0x02: /* Not Ready */ 508 if(notready++ > USB_TRANSPORT_NOT_READY_RETRY) { 509 printf("cmd 0x%02X returned 0x%02X 0x%02X 0x%02X 0x%02X (NOT READY)\n", 510 srb->cmd[0],srb->sense_buf[0],srb->sense_buf[2],srb->sense_buf[12],srb->sense_buf[13]); 511 return USB_STOR_TRANSPORT_FAILED; 512 } 513 else { 514 wait_ms(100); 515 goto do_retry; 516 } 517 break; 518 default: 519 if(retry++ > USB_TRANSPORT_UNKNOWN_RETRY) { 520 printf("cmd 0x%02X returned 0x%02X 0x%02X 0x%02X 0x%02X\n", 521 srb->cmd[0],srb->sense_buf[0],srb->sense_buf[2],srb->sense_buf[12],srb->sense_buf[13]); 522 return USB_STOR_TRANSPORT_FAILED; 523 } 524 else 525 goto do_retry; 526 break; 527 } 528 return USB_STOR_TRANSPORT_FAILED; 529 } 530 531 532 533 static int usb_inquiry(ccb *srb,struct us_data *ss) 534 { 535 int retry,i; 536 retry=3; 537 do { 538 memset(&srb->cmd[0],0,12); 539 srb->cmd[0]=SCSI_INQUIRY; 540 srb->cmd[1]=srb->lun<<5; 541 srb->cmd[4]=36; 542 srb->datalen=36; 543 srb->cmdlen=12; 544 i=ss->transport(srb,ss); 545 USB_STOR_PRINTF("inquiry returns %d\n",i); 546 if(i==0) 547 break; 548 }while(retry--); 549 if(!retry) { 550 printf("error in inquiry\n"); 551 return -1; 552 } 553 return 0; 554 } 555 556 static int usb_request_sense(ccb *srb,struct us_data *ss) 557 { 558 char *ptr; 559 return 0; 560 ptr=srb->pdata; 561 memset(&srb->cmd[0],0,12); 562 srb->cmd[0]=SCSI_REQ_SENSE; 563 srb->cmd[1]=srb->lun<<5; 564 srb->cmd[4]=18; 565 srb->datalen=18; 566 srb->pdata=&srb->sense_buf[0]; 567 srb->cmdlen=12; 568 ss->transport(srb,ss); 569 USB_STOR_PRINTF("Request Sense returned %02X %02X %02X\n",srb->sense_buf[2],srb->sense_buf[12],srb->sense_buf[13]); 570 srb->pdata=ptr; 571 return 0; 572 } 573 574 static int usb_test_unit_ready(ccb *srb,struct us_data *ss) 575 { 576 int retries=10; 577 do { 578 memset(&srb->cmd[0],0,12); 579 srb->cmd[0]=SCSI_TST_U_RDY; 580 srb->cmd[1]=srb->lun<<5; 581 srb->datalen=0; 582 srb->cmdlen=12; 583 if(ss->transport(srb,ss)==USB_STOR_TRANSPORT_GOOD) 584 { 585 return 0; 586 } 587 } while(retries--); 588 return -1; 589 } 590 591 static int usb_read_capacity(ccb *srb,struct us_data *ss) 592 { 593 int retry; 594 retry=2; /* retries */ 595 do { 596 memset(&srb->cmd[0],0,12); 597 srb->cmd[0]=SCSI_RD_CAPAC; 598 srb->cmd[1]=srb->lun<<5; 599 srb->datalen=8; 600 srb->cmdlen=12; 601 if(ss->transport(srb,ss)==USB_STOR_TRANSPORT_GOOD) { 602 return 0; 603 } 604 }while(retry--); 605 return -1; 606 } 607 608 static int usb_read_10(ccb *srb,struct us_data *ss, unsigned long start, unsigned short blocks) 609 { 610 memset(&srb->cmd[0],0,12); 611 srb->cmd[0]=SCSI_READ10; 612 srb->cmd[1]=srb->lun<<5; 613 srb->cmd[2]=((unsigned char) (start>>24))&0xff; 614 srb->cmd[3]=((unsigned char) (start>>16))&0xff; 615 srb->cmd[4]=((unsigned char) (start>>8))&0xff; 616 srb->cmd[5]=((unsigned char) (start))&0xff; 617 srb->cmd[7]=((unsigned char) (blocks>>8))&0xff; 618 srb->cmd[8]=(unsigned char) blocks & 0xff; 619 srb->cmdlen=12; 620 USB_STOR_PRINTF("read10: start %lx blocks %x\n",start,blocks); 621 return ss->transport(srb,ss); 622 } 623 624 625 #define USB_MAX_READ_BLK 20 626 627 unsigned long usb_stor_read(int device, unsigned long blknr, unsigned long blkcnt, unsigned long *buffer) 628 { 629 unsigned long start,blks, buf_addr; 630 unsigned short smallblks; 631 struct usb_device *dev; 632 int retry,i; 633 ccb *srb=&usb_ccb; 634 device&=0xff; 635 /* Setup device 636 */ 637 USB_STOR_PRINTF("\nusb_read: dev %d \n",device); 638 dev=NULL; 639 for(i=0;i<USB_MAX_DEVICE;i++) { 640 dev=usb_get_dev_index(i); 641 if(dev==NULL) { 642 return 0; 643 } 644 if(dev->devnum==usb_dev_desc[device].target) 645 break; 646 } 647 648 usb_disable_asynch(1); /* asynch transfer not allowed */ 649 srb->lun=usb_dev_desc[device].lun; 650 buf_addr=(unsigned long)buffer; 651 start=blknr; 652 blks=blkcnt; 653 if(usb_test_unit_ready(srb,(struct us_data *)dev->privptr)) { 654 printf("Device NOT ready\n Request Sense returned %02X %02X %02X\n", 655 srb->sense_buf[2],srb->sense_buf[12],srb->sense_buf[13]); 656 return 0; 657 } 658 USB_STOR_PRINTF("\nusb_read: dev %d startblk %lx, blccnt %lx buffer %lx\n",device,start,blks, buf_addr); 659 do { 660 retry=2; 661 srb->pdata=(unsigned char *)buf_addr; 662 if(blks>USB_MAX_READ_BLK) { 663 smallblks=USB_MAX_READ_BLK; 664 } 665 else { 666 smallblks=(unsigned short) blks; 667 } 668 retry_it: 669 if(smallblks==USB_MAX_READ_BLK) 670 usb_show_progress(); 671 srb->datalen=usb_dev_desc[device].blksz * smallblks; 672 srb->pdata=(unsigned char *)buf_addr; 673 if(usb_read_10(srb,(struct us_data *)dev->privptr, start, smallblks)) { 674 USB_STOR_PRINTF("Read ERROR\n"); 675 usb_request_sense(srb,(struct us_data *)dev->privptr); 676 if(retry--) 677 goto retry_it; 678 blkcnt-=blks; 679 break; 680 } 681 start+=smallblks; 682 blks-=smallblks; 683 buf_addr+=srb->datalen; 684 } while(blks!=0); 685 USB_STOR_PRINTF("usb_read: end startblk %lx, blccnt %x buffer %lx\n",start,smallblks,buf_addr); 686 usb_disable_asynch(0); /* asynch transfer allowed */ 687 if(blkcnt>=USB_MAX_READ_BLK) 688 printf("\n"); 689 return(blkcnt); 690 } 691 692 693 /* Probe to see if a new device is actually a Storage device */ 694 int usb_storage_probe(struct usb_device *dev, unsigned int ifnum,struct us_data *ss) 695 { 696 struct usb_interface_descriptor *iface; 697 int i; 698 unsigned int flags = 0; 699 700 int protocol = 0; 701 int subclass = 0; 702 703 704 memset(ss, 0, sizeof(struct us_data)); 705 706 /* let's examine the device now */ 707 iface = &dev->config.if_desc[ifnum]; 708 709 #if 0 710 /* this is the place to patch some storage devices */ 711 USB_STOR_PRINTF("iVendor %X iProduct %X\n",dev->descriptor.idVendor,dev->descriptor.idProduct); 712 if ((dev->descriptor.idVendor) == 0x066b && (dev->descriptor.idProduct) == 0x0103) { 713 USB_STOR_PRINTF("patched for E-USB\n"); 714 protocol = US_PR_CB; 715 subclass = US_SC_UFI; /* an assumption */ 716 } 717 #endif 718 719 if (dev->descriptor.bDeviceClass != 0 || 720 iface->bInterfaceClass != USB_CLASS_MASS_STORAGE || 721 iface->bInterfaceSubClass < US_SC_MIN || 722 iface->bInterfaceSubClass > US_SC_MAX) { 723 /* if it's not a mass storage, we go no further */ 724 return 0; 725 } 726 727 /* At this point, we know we've got a live one */ 728 USB_STOR_PRINTF("\n\nUSB Mass Storage device detected\n"); 729 730 /* Initialize the us_data structure with some useful info */ 731 ss->flags = flags; 732 ss->ifnum = ifnum; 733 ss->pusb_dev = dev; 734 ss->attention_done = 0; 735 736 /* If the device has subclass and protocol, then use that. Otherwise, 737 * take data from the specific interface. 738 */ 739 if (subclass) { 740 ss->subclass = subclass; 741 ss->protocol = protocol; 742 } else { 743 ss->subclass = iface->bInterfaceSubClass; 744 ss->protocol = iface->bInterfaceProtocol; 745 } 746 747 /* set the handler pointers based on the protocol */ 748 USB_STOR_PRINTF("Transport: "); 749 switch (ss->protocol) { 750 case US_PR_CB: 751 USB_STOR_PRINTF("Control/Bulk\n"); 752 ss->transport = usb_stor_CB_transport; 753 ss->transport_reset = usb_stor_CB_reset; 754 break; 755 756 case US_PR_CBI: 757 USB_STOR_PRINTF("Control/Bulk/Interrupt\n"); 758 ss->transport = usb_stor_CB_transport; 759 ss->transport_reset = usb_stor_CB_reset; 760 break; 761 default: 762 printf("USB Starage Transport unknown / not yet implemented\n"); 763 return 0; 764 break; 765 } 766 767 /* 768 * We are expecting a minimum of 2 endpoints - in and out (bulk). 769 * An optional interrupt is OK (necessary for CBI protocol). 770 * We will ignore any others. 771 */ 772 for (i = 0; i < iface->bNumEndpoints; i++) { 773 /* is it an BULK endpoint? */ 774 if ((iface->ep_desc[i].bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) 775 == USB_ENDPOINT_XFER_BULK) { 776 if (iface->ep_desc[i].bEndpointAddress & USB_DIR_IN) 777 ss->ep_in = iface->ep_desc[i].bEndpointAddress & 778 USB_ENDPOINT_NUMBER_MASK; 779 else 780 ss->ep_out = iface->ep_desc[i].bEndpointAddress & 781 USB_ENDPOINT_NUMBER_MASK; 782 } 783 784 /* is it an interrupt endpoint? */ 785 if ((iface->ep_desc[i].bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) 786 == USB_ENDPOINT_XFER_INT) { 787 ss->ep_int = iface->ep_desc[i].bEndpointAddress & 788 USB_ENDPOINT_NUMBER_MASK; 789 ss->irqinterval = iface->ep_desc[i].bInterval; 790 } 791 } 792 USB_STOR_PRINTF("Endpoints In %d Out %d Int %d\n", 793 ss->ep_in, ss->ep_out, ss->ep_int); 794 795 /* Do some basic sanity checks, and bail if we find a problem */ 796 if (usb_set_interface(dev, iface->bInterfaceNumber, 0) || 797 !ss->ep_in || !ss->ep_out || 798 (ss->protocol == US_PR_CBI && ss->ep_int == 0)) { 799 USB_STOR_PRINTF("Problems with device\n"); 800 return 0; 801 } 802 /* set class specific stuff */ 803 /* We only handle certain protocols. Currently, this is 804 * the only one. 805 */ 806 if (ss->subclass != US_SC_UFI) { 807 printf("Sorry, protocol %d not yet supported.\n",ss->subclass); 808 return 0; 809 } 810 if(ss->ep_int) /* we had found an interrupt endpoint, prepare irq pipe */ 811 { 812 /* set up the IRQ pipe and handler */ 813 814 ss->irqinterval = (ss->irqinterval > 0) ? ss->irqinterval : 255; 815 ss->irqpipe = usb_rcvintpipe(ss->pusb_dev, ss->ep_int); 816 ss->irqmaxp = usb_maxpacket(dev, ss->irqpipe); 817 dev->irq_handle=usb_stor_irq; 818 dev->privptr=(void *)ss; 819 } 820 return 1; 821 } 822 823 int usb_stor_get_info(struct usb_device *dev,struct us_data *ss,block_dev_desc_t *dev_desc) 824 { 825 unsigned char perq,modi; 826 unsigned long cap[2]; 827 unsigned long *capacity,*blksz; 828 ccb *pccb=&usb_ccb; 829 830 ss->transport_reset(ss); 831 pccb->pdata=usb_stor_buf; 832 833 dev_desc->target=dev->devnum; 834 pccb->lun=dev_desc->lun; 835 USB_STOR_PRINTF(" address %d\n",dev_desc->target); 836 837 if(usb_inquiry(pccb,ss)) 838 return -1; 839 perq=usb_stor_buf[0]; 840 modi=usb_stor_buf[1]; 841 if((perq & 0x1f)==0x1f) { 842 return 0; /* skip unknown devices */ 843 } 844 if((modi&0x80)==0x80) {/* drive is removable */ 845 dev_desc->removable=1; 846 } 847 memcpy(&dev_desc->vendor[0], &usb_stor_buf[8], 8); 848 memcpy(&dev_desc->product[0], &usb_stor_buf[16], 16); 849 memcpy(&dev_desc->revision[0], &usb_stor_buf[32], 4); 850 dev_desc->vendor[8]=0; 851 dev_desc->product[16]=0; 852 dev_desc->revision[4]=0; 853 USB_STOR_PRINTF("ISO Vers %X, Response Data %X\n",usb_stor_buf[2],usb_stor_buf[3]); 854 if(usb_test_unit_ready(pccb,ss)) { 855 printf("Device NOT ready\n Request Sense returned %02X %02X %02X\n",pccb->sense_buf[2],pccb->sense_buf[12],pccb->sense_buf[13]); 856 if(dev_desc->removable==1) { 857 dev_desc->type=perq; 858 return 1; 859 } 860 else 861 return 0; 862 } 863 pccb->pdata=(unsigned char *)&cap[0]; 864 memset(pccb->pdata,0,8); 865 if(usb_read_capacity(pccb,ss)!=0) { 866 printf("READ_CAP ERROR\n"); 867 cap[0]=2880; 868 cap[1]=0x200; 869 } 870 USB_STOR_PRINTF("Read Capacity returns: 0x%lx, 0x%lx\n",cap[0],cap[1]); 871 #if 0 872 if(cap[0]>(0x200000 * 10)) /* greater than 10 GByte */ 873 cap[0]>>=16; 874 #endif 875 cap[0]+=1; 876 capacity=&cap[0]; 877 blksz=&cap[1]; 878 USB_STOR_PRINTF("Capacity = 0x%lx, blocksz = 0x%lx\n",*capacity,*blksz); 879 dev_desc->lba=*capacity; 880 dev_desc->blksz=*blksz; 881 dev_desc->type=perq; 882 USB_STOR_PRINTF(" address %d\n",dev_desc->target); 883 USB_STOR_PRINTF("partype: %d\n",dev_desc->part_type); 884 885 init_part(dev_desc); 886 887 USB_STOR_PRINTF("partype: %d\n",dev_desc->part_type); 888 return 1; 889 } 890 891 #endif 892 #endif /* CONFIG_USB_STORAGE */ 893 894 895 896