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