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