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