[mirror_ubuntu-focal-kernel.git] / drivers / usb / storage / jumpshot.c

// SPDX-License-Identifier: GPL-2.0+
/*
 * Driver for Lexar "Jumpshot" Compact Flash reader
 *
 * jumpshot driver v0.1:
 *
 * First release
 *
 * Current development and maintenance by:
 *   (c) 2000 Jimmie Mayfield (mayfield+usb@sackheads.org)
 *
 *   Many thanks to Robert Baruch for the SanDisk SmartMedia reader driver
 *   which I used as a template for this driver.
 *
 *   Some bugfixes and scatter-gather code by Gregory P. Smith 
 *   (greg-usb@electricrain.com)
 *
 *   Fix for media change by Joerg Schneider (js@joergschneider.com)
 *
 * Developed with the assistance of:
 *
 *   (C) 2002 Alan Stern <stern@rowland.org>
 */
 
 /*
  * This driver attempts to support the Lexar Jumpshot USB CompactFlash 
  * reader.  Like many other USB CompactFlash readers, the Jumpshot contains
  * a USB-to-ATA chip. 
  *
  * This driver supports reading and writing.  If you're truly paranoid,
  * however, you can force the driver into a write-protected state by setting
  * the WP enable bits in jumpshot_handle_mode_sense.  See the comments
  * in that routine.
  */

#include <linux/errno.h>
#include <linux/module.h>
#include <linux/slab.h>

#include <scsi/scsi.h>
#include <scsi/scsi_cmnd.h>

#include "usb.h"
#include "transport.h"
#include "protocol.h"
#include "debug.h"
#include "scsiglue.h"

#define DRV_NAME "ums-jumpshot"

MODULE_DESCRIPTION("Driver for Lexar \"Jumpshot\" Compact Flash reader");
MODULE_AUTHOR("Jimmie Mayfield <mayfield+usb@sackheads.org>");
MODULE_LICENSE("GPL");

/*
 * The table of devices
 */
#define UNUSUAL_DEV(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax, \
		    vendorName, productName, useProtocol, useTransport, \
		    initFunction, flags) \
{ USB_DEVICE_VER(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax), \
  .driver_info = (flags) }

static struct usb_device_id jumpshot_usb_ids[] = {
#	include "unusual_jumpshot.h"
	{ }		/* Terminating entry */
};
MODULE_DEVICE_TABLE(usb, jumpshot_usb_ids);

#undef UNUSUAL_DEV

/*
 * The flags table
 */
#define UNUSUAL_DEV(idVendor, idProduct, bcdDeviceMin, bcdDeviceMax, \
		    vendor_name, product_name, use_protocol, use_transport, \
		    init_function, Flags) \
{ \
	.vendorName = vendor_name,	\
	.productName = product_name,	\
	.useProtocol = use_protocol,	\
	.useTransport = use_transport,	\
	.initFunction = init_function,	\
}

static struct us_unusual_dev jumpshot_unusual_dev_list[] = {
#	include "unusual_jumpshot.h"
	{ }		/* Terminating entry */
};

#undef UNUSUAL_DEV


struct jumpshot_info {
   unsigned long   sectors;     /* total sector count */
   unsigned long   ssize;       /* sector size in bytes */

   /* the following aren't used yet */
   unsigned char   sense_key;
   unsigned long   sense_asc;   /* additional sense code */
   unsigned long   sense_ascq;  /* additional sense code qualifier */
};

static inline int jumpshot_bulk_read(struct us_data *us,
				     unsigned char *data, 
				     unsigned int len)
{
	if (len == 0)
		return USB_STOR_XFER_GOOD;

	usb_stor_dbg(us, "len = %d\n", len);
	return usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe,
			data, len, NULL);
}


static inline int jumpshot_bulk_write(struct us_data *us,
				      unsigned char *data, 
				      unsigned int len)
{
	if (len == 0)
		return USB_STOR_XFER_GOOD;

	usb_stor_dbg(us, "len = %d\n", len);
	return usb_stor_bulk_transfer_buf(us, us->send_bulk_pipe,
			data, len, NULL);
}


static int jumpshot_get_status(struct us_data  *us)
{
	int rc;

	if (!us)
		return USB_STOR_TRANSPORT_ERROR;

	// send the setup
	rc = usb_stor_ctrl_transfer(us, us->recv_ctrl_pipe,
				   0, 0xA0, 0, 7, us->iobuf, 1);

	if (rc != USB_STOR_XFER_GOOD)
		return USB_STOR_TRANSPORT_ERROR;

	if (us->iobuf[0] != 0x50) {
		usb_stor_dbg(us, "0x%2x\n", us->iobuf[0]);
		return USB_STOR_TRANSPORT_ERROR;
	}

	return USB_STOR_TRANSPORT_GOOD;
}

static int jumpshot_read_data(struct us_data *us,
			      struct jumpshot_info *info,
			      u32 sector,
			      u32 sectors)
{
	unsigned char *command = us->iobuf;
	unsigned char *buffer;
	unsigned char  thistime;
	unsigned int totallen, alloclen;
	int len, result;
	unsigned int sg_offset = 0;
	struct scatterlist *sg = NULL;

	// we're working in LBA mode.  according to the ATA spec, 
	// we can support up to 28-bit addressing.  I don't know if Jumpshot
	// supports beyond 24-bit addressing.  It's kind of hard to test 
	// since it requires > 8GB CF card.

	if (sector > 0x0FFFFFFF)
		return USB_STOR_TRANSPORT_ERROR;

	totallen = sectors * info->ssize;

	// Since we don't read more than 64 KB at a time, we have to create
	// a bounce buffer and move the data a piece at a time between the
	// bounce buffer and the actual transfer buffer.

	alloclen = min(totallen, 65536u);
	buffer = kmalloc(alloclen, GFP_NOIO);
	if (buffer == NULL)
		return USB_STOR_TRANSPORT_ERROR;

	do {
		// loop, never allocate or transfer more than 64k at once
		// (min(128k, 255*info->ssize) is the real limit)
		len = min(totallen, alloclen);
		thistime = (len / info->ssize) & 0xff;

		command[0] = 0;
		command[1] = thistime;
		command[2] = sector & 0xFF;
		command[3] = (sector >>  8) & 0xFF;
		command[4] = (sector >> 16) & 0xFF;

		command[5] = 0xE0 | ((sector >> 24) & 0x0F);
		command[6] = 0x20;

		// send the setup + command
		result = usb_stor_ctrl_transfer(us, us->send_ctrl_pipe,
					       0, 0x20, 0, 1, command, 7);
		if (result != USB_STOR_XFER_GOOD)
			goto leave;

		// read the result
		result = jumpshot_bulk_read(us, buffer, len);
		if (result != USB_STOR_XFER_GOOD)
			goto leave;

		usb_stor_dbg(us, "%d bytes\n", len);

		// Store the data in the transfer buffer
		usb_stor_access_xfer_buf(buffer, len, us->srb,
				 &sg, &sg_offset, TO_XFER_BUF);

		sector += thistime;
		totallen -= len;
	} while (totallen > 0);

	kfree(buffer);
	return USB_STOR_TRANSPORT_GOOD;

 leave:
	kfree(buffer);
	return USB_STOR_TRANSPORT_ERROR;
}


static int jumpshot_write_data(struct us_data *us,
			       struct jumpshot_info *info,
			       u32 sector,
			       u32 sectors)
{
	unsigned char *command = us->iobuf;
	unsigned char *buffer;
	unsigned char  thistime;
	unsigned int totallen, alloclen;
	int len, result, waitcount;
	unsigned int sg_offset = 0;
	struct scatterlist *sg = NULL;

	// we're working in LBA mode.  according to the ATA spec, 
	// we can support up to 28-bit addressing.  I don't know if Jumpshot
	// supports beyond 24-bit addressing.  It's kind of hard to test 
	// since it requires > 8GB CF card.
	//
	if (sector > 0x0FFFFFFF)
		return USB_STOR_TRANSPORT_ERROR;

	totallen = sectors * info->ssize;

	// Since we don't write more than 64 KB at a time, we have to create
	// a bounce buffer and move the data a piece at a time between the
	// bounce buffer and the actual transfer buffer.

	alloclen = min(totallen, 65536u);
	buffer = kmalloc(alloclen, GFP_NOIO);
	if (buffer == NULL)
		return USB_STOR_TRANSPORT_ERROR;

	do {
		// loop, never allocate or transfer more than 64k at once
		// (min(128k, 255*info->ssize) is the real limit)

		len = min(totallen, alloclen);
		thistime = (len / info->ssize) & 0xff;

		// Get the data from the transfer buffer
		usb_stor_access_xfer_buf(buffer, len, us->srb,
				&sg, &sg_offset, FROM_XFER_BUF);

		command[0] = 0;
		command[1] = thistime;
		command[2] = sector & 0xFF;
		command[3] = (sector >>  8) & 0xFF;
		command[4] = (sector >> 16) & 0xFF;

		command[5] = 0xE0 | ((sector >> 24) & 0x0F);
		command[6] = 0x30;

		// send the setup + command
		result = usb_stor_ctrl_transfer(us, us->send_ctrl_pipe,
			0, 0x20, 0, 1, command, 7);
		if (result != USB_STOR_XFER_GOOD)
			goto leave;

		// send the data
		result = jumpshot_bulk_write(us, buffer, len);
		if (result != USB_STOR_XFER_GOOD)
			goto leave;

		// read the result.  apparently the bulk write can complete
		// before the jumpshot drive is finished writing.  so we loop
		// here until we get a good return code
		waitcount = 0;
		do {
			result = jumpshot_get_status(us);
			if (result != USB_STOR_TRANSPORT_GOOD) {
				// I have not experimented to find the smallest value.
				//
				msleep(50); 
			}
		} while ((result != USB_STOR_TRANSPORT_GOOD) && (waitcount < 10));

		if (result != USB_STOR_TRANSPORT_GOOD)
			usb_stor_dbg(us, "Gah!  Waitcount = 10.  Bad write!?\n");

		sector += thistime;
		totallen -= len;
	} while (totallen > 0);

	kfree(buffer);
	return result;

 leave:
	kfree(buffer);
	return USB_STOR_TRANSPORT_ERROR;
}

static int jumpshot_id_device(struct us_data *us,
			      struct jumpshot_info *info)
{
	unsigned char *command = us->iobuf;
	unsigned char *reply;
	int 	 rc;

	if (!info)
		return USB_STOR_TRANSPORT_ERROR;

	command[0] = 0xE0;
	command[1] = 0xEC;
	reply = kmalloc(512, GFP_NOIO);
	if (!reply)
		return USB_STOR_TRANSPORT_ERROR;

	// send the setup
	rc = usb_stor_ctrl_transfer(us, us->send_ctrl_pipe,
				   0, 0x20, 0, 6, command, 2);

	if (rc != USB_STOR_XFER_GOOD) {
		usb_stor_dbg(us, "Gah! send_control for read_capacity failed\n");
		rc = USB_STOR_TRANSPORT_ERROR;
		goto leave;
	}

	// read the reply
	rc = jumpshot_bulk_read(us, reply, 512);
	if (rc != USB_STOR_XFER_GOOD) {
		rc = USB_STOR_TRANSPORT_ERROR;
		goto leave;
	}

	info->sectors = ((u32)(reply[117]) << 24) |
			((u32)(reply[116]) << 16) |
			((u32)(reply[115]) <<  8) |
			((u32)(reply[114])      );

	rc = USB_STOR_TRANSPORT_GOOD;

 leave:
	kfree(reply);
	return rc;
}

static int jumpshot_handle_mode_sense(struct us_data *us,
				      struct scsi_cmnd * srb, 
				      int sense_6)
{
	static unsigned char rw_err_page[12] = {
		0x1, 0xA, 0x21, 1, 0, 0, 0, 0, 1, 0, 0, 0
	};
	static unsigned char cache_page[12] = {
		0x8, 0xA, 0x1, 0, 0, 0, 0, 0, 0, 0, 0, 0
	};
	static unsigned char rbac_page[12] = {
		0x1B, 0xA, 0, 0x81, 0, 0, 0, 0, 0, 0, 0, 0
	};
	static unsigned char timer_page[8] = {
		0x1C, 0x6, 0, 0, 0, 0
	};
	unsigned char pc, page_code;
	unsigned int i = 0;
	struct jumpshot_info *info = (struct jumpshot_info *) (us->extra);
	unsigned char *ptr = us->iobuf;

	pc = srb->cmnd[2] >> 6;
	page_code = srb->cmnd[2] & 0x3F;

	switch (pc) {
	   case 0x0:
		   usb_stor_dbg(us, "Current values\n");
		   break;
	   case 0x1:
		   usb_stor_dbg(us, "Changeable values\n");
		   break;
	   case 0x2:
		   usb_stor_dbg(us, "Default values\n");
		   break;
	   case 0x3:
		   usb_stor_dbg(us, "Saves values\n");
		   break;
	}

	memset(ptr, 0, 8);
	if (sense_6) {
		ptr[2] = 0x00;		// WP enable: 0x80
		i = 4;
	} else {
		ptr[3] = 0x00;		// WP enable: 0x80
		i = 8;
	}

	switch (page_code) {
	   case 0x0:
		// vendor-specific mode
		info->sense_key = 0x05;
		info->sense_asc = 0x24;
		info->sense_ascq = 0x00;
		return USB_STOR_TRANSPORT_FAILED;

	   case 0x1:
		memcpy(ptr + i, rw_err_page, sizeof(rw_err_page));
		i += sizeof(rw_err_page);
		break;

	   case 0x8:
		memcpy(ptr + i, cache_page, sizeof(cache_page));
		i += sizeof(cache_page);
		break;

	   case 0x1B:
		memcpy(ptr + i, rbac_page, sizeof(rbac_page));
		i += sizeof(rbac_page);
		break;

	   case 0x1C:
		memcpy(ptr + i, timer_page, sizeof(timer_page));
		i += sizeof(timer_page);
		break;

	   case 0x3F:
		memcpy(ptr + i, timer_page, sizeof(timer_page));
		i += sizeof(timer_page);
		memcpy(ptr + i, rbac_page, sizeof(rbac_page));
		i += sizeof(rbac_page);
		memcpy(ptr + i, cache_page, sizeof(cache_page));
		i += sizeof(cache_page);
		memcpy(ptr + i, rw_err_page, sizeof(rw_err_page));
		i += sizeof(rw_err_page);
		break;
	}

	if (sense_6)
		ptr[0] = i - 1;
	else
		((__be16 *) ptr)[0] = cpu_to_be16(i - 2);
	usb_stor_set_xfer_buf(ptr, i, srb);

	return USB_STOR_TRANSPORT_GOOD;
}


static void jumpshot_info_destructor(void *extra)
{
	// this routine is a placeholder...
	// currently, we don't allocate any extra blocks so we're okay
}


// Transport for the Lexar 'Jumpshot'
//
static int jumpshot_transport(struct scsi_cmnd *srb, struct us_data *us)
{
	struct jumpshot_info *info;
	int rc;
	unsigned long block, blocks;
	unsigned char *ptr = us->iobuf;
	static unsigned char inquiry_response[8] = {
		0x00, 0x80, 0x00, 0x01, 0x1F, 0x00, 0x00, 0x00
	};

	if (!us->extra) {
		us->extra = kzalloc(sizeof(struct jumpshot_info), GFP_NOIO);
		if (!us->extra)
			return USB_STOR_TRANSPORT_ERROR;

		us->extra_destructor = jumpshot_info_destructor;
	}

	info = (struct jumpshot_info *) (us->extra);

	if (srb->cmnd[0] == INQUIRY) {
		usb_stor_dbg(us, "INQUIRY - Returning bogus response\n");
		memcpy(ptr, inquiry_response, sizeof(inquiry_response));
		fill_inquiry_response(us, ptr, 36);
		return USB_STOR_TRANSPORT_GOOD;
	}

	if (srb->cmnd[0] == READ_CAPACITY) {
		info->ssize = 0x200;  // hard coded 512 byte sectors as per ATA spec

		rc = jumpshot_get_status(us);
		if (rc != USB_STOR_TRANSPORT_GOOD)
			return rc;

		rc = jumpshot_id_device(us, info);
		if (rc != USB_STOR_TRANSPORT_GOOD)
			return rc;

		usb_stor_dbg(us, "READ_CAPACITY:  %ld sectors, %ld bytes per sector\n",
			     info->sectors, info->ssize);

		// build the reply
		//
		((__be32 *) ptr)[0] = cpu_to_be32(info->sectors - 1);
		((__be32 *) ptr)[1] = cpu_to_be32(info->ssize);
		usb_stor_set_xfer_buf(ptr, 8, srb);

		return USB_STOR_TRANSPORT_GOOD;
	}

	if (srb->cmnd[0] == MODE_SELECT_10) {
		usb_stor_dbg(us, "Gah! MODE_SELECT_10\n");
		return USB_STOR_TRANSPORT_ERROR;
	}

	if (srb->cmnd[0] == READ_10) {
		block = ((u32)(srb->cmnd[2]) << 24) | ((u32)(srb->cmnd[3]) << 16) |
			((u32)(srb->cmnd[4]) <<  8) | ((u32)(srb->cmnd[5]));

		blocks = ((u32)(srb->cmnd[7]) << 8) | ((u32)(srb->cmnd[8]));

		usb_stor_dbg(us, "READ_10: read block 0x%04lx  count %ld\n",
			     block, blocks);
		return jumpshot_read_data(us, info, block, blocks);
	}

	if (srb->cmnd[0] == READ_12) {
		// I don't think we'll ever see a READ_12 but support it anyway...
		//
		block = ((u32)(srb->cmnd[2]) << 24) | ((u32)(srb->cmnd[3]) << 16) |
			((u32)(srb->cmnd[4]) <<  8) | ((u32)(srb->cmnd[5]));

		blocks = ((u32)(srb->cmnd[6]) << 24) | ((u32)(srb->cmnd[7]) << 16) |
			 ((u32)(srb->cmnd[8]) <<  8) | ((u32)(srb->cmnd[9]));

		usb_stor_dbg(us, "READ_12: read block 0x%04lx  count %ld\n",
			     block, blocks);
		return jumpshot_read_data(us, info, block, blocks);
	}

	if (srb->cmnd[0] == WRITE_10) {
		block = ((u32)(srb->cmnd[2]) << 24) | ((u32)(srb->cmnd[3]) << 16) |
			((u32)(srb->cmnd[4]) <<  8) | ((u32)(srb->cmnd[5]));

		blocks = ((u32)(srb->cmnd[7]) << 8) | ((u32)(srb->cmnd[8]));

		usb_stor_dbg(us, "WRITE_10: write block 0x%04lx  count %ld\n",
			     block, blocks);
		return jumpshot_write_data(us, info, block, blocks);
	}

	if (srb->cmnd[0] == WRITE_12) {
		// I don't think we'll ever see a WRITE_12 but support it anyway...
		//
		block = ((u32)(srb->cmnd[2]) << 24) | ((u32)(srb->cmnd[3]) << 16) |
			((u32)(srb->cmnd[4]) <<  8) | ((u32)(srb->cmnd[5]));

		blocks = ((u32)(srb->cmnd[6]) << 24) | ((u32)(srb->cmnd[7]) << 16) |
			 ((u32)(srb->cmnd[8]) <<  8) | ((u32)(srb->cmnd[9]));

		usb_stor_dbg(us, "WRITE_12: write block 0x%04lx  count %ld\n",
			     block, blocks);
		return jumpshot_write_data(us, info, block, blocks);
	}


	if (srb->cmnd[0] == TEST_UNIT_READY) {
		usb_stor_dbg(us, "TEST_UNIT_READY\n");
		return jumpshot_get_status(us);
	}

	if (srb->cmnd[0] == REQUEST_SENSE) {
		usb_stor_dbg(us, "REQUEST_SENSE\n");

		memset(ptr, 0, 18);
		ptr[0] = 0xF0;
		ptr[2] = info->sense_key;
		ptr[7] = 11;
		ptr[12] = info->sense_asc;
		ptr[13] = info->sense_ascq;
		usb_stor_set_xfer_buf(ptr, 18, srb);

		return USB_STOR_TRANSPORT_GOOD;
	}

	if (srb->cmnd[0] == MODE_SENSE) {
		usb_stor_dbg(us, "MODE_SENSE_6 detected\n");
		return jumpshot_handle_mode_sense(us, srb, 1);
	}

	if (srb->cmnd[0] == MODE_SENSE_10) {
		usb_stor_dbg(us, "MODE_SENSE_10 detected\n");
		return jumpshot_handle_mode_sense(us, srb, 0);
	}

	if (srb->cmnd[0] == ALLOW_MEDIUM_REMOVAL) {
		/*
		 * sure.  whatever.  not like we can stop the user from popping
		 * the media out of the device (no locking doors, etc)
		 */
		return USB_STOR_TRANSPORT_GOOD;
	}

	if (srb->cmnd[0] == START_STOP) {
		/*
		 * this is used by sd.c'check_scsidisk_media_change to detect
		 * media change
		 */
		usb_stor_dbg(us, "START_STOP\n");
		/*
		 * the first jumpshot_id_device after a media change returns
		 * an error (determined experimentally)
		 */
		rc = jumpshot_id_device(us, info);
		if (rc == USB_STOR_TRANSPORT_GOOD) {
			info->sense_key = NO_SENSE;
			srb->result = SUCCESS;
		} else {
			info->sense_key = UNIT_ATTENTION;
			srb->result = SAM_STAT_CHECK_CONDITION;
		}
		return rc;
	}

	usb_stor_dbg(us, "Gah! Unknown command: %d (0x%x)\n",
		     srb->cmnd[0], srb->cmnd[0]);
	info->sense_key = 0x05;
	info->sense_asc = 0x20;
	info->sense_ascq = 0x00;
	return USB_STOR_TRANSPORT_FAILED;
}

static struct scsi_host_template jumpshot_host_template;

static int jumpshot_probe(struct usb_interface *intf,
			 const struct usb_device_id *id)
{
	struct us_data *us;
	int result;

	result = usb_stor_probe1(&us, intf, id,
			(id - jumpshot_usb_ids) + jumpshot_unusual_dev_list,
			&jumpshot_host_template);
	if (result)
		return result;

	us->transport_name  = "Lexar Jumpshot Control/Bulk";
	us->transport = jumpshot_transport;
	us->transport_reset = usb_stor_Bulk_reset;
	us->max_lun = 1;

	result = usb_stor_probe2(us);
	return result;
}

static struct usb_driver jumpshot_driver = {
	.name =		DRV_NAME,
	.probe =	jumpshot_probe,
	.disconnect =	usb_stor_disconnect,
	.suspend =	usb_stor_suspend,
	.resume =	usb_stor_resume,
	.reset_resume =	usb_stor_reset_resume,
	.pre_reset =	usb_stor_pre_reset,
	.post_reset =	usb_stor_post_reset,
	.id_table =	jumpshot_usb_ids,
	.soft_unbind =	1,
	.no_dynamic_id = 1,
};

module_usb_stor_driver(jumpshot_driver, jumpshot_host_template, DRV_NAME);
Commit	Line	Data
5fd54ace	1	// SPDX-License-Identifier: GPL-2.0+
f0183a33 FB	2	/*
f0183a33 FB	3	* Driver for Lexar "Jumpshot" Compact Flash reader
1da177e4 LT	4	*
	5	* jumpshot driver v0.1:
	6	*
	7	* First release
	8	*
	9	* Current development and maintenance by:
	10	* (c) 2000 Jimmie Mayfield (mayfield+usb@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	* Developed with the assistance of:
	21	*
	22	* (C) 2002 Alan Stern <stern@rowland.org>
1da177e4 LT	23	*/
	24
	25	/*
	26	* This driver attempts to support the Lexar Jumpshot USB CompactFlash
	27	* reader. Like many other USB CompactFlash readers, the Jumpshot contains
	28	* a USB-to-ATA chip.
	29	*
	30	* This driver supports reading and writing. If you're truly paranoid,
	31	* however, you can force the driver into a write-protected state by setting
	32	* the WP enable bits in jumpshot_handle_mode_sense. See the comments
	33	* in that routine.
	34	*/
	35
1da177e4	36	#include <linux/errno.h>
a9fb6d05	37	#include <linux/module.h>
1da177e4 LT	38	#include <linux/slab.h>
	39
	40	#include <scsi/scsi.h>
	41	#include <scsi/scsi_cmnd.h>
	42
	43	#include "usb.h"
	44	#include "transport.h"
	45	#include "protocol.h"
	46	#include "debug.h"
aa519be3	47	#include "scsiglue.h"
1da177e4	48
aa519be3	49	#define DRV_NAME "ums-jumpshot"
1da177e4	50
4246b06a MG	51	MODULE_DESCRIPTION("Driver for Lexar \"Jumpshot\" Compact Flash reader");
	52	MODULE_AUTHOR("Jimmie Mayfield <mayfield+usb@sackheads.org>");
	53	MODULE_LICENSE("GPL");
	54
a9fb6d05 AS	55	/*
	56	* The table of devices
	57	*/
	58	#define UNUSUAL_DEV(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax, \
	59	vendorName, productName, useProtocol, useTransport, \
	60	initFunction, flags) \
	61	{ USB_DEVICE_VER(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax), \
f61870ee	62	.driver_info = (flags) }
a9fb6d05	63
9d35214b	64	static struct usb_device_id jumpshot_usb_ids[] = {
a9fb6d05 AS	65	# include "unusual_jumpshot.h"
	66	{ } /* Terminating entry */
	67	};
	68	MODULE_DEVICE_TABLE(usb, jumpshot_usb_ids);
	69
	70	#undef UNUSUAL_DEV
	71
	72	/*
	73	* The flags table
	74	*/
	75	#define UNUSUAL_DEV(idVendor, idProduct, bcdDeviceMin, bcdDeviceMax, \
	76	vendor_name, product_name, use_protocol, use_transport, \
	77	init_function, Flags) \
	78	{ \
	79	.vendorName = vendor_name, \
	80	.productName = product_name, \
	81	.useProtocol = use_protocol, \
	82	.useTransport = use_transport, \
	83	.initFunction = init_function, \
	84	}
	85
	86	static struct us_unusual_dev jumpshot_unusual_dev_list[] = {
	87	# include "unusual_jumpshot.h"
	88	{ } /* Terminating entry */
	89	};
	90
	91	#undef UNUSUAL_DEV
	92
	93
	94	struct jumpshot_info {
	95	unsigned long sectors; /* total sector count */
	96	unsigned long ssize; /* sector size in bytes */
	97
	98	/* the following aren't used yet */
	99	unsigned char sense_key;
	100	unsigned long sense_asc; /* additional sense code */
	101	unsigned long sense_ascq; /* additional sense code qualifier */
	102	};
	103
1da177e4 LT	104	static inline int jumpshot_bulk_read(struct us_data *us,
	105	unsigned char *data,
	106	unsigned int len)
	107	{
	108	if (len == 0)
	109	return USB_STOR_XFER_GOOD;
	110
191648d0	111	usb_stor_dbg(us, "len = %d\n", len);
1da177e4 LT	112	return usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe,
	113	data, len, NULL);
	114	}
	115
	116
	117	static inline int jumpshot_bulk_write(struct us_data *us,
	118	unsigned char *data,
	119	unsigned int len)
	120	{
	121	if (len == 0)
	122	return USB_STOR_XFER_GOOD;
	123
191648d0	124	usb_stor_dbg(us, "len = %d\n", len);
1da177e4 LT	125	return usb_stor_bulk_transfer_buf(us, us->send_bulk_pipe,
	126	data, len, NULL);
	127	}
	128
	129
	130	static int jumpshot_get_status(struct us_data *us)
	131	{
	132	int rc;
	133
	134	if (!us)
	135	return USB_STOR_TRANSPORT_ERROR;
	136
	137	// send the setup
	138	rc = usb_stor_ctrl_transfer(us, us->recv_ctrl_pipe,
	139	0, 0xA0, 0, 7, us->iobuf, 1);
	140
	141	if (rc != USB_STOR_XFER_GOOD)
	142	return USB_STOR_TRANSPORT_ERROR;
	143
	144	if (us->iobuf[0] != 0x50) {
191648d0	145	usb_stor_dbg(us, "0x%2x\n", us->iobuf[0]);
1da177e4 LT	146	return USB_STOR_TRANSPORT_ERROR;
	147	}
	148
	149	return USB_STOR_TRANSPORT_GOOD;
	150	}
	151
	152	static int jumpshot_read_data(struct us_data *us,
	153	struct jumpshot_info *info,
	154	u32 sector,
	155	u32 sectors)
	156	{
	157	unsigned char *command = us->iobuf;
	158	unsigned char *buffer;
	159	unsigned char thistime;
	160	unsigned int totallen, alloclen;
	161	int len, result;
1f6f31a0 JA	162	unsigned int sg_offset = 0;
1f6f31a0 JA	163	struct scatterlist *sg = NULL;
1da177e4 LT	164
	165	// we're working in LBA mode. according to the ATA spec,
	166	// we can support up to 28-bit addressing. I don't know if Jumpshot
	167	// supports beyond 24-bit addressing. It's kind of hard to test
	168	// since it requires > 8GB CF card.
	169
	170	if (sector > 0x0FFFFFFF)
	171	return USB_STOR_TRANSPORT_ERROR;
	172
	173	totallen = sectors * info->ssize;
	174
	175	// Since we don't read more than 64 KB at a time, we have to create
	176	// a bounce buffer and move the data a piece at a time between the
	177	// bounce buffer and the actual transfer buffer.
	178
	179	alloclen = min(totallen, 65536u);
	180	buffer = kmalloc(alloclen, GFP_NOIO);
	181	if (buffer == NULL)
	182	return USB_STOR_TRANSPORT_ERROR;
	183
	184	do {
	185	// loop, never allocate or transfer more than 64k at once
	186	// (min(128k, 255*info->ssize) is the real limit)
	187	len = min(totallen, alloclen);
	188	thistime = (len / info->ssize) & 0xff;
	189
	190	command[0] = 0;
	191	command[1] = thistime;
	192	command[2] = sector & 0xFF;
	193	command[3] = (sector >> 8) & 0xFF;
	194	command[4] = (sector >> 16) & 0xFF;
	195
	196	command[5] = 0xE0 \| ((sector >> 24) & 0x0F);
	197	command[6] = 0x20;
	198
	199	// send the setup + command
	200	result = usb_stor_ctrl_transfer(us, us->send_ctrl_pipe,
	201	0, 0x20, 0, 1, command, 7);
	202	if (result != USB_STOR_XFER_GOOD)
	203	goto leave;
	204
	205	// read the result
	206	result = jumpshot_bulk_read(us, buffer, len);
	207	if (result != USB_STOR_XFER_GOOD)
	208	goto leave;
	209
191648d0	210	usb_stor_dbg(us, "%d bytes\n", len);
1da177e4 LT	211
	212	// Store the data in the transfer buffer
	213	usb_stor_access_xfer_buf(buffer, len, us->srb,
1f6f31a0	214	&sg, &sg_offset, TO_XFER_BUF);
1da177e4 LT	215
	216	sector += thistime;
	217	totallen -= len;
	218	} while (totallen > 0);
	219
	220	kfree(buffer);
	221	return USB_STOR_TRANSPORT_GOOD;
	222
	223	leave:
	224	kfree(buffer);
	225	return USB_STOR_TRANSPORT_ERROR;
	226	}
	227
	228
	229	static int jumpshot_write_data(struct us_data *us,
	230	struct jumpshot_info *info,
	231	u32 sector,
	232	u32 sectors)
	233	{
	234	unsigned char *command = us->iobuf;
	235	unsigned char *buffer;
	236	unsigned char thistime;
	237	unsigned int totallen, alloclen;
	238	int len, result, waitcount;
1f6f31a0 JA	239	unsigned int sg_offset = 0;
1f6f31a0 JA	240	struct scatterlist *sg = NULL;
1da177e4 LT	241
	242	// we're working in LBA mode. according to the ATA spec,
	243	// we can support up to 28-bit addressing. I don't know if Jumpshot
	244	// supports beyond 24-bit addressing. It's kind of hard to test
	245	// since it requires > 8GB CF card.
	246	//
	247	if (sector > 0x0FFFFFFF)
	248	return USB_STOR_TRANSPORT_ERROR;
	249
	250	totallen = sectors * info->ssize;
	251
	252	// Since we don't write more than 64 KB at a time, we have to create
	253	// a bounce buffer and move the data a piece at a time between the
	254	// bounce buffer and the actual transfer buffer.
	255
	256	alloclen = min(totallen, 65536u);
	257	buffer = kmalloc(alloclen, GFP_NOIO);
	258	if (buffer == NULL)
	259	return USB_STOR_TRANSPORT_ERROR;
	260
	261	do {
	262	// loop, never allocate or transfer more than 64k at once
	263	// (min(128k, 255*info->ssize) is the real limit)
	264
	265	len = min(totallen, alloclen);
	266	thistime = (len / info->ssize) & 0xff;
	267
	268	// Get the data from the transfer buffer
	269	usb_stor_access_xfer_buf(buffer, len, us->srb,
1f6f31a0	270	&sg, &sg_offset, FROM_XFER_BUF);
1da177e4 LT	271
	272	command[0] = 0;
	273	command[1] = thistime;
	274	command[2] = sector & 0xFF;
	275	command[3] = (sector >> 8) & 0xFF;
	276	command[4] = (sector >> 16) & 0xFF;
	277
	278	command[5] = 0xE0 \| ((sector >> 24) & 0x0F);
	279	command[6] = 0x30;
	280
	281	// send the setup + command
	282	result = usb_stor_ctrl_transfer(us, us->send_ctrl_pipe,
	283	0, 0x20, 0, 1, command, 7);
	284	if (result != USB_STOR_XFER_GOOD)
	285	goto leave;
	286
	287	// send the data
	288	result = jumpshot_bulk_write(us, buffer, len);
	289	if (result != USB_STOR_XFER_GOOD)
	290	goto leave;
	291
	292	// read the result. apparently the bulk write can complete
	293	// before the jumpshot drive is finished writing. so we loop
	294	// here until we get a good return code
	295	waitcount = 0;
	296	do {
	297	result = jumpshot_get_status(us);
	298	if (result != USB_STOR_TRANSPORT_GOOD) {
	299	// I have not experimented to find the smallest value.
	300	//
	301	msleep(50);
	302	}
	303	} while ((result != USB_STOR_TRANSPORT_GOOD) && (waitcount < 10));
	304
	305	if (result != USB_STOR_TRANSPORT_GOOD)
191648d0	306	usb_stor_dbg(us, "Gah! Waitcount = 10. Bad write!?\n");
1da177e4 LT	307
	308	sector += thistime;
	309	totallen -= len;
	310	} while (totallen > 0);
	311
	312	kfree(buffer);
	313	return result;
	314
	315	leave:
	316	kfree(buffer);
	317	return USB_STOR_TRANSPORT_ERROR;
	318	}
	319
	320	static int jumpshot_id_device(struct us_data *us,
	321	struct jumpshot_info *info)
	322	{
	323	unsigned char *command = us->iobuf;
	324	unsigned char *reply;
	325	int rc;
	326
64aebe73	327	if (!info)
1da177e4 LT	328	return USB_STOR_TRANSPORT_ERROR;
	329
	330	command[0] = 0xE0;
	331	command[1] = 0xEC;
	332	reply = kmalloc(512, GFP_NOIO);
	333	if (!reply)
	334	return USB_STOR_TRANSPORT_ERROR;
	335
	336	// send the setup
	337	rc = usb_stor_ctrl_transfer(us, us->send_ctrl_pipe,
	338	0, 0x20, 0, 6, command, 2);
	339
	340	if (rc != USB_STOR_XFER_GOOD) {
191648d0	341	usb_stor_dbg(us, "Gah! send_control for read_capacity failed\n");
1da177e4 LT	342	rc = USB_STOR_TRANSPORT_ERROR;
	343	goto leave;
	344	}
	345
	346	// read the reply
	347	rc = jumpshot_bulk_read(us, reply, 512);
	348	if (rc != USB_STOR_XFER_GOOD) {
	349	rc = USB_STOR_TRANSPORT_ERROR;
	350	goto leave;
	351	}
	352
	353	info->sectors = ((u32)(reply[117]) << 24) \|
	354	((u32)(reply[116]) << 16) \|
	355	((u32)(reply[115]) << 8) \|
	356	((u32)(reply[114]) );
	357
	358	rc = USB_STOR_TRANSPORT_GOOD;
	359
	360	leave:
	361	kfree(reply);
	362	return rc;
	363	}
	364
	365	static int jumpshot_handle_mode_sense(struct us_data *us,
	366	struct scsi_cmnd * srb,
	367	int sense_6)
	368	{
	369	static unsigned char rw_err_page[12] = {
	370	0x1, 0xA, 0x21, 1, 0, 0, 0, 0, 1, 0, 0, 0
	371	};
	372	static unsigned char cache_page[12] = {
	373	0x8, 0xA, 0x1, 0, 0, 0, 0, 0, 0, 0, 0, 0
	374	};
	375	static unsigned char rbac_page[12] = {
	376	0x1B, 0xA, 0, 0x81, 0, 0, 0, 0, 0, 0, 0, 0
	377	};
	378	static unsigned char timer_page[8] = {
	379	0x1C, 0x6, 0, 0, 0, 0
	380	};
	381	unsigned char pc, page_code;
	382	unsigned int i = 0;
	383	struct jumpshot_info info = (struct jumpshot_info ) (us->extra);
	384	unsigned char *ptr = us->iobuf;
	385
	386	pc = srb->cmnd[2] >> 6;
	387	page_code = srb->cmnd[2] & 0x3F;
	388
	389	switch (pc) {
	390	case 0x0:
191648d0 JP	391	usb_stor_dbg(us, "Current values\n");
191648d0 JP	392	break;
1da177e4	393	case 0x1:
191648d0 JP	394	usb_stor_dbg(us, "Changeable values\n");
191648d0 JP	395	break;
1da177e4	396	case 0x2:
191648d0 JP	397	usb_stor_dbg(us, "Default values\n");
191648d0 JP	398	break;
1da177e4	399	case 0x3:
191648d0 JP	400	usb_stor_dbg(us, "Saves values\n");
191648d0 JP	401	break;
1da177e4 LT	402	}
	403
	404	memset(ptr, 0, 8);
	405	if (sense_6) {
	406	ptr[2] = 0x00; // WP enable: 0x80
	407	i = 4;
	408	} else {
	409	ptr[3] = 0x00; // WP enable: 0x80
	410	i = 8;
	411	}
	412
	413	switch (page_code) {
	414	case 0x0:
	415	// vendor-specific mode
	416	info->sense_key = 0x05;
	417	info->sense_asc = 0x24;
	418	info->sense_ascq = 0x00;
	419	return USB_STOR_TRANSPORT_FAILED;
	420
	421	case 0x1:
	422	memcpy(ptr + i, rw_err_page, sizeof(rw_err_page));
	423	i += sizeof(rw_err_page);
	424	break;
	425
	426	case 0x8:
	427	memcpy(ptr + i, cache_page, sizeof(cache_page));
	428	i += sizeof(cache_page);
	429	break;
	430
	431	case 0x1B:
	432	memcpy(ptr + i, rbac_page, sizeof(rbac_page));
	433	i += sizeof(rbac_page);
	434	break;
	435
	436	case 0x1C:
	437	memcpy(ptr + i, timer_page, sizeof(timer_page));
	438	i += sizeof(timer_page);
	439	break;
	440
	441	case 0x3F:
	442	memcpy(ptr + i, timer_page, sizeof(timer_page));
	443	i += sizeof(timer_page);
	444	memcpy(ptr + i, rbac_page, sizeof(rbac_page));
	445	i += sizeof(rbac_page);
	446	memcpy(ptr + i, cache_page, sizeof(cache_page));
	447	i += sizeof(cache_page);
	448	memcpy(ptr + i, rw_err_page, sizeof(rw_err_page));
	449	i += sizeof(rw_err_page);
	450	break;
	451	}
	452
	453	if (sense_6)
	454	ptr[0] = i - 1;
	455	else
	456	((__be16 *) ptr)[0] = cpu_to_be16(i - 2);
	457	usb_stor_set_xfer_buf(ptr, i, srb);
	458
	459	return USB_STOR_TRANSPORT_GOOD;
	460	}
	461
	462
	463	static void jumpshot_info_destructor(void *extra)
	464	{
	465	// this routine is a placeholder...
466	// currently, we don't allocate any extra blocks so we're okay
467	}
468
469
470
471	// Transport for the Lexar 'Jumpshot'
472	//
a9fb6d05	473	static int jumpshot_transport(struct scsi_cmnd srb, struct us_data us)
1da177e4 LT	474	{
	475	struct jumpshot_info *info;
	476	int rc;
	477	unsigned long block, blocks;
	478	unsigned char *ptr = us->iobuf;
	479	static unsigned char inquiry_response[8] = {
	480	0x00, 0x80, 0x00, 0x01, 0x1F, 0x00, 0x00, 0x00
	481	};
	482
	483	if (!us->extra) {
887c2560	484	us->extra = kzalloc(sizeof(struct jumpshot_info), GFP_NOIO);
191648d0	485	if (!us->extra)
1da177e4	486	return USB_STOR_TRANSPORT_ERROR;
191648d0	487
1da177e4 LT	488	us->extra_destructor = jumpshot_info_destructor;
	489	}
	490
	491	info = (struct jumpshot_info *) (us->extra);
	492
	493	if (srb->cmnd[0] == INQUIRY) {
191648d0	494	usb_stor_dbg(us, "INQUIRY - Returning bogus response\n");
1da177e4 LT	495	memcpy(ptr, inquiry_response, sizeof(inquiry_response));
	496	fill_inquiry_response(us, ptr, 36);
	497	return USB_STOR_TRANSPORT_GOOD;
	498	}
	499
	500	if (srb->cmnd[0] == READ_CAPACITY) {
	501	info->ssize = 0x200; // hard coded 512 byte sectors as per ATA spec
	502
	503	rc = jumpshot_get_status(us);
	504	if (rc != USB_STOR_TRANSPORT_GOOD)
	505	return rc;
	506
	507	rc = jumpshot_id_device(us, info);
	508	if (rc != USB_STOR_TRANSPORT_GOOD)
	509	return rc;
	510
191648d0 JP	511	usb_stor_dbg(us, "READ_CAPACITY: %ld sectors, %ld bytes per sector\n",
191648d0 JP	512	info->sectors, info->ssize);
1da177e4 LT	513
	514	// build the reply
	515	//
	516	((__be32 *) ptr)[0] = cpu_to_be32(info->sectors - 1);
	517	((__be32 *) ptr)[1] = cpu_to_be32(info->ssize);
	518	usb_stor_set_xfer_buf(ptr, 8, srb);
	519
	520	return USB_STOR_TRANSPORT_GOOD;
	521	}
	522
	523	if (srb->cmnd[0] == MODE_SELECT_10) {
191648d0	524	usb_stor_dbg(us, "Gah! MODE_SELECT_10\n");
1da177e4 LT	525	return USB_STOR_TRANSPORT_ERROR;
	526	}
	527
	528	if (srb->cmnd[0] == READ_10) {
	529	block = ((u32)(srb->cmnd[2]) << 24) \| ((u32)(srb->cmnd[3]) << 16) \|
	530	((u32)(srb->cmnd[4]) << 8) \| ((u32)(srb->cmnd[5]));
	531
	532	blocks = ((u32)(srb->cmnd[7]) << 8) \| ((u32)(srb->cmnd[8]));
	533
191648d0 JP	534	usb_stor_dbg(us, "READ_10: read block 0x%04lx count %ld\n",
191648d0 JP	535	block, blocks);
1da177e4 LT	536	return jumpshot_read_data(us, info, block, blocks);
	537	}
	538
	539	if (srb->cmnd[0] == READ_12) {
	540	// I don't think we'll ever see a READ_12 but support it anyway...
	541	//
	542	block = ((u32)(srb->cmnd[2]) << 24) \| ((u32)(srb->cmnd[3]) << 16) \|
	543	((u32)(srb->cmnd[4]) << 8) \| ((u32)(srb->cmnd[5]));
	544
	545	blocks = ((u32)(srb->cmnd[6]) << 24) \| ((u32)(srb->cmnd[7]) << 16) \|
	546	((u32)(srb->cmnd[8]) << 8) \| ((u32)(srb->cmnd[9]));
	547
191648d0 JP	548	usb_stor_dbg(us, "READ_12: read block 0x%04lx count %ld\n",
191648d0 JP	549	block, blocks);
1da177e4 LT	550	return jumpshot_read_data(us, info, block, blocks);
	551	}
	552
	553	if (srb->cmnd[0] == WRITE_10) {
	554	block = ((u32)(srb->cmnd[2]) << 24) \| ((u32)(srb->cmnd[3]) << 16) \|
	555	((u32)(srb->cmnd[4]) << 8) \| ((u32)(srb->cmnd[5]));
	556
	557	blocks = ((u32)(srb->cmnd[7]) << 8) \| ((u32)(srb->cmnd[8]));
	558
191648d0 JP	559	usb_stor_dbg(us, "WRITE_10: write block 0x%04lx count %ld\n",
191648d0 JP	560	block, blocks);
1da177e4 LT	561	return jumpshot_write_data(us, info, block, blocks);
	562	}
	563
	564	if (srb->cmnd[0] == WRITE_12) {
	565	// I don't think we'll ever see a WRITE_12 but support it anyway...
	566	//
	567	block = ((u32)(srb->cmnd[2]) << 24) \| ((u32)(srb->cmnd[3]) << 16) \|
	568	((u32)(srb->cmnd[4]) << 8) \| ((u32)(srb->cmnd[5]));
	569
	570	blocks = ((u32)(srb->cmnd[6]) << 24) \| ((u32)(srb->cmnd[7]) << 16) \|
	571	((u32)(srb->cmnd[8]) << 8) \| ((u32)(srb->cmnd[9]));
	572
191648d0 JP	573	usb_stor_dbg(us, "WRITE_12: write block 0x%04lx count %ld\n",
191648d0 JP	574	block, blocks);
1da177e4 LT	575	return jumpshot_write_data(us, info, block, blocks);
	576	}
	577
	578
	579	if (srb->cmnd[0] == TEST_UNIT_READY) {
191648d0	580	usb_stor_dbg(us, "TEST_UNIT_READY\n");
1da177e4 LT	581	return jumpshot_get_status(us);
	582	}
	583
	584	if (srb->cmnd[0] == REQUEST_SENSE) {
191648d0	585	usb_stor_dbg(us, "REQUEST_SENSE\n");
1da177e4 LT	586
	587	memset(ptr, 0, 18);
	588	ptr[0] = 0xF0;
	589	ptr[2] = info->sense_key;
	590	ptr[7] = 11;
	591	ptr[12] = info->sense_asc;
	592	ptr[13] = info->sense_ascq;
	593	usb_stor_set_xfer_buf(ptr, 18, srb);
	594
	595	return USB_STOR_TRANSPORT_GOOD;
	596	}
	597
	598	if (srb->cmnd[0] == MODE_SENSE) {
191648d0	599	usb_stor_dbg(us, "MODE_SENSE_6 detected\n");
1da177e4 LT	600	return jumpshot_handle_mode_sense(us, srb, 1);
	601	}
	602
	603	if (srb->cmnd[0] == MODE_SENSE_10) {
191648d0	604	usb_stor_dbg(us, "MODE_SENSE_10 detected\n");
1da177e4 LT	605	return jumpshot_handle_mode_sense(us, srb, 0);
	606	}
	607
	608	if (srb->cmnd[0] == ALLOW_MEDIUM_REMOVAL) {
f0183a33 FB	609	/*
	610	* sure. whatever. not like we can stop the user from popping
	611	* the media out of the device (no locking doors, etc)
	612	*/
1da177e4 LT	613	return USB_STOR_TRANSPORT_GOOD;
	614	}
	615
	616	if (srb->cmnd[0] == START_STOP) {
f0183a33 FB	617	/*
	618	* this is used by sd.c'check_scsidisk_media_change to detect
	619	* media change
	620	*/
191648d0	621	usb_stor_dbg(us, "START_STOP\n");
f0183a33 FB	622	/*
	623	* the first jumpshot_id_device after a media change returns
	624	* an error (determined experimentally)
	625	*/
1da177e4 LT	626	rc = jumpshot_id_device(us, info);
	627	if (rc == USB_STOR_TRANSPORT_GOOD) {
	628	info->sense_key = NO_SENSE;
	629	srb->result = SUCCESS;
	630	} else {
	631	info->sense_key = UNIT_ATTENTION;
	632	srb->result = SAM_STAT_CHECK_CONDITION;
	633	}
	634	return rc;
	635	}
	636
191648d0 JP	637	usb_stor_dbg(us, "Gah! Unknown command: %d (0x%x)\n",
191648d0 JP	638	srb->cmnd[0], srb->cmnd[0]);
1da177e4 LT	639	info->sense_key = 0x05;
	640	info->sense_asc = 0x20;
	641	info->sense_ascq = 0x00;
	642	return USB_STOR_TRANSPORT_FAILED;
	643	}
a9fb6d05	644
aa519be3 AM	645	static struct scsi_host_template jumpshot_host_template;
aa519be3 AM	646
a9fb6d05 AS	647	static int jumpshot_probe(struct usb_interface *intf,
	648	const struct usb_device_id *id)
	649	{
	650	struct us_data *us;
	651	int result;
	652
	653	result = usb_stor_probe1(&us, intf, id,
aa519be3 AM	654	(id - jumpshot_usb_ids) + jumpshot_unusual_dev_list,
aa519be3 AM	655	&jumpshot_host_template);
a9fb6d05 AS	656	if (result)
	657	return result;
	658
	659	us->transport_name = "Lexar Jumpshot Control/Bulk";
	660	us->transport = jumpshot_transport;
	661	us->transport_reset = usb_stor_Bulk_reset;
	662	us->max_lun = 1;
	663
	664	result = usb_stor_probe2(us);
	665	return result;
	666	}
	667
	668	static struct usb_driver jumpshot_driver = {
aa519be3	669	.name = DRV_NAME,
a9fb6d05 AS	670	.probe = jumpshot_probe,
	671	.disconnect = usb_stor_disconnect,
	672	.suspend = usb_stor_suspend,
	673	.resume = usb_stor_resume,
	674	.reset_resume = usb_stor_reset_resume,
	675	.pre_reset = usb_stor_pre_reset,
	676	.post_reset = usb_stor_post_reset,
	677	.id_table = jumpshot_usb_ids,
	678	.soft_unbind = 1,
e73b2db6	679	.no_dynamic_id = 1,
a9fb6d05 AS	680	};
a9fb6d05 AS	681
aa519be3	682	module_usb_stor_driver(jumpshot_driver, jumpshot_host_template, DRV_NAME);