1 /* Driver for Datafab USB Compact Flash reader
2 *
3 * $Id: datafab.c,v 1.7 2002/02/25 00:40:13 mdharm Exp $
4 *
5 * datafab driver v0.1:
6 *
7 * First release
8 *
9 * Current development and maintenance by:
10 * (c) 2000 Jimmie Mayfield (mayfield+datafab@sackheads.org)
11 *
12 * Many thanks to Robert Baruch for the SanDisk SmartMedia reader driver
13 * which I used as a template for this driver.
14 *
15 * Some bugfixes and scatter-gather code by Gregory P. Smith
16 * (greg-usb@electricrain.com)
17 *
18 * Fix for media change by Joerg Schneider (js@joergschneider.com)
19 *
20 * Other contributors:
21 * (c) 2002 Alan Stern <stern@rowland.org>
22 *
23 * This program is free software; you can redistribute it and/or modify it
24 * under the terms of the GNU General Public License as published by the
25 * Free Software Foundation; either version 2, or (at your option) any
26 * later version.
27 *
28 * This program is distributed in the hope that it will be useful, but
29 * WITHOUT ANY WARRANTY; without even the implied warranty of
30 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
31 * General Public License for more details.
32 *
33 * You should have received a copy of the GNU General Public License along
34 * with this program; if not, write to the Free Software Foundation, Inc.,
35 * 675 Mass Ave, Cambridge, MA 02139, USA.
36 */
37
38 /*
39 * This driver attempts to support USB CompactFlash reader/writer devices
40 * based on Datafab USB-to-ATA chips. It was specifically developed for the
41 * Datafab MDCFE-B USB CompactFlash reader but has since been found to work
42 * with a variety of Datafab-based devices from a number of manufacturers.
43 * I've received a report of this driver working with a Datafab-based
44 * SmartMedia device though please be aware that I'm personally unable to
45 * test SmartMedia support.
46 *
47 * This driver supports reading and writing. If you're truly paranoid,
48 * however, you can force the driver into a write-protected state by setting
49 * the WP enable bits in datafab_handle_mode_sense(). Basically this means
50 * setting mode_param_header[3] = 0x80.
51 */
52
53 #include "transport.h"
54 #include "protocol.h"
55 #include "usb.h"
56 #include "debug.h"
57 #include "datafab.h"
58
59 #include <linux/sched.h>
60 #include <linux/errno.h>
61 #include <linux/slab.h>
62
63 extern int usb_stor_bulk_msg(struct us_data *us, void *data, int pipe,
64 unsigned int len, unsigned int *act_len);
65
66 static int datafab_determine_lun(struct us_data *us, struct datafab_info *info);
67
68
datafab_dump_data(unsigned char * data,int len)69 static void datafab_dump_data(unsigned char *data, int len)
70 {
71 unsigned char buf[80];
72 int sofar = 0;
73
74 if (!data)
75 return;
76
77 memset(buf, 0, sizeof(buf));
78
79 for (sofar = 0; sofar < len; sofar++) {
80 sprintf(buf + strlen(buf), "%02x ",
81 ((unsigned int) data[sofar]) & 0xFF);
82
83 if (sofar % 16 == 15) {
84 US_DEBUGP("datafab: %s\n", buf);
85 memset(buf, 0, sizeof(buf));
86 }
87 }
88
89 if (strlen(buf) != 0)
90 US_DEBUGP("datafab: %s\n", buf);
91 }
92
93
datafab_raw_bulk(int direction,struct us_data * us,unsigned char * data,unsigned int len)94 static int datafab_raw_bulk(int direction,
95 struct us_data *us,
96 unsigned char *data,
97 unsigned int len)
98 {
99 int result;
100 int act_len;
101 int pipe;
102
103 if (direction == SCSI_DATA_READ)
104 pipe = usb_rcvbulkpipe(us->pusb_dev, us->ep_in);
105 else
106 pipe = usb_sndbulkpipe(us->pusb_dev, us->ep_out);
107
108 result = usb_stor_bulk_msg(us, data, pipe, len, &act_len);
109
110 // if we stall, we need to clear it before we go on
111 if (result == -EPIPE) {
112 US_DEBUGP("datafab_raw_bulk: EPIPE. clearing endpoint halt for"
113 " pipe 0x%x, stalled at %d bytes\n", pipe, act_len);
114 usb_stor_clear_halt(us, pipe);
115 }
116
117 if (result) {
118 // NAK - that means we've retried a few times already
119 if (result == -ETIMEDOUT) {
120 US_DEBUGP("datafab_raw_bulk: device NAKed\n");
121 return US_BULK_TRANSFER_FAILED;
122 }
123
124 // -ECONNRESET -- we canceled this transfer
125 if (result == -ECONNRESET) {
126 US_DEBUGP("datafab_raw_bulk: transfer aborted\n");
127 return US_BULK_TRANSFER_ABORTED;
128 }
129
130 if (result == -EPIPE) {
131 US_DEBUGP("datafab_raw_bulk: output pipe stalled\n");
132 return USB_STOR_TRANSPORT_FAILED;
133 }
134
135 // the catch-all case
136 US_DEBUGP("datafab_raw_bulk: unknown error\n");
137 return US_BULK_TRANSFER_FAILED;
138 }
139
140 if (act_len != len) {
141 US_DEBUGP("datafab_raw_bulk: Warning. Transferred only %d bytes\n", act_len);
142 return US_BULK_TRANSFER_SHORT;
143 }
144
145 US_DEBUGP("datafab_raw_bulk: Transfered %d of %d bytes\n", act_len, len);
146 return US_BULK_TRANSFER_GOOD;
147 }
148
datafab_bulk_read(struct us_data * us,unsigned char * data,unsigned int len)149 static inline int datafab_bulk_read(struct us_data *us,
150 unsigned char *data,
151 unsigned int len)
152 {
153 if (len == 0)
154 return USB_STOR_TRANSPORT_GOOD;
155
156 US_DEBUGP("datafab_bulk_read: len = %d\n", len);
157 return datafab_raw_bulk(SCSI_DATA_READ, us, data, len);
158 }
159
160
datafab_bulk_write(struct us_data * us,unsigned char * data,unsigned int len)161 static inline int datafab_bulk_write(struct us_data *us,
162 unsigned char *data,
163 unsigned int len)
164 {
165 if (len == 0)
166 return USB_STOR_TRANSPORT_GOOD;
167
168 US_DEBUGP("datafab_bulk_write: len = %d\n", len);
169 return datafab_raw_bulk(SCSI_DATA_WRITE, us, data, len);
170 }
171
172
datafab_read_data(struct us_data * us,struct datafab_info * info,u32 sector,u32 sectors,unsigned char * dest,int use_sg)173 static int datafab_read_data(struct us_data *us,
174 struct datafab_info *info,
175 u32 sector,
176 u32 sectors,
177 unsigned char *dest,
178 int use_sg)
179 {
180 unsigned char command[8] = { 0, 0, 0, 0, 0, 0xE0, 0x20, 0x01 };
181 unsigned char *buffer = NULL;
182 unsigned char *ptr;
183 unsigned char thistime;
184 struct scatterlist *sg = NULL;
185 int totallen, len, result;
186 int sg_idx = 0, current_sg_offset = 0;
187 int transferred, rc;
188
189 // we're working in LBA mode. according to the ATA spec,
190 // we can support up to 28-bit addressing. I don't know if Datafab
191 // supports beyond 24-bit addressing. It's kind of hard to test
192 // since it requires > 8GB CF card.
193 //
194 if (sectors > 0x0FFFFFFF)
195 return USB_STOR_TRANSPORT_ERROR;
196
197 if (info->lun == -1) {
198 rc = datafab_determine_lun(us, info);
199 if (rc != USB_STOR_TRANSPORT_GOOD)
200 return rc;
201 }
202
203 command[5] += (info->lun << 4);
204
205 // If we're using scatter-gather, we have to create a new
206 // buffer to read all of the data in first, since a
207 // scatter-gather buffer could in theory start in the middle
208 // of a page, which would be bad. A developer who wants a
209 // challenge might want to write a limited-buffer
210 // version of this code.
211
212 totallen = sectors * info->ssize;
213
214 do {
215 // loop, never allocate or transfer more than 64k at once (min(128k, 255*info->ssize) is the real limit)
216 len = min_t(int, totallen, 65536);
217
218 if (use_sg) {
219 sg = (struct scatterlist *) dest;
220 buffer = kmalloc(len, GFP_NOIO);
221 if (buffer == NULL)
222 return USB_STOR_TRANSPORT_ERROR;
223 ptr = buffer;
224 } else {
225 ptr = dest;
226 }
227
228 thistime = (len / info->ssize) & 0xff;
229
230 command[0] = 0;
231 command[1] = thistime;
232 command[2] = sector & 0xFF;
233 command[3] = (sector >> 8) & 0xFF;
234 command[4] = (sector >> 16) & 0xFF;
235
236 command[5] |= (sector >> 24) & 0x0F;
237
238 // send the command
239 US_DEBUGP("datafab_read_data: sending following command\n");
240 datafab_dump_data(command, sizeof(command));
241
242 result = datafab_bulk_write(us, command, sizeof(command));
243 if (result != USB_STOR_TRANSPORT_GOOD) {
244 if (use_sg)
245 kfree(buffer);
246 return result;
247 }
248
249 // read the result
250 result = datafab_bulk_read(us, ptr, len);
251 if (result != USB_STOR_TRANSPORT_GOOD) {
252 if (use_sg)
253 kfree(buffer);
254 return result;
255 }
256
257 US_DEBUGP("datafab_read_data results: %d bytes\n", len);
258 // datafab_dump_data(ptr, len);
259
260 sectors -= thistime;
261 sector += thistime;
262
263 if (use_sg) {
264 transferred = 0;
265 while (sg_idx < use_sg && transferred < len) {
266 if (len - transferred >= sg[sg_idx].length - current_sg_offset) {
267 US_DEBUGP("datafab_read_data: adding %d bytes to %d byte sg buffer\n", sg[sg_idx].length - current_sg_offset, sg[sg_idx].length);
268 memcpy(sg[sg_idx].address + current_sg_offset,
269 buffer + transferred,
270 sg[sg_idx].length - current_sg_offset);
271 transferred += sg[sg_idx].length - current_sg_offset;
272 current_sg_offset = 0;
273 // on to the next sg buffer
274 ++sg_idx;
275 } else {
276 US_DEBUGP("datafab_read_data: adding %d bytes to %d byte sg buffer\n", len - transferred, sg[sg_idx].length);
277 memcpy(sg[sg_idx].address + current_sg_offset,
278 buffer + transferred,
279 len - transferred);
280 current_sg_offset += len - transferred;
281 // this sg buffer is only partially full and we're out of data to copy in
282 break;
283 }
284 }
285 kfree(buffer);
286 } else {
287 dest += len;
288 }
289
290 totallen -= len;
291 } while (totallen > 0);
292
293 return USB_STOR_TRANSPORT_GOOD;
294 }
295
296
datafab_write_data(struct us_data * us,struct datafab_info * info,u32 sector,u32 sectors,unsigned char * src,int use_sg)297 static int datafab_write_data(struct us_data *us,
298 struct datafab_info *info,
299 u32 sector,
300 u32 sectors,
301 unsigned char *src,
302 int use_sg)
303 {
304 unsigned char command[8] = { 0, 0, 0, 0, 0, 0xE0, 0x30, 0x02 };
305 unsigned char reply[2] = { 0, 0 };
306 unsigned char *buffer = NULL;
307 unsigned char *ptr;
308 unsigned char thistime;
309 struct scatterlist *sg = NULL;
310 int totallen, len, result;
311 int sg_idx = 0, current_sg_offset = 0;
312 int transferred, rc;
313
314 // we're working in LBA mode. according to the ATA spec,
315 // we can support up to 28-bit addressing. I don't know if Datafab
316 // supports beyond 24-bit addressing. It's kind of hard to test
317 // since it requires > 8GB CF card.
318 //
319 if (sectors > 0x0FFFFFFF)
320 return USB_STOR_TRANSPORT_ERROR;
321
322 if (info->lun == -1) {
323 rc = datafab_determine_lun(us, info);
324 if (rc != USB_STOR_TRANSPORT_GOOD)
325 return rc;
326 }
327
328 command[5] += (info->lun << 4);
329
330 // If we're using scatter-gather, we have to create a new
331 // buffer to read all of the data in first, since a
332 // scatter-gather buffer could in theory start in the middle
333 // of a page, which would be bad. A developer who wants a
334 // challenge might want to write a limited-buffer
335 // version of this code.
336
337 totallen = sectors * info->ssize;
338
339 do {
340 // loop, never allocate or transfer more than 64k at once (min(128k, 255*info->ssize) is the real limit)
341 len = min_t(int, totallen, 65536);
342
343 if (use_sg) {
344 sg = (struct scatterlist *) src;
345 buffer = kmalloc(len, GFP_NOIO);
346 if (buffer == NULL)
347 return USB_STOR_TRANSPORT_ERROR;
348 ptr = buffer;
349
350 memset(buffer, 0, len);
351
352 // copy the data from the sg bufs into the big contiguous buf
353 //
354 transferred = 0;
355 while (transferred < len) {
356 if (len - transferred >= sg[sg_idx].length - current_sg_offset) {
357 US_DEBUGP("datafab_write_data: getting %d bytes from %d byte sg buffer\n", sg[sg_idx].length - current_sg_offset, sg[sg_idx].length);
358 memcpy(ptr + transferred,
359 sg[sg_idx].address + current_sg_offset,
360 sg[sg_idx].length - current_sg_offset);
361 transferred += sg[sg_idx].length - current_sg_offset;
362 current_sg_offset = 0;
363 // on to the next sg buffer
364 ++sg_idx;
365 } else {
366 US_DEBUGP("datafab_write_data: getting %d bytes from %d byte sg buffer\n", len - transferred, sg[sg_idx].length);
367 memcpy(ptr + transferred,
368 sg[sg_idx].address + current_sg_offset,
369 len - transferred);
370 current_sg_offset += len - transferred;
371 // we only copied part of this sg buffer
372 break;
373 }
374 }
375 } else {
376 ptr = src;
377 }
378
379 thistime = (len / info->ssize) & 0xff;
380
381 command[0] = 0;
382 command[1] = thistime;
383 command[2] = sector & 0xFF;
384 command[3] = (sector >> 8) & 0xFF;
385 command[4] = (sector >> 16) & 0xFF;
386
387 command[5] |= (sector >> 24) & 0x0F;
388
389 // send the command
390 US_DEBUGP("datafab_write_data: sending following command\n");
391 datafab_dump_data(command, sizeof(command));
392
393 result = datafab_bulk_write(us, command, sizeof(command));
394 if (result != USB_STOR_TRANSPORT_GOOD) {
395 if (use_sg)
396 kfree(buffer);
397 return result;
398 }
399
400 // send the data
401 result = datafab_bulk_write(us, ptr, len);
402 if (result != USB_STOR_TRANSPORT_GOOD) {
403 if (use_sg)
404 kfree(buffer);
405 return result;
406 }
407
408 // read the result
409 result = datafab_bulk_read(us, reply, sizeof(reply));
410 if (result != USB_STOR_TRANSPORT_GOOD) {
411 if (use_sg)
412 kfree(buffer);
413 return result;
414 }
415
416 if (reply[0] != 0x50 && reply[1] != 0) {
417 US_DEBUGP("datafab_write_data: Gah! write return code: %02x %02x\n", reply[0], reply[1]);
418 if (use_sg)
419 kfree(buffer);
420 return USB_STOR_TRANSPORT_ERROR;
421 }
422
423 sectors -= thistime;
424 sector += thistime;
425
426 if (use_sg) {
427 kfree(buffer);
428 } else {
429 src += len;
430 }
431
432 totallen -= len;
433 } while (totallen > 0);
434
435 return USB_STOR_TRANSPORT_GOOD;
436 }
437
438
datafab_determine_lun(struct us_data * us,struct datafab_info * info)439 static int datafab_determine_lun(struct us_data *us,
440 struct datafab_info *info)
441 {
442 // dual-slot readers can be thought of as dual-LUN devices. we need to
443 // determine which card slot is being used. we'll send an IDENTIFY DEVICE
444 // command and see which LUN responds...
445 //
446 // there might be a better way of doing this?
447 //
448 unsigned char command[8] = { 0, 1, 0, 0, 0, 0xa0, 0xec, 1 };
449 unsigned char buf[512];
450 int count = 0, rc;
451
452 if (!us || !info)
453 return USB_STOR_TRANSPORT_ERROR;
454
455 US_DEBUGP("datafab_determine_lun: locating...\n");
456
457 // we'll try 10 times before giving up...
458 //
459 while (count++ < 10) {
460 command[5] = 0xa0;
461
462 rc = datafab_bulk_write(us, command, 8);
463 if (rc != USB_STOR_TRANSPORT_GOOD)
464 return rc;
465
466 rc = datafab_bulk_read(us, buf, sizeof(buf));
467 if (rc == USB_STOR_TRANSPORT_GOOD) {
468 info->lun = 0;
469 return USB_STOR_TRANSPORT_GOOD;
470 }
471
472 command[5] = 0xb0;
473
474 rc = datafab_bulk_write(us, command, 8);
475 if (rc != USB_STOR_TRANSPORT_GOOD)
476 return rc;
477
478 rc = datafab_bulk_read(us, buf, sizeof(buf));
479 if (rc == USB_STOR_TRANSPORT_GOOD) {
480 info->lun = 1;
481 return USB_STOR_TRANSPORT_GOOD;
482 }
483
484 wait_ms(20);
485 }
486
487 return USB_STOR_TRANSPORT_FAILED;
488 }
489
datafab_id_device(struct us_data * us,struct datafab_info * info)490 static int datafab_id_device(struct us_data *us,
491 struct datafab_info *info)
492 {
493 // this is a variation of the ATA "IDENTIFY DEVICE" command...according
494 // to the ATA spec, 'Sector Count' isn't used but the Windows driver
495 // sets this bit so we do too...
496 //
497 unsigned char command[8] = { 0, 1, 0, 0, 0, 0xa0, 0xec, 1 };
498 unsigned char reply[512];
499 int rc;
500
501 if (!us || !info)
502 return USB_STOR_TRANSPORT_ERROR;
503
504 if (info->lun == -1) {
505 rc = datafab_determine_lun(us, info);
506 if (rc != USB_STOR_TRANSPORT_GOOD)
507 return rc;
508 }
509
510 command[5] += (info->lun << 4);
511
512 rc = datafab_bulk_write(us, command, 8);
513 if (rc != USB_STOR_TRANSPORT_GOOD)
514 return rc;
515
516 // we'll go ahead and extract the media capacity while we're here...
517 //
518 rc = datafab_bulk_read(us, reply, sizeof(reply));
519 if (rc == USB_STOR_TRANSPORT_GOOD) {
520 // capacity is at word offset 57-58
521 //
522 info->sectors = ((u32)(reply[117]) << 24) |
523 ((u32)(reply[116]) << 16) |
524 ((u32)(reply[115]) << 8) |
525 ((u32)(reply[114]) );
526 }
527
528 return rc;
529 }
530
531
datafab_handle_mode_sense(struct us_data * us,Scsi_Cmnd * srb,unsigned char * ptr,int sense_6)532 static int datafab_handle_mode_sense(struct us_data *us,
533 Scsi_Cmnd * srb,
534 unsigned char *ptr,
535 int sense_6)
536 {
537 unsigned char mode_param_header[8] = {
538 0, 0, 0, 0, 0, 0, 0, 0
539 };
540 unsigned char rw_err_page[12] = {
541 0x1, 0xA, 0x21, 1, 0, 0, 0, 0, 1, 0, 0, 0
542 };
543 unsigned char cache_page[12] = {
544 0x8, 0xA, 0x1, 0, 0, 0, 0, 0, 0, 0, 0, 0
545 };
546 unsigned char rbac_page[12] = {
547 0x1B, 0xA, 0, 0x81, 0, 0, 0, 0, 0, 0, 0, 0
548 };
549 unsigned char timer_page[8] = {
550 0x1C, 0x6, 0, 0, 0, 0
551 };
552 unsigned char pc, page_code;
553 unsigned short total_len = 0;
554 unsigned short param_len, i = 0;
555
556 // most of this stuff is just a hack to get things working. the
557 // datafab reader doesn't present a SCSI interface so we
558 // fudge the SCSI commands...
559 //
560
561 if (sense_6)
562 param_len = srb->cmnd[4];
563 else
564 param_len = ((u16) (srb->cmnd[7]) >> 8) | ((u16) (srb->cmnd[8]));
565
566 pc = srb->cmnd[2] >> 6;
567 page_code = srb->cmnd[2] & 0x3F;
568
569 switch (pc) {
570 case 0x0:
571 US_DEBUGP("datafab_handle_mode_sense: Current values\n");
572 break;
573 case 0x1:
574 US_DEBUGP("datafab_handle_mode_sense: Changeable values\n");
575 break;
576 case 0x2:
577 US_DEBUGP("datafab_handle_mode_sense: Default values\n");
578 break;
579 case 0x3:
580 US_DEBUGP("datafab_handle_mode_sense: Saves values\n");
581 break;
582 }
583
584 mode_param_header[3] = 0x80; // write enable
585
586 switch (page_code) {
587 case 0x0:
588 // vendor-specific mode
589 return USB_STOR_TRANSPORT_ERROR;
590
591 case 0x1:
592 total_len = sizeof(rw_err_page);
593 mode_param_header[0] = total_len >> 8;
594 mode_param_header[1] = total_len & 0xFF;
595 mode_param_header[3] = 0x00; // WP enable: 0x80
596
597 memcpy(ptr, mode_param_header, sizeof(mode_param_header));
598 i += sizeof(mode_param_header);
599 memcpy(ptr + i, rw_err_page, sizeof(rw_err_page));
600 break;
601
602 case 0x8:
603 total_len = sizeof(cache_page);
604 mode_param_header[0] = total_len >> 8;
605 mode_param_header[1] = total_len & 0xFF;
606 mode_param_header[3] = 0x00; // WP enable: 0x80
607
608 memcpy(ptr, mode_param_header, sizeof(mode_param_header));
609 i += sizeof(mode_param_header);
610 memcpy(ptr + i, cache_page, sizeof(cache_page));
611 break;
612
613 case 0x1B:
614 total_len = sizeof(rbac_page);
615 mode_param_header[0] = total_len >> 8;
616 mode_param_header[1] = total_len & 0xFF;
617 mode_param_header[3] = 0x00; // WP enable: 0x80
618
619 memcpy(ptr, mode_param_header, sizeof(mode_param_header));
620 i += sizeof(mode_param_header);
621 memcpy(ptr + i, rbac_page, sizeof(rbac_page));
622 break;
623
624 case 0x1C:
625 total_len = sizeof(timer_page);
626 mode_param_header[0] = total_len >> 8;
627 mode_param_header[1] = total_len & 0xFF;
628 mode_param_header[3] = 0x00; // WP enable: 0x80
629
630 memcpy(ptr, mode_param_header, sizeof(mode_param_header));
631 i += sizeof(mode_param_header);
632 memcpy(ptr + i, timer_page, sizeof(timer_page));
633 break;
634
635 case 0x3F: // retrieve all pages
636 total_len = sizeof(timer_page) + sizeof(rbac_page) +
637 sizeof(cache_page) + sizeof(rw_err_page);
638 mode_param_header[0] = total_len >> 8;
639 mode_param_header[1] = total_len & 0xFF;
640 mode_param_header[3] = 0x00; // WP enable
641
642 memcpy(ptr, mode_param_header, sizeof(mode_param_header));
643 i += sizeof(mode_param_header);
644 memcpy(ptr + i, timer_page, sizeof(timer_page));
645 i += sizeof(timer_page);
646 memcpy(ptr + i, rbac_page, sizeof(rbac_page));
647 i += sizeof(rbac_page);
648 memcpy(ptr + i, cache_page, sizeof(cache_page));
649 i += sizeof(cache_page);
650 memcpy(ptr + i, rw_err_page, sizeof(rw_err_page));
651 break;
652 }
653
654 return USB_STOR_TRANSPORT_GOOD;
655 }
656
datafab_info_destructor(void * extra)657 void datafab_info_destructor(void *extra)
658 {
659 // this routine is a placeholder...
660 // currently, we don't allocate any extra memory so we're okay
661 }
662
663
664 // Transport for the Datafab MDCFE-B
665 //
datafab_transport(Scsi_Cmnd * srb,struct us_data * us)666 int datafab_transport(Scsi_Cmnd * srb, struct us_data *us)
667 {
668 struct datafab_info *info;
669 int rc;
670 unsigned long block, blocks;
671 unsigned char *ptr = NULL;
672 unsigned char inquiry_reply[36] = {
673 0x00, 0x80, 0x00, 0x01, 0x1F, 0x00, 0x00, 0x00
674 };
675
676 if (!us->extra) {
677 us->extra = kmalloc(sizeof(struct datafab_info), GFP_NOIO);
678 if (!us->extra) {
679 US_DEBUGP("datafab_transport: Gah! Can't allocate storage for Datafab info struct!\n");
680 return USB_STOR_TRANSPORT_ERROR;
681 }
682 memset(us->extra, 0, sizeof(struct datafab_info));
683 us->extra_destructor = datafab_info_destructor;
684 ((struct datafab_info *)us->extra)->lun = -1;
685 }
686
687 info = (struct datafab_info *) (us->extra);
688 ptr = (unsigned char *) srb->request_buffer;
689
690 if (srb->cmnd[0] == INQUIRY) {
691 US_DEBUGP("datafab_transport: INQUIRY. Returning bogus response");
692 memset( inquiry_reply + 8, 0, 28 );
693 fill_inquiry_response(us, inquiry_reply, 36);
694 return USB_STOR_TRANSPORT_GOOD;
695 }
696
697 if (srb->cmnd[0] == READ_CAPACITY) {
698 unsigned int max_sector;
699
700 info->ssize = 0x200; // hard coded 512 byte sectors as per ATA spec
701 rc = datafab_id_device(us, info);
702 if (rc != USB_STOR_TRANSPORT_GOOD)
703 return rc;
704
705 US_DEBUGP("datafab_transport: READ_CAPACITY: "
706 "%ld sectors, %ld bytes per sector\n",
707 info->sectors, info->ssize);
708
709 // build the reply
710 //
711 max_sector = info->sectors - 1;
712 ptr[0] = (max_sector >> 24) & 0xFF;
713 ptr[1] = (max_sector >> 16) & 0xFF;
714 ptr[2] = (max_sector >> 8) & 0xFF;
715 ptr[3] = (max_sector) & 0xFF;
716
717 ptr[4] = (info->ssize >> 24) & 0xFF;
718 ptr[5] = (info->ssize >> 16) & 0xFF;
719 ptr[6] = (info->ssize >> 8) & 0xFF;
720 ptr[7] = (info->ssize) & 0xFF;
721
722 return USB_STOR_TRANSPORT_GOOD;
723 }
724
725 if (srb->cmnd[0] == MODE_SELECT_10) {
726 US_DEBUGP("datafab_transport: Gah! MODE_SELECT_10.\n");
727 return USB_STOR_TRANSPORT_ERROR;
728 }
729
730 // don't bother implementing READ_6 or WRITE_6. Just set MODE_XLATE and
731 // let the usb storage code convert to READ_10/WRITE_10
732 //
733 if (srb->cmnd[0] == READ_10) {
734 block = ((u32)(srb->cmnd[2]) << 24) | ((u32)(srb->cmnd[3]) << 16) |
735 ((u32)(srb->cmnd[4]) << 8) | ((u32)(srb->cmnd[5]));
736
737 blocks = ((u32)(srb->cmnd[7]) << 8) | ((u32)(srb->cmnd[8]));
738
739 US_DEBUGP("datafab_transport: READ_10: read block 0x%04lx count %ld\n", block, blocks);
740 return datafab_read_data(us, info, block, blocks, ptr, srb->use_sg);
741 }
742
743 if (srb->cmnd[0] == READ_12) {
744 // we'll probably never see a READ_12 but we'll do it anyway...
745 //
746 block = ((u32)(srb->cmnd[2]) << 24) | ((u32)(srb->cmnd[3]) << 16) |
747 ((u32)(srb->cmnd[4]) << 8) | ((u32)(srb->cmnd[5]));
748
749 blocks = ((u32)(srb->cmnd[6]) << 24) | ((u32)(srb->cmnd[7]) << 16) |
750 ((u32)(srb->cmnd[8]) << 8) | ((u32)(srb->cmnd[9]));
751
752 US_DEBUGP("datafab_transport: READ_12: read block 0x%04lx count %ld\n", block, blocks);
753 return datafab_read_data(us, info, block, blocks, ptr, srb->use_sg);
754 }
755
756 if (srb->cmnd[0] == WRITE_10) {
757 block = ((u32)(srb->cmnd[2]) << 24) | ((u32)(srb->cmnd[3]) << 16) |
758 ((u32)(srb->cmnd[4]) << 8) | ((u32)(srb->cmnd[5]));
759
760 blocks = ((u32)(srb->cmnd[7]) << 8) | ((u32)(srb->cmnd[8]));
761
762 US_DEBUGP("datafab_transport: WRITE_10: write block 0x%04lx count %ld\n", block, blocks);
763 return datafab_write_data(us, info, block, blocks, ptr, srb->use_sg);
764 }
765
766 if (srb->cmnd[0] == WRITE_12) {
767 // we'll probably never see a WRITE_12 but we'll do it anyway...
768 //
769 block = ((u32)(srb->cmnd[2]) << 24) | ((u32)(srb->cmnd[3]) << 16) |
770 ((u32)(srb->cmnd[4]) << 8) | ((u32)(srb->cmnd[5]));
771
772 blocks = ((u32)(srb->cmnd[6]) << 24) | ((u32)(srb->cmnd[7]) << 16) |
773 ((u32)(srb->cmnd[8]) << 8) | ((u32)(srb->cmnd[9]));
774
775 US_DEBUGP("datafab_transport: WRITE_12: write block 0x%04lx count %ld\n", block, blocks);
776 return datafab_write_data(us, info, block, blocks, ptr, srb->use_sg);
777 }
778
779 if (srb->cmnd[0] == TEST_UNIT_READY) {
780 US_DEBUGP("datafab_transport: TEST_UNIT_READY.\n");
781 return datafab_id_device(us, info);
782 }
783
784 if (srb->cmnd[0] == REQUEST_SENSE) {
785 US_DEBUGP("datafab_transport: REQUEST_SENSE. Returning faked response\n");
786
787 // this response is pretty bogus right now. eventually if necessary
788 // we can set the correct sense data. so far though it hasn't been
789 // necessary
790 //
791 ptr[0] = 0xF0;
792 ptr[2] = info->sense_key;
793 ptr[7] = 11;
794 ptr[12] = info->sense_asc;
795 ptr[13] = info->sense_ascq;
796
797 return USB_STOR_TRANSPORT_GOOD;
798 }
799
800 if (srb->cmnd[0] == MODE_SENSE) {
801 US_DEBUGP("datafab_transport: MODE_SENSE_6 detected\n");
802 return datafab_handle_mode_sense(us, srb, ptr, TRUE);
803 }
804
805 if (srb->cmnd[0] == MODE_SENSE_10) {
806 US_DEBUGP("datafab_transport: MODE_SENSE_10 detected\n");
807 return datafab_handle_mode_sense(us, srb, ptr, FALSE);
808 }
809
810 if (srb->cmnd[0] == ALLOW_MEDIUM_REMOVAL) {
811 // sure. whatever. not like we can stop the user from
812 // popping the media out of the device (no locking doors, etc)
813 //
814 return USB_STOR_TRANSPORT_GOOD;
815 }
816
817 if (srb->cmnd[0] == START_STOP) {
818 /* this is used by sd.c'check_scsidisk_media_change to detect
819 media change */
820 US_DEBUGP("datafab_transport: START_STOP.\n");
821 /* the first datafab_id_device after a media change returns
822 an error (determined experimentally) */
823 rc = datafab_id_device(us, info);
824 if (rc == USB_STOR_TRANSPORT_GOOD) {
825 info->sense_key = NO_SENSE;
826 srb->result = SUCCESS;
827 } else {
828 info->sense_key = UNIT_ATTENTION;
829 srb->result = CHECK_CONDITION;
830 }
831 return rc;
832 }
833
834 US_DEBUGP("datafab_transport: Gah! Unknown command: %d (0x%x)\n", srb->cmnd[0], srb->cmnd[0]);
835 return USB_STOR_TRANSPORT_ERROR;
836 }
837