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