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 * Driver model conversion: 13 * (C) Copyright 2015 Google, Inc 14 * 15 * For BBB support (C) Copyright 2003 16 * Gary Jennejohn, DENX Software Engineering <garyj@denx.de> 17 * 18 * BBB support based on /sys/dev/usb/umass.c from 19 * FreeBSD. 20 * 21 * SPDX-License-Identifier: GPL-2.0+ 22 */ 23 24 /* Note: 25 * Currently only the CBI transport protocoll has been implemented, and it 26 * is only tested with a TEAC USB Floppy. Other Massstorages with CBI or CB 27 * transport protocoll may work as well. 28 */ 29 /* 30 * New Note: 31 * Support for USB Mass Storage Devices (BBB) has been added. It has 32 * only been tested with USB memory sticks. 33 */ 34 35 36 #include <common.h> 37 #include <command.h> 38 #include <dm.h> 39 #include <errno.h> 40 #include <inttypes.h> 41 #include <mapmem.h> 42 #include <memalign.h> 43 #include <asm/byteorder.h> 44 #include <asm/processor.h> 45 #include <dm/device-internal.h> 46 47 #include <part.h> 48 #include <usb.h> 49 50 #undef BBB_COMDAT_TRACE 51 #undef BBB_XPORT_TRACE 52 53 #include <scsi.h> 54 /* direction table -- this indicates the direction of the data 55 * transfer for each command code -- a 1 indicates input 56 */ 57 static const unsigned char us_direction[256/8] = { 58 0x28, 0x81, 0x14, 0x14, 0x20, 0x01, 0x90, 0x77, 59 0x0C, 0x20, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 60 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 61 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 62 }; 63 #define US_DIRECTION(x) ((us_direction[x>>3] >> (x & 7)) & 1) 64 65 static ccb usb_ccb __attribute__((aligned(ARCH_DMA_MINALIGN))); 66 static __u32 CBWTag; 67 68 static int usb_max_devs; /* number of highest available usb device */ 69 70 static struct blk_desc usb_dev_desc[USB_MAX_STOR_DEV]; 71 72 struct us_data; 73 typedef int (*trans_cmnd)(ccb *cb, struct us_data *data); 74 typedef int (*trans_reset)(struct us_data *data); 75 76 struct us_data { 77 struct usb_device *pusb_dev; /* this usb_device */ 78 79 unsigned int flags; /* from filter initially */ 80 # define USB_READY (1 << 0) 81 unsigned char ifnum; /* interface number */ 82 unsigned char ep_in; /* in endpoint */ 83 unsigned char ep_out; /* out ....... */ 84 unsigned char ep_int; /* interrupt . */ 85 unsigned char subclass; /* as in overview */ 86 unsigned char protocol; /* .............. */ 87 unsigned char attention_done; /* force attn on first cmd */ 88 unsigned short ip_data; /* interrupt data */ 89 int action; /* what to do */ 90 int ip_wanted; /* needed */ 91 int *irq_handle; /* for USB int requests */ 92 unsigned int irqpipe; /* pipe for release_irq */ 93 unsigned char irqmaxp; /* max packed for irq Pipe */ 94 unsigned char irqinterval; /* Intervall for IRQ Pipe */ 95 ccb *srb; /* current srb */ 96 trans_reset transport_reset; /* reset routine */ 97 trans_cmnd transport; /* transport routine */ 98 }; 99 100 #ifdef CONFIG_USB_EHCI 101 /* 102 * The U-Boot EHCI driver can handle any transfer length as long as there is 103 * enough free heap space left, but the SCSI READ(10) and WRITE(10) commands are 104 * limited to 65535 blocks. 105 */ 106 #define USB_MAX_XFER_BLK 65535 107 #else 108 #define USB_MAX_XFER_BLK 20 109 #endif 110 111 static struct us_data usb_stor[USB_MAX_STOR_DEV]; 112 113 #define USB_STOR_TRANSPORT_GOOD 0 114 #define USB_STOR_TRANSPORT_FAILED -1 115 #define USB_STOR_TRANSPORT_ERROR -2 116 117 int usb_stor_get_info(struct usb_device *dev, struct us_data *us, 118 struct blk_desc *dev_desc); 119 int usb_storage_probe(struct usb_device *dev, unsigned int ifnum, 120 struct us_data *ss); 121 static unsigned long usb_stor_read(struct blk_desc *block_dev, lbaint_t blknr, 122 lbaint_t blkcnt, void *buffer); 123 static unsigned long usb_stor_write(struct blk_desc *block_dev, lbaint_t blknr, 124 lbaint_t blkcnt, const void *buffer); 125 void uhci_show_temp_int_td(void); 126 127 #ifdef CONFIG_PARTITIONS 128 struct blk_desc *usb_stor_get_dev(int index) 129 { 130 return (index < usb_max_devs) ? &usb_dev_desc[index] : NULL; 131 } 132 #endif 133 134 static void usb_show_progress(void) 135 { 136 debug("."); 137 } 138 139 /******************************************************************************* 140 * show info on storage devices; 'usb start/init' must be invoked earlier 141 * as we only retrieve structures populated during devices initialization 142 */ 143 int usb_stor_info(void) 144 { 145 int count = 0; 146 int i; 147 148 if (usb_max_devs > 0) { 149 for (i = 0; i < usb_max_devs; i++) { 150 printf(" Device %d: ", i); 151 dev_print(&usb_dev_desc[i]); 152 } 153 return 0; 154 } 155 156 if (!count) { 157 printf("No storage devices, perhaps not 'usb start'ed..?\n"); 158 return 1; 159 } 160 161 return 1; 162 } 163 164 static unsigned int usb_get_max_lun(struct us_data *us) 165 { 166 int len; 167 ALLOC_CACHE_ALIGN_BUFFER(unsigned char, result, 1); 168 len = usb_control_msg(us->pusb_dev, 169 usb_rcvctrlpipe(us->pusb_dev, 0), 170 US_BBB_GET_MAX_LUN, 171 USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_DIR_IN, 172 0, us->ifnum, 173 result, sizeof(char), 174 USB_CNTL_TIMEOUT * 5); 175 debug("Get Max LUN -> len = %i, result = %i\n", len, (int) *result); 176 return (len > 0) ? *result : 0; 177 } 178 179 static int usb_stor_probe_device(struct usb_device *udev) 180 { 181 int lun, max_lun; 182 int start; 183 184 if (udev == NULL) 185 return -ENOENT; /* no more devices available */ 186 187 /* We don't have space to even probe if we hit the maximum */ 188 if (usb_max_devs == USB_MAX_STOR_DEV) { 189 printf("max USB Storage Device reached: %d stopping\n", 190 usb_max_devs); 191 return -ENOSPC; 192 } 193 194 debug("\n\nProbing for storage\n"); 195 if (!usb_storage_probe(udev, 0, &usb_stor[usb_max_devs])) 196 return 0; 197 198 /* 199 * OK, it's a storage device. Iterate over its LUNs and populate 200 * usb_dev_desc' 201 */ 202 start = usb_max_devs; 203 204 max_lun = usb_get_max_lun(&usb_stor[usb_max_devs]); 205 for (lun = 0; lun <= max_lun && usb_max_devs < USB_MAX_STOR_DEV; 206 lun++) { 207 struct blk_desc *blkdev; 208 209 blkdev = &usb_dev_desc[usb_max_devs]; 210 memset(blkdev, '\0', sizeof(struct blk_desc)); 211 blkdev->if_type = IF_TYPE_USB; 212 blkdev->devnum = usb_max_devs; 213 blkdev->part_type = PART_TYPE_UNKNOWN; 214 blkdev->target = 0xff; 215 blkdev->type = DEV_TYPE_UNKNOWN; 216 blkdev->block_read = usb_stor_read; 217 blkdev->block_write = usb_stor_write; 218 blkdev->lun = lun; 219 blkdev->priv = udev; 220 221 if (usb_stor_get_info(udev, &usb_stor[start], 222 &usb_dev_desc[usb_max_devs]) == 1) { 223 usb_max_devs++; 224 debug("%s: Found device %p\n", __func__, udev); 225 } 226 } 227 228 return 0; 229 } 230 231 void usb_stor_reset(void) 232 { 233 usb_max_devs = 0; 234 } 235 236 #ifndef CONFIG_DM_USB 237 /******************************************************************************* 238 * scan the usb and reports device info 239 * to the user if mode = 1 240 * returns current device or -1 if no 241 */ 242 int usb_stor_scan(int mode) 243 { 244 unsigned char i; 245 246 if (mode == 1) 247 printf(" scanning usb for storage devices... "); 248 249 usb_disable_asynch(1); /* asynch transfer not allowed */ 250 251 usb_stor_reset(); 252 for (i = 0; i < USB_MAX_DEVICE; i++) { 253 struct usb_device *dev; 254 255 dev = usb_get_dev_index(i); /* get device */ 256 debug("i=%d\n", i); 257 if (usb_stor_probe_device(dev)) 258 break; 259 } /* for */ 260 261 usb_disable_asynch(0); /* asynch transfer allowed */ 262 printf("%d Storage Device(s) found\n", usb_max_devs); 263 if (usb_max_devs > 0) 264 return 0; 265 return -1; 266 } 267 #endif 268 269 static int usb_stor_irq(struct usb_device *dev) 270 { 271 struct us_data *us; 272 us = (struct us_data *)dev->privptr; 273 274 if (us->ip_wanted) 275 us->ip_wanted = 0; 276 return 0; 277 } 278 279 280 #ifdef DEBUG 281 282 static void usb_show_srb(ccb *pccb) 283 { 284 int i; 285 printf("SRB: len %d datalen 0x%lX\n ", pccb->cmdlen, pccb->datalen); 286 for (i = 0; i < 12; i++) 287 printf("%02X ", pccb->cmd[i]); 288 printf("\n"); 289 } 290 291 static void display_int_status(unsigned long tmp) 292 { 293 printf("Status: %s %s %s %s %s %s %s\n", 294 (tmp & USB_ST_ACTIVE) ? "Active" : "", 295 (tmp & USB_ST_STALLED) ? "Stalled" : "", 296 (tmp & USB_ST_BUF_ERR) ? "Buffer Error" : "", 297 (tmp & USB_ST_BABBLE_DET) ? "Babble Det" : "", 298 (tmp & USB_ST_NAK_REC) ? "NAKed" : "", 299 (tmp & USB_ST_CRC_ERR) ? "CRC Error" : "", 300 (tmp & USB_ST_BIT_ERR) ? "Bitstuff Error" : ""); 301 } 302 #endif 303 /*********************************************************************** 304 * Data transfer routines 305 ***********************************************************************/ 306 307 static int us_one_transfer(struct us_data *us, int pipe, char *buf, int length) 308 { 309 int max_size; 310 int this_xfer; 311 int result; 312 int partial; 313 int maxtry; 314 int stat; 315 316 /* determine the maximum packet size for these transfers */ 317 max_size = usb_maxpacket(us->pusb_dev, pipe) * 16; 318 319 /* while we have data left to transfer */ 320 while (length) { 321 322 /* calculate how long this will be -- maximum or a remainder */ 323 this_xfer = length > max_size ? max_size : length; 324 length -= this_xfer; 325 326 /* setup the retry counter */ 327 maxtry = 10; 328 329 /* set up the transfer loop */ 330 do { 331 /* transfer the data */ 332 debug("Bulk xfer 0x%lx(%d) try #%d\n", 333 (ulong)map_to_sysmem(buf), this_xfer, 334 11 - maxtry); 335 result = usb_bulk_msg(us->pusb_dev, pipe, buf, 336 this_xfer, &partial, 337 USB_CNTL_TIMEOUT * 5); 338 debug("bulk_msg returned %d xferred %d/%d\n", 339 result, partial, this_xfer); 340 if (us->pusb_dev->status != 0) { 341 /* if we stall, we need to clear it before 342 * we go on 343 */ 344 #ifdef DEBUG 345 display_int_status(us->pusb_dev->status); 346 #endif 347 if (us->pusb_dev->status & USB_ST_STALLED) { 348 debug("stalled ->clearing endpoint" \ 349 "halt for pipe 0x%x\n", pipe); 350 stat = us->pusb_dev->status; 351 usb_clear_halt(us->pusb_dev, pipe); 352 us->pusb_dev->status = stat; 353 if (this_xfer == partial) { 354 debug("bulk transferred" \ 355 "with error %lX," \ 356 " but data ok\n", 357 us->pusb_dev->status); 358 return 0; 359 } 360 else 361 return result; 362 } 363 if (us->pusb_dev->status & USB_ST_NAK_REC) { 364 debug("Device NAKed bulk_msg\n"); 365 return result; 366 } 367 debug("bulk transferred with error"); 368 if (this_xfer == partial) { 369 debug(" %ld, but data ok\n", 370 us->pusb_dev->status); 371 return 0; 372 } 373 /* if our try counter reaches 0, bail out */ 374 debug(" %ld, data %d\n", 375 us->pusb_dev->status, partial); 376 if (!maxtry--) 377 return result; 378 } 379 /* update to show what data was transferred */ 380 this_xfer -= partial; 381 buf += partial; 382 /* continue until this transfer is done */ 383 } while (this_xfer); 384 } 385 386 /* if we get here, we're done and successful */ 387 return 0; 388 } 389 390 static int usb_stor_BBB_reset(struct us_data *us) 391 { 392 int result; 393 unsigned int pipe; 394 395 /* 396 * Reset recovery (5.3.4 in Universal Serial Bus Mass Storage Class) 397 * 398 * For Reset Recovery the host shall issue in the following order: 399 * a) a Bulk-Only Mass Storage Reset 400 * b) a Clear Feature HALT to the Bulk-In endpoint 401 * c) a Clear Feature HALT to the Bulk-Out endpoint 402 * 403 * This is done in 3 steps. 404 * 405 * If the reset doesn't succeed, the device should be port reset. 406 * 407 * This comment stolen from FreeBSD's /sys/dev/usb/umass.c. 408 */ 409 debug("BBB_reset\n"); 410 result = usb_control_msg(us->pusb_dev, usb_sndctrlpipe(us->pusb_dev, 0), 411 US_BBB_RESET, 412 USB_TYPE_CLASS | USB_RECIP_INTERFACE, 413 0, us->ifnum, NULL, 0, USB_CNTL_TIMEOUT * 5); 414 415 if ((result < 0) && (us->pusb_dev->status & USB_ST_STALLED)) { 416 debug("RESET:stall\n"); 417 return -1; 418 } 419 420 /* long wait for reset */ 421 mdelay(150); 422 debug("BBB_reset result %d: status %lX reset\n", 423 result, us->pusb_dev->status); 424 pipe = usb_rcvbulkpipe(us->pusb_dev, us->ep_in); 425 result = usb_clear_halt(us->pusb_dev, pipe); 426 /* long wait for reset */ 427 mdelay(150); 428 debug("BBB_reset result %d: status %lX clearing IN endpoint\n", 429 result, us->pusb_dev->status); 430 /* long wait for reset */ 431 pipe = usb_sndbulkpipe(us->pusb_dev, us->ep_out); 432 result = usb_clear_halt(us->pusb_dev, pipe); 433 mdelay(150); 434 debug("BBB_reset result %d: status %lX clearing OUT endpoint\n", 435 result, us->pusb_dev->status); 436 debug("BBB_reset done\n"); 437 return 0; 438 } 439 440 /* FIXME: this reset function doesn't really reset the port, and it 441 * should. Actually it should probably do what it's doing here, and 442 * reset the port physically 443 */ 444 static int usb_stor_CB_reset(struct us_data *us) 445 { 446 unsigned char cmd[12]; 447 int result; 448 449 debug("CB_reset\n"); 450 memset(cmd, 0xff, sizeof(cmd)); 451 cmd[0] = SCSI_SEND_DIAG; 452 cmd[1] = 4; 453 result = usb_control_msg(us->pusb_dev, usb_sndctrlpipe(us->pusb_dev, 0), 454 US_CBI_ADSC, 455 USB_TYPE_CLASS | USB_RECIP_INTERFACE, 456 0, us->ifnum, cmd, sizeof(cmd), 457 USB_CNTL_TIMEOUT * 5); 458 459 /* long wait for reset */ 460 mdelay(1500); 461 debug("CB_reset result %d: status %lX clearing endpoint halt\n", 462 result, us->pusb_dev->status); 463 usb_clear_halt(us->pusb_dev, usb_rcvbulkpipe(us->pusb_dev, us->ep_in)); 464 usb_clear_halt(us->pusb_dev, usb_rcvbulkpipe(us->pusb_dev, us->ep_out)); 465 466 debug("CB_reset done\n"); 467 return 0; 468 } 469 470 /* 471 * Set up the command for a BBB device. Note that the actual SCSI 472 * command is copied into cbw.CBWCDB. 473 */ 474 static int usb_stor_BBB_comdat(ccb *srb, struct us_data *us) 475 { 476 int result; 477 int actlen; 478 int dir_in; 479 unsigned int pipe; 480 ALLOC_CACHE_ALIGN_BUFFER(struct umass_bbb_cbw, cbw, 1); 481 482 dir_in = US_DIRECTION(srb->cmd[0]); 483 484 #ifdef BBB_COMDAT_TRACE 485 printf("dir %d lun %d cmdlen %d cmd %p datalen %lu pdata %p\n", 486 dir_in, srb->lun, srb->cmdlen, srb->cmd, srb->datalen, 487 srb->pdata); 488 if (srb->cmdlen) { 489 for (result = 0; result < srb->cmdlen; result++) 490 printf("cmd[%d] %#x ", result, srb->cmd[result]); 491 printf("\n"); 492 } 493 #endif 494 /* sanity checks */ 495 if (!(srb->cmdlen <= CBWCDBLENGTH)) { 496 debug("usb_stor_BBB_comdat:cmdlen too large\n"); 497 return -1; 498 } 499 500 /* always OUT to the ep */ 501 pipe = usb_sndbulkpipe(us->pusb_dev, us->ep_out); 502 503 cbw->dCBWSignature = cpu_to_le32(CBWSIGNATURE); 504 cbw->dCBWTag = cpu_to_le32(CBWTag++); 505 cbw->dCBWDataTransferLength = cpu_to_le32(srb->datalen); 506 cbw->bCBWFlags = (dir_in ? CBWFLAGS_IN : CBWFLAGS_OUT); 507 cbw->bCBWLUN = srb->lun; 508 cbw->bCDBLength = srb->cmdlen; 509 /* copy the command data into the CBW command data buffer */ 510 /* DST SRC LEN!!! */ 511 512 memcpy(cbw->CBWCDB, srb->cmd, srb->cmdlen); 513 result = usb_bulk_msg(us->pusb_dev, pipe, cbw, UMASS_BBB_CBW_SIZE, 514 &actlen, USB_CNTL_TIMEOUT * 5); 515 if (result < 0) 516 debug("usb_stor_BBB_comdat:usb_bulk_msg error\n"); 517 return result; 518 } 519 520 /* FIXME: we also need a CBI_command which sets up the completion 521 * interrupt, and waits for it 522 */ 523 static int usb_stor_CB_comdat(ccb *srb, struct us_data *us) 524 { 525 int result = 0; 526 int dir_in, retry; 527 unsigned int pipe; 528 unsigned long status; 529 530 retry = 5; 531 dir_in = US_DIRECTION(srb->cmd[0]); 532 533 if (dir_in) 534 pipe = usb_rcvbulkpipe(us->pusb_dev, us->ep_in); 535 else 536 pipe = usb_sndbulkpipe(us->pusb_dev, us->ep_out); 537 538 while (retry--) { 539 debug("CBI gets a command: Try %d\n", 5 - retry); 540 #ifdef DEBUG 541 usb_show_srb(srb); 542 #endif 543 /* let's send the command via the control pipe */ 544 result = usb_control_msg(us->pusb_dev, 545 usb_sndctrlpipe(us->pusb_dev , 0), 546 US_CBI_ADSC, 547 USB_TYPE_CLASS | USB_RECIP_INTERFACE, 548 0, us->ifnum, 549 srb->cmd, srb->cmdlen, 550 USB_CNTL_TIMEOUT * 5); 551 debug("CB_transport: control msg returned %d, status %lX\n", 552 result, us->pusb_dev->status); 553 /* check the return code for the command */ 554 if (result < 0) { 555 if (us->pusb_dev->status & USB_ST_STALLED) { 556 status = us->pusb_dev->status; 557 debug(" stall during command found," \ 558 " clear pipe\n"); 559 usb_clear_halt(us->pusb_dev, 560 usb_sndctrlpipe(us->pusb_dev, 0)); 561 us->pusb_dev->status = status; 562 } 563 debug(" error during command %02X" \ 564 " Stat = %lX\n", srb->cmd[0], 565 us->pusb_dev->status); 566 return result; 567 } 568 /* transfer the data payload for this command, if one exists*/ 569 570 debug("CB_transport: control msg returned %d," \ 571 " direction is %s to go 0x%lx\n", result, 572 dir_in ? "IN" : "OUT", srb->datalen); 573 if (srb->datalen) { 574 result = us_one_transfer(us, pipe, (char *)srb->pdata, 575 srb->datalen); 576 debug("CBI attempted to transfer data," \ 577 " result is %d status %lX, len %d\n", 578 result, us->pusb_dev->status, 579 us->pusb_dev->act_len); 580 if (!(us->pusb_dev->status & USB_ST_NAK_REC)) 581 break; 582 } /* if (srb->datalen) */ 583 else 584 break; 585 } 586 /* return result */ 587 588 return result; 589 } 590 591 592 static int usb_stor_CBI_get_status(ccb *srb, struct us_data *us) 593 { 594 int timeout; 595 596 us->ip_wanted = 1; 597 submit_int_msg(us->pusb_dev, us->irqpipe, 598 (void *) &us->ip_data, us->irqmaxp, us->irqinterval); 599 timeout = 1000; 600 while (timeout--) { 601 if (us->ip_wanted == 0) 602 break; 603 mdelay(10); 604 } 605 if (us->ip_wanted) { 606 printf(" Did not get interrupt on CBI\n"); 607 us->ip_wanted = 0; 608 return USB_STOR_TRANSPORT_ERROR; 609 } 610 debug("Got interrupt data 0x%x, transfered %d status 0x%lX\n", 611 us->ip_data, us->pusb_dev->irq_act_len, 612 us->pusb_dev->irq_status); 613 /* UFI gives us ASC and ASCQ, like a request sense */ 614 if (us->subclass == US_SC_UFI) { 615 if (srb->cmd[0] == SCSI_REQ_SENSE || 616 srb->cmd[0] == SCSI_INQUIRY) 617 return USB_STOR_TRANSPORT_GOOD; /* Good */ 618 else if (us->ip_data) 619 return USB_STOR_TRANSPORT_FAILED; 620 else 621 return USB_STOR_TRANSPORT_GOOD; 622 } 623 /* otherwise, we interpret the data normally */ 624 switch (us->ip_data) { 625 case 0x0001: 626 return USB_STOR_TRANSPORT_GOOD; 627 case 0x0002: 628 return USB_STOR_TRANSPORT_FAILED; 629 default: 630 return USB_STOR_TRANSPORT_ERROR; 631 } /* switch */ 632 return USB_STOR_TRANSPORT_ERROR; 633 } 634 635 #define USB_TRANSPORT_UNKNOWN_RETRY 5 636 #define USB_TRANSPORT_NOT_READY_RETRY 10 637 638 /* clear a stall on an endpoint - special for BBB devices */ 639 static int usb_stor_BBB_clear_endpt_stall(struct us_data *us, __u8 endpt) 640 { 641 int result; 642 643 /* ENDPOINT_HALT = 0, so set value to 0 */ 644 result = usb_control_msg(us->pusb_dev, usb_sndctrlpipe(us->pusb_dev, 0), 645 USB_REQ_CLEAR_FEATURE, USB_RECIP_ENDPOINT, 646 0, endpt, NULL, 0, USB_CNTL_TIMEOUT * 5); 647 return result; 648 } 649 650 static int usb_stor_BBB_transport(ccb *srb, struct us_data *us) 651 { 652 int result, retry; 653 int dir_in; 654 int actlen, data_actlen; 655 unsigned int pipe, pipein, pipeout; 656 ALLOC_CACHE_ALIGN_BUFFER(struct umass_bbb_csw, csw, 1); 657 #ifdef BBB_XPORT_TRACE 658 unsigned char *ptr; 659 int index; 660 #endif 661 662 dir_in = US_DIRECTION(srb->cmd[0]); 663 664 /* COMMAND phase */ 665 debug("COMMAND phase\n"); 666 result = usb_stor_BBB_comdat(srb, us); 667 if (result < 0) { 668 debug("failed to send CBW status %ld\n", 669 us->pusb_dev->status); 670 usb_stor_BBB_reset(us); 671 return USB_STOR_TRANSPORT_FAILED; 672 } 673 if (!(us->flags & USB_READY)) 674 mdelay(5); 675 pipein = usb_rcvbulkpipe(us->pusb_dev, us->ep_in); 676 pipeout = usb_sndbulkpipe(us->pusb_dev, us->ep_out); 677 /* DATA phase + error handling */ 678 data_actlen = 0; 679 /* no data, go immediately to the STATUS phase */ 680 if (srb->datalen == 0) 681 goto st; 682 debug("DATA phase\n"); 683 if (dir_in) 684 pipe = pipein; 685 else 686 pipe = pipeout; 687 688 result = usb_bulk_msg(us->pusb_dev, pipe, srb->pdata, srb->datalen, 689 &data_actlen, USB_CNTL_TIMEOUT * 5); 690 /* special handling of STALL in DATA phase */ 691 if ((result < 0) && (us->pusb_dev->status & USB_ST_STALLED)) { 692 debug("DATA:stall\n"); 693 /* clear the STALL on the endpoint */ 694 result = usb_stor_BBB_clear_endpt_stall(us, 695 dir_in ? us->ep_in : us->ep_out); 696 if (result >= 0) 697 /* continue on to STATUS phase */ 698 goto st; 699 } 700 if (result < 0) { 701 debug("usb_bulk_msg error status %ld\n", 702 us->pusb_dev->status); 703 usb_stor_BBB_reset(us); 704 return USB_STOR_TRANSPORT_FAILED; 705 } 706 #ifdef BBB_XPORT_TRACE 707 for (index = 0; index < data_actlen; index++) 708 printf("pdata[%d] %#x ", index, srb->pdata[index]); 709 printf("\n"); 710 #endif 711 /* STATUS phase + error handling */ 712 st: 713 retry = 0; 714 again: 715 debug("STATUS phase\n"); 716 result = usb_bulk_msg(us->pusb_dev, pipein, csw, UMASS_BBB_CSW_SIZE, 717 &actlen, USB_CNTL_TIMEOUT*5); 718 719 /* special handling of STALL in STATUS phase */ 720 if ((result < 0) && (retry < 1) && 721 (us->pusb_dev->status & USB_ST_STALLED)) { 722 debug("STATUS:stall\n"); 723 /* clear the STALL on the endpoint */ 724 result = usb_stor_BBB_clear_endpt_stall(us, us->ep_in); 725 if (result >= 0 && (retry++ < 1)) 726 /* do a retry */ 727 goto again; 728 } 729 if (result < 0) { 730 debug("usb_bulk_msg error status %ld\n", 731 us->pusb_dev->status); 732 usb_stor_BBB_reset(us); 733 return USB_STOR_TRANSPORT_FAILED; 734 } 735 #ifdef BBB_XPORT_TRACE 736 ptr = (unsigned char *)csw; 737 for (index = 0; index < UMASS_BBB_CSW_SIZE; index++) 738 printf("ptr[%d] %#x ", index, ptr[index]); 739 printf("\n"); 740 #endif 741 /* misuse pipe to get the residue */ 742 pipe = le32_to_cpu(csw->dCSWDataResidue); 743 if (pipe == 0 && srb->datalen != 0 && srb->datalen - data_actlen != 0) 744 pipe = srb->datalen - data_actlen; 745 if (CSWSIGNATURE != le32_to_cpu(csw->dCSWSignature)) { 746 debug("!CSWSIGNATURE\n"); 747 usb_stor_BBB_reset(us); 748 return USB_STOR_TRANSPORT_FAILED; 749 } else if ((CBWTag - 1) != le32_to_cpu(csw->dCSWTag)) { 750 debug("!Tag\n"); 751 usb_stor_BBB_reset(us); 752 return USB_STOR_TRANSPORT_FAILED; 753 } else if (csw->bCSWStatus > CSWSTATUS_PHASE) { 754 debug(">PHASE\n"); 755 usb_stor_BBB_reset(us); 756 return USB_STOR_TRANSPORT_FAILED; 757 } else if (csw->bCSWStatus == CSWSTATUS_PHASE) { 758 debug("=PHASE\n"); 759 usb_stor_BBB_reset(us); 760 return USB_STOR_TRANSPORT_FAILED; 761 } else if (data_actlen > srb->datalen) { 762 debug("transferred %dB instead of %ldB\n", 763 data_actlen, srb->datalen); 764 return USB_STOR_TRANSPORT_FAILED; 765 } else if (csw->bCSWStatus == CSWSTATUS_FAILED) { 766 debug("FAILED\n"); 767 return USB_STOR_TRANSPORT_FAILED; 768 } 769 770 return result; 771 } 772 773 static int usb_stor_CB_transport(ccb *srb, struct us_data *us) 774 { 775 int result, status; 776 ccb *psrb; 777 ccb reqsrb; 778 int retry, notready; 779 780 psrb = &reqsrb; 781 status = USB_STOR_TRANSPORT_GOOD; 782 retry = 0; 783 notready = 0; 784 /* issue the command */ 785 do_retry: 786 result = usb_stor_CB_comdat(srb, us); 787 debug("command / Data returned %d, status %lX\n", 788 result, us->pusb_dev->status); 789 /* if this is an CBI Protocol, get IRQ */ 790 if (us->protocol == US_PR_CBI) { 791 status = usb_stor_CBI_get_status(srb, us); 792 /* if the status is error, report it */ 793 if (status == USB_STOR_TRANSPORT_ERROR) { 794 debug(" USB CBI Command Error\n"); 795 return status; 796 } 797 srb->sense_buf[12] = (unsigned char)(us->ip_data >> 8); 798 srb->sense_buf[13] = (unsigned char)(us->ip_data & 0xff); 799 if (!us->ip_data) { 800 /* if the status is good, report it */ 801 if (status == USB_STOR_TRANSPORT_GOOD) { 802 debug(" USB CBI Command Good\n"); 803 return status; 804 } 805 } 806 } 807 /* do we have to issue an auto request? */ 808 /* HERE we have to check the result */ 809 if ((result < 0) && !(us->pusb_dev->status & USB_ST_STALLED)) { 810 debug("ERROR %lX\n", us->pusb_dev->status); 811 us->transport_reset(us); 812 return USB_STOR_TRANSPORT_ERROR; 813 } 814 if ((us->protocol == US_PR_CBI) && 815 ((srb->cmd[0] == SCSI_REQ_SENSE) || 816 (srb->cmd[0] == SCSI_INQUIRY))) { 817 /* do not issue an autorequest after request sense */ 818 debug("No auto request and good\n"); 819 return USB_STOR_TRANSPORT_GOOD; 820 } 821 /* issue an request_sense */ 822 memset(&psrb->cmd[0], 0, 12); 823 psrb->cmd[0] = SCSI_REQ_SENSE; 824 psrb->cmd[1] = srb->lun << 5; 825 psrb->cmd[4] = 18; 826 psrb->datalen = 18; 827 psrb->pdata = &srb->sense_buf[0]; 828 psrb->cmdlen = 12; 829 /* issue the command */ 830 result = usb_stor_CB_comdat(psrb, us); 831 debug("auto request returned %d\n", result); 832 /* if this is an CBI Protocol, get IRQ */ 833 if (us->protocol == US_PR_CBI) 834 status = usb_stor_CBI_get_status(psrb, us); 835 836 if ((result < 0) && !(us->pusb_dev->status & USB_ST_STALLED)) { 837 debug(" AUTO REQUEST ERROR %ld\n", 838 us->pusb_dev->status); 839 return USB_STOR_TRANSPORT_ERROR; 840 } 841 debug("autorequest returned 0x%02X 0x%02X 0x%02X 0x%02X\n", 842 srb->sense_buf[0], srb->sense_buf[2], 843 srb->sense_buf[12], srb->sense_buf[13]); 844 /* Check the auto request result */ 845 if ((srb->sense_buf[2] == 0) && 846 (srb->sense_buf[12] == 0) && 847 (srb->sense_buf[13] == 0)) { 848 /* ok, no sense */ 849 return USB_STOR_TRANSPORT_GOOD; 850 } 851 852 /* Check the auto request result */ 853 switch (srb->sense_buf[2]) { 854 case 0x01: 855 /* Recovered Error */ 856 return USB_STOR_TRANSPORT_GOOD; 857 break; 858 case 0x02: 859 /* Not Ready */ 860 if (notready++ > USB_TRANSPORT_NOT_READY_RETRY) { 861 printf("cmd 0x%02X returned 0x%02X 0x%02X 0x%02X" 862 " 0x%02X (NOT READY)\n", srb->cmd[0], 863 srb->sense_buf[0], srb->sense_buf[2], 864 srb->sense_buf[12], srb->sense_buf[13]); 865 return USB_STOR_TRANSPORT_FAILED; 866 } else { 867 mdelay(100); 868 goto do_retry; 869 } 870 break; 871 default: 872 if (retry++ > USB_TRANSPORT_UNKNOWN_RETRY) { 873 printf("cmd 0x%02X returned 0x%02X 0x%02X 0x%02X" 874 " 0x%02X\n", srb->cmd[0], srb->sense_buf[0], 875 srb->sense_buf[2], srb->sense_buf[12], 876 srb->sense_buf[13]); 877 return USB_STOR_TRANSPORT_FAILED; 878 } else 879 goto do_retry; 880 break; 881 } 882 return USB_STOR_TRANSPORT_FAILED; 883 } 884 885 886 static int usb_inquiry(ccb *srb, struct us_data *ss) 887 { 888 int retry, i; 889 retry = 5; 890 do { 891 memset(&srb->cmd[0], 0, 12); 892 srb->cmd[0] = SCSI_INQUIRY; 893 srb->cmd[1] = srb->lun << 5; 894 srb->cmd[4] = 36; 895 srb->datalen = 36; 896 srb->cmdlen = 12; 897 i = ss->transport(srb, ss); 898 debug("inquiry returns %d\n", i); 899 if (i == 0) 900 break; 901 } while (--retry); 902 903 if (!retry) { 904 printf("error in inquiry\n"); 905 return -1; 906 } 907 return 0; 908 } 909 910 static int usb_request_sense(ccb *srb, struct us_data *ss) 911 { 912 char *ptr; 913 914 ptr = (char *)srb->pdata; 915 memset(&srb->cmd[0], 0, 12); 916 srb->cmd[0] = SCSI_REQ_SENSE; 917 srb->cmd[1] = srb->lun << 5; 918 srb->cmd[4] = 18; 919 srb->datalen = 18; 920 srb->pdata = &srb->sense_buf[0]; 921 srb->cmdlen = 12; 922 ss->transport(srb, ss); 923 debug("Request Sense returned %02X %02X %02X\n", 924 srb->sense_buf[2], srb->sense_buf[12], 925 srb->sense_buf[13]); 926 srb->pdata = (uchar *)ptr; 927 return 0; 928 } 929 930 static int usb_test_unit_ready(ccb *srb, struct us_data *ss) 931 { 932 int retries = 10; 933 934 do { 935 memset(&srb->cmd[0], 0, 12); 936 srb->cmd[0] = SCSI_TST_U_RDY; 937 srb->cmd[1] = srb->lun << 5; 938 srb->datalen = 0; 939 srb->cmdlen = 12; 940 if (ss->transport(srb, ss) == USB_STOR_TRANSPORT_GOOD) { 941 ss->flags |= USB_READY; 942 return 0; 943 } 944 usb_request_sense(srb, ss); 945 /* 946 * Check the Key Code Qualifier, if it matches 947 * "Not Ready - medium not present" 948 * (the sense Key equals 0x2 and the ASC is 0x3a) 949 * return immediately as the medium being absent won't change 950 * unless there is a user action. 951 */ 952 if ((srb->sense_buf[2] == 0x02) && 953 (srb->sense_buf[12] == 0x3a)) 954 return -1; 955 mdelay(100); 956 } while (retries--); 957 958 return -1; 959 } 960 961 static int usb_read_capacity(ccb *srb, struct us_data *ss) 962 { 963 int retry; 964 /* XXX retries */ 965 retry = 3; 966 do { 967 memset(&srb->cmd[0], 0, 12); 968 srb->cmd[0] = SCSI_RD_CAPAC; 969 srb->cmd[1] = srb->lun << 5; 970 srb->datalen = 8; 971 srb->cmdlen = 12; 972 if (ss->transport(srb, ss) == USB_STOR_TRANSPORT_GOOD) 973 return 0; 974 } while (retry--); 975 976 return -1; 977 } 978 979 static int usb_read_10(ccb *srb, struct us_data *ss, unsigned long start, 980 unsigned short blocks) 981 { 982 memset(&srb->cmd[0], 0, 12); 983 srb->cmd[0] = SCSI_READ10; 984 srb->cmd[1] = srb->lun << 5; 985 srb->cmd[2] = ((unsigned char) (start >> 24)) & 0xff; 986 srb->cmd[3] = ((unsigned char) (start >> 16)) & 0xff; 987 srb->cmd[4] = ((unsigned char) (start >> 8)) & 0xff; 988 srb->cmd[5] = ((unsigned char) (start)) & 0xff; 989 srb->cmd[7] = ((unsigned char) (blocks >> 8)) & 0xff; 990 srb->cmd[8] = (unsigned char) blocks & 0xff; 991 srb->cmdlen = 12; 992 debug("read10: start %lx blocks %x\n", start, blocks); 993 return ss->transport(srb, ss); 994 } 995 996 static int usb_write_10(ccb *srb, struct us_data *ss, unsigned long start, 997 unsigned short blocks) 998 { 999 memset(&srb->cmd[0], 0, 12); 1000 srb->cmd[0] = SCSI_WRITE10; 1001 srb->cmd[1] = srb->lun << 5; 1002 srb->cmd[2] = ((unsigned char) (start >> 24)) & 0xff; 1003 srb->cmd[3] = ((unsigned char) (start >> 16)) & 0xff; 1004 srb->cmd[4] = ((unsigned char) (start >> 8)) & 0xff; 1005 srb->cmd[5] = ((unsigned char) (start)) & 0xff; 1006 srb->cmd[7] = ((unsigned char) (blocks >> 8)) & 0xff; 1007 srb->cmd[8] = (unsigned char) blocks & 0xff; 1008 srb->cmdlen = 12; 1009 debug("write10: start %lx blocks %x\n", start, blocks); 1010 return ss->transport(srb, ss); 1011 } 1012 1013 1014 #ifdef CONFIG_USB_BIN_FIXUP 1015 /* 1016 * Some USB storage devices queried for SCSI identification data respond with 1017 * binary strings, which if output to the console freeze the terminal. The 1018 * workaround is to modify the vendor and product strings read from such 1019 * device with proper values (as reported by 'usb info'). 1020 * 1021 * Vendor and product length limits are taken from the definition of 1022 * struct blk_desc in include/part.h. 1023 */ 1024 static void usb_bin_fixup(struct usb_device_descriptor descriptor, 1025 unsigned char vendor[], 1026 unsigned char product[]) { 1027 const unsigned char max_vendor_len = 40; 1028 const unsigned char max_product_len = 20; 1029 if (descriptor.idVendor == 0x0424 && descriptor.idProduct == 0x223a) { 1030 strncpy((char *)vendor, "SMSC", max_vendor_len); 1031 strncpy((char *)product, "Flash Media Cntrller", 1032 max_product_len); 1033 } 1034 } 1035 #endif /* CONFIG_USB_BIN_FIXUP */ 1036 1037 static unsigned long usb_stor_read(struct blk_desc *block_dev, lbaint_t blknr, 1038 lbaint_t blkcnt, void *buffer) 1039 { 1040 lbaint_t start, blks; 1041 uintptr_t buf_addr; 1042 unsigned short smallblks; 1043 struct usb_device *udev; 1044 struct us_data *ss; 1045 int retry; 1046 ccb *srb = &usb_ccb; 1047 1048 if (blkcnt == 0) 1049 return 0; 1050 /* Setup device */ 1051 debug("\nusb_read: udev %d\n", block_dev->devnum); 1052 udev = usb_dev_desc[block_dev->devnum].priv; 1053 if (!udev) { 1054 debug("%s: No device\n", __func__); 1055 return 0; 1056 } 1057 ss = (struct us_data *)udev->privptr; 1058 1059 usb_disable_asynch(1); /* asynch transfer not allowed */ 1060 srb->lun = block_dev->lun; 1061 buf_addr = (uintptr_t)buffer; 1062 start = blknr; 1063 blks = blkcnt; 1064 1065 debug("\nusb_read: dev %d startblk " LBAF ", blccnt " LBAF " buffer %" 1066 PRIxPTR "\n", block_dev->devnum, start, blks, buf_addr); 1067 1068 do { 1069 /* XXX need some comment here */ 1070 retry = 2; 1071 srb->pdata = (unsigned char *)buf_addr; 1072 if (blks > USB_MAX_XFER_BLK) 1073 smallblks = USB_MAX_XFER_BLK; 1074 else 1075 smallblks = (unsigned short) blks; 1076 retry_it: 1077 if (smallblks == USB_MAX_XFER_BLK) 1078 usb_show_progress(); 1079 srb->datalen = block_dev->blksz * smallblks; 1080 srb->pdata = (unsigned char *)buf_addr; 1081 if (usb_read_10(srb, ss, start, smallblks)) { 1082 debug("Read ERROR\n"); 1083 usb_request_sense(srb, ss); 1084 if (retry--) 1085 goto retry_it; 1086 blkcnt -= blks; 1087 break; 1088 } 1089 start += smallblks; 1090 blks -= smallblks; 1091 buf_addr += srb->datalen; 1092 } while (blks != 0); 1093 ss->flags &= ~USB_READY; 1094 1095 debug("usb_read: end startblk " LBAF 1096 ", blccnt %x buffer %" PRIxPTR "\n", 1097 start, smallblks, buf_addr); 1098 1099 usb_disable_asynch(0); /* asynch transfer allowed */ 1100 if (blkcnt >= USB_MAX_XFER_BLK) 1101 debug("\n"); 1102 return blkcnt; 1103 } 1104 1105 static unsigned long usb_stor_write(struct blk_desc *block_dev, lbaint_t blknr, 1106 lbaint_t blkcnt, const void *buffer) 1107 { 1108 lbaint_t start, blks; 1109 uintptr_t buf_addr; 1110 unsigned short smallblks; 1111 struct usb_device *udev; 1112 struct us_data *ss; 1113 int retry; 1114 ccb *srb = &usb_ccb; 1115 1116 if (blkcnt == 0) 1117 return 0; 1118 1119 /* Setup device */ 1120 debug("\nusb_read: udev %d\n", block_dev->devnum); 1121 udev = usb_dev_desc[block_dev->devnum].priv; 1122 if (!udev) { 1123 debug("%s: No device\n", __func__); 1124 return 0; 1125 } 1126 ss = (struct us_data *)udev->privptr; 1127 1128 usb_disable_asynch(1); /* asynch transfer not allowed */ 1129 1130 srb->lun = block_dev->lun; 1131 buf_addr = (uintptr_t)buffer; 1132 start = blknr; 1133 blks = blkcnt; 1134 1135 debug("\nusb_write: dev %d startblk " LBAF ", blccnt " LBAF " buffer %" 1136 PRIxPTR "\n", block_dev->devnum, start, blks, buf_addr); 1137 1138 do { 1139 /* If write fails retry for max retry count else 1140 * return with number of blocks written successfully. 1141 */ 1142 retry = 2; 1143 srb->pdata = (unsigned char *)buf_addr; 1144 if (blks > USB_MAX_XFER_BLK) 1145 smallblks = USB_MAX_XFER_BLK; 1146 else 1147 smallblks = (unsigned short) blks; 1148 retry_it: 1149 if (smallblks == USB_MAX_XFER_BLK) 1150 usb_show_progress(); 1151 srb->datalen = block_dev->blksz * smallblks; 1152 srb->pdata = (unsigned char *)buf_addr; 1153 if (usb_write_10(srb, ss, start, smallblks)) { 1154 debug("Write ERROR\n"); 1155 usb_request_sense(srb, ss); 1156 if (retry--) 1157 goto retry_it; 1158 blkcnt -= blks; 1159 break; 1160 } 1161 start += smallblks; 1162 blks -= smallblks; 1163 buf_addr += srb->datalen; 1164 } while (blks != 0); 1165 ss->flags &= ~USB_READY; 1166 1167 debug("usb_write: end startblk " LBAF ", blccnt %x buffer %" 1168 PRIxPTR "\n", start, smallblks, buf_addr); 1169 1170 usb_disable_asynch(0); /* asynch transfer allowed */ 1171 if (blkcnt >= USB_MAX_XFER_BLK) 1172 debug("\n"); 1173 return blkcnt; 1174 1175 } 1176 1177 /* Probe to see if a new device is actually a Storage device */ 1178 int usb_storage_probe(struct usb_device *dev, unsigned int ifnum, 1179 struct us_data *ss) 1180 { 1181 struct usb_interface *iface; 1182 int i; 1183 struct usb_endpoint_descriptor *ep_desc; 1184 unsigned int flags = 0; 1185 1186 /* let's examine the device now */ 1187 iface = &dev->config.if_desc[ifnum]; 1188 1189 if (dev->descriptor.bDeviceClass != 0 || 1190 iface->desc.bInterfaceClass != USB_CLASS_MASS_STORAGE || 1191 iface->desc.bInterfaceSubClass < US_SC_MIN || 1192 iface->desc.bInterfaceSubClass > US_SC_MAX) { 1193 debug("Not mass storage\n"); 1194 /* if it's not a mass storage, we go no further */ 1195 return 0; 1196 } 1197 1198 memset(ss, 0, sizeof(struct us_data)); 1199 1200 /* At this point, we know we've got a live one */ 1201 debug("\n\nUSB Mass Storage device detected\n"); 1202 1203 /* Initialize the us_data structure with some useful info */ 1204 ss->flags = flags; 1205 ss->ifnum = ifnum; 1206 ss->pusb_dev = dev; 1207 ss->attention_done = 0; 1208 ss->subclass = iface->desc.bInterfaceSubClass; 1209 ss->protocol = iface->desc.bInterfaceProtocol; 1210 1211 /* set the handler pointers based on the protocol */ 1212 debug("Transport: "); 1213 switch (ss->protocol) { 1214 case US_PR_CB: 1215 debug("Control/Bulk\n"); 1216 ss->transport = usb_stor_CB_transport; 1217 ss->transport_reset = usb_stor_CB_reset; 1218 break; 1219 1220 case US_PR_CBI: 1221 debug("Control/Bulk/Interrupt\n"); 1222 ss->transport = usb_stor_CB_transport; 1223 ss->transport_reset = usb_stor_CB_reset; 1224 break; 1225 case US_PR_BULK: 1226 debug("Bulk/Bulk/Bulk\n"); 1227 ss->transport = usb_stor_BBB_transport; 1228 ss->transport_reset = usb_stor_BBB_reset; 1229 break; 1230 default: 1231 printf("USB Storage Transport unknown / not yet implemented\n"); 1232 return 0; 1233 break; 1234 } 1235 1236 /* 1237 * We are expecting a minimum of 2 endpoints - in and out (bulk). 1238 * An optional interrupt is OK (necessary for CBI protocol). 1239 * We will ignore any others. 1240 */ 1241 for (i = 0; i < iface->desc.bNumEndpoints; i++) { 1242 ep_desc = &iface->ep_desc[i]; 1243 /* is it an BULK endpoint? */ 1244 if ((ep_desc->bmAttributes & 1245 USB_ENDPOINT_XFERTYPE_MASK) == USB_ENDPOINT_XFER_BULK) { 1246 if (ep_desc->bEndpointAddress & USB_DIR_IN) 1247 ss->ep_in = ep_desc->bEndpointAddress & 1248 USB_ENDPOINT_NUMBER_MASK; 1249 else 1250 ss->ep_out = 1251 ep_desc->bEndpointAddress & 1252 USB_ENDPOINT_NUMBER_MASK; 1253 } 1254 1255 /* is it an interrupt endpoint? */ 1256 if ((ep_desc->bmAttributes & 1257 USB_ENDPOINT_XFERTYPE_MASK) == USB_ENDPOINT_XFER_INT) { 1258 ss->ep_int = ep_desc->bEndpointAddress & 1259 USB_ENDPOINT_NUMBER_MASK; 1260 ss->irqinterval = ep_desc->bInterval; 1261 } 1262 } 1263 debug("Endpoints In %d Out %d Int %d\n", 1264 ss->ep_in, ss->ep_out, ss->ep_int); 1265 1266 /* Do some basic sanity checks, and bail if we find a problem */ 1267 if (usb_set_interface(dev, iface->desc.bInterfaceNumber, 0) || 1268 !ss->ep_in || !ss->ep_out || 1269 (ss->protocol == US_PR_CBI && ss->ep_int == 0)) { 1270 debug("Problems with device\n"); 1271 return 0; 1272 } 1273 /* set class specific stuff */ 1274 /* We only handle certain protocols. Currently, these are 1275 * the only ones. 1276 * The SFF8070 accepts the requests used in u-boot 1277 */ 1278 if (ss->subclass != US_SC_UFI && ss->subclass != US_SC_SCSI && 1279 ss->subclass != US_SC_8070) { 1280 printf("Sorry, protocol %d not yet supported.\n", ss->subclass); 1281 return 0; 1282 } 1283 if (ss->ep_int) { 1284 /* we had found an interrupt endpoint, prepare irq pipe 1285 * set up the IRQ pipe and handler 1286 */ 1287 ss->irqinterval = (ss->irqinterval > 0) ? ss->irqinterval : 255; 1288 ss->irqpipe = usb_rcvintpipe(ss->pusb_dev, ss->ep_int); 1289 ss->irqmaxp = usb_maxpacket(dev, ss->irqpipe); 1290 dev->irq_handle = usb_stor_irq; 1291 } 1292 dev->privptr = (void *)ss; 1293 return 1; 1294 } 1295 1296 int usb_stor_get_info(struct usb_device *dev, struct us_data *ss, 1297 struct blk_desc *dev_desc) 1298 { 1299 unsigned char perq, modi; 1300 ALLOC_CACHE_ALIGN_BUFFER(u32, cap, 2); 1301 ALLOC_CACHE_ALIGN_BUFFER(u8, usb_stor_buf, 36); 1302 u32 capacity, blksz; 1303 ccb *pccb = &usb_ccb; 1304 1305 pccb->pdata = usb_stor_buf; 1306 1307 dev_desc->target = dev->devnum; 1308 pccb->lun = dev_desc->lun; 1309 debug(" address %d\n", dev_desc->target); 1310 1311 if (usb_inquiry(pccb, ss)) { 1312 debug("%s: usb_inquiry() failed\n", __func__); 1313 return -1; 1314 } 1315 1316 perq = usb_stor_buf[0]; 1317 modi = usb_stor_buf[1]; 1318 1319 /* 1320 * Skip unknown devices (0x1f) and enclosure service devices (0x0d), 1321 * they would not respond to test_unit_ready . 1322 */ 1323 if (((perq & 0x1f) == 0x1f) || ((perq & 0x1f) == 0x0d)) { 1324 debug("%s: unknown/unsupported device\n", __func__); 1325 return 0; 1326 } 1327 if ((modi&0x80) == 0x80) { 1328 /* drive is removable */ 1329 dev_desc->removable = 1; 1330 } 1331 memcpy(dev_desc->vendor, (const void *)&usb_stor_buf[8], 8); 1332 memcpy(dev_desc->product, (const void *)&usb_stor_buf[16], 16); 1333 memcpy(dev_desc->revision, (const void *)&usb_stor_buf[32], 4); 1334 dev_desc->vendor[8] = 0; 1335 dev_desc->product[16] = 0; 1336 dev_desc->revision[4] = 0; 1337 #ifdef CONFIG_USB_BIN_FIXUP 1338 usb_bin_fixup(dev->descriptor, (uchar *)dev_desc->vendor, 1339 (uchar *)dev_desc->product); 1340 #endif /* CONFIG_USB_BIN_FIXUP */ 1341 debug("ISO Vers %X, Response Data %X\n", usb_stor_buf[2], 1342 usb_stor_buf[3]); 1343 if (usb_test_unit_ready(pccb, ss)) { 1344 printf("Device NOT ready\n" 1345 " Request Sense returned %02X %02X %02X\n", 1346 pccb->sense_buf[2], pccb->sense_buf[12], 1347 pccb->sense_buf[13]); 1348 if (dev_desc->removable == 1) { 1349 dev_desc->type = perq; 1350 return 1; 1351 } 1352 return 0; 1353 } 1354 pccb->pdata = (unsigned char *)cap; 1355 memset(pccb->pdata, 0, 8); 1356 if (usb_read_capacity(pccb, ss) != 0) { 1357 printf("READ_CAP ERROR\n"); 1358 cap[0] = 2880; 1359 cap[1] = 0x200; 1360 } 1361 ss->flags &= ~USB_READY; 1362 debug("Read Capacity returns: 0x%08x, 0x%08x\n", cap[0], cap[1]); 1363 #if 0 1364 if (cap[0] > (0x200000 * 10)) /* greater than 10 GByte */ 1365 cap[0] >>= 16; 1366 1367 cap[0] = cpu_to_be32(cap[0]); 1368 cap[1] = cpu_to_be32(cap[1]); 1369 #endif 1370 1371 capacity = be32_to_cpu(cap[0]) + 1; 1372 blksz = be32_to_cpu(cap[1]); 1373 1374 debug("Capacity = 0x%08x, blocksz = 0x%08x\n", capacity, blksz); 1375 dev_desc->lba = capacity; 1376 dev_desc->blksz = blksz; 1377 dev_desc->log2blksz = LOG2(dev_desc->blksz); 1378 dev_desc->type = perq; 1379 debug(" address %d\n", dev_desc->target); 1380 debug("partype: %d\n", dev_desc->part_type); 1381 1382 part_init(dev_desc); 1383 1384 debug("partype: %d\n", dev_desc->part_type); 1385 return 1; 1386 } 1387 1388 #ifdef CONFIG_DM_USB 1389 1390 static int usb_mass_storage_probe(struct udevice *dev) 1391 { 1392 struct usb_device *udev = dev_get_parent_priv(dev); 1393 int ret; 1394 1395 usb_disable_asynch(1); /* asynch transfer not allowed */ 1396 ret = usb_stor_probe_device(udev); 1397 usb_disable_asynch(0); /* asynch transfer allowed */ 1398 1399 return ret; 1400 } 1401 1402 static const struct udevice_id usb_mass_storage_ids[] = { 1403 { .compatible = "usb-mass-storage" }, 1404 { } 1405 }; 1406 1407 U_BOOT_DRIVER(usb_mass_storage) = { 1408 .name = "usb_mass_storage", 1409 .id = UCLASS_MASS_STORAGE, 1410 .of_match = usb_mass_storage_ids, 1411 .probe = usb_mass_storage_probe, 1412 }; 1413 1414 UCLASS_DRIVER(usb_mass_storage) = { 1415 .id = UCLASS_MASS_STORAGE, 1416 .name = "usb_mass_storage", 1417 }; 1418 1419 static const struct usb_device_id mass_storage_id_table[] = { 1420 { 1421 .match_flags = USB_DEVICE_ID_MATCH_INT_CLASS, 1422 .bInterfaceClass = USB_CLASS_MASS_STORAGE 1423 }, 1424 { } /* Terminating entry */ 1425 }; 1426 1427 U_BOOT_USB_DEVICE(usb_mass_storage, mass_storage_id_table); 1428 1429 #endif 1430