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