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