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