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