1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3  * Driver for SCM Microsystems (a.k.a. Shuttle) USB-ATAPI cable
4  *
5  * Current development and maintenance by:
6  *   (c) 2000, 2001 Robert Baruch (autophile@starband.net)
7  *   (c) 2004, 2005 Daniel Drake <dsd@gentoo.org>
8  *
9  * Developed with the assistance of:
10  *   (c) 2002 Alan Stern <stern@rowland.org>
11  *
12  * Flash support based on earlier work by:
13  *   (c) 2002 Thomas Kreiling <usbdev@sm04.de>
14  *
15  * Many originally ATAPI devices were slightly modified to meet the USB
16  * market by using some kind of translation from ATAPI to USB on the host,
17  * and the peripheral would translate from USB back to ATAPI.
18  *
19  * SCM Microsystems (www.scmmicro.com) makes a device, sold to OEM's only,
20  * which does the USB-to-ATAPI conversion.  By obtaining the data sheet on
21  * their device under nondisclosure agreement, I have been able to write
22  * this driver for Linux.
23  *
24  * The chip used in the device can also be used for EPP and ISA translation
25  * as well. This driver is only guaranteed to work with the ATAPI
26  * translation.
27  *
28  * See the Kconfig help text for a list of devices known to be supported by
29  * this driver.
30  */
31 
32 #include <linux/errno.h>
33 #include <linux/module.h>
34 #include <linux/slab.h>
35 #include <linux/cdrom.h>
36 
37 #include <scsi/scsi.h>
38 #include <scsi/scsi_cmnd.h>
39 
40 #include "usb.h"
41 #include "transport.h"
42 #include "protocol.h"
43 #include "debug.h"
44 #include "scsiglue.h"
45 
46 #define DRV_NAME "ums-usbat"
47 
48 MODULE_DESCRIPTION("Driver for SCM Microsystems (a.k.a. Shuttle) USB-ATAPI cable");
49 MODULE_AUTHOR("Daniel Drake <dsd@gentoo.org>, Robert Baruch <autophile@starband.net>");
50 MODULE_LICENSE("GPL");
51 MODULE_IMPORT_NS(USB_STORAGE);
52 
53 /* Supported device types */
54 #define USBAT_DEV_HP8200	0x01
55 #define USBAT_DEV_FLASH		0x02
56 
57 #define USBAT_EPP_PORT		0x10
58 #define USBAT_EPP_REGISTER	0x30
59 #define USBAT_ATA		0x40
60 #define USBAT_ISA		0x50
61 
62 /* Commands (need to be logically OR'd with an access type */
63 #define USBAT_CMD_READ_REG		0x00
64 #define USBAT_CMD_WRITE_REG		0x01
65 #define USBAT_CMD_READ_BLOCK	0x02
66 #define USBAT_CMD_WRITE_BLOCK	0x03
67 #define USBAT_CMD_COND_READ_BLOCK	0x04
68 #define USBAT_CMD_COND_WRITE_BLOCK	0x05
69 #define USBAT_CMD_WRITE_REGS	0x07
70 
71 /* Commands (these don't need an access type) */
72 #define USBAT_CMD_EXEC_CMD	0x80
73 #define USBAT_CMD_SET_FEAT	0x81
74 #define USBAT_CMD_UIO		0x82
75 
76 /* Methods of accessing UIO register */
77 #define USBAT_UIO_READ	1
78 #define USBAT_UIO_WRITE	0
79 
80 /* Qualifier bits */
81 #define USBAT_QUAL_FCQ	0x20	/* full compare */
82 #define USBAT_QUAL_ALQ	0x10	/* auto load subcount */
83 
84 /* USBAT Flash Media status types */
85 #define USBAT_FLASH_MEDIA_NONE	0
86 #define USBAT_FLASH_MEDIA_CF	1
87 
88 /* USBAT Flash Media change types */
89 #define USBAT_FLASH_MEDIA_SAME	0
90 #define USBAT_FLASH_MEDIA_CHANGED	1
91 
92 /* USBAT ATA registers */
93 #define USBAT_ATA_DATA      0x10  /* read/write data (R/W) */
94 #define USBAT_ATA_FEATURES  0x11  /* set features (W) */
95 #define USBAT_ATA_ERROR     0x11  /* error (R) */
96 #define USBAT_ATA_SECCNT    0x12  /* sector count (R/W) */
97 #define USBAT_ATA_SECNUM    0x13  /* sector number (R/W) */
98 #define USBAT_ATA_LBA_ME    0x14  /* cylinder low (R/W) */
99 #define USBAT_ATA_LBA_HI    0x15  /* cylinder high (R/W) */
100 #define USBAT_ATA_DEVICE    0x16  /* head/device selection (R/W) */
101 #define USBAT_ATA_STATUS    0x17  /* device status (R) */
102 #define USBAT_ATA_CMD       0x17  /* device command (W) */
103 #define USBAT_ATA_ALTSTATUS 0x0E  /* status (no clear IRQ) (R) */
104 
105 /* USBAT User I/O Data registers */
106 #define USBAT_UIO_EPAD		0x80 /* Enable Peripheral Control Signals */
107 #define USBAT_UIO_CDT		0x40 /* Card Detect (Read Only) */
108 				     /* CDT = ACKD & !UI1 & !UI0 */
109 #define USBAT_UIO_1		0x20 /* I/O 1 */
110 #define USBAT_UIO_0		0x10 /* I/O 0 */
111 #define USBAT_UIO_EPP_ATA	0x08 /* 1=EPP mode, 0=ATA mode */
112 #define USBAT_UIO_UI1		0x04 /* Input 1 */
113 #define USBAT_UIO_UI0		0x02 /* Input 0 */
114 #define USBAT_UIO_INTR_ACK	0x01 /* Interrupt (ATA/ISA)/Acknowledge (EPP) */
115 
116 /* USBAT User I/O Enable registers */
117 #define USBAT_UIO_DRVRST	0x80 /* Reset Peripheral */
118 #define USBAT_UIO_ACKD		0x40 /* Enable Card Detect */
119 #define USBAT_UIO_OE1		0x20 /* I/O 1 set=output/clr=input */
120 				     /* If ACKD=1, set OE1 to 1 also. */
121 #define USBAT_UIO_OE0		0x10 /* I/O 0 set=output/clr=input */
122 #define USBAT_UIO_ADPRST	0x01 /* Reset SCM chip */
123 
124 /* USBAT Features */
125 #define USBAT_FEAT_ETEN	0x80	/* External trigger enable */
126 #define USBAT_FEAT_U1	0x08
127 #define USBAT_FEAT_U0	0x04
128 #define USBAT_FEAT_ET1	0x02
129 #define USBAT_FEAT_ET2	0x01
130 
131 struct usbat_info {
132 	int devicetype;
133 
134 	/* Used for Flash readers only */
135 	unsigned long sectors;     /* total sector count */
136 	unsigned long ssize;       /* sector size in bytes */
137 
138 	unsigned char sense_key;
139 	unsigned long sense_asc;   /* additional sense code */
140 	unsigned long sense_ascq;  /* additional sense code qualifier */
141 };
142 
143 #define short_pack(LSB,MSB) ( ((u16)(LSB)) | ( ((u16)(MSB))<<8 ) )
144 #define LSB_of(s) ((s)&0xFF)
145 #define MSB_of(s) ((s)>>8)
146 
147 static int transferred = 0;
148 
149 static int usbat_flash_transport(struct scsi_cmnd * srb, struct us_data *us);
150 static int usbat_hp8200e_transport(struct scsi_cmnd *srb, struct us_data *us);
151 
152 static int init_usbat_cd(struct us_data *us);
153 static int init_usbat_flash(struct us_data *us);
154 
155 
156 /*
157  * The table of devices
158  */
159 #define UNUSUAL_DEV(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax, \
160 		    vendorName, productName, useProtocol, useTransport, \
161 		    initFunction, flags) \
162 { USB_DEVICE_VER(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax), \
163   .driver_info = (flags) }
164 
165 static struct usb_device_id usbat_usb_ids[] = {
166 #	include "unusual_usbat.h"
167 	{ }		/* Terminating entry */
168 };
169 MODULE_DEVICE_TABLE(usb, usbat_usb_ids);
170 
171 #undef UNUSUAL_DEV
172 
173 /*
174  * The flags table
175  */
176 #define UNUSUAL_DEV(idVendor, idProduct, bcdDeviceMin, bcdDeviceMax, \
177 		    vendor_name, product_name, use_protocol, use_transport, \
178 		    init_function, Flags) \
179 { \
180 	.vendorName = vendor_name,	\
181 	.productName = product_name,	\
182 	.useProtocol = use_protocol,	\
183 	.useTransport = use_transport,	\
184 	.initFunction = init_function,	\
185 }
186 
187 static struct us_unusual_dev usbat_unusual_dev_list[] = {
188 #	include "unusual_usbat.h"
189 	{ }		/* Terminating entry */
190 };
191 
192 #undef UNUSUAL_DEV
193 
194 /*
195  * Convenience function to produce an ATA read/write sectors command
196  * Use cmd=0x20 for read, cmd=0x30 for write
197  */
198 static void usbat_pack_ata_sector_cmd(unsigned char *buf,
199 					unsigned char thistime,
200 					u32 sector, unsigned char cmd)
201 {
202 	buf[0] = 0;
203 	buf[1] = thistime;
204 	buf[2] = sector & 0xFF;
205 	buf[3] = (sector >>  8) & 0xFF;
206 	buf[4] = (sector >> 16) & 0xFF;
207 	buf[5] = 0xE0 | ((sector >> 24) & 0x0F);
208 	buf[6] = cmd;
209 }
210 
211 /*
212  * Convenience function to get the device type (flash or hp8200)
213  */
214 static int usbat_get_device_type(struct us_data *us)
215 {
216 	return ((struct usbat_info*)us->extra)->devicetype;
217 }
218 
219 /*
220  * Read a register from the device
221  */
222 static int usbat_read(struct us_data *us,
223 		      unsigned char access,
224 		      unsigned char reg,
225 		      unsigned char *content)
226 {
227 	return usb_stor_ctrl_transfer(us,
228 		us->recv_ctrl_pipe,
229 		access | USBAT_CMD_READ_REG,
230 		0xC0,
231 		(u16)reg,
232 		0,
233 		content,
234 		1);
235 }
236 
237 /*
238  * Write to a register on the device
239  */
240 static int usbat_write(struct us_data *us,
241 		       unsigned char access,
242 		       unsigned char reg,
243 		       unsigned char content)
244 {
245 	return usb_stor_ctrl_transfer(us,
246 		us->send_ctrl_pipe,
247 		access | USBAT_CMD_WRITE_REG,
248 		0x40,
249 		short_pack(reg, content),
250 		0,
251 		NULL,
252 		0);
253 }
254 
255 /*
256  * Convenience function to perform a bulk read
257  */
258 static int usbat_bulk_read(struct us_data *us,
259 			   void* buf,
260 			   unsigned int len,
261 			   int use_sg)
262 {
263 	if (len == 0)
264 		return USB_STOR_XFER_GOOD;
265 
266 	usb_stor_dbg(us, "len = %d\n", len);
267 	return usb_stor_bulk_transfer_sg(us, us->recv_bulk_pipe, buf, len, use_sg, NULL);
268 }
269 
270 /*
271  * Convenience function to perform a bulk write
272  */
273 static int usbat_bulk_write(struct us_data *us,
274 			    void* buf,
275 			    unsigned int len,
276 			    int use_sg)
277 {
278 	if (len == 0)
279 		return USB_STOR_XFER_GOOD;
280 
281 	usb_stor_dbg(us, "len = %d\n", len);
282 	return usb_stor_bulk_transfer_sg(us, us->send_bulk_pipe, buf, len, use_sg, NULL);
283 }
284 
285 /*
286  * Some USBAT-specific commands can only be executed over a command transport
287  * This transport allows one (len=8) or two (len=16) vendor-specific commands
288  * to be executed.
289  */
290 static int usbat_execute_command(struct us_data *us,
291 								 unsigned char *commands,
292 								 unsigned int len)
293 {
294 	return usb_stor_ctrl_transfer(us, us->send_ctrl_pipe,
295 								  USBAT_CMD_EXEC_CMD, 0x40, 0, 0,
296 								  commands, len);
297 }
298 
299 /*
300  * Read the status register
301  */
302 static int usbat_get_status(struct us_data *us, unsigned char *status)
303 {
304 	int rc;
305 	rc = usbat_read(us, USBAT_ATA, USBAT_ATA_STATUS, status);
306 
307 	usb_stor_dbg(us, "0x%02X\n", *status);
308 	return rc;
309 }
310 
311 /*
312  * Check the device status
313  */
314 static int usbat_check_status(struct us_data *us)
315 {
316 	unsigned char *reply = us->iobuf;
317 	int rc;
318 
319 	rc = usbat_get_status(us, reply);
320 	if (rc != USB_STOR_XFER_GOOD)
321 		return USB_STOR_TRANSPORT_FAILED;
322 
323 	/* error/check condition (0x51 is ok) */
324 	if (*reply & 0x01 && *reply != 0x51)
325 		return USB_STOR_TRANSPORT_FAILED;
326 
327 	/* device fault */
328 	if (*reply & 0x20)
329 		return USB_STOR_TRANSPORT_FAILED;
330 
331 	return USB_STOR_TRANSPORT_GOOD;
332 }
333 
334 /*
335  * Stores critical information in internal registers in preparation for the execution
336  * of a conditional usbat_read_blocks or usbat_write_blocks call.
337  */
338 static int usbat_set_shuttle_features(struct us_data *us,
339 				      unsigned char external_trigger,
340 				      unsigned char epp_control,
341 				      unsigned char mask_byte,
342 				      unsigned char test_pattern,
343 				      unsigned char subcountH,
344 				      unsigned char subcountL)
345 {
346 	unsigned char *command = us->iobuf;
347 
348 	command[0] = 0x40;
349 	command[1] = USBAT_CMD_SET_FEAT;
350 
351 	/*
352 	 * The only bit relevant to ATA access is bit 6
353 	 * which defines 8 bit data access (set) or 16 bit (unset)
354 	 */
355 	command[2] = epp_control;
356 
357 	/*
358 	 * If FCQ is set in the qualifier (defined in R/W cmd), then bits U0, U1,
359 	 * ET1 and ET2 define an external event to be checked for on event of a
360 	 * _read_blocks or _write_blocks operation. The read/write will not take
361 	 * place unless the defined trigger signal is active.
362 	 */
363 	command[3] = external_trigger;
364 
365 	/*
366 	 * The resultant byte of the mask operation (see mask_byte) is compared for
367 	 * equivalence with this test pattern. If equal, the read/write will take
368 	 * place.
369 	 */
370 	command[4] = test_pattern;
371 
372 	/*
373 	 * This value is logically ANDed with the status register field specified
374 	 * in the read/write command.
375 	 */
376 	command[5] = mask_byte;
377 
378 	/*
379 	 * If ALQ is set in the qualifier, this field contains the address of the
380 	 * registers where the byte count should be read for transferring the data.
381 	 * If ALQ is not set, then this field contains the number of bytes to be
382 	 * transferred.
383 	 */
384 	command[6] = subcountL;
385 	command[7] = subcountH;
386 
387 	return usbat_execute_command(us, command, 8);
388 }
389 
390 /*
391  * Block, waiting for an ATA device to become not busy or to report
392  * an error condition.
393  */
394 static int usbat_wait_not_busy(struct us_data *us, int minutes)
395 {
396 	int i;
397 	int result;
398 	unsigned char *status = us->iobuf;
399 
400 	/*
401 	 * Synchronizing cache on a CDR could take a heck of a long time,
402 	 * but probably not more than 10 minutes or so. On the other hand,
403 	 * doing a full blank on a CDRW at speed 1 will take about 75
404 	 * minutes!
405 	 */
406 
407 	for (i=0; i<1200+minutes*60; i++) {
408 
409  		result = usbat_get_status(us, status);
410 
411 		if (result!=USB_STOR_XFER_GOOD)
412 			return USB_STOR_TRANSPORT_ERROR;
413 		if (*status & 0x01) { /* check condition */
414 			result = usbat_read(us, USBAT_ATA, 0x10, status);
415 			return USB_STOR_TRANSPORT_FAILED;
416 		}
417 		if (*status & 0x20) /* device fault */
418 			return USB_STOR_TRANSPORT_FAILED;
419 
420 		if ((*status & 0x80)==0x00) { /* not busy */
421 			usb_stor_dbg(us, "Waited not busy for %d steps\n", i);
422 			return USB_STOR_TRANSPORT_GOOD;
423 		}
424 
425 		if (i<500)
426 			msleep(10); /* 5 seconds */
427 		else if (i<700)
428 			msleep(50); /* 10 seconds */
429 		else if (i<1200)
430 			msleep(100); /* 50 seconds */
431 		else
432 			msleep(1000); /* X minutes */
433 	}
434 
435 	usb_stor_dbg(us, "Waited not busy for %d minutes, timing out\n",
436 		     minutes);
437 	return USB_STOR_TRANSPORT_FAILED;
438 }
439 
440 /*
441  * Read block data from the data register
442  */
443 static int usbat_read_block(struct us_data *us,
444 			    void* buf,
445 			    unsigned short len,
446 			    int use_sg)
447 {
448 	int result;
449 	unsigned char *command = us->iobuf;
450 
451 	if (!len)
452 		return USB_STOR_TRANSPORT_GOOD;
453 
454 	command[0] = 0xC0;
455 	command[1] = USBAT_ATA | USBAT_CMD_READ_BLOCK;
456 	command[2] = USBAT_ATA_DATA;
457 	command[3] = 0;
458 	command[4] = 0;
459 	command[5] = 0;
460 	command[6] = LSB_of(len);
461 	command[7] = MSB_of(len);
462 
463 	result = usbat_execute_command(us, command, 8);
464 	if (result != USB_STOR_XFER_GOOD)
465 		return USB_STOR_TRANSPORT_ERROR;
466 
467 	result = usbat_bulk_read(us, buf, len, use_sg);
468 	return (result == USB_STOR_XFER_GOOD ?
469 			USB_STOR_TRANSPORT_GOOD : USB_STOR_TRANSPORT_ERROR);
470 }
471 
472 /*
473  * Write block data via the data register
474  */
475 static int usbat_write_block(struct us_data *us,
476 			     unsigned char access,
477 			     void* buf,
478 			     unsigned short len,
479 			     int minutes,
480 			     int use_sg)
481 {
482 	int result;
483 	unsigned char *command = us->iobuf;
484 
485 	if (!len)
486 		return USB_STOR_TRANSPORT_GOOD;
487 
488 	command[0] = 0x40;
489 	command[1] = access | USBAT_CMD_WRITE_BLOCK;
490 	command[2] = USBAT_ATA_DATA;
491 	command[3] = 0;
492 	command[4] = 0;
493 	command[5] = 0;
494 	command[6] = LSB_of(len);
495 	command[7] = MSB_of(len);
496 
497 	result = usbat_execute_command(us, command, 8);
498 
499 	if (result != USB_STOR_XFER_GOOD)
500 		return USB_STOR_TRANSPORT_ERROR;
501 
502 	result = usbat_bulk_write(us, buf, len, use_sg);
503 	if (result != USB_STOR_XFER_GOOD)
504 		return USB_STOR_TRANSPORT_ERROR;
505 
506 	return usbat_wait_not_busy(us, minutes);
507 }
508 
509 /*
510  * Process read and write requests
511  */
512 static int usbat_hp8200e_rw_block_test(struct us_data *us,
513 				       unsigned char access,
514 				       unsigned char *registers,
515 				       unsigned char *data_out,
516 				       unsigned short num_registers,
517 				       unsigned char data_reg,
518 				       unsigned char status_reg,
519 				       unsigned char timeout,
520 				       unsigned char qualifier,
521 				       int direction,
522 				       void *buf,
523 				       unsigned short len,
524 				       int use_sg,
525 				       int minutes)
526 {
527 	int result;
528 	unsigned int pipe = (direction == DMA_FROM_DEVICE) ?
529 			us->recv_bulk_pipe : us->send_bulk_pipe;
530 
531 	unsigned char *command = us->iobuf;
532 	int i, j;
533 	int cmdlen;
534 	unsigned char *data = us->iobuf;
535 	unsigned char *status = us->iobuf;
536 
537 	BUG_ON(num_registers > US_IOBUF_SIZE/2);
538 
539 	for (i=0; i<20; i++) {
540 
541 		/*
542 		 * The first time we send the full command, which consists
543 		 * of downloading the SCSI command followed by downloading
544 		 * the data via a write-and-test.  Any other time we only
545 		 * send the command to download the data -- the SCSI command
546 		 * is still 'active' in some sense in the device.
547 		 *
548 		 * We're only going to try sending the data 10 times. After
549 		 * that, we just return a failure.
550 		 */
551 
552 		if (i==0) {
553 			cmdlen = 16;
554 			/*
555 			 * Write to multiple registers
556 			 * Not really sure the 0x07, 0x17, 0xfc, 0xe7 is
557 			 * necessary here, but that's what came out of the
558 			 * trace every single time.
559 			 */
560 			command[0] = 0x40;
561 			command[1] = access | USBAT_CMD_WRITE_REGS;
562 			command[2] = 0x07;
563 			command[3] = 0x17;
564 			command[4] = 0xFC;
565 			command[5] = 0xE7;
566 			command[6] = LSB_of(num_registers*2);
567 			command[7] = MSB_of(num_registers*2);
568 		} else
569 			cmdlen = 8;
570 
571 		/* Conditionally read or write blocks */
572 		command[cmdlen-8] = (direction==DMA_TO_DEVICE ? 0x40 : 0xC0);
573 		command[cmdlen-7] = access |
574 				(direction==DMA_TO_DEVICE ?
575 				 USBAT_CMD_COND_WRITE_BLOCK : USBAT_CMD_COND_READ_BLOCK);
576 		command[cmdlen-6] = data_reg;
577 		command[cmdlen-5] = status_reg;
578 		command[cmdlen-4] = timeout;
579 		command[cmdlen-3] = qualifier;
580 		command[cmdlen-2] = LSB_of(len);
581 		command[cmdlen-1] = MSB_of(len);
582 
583 		result = usbat_execute_command(us, command, cmdlen);
584 
585 		if (result != USB_STOR_XFER_GOOD)
586 			return USB_STOR_TRANSPORT_ERROR;
587 
588 		if (i==0) {
589 
590 			for (j=0; j<num_registers; j++) {
591 				data[j<<1] = registers[j];
592 				data[1+(j<<1)] = data_out[j];
593 			}
594 
595 			result = usbat_bulk_write(us, data, num_registers*2, 0);
596 			if (result != USB_STOR_XFER_GOOD)
597 				return USB_STOR_TRANSPORT_ERROR;
598 
599 		}
600 
601 		result = usb_stor_bulk_transfer_sg(us,
602 			pipe, buf, len, use_sg, NULL);
603 
604 		/*
605 		 * If we get a stall on the bulk download, we'll retry
606 		 * the bulk download -- but not the SCSI command because
607 		 * in some sense the SCSI command is still 'active' and
608 		 * waiting for the data. Don't ask me why this should be;
609 		 * I'm only following what the Windoze driver did.
610 		 *
611 		 * Note that a stall for the test-and-read/write command means
612 		 * that the test failed. In this case we're testing to make
613 		 * sure that the device is error-free
614 		 * (i.e. bit 0 -- CHK -- of status is 0). The most likely
615 		 * hypothesis is that the USBAT chip somehow knows what
616 		 * the device will accept, but doesn't give the device any
617 		 * data until all data is received. Thus, the device would
618 		 * still be waiting for the first byte of data if a stall
619 		 * occurs, even if the stall implies that some data was
620 		 * transferred.
621 		 */
622 
623 		if (result == USB_STOR_XFER_SHORT ||
624 				result == USB_STOR_XFER_STALLED) {
625 
626 			/*
627 			 * If we're reading and we stalled, then clear
628 			 * the bulk output pipe only the first time.
629 			 */
630 
631 			if (direction==DMA_FROM_DEVICE && i==0) {
632 				if (usb_stor_clear_halt(us,
633 						us->send_bulk_pipe) < 0)
634 					return USB_STOR_TRANSPORT_ERROR;
635 			}
636 
637 			/*
638 			 * Read status: is the device angry, or just busy?
639 			 */
640 
641  			result = usbat_read(us, USBAT_ATA,
642 				direction==DMA_TO_DEVICE ?
643 					USBAT_ATA_STATUS : USBAT_ATA_ALTSTATUS,
644 				status);
645 
646 			if (result!=USB_STOR_XFER_GOOD)
647 				return USB_STOR_TRANSPORT_ERROR;
648 			if (*status & 0x01) /* check condition */
649 				return USB_STOR_TRANSPORT_FAILED;
650 			if (*status & 0x20) /* device fault */
651 				return USB_STOR_TRANSPORT_FAILED;
652 
653 			usb_stor_dbg(us, "Redoing %s\n",
654 				     direction == DMA_TO_DEVICE
655 				     ? "write" : "read");
656 
657 		} else if (result != USB_STOR_XFER_GOOD)
658 			return USB_STOR_TRANSPORT_ERROR;
659 		else
660 			return usbat_wait_not_busy(us, minutes);
661 
662 	}
663 
664 	usb_stor_dbg(us, "Bummer! %s bulk data 20 times failed\n",
665 		     direction == DMA_TO_DEVICE ? "Writing" : "Reading");
666 
667 	return USB_STOR_TRANSPORT_FAILED;
668 }
669 
670 /*
671  * Write to multiple registers:
672  * Allows us to write specific data to any registers. The data to be written
673  * gets packed in this sequence: reg0, data0, reg1, data1, ..., regN, dataN
674  * which gets sent through bulk out.
675  * Not designed for large transfers of data!
676  */
677 static int usbat_multiple_write(struct us_data *us,
678 				unsigned char *registers,
679 				unsigned char *data_out,
680 				unsigned short num_registers)
681 {
682 	int i, result;
683 	unsigned char *data = us->iobuf;
684 	unsigned char *command = us->iobuf;
685 
686 	BUG_ON(num_registers > US_IOBUF_SIZE/2);
687 
688 	/* Write to multiple registers, ATA access */
689 	command[0] = 0x40;
690 	command[1] = USBAT_ATA | USBAT_CMD_WRITE_REGS;
691 
692 	/* No relevance */
693 	command[2] = 0;
694 	command[3] = 0;
695 	command[4] = 0;
696 	command[5] = 0;
697 
698 	/* Number of bytes to be transferred (incl. addresses and data) */
699 	command[6] = LSB_of(num_registers*2);
700 	command[7] = MSB_of(num_registers*2);
701 
702 	/* The setup command */
703 	result = usbat_execute_command(us, command, 8);
704 	if (result != USB_STOR_XFER_GOOD)
705 		return USB_STOR_TRANSPORT_ERROR;
706 
707 	/* Create the reg/data, reg/data sequence */
708 	for (i=0; i<num_registers; i++) {
709 		data[i<<1] = registers[i];
710 		data[1+(i<<1)] = data_out[i];
711 	}
712 
713 	/* Send the data */
714 	result = usbat_bulk_write(us, data, num_registers*2, 0);
715 	if (result != USB_STOR_XFER_GOOD)
716 		return USB_STOR_TRANSPORT_ERROR;
717 
718 	if (usbat_get_device_type(us) == USBAT_DEV_HP8200)
719 		return usbat_wait_not_busy(us, 0);
720 	else
721 		return USB_STOR_TRANSPORT_GOOD;
722 }
723 
724 /*
725  * Conditionally read blocks from device:
726  * Allows us to read blocks from a specific data register, based upon the
727  * condition that a status register can be successfully masked with a status
728  * qualifier. If this condition is not initially met, the read will wait
729  * up until a maximum amount of time has elapsed, as specified by timeout.
730  * The read will start when the condition is met, otherwise the command aborts.
731  *
732  * The qualifier defined here is not the value that is masked, it defines
733  * conditions for the write to take place. The actual masked qualifier (and
734  * other related details) are defined beforehand with _set_shuttle_features().
735  */
736 static int usbat_read_blocks(struct us_data *us,
737 			     void* buffer,
738 			     int len,
739 			     int use_sg)
740 {
741 	int result;
742 	unsigned char *command = us->iobuf;
743 
744 	command[0] = 0xC0;
745 	command[1] = USBAT_ATA | USBAT_CMD_COND_READ_BLOCK;
746 	command[2] = USBAT_ATA_DATA;
747 	command[3] = USBAT_ATA_STATUS;
748 	command[4] = 0xFD; /* Timeout (ms); */
749 	command[5] = USBAT_QUAL_FCQ;
750 	command[6] = LSB_of(len);
751 	command[7] = MSB_of(len);
752 
753 	/* Multiple block read setup command */
754 	result = usbat_execute_command(us, command, 8);
755 	if (result != USB_STOR_XFER_GOOD)
756 		return USB_STOR_TRANSPORT_FAILED;
757 
758 	/* Read the blocks we just asked for */
759 	result = usbat_bulk_read(us, buffer, len, use_sg);
760 	if (result != USB_STOR_XFER_GOOD)
761 		return USB_STOR_TRANSPORT_FAILED;
762 
763 	return USB_STOR_TRANSPORT_GOOD;
764 }
765 
766 /*
767  * Conditionally write blocks to device:
768  * Allows us to write blocks to a specific data register, based upon the
769  * condition that a status register can be successfully masked with a status
770  * qualifier. If this condition is not initially met, the write will wait
771  * up until a maximum amount of time has elapsed, as specified by timeout.
772  * The read will start when the condition is met, otherwise the command aborts.
773  *
774  * The qualifier defined here is not the value that is masked, it defines
775  * conditions for the write to take place. The actual masked qualifier (and
776  * other related details) are defined beforehand with _set_shuttle_features().
777  */
778 static int usbat_write_blocks(struct us_data *us,
779 			      void* buffer,
780 			      int len,
781 			      int use_sg)
782 {
783 	int result;
784 	unsigned char *command = us->iobuf;
785 
786 	command[0] = 0x40;
787 	command[1] = USBAT_ATA | USBAT_CMD_COND_WRITE_BLOCK;
788 	command[2] = USBAT_ATA_DATA;
789 	command[3] = USBAT_ATA_STATUS;
790 	command[4] = 0xFD; /* Timeout (ms) */
791 	command[5] = USBAT_QUAL_FCQ;
792 	command[6] = LSB_of(len);
793 	command[7] = MSB_of(len);
794 
795 	/* Multiple block write setup command */
796 	result = usbat_execute_command(us, command, 8);
797 	if (result != USB_STOR_XFER_GOOD)
798 		return USB_STOR_TRANSPORT_FAILED;
799 
800 	/* Write the data */
801 	result = usbat_bulk_write(us, buffer, len, use_sg);
802 	if (result != USB_STOR_XFER_GOOD)
803 		return USB_STOR_TRANSPORT_FAILED;
804 
805 	return USB_STOR_TRANSPORT_GOOD;
806 }
807 
808 /*
809  * Read the User IO register
810  */
811 static int usbat_read_user_io(struct us_data *us, unsigned char *data_flags)
812 {
813 	int result;
814 
815 	result = usb_stor_ctrl_transfer(us,
816 		us->recv_ctrl_pipe,
817 		USBAT_CMD_UIO,
818 		0xC0,
819 		0,
820 		0,
821 		data_flags,
822 		USBAT_UIO_READ);
823 
824 	usb_stor_dbg(us, "UIO register reads %02X\n", *data_flags);
825 
826 	return result;
827 }
828 
829 /*
830  * Write to the User IO register
831  */
832 static int usbat_write_user_io(struct us_data *us,
833 			       unsigned char enable_flags,
834 			       unsigned char data_flags)
835 {
836 	return usb_stor_ctrl_transfer(us,
837 		us->send_ctrl_pipe,
838 		USBAT_CMD_UIO,
839 		0x40,
840 		short_pack(enable_flags, data_flags),
841 		0,
842 		NULL,
843 		USBAT_UIO_WRITE);
844 }
845 
846 /*
847  * Reset the device
848  * Often needed on media change.
849  */
850 static int usbat_device_reset(struct us_data *us)
851 {
852 	int rc;
853 
854 	/*
855 	 * Reset peripheral, enable peripheral control signals
856 	 * (bring reset signal up)
857 	 */
858 	rc = usbat_write_user_io(us,
859 							 USBAT_UIO_DRVRST | USBAT_UIO_OE1 | USBAT_UIO_OE0,
860 							 USBAT_UIO_EPAD | USBAT_UIO_1);
861 	if (rc != USB_STOR_XFER_GOOD)
862 		return USB_STOR_TRANSPORT_ERROR;
863 
864 	/*
865 	 * Enable peripheral control signals
866 	 * (bring reset signal down)
867 	 */
868 	rc = usbat_write_user_io(us,
869 							 USBAT_UIO_OE1  | USBAT_UIO_OE0,
870 							 USBAT_UIO_EPAD | USBAT_UIO_1);
871 	if (rc != USB_STOR_XFER_GOOD)
872 		return USB_STOR_TRANSPORT_ERROR;
873 
874 	return USB_STOR_TRANSPORT_GOOD;
875 }
876 
877 /*
878  * Enable card detect
879  */
880 static int usbat_device_enable_cdt(struct us_data *us)
881 {
882 	int rc;
883 
884 	/* Enable peripheral control signals and card detect */
885 	rc = usbat_write_user_io(us,
886 							 USBAT_UIO_ACKD | USBAT_UIO_OE1  | USBAT_UIO_OE0,
887 							 USBAT_UIO_EPAD | USBAT_UIO_1);
888 	if (rc != USB_STOR_XFER_GOOD)
889 		return USB_STOR_TRANSPORT_ERROR;
890 
891 	return USB_STOR_TRANSPORT_GOOD;
892 }
893 
894 /*
895  * Determine if media is present.
896  */
897 static int usbat_flash_check_media_present(struct us_data *us,
898 					   unsigned char *uio)
899 {
900 	if (*uio & USBAT_UIO_UI0) {
901 		usb_stor_dbg(us, "no media detected\n");
902 		return USBAT_FLASH_MEDIA_NONE;
903 	}
904 
905 	return USBAT_FLASH_MEDIA_CF;
906 }
907 
908 /*
909  * Determine if media has changed since last operation
910  */
911 static int usbat_flash_check_media_changed(struct us_data *us,
912 					   unsigned char *uio)
913 {
914 	if (*uio & USBAT_UIO_0) {
915 		usb_stor_dbg(us, "media change detected\n");
916 		return USBAT_FLASH_MEDIA_CHANGED;
917 	}
918 
919 	return USBAT_FLASH_MEDIA_SAME;
920 }
921 
922 /*
923  * Check for media change / no media and handle the situation appropriately
924  */
925 static int usbat_flash_check_media(struct us_data *us,
926 				   struct usbat_info *info)
927 {
928 	int rc;
929 	unsigned char *uio = us->iobuf;
930 
931 	rc = usbat_read_user_io(us, uio);
932 	if (rc != USB_STOR_XFER_GOOD)
933 		return USB_STOR_TRANSPORT_ERROR;
934 
935 	/* Check for media existence */
936 	rc = usbat_flash_check_media_present(us, uio);
937 	if (rc == USBAT_FLASH_MEDIA_NONE) {
938 		info->sense_key = 0x02;
939 		info->sense_asc = 0x3A;
940 		info->sense_ascq = 0x00;
941 		return USB_STOR_TRANSPORT_FAILED;
942 	}
943 
944 	/* Check for media change */
945 	rc = usbat_flash_check_media_changed(us, uio);
946 	if (rc == USBAT_FLASH_MEDIA_CHANGED) {
947 
948 		/* Reset and re-enable card detect */
949 		rc = usbat_device_reset(us);
950 		if (rc != USB_STOR_TRANSPORT_GOOD)
951 			return rc;
952 		rc = usbat_device_enable_cdt(us);
953 		if (rc != USB_STOR_TRANSPORT_GOOD)
954 			return rc;
955 
956 		msleep(50);
957 
958 		rc = usbat_read_user_io(us, uio);
959 		if (rc != USB_STOR_XFER_GOOD)
960 			return USB_STOR_TRANSPORT_ERROR;
961 
962 		info->sense_key = UNIT_ATTENTION;
963 		info->sense_asc = 0x28;
964 		info->sense_ascq = 0x00;
965 		return USB_STOR_TRANSPORT_FAILED;
966 	}
967 
968 	return USB_STOR_TRANSPORT_GOOD;
969 }
970 
971 /*
972  * Determine whether we are controlling a flash-based reader/writer,
973  * or a HP8200-based CD drive.
974  * Sets transport functions as appropriate.
975  */
976 static int usbat_identify_device(struct us_data *us,
977 				 struct usbat_info *info)
978 {
979 	int rc;
980 	unsigned char status;
981 
982 	if (!us || !info)
983 		return USB_STOR_TRANSPORT_ERROR;
984 
985 	rc = usbat_device_reset(us);
986 	if (rc != USB_STOR_TRANSPORT_GOOD)
987 		return rc;
988 	msleep(500);
989 
990 	/*
991 	 * In attempt to distinguish between HP CDRW's and Flash readers, we now
992 	 * execute the IDENTIFY PACKET DEVICE command. On ATA devices (i.e. flash
993 	 * readers), this command should fail with error. On ATAPI devices (i.e.
994 	 * CDROM drives), it should succeed.
995 	 */
996 	rc = usbat_write(us, USBAT_ATA, USBAT_ATA_CMD, 0xA1);
997  	if (rc != USB_STOR_XFER_GOOD)
998  		return USB_STOR_TRANSPORT_ERROR;
999 
1000 	rc = usbat_get_status(us, &status);
1001  	if (rc != USB_STOR_XFER_GOOD)
1002  		return USB_STOR_TRANSPORT_ERROR;
1003 
1004 	/* Check for error bit, or if the command 'fell through' */
1005 	if (status == 0xA1 || !(status & 0x01)) {
1006 		/* Device is HP 8200 */
1007 		usb_stor_dbg(us, "Detected HP8200 CDRW\n");
1008 		info->devicetype = USBAT_DEV_HP8200;
1009 	} else {
1010 		/* Device is a CompactFlash reader/writer */
1011 		usb_stor_dbg(us, "Detected Flash reader/writer\n");
1012 		info->devicetype = USBAT_DEV_FLASH;
1013 	}
1014 
1015 	return USB_STOR_TRANSPORT_GOOD;
1016 }
1017 
1018 /*
1019  * Set the transport function based on the device type
1020  */
1021 static int usbat_set_transport(struct us_data *us,
1022 			       struct usbat_info *info,
1023 			       int devicetype)
1024 {
1025 
1026 	if (!info->devicetype)
1027 		info->devicetype = devicetype;
1028 
1029 	if (!info->devicetype)
1030 		usbat_identify_device(us, info);
1031 
1032 	switch (info->devicetype) {
1033 	default:
1034 		return USB_STOR_TRANSPORT_ERROR;
1035 
1036 	case  USBAT_DEV_HP8200:
1037 		us->transport = usbat_hp8200e_transport;
1038 		break;
1039 
1040 	case USBAT_DEV_FLASH:
1041 		us->transport = usbat_flash_transport;
1042 		break;
1043 	}
1044 
1045 	return 0;
1046 }
1047 
1048 /*
1049  * Read the media capacity
1050  */
1051 static int usbat_flash_get_sector_count(struct us_data *us,
1052 					struct usbat_info *info)
1053 {
1054 	unsigned char registers[3] = {
1055 		USBAT_ATA_SECCNT,
1056 		USBAT_ATA_DEVICE,
1057 		USBAT_ATA_CMD,
1058 	};
1059 	unsigned char  command[3] = { 0x01, 0xA0, 0xEC };
1060 	unsigned char *reply;
1061 	unsigned char status;
1062 	int rc;
1063 
1064 	if (!us || !info)
1065 		return USB_STOR_TRANSPORT_ERROR;
1066 
1067 	reply = kmalloc(512, GFP_NOIO);
1068 	if (!reply)
1069 		return USB_STOR_TRANSPORT_ERROR;
1070 
1071 	/* ATA command : IDENTIFY DEVICE */
1072 	rc = usbat_multiple_write(us, registers, command, 3);
1073 	if (rc != USB_STOR_XFER_GOOD) {
1074 		usb_stor_dbg(us, "Gah! identify_device failed\n");
1075 		rc = USB_STOR_TRANSPORT_ERROR;
1076 		goto leave;
1077 	}
1078 
1079 	/* Read device status */
1080 	if (usbat_get_status(us, &status) != USB_STOR_XFER_GOOD) {
1081 		rc = USB_STOR_TRANSPORT_ERROR;
1082 		goto leave;
1083 	}
1084 
1085 	msleep(100);
1086 
1087 	/* Read the device identification data */
1088 	rc = usbat_read_block(us, reply, 512, 0);
1089 	if (rc != USB_STOR_TRANSPORT_GOOD)
1090 		goto leave;
1091 
1092 	info->sectors = ((u32)(reply[117]) << 24) |
1093 		((u32)(reply[116]) << 16) |
1094 		((u32)(reply[115]) <<  8) |
1095 		((u32)(reply[114])      );
1096 
1097 	rc = USB_STOR_TRANSPORT_GOOD;
1098 
1099  leave:
1100 	kfree(reply);
1101 	return rc;
1102 }
1103 
1104 /*
1105  * Read data from device
1106  */
1107 static int usbat_flash_read_data(struct us_data *us,
1108 								 struct usbat_info *info,
1109 								 u32 sector,
1110 								 u32 sectors)
1111 {
1112 	unsigned char registers[7] = {
1113 		USBAT_ATA_FEATURES,
1114 		USBAT_ATA_SECCNT,
1115 		USBAT_ATA_SECNUM,
1116 		USBAT_ATA_LBA_ME,
1117 		USBAT_ATA_LBA_HI,
1118 		USBAT_ATA_DEVICE,
1119 		USBAT_ATA_STATUS,
1120 	};
1121 	unsigned char command[7];
1122 	unsigned char *buffer;
1123 	unsigned char  thistime;
1124 	unsigned int totallen, alloclen;
1125 	int len, result;
1126 	unsigned int sg_offset = 0;
1127 	struct scatterlist *sg = NULL;
1128 
1129 	result = usbat_flash_check_media(us, info);
1130 	if (result != USB_STOR_TRANSPORT_GOOD)
1131 		return result;
1132 
1133 	/*
1134 	 * we're working in LBA mode.  according to the ATA spec,
1135 	 * we can support up to 28-bit addressing.  I don't know if Jumpshot
1136 	 * supports beyond 24-bit addressing.  It's kind of hard to test
1137 	 * since it requires > 8GB CF card.
1138 	 */
1139 
1140 	if (sector > 0x0FFFFFFF)
1141 		return USB_STOR_TRANSPORT_ERROR;
1142 
1143 	totallen = sectors * info->ssize;
1144 
1145 	/*
1146 	 * Since we don't read more than 64 KB at a time, we have to create
1147 	 * a bounce buffer and move the data a piece at a time between the
1148 	 * bounce buffer and the actual transfer buffer.
1149 	 */
1150 
1151 	alloclen = min(totallen, 65536u);
1152 	buffer = kmalloc(alloclen, GFP_NOIO);
1153 	if (buffer == NULL)
1154 		return USB_STOR_TRANSPORT_ERROR;
1155 
1156 	do {
1157 		/*
1158 		 * loop, never allocate or transfer more than 64k at once
1159 		 * (min(128k, 255*info->ssize) is the real limit)
1160 		 */
1161 		len = min(totallen, alloclen);
1162 		thistime = (len / info->ssize) & 0xff;
1163 
1164 		/* ATA command 0x20 (READ SECTORS) */
1165 		usbat_pack_ata_sector_cmd(command, thistime, sector, 0x20);
1166 
1167 		/* Write/execute ATA read command */
1168 		result = usbat_multiple_write(us, registers, command, 7);
1169 		if (result != USB_STOR_TRANSPORT_GOOD)
1170 			goto leave;
1171 
1172 		/* Read the data we just requested */
1173 		result = usbat_read_blocks(us, buffer, len, 0);
1174 		if (result != USB_STOR_TRANSPORT_GOOD)
1175 			goto leave;
1176 
1177 		usb_stor_dbg(us, "%d bytes\n", len);
1178 
1179 		/* Store the data in the transfer buffer */
1180 		usb_stor_access_xfer_buf(buffer, len, us->srb,
1181 					 &sg, &sg_offset, TO_XFER_BUF);
1182 
1183 		sector += thistime;
1184 		totallen -= len;
1185 	} while (totallen > 0);
1186 
1187 	kfree(buffer);
1188 	return USB_STOR_TRANSPORT_GOOD;
1189 
1190 leave:
1191 	kfree(buffer);
1192 	return USB_STOR_TRANSPORT_ERROR;
1193 }
1194 
1195 /*
1196  * Write data to device
1197  */
1198 static int usbat_flash_write_data(struct us_data *us,
1199 								  struct usbat_info *info,
1200 								  u32 sector,
1201 								  u32 sectors)
1202 {
1203 	unsigned char registers[7] = {
1204 		USBAT_ATA_FEATURES,
1205 		USBAT_ATA_SECCNT,
1206 		USBAT_ATA_SECNUM,
1207 		USBAT_ATA_LBA_ME,
1208 		USBAT_ATA_LBA_HI,
1209 		USBAT_ATA_DEVICE,
1210 		USBAT_ATA_STATUS,
1211 	};
1212 	unsigned char command[7];
1213 	unsigned char *buffer;
1214 	unsigned char  thistime;
1215 	unsigned int totallen, alloclen;
1216 	int len, result;
1217 	unsigned int sg_offset = 0;
1218 	struct scatterlist *sg = NULL;
1219 
1220 	result = usbat_flash_check_media(us, info);
1221 	if (result != USB_STOR_TRANSPORT_GOOD)
1222 		return result;
1223 
1224 	/*
1225 	 * we're working in LBA mode.  according to the ATA spec,
1226 	 * we can support up to 28-bit addressing.  I don't know if the device
1227 	 * supports beyond 24-bit addressing.  It's kind of hard to test
1228 	 * since it requires > 8GB media.
1229 	 */
1230 
1231 	if (sector > 0x0FFFFFFF)
1232 		return USB_STOR_TRANSPORT_ERROR;
1233 
1234 	totallen = sectors * info->ssize;
1235 
1236 	/*
1237 	 * Since we don't write more than 64 KB at a time, we have to create
1238 	 * a bounce buffer and move the data a piece at a time between the
1239 	 * bounce buffer and the actual transfer buffer.
1240 	 */
1241 
1242 	alloclen = min(totallen, 65536u);
1243 	buffer = kmalloc(alloclen, GFP_NOIO);
1244 	if (buffer == NULL)
1245 		return USB_STOR_TRANSPORT_ERROR;
1246 
1247 	do {
1248 		/*
1249 		 * loop, never allocate or transfer more than 64k at once
1250 		 * (min(128k, 255*info->ssize) is the real limit)
1251 		 */
1252 		len = min(totallen, alloclen);
1253 		thistime = (len / info->ssize) & 0xff;
1254 
1255 		/* Get the data from the transfer buffer */
1256 		usb_stor_access_xfer_buf(buffer, len, us->srb,
1257 					 &sg, &sg_offset, FROM_XFER_BUF);
1258 
1259 		/* ATA command 0x30 (WRITE SECTORS) */
1260 		usbat_pack_ata_sector_cmd(command, thistime, sector, 0x30);
1261 
1262 		/* Write/execute ATA write command */
1263 		result = usbat_multiple_write(us, registers, command, 7);
1264 		if (result != USB_STOR_TRANSPORT_GOOD)
1265 			goto leave;
1266 
1267 		/* Write the data */
1268 		result = usbat_write_blocks(us, buffer, len, 0);
1269 		if (result != USB_STOR_TRANSPORT_GOOD)
1270 			goto leave;
1271 
1272 		sector += thistime;
1273 		totallen -= len;
1274 	} while (totallen > 0);
1275 
1276 	kfree(buffer);
1277 	return result;
1278 
1279 leave:
1280 	kfree(buffer);
1281 	return USB_STOR_TRANSPORT_ERROR;
1282 }
1283 
1284 /*
1285  * Squeeze a potentially huge (> 65535 byte) read10 command into
1286  * a little ( <= 65535 byte) ATAPI pipe
1287  */
1288 static int usbat_hp8200e_handle_read10(struct us_data *us,
1289 				       unsigned char *registers,
1290 				       unsigned char *data,
1291 				       struct scsi_cmnd *srb)
1292 {
1293 	int result = USB_STOR_TRANSPORT_GOOD;
1294 	unsigned char *buffer;
1295 	unsigned int len;
1296 	unsigned int sector;
1297 	unsigned int sg_offset = 0;
1298 	struct scatterlist *sg = NULL;
1299 
1300 	usb_stor_dbg(us, "transfersize %d\n", srb->transfersize);
1301 
1302 	if (scsi_bufflen(srb) < 0x10000) {
1303 
1304 		result = usbat_hp8200e_rw_block_test(us, USBAT_ATA,
1305 			registers, data, 19,
1306 			USBAT_ATA_DATA, USBAT_ATA_STATUS, 0xFD,
1307 			(USBAT_QUAL_FCQ | USBAT_QUAL_ALQ),
1308 			DMA_FROM_DEVICE,
1309 			scsi_sglist(srb),
1310 			scsi_bufflen(srb), scsi_sg_count(srb), 1);
1311 
1312 		return result;
1313 	}
1314 
1315 	/*
1316 	 * Since we're requesting more data than we can handle in
1317 	 * a single read command (max is 64k-1), we will perform
1318 	 * multiple reads, but each read must be in multiples of
1319 	 * a sector.  Luckily the sector size is in srb->transfersize
1320 	 * (see linux/drivers/scsi/sr.c).
1321 	 */
1322 
1323 	if (data[7+0] == GPCMD_READ_CD) {
1324 		len = short_pack(data[7+9], data[7+8]);
1325 		len <<= 16;
1326 		len |= data[7+7];
1327 		usb_stor_dbg(us, "GPCMD_READ_CD: len %d\n", len);
1328 		srb->transfersize = scsi_bufflen(srb)/len;
1329 	}
1330 
1331 	if (!srb->transfersize)  {
1332 		srb->transfersize = 2048; /* A guess */
1333 		usb_stor_dbg(us, "transfersize 0, forcing %d\n",
1334 			     srb->transfersize);
1335 	}
1336 
1337 	/*
1338 	 * Since we only read in one block at a time, we have to create
1339 	 * a bounce buffer and move the data a piece at a time between the
1340 	 * bounce buffer and the actual transfer buffer.
1341 	 */
1342 
1343 	len = (65535/srb->transfersize) * srb->transfersize;
1344 	usb_stor_dbg(us, "Max read is %d bytes\n", len);
1345 	len = min(len, scsi_bufflen(srb));
1346 	buffer = kmalloc(len, GFP_NOIO);
1347 	if (buffer == NULL) /* bloody hell! */
1348 		return USB_STOR_TRANSPORT_FAILED;
1349 	sector = short_pack(data[7+3], data[7+2]);
1350 	sector <<= 16;
1351 	sector |= short_pack(data[7+5], data[7+4]);
1352 	transferred = 0;
1353 
1354 	while (transferred != scsi_bufflen(srb)) {
1355 
1356 		if (len > scsi_bufflen(srb) - transferred)
1357 			len = scsi_bufflen(srb) - transferred;
1358 
1359 		data[3] = len&0xFF; 	  /* (cylL) = expected length (L) */
1360 		data[4] = (len>>8)&0xFF;  /* (cylH) = expected length (H) */
1361 
1362 		/* Fix up the SCSI command sector and num sectors */
1363 
1364 		data[7+2] = MSB_of(sector>>16); /* SCSI command sector */
1365 		data[7+3] = LSB_of(sector>>16);
1366 		data[7+4] = MSB_of(sector&0xFFFF);
1367 		data[7+5] = LSB_of(sector&0xFFFF);
1368 		if (data[7+0] == GPCMD_READ_CD)
1369 			data[7+6] = 0;
1370 		data[7+7] = MSB_of(len / srb->transfersize); /* SCSI command */
1371 		data[7+8] = LSB_of(len / srb->transfersize); /* num sectors */
1372 
1373 		result = usbat_hp8200e_rw_block_test(us, USBAT_ATA,
1374 			registers, data, 19,
1375 			USBAT_ATA_DATA, USBAT_ATA_STATUS, 0xFD,
1376 			(USBAT_QUAL_FCQ | USBAT_QUAL_ALQ),
1377 			DMA_FROM_DEVICE,
1378 			buffer,
1379 			len, 0, 1);
1380 
1381 		if (result != USB_STOR_TRANSPORT_GOOD)
1382 			break;
1383 
1384 		/* Store the data in the transfer buffer */
1385 		usb_stor_access_xfer_buf(buffer, len, srb,
1386 				 &sg, &sg_offset, TO_XFER_BUF);
1387 
1388 		/* Update the amount transferred and the sector number */
1389 
1390 		transferred += len;
1391 		sector += len / srb->transfersize;
1392 
1393 	} /* while transferred != scsi_bufflen(srb) */
1394 
1395 	kfree(buffer);
1396 	return result;
1397 }
1398 
1399 static int usbat_select_and_test_registers(struct us_data *us)
1400 {
1401 	int selector;
1402 	unsigned char *status = us->iobuf;
1403 
1404 	/* try device = master, then device = slave. */
1405 	for (selector = 0xA0; selector <= 0xB0; selector += 0x10) {
1406 		if (usbat_write(us, USBAT_ATA, USBAT_ATA_DEVICE, selector) !=
1407 				USB_STOR_XFER_GOOD)
1408 			return USB_STOR_TRANSPORT_ERROR;
1409 
1410 		if (usbat_read(us, USBAT_ATA, USBAT_ATA_STATUS, status) !=
1411 				USB_STOR_XFER_GOOD)
1412 			return USB_STOR_TRANSPORT_ERROR;
1413 
1414 		if (usbat_read(us, USBAT_ATA, USBAT_ATA_DEVICE, status) !=
1415 				USB_STOR_XFER_GOOD)
1416 			return USB_STOR_TRANSPORT_ERROR;
1417 
1418 		if (usbat_read(us, USBAT_ATA, USBAT_ATA_LBA_ME, status) !=
1419 				USB_STOR_XFER_GOOD)
1420 			return USB_STOR_TRANSPORT_ERROR;
1421 
1422 		if (usbat_read(us, USBAT_ATA, USBAT_ATA_LBA_HI, status) !=
1423 				USB_STOR_XFER_GOOD)
1424 			return USB_STOR_TRANSPORT_ERROR;
1425 
1426 		if (usbat_write(us, USBAT_ATA, USBAT_ATA_LBA_ME, 0x55) !=
1427 				USB_STOR_XFER_GOOD)
1428 			return USB_STOR_TRANSPORT_ERROR;
1429 
1430 		if (usbat_write(us, USBAT_ATA, USBAT_ATA_LBA_HI, 0xAA) !=
1431 				USB_STOR_XFER_GOOD)
1432 			return USB_STOR_TRANSPORT_ERROR;
1433 
1434 		if (usbat_read(us, USBAT_ATA, USBAT_ATA_LBA_ME, status) !=
1435 				USB_STOR_XFER_GOOD)
1436 			return USB_STOR_TRANSPORT_ERROR;
1437 
1438 		if (usbat_read(us, USBAT_ATA, USBAT_ATA_LBA_ME, status) !=
1439 				USB_STOR_XFER_GOOD)
1440 			return USB_STOR_TRANSPORT_ERROR;
1441 	}
1442 
1443 	return USB_STOR_TRANSPORT_GOOD;
1444 }
1445 
1446 /*
1447  * Initialize the USBAT processor and the storage device
1448  */
1449 static int init_usbat(struct us_data *us, int devicetype)
1450 {
1451 	int rc;
1452 	struct usbat_info *info;
1453 	unsigned char subcountH = USBAT_ATA_LBA_HI;
1454 	unsigned char subcountL = USBAT_ATA_LBA_ME;
1455 	unsigned char *status = us->iobuf;
1456 
1457 	us->extra = kzalloc(sizeof(struct usbat_info), GFP_NOIO);
1458 	if (!us->extra)
1459 		return 1;
1460 
1461 	info = (struct usbat_info *) (us->extra);
1462 
1463 	/* Enable peripheral control signals */
1464 	rc = usbat_write_user_io(us,
1465 				 USBAT_UIO_OE1 | USBAT_UIO_OE0,
1466 				 USBAT_UIO_EPAD | USBAT_UIO_1);
1467 	if (rc != USB_STOR_XFER_GOOD)
1468 		return USB_STOR_TRANSPORT_ERROR;
1469 
1470 	usb_stor_dbg(us, "INIT 1\n");
1471 
1472 	msleep(2000);
1473 
1474 	rc = usbat_read_user_io(us, status);
1475 	if (rc != USB_STOR_TRANSPORT_GOOD)
1476 		return rc;
1477 
1478 	usb_stor_dbg(us, "INIT 2\n");
1479 
1480 	rc = usbat_read_user_io(us, status);
1481 	if (rc != USB_STOR_XFER_GOOD)
1482 		return USB_STOR_TRANSPORT_ERROR;
1483 
1484 	rc = usbat_read_user_io(us, status);
1485 	if (rc != USB_STOR_XFER_GOOD)
1486 		return USB_STOR_TRANSPORT_ERROR;
1487 
1488 	usb_stor_dbg(us, "INIT 3\n");
1489 
1490 	rc = usbat_select_and_test_registers(us);
1491 	if (rc != USB_STOR_TRANSPORT_GOOD)
1492 		return rc;
1493 
1494 	usb_stor_dbg(us, "INIT 4\n");
1495 
1496 	rc = usbat_read_user_io(us, status);
1497 	if (rc != USB_STOR_XFER_GOOD)
1498 		return USB_STOR_TRANSPORT_ERROR;
1499 
1500 	usb_stor_dbg(us, "INIT 5\n");
1501 
1502 	/* Enable peripheral control signals and card detect */
1503 	rc = usbat_device_enable_cdt(us);
1504 	if (rc != USB_STOR_TRANSPORT_GOOD)
1505 		return rc;
1506 
1507 	usb_stor_dbg(us, "INIT 6\n");
1508 
1509 	rc = usbat_read_user_io(us, status);
1510 	if (rc != USB_STOR_XFER_GOOD)
1511 		return USB_STOR_TRANSPORT_ERROR;
1512 
1513 	usb_stor_dbg(us, "INIT 7\n");
1514 
1515 	msleep(1400);
1516 
1517 	rc = usbat_read_user_io(us, status);
1518 	if (rc != USB_STOR_XFER_GOOD)
1519 		return USB_STOR_TRANSPORT_ERROR;
1520 
1521 	usb_stor_dbg(us, "INIT 8\n");
1522 
1523 	rc = usbat_select_and_test_registers(us);
1524 	if (rc != USB_STOR_TRANSPORT_GOOD)
1525 		return rc;
1526 
1527 	usb_stor_dbg(us, "INIT 9\n");
1528 
1529 	/* At this point, we need to detect which device we are using */
1530 	if (usbat_set_transport(us, info, devicetype))
1531 		return USB_STOR_TRANSPORT_ERROR;
1532 
1533 	usb_stor_dbg(us, "INIT 10\n");
1534 
1535 	if (usbat_get_device_type(us) == USBAT_DEV_FLASH) {
1536 		subcountH = 0x02;
1537 		subcountL = 0x00;
1538 	}
1539 	rc = usbat_set_shuttle_features(us, (USBAT_FEAT_ETEN | USBAT_FEAT_ET2 | USBAT_FEAT_ET1),
1540 									0x00, 0x88, 0x08, subcountH, subcountL);
1541 	if (rc != USB_STOR_XFER_GOOD)
1542 		return USB_STOR_TRANSPORT_ERROR;
1543 
1544 	usb_stor_dbg(us, "INIT 11\n");
1545 
1546 	return USB_STOR_TRANSPORT_GOOD;
1547 }
1548 
1549 /*
1550  * Transport for the HP 8200e
1551  */
1552 static int usbat_hp8200e_transport(struct scsi_cmnd *srb, struct us_data *us)
1553 {
1554 	int result;
1555 	unsigned char *status = us->iobuf;
1556 	unsigned char registers[32];
1557 	unsigned char data[32];
1558 	unsigned int len;
1559 	int i;
1560 
1561 	len = scsi_bufflen(srb);
1562 
1563 	/*
1564 	 * Send A0 (ATA PACKET COMMAND).
1565 	 * Note: I guess we're never going to get any of the ATA
1566 	 * commands... just ATA Packet Commands.
1567  	 */
1568 
1569 	registers[0] = USBAT_ATA_FEATURES;
1570 	registers[1] = USBAT_ATA_SECCNT;
1571 	registers[2] = USBAT_ATA_SECNUM;
1572 	registers[3] = USBAT_ATA_LBA_ME;
1573 	registers[4] = USBAT_ATA_LBA_HI;
1574 	registers[5] = USBAT_ATA_DEVICE;
1575 	registers[6] = USBAT_ATA_CMD;
1576 	data[0] = 0x00;
1577 	data[1] = 0x00;
1578 	data[2] = 0x00;
1579 	data[3] = len&0xFF; 		/* (cylL) = expected length (L) */
1580 	data[4] = (len>>8)&0xFF; 	/* (cylH) = expected length (H) */
1581 	data[5] = 0xB0; 		/* (device sel) = slave */
1582 	data[6] = 0xA0; 		/* (command) = ATA PACKET COMMAND */
1583 
1584 	for (i=7; i<19; i++) {
1585 		registers[i] = 0x10;
1586 		data[i] = (i-7 >= srb->cmd_len) ? 0 : srb->cmnd[i-7];
1587 	}
1588 
1589 	result = usbat_get_status(us, status);
1590 	usb_stor_dbg(us, "Status = %02X\n", *status);
1591 	if (result != USB_STOR_XFER_GOOD)
1592 		return USB_STOR_TRANSPORT_ERROR;
1593 	if (srb->cmnd[0] == TEST_UNIT_READY)
1594 		transferred = 0;
1595 
1596 	if (srb->sc_data_direction == DMA_TO_DEVICE) {
1597 
1598 		result = usbat_hp8200e_rw_block_test(us, USBAT_ATA,
1599 			registers, data, 19,
1600 			USBAT_ATA_DATA, USBAT_ATA_STATUS, 0xFD,
1601 			(USBAT_QUAL_FCQ | USBAT_QUAL_ALQ),
1602 			DMA_TO_DEVICE,
1603 			scsi_sglist(srb),
1604 			len, scsi_sg_count(srb), 10);
1605 
1606 		if (result == USB_STOR_TRANSPORT_GOOD) {
1607 			transferred += len;
1608 			usb_stor_dbg(us, "Wrote %08X bytes\n", transferred);
1609 		}
1610 
1611 		return result;
1612 
1613 	} else if (srb->cmnd[0] == READ_10 ||
1614 		   srb->cmnd[0] == GPCMD_READ_CD) {
1615 
1616 		return usbat_hp8200e_handle_read10(us, registers, data, srb);
1617 
1618 	}
1619 
1620 	if (len > 0xFFFF) {
1621 		usb_stor_dbg(us, "Error: len = %08X... what do I do now?\n",
1622 			     len);
1623 		return USB_STOR_TRANSPORT_ERROR;
1624 	}
1625 
1626 	result = usbat_multiple_write(us, registers, data, 7);
1627 
1628 	if (result != USB_STOR_TRANSPORT_GOOD)
1629 		return result;
1630 
1631 	/*
1632 	 * Write the 12-byte command header.
1633 	 *
1634 	 * If the command is BLANK then set the timer for 75 minutes.
1635 	 * Otherwise set it for 10 minutes.
1636 	 *
1637 	 * NOTE: THE 8200 DOCUMENTATION STATES THAT BLANKING A CDRW
1638 	 * AT SPEED 4 IS UNRELIABLE!!!
1639 	 */
1640 
1641 	result = usbat_write_block(us, USBAT_ATA, srb->cmnd, 12,
1642 				   srb->cmnd[0] == GPCMD_BLANK ? 75 : 10, 0);
1643 
1644 	if (result != USB_STOR_TRANSPORT_GOOD)
1645 		return result;
1646 
1647 	/* If there is response data to be read in then do it here. */
1648 
1649 	if (len != 0 && (srb->sc_data_direction == DMA_FROM_DEVICE)) {
1650 
1651 		/* How many bytes to read in? Check cylL register */
1652 
1653 		if (usbat_read(us, USBAT_ATA, USBAT_ATA_LBA_ME, status) !=
1654 		    	USB_STOR_XFER_GOOD) {
1655 			return USB_STOR_TRANSPORT_ERROR;
1656 		}
1657 
1658 		if (len > 0xFF) { /* need to read cylH also */
1659 			len = *status;
1660 			if (usbat_read(us, USBAT_ATA, USBAT_ATA_LBA_HI, status) !=
1661 				    USB_STOR_XFER_GOOD) {
1662 				return USB_STOR_TRANSPORT_ERROR;
1663 			}
1664 			len += ((unsigned int) *status)<<8;
1665 		}
1666 		else
1667 			len = *status;
1668 
1669 
1670 		result = usbat_read_block(us, scsi_sglist(srb), len,
1671 			                                   scsi_sg_count(srb));
1672 	}
1673 
1674 	return result;
1675 }
1676 
1677 /*
1678  * Transport for USBAT02-based CompactFlash and similar storage devices
1679  */
1680 static int usbat_flash_transport(struct scsi_cmnd * srb, struct us_data *us)
1681 {
1682 	int rc;
1683 	struct usbat_info *info = (struct usbat_info *) (us->extra);
1684 	unsigned long block, blocks;
1685 	unsigned char *ptr = us->iobuf;
1686 	static unsigned char inquiry_response[36] = {
1687 		0x00, 0x80, 0x00, 0x01, 0x1F, 0x00, 0x00, 0x00
1688 	};
1689 
1690 	if (srb->cmnd[0] == INQUIRY) {
1691 		usb_stor_dbg(us, "INQUIRY - Returning bogus response\n");
1692 		memcpy(ptr, inquiry_response, sizeof(inquiry_response));
1693 		fill_inquiry_response(us, ptr, 36);
1694 		return USB_STOR_TRANSPORT_GOOD;
1695 	}
1696 
1697 	if (srb->cmnd[0] == READ_CAPACITY) {
1698 		rc = usbat_flash_check_media(us, info);
1699 		if (rc != USB_STOR_TRANSPORT_GOOD)
1700 			return rc;
1701 
1702 		rc = usbat_flash_get_sector_count(us, info);
1703 		if (rc != USB_STOR_TRANSPORT_GOOD)
1704 			return rc;
1705 
1706 		/* hard coded 512 byte sectors as per ATA spec */
1707 		info->ssize = 0x200;
1708 		usb_stor_dbg(us, "READ_CAPACITY: %ld sectors, %ld bytes per sector\n",
1709 			     info->sectors, info->ssize);
1710 
1711 		/*
1712 		 * build the reply
1713 		 * note: must return the sector number of the last sector,
1714 		 * *not* the total number of sectors
1715 		 */
1716 		((__be32 *) ptr)[0] = cpu_to_be32(info->sectors - 1);
1717 		((__be32 *) ptr)[1] = cpu_to_be32(info->ssize);
1718 		usb_stor_set_xfer_buf(ptr, 8, srb);
1719 
1720 		return USB_STOR_TRANSPORT_GOOD;
1721 	}
1722 
1723 	if (srb->cmnd[0] == MODE_SELECT_10) {
1724 		usb_stor_dbg(us, "Gah! MODE_SELECT_10\n");
1725 		return USB_STOR_TRANSPORT_ERROR;
1726 	}
1727 
1728 	if (srb->cmnd[0] == READ_10) {
1729 		block = ((u32)(srb->cmnd[2]) << 24) | ((u32)(srb->cmnd[3]) << 16) |
1730 				((u32)(srb->cmnd[4]) <<  8) | ((u32)(srb->cmnd[5]));
1731 
1732 		blocks = ((u32)(srb->cmnd[7]) << 8) | ((u32)(srb->cmnd[8]));
1733 
1734 		usb_stor_dbg(us, "READ_10: read block 0x%04lx  count %ld\n",
1735 			     block, blocks);
1736 		return usbat_flash_read_data(us, info, block, blocks);
1737 	}
1738 
1739 	if (srb->cmnd[0] == READ_12) {
1740 		/*
1741 		 * I don't think we'll ever see a READ_12 but support it anyway
1742 		 */
1743 		block = ((u32)(srb->cmnd[2]) << 24) | ((u32)(srb->cmnd[3]) << 16) |
1744 		        ((u32)(srb->cmnd[4]) <<  8) | ((u32)(srb->cmnd[5]));
1745 
1746 		blocks = ((u32)(srb->cmnd[6]) << 24) | ((u32)(srb->cmnd[7]) << 16) |
1747 		         ((u32)(srb->cmnd[8]) <<  8) | ((u32)(srb->cmnd[9]));
1748 
1749 		usb_stor_dbg(us, "READ_12: read block 0x%04lx  count %ld\n",
1750 			     block, blocks);
1751 		return usbat_flash_read_data(us, info, block, blocks);
1752 	}
1753 
1754 	if (srb->cmnd[0] == WRITE_10) {
1755 		block = ((u32)(srb->cmnd[2]) << 24) | ((u32)(srb->cmnd[3]) << 16) |
1756 		        ((u32)(srb->cmnd[4]) <<  8) | ((u32)(srb->cmnd[5]));
1757 
1758 		blocks = ((u32)(srb->cmnd[7]) << 8) | ((u32)(srb->cmnd[8]));
1759 
1760 		usb_stor_dbg(us, "WRITE_10: write block 0x%04lx  count %ld\n",
1761 			     block, blocks);
1762 		return usbat_flash_write_data(us, info, block, blocks);
1763 	}
1764 
1765 	if (srb->cmnd[0] == WRITE_12) {
1766 		/*
1767 		 * I don't think we'll ever see a WRITE_12 but support it anyway
1768 		 */
1769 		block = ((u32)(srb->cmnd[2]) << 24) | ((u32)(srb->cmnd[3]) << 16) |
1770 		        ((u32)(srb->cmnd[4]) <<  8) | ((u32)(srb->cmnd[5]));
1771 
1772 		blocks = ((u32)(srb->cmnd[6]) << 24) | ((u32)(srb->cmnd[7]) << 16) |
1773 		         ((u32)(srb->cmnd[8]) <<  8) | ((u32)(srb->cmnd[9]));
1774 
1775 		usb_stor_dbg(us, "WRITE_12: write block 0x%04lx  count %ld\n",
1776 			     block, blocks);
1777 		return usbat_flash_write_data(us, info, block, blocks);
1778 	}
1779 
1780 
1781 	if (srb->cmnd[0] == TEST_UNIT_READY) {
1782 		usb_stor_dbg(us, "TEST_UNIT_READY\n");
1783 
1784 		rc = usbat_flash_check_media(us, info);
1785 		if (rc != USB_STOR_TRANSPORT_GOOD)
1786 			return rc;
1787 
1788 		return usbat_check_status(us);
1789 	}
1790 
1791 	if (srb->cmnd[0] == REQUEST_SENSE) {
1792 		usb_stor_dbg(us, "REQUEST_SENSE\n");
1793 
1794 		memset(ptr, 0, 18);
1795 		ptr[0] = 0xF0;
1796 		ptr[2] = info->sense_key;
1797 		ptr[7] = 11;
1798 		ptr[12] = info->sense_asc;
1799 		ptr[13] = info->sense_ascq;
1800 		usb_stor_set_xfer_buf(ptr, 18, srb);
1801 
1802 		return USB_STOR_TRANSPORT_GOOD;
1803 	}
1804 
1805 	if (srb->cmnd[0] == ALLOW_MEDIUM_REMOVAL) {
1806 		/*
1807 		 * sure.  whatever.  not like we can stop the user from popping
1808 		 * the media out of the device (no locking doors, etc)
1809 		 */
1810 		return USB_STOR_TRANSPORT_GOOD;
1811 	}
1812 
1813 	usb_stor_dbg(us, "Gah! Unknown command: %d (0x%x)\n",
1814 		     srb->cmnd[0], srb->cmnd[0]);
1815 	info->sense_key = 0x05;
1816 	info->sense_asc = 0x20;
1817 	info->sense_ascq = 0x00;
1818 	return USB_STOR_TRANSPORT_FAILED;
1819 }
1820 
1821 static int init_usbat_cd(struct us_data *us)
1822 {
1823 	return init_usbat(us, USBAT_DEV_HP8200);
1824 }
1825 
1826 static int init_usbat_flash(struct us_data *us)
1827 {
1828 	return init_usbat(us, USBAT_DEV_FLASH);
1829 }
1830 
1831 static struct scsi_host_template usbat_host_template;
1832 
1833 static int usbat_probe(struct usb_interface *intf,
1834 			 const struct usb_device_id *id)
1835 {
1836 	struct us_data *us;
1837 	int result;
1838 
1839 	result = usb_stor_probe1(&us, intf, id,
1840 			(id - usbat_usb_ids) + usbat_unusual_dev_list,
1841 			&usbat_host_template);
1842 	if (result)
1843 		return result;
1844 
1845 	/*
1846 	 * The actual transport will be determined later by the
1847 	 * initialization routine; this is just a placeholder.
1848 	 */
1849 	us->transport_name = "Shuttle USBAT";
1850 	us->transport = usbat_flash_transport;
1851 	us->transport_reset = usb_stor_CB_reset;
1852 	us->max_lun = 0;
1853 
1854 	result = usb_stor_probe2(us);
1855 	return result;
1856 }
1857 
1858 static struct usb_driver usbat_driver = {
1859 	.name =		DRV_NAME,
1860 	.probe =	usbat_probe,
1861 	.disconnect =	usb_stor_disconnect,
1862 	.suspend =	usb_stor_suspend,
1863 	.resume =	usb_stor_resume,
1864 	.reset_resume =	usb_stor_reset_resume,
1865 	.pre_reset =	usb_stor_pre_reset,
1866 	.post_reset =	usb_stor_post_reset,
1867 	.id_table =	usbat_usb_ids,
1868 	.soft_unbind =	1,
1869 	.no_dynamic_id = 1,
1870 };
1871 
1872 module_usb_stor_driver(usbat_driver, usbat_host_template, DRV_NAME);
1873