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