2 * Most of this source has been derived from the Linux USB
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.
11 * (C) Copyright 2001 Denis Peter, MPL AG Switzerland
13 * For BBB support (C) Copyright 2003
14 * Gary Jennejohn, DENX Software Engineering <garyj@denx.de>
16 * BBB support based on /sys/dev/usb/umass.c from
19 * SPDX-License-Identifier: GPL-2.0+
23 * Currently only the CBI transport protocoll has been implemented, and it
24 * is only tested with a TEAC USB Floppy. Other Massstorages with CBI or CB
25 * transport protocoll may work as well.
29 * Support for USB Mass Storage Devices (BBB) has been added. It has
30 * only been tested with USB memory sticks.
37 #include <asm/byteorder.h>
38 #include <asm/processor.h>
43 #undef BBB_COMDAT_TRACE
44 #undef BBB_XPORT_TRACE
47 /* direction table -- this indicates the direction of the data
48 * transfer for each command code -- a 1 indicates input
50 static const unsigned char us_direction
[256/8] = {
51 0x28, 0x81, 0x14, 0x14, 0x20, 0x01, 0x90, 0x77,
52 0x0C, 0x20, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00,
53 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01,
54 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
56 #define US_DIRECTION(x) ((us_direction[x>>3] >> (x & 7)) & 1)
58 static ccb usb_ccb
__attribute__((aligned(ARCH_DMA_MINALIGN
)));
69 #define US_BBB_RESET 0xff
70 #define US_BBB_GET_MAX_LUN 0xfe
72 /* Command Block Wrapper */
75 # define CBWSIGNATURE 0x43425355
77 __u32 dCBWDataTransferLength
;
79 # define CBWFLAGS_OUT 0x00
80 # define CBWFLAGS_IN 0x80
83 # define CBWCDBLENGTH 16
84 __u8 CBWCDB
[CBWCDBLENGTH
];
86 #define UMASS_BBB_CBW_SIZE 31
89 /* Command Status Wrapper */
92 # define CSWSIGNATURE 0x53425355
94 __u32 dCSWDataResidue
;
96 # define CSWSTATUS_GOOD 0x0
97 # define CSWSTATUS_FAILED 0x1
98 # define CSWSTATUS_PHASE 0x2
100 #define UMASS_BBB_CSW_SIZE 13
102 #define USB_MAX_STOR_DEV 5
103 static int usb_max_devs
; /* number of highest available usb device */
105 static block_dev_desc_t usb_dev_desc
[USB_MAX_STOR_DEV
];
108 typedef int (*trans_cmnd
)(ccb
*cb
, struct us_data
*data
);
109 typedef int (*trans_reset
)(struct us_data
*data
);
112 struct usb_device
*pusb_dev
; /* this usb_device */
114 unsigned int flags
; /* from filter initially */
115 # define USB_READY (1 << 0)
116 unsigned char ifnum
; /* interface number */
117 unsigned char ep_in
; /* in endpoint */
118 unsigned char ep_out
; /* out ....... */
119 unsigned char ep_int
; /* interrupt . */
120 unsigned char subclass
; /* as in overview */
121 unsigned char protocol
; /* .............. */
122 unsigned char attention_done
; /* force attn on first cmd */
123 unsigned short ip_data
; /* interrupt data */
124 int action
; /* what to do */
125 int ip_wanted
; /* needed */
126 int *irq_handle
; /* for USB int requests */
127 unsigned int irqpipe
; /* pipe for release_irq */
128 unsigned char irqmaxp
; /* max packed for irq Pipe */
129 unsigned char irqinterval
; /* Intervall for IRQ Pipe */
130 ccb
*srb
; /* current srb */
131 trans_reset transport_reset
; /* reset routine */
132 trans_cmnd transport
; /* transport routine */
135 #ifdef CONFIG_USB_EHCI
137 * The U-Boot EHCI driver can handle any transfer length as long as there is
138 * enough free heap space left, but the SCSI READ(10) and WRITE(10) commands are
139 * limited to 65535 blocks.
141 #define USB_MAX_XFER_BLK 65535
143 #define USB_MAX_XFER_BLK 20
146 static struct us_data usb_stor
[USB_MAX_STOR_DEV
];
149 #define USB_STOR_TRANSPORT_GOOD 0
150 #define USB_STOR_TRANSPORT_FAILED -1
151 #define USB_STOR_TRANSPORT_ERROR -2
153 int usb_stor_get_info(struct usb_device
*dev
, struct us_data
*us
,
154 block_dev_desc_t
*dev_desc
);
155 int usb_storage_probe(struct usb_device
*dev
, unsigned int ifnum
,
157 unsigned long usb_stor_read(int device
, lbaint_t blknr
,
158 lbaint_t blkcnt
, void *buffer
);
159 unsigned long usb_stor_write(int device
, lbaint_t blknr
,
160 lbaint_t blkcnt
, const void *buffer
);
161 struct usb_device
* usb_get_dev_index(int index
);
162 void uhci_show_temp_int_td(void);
164 #ifdef CONFIG_PARTITIONS
165 block_dev_desc_t
*usb_stor_get_dev(int index
)
167 return (index
< usb_max_devs
) ? &usb_dev_desc
[index
] : NULL
;
171 static void usb_show_progress(void)
176 /*******************************************************************************
177 * show info on storage devices; 'usb start/init' must be invoked earlier
178 * as we only retrieve structures populated during devices initialization
180 int usb_stor_info(void)
184 if (usb_max_devs
> 0) {
185 for (i
= 0; i
< usb_max_devs
; i
++) {
186 printf(" Device %d: ", i
);
187 dev_print(&usb_dev_desc
[i
]);
192 printf("No storage devices, perhaps not 'usb start'ed..?\n");
196 static unsigned int usb_get_max_lun(struct us_data
*us
)
199 ALLOC_CACHE_ALIGN_BUFFER(unsigned char, result
, 1);
200 len
= usb_control_msg(us
->pusb_dev
,
201 usb_rcvctrlpipe(us
->pusb_dev
, 0),
203 USB_TYPE_CLASS
| USB_RECIP_INTERFACE
| USB_DIR_IN
,
205 result
, sizeof(char),
206 USB_CNTL_TIMEOUT
* 5);
207 debug("Get Max LUN -> len = %i, result = %i\n", len
, (int) *result
);
208 return (len
> 0) ? *result
: 0;
211 /*******************************************************************************
212 * scan the usb and reports device info
213 * to the user if mode = 1
214 * returns current device or -1 if no
216 int usb_stor_scan(int mode
)
219 struct usb_device
*dev
;
222 printf(" scanning usb for storage devices... ");
224 usb_disable_asynch(1); /* asynch transfer not allowed */
226 for (i
= 0; i
< USB_MAX_STOR_DEV
; i
++) {
227 memset(&usb_dev_desc
[i
], 0, sizeof(block_dev_desc_t
));
228 usb_dev_desc
[i
].if_type
= IF_TYPE_USB
;
229 usb_dev_desc
[i
].dev
= i
;
230 usb_dev_desc
[i
].part_type
= PART_TYPE_UNKNOWN
;
231 usb_dev_desc
[i
].target
= 0xff;
232 usb_dev_desc
[i
].type
= DEV_TYPE_UNKNOWN
;
233 usb_dev_desc
[i
].block_read
= usb_stor_read
;
234 usb_dev_desc
[i
].block_write
= usb_stor_write
;
238 for (i
= 0; i
< USB_MAX_DEVICE
; i
++) {
239 dev
= usb_get_dev_index(i
); /* get device */
242 break; /* no more devices available */
244 if (usb_storage_probe(dev
, 0, &usb_stor
[usb_max_devs
])) {
245 /* OK, it's a storage device. Iterate over its LUNs
246 * and populate `usb_dev_desc'.
248 int lun
, max_lun
, start
= usb_max_devs
;
250 max_lun
= usb_get_max_lun(&usb_stor
[usb_max_devs
]);
252 lun
<= max_lun
&& usb_max_devs
< USB_MAX_STOR_DEV
;
254 usb_dev_desc
[usb_max_devs
].lun
= lun
;
255 if (usb_stor_get_info(dev
, &usb_stor
[start
],
256 &usb_dev_desc
[usb_max_devs
]) == 1) {
261 /* if storage device */
262 if (usb_max_devs
== USB_MAX_STOR_DEV
) {
263 printf("max USB Storage Device reached: %d stopping\n",
269 usb_disable_asynch(0); /* asynch transfer allowed */
270 printf("%d Storage Device(s) found\n", usb_max_devs
);
271 if (usb_max_devs
> 0)
276 static int usb_stor_irq(struct usb_device
*dev
)
279 us
= (struct us_data
*)dev
->privptr
;
289 static void usb_show_srb(ccb
*pccb
)
292 printf("SRB: len %d datalen 0x%lX\n ", pccb
->cmdlen
, pccb
->datalen
);
293 for (i
= 0; i
< 12; i
++)
294 printf("%02X ", pccb
->cmd
[i
]);
298 static void display_int_status(unsigned long tmp
)
300 printf("Status: %s %s %s %s %s %s %s\n",
301 (tmp
& USB_ST_ACTIVE
) ? "Active" : "",
302 (tmp
& USB_ST_STALLED
) ? "Stalled" : "",
303 (tmp
& USB_ST_BUF_ERR
) ? "Buffer Error" : "",
304 (tmp
& USB_ST_BABBLE_DET
) ? "Babble Det" : "",
305 (tmp
& USB_ST_NAK_REC
) ? "NAKed" : "",
306 (tmp
& USB_ST_CRC_ERR
) ? "CRC Error" : "",
307 (tmp
& USB_ST_BIT_ERR
) ? "Bitstuff Error" : "");
310 /***********************************************************************
311 * Data transfer routines
312 ***********************************************************************/
314 static int us_one_transfer(struct us_data
*us
, int pipe
, char *buf
, int length
)
323 /* determine the maximum packet size for these transfers */
324 max_size
= usb_maxpacket(us
->pusb_dev
, pipe
) * 16;
326 /* while we have data left to transfer */
329 /* calculate how long this will be -- maximum or a remainder */
330 this_xfer
= length
> max_size
? max_size
: length
;
333 /* setup the retry counter */
336 /* set up the transfer loop */
338 /* transfer the data */
339 debug("Bulk xfer 0x%x(%d) try #%d\n",
340 (unsigned int)buf
, this_xfer
, 11 - maxtry
);
341 result
= usb_bulk_msg(us
->pusb_dev
, pipe
, buf
,
343 USB_CNTL_TIMEOUT
* 5);
344 debug("bulk_msg returned %d xferred %d/%d\n",
345 result
, partial
, this_xfer
);
346 if (us
->pusb_dev
->status
!= 0) {
347 /* if we stall, we need to clear it before
351 display_int_status(us
->pusb_dev
->status
);
353 if (us
->pusb_dev
->status
& USB_ST_STALLED
) {
354 debug("stalled ->clearing endpoint" \
355 "halt for pipe 0x%x\n", pipe
);
356 stat
= us
->pusb_dev
->status
;
357 usb_clear_halt(us
->pusb_dev
, pipe
);
358 us
->pusb_dev
->status
= stat
;
359 if (this_xfer
== partial
) {
360 debug("bulk transferred" \
363 us
->pusb_dev
->status
);
369 if (us
->pusb_dev
->status
& USB_ST_NAK_REC
) {
370 debug("Device NAKed bulk_msg\n");
373 debug("bulk transferred with error");
374 if (this_xfer
== partial
) {
375 debug(" %ld, but data ok\n",
376 us
->pusb_dev
->status
);
379 /* if our try counter reaches 0, bail out */
380 debug(" %ld, data %d\n",
381 us
->pusb_dev
->status
, partial
);
385 /* update to show what data was transferred */
386 this_xfer
-= partial
;
388 /* continue until this transfer is done */
392 /* if we get here, we're done and successful */
396 static int usb_stor_BBB_reset(struct us_data
*us
)
402 * Reset recovery (5.3.4 in Universal Serial Bus Mass Storage Class)
404 * For Reset Recovery the host shall issue in the following order:
405 * a) a Bulk-Only Mass Storage Reset
406 * b) a Clear Feature HALT to the Bulk-In endpoint
407 * c) a Clear Feature HALT to the Bulk-Out endpoint
409 * This is done in 3 steps.
411 * If the reset doesn't succeed, the device should be port reset.
413 * This comment stolen from FreeBSD's /sys/dev/usb/umass.c.
415 debug("BBB_reset\n");
416 result
= usb_control_msg(us
->pusb_dev
, usb_sndctrlpipe(us
->pusb_dev
, 0),
418 USB_TYPE_CLASS
| USB_RECIP_INTERFACE
,
419 0, us
->ifnum
, NULL
, 0, USB_CNTL_TIMEOUT
* 5);
421 if ((result
< 0) && (us
->pusb_dev
->status
& USB_ST_STALLED
)) {
422 debug("RESET:stall\n");
426 /* long wait for reset */
428 debug("BBB_reset result %d: status %lX reset\n",
429 result
, us
->pusb_dev
->status
);
430 pipe
= usb_rcvbulkpipe(us
->pusb_dev
, us
->ep_in
);
431 result
= usb_clear_halt(us
->pusb_dev
, pipe
);
432 /* long wait for reset */
434 debug("BBB_reset result %d: status %lX clearing IN endpoint\n",
435 result
, us
->pusb_dev
->status
);
436 /* long wait for reset */
437 pipe
= usb_sndbulkpipe(us
->pusb_dev
, us
->ep_out
);
438 result
= usb_clear_halt(us
->pusb_dev
, pipe
);
440 debug("BBB_reset result %d: status %lX clearing OUT endpoint\n",
441 result
, us
->pusb_dev
->status
);
442 debug("BBB_reset done\n");
446 /* FIXME: this reset function doesn't really reset the port, and it
447 * should. Actually it should probably do what it's doing here, and
448 * reset the port physically
450 static int usb_stor_CB_reset(struct us_data
*us
)
452 unsigned char cmd
[12];
456 memset(cmd
, 0xff, sizeof(cmd
));
457 cmd
[0] = SCSI_SEND_DIAG
;
459 result
= usb_control_msg(us
->pusb_dev
, usb_sndctrlpipe(us
->pusb_dev
, 0),
461 USB_TYPE_CLASS
| USB_RECIP_INTERFACE
,
462 0, us
->ifnum
, cmd
, sizeof(cmd
),
463 USB_CNTL_TIMEOUT
* 5);
465 /* long wait for reset */
467 debug("CB_reset result %d: status %lX clearing endpoint halt\n",
468 result
, us
->pusb_dev
->status
);
469 usb_clear_halt(us
->pusb_dev
, usb_rcvbulkpipe(us
->pusb_dev
, us
->ep_in
));
470 usb_clear_halt(us
->pusb_dev
, usb_rcvbulkpipe(us
->pusb_dev
, us
->ep_out
));
472 debug("CB_reset done\n");
477 * Set up the command for a BBB device. Note that the actual SCSI
478 * command is copied into cbw.CBWCDB.
480 static int usb_stor_BBB_comdat(ccb
*srb
, struct us_data
*us
)
486 ALLOC_CACHE_ALIGN_BUFFER(umass_bbb_cbw_t
, cbw
, 1);
488 dir_in
= US_DIRECTION(srb
->cmd
[0]);
490 #ifdef BBB_COMDAT_TRACE
491 printf("dir %d lun %d cmdlen %d cmd %p datalen %lu pdata %p\n",
492 dir_in
, srb
->lun
, srb
->cmdlen
, srb
->cmd
, srb
->datalen
,
495 for (result
= 0; result
< srb
->cmdlen
; result
++)
496 printf("cmd[%d] %#x ", result
, srb
->cmd
[result
]);
501 if (!(srb
->cmdlen
<= CBWCDBLENGTH
)) {
502 debug("usb_stor_BBB_comdat:cmdlen too large\n");
506 /* always OUT to the ep */
507 pipe
= usb_sndbulkpipe(us
->pusb_dev
, us
->ep_out
);
509 cbw
->dCBWSignature
= cpu_to_le32(CBWSIGNATURE
);
510 cbw
->dCBWTag
= cpu_to_le32(CBWTag
++);
511 cbw
->dCBWDataTransferLength
= cpu_to_le32(srb
->datalen
);
512 cbw
->bCBWFlags
= (dir_in
? CBWFLAGS_IN
: CBWFLAGS_OUT
);
513 cbw
->bCBWLUN
= srb
->lun
;
514 cbw
->bCDBLength
= srb
->cmdlen
;
515 /* copy the command data into the CBW command data buffer */
517 memcpy(cbw
->CBWCDB
, srb
->cmd
, srb
->cmdlen
);
518 result
= usb_bulk_msg(us
->pusb_dev
, pipe
, cbw
, UMASS_BBB_CBW_SIZE
,
519 &actlen
, USB_CNTL_TIMEOUT
* 5);
521 debug("usb_stor_BBB_comdat:usb_bulk_msg error\n");
525 /* FIXME: we also need a CBI_command which sets up the completion
526 * interrupt, and waits for it
528 static int usb_stor_CB_comdat(ccb
*srb
, struct us_data
*us
)
533 unsigned long status
;
536 dir_in
= US_DIRECTION(srb
->cmd
[0]);
539 pipe
= usb_rcvbulkpipe(us
->pusb_dev
, us
->ep_in
);
541 pipe
= usb_sndbulkpipe(us
->pusb_dev
, us
->ep_out
);
544 debug("CBI gets a command: Try %d\n", 5 - retry
);
548 /* let's send the command via the control pipe */
549 result
= usb_control_msg(us
->pusb_dev
,
550 usb_sndctrlpipe(us
->pusb_dev
, 0),
552 USB_TYPE_CLASS
| USB_RECIP_INTERFACE
,
554 srb
->cmd
, srb
->cmdlen
,
555 USB_CNTL_TIMEOUT
* 5);
556 debug("CB_transport: control msg returned %d, status %lX\n",
557 result
, us
->pusb_dev
->status
);
558 /* check the return code for the command */
560 if (us
->pusb_dev
->status
& USB_ST_STALLED
) {
561 status
= us
->pusb_dev
->status
;
562 debug(" stall during command found," \
564 usb_clear_halt(us
->pusb_dev
,
565 usb_sndctrlpipe(us
->pusb_dev
, 0));
566 us
->pusb_dev
->status
= status
;
568 debug(" error during command %02X" \
569 " Stat = %lX\n", srb
->cmd
[0],
570 us
->pusb_dev
->status
);
573 /* transfer the data payload for this command, if one exists*/
575 debug("CB_transport: control msg returned %d," \
576 " direction is %s to go 0x%lx\n", result
,
577 dir_in
? "IN" : "OUT", srb
->datalen
);
579 result
= us_one_transfer(us
, pipe
, (char *)srb
->pdata
,
581 debug("CBI attempted to transfer data," \
582 " result is %d status %lX, len %d\n",
583 result
, us
->pusb_dev
->status
,
584 us
->pusb_dev
->act_len
);
585 if (!(us
->pusb_dev
->status
& USB_ST_NAK_REC
))
587 } /* if (srb->datalen) */
597 static int usb_stor_CBI_get_status(ccb
*srb
, struct us_data
*us
)
602 submit_int_msg(us
->pusb_dev
, us
->irqpipe
,
603 (void *) &us
->ip_data
, us
->irqmaxp
, us
->irqinterval
);
606 if ((volatile int *) us
->ip_wanted
== NULL
)
611 printf(" Did not get interrupt on CBI\n");
613 return USB_STOR_TRANSPORT_ERROR
;
615 debug("Got interrupt data 0x%x, transfered %d status 0x%lX\n",
616 us
->ip_data
, us
->pusb_dev
->irq_act_len
,
617 us
->pusb_dev
->irq_status
);
618 /* UFI gives us ASC and ASCQ, like a request sense */
619 if (us
->subclass
== US_SC_UFI
) {
620 if (srb
->cmd
[0] == SCSI_REQ_SENSE
||
621 srb
->cmd
[0] == SCSI_INQUIRY
)
622 return USB_STOR_TRANSPORT_GOOD
; /* Good */
623 else if (us
->ip_data
)
624 return USB_STOR_TRANSPORT_FAILED
;
626 return USB_STOR_TRANSPORT_GOOD
;
628 /* otherwise, we interpret the data normally */
629 switch (us
->ip_data
) {
631 return USB_STOR_TRANSPORT_GOOD
;
633 return USB_STOR_TRANSPORT_FAILED
;
635 return USB_STOR_TRANSPORT_ERROR
;
637 return USB_STOR_TRANSPORT_ERROR
;
640 #define USB_TRANSPORT_UNKNOWN_RETRY 5
641 #define USB_TRANSPORT_NOT_READY_RETRY 10
643 /* clear a stall on an endpoint - special for BBB devices */
644 static int usb_stor_BBB_clear_endpt_stall(struct us_data
*us
, __u8 endpt
)
648 /* ENDPOINT_HALT = 0, so set value to 0 */
649 result
= usb_control_msg(us
->pusb_dev
, usb_sndctrlpipe(us
->pusb_dev
, 0),
650 USB_REQ_CLEAR_FEATURE
, USB_RECIP_ENDPOINT
,
651 0, endpt
, NULL
, 0, USB_CNTL_TIMEOUT
* 5);
655 static int usb_stor_BBB_transport(ccb
*srb
, struct us_data
*us
)
659 int actlen
, data_actlen
;
660 unsigned int pipe
, pipein
, pipeout
;
661 ALLOC_CACHE_ALIGN_BUFFER(umass_bbb_csw_t
, csw
, 1);
662 #ifdef BBB_XPORT_TRACE
667 dir_in
= US_DIRECTION(srb
->cmd
[0]);
670 debug("COMMAND phase\n");
671 result
= usb_stor_BBB_comdat(srb
, us
);
673 debug("failed to send CBW status %ld\n",
674 us
->pusb_dev
->status
);
675 usb_stor_BBB_reset(us
);
676 return USB_STOR_TRANSPORT_FAILED
;
678 if (!(us
->flags
& USB_READY
))
680 pipein
= usb_rcvbulkpipe(us
->pusb_dev
, us
->ep_in
);
681 pipeout
= usb_sndbulkpipe(us
->pusb_dev
, us
->ep_out
);
682 /* DATA phase + error handling */
684 /* no data, go immediately to the STATUS phase */
685 if (srb
->datalen
== 0)
687 debug("DATA phase\n");
692 result
= usb_bulk_msg(us
->pusb_dev
, pipe
, srb
->pdata
, srb
->datalen
,
693 &data_actlen
, USB_CNTL_TIMEOUT
* 5);
694 /* special handling of STALL in DATA phase */
695 if ((result
< 0) && (us
->pusb_dev
->status
& USB_ST_STALLED
)) {
696 debug("DATA:stall\n");
697 /* clear the STALL on the endpoint */
698 result
= usb_stor_BBB_clear_endpt_stall(us
,
699 dir_in
? us
->ep_in
: us
->ep_out
);
701 /* continue on to STATUS phase */
705 debug("usb_bulk_msg error status %ld\n",
706 us
->pusb_dev
->status
);
707 usb_stor_BBB_reset(us
);
708 return USB_STOR_TRANSPORT_FAILED
;
710 #ifdef BBB_XPORT_TRACE
711 for (index
= 0; index
< data_actlen
; index
++)
712 printf("pdata[%d] %#x ", index
, srb
->pdata
[index
]);
715 /* STATUS phase + error handling */
719 debug("STATUS phase\n");
720 result
= usb_bulk_msg(us
->pusb_dev
, pipein
, csw
, UMASS_BBB_CSW_SIZE
,
721 &actlen
, USB_CNTL_TIMEOUT
*5);
723 /* special handling of STALL in STATUS phase */
724 if ((result
< 0) && (retry
< 1) &&
725 (us
->pusb_dev
->status
& USB_ST_STALLED
)) {
726 debug("STATUS:stall\n");
727 /* clear the STALL on the endpoint */
728 result
= usb_stor_BBB_clear_endpt_stall(us
, us
->ep_in
);
729 if (result
>= 0 && (retry
++ < 1))
734 debug("usb_bulk_msg error status %ld\n",
735 us
->pusb_dev
->status
);
736 usb_stor_BBB_reset(us
);
737 return USB_STOR_TRANSPORT_FAILED
;
739 #ifdef BBB_XPORT_TRACE
740 ptr
= (unsigned char *)csw
;
741 for (index
= 0; index
< UMASS_BBB_CSW_SIZE
; index
++)
742 printf("ptr[%d] %#x ", index
, ptr
[index
]);
745 /* misuse pipe to get the residue */
746 pipe
= le32_to_cpu(csw
->dCSWDataResidue
);
747 if (pipe
== 0 && srb
->datalen
!= 0 && srb
->datalen
- data_actlen
!= 0)
748 pipe
= srb
->datalen
- data_actlen
;
749 if (CSWSIGNATURE
!= le32_to_cpu(csw
->dCSWSignature
)) {
750 debug("!CSWSIGNATURE\n");
751 usb_stor_BBB_reset(us
);
752 return USB_STOR_TRANSPORT_FAILED
;
753 } else if ((CBWTag
- 1) != le32_to_cpu(csw
->dCSWTag
)) {
755 usb_stor_BBB_reset(us
);
756 return USB_STOR_TRANSPORT_FAILED
;
757 } else if (csw
->bCSWStatus
> CSWSTATUS_PHASE
) {
759 usb_stor_BBB_reset(us
);
760 return USB_STOR_TRANSPORT_FAILED
;
761 } else if (csw
->bCSWStatus
== CSWSTATUS_PHASE
) {
763 usb_stor_BBB_reset(us
);
764 return USB_STOR_TRANSPORT_FAILED
;
765 } else if (data_actlen
> srb
->datalen
) {
766 debug("transferred %dB instead of %ldB\n",
767 data_actlen
, srb
->datalen
);
768 return USB_STOR_TRANSPORT_FAILED
;
769 } else if (csw
->bCSWStatus
== CSWSTATUS_FAILED
) {
771 return USB_STOR_TRANSPORT_FAILED
;
777 static int usb_stor_CB_transport(ccb
*srb
, struct us_data
*us
)
785 status
= USB_STOR_TRANSPORT_GOOD
;
788 /* issue the command */
790 result
= usb_stor_CB_comdat(srb
, us
);
791 debug("command / Data returned %d, status %lX\n",
792 result
, us
->pusb_dev
->status
);
793 /* if this is an CBI Protocol, get IRQ */
794 if (us
->protocol
== US_PR_CBI
) {
795 status
= usb_stor_CBI_get_status(srb
, us
);
796 /* if the status is error, report it */
797 if (status
== USB_STOR_TRANSPORT_ERROR
) {
798 debug(" USB CBI Command Error\n");
801 srb
->sense_buf
[12] = (unsigned char)(us
->ip_data
>> 8);
802 srb
->sense_buf
[13] = (unsigned char)(us
->ip_data
& 0xff);
804 /* if the status is good, report it */
805 if (status
== USB_STOR_TRANSPORT_GOOD
) {
806 debug(" USB CBI Command Good\n");
811 /* do we have to issue an auto request? */
812 /* HERE we have to check the result */
813 if ((result
< 0) && !(us
->pusb_dev
->status
& USB_ST_STALLED
)) {
814 debug("ERROR %lX\n", us
->pusb_dev
->status
);
815 us
->transport_reset(us
);
816 return USB_STOR_TRANSPORT_ERROR
;
818 if ((us
->protocol
== US_PR_CBI
) &&
819 ((srb
->cmd
[0] == SCSI_REQ_SENSE
) ||
820 (srb
->cmd
[0] == SCSI_INQUIRY
))) {
821 /* do not issue an autorequest after request sense */
822 debug("No auto request and good\n");
823 return USB_STOR_TRANSPORT_GOOD
;
825 /* issue an request_sense */
826 memset(&psrb
->cmd
[0], 0, 12);
827 psrb
->cmd
[0] = SCSI_REQ_SENSE
;
828 psrb
->cmd
[1] = srb
->lun
<< 5;
831 psrb
->pdata
= &srb
->sense_buf
[0];
833 /* issue the command */
834 result
= usb_stor_CB_comdat(psrb
, us
);
835 debug("auto request returned %d\n", result
);
836 /* if this is an CBI Protocol, get IRQ */
837 if (us
->protocol
== US_PR_CBI
)
838 status
= usb_stor_CBI_get_status(psrb
, us
);
840 if ((result
< 0) && !(us
->pusb_dev
->status
& USB_ST_STALLED
)) {
841 debug(" AUTO REQUEST ERROR %ld\n",
842 us
->pusb_dev
->status
);
843 return USB_STOR_TRANSPORT_ERROR
;
845 debug("autorequest returned 0x%02X 0x%02X 0x%02X 0x%02X\n",
846 srb
->sense_buf
[0], srb
->sense_buf
[2],
847 srb
->sense_buf
[12], srb
->sense_buf
[13]);
848 /* Check the auto request result */
849 if ((srb
->sense_buf
[2] == 0) &&
850 (srb
->sense_buf
[12] == 0) &&
851 (srb
->sense_buf
[13] == 0)) {
853 return USB_STOR_TRANSPORT_GOOD
;
856 /* Check the auto request result */
857 switch (srb
->sense_buf
[2]) {
859 /* Recovered Error */
860 return USB_STOR_TRANSPORT_GOOD
;
864 if (notready
++ > USB_TRANSPORT_NOT_READY_RETRY
) {
865 printf("cmd 0x%02X returned 0x%02X 0x%02X 0x%02X"
866 " 0x%02X (NOT READY)\n", srb
->cmd
[0],
867 srb
->sense_buf
[0], srb
->sense_buf
[2],
868 srb
->sense_buf
[12], srb
->sense_buf
[13]);
869 return USB_STOR_TRANSPORT_FAILED
;
876 if (retry
++ > USB_TRANSPORT_UNKNOWN_RETRY
) {
877 printf("cmd 0x%02X returned 0x%02X 0x%02X 0x%02X"
878 " 0x%02X\n", srb
->cmd
[0], srb
->sense_buf
[0],
879 srb
->sense_buf
[2], srb
->sense_buf
[12],
881 return USB_STOR_TRANSPORT_FAILED
;
886 return USB_STOR_TRANSPORT_FAILED
;
890 static int usb_inquiry(ccb
*srb
, struct us_data
*ss
)
895 memset(&srb
->cmd
[0], 0, 12);
896 srb
->cmd
[0] = SCSI_INQUIRY
;
897 srb
->cmd
[1] = srb
->lun
<< 5;
901 i
= ss
->transport(srb
, ss
);
902 debug("inquiry returns %d\n", i
);
908 printf("error in inquiry\n");
914 static int usb_request_sense(ccb
*srb
, struct us_data
*ss
)
918 ptr
= (char *)srb
->pdata
;
919 memset(&srb
->cmd
[0], 0, 12);
920 srb
->cmd
[0] = SCSI_REQ_SENSE
;
921 srb
->cmd
[1] = srb
->lun
<< 5;
924 srb
->pdata
= &srb
->sense_buf
[0];
926 ss
->transport(srb
, ss
);
927 debug("Request Sense returned %02X %02X %02X\n",
928 srb
->sense_buf
[2], srb
->sense_buf
[12],
930 srb
->pdata
= (uchar
*)ptr
;
934 static int usb_test_unit_ready(ccb
*srb
, struct us_data
*ss
)
939 memset(&srb
->cmd
[0], 0, 12);
940 srb
->cmd
[0] = SCSI_TST_U_RDY
;
941 srb
->cmd
[1] = srb
->lun
<< 5;
944 if (ss
->transport(srb
, ss
) == USB_STOR_TRANSPORT_GOOD
) {
945 ss
->flags
|= USB_READY
;
948 usb_request_sense(srb
, ss
);
950 * Check the Key Code Qualifier, if it matches
951 * "Not Ready - medium not present"
952 * (the sense Key equals 0x2 and the ASC is 0x3a)
953 * return immediately as the medium being absent won't change
954 * unless there is a user action.
956 if ((srb
->sense_buf
[2] == 0x02) &&
957 (srb
->sense_buf
[12] == 0x3a))
965 static int usb_read_capacity(ccb
*srb
, struct us_data
*ss
)
971 memset(&srb
->cmd
[0], 0, 12);
972 srb
->cmd
[0] = SCSI_RD_CAPAC
;
973 srb
->cmd
[1] = srb
->lun
<< 5;
976 if (ss
->transport(srb
, ss
) == USB_STOR_TRANSPORT_GOOD
)
983 static int usb_read_10(ccb
*srb
, struct us_data
*ss
, unsigned long start
,
984 unsigned short blocks
)
986 memset(&srb
->cmd
[0], 0, 12);
987 srb
->cmd
[0] = SCSI_READ10
;
988 srb
->cmd
[1] = srb
->lun
<< 5;
989 srb
->cmd
[2] = ((unsigned char) (start
>> 24)) & 0xff;
990 srb
->cmd
[3] = ((unsigned char) (start
>> 16)) & 0xff;
991 srb
->cmd
[4] = ((unsigned char) (start
>> 8)) & 0xff;
992 srb
->cmd
[5] = ((unsigned char) (start
)) & 0xff;
993 srb
->cmd
[7] = ((unsigned char) (blocks
>> 8)) & 0xff;
994 srb
->cmd
[8] = (unsigned char) blocks
& 0xff;
996 debug("read10: start %lx blocks %x\n", start
, blocks
);
997 return ss
->transport(srb
, ss
);
1000 static int usb_write_10(ccb
*srb
, struct us_data
*ss
, unsigned long start
,
1001 unsigned short blocks
)
1003 memset(&srb
->cmd
[0], 0, 12);
1004 srb
->cmd
[0] = SCSI_WRITE10
;
1005 srb
->cmd
[1] = srb
->lun
<< 5;
1006 srb
->cmd
[2] = ((unsigned char) (start
>> 24)) & 0xff;
1007 srb
->cmd
[3] = ((unsigned char) (start
>> 16)) & 0xff;
1008 srb
->cmd
[4] = ((unsigned char) (start
>> 8)) & 0xff;
1009 srb
->cmd
[5] = ((unsigned char) (start
)) & 0xff;
1010 srb
->cmd
[7] = ((unsigned char) (blocks
>> 8)) & 0xff;
1011 srb
->cmd
[8] = (unsigned char) blocks
& 0xff;
1013 debug("write10: start %lx blocks %x\n", start
, blocks
);
1014 return ss
->transport(srb
, ss
);
1018 #ifdef CONFIG_USB_BIN_FIXUP
1020 * Some USB storage devices queried for SCSI identification data respond with
1021 * binary strings, which if output to the console freeze the terminal. The
1022 * workaround is to modify the vendor and product strings read from such
1023 * device with proper values (as reported by 'usb info').
1025 * Vendor and product length limits are taken from the definition of
1026 * block_dev_desc_t in include/part.h.
1028 static void usb_bin_fixup(struct usb_device_descriptor descriptor
,
1029 unsigned char vendor
[],
1030 unsigned char product
[]) {
1031 const unsigned char max_vendor_len
= 40;
1032 const unsigned char max_product_len
= 20;
1033 if (descriptor
.idVendor
== 0x0424 && descriptor
.idProduct
== 0x223a) {
1034 strncpy((char *)vendor
, "SMSC", max_vendor_len
);
1035 strncpy((char *)product
, "Flash Media Cntrller",
1039 #endif /* CONFIG_USB_BIN_FIXUP */
1041 unsigned long usb_stor_read(int device
, lbaint_t blknr
,
1042 lbaint_t blkcnt
, void *buffer
)
1044 lbaint_t start
, blks
;
1046 unsigned short smallblks
;
1047 struct usb_device
*dev
;
1050 ccb
*srb
= &usb_ccb
;
1057 debug("\nusb_read: dev %d \n", device
);
1059 for (i
= 0; i
< USB_MAX_DEVICE
; i
++) {
1060 dev
= usb_get_dev_index(i
);
1063 if (dev
->devnum
== usb_dev_desc
[device
].target
)
1066 ss
= (struct us_data
*)dev
->privptr
;
1068 usb_disable_asynch(1); /* asynch transfer not allowed */
1069 srb
->lun
= usb_dev_desc
[device
].lun
;
1070 buf_addr
= (unsigned long)buffer
;
1074 debug("\nusb_read: dev %d startblk " LBAF
", blccnt " LBAF
1075 " buffer %" PRIxPTR
"\n", device
, start
, blks
, buf_addr
);
1078 /* XXX need some comment here */
1080 srb
->pdata
= (unsigned char *)buf_addr
;
1081 if (blks
> USB_MAX_XFER_BLK
)
1082 smallblks
= USB_MAX_XFER_BLK
;
1084 smallblks
= (unsigned short) blks
;
1086 if (smallblks
== USB_MAX_XFER_BLK
)
1087 usb_show_progress();
1088 srb
->datalen
= usb_dev_desc
[device
].blksz
* smallblks
;
1089 srb
->pdata
= (unsigned char *)buf_addr
;
1090 if (usb_read_10(srb
, ss
, start
, smallblks
)) {
1091 debug("Read ERROR\n");
1092 usb_request_sense(srb
, ss
);
1100 buf_addr
+= srb
->datalen
;
1101 } while (blks
!= 0);
1102 ss
->flags
&= ~USB_READY
;
1104 debug("usb_read: end startblk " LBAF
1105 ", blccnt %x buffer %" PRIxPTR
"\n",
1106 start
, smallblks
, buf_addr
);
1108 usb_disable_asynch(0); /* asynch transfer allowed */
1109 if (blkcnt
>= USB_MAX_XFER_BLK
)
1114 unsigned long usb_stor_write(int device
, lbaint_t blknr
,
1115 lbaint_t blkcnt
, const void *buffer
)
1117 lbaint_t start
, blks
;
1119 unsigned short smallblks
;
1120 struct usb_device
*dev
;
1123 ccb
*srb
= &usb_ccb
;
1130 debug("\nusb_write: dev %d \n", device
);
1132 for (i
= 0; i
< USB_MAX_DEVICE
; i
++) {
1133 dev
= usb_get_dev_index(i
);
1136 if (dev
->devnum
== usb_dev_desc
[device
].target
)
1139 ss
= (struct us_data
*)dev
->privptr
;
1141 usb_disable_asynch(1); /* asynch transfer not allowed */
1143 srb
->lun
= usb_dev_desc
[device
].lun
;
1144 buf_addr
= (unsigned long)buffer
;
1148 debug("\nusb_write: dev %d startblk " LBAF
", blccnt " LBAF
1149 " buffer %" PRIxPTR
"\n", device
, start
, blks
, buf_addr
);
1152 /* If write fails retry for max retry count else
1153 * return with number of blocks written successfully.
1156 srb
->pdata
= (unsigned char *)buf_addr
;
1157 if (blks
> USB_MAX_XFER_BLK
)
1158 smallblks
= USB_MAX_XFER_BLK
;
1160 smallblks
= (unsigned short) blks
;
1162 if (smallblks
== USB_MAX_XFER_BLK
)
1163 usb_show_progress();
1164 srb
->datalen
= usb_dev_desc
[device
].blksz
* smallblks
;
1165 srb
->pdata
= (unsigned char *)buf_addr
;
1166 if (usb_write_10(srb
, ss
, start
, smallblks
)) {
1167 debug("Write ERROR\n");
1168 usb_request_sense(srb
, ss
);
1176 buf_addr
+= srb
->datalen
;
1177 } while (blks
!= 0);
1178 ss
->flags
&= ~USB_READY
;
1180 debug("usb_write: end startblk " LBAF
", blccnt %x buffer %"
1181 PRIxPTR
"\n", start
, smallblks
, buf_addr
);
1183 usb_disable_asynch(0); /* asynch transfer allowed */
1184 if (blkcnt
>= USB_MAX_XFER_BLK
)
1190 /* Probe to see if a new device is actually a Storage device */
1191 int usb_storage_probe(struct usb_device
*dev
, unsigned int ifnum
,
1194 struct usb_interface
*iface
;
1196 struct usb_endpoint_descriptor
*ep_desc
;
1197 unsigned int flags
= 0;
1202 /* let's examine the device now */
1203 iface
= &dev
->config
.if_desc
[ifnum
];
1206 /* this is the place to patch some storage devices */
1207 debug("iVendor %X iProduct %X\n", dev
->descriptor
.idVendor
,
1208 dev
->descriptor
.idProduct
);
1210 if ((dev
->descriptor
.idVendor
) == 0x066b &&
1211 (dev
->descriptor
.idProduct
) == 0x0103) {
1212 debug("patched for E-USB\n");
1213 protocol
= US_PR_CB
;
1214 subclass
= US_SC_UFI
; /* an assumption */
1218 if (dev
->descriptor
.bDeviceClass
!= 0 ||
1219 iface
->desc
.bInterfaceClass
!= USB_CLASS_MASS_STORAGE
||
1220 iface
->desc
.bInterfaceSubClass
< US_SC_MIN
||
1221 iface
->desc
.bInterfaceSubClass
> US_SC_MAX
) {
1222 /* if it's not a mass storage, we go no further */
1226 memset(ss
, 0, sizeof(struct us_data
));
1228 /* At this point, we know we've got a live one */
1229 debug("\n\nUSB Mass Storage device detected\n");
1231 /* Initialize the us_data structure with some useful info */
1235 ss
->attention_done
= 0;
1237 /* If the device has subclass and protocol, then use that. Otherwise,
1238 * take data from the specific interface.
1241 ss
->subclass
= subclass
;
1242 ss
->protocol
= protocol
;
1244 ss
->subclass
= iface
->desc
.bInterfaceSubClass
;
1245 ss
->protocol
= iface
->desc
.bInterfaceProtocol
;
1248 /* set the handler pointers based on the protocol */
1249 debug("Transport: ");
1250 switch (ss
->protocol
) {
1252 debug("Control/Bulk\n");
1253 ss
->transport
= usb_stor_CB_transport
;
1254 ss
->transport_reset
= usb_stor_CB_reset
;
1258 debug("Control/Bulk/Interrupt\n");
1259 ss
->transport
= usb_stor_CB_transport
;
1260 ss
->transport_reset
= usb_stor_CB_reset
;
1263 debug("Bulk/Bulk/Bulk\n");
1264 ss
->transport
= usb_stor_BBB_transport
;
1265 ss
->transport_reset
= usb_stor_BBB_reset
;
1268 printf("USB Storage Transport unknown / not yet implemented\n");
1274 * We are expecting a minimum of 2 endpoints - in and out (bulk).
1275 * An optional interrupt is OK (necessary for CBI protocol).
1276 * We will ignore any others.
1278 for (i
= 0; i
< iface
->desc
.bNumEndpoints
; i
++) {
1279 ep_desc
= &iface
->ep_desc
[i
];
1280 /* is it an BULK endpoint? */
1281 if ((ep_desc
->bmAttributes
&
1282 USB_ENDPOINT_XFERTYPE_MASK
) == USB_ENDPOINT_XFER_BULK
) {
1283 if (ep_desc
->bEndpointAddress
& USB_DIR_IN
)
1284 ss
->ep_in
= ep_desc
->bEndpointAddress
&
1285 USB_ENDPOINT_NUMBER_MASK
;
1288 ep_desc
->bEndpointAddress
&
1289 USB_ENDPOINT_NUMBER_MASK
;
1292 /* is it an interrupt endpoint? */
1293 if ((ep_desc
->bmAttributes
&
1294 USB_ENDPOINT_XFERTYPE_MASK
) == USB_ENDPOINT_XFER_INT
) {
1295 ss
->ep_int
= ep_desc
->bEndpointAddress
&
1296 USB_ENDPOINT_NUMBER_MASK
;
1297 ss
->irqinterval
= ep_desc
->bInterval
;
1300 debug("Endpoints In %d Out %d Int %d\n",
1301 ss
->ep_in
, ss
->ep_out
, ss
->ep_int
);
1303 /* Do some basic sanity checks, and bail if we find a problem */
1304 if (usb_set_interface(dev
, iface
->desc
.bInterfaceNumber
, 0) ||
1305 !ss
->ep_in
|| !ss
->ep_out
||
1306 (ss
->protocol
== US_PR_CBI
&& ss
->ep_int
== 0)) {
1307 debug("Problems with device\n");
1310 /* set class specific stuff */
1311 /* We only handle certain protocols. Currently, these are
1313 * The SFF8070 accepts the requests used in u-boot
1315 if (ss
->subclass
!= US_SC_UFI
&& ss
->subclass
!= US_SC_SCSI
&&
1316 ss
->subclass
!= US_SC_8070
) {
1317 printf("Sorry, protocol %d not yet supported.\n", ss
->subclass
);
1321 /* we had found an interrupt endpoint, prepare irq pipe
1322 * set up the IRQ pipe and handler
1324 ss
->irqinterval
= (ss
->irqinterval
> 0) ? ss
->irqinterval
: 255;
1325 ss
->irqpipe
= usb_rcvintpipe(ss
->pusb_dev
, ss
->ep_int
);
1326 ss
->irqmaxp
= usb_maxpacket(dev
, ss
->irqpipe
);
1327 dev
->irq_handle
= usb_stor_irq
;
1329 dev
->privptr
= (void *)ss
;
1333 int usb_stor_get_info(struct usb_device
*dev
, struct us_data
*ss
,
1334 block_dev_desc_t
*dev_desc
)
1336 unsigned char perq
, modi
;
1337 ALLOC_CACHE_ALIGN_BUFFER(unsigned long, cap
, 2);
1338 ALLOC_CACHE_ALIGN_BUFFER(unsigned char, usb_stor_buf
, 36);
1339 unsigned long *capacity
, *blksz
;
1340 ccb
*pccb
= &usb_ccb
;
1342 pccb
->pdata
= usb_stor_buf
;
1344 dev_desc
->target
= dev
->devnum
;
1345 pccb
->lun
= dev_desc
->lun
;
1346 debug(" address %d\n", dev_desc
->target
);
1348 if (usb_inquiry(pccb
, ss
))
1351 perq
= usb_stor_buf
[0];
1352 modi
= usb_stor_buf
[1];
1355 * Skip unknown devices (0x1f) and enclosure service devices (0x0d),
1356 * they would not respond to test_unit_ready .
1358 if (((perq
& 0x1f) == 0x1f) || ((perq
& 0x1f) == 0x0d)) {
1361 if ((modi
&0x80) == 0x80) {
1362 /* drive is removable */
1363 dev_desc
->removable
= 1;
1365 memcpy(&dev_desc
->vendor
[0], (const void *) &usb_stor_buf
[8], 8);
1366 memcpy(&dev_desc
->product
[0], (const void *) &usb_stor_buf
[16], 16);
1367 memcpy(&dev_desc
->revision
[0], (const void *) &usb_stor_buf
[32], 4);
1368 dev_desc
->vendor
[8] = 0;
1369 dev_desc
->product
[16] = 0;
1370 dev_desc
->revision
[4] = 0;
1371 #ifdef CONFIG_USB_BIN_FIXUP
1372 usb_bin_fixup(dev
->descriptor
, (uchar
*)dev_desc
->vendor
,
1373 (uchar
*)dev_desc
->product
);
1374 #endif /* CONFIG_USB_BIN_FIXUP */
1375 debug("ISO Vers %X, Response Data %X\n", usb_stor_buf
[2],
1377 if (usb_test_unit_ready(pccb
, ss
)) {
1378 printf("Device NOT ready\n"
1379 " Request Sense returned %02X %02X %02X\n",
1380 pccb
->sense_buf
[2], pccb
->sense_buf
[12],
1381 pccb
->sense_buf
[13]);
1382 if (dev_desc
->removable
== 1) {
1383 dev_desc
->type
= perq
;
1388 pccb
->pdata
= (unsigned char *)&cap
[0];
1389 memset(pccb
->pdata
, 0, 8);
1390 if (usb_read_capacity(pccb
, ss
) != 0) {
1391 printf("READ_CAP ERROR\n");
1395 ss
->flags
&= ~USB_READY
;
1396 debug("Read Capacity returns: 0x%lx, 0x%lx\n", cap
[0], cap
[1]);
1398 if (cap
[0] > (0x200000 * 10)) /* greater than 10 GByte */
1401 cap
[0] = cpu_to_be32(cap
[0]);
1402 cap
[1] = cpu_to_be32(cap
[1]);
1404 /* this assumes bigendian! */
1408 debug("Capacity = 0x%lx, blocksz = 0x%lx\n", *capacity
, *blksz
);
1409 dev_desc
->lba
= *capacity
;
1410 dev_desc
->blksz
= *blksz
;
1411 dev_desc
->log2blksz
= LOG2(dev_desc
->blksz
);
1412 dev_desc
->type
= perq
;
1413 debug(" address %d\n", dev_desc
->target
);
1414 debug("partype: %d\n", dev_desc
->part_type
);
1416 init_part(dev_desc
);
1418 debug("partype: %d\n", dev_desc
->part_type
);