1 /* 2 * Most of this source has been derived from the Linux USB 3 * project: 4 * (c) 1999-2002 Matthew Dharm (mdharm-usb@one-eyed-alien.net) 5 * (c) 2000 David L. Brown, Jr. (usb-storage@davidb.org) 6 * (c) 1999 Michael Gee (michael@linuxspecific.com) 7 * (c) 2000 Yggdrasil Computing, Inc. 8 * 9 * 10 * Adapted for U-Boot: 11 * (C) Copyright 2001 Denis Peter, MPL AG Switzerland 12 * 13 * For BBB support (C) Copyright 2003 14 * Gary Jennejohn, DENX Software Engineering <gj@denx.de> 15 * 16 * BBB support based on /sys/dev/usb/umass.c from 17 * FreeBSD. 18 * 19 * See file CREDITS for list of people who contributed to this 20 * project. 21 * 22 * This program is free software; you can redistribute it and/or 23 * modify it under the terms of the GNU General Public License as 24 * published by the Free Software Foundation; either version 2 of 25 * the License, or (at your option) any later version. 26 * 27 * This program is distributed in the hope that it will be useful, 28 * but WITHOUT ANY WARRANTY; without even the implied warranty of 29 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 30 * GNU General Public License for more details. 31 * 32 * You should have received a copy of the GNU General Public License 33 * along with this program; if not, write to the Free Software 34 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, 35 * MA 02111-1307 USA 36 * 37 */ 38 39 /* Note: 40 * Currently only the CBI transport protocoll has been implemented, and it 41 * is only tested with a TEAC USB Floppy. Other Massstorages with CBI or CB 42 * transport protocoll may work as well. 43 */ 44 /* 45 * New Note: 46 * Support for USB Mass Storage Devices (BBB) has been added. It has 47 * only been tested with USB memory sticks. 48 * Nota bene: if you are using the BBB support with a little-endian 49 * CPU then you MUST define LITTLEENDIAN in the configuration file! 50 */ 51 52 53 #include <common.h> 54 #include <command.h> 55 #include <asm/processor.h> 56 57 58 #if (CONFIG_COMMANDS & CFG_CMD_USB) 59 #include <usb.h> 60 61 #ifdef CONFIG_USB_STORAGE 62 63 #undef USB_STOR_DEBUG 64 #undef BBB_COMDAT_TRACE 65 #undef BBB_XPORT_TRACE 66 67 #ifdef USB_STOR_DEBUG 68 #define USB_STOR_PRINTF(fmt,args...) printf (fmt ,##args) 69 #else 70 #define USB_STOR_PRINTF(fmt,args...) 71 #endif 72 73 #include <scsi.h> 74 /* direction table -- this indicates the direction of the data 75 * transfer for each command code -- a 1 indicates input 76 */ 77 unsigned char us_direction[256/8] = { 78 0x28, 0x81, 0x14, 0x14, 0x20, 0x01, 0x90, 0x77, 79 0x0C, 0x20, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 80 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 81 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 82 }; 83 #define US_DIRECTION(x) ((us_direction[x>>3] >> (x & 7)) & 1) 84 85 static unsigned char usb_stor_buf[512]; 86 static ccb usb_ccb; 87 88 /* 89 * CBI style 90 */ 91 92 #define US_CBI_ADSC 0 93 94 /* 95 * BULK only 96 */ 97 #define US_BBB_RESET 0xff 98 #define US_BBB_GET_MAX_LUN 0xfe 99 100 /* Command Block Wrapper */ 101 typedef struct { 102 __u32 dCBWSignature; 103 # define CBWSIGNATURE 0x43425355 104 __u32 dCBWTag; 105 __u32 dCBWDataTransferLength; 106 __u8 bCBWFlags; 107 # define CBWFLAGS_OUT 0x00 108 # define CBWFLAGS_IN 0x80 109 __u8 bCBWLUN; 110 __u8 bCDBLength; 111 # define CBWCDBLENGTH 16 112 __u8 CBWCDB[CBWCDBLENGTH]; 113 } umass_bbb_cbw_t; 114 #define UMASS_BBB_CBW_SIZE 31 115 static __u32 CBWTag = 0; 116 117 /* Command Status Wrapper */ 118 typedef struct { 119 __u32 dCSWSignature; 120 # define CSWSIGNATURE 0x53425355 121 __u32 dCSWTag; 122 __u32 dCSWDataResidue; 123 __u8 bCSWStatus; 124 # define CSWSTATUS_GOOD 0x0 125 # define CSWSTATUS_FAILED 0x1 126 # define CSWSTATUS_PHASE 0x2 127 } umass_bbb_csw_t; 128 #define UMASS_BBB_CSW_SIZE 13 129 130 #define USB_MAX_STOR_DEV 5 131 static int usb_max_devs = 0; /* number of highest available usb device */ 132 133 static block_dev_desc_t usb_dev_desc[USB_MAX_STOR_DEV]; 134 135 struct us_data; 136 typedef int (*trans_cmnd)(ccb*, struct us_data*); 137 typedef int (*trans_reset)(struct us_data*); 138 139 struct us_data { 140 struct usb_device *pusb_dev; /* this usb_device */ 141 unsigned int flags; /* from filter initially */ 142 unsigned char ifnum; /* interface number */ 143 unsigned char ep_in; /* in endpoint */ 144 unsigned char ep_out; /* out ....... */ 145 unsigned char ep_int; /* interrupt . */ 146 unsigned char subclass; /* as in overview */ 147 unsigned char protocol; /* .............. */ 148 unsigned char attention_done; /* force attn on first cmd */ 149 unsigned short ip_data; /* interrupt data */ 150 int action; /* what to do */ 151 int ip_wanted; /* needed */ 152 int *irq_handle; /* for USB int requests */ 153 unsigned int irqpipe; /* pipe for release_irq */ 154 unsigned char irqmaxp; /* max packed for irq Pipe */ 155 unsigned char irqinterval; /* Intervall for IRQ Pipe */ 156 ccb *srb; /* current srb */ 157 trans_reset transport_reset; /* reset routine */ 158 trans_cmnd transport; /* transport routine */ 159 }; 160 161 static struct us_data usb_stor[USB_MAX_STOR_DEV]; 162 163 164 #define USB_STOR_TRANSPORT_GOOD 0 165 #define USB_STOR_TRANSPORT_FAILED -1 166 #define USB_STOR_TRANSPORT_ERROR -2 167 168 169 int usb_stor_get_info(struct usb_device *dev, struct us_data *us, block_dev_desc_t *dev_desc); 170 int usb_storage_probe(struct usb_device *dev, unsigned int ifnum,struct us_data *ss); 171 unsigned long usb_stor_read(int device, unsigned long blknr, unsigned long blkcnt, unsigned long *buffer); 172 struct usb_device * usb_get_dev_index(int index); 173 void uhci_show_temp_int_td(void); 174 175 block_dev_desc_t *usb_stor_get_dev(int index) 176 { 177 return &usb_dev_desc[index]; 178 } 179 180 181 void usb_show_progress(void) 182 { 183 printf("."); 184 } 185 186 /********************************************************************************* 187 * show info on storage devices; 'usb start/init' must be invoked earlier 188 * as we only retrieve structures populated during devices initialization 189 */ 190 void usb_stor_info(void) 191 { 192 int i; 193 194 if (usb_max_devs > 0) 195 for (i = 0; i < usb_max_devs; i++) { 196 printf (" Device %d: ", i); 197 dev_print(&usb_dev_desc[i]); 198 } 199 else 200 printf("No storage devices, perhaps not 'usb start'ed..?\n"); 201 } 202 203 /********************************************************************************* 204 * scan the usb and reports device info 205 * to the user if mode = 1 206 * returns current device or -1 if no 207 */ 208 int usb_stor_scan(int mode) 209 { 210 unsigned char i; 211 struct usb_device *dev; 212 213 /* GJ */ 214 memset(usb_stor_buf, 0, sizeof(usb_stor_buf)); 215 216 if(mode==1) { 217 printf(" scanning bus for storage devices... "); 218 } 219 usb_disable_asynch(1); /* asynch transfer not allowed */ 220 221 for(i=0;i<USB_MAX_STOR_DEV;i++) { 222 memset(&usb_dev_desc[i],0,sizeof(block_dev_desc_t)); 223 usb_dev_desc[i].target=0xff; 224 usb_dev_desc[i].if_type=IF_TYPE_USB; 225 usb_dev_desc[i].dev=i; 226 usb_dev_desc[i].part_type=PART_TYPE_UNKNOWN; 227 usb_dev_desc[i].block_read=usb_stor_read; 228 } 229 230 usb_max_devs=0; 231 for(i=0;i<USB_MAX_DEVICE;i++) { 232 dev=usb_get_dev_index(i); /* get device */ 233 USB_STOR_PRINTF("i=%d\n",i); 234 if(dev==NULL) { 235 break; /* no more devices avaiable */ 236 } 237 if(usb_storage_probe(dev,0,&usb_stor[usb_max_devs])) { /* ok, it is a storage devices */ 238 /* get info and fill it in */ 239 if(usb_stor_get_info(dev, &usb_stor[usb_max_devs], &usb_dev_desc[usb_max_devs])) 240 usb_max_devs++; 241 } /* if storage device */ 242 if(usb_max_devs==USB_MAX_STOR_DEV) { 243 printf("max USB Storage Device reached: %d stopping\n",usb_max_devs); 244 break; 245 } 246 } /* for */ 247 248 usb_disable_asynch(0); /* asynch transfer allowed */ 249 printf("%d Storage Device(s) found\n", usb_max_devs); 250 if(usb_max_devs>0) 251 return 0; 252 else 253 return-1; 254 } 255 256 static int usb_stor_irq(struct usb_device *dev) 257 { 258 struct us_data *us; 259 us=(struct us_data *)dev->privptr; 260 261 if(us->ip_wanted) { 262 us->ip_wanted=0; 263 } 264 return 0; 265 } 266 267 268 #ifdef USB_STOR_DEBUG 269 270 static void usb_show_srb(ccb * pccb) 271 { 272 int i; 273 printf("SRB: len %d datalen 0x%lX\n ",pccb->cmdlen,pccb->datalen); 274 for(i=0;i<12;i++) { 275 printf("%02X ",pccb->cmd[i]); 276 } 277 printf("\n"); 278 } 279 280 static void display_int_status(unsigned long tmp) 281 { 282 printf("Status: %s %s %s %s %s %s %s\n", 283 (tmp & USB_ST_ACTIVE) ? "Active" : "", 284 (tmp & USB_ST_STALLED) ? "Stalled" : "", 285 (tmp & USB_ST_BUF_ERR) ? "Buffer Error" : "", 286 (tmp & USB_ST_BABBLE_DET) ? "Babble Det" : "", 287 (tmp & USB_ST_NAK_REC) ? "NAKed" : "", 288 (tmp & USB_ST_CRC_ERR) ? "CRC Error" : "", 289 (tmp & USB_ST_BIT_ERR) ? "Bitstuff Error" : ""); 290 } 291 #endif 292 /*********************************************************************** 293 * Data transfer routines 294 ***********************************************************************/ 295 296 static int us_one_transfer(struct us_data *us, int pipe, char *buf, int length) 297 { 298 int max_size; 299 int this_xfer; 300 int result; 301 int partial; 302 int maxtry; 303 int stat; 304 305 /* determine the maximum packet size for these transfers */ 306 max_size = usb_maxpacket(us->pusb_dev, pipe) * 16; 307 308 /* while we have data left to transfer */ 309 while (length) { 310 311 /* calculate how long this will be -- maximum or a remainder */ 312 this_xfer = length > max_size ? max_size : length; 313 length -= this_xfer; 314 315 /* setup the retry counter */ 316 maxtry = 10; 317 318 /* set up the transfer loop */ 319 do { 320 /* transfer the data */ 321 USB_STOR_PRINTF("Bulk xfer 0x%x(%d) try #%d\n", 322 (unsigned int)buf, this_xfer, 11 - maxtry); 323 result = usb_bulk_msg(us->pusb_dev, pipe, buf, 324 this_xfer, &partial, USB_CNTL_TIMEOUT*5); 325 USB_STOR_PRINTF("bulk_msg returned %d xferred %d/%d\n", 326 result, partial, this_xfer); 327 if(us->pusb_dev->status!=0) { 328 /* if we stall, we need to clear it before we go on */ 329 #ifdef USB_STOR_DEBUG 330 display_int_status(us->pusb_dev->status); 331 #endif 332 if (us->pusb_dev->status & USB_ST_STALLED) { 333 USB_STOR_PRINTF("stalled ->clearing endpoint halt for pipe 0x%x\n", pipe); 334 stat = us->pusb_dev->status; 335 usb_clear_halt(us->pusb_dev, pipe); 336 us->pusb_dev->status=stat; 337 if(this_xfer == partial) { 338 USB_STOR_PRINTF("bulk transferred with error %X, but data ok\n",us->pusb_dev->status); 339 return 0; 340 } 341 else 342 return result; 343 } 344 if (us->pusb_dev->status & USB_ST_NAK_REC) { 345 USB_STOR_PRINTF("Device NAKed bulk_msg\n"); 346 return result; 347 } 348 if(this_xfer == partial) { 349 USB_STOR_PRINTF("bulk transferred with error %d, but data ok\n",us->pusb_dev->status); 350 return 0; 351 } 352 /* if our try counter reaches 0, bail out */ 353 USB_STOR_PRINTF("bulk transferred with error %d, data %d\n",us->pusb_dev->status,partial); 354 if (!maxtry--) 355 return result; 356 } 357 /* update to show what data was transferred */ 358 this_xfer -= partial; 359 buf += partial; 360 /* continue until this transfer is done */ 361 } while ( this_xfer ); 362 } 363 364 /* if we get here, we're done and successful */ 365 return 0; 366 } 367 368 static int usb_stor_BBB_reset(struct us_data *us) 369 { 370 int result; 371 unsigned int pipe; 372 373 /* 374 * Reset recovery (5.3.4 in Universal Serial Bus Mass Storage Class) 375 * 376 * For Reset Recovery the host shall issue in the following order: 377 * a) a Bulk-Only Mass Storage Reset 378 * b) a Clear Feature HALT to the Bulk-In endpoint 379 * c) a Clear Feature HALT to the Bulk-Out endpoint 380 * 381 * This is done in 3 steps. 382 * 383 * If the reset doesn't succeed, the device should be port reset. 384 * 385 * This comment stolen from FreeBSD's /sys/dev/usb/umass.c. 386 */ 387 USB_STOR_PRINTF("BBB_reset\n"); 388 result = usb_control_msg(us->pusb_dev, usb_sndctrlpipe(us->pusb_dev,0), 389 US_BBB_RESET, USB_TYPE_CLASS | USB_RECIP_INTERFACE, 390 0, us->ifnum, 0, 0, USB_CNTL_TIMEOUT*5); 391 392 if((result < 0) && (us->pusb_dev->status & USB_ST_STALLED)) 393 { 394 USB_STOR_PRINTF("RESET:stall\n"); 395 return -1; 396 } 397 398 /* long wait for reset */ 399 wait_ms(150); 400 USB_STOR_PRINTF("BBB_reset result %d: status %X reset\n",result,us->pusb_dev->status); 401 pipe = usb_rcvbulkpipe(us->pusb_dev, us->ep_in); 402 result = usb_clear_halt(us->pusb_dev, pipe); 403 /* long wait for reset */ 404 wait_ms(150); 405 USB_STOR_PRINTF("BBB_reset result %d: status %X clearing IN endpoint\n",result,us->pusb_dev->status); 406 /* long wait for reset */ 407 pipe = usb_sndbulkpipe(us->pusb_dev, us->ep_out); 408 result = usb_clear_halt(us->pusb_dev, pipe); 409 wait_ms(150); 410 USB_STOR_PRINTF("BBB_reset result %d: status %X clearing OUT endpoint\n",result,us->pusb_dev->status); 411 USB_STOR_PRINTF("BBB_reset done\n"); 412 return 0; 413 } 414 415 /* FIXME: this reset function doesn't really reset the port, and it 416 * should. Actually it should probably do what it's doing here, and 417 * reset the port physically 418 */ 419 static int usb_stor_CB_reset(struct us_data *us) 420 { 421 unsigned char cmd[12]; 422 int result; 423 424 USB_STOR_PRINTF("CB_reset\n"); 425 memset(cmd, 0xFF, sizeof(cmd)); 426 cmd[0] = SCSI_SEND_DIAG; 427 cmd[1] = 4; 428 result = usb_control_msg(us->pusb_dev, usb_sndctrlpipe(us->pusb_dev,0), 429 US_CBI_ADSC, USB_TYPE_CLASS | USB_RECIP_INTERFACE, 430 0, us->ifnum, cmd, sizeof(cmd), USB_CNTL_TIMEOUT*5); 431 432 /* long wait for reset */ 433 wait_ms(1500); 434 USB_STOR_PRINTF("CB_reset result %d: status %X clearing endpoint halt\n",result,us->pusb_dev->status); 435 usb_clear_halt(us->pusb_dev, usb_rcvbulkpipe(us->pusb_dev, us->ep_in)); 436 usb_clear_halt(us->pusb_dev, usb_rcvbulkpipe(us->pusb_dev, us->ep_out)); 437 438 USB_STOR_PRINTF("CB_reset done\n"); 439 return 0; 440 } 441 442 /* 443 * Set up the command for a BBB device. Note that the actual SCSI 444 * command is copied into cbw.CBWCDB. 445 */ 446 int usb_stor_BBB_comdat(ccb *srb, struct us_data *us) 447 { 448 int result; 449 int actlen; 450 int dir_in; 451 unsigned int pipe; 452 umass_bbb_cbw_t cbw; 453 454 dir_in = US_DIRECTION(srb->cmd[0]); 455 456 #ifdef BBB_COMDAT_TRACE 457 printf("dir %d lun %d cmdlen %d cmd %p datalen %d pdata %p\n", dir_in, srb->lun, srb->cmdlen, srb->cmd, srb->datalen, srb->pdata); 458 if (srb->cmdlen) { 459 for(result = 0;result < srb->cmdlen;result++) 460 printf("cmd[%d] %#x ", result, srb->cmd[result]); 461 printf("\n"); 462 } 463 #endif 464 /* sanity checks */ 465 if (!(srb->cmdlen <= CBWCDBLENGTH)) { 466 USB_STOR_PRINTF("usb_stor_BBB_comdat:cmdlen too large\n"); 467 return -1; 468 } 469 470 /* always OUT to the ep */ 471 pipe = usb_sndbulkpipe(us->pusb_dev, us->ep_out); 472 473 cbw.dCBWSignature = swap_32(CBWSIGNATURE); 474 cbw.dCBWTag = swap_32(CBWTag++); 475 cbw.dCBWDataTransferLength = swap_32(srb->datalen); 476 cbw.bCBWFlags = (dir_in? CBWFLAGS_IN : CBWFLAGS_OUT); 477 cbw.bCBWLUN = srb->lun; 478 cbw.bCDBLength = srb->cmdlen; 479 /* copy the command data into the CBW command data buffer */ 480 /* DST SRC LEN!!! */ 481 memcpy(cbw.CBWCDB, srb->cmd, srb->cmdlen); 482 result = usb_bulk_msg(us->pusb_dev, pipe, &cbw, UMASS_BBB_CBW_SIZE, &actlen, USB_CNTL_TIMEOUT*5); 483 if (result < 0) 484 USB_STOR_PRINTF("usb_stor_BBB_comdat:usb_bulk_msg error\n"); 485 return result; 486 } 487 488 /* FIXME: we also need a CBI_command which sets up the completion 489 * interrupt, and waits for it 490 */ 491 int usb_stor_CB_comdat(ccb *srb, struct us_data *us) 492 { 493 int result = 0; 494 int dir_in,retry; 495 unsigned int pipe; 496 unsigned long status; 497 498 retry=5; 499 dir_in=US_DIRECTION(srb->cmd[0]); 500 501 if(dir_in) 502 pipe=usb_rcvbulkpipe(us->pusb_dev, us->ep_in); 503 else 504 pipe=usb_sndbulkpipe(us->pusb_dev, us->ep_out); 505 while(retry--) { 506 USB_STOR_PRINTF("CBI gets a command: Try %d\n",5-retry); 507 #ifdef USB_STOR_DEBUG 508 usb_show_srb(srb); 509 #endif 510 /* let's send the command via the control pipe */ 511 result = usb_control_msg(us->pusb_dev, usb_sndctrlpipe(us->pusb_dev,0), 512 US_CBI_ADSC, USB_TYPE_CLASS | USB_RECIP_INTERFACE, 513 0, us->ifnum, 514 srb->cmd, srb->cmdlen, USB_CNTL_TIMEOUT*5); 515 USB_STOR_PRINTF("CB_transport: control msg returned %d, status %X\n",result,us->pusb_dev->status); 516 /* check the return code for the command */ 517 if (result < 0) { 518 if(us->pusb_dev->status & USB_ST_STALLED) { 519 status=us->pusb_dev->status; 520 USB_STOR_PRINTF(" stall during command found, clear pipe\n"); 521 usb_clear_halt(us->pusb_dev, usb_sndctrlpipe(us->pusb_dev,0)); 522 us->pusb_dev->status=status; 523 } 524 USB_STOR_PRINTF(" error during command %02X Stat = %X\n",srb->cmd[0],us->pusb_dev->status); 525 return result; 526 } 527 /* transfer the data payload for this command, if one exists*/ 528 529 USB_STOR_PRINTF("CB_transport: control msg returned %d, direction is %s to go 0x%lx\n",result,dir_in ? "IN" : "OUT",srb->datalen); 530 if (srb->datalen) { 531 result = us_one_transfer(us, pipe, (char *)srb->pdata,srb->datalen); 532 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); 533 if(!(us->pusb_dev->status & USB_ST_NAK_REC)) 534 break; 535 } /* if (srb->datalen) */ 536 else 537 break; 538 } 539 /* return result */ 540 541 return result; 542 } 543 544 545 int usb_stor_CBI_get_status (ccb * srb, struct us_data *us) 546 { 547 int timeout; 548 549 us->ip_wanted = 1; 550 submit_int_msg (us->pusb_dev, us->irqpipe, 551 (void *) &us->ip_data, us->irqmaxp, us->irqinterval); 552 timeout = 1000; 553 while (timeout--) { 554 if ((volatile int *) us->ip_wanted == 0) 555 break; 556 wait_ms (10); 557 } 558 if (us->ip_wanted) { 559 printf (" Did not get interrupt on CBI\n"); 560 us->ip_wanted = 0; 561 return USB_STOR_TRANSPORT_ERROR; 562 } 563 USB_STOR_PRINTF 564 ("Got interrupt data 0x%x, transfered %d status 0x%lX\n", 565 us->ip_data, us->pusb_dev->irq_act_len, 566 us->pusb_dev->irq_status); 567 /* UFI gives us ASC and ASCQ, like a request sense */ 568 if (us->subclass == US_SC_UFI) { 569 if (srb->cmd[0] == SCSI_REQ_SENSE || 570 srb->cmd[0] == SCSI_INQUIRY) 571 return USB_STOR_TRANSPORT_GOOD; /* Good */ 572 else if (us->ip_data) 573 return USB_STOR_TRANSPORT_FAILED; 574 else 575 return USB_STOR_TRANSPORT_GOOD; 576 } 577 /* otherwise, we interpret the data normally */ 578 switch (us->ip_data) { 579 case 0x0001: 580 return USB_STOR_TRANSPORT_GOOD; 581 case 0x0002: 582 return USB_STOR_TRANSPORT_FAILED; 583 default: 584 return USB_STOR_TRANSPORT_ERROR; 585 } /* switch */ 586 return USB_STOR_TRANSPORT_ERROR; 587 } 588 589 #define USB_TRANSPORT_UNKNOWN_RETRY 5 590 #define USB_TRANSPORT_NOT_READY_RETRY 10 591 592 /* clear a stall on an endpoint - special for BBB devices */ 593 int usb_stor_BBB_clear_endpt_stall(struct us_data *us, __u8 endpt) 594 { 595 int result; 596 597 /* ENDPOINT_HALT = 0, so set value to 0 */ 598 result = usb_control_msg(us->pusb_dev, usb_sndctrlpipe(us->pusb_dev,0), 599 USB_REQ_CLEAR_FEATURE, USB_RECIP_ENDPOINT, 600 0, endpt, 0, 0, USB_CNTL_TIMEOUT*5); 601 return result; 602 } 603 604 int usb_stor_BBB_transport(ccb *srb, struct us_data *us) 605 { 606 int result, retry; 607 int dir_in; 608 int actlen, data_actlen; 609 unsigned int pipe, pipein, pipeout; 610 umass_bbb_csw_t csw; 611 #ifdef BBB_XPORT_TRACE 612 unsigned char *ptr; 613 int index; 614 #endif 615 616 dir_in = US_DIRECTION(srb->cmd[0]); 617 618 /* COMMAND phase */ 619 USB_STOR_PRINTF("COMMAND phase\n"); 620 result = usb_stor_BBB_comdat(srb, us); 621 if (result < 0) { 622 USB_STOR_PRINTF("failed to send CBW status %ld\n", 623 us->pusb_dev->status); 624 usb_stor_BBB_reset(us); 625 return USB_STOR_TRANSPORT_FAILED; 626 } 627 wait_ms(5); 628 pipein = usb_rcvbulkpipe(us->pusb_dev, us->ep_in); 629 pipeout = usb_sndbulkpipe(us->pusb_dev, us->ep_out); 630 /* DATA phase + error handling */ 631 data_actlen = 0; 632 /* no data, go immediately to the STATUS phase */ 633 if (srb->datalen == 0) 634 goto st; 635 USB_STOR_PRINTF("DATA phase\n"); 636 if (dir_in) 637 pipe = pipein; 638 else 639 pipe = pipeout; 640 result = usb_bulk_msg(us->pusb_dev, pipe, srb->pdata, srb->datalen, &data_actlen, USB_CNTL_TIMEOUT*5); 641 /* special handling of STALL in DATA phase */ 642 if((result < 0) && (us->pusb_dev->status & USB_ST_STALLED)) { 643 USB_STOR_PRINTF("DATA:stall\n"); 644 /* clear the STALL on the endpoint */ 645 result = usb_stor_BBB_clear_endpt_stall(us, dir_in? us->ep_in : us->ep_out); 646 if (result >= 0) 647 /* continue on to STATUS phase */ 648 goto st; 649 } 650 if (result < 0) { 651 USB_STOR_PRINTF("usb_bulk_msg error status %ld\n", 652 us->pusb_dev->status); 653 usb_stor_BBB_reset(us); 654 return USB_STOR_TRANSPORT_FAILED; 655 } 656 #ifdef BBB_XPORT_TRACE 657 for (index = 0; index < data_actlen; index++) 658 printf("pdata[%d] %#x ", index, srb->pdata[index]); 659 printf("\n"); 660 #endif 661 /* STATUS phase + error handling */ 662 st: 663 retry = 0; 664 again: 665 USB_STOR_PRINTF("STATUS phase\n"); 666 result = usb_bulk_msg(us->pusb_dev, pipein, &csw, UMASS_BBB_CSW_SIZE, 667 &actlen, USB_CNTL_TIMEOUT*5); 668 669 /* special handling of STALL in STATUS phase */ 670 if((result < 0) && (retry < 1) && (us->pusb_dev->status & USB_ST_STALLED)) { 671 USB_STOR_PRINTF("STATUS:stall\n"); 672 /* clear the STALL on the endpoint */ 673 result = usb_stor_BBB_clear_endpt_stall(us, us->ep_in); 674 if (result >= 0 && (retry++ < 1)) 675 /* do a retry */ 676 goto again; 677 } 678 if (result < 0) { 679 USB_STOR_PRINTF("usb_bulk_msg error status %ld\n", 680 us->pusb_dev->status); 681 usb_stor_BBB_reset(us); 682 return USB_STOR_TRANSPORT_FAILED; 683 } 684 #ifdef BBB_XPORT_TRACE 685 ptr = (unsigned char *)&csw; 686 for (index = 0; index < UMASS_BBB_CSW_SIZE; index++) 687 printf("ptr[%d] %#x ", index, ptr[index]); 688 printf("\n"); 689 #endif 690 /* misuse pipe to get the residue */ 691 pipe = swap_32(csw.dCSWDataResidue); 692 if (pipe == 0 && srb->datalen != 0 && srb->datalen - data_actlen != 0) 693 pipe = srb->datalen - data_actlen; 694 if (CSWSIGNATURE != swap_32(csw.dCSWSignature)) { 695 USB_STOR_PRINTF("!CSWSIGNATURE\n"); 696 usb_stor_BBB_reset(us); 697 return USB_STOR_TRANSPORT_FAILED; 698 } else if ((CBWTag - 1) != swap_32(csw.dCSWTag)) { 699 USB_STOR_PRINTF("!Tag\n"); 700 usb_stor_BBB_reset(us); 701 return USB_STOR_TRANSPORT_FAILED; 702 } else if (csw.bCSWStatus > CSWSTATUS_PHASE) { 703 USB_STOR_PRINTF(">PHASE\n"); 704 usb_stor_BBB_reset(us); 705 return USB_STOR_TRANSPORT_FAILED; 706 } else if (csw.bCSWStatus == CSWSTATUS_PHASE) { 707 USB_STOR_PRINTF("=PHASE\n"); 708 usb_stor_BBB_reset(us); 709 return USB_STOR_TRANSPORT_FAILED; 710 } else if (data_actlen > srb->datalen) { 711 USB_STOR_PRINTF("transferred %dB instead of %dB\n", 712 data_actlen, srb->datalen); 713 return USB_STOR_TRANSPORT_FAILED; 714 } else if (csw.bCSWStatus == CSWSTATUS_FAILED) { 715 USB_STOR_PRINTF("FAILED\n"); 716 return USB_STOR_TRANSPORT_FAILED; 717 } 718 719 return result; 720 } 721 722 int usb_stor_CB_transport(ccb *srb, struct us_data *us) 723 { 724 int result,status; 725 ccb *psrb; 726 ccb reqsrb; 727 int retry,notready; 728 729 psrb=&reqsrb; 730 status=USB_STOR_TRANSPORT_GOOD; 731 retry=0; 732 notready=0; 733 /* issue the command */ 734 do_retry: 735 result=usb_stor_CB_comdat(srb,us); 736 USB_STOR_PRINTF("command / Data returned %d, status %X\n",result,us->pusb_dev->status); 737 /* if this is an CBI Protocol, get IRQ */ 738 if(us->protocol==US_PR_CBI) { 739 status=usb_stor_CBI_get_status(srb,us); 740 /* if the status is error, report it */ 741 if(status==USB_STOR_TRANSPORT_ERROR) { 742 USB_STOR_PRINTF(" USB CBI Command Error\n"); 743 return status; 744 } 745 srb->sense_buf[12]=(unsigned char)(us->ip_data>>8); 746 srb->sense_buf[13]=(unsigned char)(us->ip_data&0xff); 747 if(!us->ip_data) { 748 /* if the status is good, report it */ 749 if(status==USB_STOR_TRANSPORT_GOOD) { 750 USB_STOR_PRINTF(" USB CBI Command Good\n"); 751 return status; 752 } 753 } 754 } 755 /* do we have to issue an auto request? */ 756 /* HERE we have to check the result */ 757 if((result<0) && !(us->pusb_dev->status & USB_ST_STALLED)) { 758 USB_STOR_PRINTF("ERROR %X\n",us->pusb_dev->status); 759 us->transport_reset(us); 760 return USB_STOR_TRANSPORT_ERROR; 761 } 762 if((us->protocol==US_PR_CBI) && 763 ((srb->cmd[0]==SCSI_REQ_SENSE) || 764 (srb->cmd[0]==SCSI_INQUIRY))) { /* do not issue an autorequest after request sense */ 765 USB_STOR_PRINTF("No auto request and good\n"); 766 return USB_STOR_TRANSPORT_GOOD; 767 } 768 /* issue an request_sense */ 769 memset(&psrb->cmd[0],0,12); 770 psrb->cmd[0]=SCSI_REQ_SENSE; 771 psrb->cmd[1]=srb->lun<<5; 772 psrb->cmd[4]=18; 773 psrb->datalen=18; 774 psrb->pdata=&srb->sense_buf[0]; 775 psrb->cmdlen=12; 776 /* issue the command */ 777 result=usb_stor_CB_comdat(psrb,us); 778 USB_STOR_PRINTF("auto request returned %d\n",result); 779 /* if this is an CBI Protocol, get IRQ */ 780 if(us->protocol==US_PR_CBI) { 781 status=usb_stor_CBI_get_status(psrb,us); 782 } 783 if((result<0)&&!(us->pusb_dev->status & USB_ST_STALLED)) { 784 USB_STOR_PRINTF(" AUTO REQUEST ERROR %d\n",us->pusb_dev->status); 785 return USB_STOR_TRANSPORT_ERROR; 786 } 787 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]); 788 /* Check the auto request result */ 789 if((srb->sense_buf[2]==0) && 790 (srb->sense_buf[12]==0) && 791 (srb->sense_buf[13]==0)) /* ok, no sense */ 792 return USB_STOR_TRANSPORT_GOOD; 793 /* Check the auto request result */ 794 switch(srb->sense_buf[2]) { 795 case 0x01: /* Recovered Error */ 796 return USB_STOR_TRANSPORT_GOOD; 797 break; 798 case 0x02: /* Not Ready */ 799 if(notready++ > USB_TRANSPORT_NOT_READY_RETRY) { 800 printf("cmd 0x%02X returned 0x%02X 0x%02X 0x%02X 0x%02X (NOT READY)\n", 801 srb->cmd[0],srb->sense_buf[0],srb->sense_buf[2],srb->sense_buf[12],srb->sense_buf[13]); 802 return USB_STOR_TRANSPORT_FAILED; 803 } else { 804 wait_ms(100); 805 goto do_retry; 806 } 807 break; 808 default: 809 if(retry++ > USB_TRANSPORT_UNKNOWN_RETRY) { 810 printf("cmd 0x%02X returned 0x%02X 0x%02X 0x%02X 0x%02X\n", 811 srb->cmd[0],srb->sense_buf[0],srb->sense_buf[2],srb->sense_buf[12],srb->sense_buf[13]); 812 return USB_STOR_TRANSPORT_FAILED; 813 } else { 814 goto do_retry; 815 } 816 break; 817 } 818 return USB_STOR_TRANSPORT_FAILED; 819 } 820 821 822 static int usb_inquiry(ccb *srb,struct us_data *ss) 823 { 824 int retry,i; 825 retry=5; 826 do { 827 memset(&srb->cmd[0],0,12); 828 srb->cmd[0]=SCSI_INQUIRY; 829 srb->cmd[1]=srb->lun<<5; 830 srb->cmd[4]=36; 831 srb->datalen=36; 832 srb->cmdlen=12; 833 i=ss->transport(srb,ss); 834 USB_STOR_PRINTF("inquiry returns %d\n",i); 835 if(i==0) 836 break; 837 } while(retry--); 838 839 if(!retry) { 840 printf("error in inquiry\n"); 841 return -1; 842 } 843 return 0; 844 } 845 846 static int usb_request_sense(ccb *srb,struct us_data *ss) 847 { 848 char *ptr; 849 850 ptr=(char *)srb->pdata; 851 memset(&srb->cmd[0],0,12); 852 srb->cmd[0]=SCSI_REQ_SENSE; 853 srb->cmd[1]=srb->lun<<5; 854 srb->cmd[4]=18; 855 srb->datalen=18; 856 srb->pdata=&srb->sense_buf[0]; 857 srb->cmdlen=12; 858 ss->transport(srb,ss); 859 USB_STOR_PRINTF("Request Sense returned %02X %02X %02X\n",srb->sense_buf[2],srb->sense_buf[12],srb->sense_buf[13]); 860 srb->pdata=(uchar *)ptr; 861 return 0; 862 } 863 864 static int usb_test_unit_ready(ccb *srb,struct us_data *ss) 865 { 866 int retries = 10; 867 868 do { 869 memset(&srb->cmd[0],0,12); 870 srb->cmd[0]=SCSI_TST_U_RDY; 871 srb->cmd[1]=srb->lun<<5; 872 srb->datalen=0; 873 srb->cmdlen=12; 874 if(ss->transport(srb,ss)==USB_STOR_TRANSPORT_GOOD) { 875 return 0; 876 } 877 usb_request_sense (srb, ss); 878 wait_ms (100); 879 } while(retries--); 880 881 return -1; 882 } 883 884 static int usb_read_capacity(ccb *srb,struct us_data *ss) 885 { 886 int retry; 887 retry = 3; /* retries */ 888 do { 889 memset(&srb->cmd[0],0,12); 890 srb->cmd[0]=SCSI_RD_CAPAC; 891 srb->cmd[1]=srb->lun<<5; 892 srb->datalen=8; 893 srb->cmdlen=12; 894 if(ss->transport(srb,ss)==USB_STOR_TRANSPORT_GOOD) { 895 return 0; 896 } 897 } while(retry--); 898 899 return -1; 900 } 901 902 static int usb_read_10(ccb *srb,struct us_data *ss, unsigned long start, unsigned short blocks) 903 { 904 memset(&srb->cmd[0],0,12); 905 srb->cmd[0]=SCSI_READ10; 906 srb->cmd[1]=srb->lun<<5; 907 srb->cmd[2]=((unsigned char) (start>>24))&0xff; 908 srb->cmd[3]=((unsigned char) (start>>16))&0xff; 909 srb->cmd[4]=((unsigned char) (start>>8))&0xff; 910 srb->cmd[5]=((unsigned char) (start))&0xff; 911 srb->cmd[7]=((unsigned char) (blocks>>8))&0xff; 912 srb->cmd[8]=(unsigned char) blocks & 0xff; 913 srb->cmdlen=12; 914 USB_STOR_PRINTF("read10: start %lx blocks %x\n",start,blocks); 915 return ss->transport(srb,ss); 916 } 917 918 919 #define USB_MAX_READ_BLK 20 920 921 unsigned long usb_stor_read(int device, unsigned long blknr, unsigned long blkcnt, unsigned long *buffer) 922 { 923 unsigned long start,blks, buf_addr; 924 unsigned short smallblks; 925 struct usb_device *dev; 926 int retry,i; 927 ccb *srb = &usb_ccb; 928 929 if (blkcnt == 0) 930 return 0; 931 932 device &= 0xff; 933 /* Setup device 934 */ 935 USB_STOR_PRINTF("\nusb_read: dev %d \n",device); 936 dev=NULL; 937 for(i=0;i<USB_MAX_DEVICE;i++) { 938 dev=usb_get_dev_index(i); 939 if(dev==NULL) { 940 return 0; 941 } 942 if(dev->devnum==usb_dev_desc[device].target) 943 break; 944 } 945 946 usb_disable_asynch(1); /* asynch transfer not allowed */ 947 srb->lun=usb_dev_desc[device].lun; 948 buf_addr=(unsigned long)buffer; 949 start=blknr; 950 blks=blkcnt; 951 if(usb_test_unit_ready(srb,(struct us_data *)dev->privptr)) { 952 printf("Device NOT ready\n Request Sense returned %02X %02X %02X\n", 953 srb->sense_buf[2],srb->sense_buf[12],srb->sense_buf[13]); 954 return 0; 955 } 956 USB_STOR_PRINTF("\nusb_read: dev %d startblk %lx, blccnt %lx buffer %lx\n",device,start,blks, buf_addr); 957 do { 958 retry=2; 959 srb->pdata=(unsigned char *)buf_addr; 960 if(blks>USB_MAX_READ_BLK) { 961 smallblks=USB_MAX_READ_BLK; 962 } else { 963 smallblks=(unsigned short) blks; 964 } 965 retry_it: 966 if(smallblks==USB_MAX_READ_BLK) 967 usb_show_progress(); 968 srb->datalen=usb_dev_desc[device].blksz * smallblks; 969 srb->pdata=(unsigned char *)buf_addr; 970 if(usb_read_10(srb,(struct us_data *)dev->privptr, start, smallblks)) { 971 USB_STOR_PRINTF("Read ERROR\n"); 972 usb_request_sense(srb,(struct us_data *)dev->privptr); 973 if(retry--) 974 goto retry_it; 975 blkcnt-=blks; 976 break; 977 } 978 start+=smallblks; 979 blks-=smallblks; 980 buf_addr+=srb->datalen; 981 } while(blks!=0); 982 USB_STOR_PRINTF("usb_read: end startblk %lx, blccnt %x buffer %lx\n",start,smallblks,buf_addr); 983 usb_disable_asynch(0); /* asynch transfer allowed */ 984 if(blkcnt>=USB_MAX_READ_BLK) 985 printf("\n"); 986 return(blkcnt); 987 } 988 989 990 /* Probe to see if a new device is actually a Storage device */ 991 int usb_storage_probe(struct usb_device *dev, unsigned int ifnum,struct us_data *ss) 992 { 993 struct usb_interface_descriptor *iface; 994 int i; 995 unsigned int flags = 0; 996 997 int protocol = 0; 998 int subclass = 0; 999 1000 /* let's examine the device now */ 1001 iface = &dev->config.if_desc[ifnum]; 1002 1003 #if 0 1004 /* this is the place to patch some storage devices */ 1005 USB_STOR_PRINTF("iVendor %X iProduct %X\n",dev->descriptor.idVendor,dev->descriptor.idProduct); 1006 if ((dev->descriptor.idVendor) == 0x066b && (dev->descriptor.idProduct) == 0x0103) { 1007 USB_STOR_PRINTF("patched for E-USB\n"); 1008 protocol = US_PR_CB; 1009 subclass = US_SC_UFI; /* an assumption */ 1010 } 1011 #endif 1012 1013 if (dev->descriptor.bDeviceClass != 0 || 1014 iface->bInterfaceClass != USB_CLASS_MASS_STORAGE || 1015 iface->bInterfaceSubClass < US_SC_MIN || 1016 iface->bInterfaceSubClass > US_SC_MAX) { 1017 /* if it's not a mass storage, we go no further */ 1018 return 0; 1019 } 1020 1021 memset(ss, 0, sizeof(struct us_data)); 1022 1023 /* At this point, we know we've got a live one */ 1024 USB_STOR_PRINTF("\n\nUSB Mass Storage device detected\n"); 1025 1026 /* Initialize the us_data structure with some useful info */ 1027 ss->flags = flags; 1028 ss->ifnum = ifnum; 1029 ss->pusb_dev = dev; 1030 ss->attention_done = 0; 1031 1032 /* If the device has subclass and protocol, then use that. Otherwise, 1033 * take data from the specific interface. 1034 */ 1035 if (subclass) { 1036 ss->subclass = subclass; 1037 ss->protocol = protocol; 1038 } else { 1039 ss->subclass = iface->bInterfaceSubClass; 1040 ss->protocol = iface->bInterfaceProtocol; 1041 } 1042 1043 /* set the handler pointers based on the protocol */ 1044 USB_STOR_PRINTF("Transport: "); 1045 switch (ss->protocol) { 1046 case US_PR_CB: 1047 USB_STOR_PRINTF("Control/Bulk\n"); 1048 ss->transport = usb_stor_CB_transport; 1049 ss->transport_reset = usb_stor_CB_reset; 1050 break; 1051 1052 case US_PR_CBI: 1053 USB_STOR_PRINTF("Control/Bulk/Interrupt\n"); 1054 ss->transport = usb_stor_CB_transport; 1055 ss->transport_reset = usb_stor_CB_reset; 1056 break; 1057 case US_PR_BULK: 1058 USB_STOR_PRINTF("Bulk/Bulk/Bulk\n"); 1059 ss->transport = usb_stor_BBB_transport; 1060 ss->transport_reset = usb_stor_BBB_reset; 1061 break; 1062 default: 1063 printf("USB Storage Transport unknown / not yet implemented\n"); 1064 return 0; 1065 break; 1066 } 1067 1068 /* 1069 * We are expecting a minimum of 2 endpoints - in and out (bulk). 1070 * An optional interrupt is OK (necessary for CBI protocol). 1071 * We will ignore any others. 1072 */ 1073 for (i = 0; i < iface->bNumEndpoints; i++) { 1074 /* is it an BULK endpoint? */ 1075 if ((iface->ep_desc[i].bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) 1076 == USB_ENDPOINT_XFER_BULK) { 1077 if (iface->ep_desc[i].bEndpointAddress & USB_DIR_IN) 1078 ss->ep_in = iface->ep_desc[i].bEndpointAddress & 1079 USB_ENDPOINT_NUMBER_MASK; 1080 else 1081 ss->ep_out = iface->ep_desc[i].bEndpointAddress & 1082 USB_ENDPOINT_NUMBER_MASK; 1083 } 1084 1085 /* is it an interrupt endpoint? */ 1086 if ((iface->ep_desc[i].bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) 1087 == USB_ENDPOINT_XFER_INT) { 1088 ss->ep_int = iface->ep_desc[i].bEndpointAddress & 1089 USB_ENDPOINT_NUMBER_MASK; 1090 ss->irqinterval = iface->ep_desc[i].bInterval; 1091 } 1092 } 1093 USB_STOR_PRINTF("Endpoints In %d Out %d Int %d\n", 1094 ss->ep_in, ss->ep_out, ss->ep_int); 1095 1096 /* Do some basic sanity checks, and bail if we find a problem */ 1097 if (usb_set_interface(dev, iface->bInterfaceNumber, 0) || 1098 !ss->ep_in || !ss->ep_out || 1099 (ss->protocol == US_PR_CBI && ss->ep_int == 0)) { 1100 USB_STOR_PRINTF("Problems with device\n"); 1101 return 0; 1102 } 1103 /* set class specific stuff */ 1104 /* We only handle certain protocols. Currently, these are 1105 * the only ones. 1106 * The SFF8070 accepts the requests used in u-boot 1107 */ 1108 if (ss->subclass != US_SC_UFI && ss->subclass != US_SC_SCSI && 1109 ss->subclass != US_SC_8070) { 1110 printf("Sorry, protocol %d not yet supported.\n",ss->subclass); 1111 return 0; 1112 } 1113 if(ss->ep_int) { /* we had found an interrupt endpoint, prepare irq pipe */ 1114 /* set up the IRQ pipe and handler */ 1115 1116 ss->irqinterval = (ss->irqinterval > 0) ? ss->irqinterval : 255; 1117 ss->irqpipe = usb_rcvintpipe(ss->pusb_dev, ss->ep_int); 1118 ss->irqmaxp = usb_maxpacket(dev, ss->irqpipe); 1119 dev->irq_handle=usb_stor_irq; 1120 } 1121 dev->privptr=(void *)ss; 1122 return 1; 1123 } 1124 1125 int usb_stor_get_info(struct usb_device *dev,struct us_data *ss,block_dev_desc_t *dev_desc) 1126 { 1127 unsigned char perq,modi; 1128 unsigned long cap[2]; 1129 unsigned long *capacity,*blksz; 1130 ccb *pccb = &usb_ccb; 1131 1132 /* for some reasons a couple of devices would not survive this reset */ 1133 if ( 1134 /* Sony USM256E */ 1135 (dev->descriptor.idVendor == 0x054c && 1136 dev->descriptor.idProduct == 0x019e) 1137 1138 || 1139 /* USB007 Mini-USB2 Flash Drive */ 1140 (dev->descriptor.idVendor == 0x066f && 1141 dev->descriptor.idProduct == 0x2010) 1142 ) 1143 USB_STOR_PRINTF("usb_stor_get_info: skipping RESET..\n"); 1144 else 1145 ss->transport_reset(ss); 1146 1147 pccb->pdata = usb_stor_buf; 1148 1149 dev_desc->target = dev->devnum; 1150 pccb->lun = dev_desc->lun; 1151 USB_STOR_PRINTF(" address %d\n",dev_desc->target); 1152 1153 if(usb_inquiry(pccb,ss)) 1154 return -1; 1155 1156 perq = usb_stor_buf[0]; 1157 modi = usb_stor_buf[1]; 1158 if((perq & 0x1f) == 0x1f) { 1159 return 0; /* skip unknown devices */ 1160 } 1161 if((modi&0x80) == 0x80) {/* drive is removable */ 1162 dev_desc->removable = 1; 1163 } 1164 memcpy(&dev_desc->vendor[0], &usb_stor_buf[8], 8); 1165 memcpy(&dev_desc->product[0], &usb_stor_buf[16], 16); 1166 memcpy(&dev_desc->revision[0], &usb_stor_buf[32], 4); 1167 dev_desc->vendor[8] = 0; 1168 dev_desc->product[16] = 0; 1169 dev_desc->revision[4] = 0; 1170 USB_STOR_PRINTF("ISO Vers %X, Response Data %X\n",usb_stor_buf[2],usb_stor_buf[3]); 1171 if(usb_test_unit_ready(pccb,ss)) { 1172 printf("Device NOT ready\n Request Sense returned %02X %02X %02X\n",pccb->sense_buf[2],pccb->sense_buf[12],pccb->sense_buf[13]); 1173 if(dev_desc->removable == 1) { 1174 dev_desc->type = perq; 1175 return 1; 1176 } 1177 else 1178 return 0; 1179 } 1180 pccb->pdata = (unsigned char *)&cap[0]; 1181 memset(pccb->pdata,0,8); 1182 if(usb_read_capacity(pccb,ss) != 0) { 1183 printf("READ_CAP ERROR\n"); 1184 cap[0] = 2880; 1185 cap[1] = 0x200; 1186 } 1187 USB_STOR_PRINTF("Read Capacity returns: 0x%lx, 0x%lx\n",cap[0],cap[1]); 1188 #if 0 1189 if(cap[0]>(0x200000 * 10)) /* greater than 10 GByte */ 1190 cap[0]>>=16; 1191 #endif 1192 #ifdef LITTLEENDIAN 1193 cap[0] = ((unsigned long)( 1194 (((unsigned long)(cap[0]) & (unsigned long)0x000000ffUL) << 24) | 1195 (((unsigned long)(cap[0]) & (unsigned long)0x0000ff00UL) << 8) | 1196 (((unsigned long)(cap[0]) & (unsigned long)0x00ff0000UL) >> 8) | 1197 (((unsigned long)(cap[0]) & (unsigned long)0xff000000UL) >> 24) )); 1198 cap[1] = ((unsigned long)( 1199 (((unsigned long)(cap[1]) & (unsigned long)0x000000ffUL) << 24) | 1200 (((unsigned long)(cap[1]) & (unsigned long)0x0000ff00UL) << 8) | 1201 (((unsigned long)(cap[1]) & (unsigned long)0x00ff0000UL) >> 8) | 1202 (((unsigned long)(cap[1]) & (unsigned long)0xff000000UL) >> 24) )); 1203 #endif 1204 /* this assumes bigendian! */ 1205 cap[0] += 1; 1206 capacity = &cap[0]; 1207 blksz = &cap[1]; 1208 USB_STOR_PRINTF("Capacity = 0x%lx, blocksz = 0x%lx\n",*capacity,*blksz); 1209 dev_desc->lba = *capacity; 1210 dev_desc->blksz = *blksz; 1211 dev_desc->type = perq; 1212 USB_STOR_PRINTF(" address %d\n",dev_desc->target); 1213 USB_STOR_PRINTF("partype: %d\n",dev_desc->part_type); 1214 1215 init_part(dev_desc); 1216 1217 USB_STOR_PRINTF("partype: %d\n",dev_desc->part_type); 1218 return 1; 1219 } 1220 1221 #endif /* CONFIG_USB_STORAGE */ 1222 #endif /* CFG_CMD_USB */ 1223