common/usb_storage.c

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