xref: /linux/drivers/usb/storage/datafab.c (revision 048c9acca90ca7da42b92745445fe008a48add88)
1 /* Driver for Datafab USB Compact Flash reader
2  *
3  * datafab driver v0.1:
4  *
5  * First release
6  *
7  * Current development and maintenance by:
8  *   (c) 2000 Jimmie Mayfield (mayfield+datafab@sackheads.org)
9  *
10  *   Many thanks to Robert Baruch for the SanDisk SmartMedia reader driver
11  *   which I used as a template for this driver.
12  *
13  *   Some bugfixes and scatter-gather code by Gregory P. Smith
14  *   (greg-usb@electricrain.com)
15  *
16  *   Fix for media change by Joerg Schneider (js@joergschneider.com)
17  *
18  * Other contributors:
19  *   (c) 2002 Alan Stern <stern@rowland.org>
20  *
21  * This program is free software; you can redistribute it and/or modify it
22  * under the terms of the GNU General Public License as published by the
23  * Free Software Foundation; either version 2, or (at your option) any
24  * later version.
25  *
26  * This program is distributed in the hope that it will be useful, but
27  * WITHOUT ANY WARRANTY; without even the implied warranty of
28  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
29  * General Public License for more details.
30  *
31  * You should have received a copy of the GNU General Public License along
32  * with this program; if not, write to the Free Software Foundation, Inc.,
33  * 675 Mass Ave, Cambridge, MA 02139, USA.
34  */
35 
36 /*
37  * This driver attempts to support USB CompactFlash reader/writer devices
38  * based on Datafab USB-to-ATA chips.  It was specifically developed for the
39  * Datafab MDCFE-B USB CompactFlash reader but has since been found to work
40  * with a variety of Datafab-based devices from a number of manufacturers.
41  * I've received a report of this driver working with a Datafab-based
42  * SmartMedia device though please be aware that I'm personally unable to
43  * test SmartMedia support.
44  *
45  * This driver supports reading and writing.  If you're truly paranoid,
46  * however, you can force the driver into a write-protected state by setting
47  * the WP enable bits in datafab_handle_mode_sense().  See the comments
48  * in that routine.
49  */
50 
51 #include <linux/errno.h>
52 #include <linux/module.h>
53 #include <linux/slab.h>
54 
55 #include <scsi/scsi.h>
56 #include <scsi/scsi_cmnd.h>
57 
58 #include "usb.h"
59 #include "transport.h"
60 #include "protocol.h"
61 #include "debug.h"
62 
63 MODULE_DESCRIPTION("Driver for Datafab USB Compact Flash reader");
64 MODULE_AUTHOR("Jimmie Mayfield <mayfield+datafab@sackheads.org>");
65 MODULE_LICENSE("GPL");
66 
67 struct datafab_info {
68 	unsigned long   sectors;	/* total sector count */
69 	unsigned long   ssize;		/* sector size in bytes */
70 	signed char	lun;		/* used for dual-slot readers */
71 
72 	/* the following aren't used yet */
73 	unsigned char   sense_key;
74 	unsigned long   sense_asc;	/* additional sense code */
75 	unsigned long   sense_ascq;	/* additional sense code qualifier */
76 };
77 
78 static int datafab_determine_lun(struct us_data *us,
79 				 struct datafab_info *info);
80 
81 
82 /*
83  * The table of devices
84  */
85 #define UNUSUAL_DEV(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax, \
86 		    vendorName, productName, useProtocol, useTransport, \
87 		    initFunction, flags) \
88 { USB_DEVICE_VER(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax), \
89   .driver_info = (flags) }
90 
91 static struct usb_device_id datafab_usb_ids[] = {
92 #	include "unusual_datafab.h"
93 	{ }		/* Terminating entry */
94 };
95 MODULE_DEVICE_TABLE(usb, datafab_usb_ids);
96 
97 #undef UNUSUAL_DEV
98 
99 /*
100  * The flags table
101  */
102 #define UNUSUAL_DEV(idVendor, idProduct, bcdDeviceMin, bcdDeviceMax, \
103 		    vendor_name, product_name, use_protocol, use_transport, \
104 		    init_function, Flags) \
105 { \
106 	.vendorName = vendor_name,	\
107 	.productName = product_name,	\
108 	.useProtocol = use_protocol,	\
109 	.useTransport = use_transport,	\
110 	.initFunction = init_function,	\
111 }
112 
113 static struct us_unusual_dev datafab_unusual_dev_list[] = {
114 #	include "unusual_datafab.h"
115 	{ }		/* Terminating entry */
116 };
117 
118 #undef UNUSUAL_DEV
119 
120 
121 static inline int
122 datafab_bulk_read(struct us_data *us, unsigned char *data, unsigned int len) {
123 	if (len == 0)
124 		return USB_STOR_XFER_GOOD;
125 
126 	usb_stor_dbg(us, "len = %d\n", len);
127 	return usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe,
128 			data, len, NULL);
129 }
130 
131 
132 static inline int
133 datafab_bulk_write(struct us_data *us, unsigned char *data, unsigned int len) {
134 	if (len == 0)
135 		return USB_STOR_XFER_GOOD;
136 
137 	usb_stor_dbg(us, "len = %d\n", len);
138 	return usb_stor_bulk_transfer_buf(us, us->send_bulk_pipe,
139 			data, len, NULL);
140 }
141 
142 
143 static int datafab_read_data(struct us_data *us,
144 			     struct datafab_info *info,
145 			     u32 sector,
146 			     u32 sectors)
147 {
148 	unsigned char *command = us->iobuf;
149 	unsigned char *buffer;
150 	unsigned char  thistime;
151 	unsigned int totallen, alloclen;
152 	int len, result;
153 	unsigned int sg_offset = 0;
154 	struct scatterlist *sg = NULL;
155 
156 	// we're working in LBA mode.  according to the ATA spec,
157 	// we can support up to 28-bit addressing.  I don't know if Datafab
158 	// supports beyond 24-bit addressing.  It's kind of hard to test
159 	// since it requires > 8GB CF card.
160 	//
161 	if (sectors > 0x0FFFFFFF)
162 		return USB_STOR_TRANSPORT_ERROR;
163 
164 	if (info->lun == -1) {
165 		result = datafab_determine_lun(us, info);
166 		if (result != USB_STOR_TRANSPORT_GOOD)
167 			return result;
168 	}
169 
170 	totallen = sectors * info->ssize;
171 
172 	// Since we don't read more than 64 KB at a time, we have to create
173 	// a bounce buffer and move the data a piece at a time between the
174 	// bounce buffer and the actual transfer buffer.
175 
176 	alloclen = min(totallen, 65536u);
177 	buffer = kmalloc(alloclen, GFP_NOIO);
178 	if (buffer == NULL)
179 		return USB_STOR_TRANSPORT_ERROR;
180 
181 	do {
182 		// loop, never allocate or transfer more than 64k at once
183 		// (min(128k, 255*info->ssize) is the real limit)
184 
185 		len = min(totallen, alloclen);
186 		thistime = (len / info->ssize) & 0xff;
187 
188 		command[0] = 0;
189 		command[1] = thistime;
190 		command[2] = sector & 0xFF;
191 		command[3] = (sector >> 8) & 0xFF;
192 		command[4] = (sector >> 16) & 0xFF;
193 
194 		command[5] = 0xE0 + (info->lun << 4);
195 		command[5] |= (sector >> 24) & 0x0F;
196 		command[6] = 0x20;
197 		command[7] = 0x01;
198 
199 		// send the read command
200 		result = datafab_bulk_write(us, command, 8);
201 		if (result != USB_STOR_XFER_GOOD)
202 			goto leave;
203 
204 		// read the result
205 		result = datafab_bulk_read(us, buffer, len);
206 		if (result != USB_STOR_XFER_GOOD)
207 			goto leave;
208 
209 		// Store the data in the transfer buffer
210 		usb_stor_access_xfer_buf(buffer, len, us->srb,
211 				 &sg, &sg_offset, TO_XFER_BUF);
212 
213 		sector += thistime;
214 		totallen -= len;
215 	} while (totallen > 0);
216 
217 	kfree(buffer);
218 	return USB_STOR_TRANSPORT_GOOD;
219 
220  leave:
221 	kfree(buffer);
222 	return USB_STOR_TRANSPORT_ERROR;
223 }
224 
225 
226 static int datafab_write_data(struct us_data *us,
227 			      struct datafab_info *info,
228 			      u32 sector,
229 			      u32 sectors)
230 {
231 	unsigned char *command = us->iobuf;
232 	unsigned char *reply = us->iobuf;
233 	unsigned char *buffer;
234 	unsigned char thistime;
235 	unsigned int totallen, alloclen;
236 	int len, result;
237 	unsigned int sg_offset = 0;
238 	struct scatterlist *sg = NULL;
239 
240 	// we're working in LBA mode.  according to the ATA spec,
241 	// we can support up to 28-bit addressing.  I don't know if Datafab
242 	// supports beyond 24-bit addressing.  It's kind of hard to test
243 	// since it requires > 8GB CF card.
244 	//
245 	if (sectors > 0x0FFFFFFF)
246 		return USB_STOR_TRANSPORT_ERROR;
247 
248 	if (info->lun == -1) {
249 		result = datafab_determine_lun(us, info);
250 		if (result != USB_STOR_TRANSPORT_GOOD)
251 			return result;
252 	}
253 
254 	totallen = sectors * info->ssize;
255 
256 	// Since we don't write more than 64 KB at a time, we have to create
257 	// a bounce buffer and move the data a piece at a time between the
258 	// bounce buffer and the actual transfer buffer.
259 
260 	alloclen = min(totallen, 65536u);
261 	buffer = kmalloc(alloclen, GFP_NOIO);
262 	if (buffer == NULL)
263 		return USB_STOR_TRANSPORT_ERROR;
264 
265 	do {
266 		// loop, never allocate or transfer more than 64k at once
267 		// (min(128k, 255*info->ssize) is the real limit)
268 
269 		len = min(totallen, alloclen);
270 		thistime = (len / info->ssize) & 0xff;
271 
272 		// Get the data from the transfer buffer
273 		usb_stor_access_xfer_buf(buffer, len, us->srb,
274 				&sg, &sg_offset, FROM_XFER_BUF);
275 
276 		command[0] = 0;
277 		command[1] = thistime;
278 		command[2] = sector & 0xFF;
279 		command[3] = (sector >> 8) & 0xFF;
280 		command[4] = (sector >> 16) & 0xFF;
281 
282 		command[5] = 0xE0 + (info->lun << 4);
283 		command[5] |= (sector >> 24) & 0x0F;
284 		command[6] = 0x30;
285 		command[7] = 0x02;
286 
287 		// send the command
288 		result = datafab_bulk_write(us, command, 8);
289 		if (result != USB_STOR_XFER_GOOD)
290 			goto leave;
291 
292 		// send the data
293 		result = datafab_bulk_write(us, buffer, len);
294 		if (result != USB_STOR_XFER_GOOD)
295 			goto leave;
296 
297 		// read the result
298 		result = datafab_bulk_read(us, reply, 2);
299 		if (result != USB_STOR_XFER_GOOD)
300 			goto leave;
301 
302 		if (reply[0] != 0x50 && reply[1] != 0) {
303 			usb_stor_dbg(us, "Gah! write return code: %02x %02x\n",
304 				     reply[0], reply[1]);
305 			result = USB_STOR_TRANSPORT_ERROR;
306 			goto leave;
307 		}
308 
309 		sector += thistime;
310 		totallen -= len;
311 	} while (totallen > 0);
312 
313 	kfree(buffer);
314 	return USB_STOR_TRANSPORT_GOOD;
315 
316  leave:
317 	kfree(buffer);
318 	return USB_STOR_TRANSPORT_ERROR;
319 }
320 
321 
322 static int datafab_determine_lun(struct us_data *us,
323 				 struct datafab_info *info)
324 {
325 	// Dual-slot readers can be thought of as dual-LUN devices.
326 	// We need to determine which card slot is being used.
327 	// We'll send an IDENTIFY DEVICE command and see which LUN responds...
328 	//
329 	// There might be a better way of doing this?
330 
331 	static unsigned char scommand[8] = { 0, 1, 0, 0, 0, 0xa0, 0xec, 1 };
332 	unsigned char *command = us->iobuf;
333 	unsigned char *buf;
334 	int count = 0, rc;
335 
336 	if (!info)
337 		return USB_STOR_TRANSPORT_ERROR;
338 
339 	memcpy(command, scommand, 8);
340 	buf = kmalloc(512, GFP_NOIO);
341 	if (!buf)
342 		return USB_STOR_TRANSPORT_ERROR;
343 
344 	usb_stor_dbg(us, "locating...\n");
345 
346 	// we'll try 3 times before giving up...
347 	//
348 	while (count++ < 3) {
349 		command[5] = 0xa0;
350 
351 		rc = datafab_bulk_write(us, command, 8);
352 		if (rc != USB_STOR_XFER_GOOD) {
353 			rc = USB_STOR_TRANSPORT_ERROR;
354 			goto leave;
355 		}
356 
357 		rc = datafab_bulk_read(us, buf, 512);
358 		if (rc == USB_STOR_XFER_GOOD) {
359 			info->lun = 0;
360 			rc = USB_STOR_TRANSPORT_GOOD;
361 			goto leave;
362 		}
363 
364 		command[5] = 0xb0;
365 
366 		rc = datafab_bulk_write(us, command, 8);
367 		if (rc != USB_STOR_XFER_GOOD) {
368 			rc = USB_STOR_TRANSPORT_ERROR;
369 			goto leave;
370 		}
371 
372 		rc = datafab_bulk_read(us, buf, 512);
373 		if (rc == USB_STOR_XFER_GOOD) {
374 			info->lun = 1;
375 			rc = USB_STOR_TRANSPORT_GOOD;
376 			goto leave;
377 		}
378 
379 		msleep(20);
380 	}
381 
382 	rc = USB_STOR_TRANSPORT_ERROR;
383 
384  leave:
385 	kfree(buf);
386 	return rc;
387 }
388 
389 static int datafab_id_device(struct us_data *us,
390 			     struct datafab_info *info)
391 {
392 	// this is a variation of the ATA "IDENTIFY DEVICE" command...according
393 	// to the ATA spec, 'Sector Count' isn't used but the Windows driver
394 	// sets this bit so we do too...
395 	//
396 	static unsigned char scommand[8] = { 0, 1, 0, 0, 0, 0xa0, 0xec, 1 };
397 	unsigned char *command = us->iobuf;
398 	unsigned char *reply;
399 	int rc;
400 
401 	if (!info)
402 		return USB_STOR_TRANSPORT_ERROR;
403 
404 	if (info->lun == -1) {
405 		rc = datafab_determine_lun(us, info);
406 		if (rc != USB_STOR_TRANSPORT_GOOD)
407 			return rc;
408 	}
409 
410 	memcpy(command, scommand, 8);
411 	reply = kmalloc(512, GFP_NOIO);
412 	if (!reply)
413 		return USB_STOR_TRANSPORT_ERROR;
414 
415 	command[5] += (info->lun << 4);
416 
417 	rc = datafab_bulk_write(us, command, 8);
418 	if (rc != USB_STOR_XFER_GOOD) {
419 		rc = USB_STOR_TRANSPORT_ERROR;
420 		goto leave;
421 	}
422 
423 	// we'll go ahead and extract the media capacity while we're here...
424 	//
425 	rc = datafab_bulk_read(us, reply, 512);
426 	if (rc == USB_STOR_XFER_GOOD) {
427 		// capacity is at word offset 57-58
428 		//
429 		info->sectors = ((u32)(reply[117]) << 24) |
430 				((u32)(reply[116]) << 16) |
431 				((u32)(reply[115]) <<  8) |
432 				((u32)(reply[114])      );
433 		rc = USB_STOR_TRANSPORT_GOOD;
434 		goto leave;
435 	}
436 
437 	rc = USB_STOR_TRANSPORT_ERROR;
438 
439  leave:
440 	kfree(reply);
441 	return rc;
442 }
443 
444 
445 static int datafab_handle_mode_sense(struct us_data *us,
446 				     struct scsi_cmnd * srb,
447 				     int sense_6)
448 {
449 	static unsigned char rw_err_page[12] = {
450 		0x1, 0xA, 0x21, 1, 0, 0, 0, 0, 1, 0, 0, 0
451 	};
452 	static unsigned char cache_page[12] = {
453 		0x8, 0xA, 0x1, 0, 0, 0, 0, 0, 0, 0, 0, 0
454 	};
455 	static unsigned char rbac_page[12] = {
456 		0x1B, 0xA, 0, 0x81, 0, 0, 0, 0, 0, 0, 0, 0
457 	};
458 	static unsigned char timer_page[8] = {
459 		0x1C, 0x6, 0, 0, 0, 0
460 	};
461 	unsigned char pc, page_code;
462 	unsigned int i = 0;
463 	struct datafab_info *info = (struct datafab_info *) (us->extra);
464 	unsigned char *ptr = us->iobuf;
465 
466 	// most of this stuff is just a hack to get things working.  the
467 	// datafab reader doesn't present a SCSI interface so we
468 	// fudge the SCSI commands...
469 	//
470 
471 	pc = srb->cmnd[2] >> 6;
472 	page_code = srb->cmnd[2] & 0x3F;
473 
474 	switch (pc) {
475 	   case 0x0:
476 		   usb_stor_dbg(us, "Current values\n");
477 		break;
478 	   case 0x1:
479 		   usb_stor_dbg(us, "Changeable values\n");
480 		break;
481 	   case 0x2:
482 		   usb_stor_dbg(us, "Default values\n");
483 		break;
484 	   case 0x3:
485 		   usb_stor_dbg(us, "Saves values\n");
486 		break;
487 	}
488 
489 	memset(ptr, 0, 8);
490 	if (sense_6) {
491 		ptr[2] = 0x00;		// WP enable: 0x80
492 		i = 4;
493 	} else {
494 		ptr[3] = 0x00;		// WP enable: 0x80
495 		i = 8;
496 	}
497 
498 	switch (page_code) {
499 	   default:
500 		// vendor-specific mode
501 		info->sense_key = 0x05;
502 		info->sense_asc = 0x24;
503 		info->sense_ascq = 0x00;
504 		return USB_STOR_TRANSPORT_FAILED;
505 
506 	   case 0x1:
507 		memcpy(ptr + i, rw_err_page, sizeof(rw_err_page));
508 		i += sizeof(rw_err_page);
509 		break;
510 
511 	   case 0x8:
512 		memcpy(ptr + i, cache_page, sizeof(cache_page));
513 		i += sizeof(cache_page);
514 		break;
515 
516 	   case 0x1B:
517 		memcpy(ptr + i, rbac_page, sizeof(rbac_page));
518 		i += sizeof(rbac_page);
519 		break;
520 
521 	   case 0x1C:
522 		memcpy(ptr + i, timer_page, sizeof(timer_page));
523 		i += sizeof(timer_page);
524 		break;
525 
526 	   case 0x3F:		// retrieve all pages
527 		memcpy(ptr + i, timer_page, sizeof(timer_page));
528 		i += sizeof(timer_page);
529 		memcpy(ptr + i, rbac_page, sizeof(rbac_page));
530 		i += sizeof(rbac_page);
531 		memcpy(ptr + i, cache_page, sizeof(cache_page));
532 		i += sizeof(cache_page);
533 		memcpy(ptr + i, rw_err_page, sizeof(rw_err_page));
534 		i += sizeof(rw_err_page);
535 		break;
536 	}
537 
538 	if (sense_6)
539 		ptr[0] = i - 1;
540 	else
541 		((__be16 *) ptr)[0] = cpu_to_be16(i - 2);
542 	usb_stor_set_xfer_buf(ptr, i, srb);
543 
544 	return USB_STOR_TRANSPORT_GOOD;
545 }
546 
547 static void datafab_info_destructor(void *extra)
548 {
549 	// this routine is a placeholder...
550 	// currently, we don't allocate any extra memory so we're okay
551 }
552 
553 
554 // Transport for the Datafab MDCFE-B
555 //
556 static int datafab_transport(struct scsi_cmnd *srb, struct us_data *us)
557 {
558 	struct datafab_info *info;
559 	int rc;
560 	unsigned long block, blocks;
561 	unsigned char *ptr = us->iobuf;
562 	static unsigned char inquiry_reply[8] = {
563 		0x00, 0x80, 0x00, 0x01, 0x1F, 0x00, 0x00, 0x00
564 	};
565 
566 	if (!us->extra) {
567 		us->extra = kzalloc(sizeof(struct datafab_info), GFP_NOIO);
568 		if (!us->extra)
569 			return USB_STOR_TRANSPORT_ERROR;
570 
571 		us->extra_destructor = datafab_info_destructor;
572   		((struct datafab_info *)us->extra)->lun = -1;
573 	}
574 
575 	info = (struct datafab_info *) (us->extra);
576 
577 	if (srb->cmnd[0] == INQUIRY) {
578 		usb_stor_dbg(us, "INQUIRY - Returning bogus response\n");
579 		memcpy(ptr, inquiry_reply, sizeof(inquiry_reply));
580 		fill_inquiry_response(us, ptr, 36);
581 		return USB_STOR_TRANSPORT_GOOD;
582 	}
583 
584 	if (srb->cmnd[0] == READ_CAPACITY) {
585 		info->ssize = 0x200;  // hard coded 512 byte sectors as per ATA spec
586 		rc = datafab_id_device(us, info);
587 		if (rc != USB_STOR_TRANSPORT_GOOD)
588 			return rc;
589 
590 		usb_stor_dbg(us, "READ_CAPACITY:  %ld sectors, %ld bytes per sector\n",
591 			     info->sectors, info->ssize);
592 
593 		// build the reply
594 		// we need the last sector, not the number of sectors
595 		((__be32 *) ptr)[0] = cpu_to_be32(info->sectors - 1);
596 		((__be32 *) ptr)[1] = cpu_to_be32(info->ssize);
597 		usb_stor_set_xfer_buf(ptr, 8, srb);
598 
599 		return USB_STOR_TRANSPORT_GOOD;
600 	}
601 
602 	if (srb->cmnd[0] == MODE_SELECT_10) {
603 		usb_stor_dbg(us, "Gah! MODE_SELECT_10\n");
604 		return USB_STOR_TRANSPORT_ERROR;
605 	}
606 
607 	// don't bother implementing READ_6 or WRITE_6.
608 	//
609 	if (srb->cmnd[0] == READ_10) {
610 		block = ((u32)(srb->cmnd[2]) << 24) | ((u32)(srb->cmnd[3]) << 16) |
611 			((u32)(srb->cmnd[4]) <<  8) | ((u32)(srb->cmnd[5]));
612 
613 		blocks = ((u32)(srb->cmnd[7]) << 8) | ((u32)(srb->cmnd[8]));
614 
615 		usb_stor_dbg(us, "READ_10: read block 0x%04lx  count %ld\n",
616 			     block, blocks);
617 		return datafab_read_data(us, info, block, blocks);
618 	}
619 
620 	if (srb->cmnd[0] == READ_12) {
621 		// we'll probably never see a READ_12 but we'll do it anyway...
622 		//
623 		block = ((u32)(srb->cmnd[2]) << 24) | ((u32)(srb->cmnd[3]) << 16) |
624 			((u32)(srb->cmnd[4]) <<  8) | ((u32)(srb->cmnd[5]));
625 
626 		blocks = ((u32)(srb->cmnd[6]) << 24) | ((u32)(srb->cmnd[7]) << 16) |
627 			 ((u32)(srb->cmnd[8]) <<  8) | ((u32)(srb->cmnd[9]));
628 
629 		usb_stor_dbg(us, "READ_12: read block 0x%04lx  count %ld\n",
630 			     block, blocks);
631 		return datafab_read_data(us, info, block, blocks);
632 	}
633 
634 	if (srb->cmnd[0] == WRITE_10) {
635 		block = ((u32)(srb->cmnd[2]) << 24) | ((u32)(srb->cmnd[3]) << 16) |
636 			((u32)(srb->cmnd[4]) <<  8) | ((u32)(srb->cmnd[5]));
637 
638 		blocks = ((u32)(srb->cmnd[7]) << 8) | ((u32)(srb->cmnd[8]));
639 
640 		usb_stor_dbg(us, "WRITE_10: write block 0x%04lx count %ld\n",
641 			     block, blocks);
642 		return datafab_write_data(us, info, block, blocks);
643 	}
644 
645 	if (srb->cmnd[0] == WRITE_12) {
646 		// we'll probably never see a WRITE_12 but we'll do it anyway...
647 		//
648 		block = ((u32)(srb->cmnd[2]) << 24) | ((u32)(srb->cmnd[3]) << 16) |
649 			((u32)(srb->cmnd[4]) <<  8) | ((u32)(srb->cmnd[5]));
650 
651 		blocks = ((u32)(srb->cmnd[6]) << 24) | ((u32)(srb->cmnd[7]) << 16) |
652 			 ((u32)(srb->cmnd[8]) <<  8) | ((u32)(srb->cmnd[9]));
653 
654 		usb_stor_dbg(us, "WRITE_12: write block 0x%04lx count %ld\n",
655 			     block, blocks);
656 		return datafab_write_data(us, info, block, blocks);
657 	}
658 
659 	if (srb->cmnd[0] == TEST_UNIT_READY) {
660 		usb_stor_dbg(us, "TEST_UNIT_READY\n");
661 		return datafab_id_device(us, info);
662 	}
663 
664 	if (srb->cmnd[0] == REQUEST_SENSE) {
665 		usb_stor_dbg(us, "REQUEST_SENSE - Returning faked response\n");
666 
667 		// this response is pretty bogus right now.  eventually if necessary
668 		// we can set the correct sense data.  so far though it hasn't been
669 		// necessary
670 		//
671 		memset(ptr, 0, 18);
672 		ptr[0] = 0xF0;
673 		ptr[2] = info->sense_key;
674 		ptr[7] = 11;
675 		ptr[12] = info->sense_asc;
676 		ptr[13] = info->sense_ascq;
677 		usb_stor_set_xfer_buf(ptr, 18, srb);
678 
679 		return USB_STOR_TRANSPORT_GOOD;
680 	}
681 
682 	if (srb->cmnd[0] == MODE_SENSE) {
683 		usb_stor_dbg(us, "MODE_SENSE_6 detected\n");
684 		return datafab_handle_mode_sense(us, srb, 1);
685 	}
686 
687 	if (srb->cmnd[0] == MODE_SENSE_10) {
688 		usb_stor_dbg(us, "MODE_SENSE_10 detected\n");
689 		return datafab_handle_mode_sense(us, srb, 0);
690 	}
691 
692 	if (srb->cmnd[0] == ALLOW_MEDIUM_REMOVAL) {
693 		// sure.  whatever.  not like we can stop the user from
694 		// popping the media out of the device (no locking doors, etc)
695 		//
696 		return USB_STOR_TRANSPORT_GOOD;
697 	}
698 
699 	if (srb->cmnd[0] == START_STOP) {
700 		/* this is used by sd.c'check_scsidisk_media_change to detect
701 		   media change */
702 		usb_stor_dbg(us, "START_STOP\n");
703 		/* the first datafab_id_device after a media change returns
704 		   an error (determined experimentally) */
705 		rc = datafab_id_device(us, info);
706 		if (rc == USB_STOR_TRANSPORT_GOOD) {
707 			info->sense_key = NO_SENSE;
708 			srb->result = SUCCESS;
709 		} else {
710 			info->sense_key = UNIT_ATTENTION;
711 			srb->result = SAM_STAT_CHECK_CONDITION;
712 		}
713 		return rc;
714 	}
715 
716 	usb_stor_dbg(us, "Gah! Unknown command: %d (0x%x)\n",
717 		     srb->cmnd[0], srb->cmnd[0]);
718 	info->sense_key = 0x05;
719 	info->sense_asc = 0x20;
720 	info->sense_ascq = 0x00;
721 	return USB_STOR_TRANSPORT_FAILED;
722 }
723 
724 static int datafab_probe(struct usb_interface *intf,
725 			 const struct usb_device_id *id)
726 {
727 	struct us_data *us;
728 	int result;
729 
730 	result = usb_stor_probe1(&us, intf, id,
731 			(id - datafab_usb_ids) + datafab_unusual_dev_list);
732 	if (result)
733 		return result;
734 
735 	us->transport_name  = "Datafab Bulk-Only";
736 	us->transport = datafab_transport;
737 	us->transport_reset = usb_stor_Bulk_reset;
738 	us->max_lun = 1;
739 
740 	result = usb_stor_probe2(us);
741 	return result;
742 }
743 
744 static struct usb_driver datafab_driver = {
745 	.name =		"ums-datafab",
746 	.probe =	datafab_probe,
747 	.disconnect =	usb_stor_disconnect,
748 	.suspend =	usb_stor_suspend,
749 	.resume =	usb_stor_resume,
750 	.reset_resume =	usb_stor_reset_resume,
751 	.pre_reset =	usb_stor_pre_reset,
752 	.post_reset =	usb_stor_post_reset,
753 	.id_table =	datafab_usb_ids,
754 	.soft_unbind =	1,
755 	.no_dynamic_id = 1,
756 };
757 
758 module_usb_driver(datafab_driver);
759