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