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