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