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