[linux-2.6-block.git] / drivers / usb / storage / uas.c

/*
 * USB Attached SCSI
 * Note that this is not the same as the USB Mass Storage driver
 *
 * Copyright Matthew Wilcox for Intel Corp, 2010
 * Copyright Sarah Sharp for Intel Corp, 2010
 *
 * Distributed under the terms of the GNU GPL, version two.
 */

#include <linux/blkdev.h>
#include <linux/slab.h>
#include <linux/types.h>
#include <linux/usb.h>
#include <linux/usb/storage.h>

#include <scsi/scsi.h>
#include <scsi/scsi_dbg.h>
#include <scsi/scsi_cmnd.h>
#include <scsi/scsi_device.h>
#include <scsi/scsi_host.h>
#include <scsi/scsi_tcq.h>

/* Common header for all IUs */
struct iu {
	__u8 iu_id;
	__u8 rsvd1;
	__be16 tag;
};

enum {
	IU_ID_COMMAND		= 0x01,
	IU_ID_STATUS		= 0x03,
	IU_ID_RESPONSE		= 0x04,
	IU_ID_TASK_MGMT		= 0x05,
	IU_ID_READ_READY	= 0x06,
	IU_ID_WRITE_READY	= 0x07,
};

struct command_iu {
	__u8 iu_id;
	__u8 rsvd1;
	__be16 tag;
	__u8 prio_attr;
	__u8 rsvd5;
	__u8 len;
	__u8 rsvd7;
	struct scsi_lun lun;
	__u8 cdb[16];	/* XXX: Overflow-checking tools may misunderstand */
};

struct sense_iu {
	__u8 iu_id;
	__u8 rsvd1;
	__be16 tag;
	__be16 status_qual;
	__u8 status;
	__u8 service_response;
	__u8 rsvd8[6];
	__be16 len;
	__u8 sense[SCSI_SENSE_BUFFERSIZE];
};

/*
 * The r00-r01c specs define this version of the SENSE IU data structure.
 * It's still in use by several different firmware releases.
 */
struct sense_iu_old {
	__u8 iu_id;
	__u8 rsvd1;
	__be16 tag;
	__be16 len;
	__u8 status;
	__u8 service_response;
	__u8 sense[SCSI_SENSE_BUFFERSIZE];
};

enum {
	CMD_PIPE_ID		= 1,
	STATUS_PIPE_ID		= 2,
	DATA_IN_PIPE_ID		= 3,
	DATA_OUT_PIPE_ID	= 4,

	UAS_SIMPLE_TAG		= 0,
	UAS_HEAD_TAG		= 1,
	UAS_ORDERED_TAG		= 2,
	UAS_ACA			= 4,
};

struct uas_dev_info {
	struct usb_interface *intf;
	struct usb_device *udev;
	int qdepth;
	unsigned cmd_pipe, status_pipe, data_in_pipe, data_out_pipe;
	unsigned use_streams:1;
	unsigned uas_sense_old:1;
};

enum {
	ALLOC_SENSE_URB		= (1 << 0),
	SUBMIT_SENSE_URB	= (1 << 1),
	ALLOC_DATA_IN_URB	= (1 << 2),
	SUBMIT_DATA_IN_URB	= (1 << 3),
	ALLOC_DATA_OUT_URB	= (1 << 4),
	SUBMIT_DATA_OUT_URB	= (1 << 5),
	ALLOC_CMD_URB		= (1 << 6),
	SUBMIT_CMD_URB		= (1 << 7),
};

/* Overrides scsi_pointer */
struct uas_cmd_info {
	unsigned int state;
	unsigned int stream;
	struct urb *cmd_urb;
	struct urb *sense_urb;
	struct urb *data_in_urb;
	struct urb *data_out_urb;
	struct list_head list;
};

/* I hate forward declarations, but I actually have a loop */
static int uas_submit_urbs(struct scsi_cmnd *cmnd,
				struct uas_dev_info *devinfo, gfp_t gfp);

static DEFINE_SPINLOCK(uas_work_lock);
static LIST_HEAD(uas_work_list);

static void uas_do_work(struct work_struct *work)
{
	struct uas_cmd_info *cmdinfo;
	struct list_head list;

	spin_lock_irq(&uas_work_lock);
	list_replace_init(&uas_work_list, &list);
	spin_unlock_irq(&uas_work_lock);

	list_for_each_entry(cmdinfo, &list, list) {
		struct scsi_pointer *scp = (void *)cmdinfo;
		struct scsi_cmnd *cmnd = container_of(scp,
							struct scsi_cmnd, SCp);
		uas_submit_urbs(cmnd, cmnd->device->hostdata, GFP_KERNEL);
	}
}

static DECLARE_WORK(uas_work, uas_do_work);

static void uas_sense(struct urb *urb, struct scsi_cmnd *cmnd)
{
	struct sense_iu *sense_iu = urb->transfer_buffer;
	struct scsi_device *sdev = cmnd->device;

	if (urb->actual_length > 16) {
		unsigned len = be16_to_cpup(&sense_iu->len);
		if (len + 16 != urb->actual_length) {
			int newlen = min(len + 16, urb->actual_length) - 16;
			if (newlen < 0)
				newlen = 0;
			sdev_printk(KERN_INFO, sdev, "%s: urb length %d "
				"disagrees with IU sense data length %d, "
				"using %d bytes of sense data\n", __func__,
					urb->actual_length, len, newlen);
			len = newlen;
		}
		memcpy(cmnd->sense_buffer, sense_iu->sense, len);
	}

	cmnd->result = sense_iu->status;
	if (sdev->current_cmnd)
		sdev->current_cmnd = NULL;
	cmnd->scsi_done(cmnd);
	usb_free_urb(urb);
}

static void uas_sense_old(struct urb *urb, struct scsi_cmnd *cmnd)
{
	struct sense_iu_old *sense_iu = urb->transfer_buffer;
	struct scsi_device *sdev = cmnd->device;

	if (urb->actual_length > 8) {
		unsigned len = be16_to_cpup(&sense_iu->len) - 2;
		if (len + 8 != urb->actual_length) {
			int newlen = min(len + 8, urb->actual_length) - 8;
			if (newlen < 0)
				newlen = 0;
			sdev_printk(KERN_INFO, sdev, "%s: urb length %d "
				"disagrees with IU sense data length %d, "
				"using %d bytes of sense data\n", __func__,
					urb->actual_length, len, newlen);
			len = newlen;
		}
		memcpy(cmnd->sense_buffer, sense_iu->sense, len);
	}

	cmnd->result = sense_iu->status;
	if (sdev->current_cmnd)
		sdev->current_cmnd = NULL;
	cmnd->scsi_done(cmnd);
	usb_free_urb(urb);
}

static void uas_xfer_data(struct urb *urb, struct scsi_cmnd *cmnd,
							unsigned direction)
{
	struct uas_cmd_info *cmdinfo = (void *)&cmnd->SCp;
	int err;

	cmdinfo->state = direction | SUBMIT_SENSE_URB;
	err = uas_submit_urbs(cmnd, cmnd->device->hostdata, GFP_ATOMIC);
	if (err) {
		spin_lock(&uas_work_lock);
		list_add_tail(&cmdinfo->list, &uas_work_list);
		spin_unlock(&uas_work_lock);
		schedule_work(&uas_work);
	}
}

static void uas_stat_cmplt(struct urb *urb)
{
	struct iu *iu = urb->transfer_buffer;
	struct scsi_device *sdev = urb->context;
	struct uas_dev_info *devinfo = sdev->hostdata;
	struct scsi_cmnd *cmnd;
	u16 tag;

	if (urb->status) {
		dev_err(&urb->dev->dev, "URB BAD STATUS %d\n", urb->status);
		usb_free_urb(urb);
		return;
	}

	tag = be16_to_cpup(&iu->tag) - 1;
	if (sdev->current_cmnd)
		cmnd = sdev->current_cmnd;
	else
		cmnd = scsi_find_tag(sdev, tag);
	if (!cmnd)
		return;

	switch (iu->iu_id) {
	case IU_ID_STATUS:
		if (urb->actual_length < 16)
			devinfo->uas_sense_old = 1;
		if (devinfo->uas_sense_old)
			uas_sense_old(urb, cmnd);
		else
			uas_sense(urb, cmnd);
		break;
	case IU_ID_READ_READY:
		uas_xfer_data(urb, cmnd, SUBMIT_DATA_IN_URB);
		break;
	case IU_ID_WRITE_READY:
		uas_xfer_data(urb, cmnd, SUBMIT_DATA_OUT_URB);
		break;
	default:
		scmd_printk(KERN_ERR, cmnd,
			"Bogus IU (%d) received on status pipe\n", iu->iu_id);
	}
}

static void uas_data_cmplt(struct urb *urb)
{
	struct scsi_data_buffer *sdb = urb->context;
	sdb->resid = sdb->length - urb->actual_length;
	usb_free_urb(urb);
}

static struct urb *uas_alloc_data_urb(struct uas_dev_info *devinfo, gfp_t gfp,
				unsigned int pipe, u16 stream_id,
				struct scsi_data_buffer *sdb,
				enum dma_data_direction dir)
{
	struct usb_device *udev = devinfo->udev;
	struct urb *urb = usb_alloc_urb(0, gfp);

	if (!urb)
		goto out;
	usb_fill_bulk_urb(urb, udev, pipe, NULL, sdb->length, uas_data_cmplt,
									sdb);
	if (devinfo->use_streams)
		urb->stream_id = stream_id;
	urb->num_sgs = udev->bus->sg_tablesize ? sdb->table.nents : 0;
	urb->sg = sdb->table.sgl;
 out:
	return urb;
}

static struct urb *uas_alloc_sense_urb(struct uas_dev_info *devinfo, gfp_t gfp,
					struct scsi_cmnd *cmnd, u16 stream_id)
{
	struct usb_device *udev = devinfo->udev;
	struct urb *urb = usb_alloc_urb(0, gfp);
	struct sense_iu *iu;

	if (!urb)
		goto out;

	iu = kmalloc(sizeof(*iu), gfp);
	if (!iu)
		goto free;

	usb_fill_bulk_urb(urb, udev, devinfo->status_pipe, iu, sizeof(*iu),
						uas_stat_cmplt, cmnd->device);
	urb->stream_id = stream_id;
	urb->transfer_flags |= URB_FREE_BUFFER;
 out:
	return urb;
 free:
	usb_free_urb(urb);
	return NULL;
}

static struct urb *uas_alloc_cmd_urb(struct uas_dev_info *devinfo, gfp_t gfp,
					struct scsi_cmnd *cmnd, u16 stream_id)
{
	struct usb_device *udev = devinfo->udev;
	struct scsi_device *sdev = cmnd->device;
	struct urb *urb = usb_alloc_urb(0, gfp);
	struct command_iu *iu;
	int len;

	if (!urb)
		goto out;

	len = cmnd->cmd_len - 16;
	if (len < 0)
		len = 0;
	len = ALIGN(len, 4);
	iu = kmalloc(sizeof(*iu) + len, gfp);
	if (!iu)
		goto free;

	iu->iu_id = IU_ID_COMMAND;
	iu->tag = cpu_to_be16(stream_id);
	iu->prio_attr = UAS_SIMPLE_TAG;
	iu->len = len;
	int_to_scsilun(sdev->lun, &iu->lun);
	memcpy(iu->cdb, cmnd->cmnd, cmnd->cmd_len);

	usb_fill_bulk_urb(urb, udev, devinfo->cmd_pipe, iu, sizeof(*iu) + len,
							usb_free_urb, NULL);
	urb->transfer_flags |= URB_FREE_BUFFER;
 out:
	return urb;
 free:
	usb_free_urb(urb);
	return NULL;
}

/*
 * Why should I request the Status IU before sending the Command IU?  Spec
 * says to, but also says the device may receive them in any order.  Seems
 * daft to me.
 */

static int uas_submit_urbs(struct scsi_cmnd *cmnd,
					struct uas_dev_info *devinfo, gfp_t gfp)
{
	struct uas_cmd_info *cmdinfo = (void *)&cmnd->SCp;

	if (cmdinfo->state & ALLOC_SENSE_URB) {
		cmdinfo->sense_urb = uas_alloc_sense_urb(devinfo, gfp, cmnd,
							cmdinfo->stream);
		if (!cmdinfo->sense_urb)
			return SCSI_MLQUEUE_DEVICE_BUSY;
		cmdinfo->state &= ~ALLOC_SENSE_URB;
	}

	if (cmdinfo->state & SUBMIT_SENSE_URB) {
		if (usb_submit_urb(cmdinfo->sense_urb, gfp)) {
			scmd_printk(KERN_INFO, cmnd,
					"sense urb submission failure\n");
			return SCSI_MLQUEUE_DEVICE_BUSY;
		}
		cmdinfo->state &= ~SUBMIT_SENSE_URB;
	}

	if (cmdinfo->state & ALLOC_DATA_IN_URB) {
		cmdinfo->data_in_urb = uas_alloc_data_urb(devinfo, gfp,
					devinfo->data_in_pipe, cmdinfo->stream,
					scsi_in(cmnd), DMA_FROM_DEVICE);
		if (!cmdinfo->data_in_urb)
			return SCSI_MLQUEUE_DEVICE_BUSY;
		cmdinfo->state &= ~ALLOC_DATA_IN_URB;
	}

	if (cmdinfo->state & SUBMIT_DATA_IN_URB) {
		if (usb_submit_urb(cmdinfo->data_in_urb, gfp)) {
			scmd_printk(KERN_INFO, cmnd,
					"data in urb submission failure\n");
			return SCSI_MLQUEUE_DEVICE_BUSY;
		}
		cmdinfo->state &= ~SUBMIT_DATA_IN_URB;
	}

	if (cmdinfo->state & ALLOC_DATA_OUT_URB) {
		cmdinfo->data_out_urb = uas_alloc_data_urb(devinfo, gfp,
					devinfo->data_out_pipe, cmdinfo->stream,
					scsi_out(cmnd), DMA_TO_DEVICE);
		if (!cmdinfo->data_out_urb)
			return SCSI_MLQUEUE_DEVICE_BUSY;
		cmdinfo->state &= ~ALLOC_DATA_OUT_URB;
	}

	if (cmdinfo->state & SUBMIT_DATA_OUT_URB) {
		if (usb_submit_urb(cmdinfo->data_out_urb, gfp)) {
			scmd_printk(KERN_INFO, cmnd,
					"data out urb submission failure\n");
			return SCSI_MLQUEUE_DEVICE_BUSY;
		}
		cmdinfo->state &= ~SUBMIT_DATA_OUT_URB;
	}

	if (cmdinfo->state & ALLOC_CMD_URB) {
		cmdinfo->cmd_urb = uas_alloc_cmd_urb(devinfo, gfp, cmnd,
							cmdinfo->stream);
		if (!cmdinfo->cmd_urb)
			return SCSI_MLQUEUE_DEVICE_BUSY;
		cmdinfo->state &= ~ALLOC_CMD_URB;
	}

	if (cmdinfo->state & SUBMIT_CMD_URB) {
		if (usb_submit_urb(cmdinfo->cmd_urb, gfp)) {
			scmd_printk(KERN_INFO, cmnd,
					"cmd urb submission failure\n");
			return SCSI_MLQUEUE_DEVICE_BUSY;
		}
		cmdinfo->state &= ~SUBMIT_CMD_URB;
	}

	return 0;
}

static int uas_queuecommand(struct scsi_cmnd *cmnd,
					void (*done)(struct scsi_cmnd *))
{
	struct scsi_device *sdev = cmnd->device;
	struct uas_dev_info *devinfo = sdev->hostdata;
	struct uas_cmd_info *cmdinfo = (void *)&cmnd->SCp;
	int err;

	BUILD_BUG_ON(sizeof(struct uas_cmd_info) > sizeof(struct scsi_pointer));

	if (!cmdinfo->sense_urb && sdev->current_cmnd)
		return SCSI_MLQUEUE_DEVICE_BUSY;

	if (blk_rq_tagged(cmnd->request)) {
		cmdinfo->stream = cmnd->request->tag + 1;
	} else {
		sdev->current_cmnd = cmnd;
		cmdinfo->stream = 1;
	}

	cmnd->scsi_done = done;

	cmdinfo->state = ALLOC_SENSE_URB | SUBMIT_SENSE_URB |
			ALLOC_CMD_URB | SUBMIT_CMD_URB;

	switch (cmnd->sc_data_direction) {
	case DMA_FROM_DEVICE:
		cmdinfo->state |= ALLOC_DATA_IN_URB | SUBMIT_DATA_IN_URB;
		break;
	case DMA_BIDIRECTIONAL:
		cmdinfo->state |= ALLOC_DATA_IN_URB | SUBMIT_DATA_IN_URB;
	case DMA_TO_DEVICE:
		cmdinfo->state |= ALLOC_DATA_OUT_URB | SUBMIT_DATA_OUT_URB;
	case DMA_NONE:
		break;
	}

	if (!devinfo->use_streams) {
		cmdinfo->state &= ~(SUBMIT_DATA_IN_URB | SUBMIT_DATA_OUT_URB);
		cmdinfo->stream = 0;
	}

	err = uas_submit_urbs(cmnd, devinfo, GFP_ATOMIC);
	if (err) {
		/* If we did nothing, give up now */
		if (cmdinfo->state & SUBMIT_SENSE_URB) {
			usb_free_urb(cmdinfo->sense_urb);
			return SCSI_MLQUEUE_DEVICE_BUSY;
		}
		spin_lock(&uas_work_lock);
		list_add_tail(&cmdinfo->list, &uas_work_list);
		spin_unlock(&uas_work_lock);
		schedule_work(&uas_work);
	}

	return 0;
}

static int uas_eh_abort_handler(struct scsi_cmnd *cmnd)
{
	struct scsi_device *sdev = cmnd->device;
	sdev_printk(KERN_INFO, sdev, "%s tag %d\n", __func__,
							cmnd->request->tag);

/* XXX: Send ABORT TASK Task Management command */
	return FAILED;
}

static int uas_eh_device_reset_handler(struct scsi_cmnd *cmnd)
{
	struct scsi_device *sdev = cmnd->device;
	sdev_printk(KERN_INFO, sdev, "%s tag %d\n", __func__,
							cmnd->request->tag);

/* XXX: Send LOGICAL UNIT RESET Task Management command */
	return FAILED;
}

static int uas_eh_target_reset_handler(struct scsi_cmnd *cmnd)
{
	struct scsi_device *sdev = cmnd->device;
	sdev_printk(KERN_INFO, sdev, "%s tag %d\n", __func__,
							cmnd->request->tag);

/* XXX: Can we reset just the one USB interface?
 * Would calling usb_set_interface() have the right effect?
 */
	return FAILED;
}

static int uas_eh_bus_reset_handler(struct scsi_cmnd *cmnd)
{
	struct scsi_device *sdev = cmnd->device;
	struct uas_dev_info *devinfo = sdev->hostdata;
	struct usb_device *udev = devinfo->udev;

	sdev_printk(KERN_INFO, sdev, "%s tag %d\n", __func__,
							cmnd->request->tag);

	if (usb_reset_device(udev))
		return SUCCESS;

	return FAILED;
}

static int uas_slave_alloc(struct scsi_device *sdev)
{
	sdev->hostdata = (void *)sdev->host->hostdata[0];
	return 0;
}

static int uas_slave_configure(struct scsi_device *sdev)
{
	struct uas_dev_info *devinfo = sdev->hostdata;
	scsi_set_tag_type(sdev, MSG_ORDERED_TAG);
	scsi_activate_tcq(sdev, devinfo->qdepth - 1);
	return 0;
}

static struct scsi_host_template uas_host_template = {
	.module = THIS_MODULE,
	.name = "uas",
	.queuecommand = uas_queuecommand,
	.slave_alloc = uas_slave_alloc,
	.slave_configure = uas_slave_configure,
	.eh_abort_handler = uas_eh_abort_handler,
	.eh_device_reset_handler = uas_eh_device_reset_handler,
	.eh_target_reset_handler = uas_eh_target_reset_handler,
	.eh_bus_reset_handler = uas_eh_bus_reset_handler,
	.can_queue = 65536,	/* Is there a limit on the _host_ ? */
	.this_id = -1,
	.sg_tablesize = SG_NONE,
	.cmd_per_lun = 1,	/* until we override it */
	.skip_settle_delay = 1,
	.ordered_tag = 1,
};

static struct usb_device_id uas_usb_ids[] = {
	{ USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, USB_SC_SCSI, USB_PR_BULK) },
	{ USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, USB_SC_SCSI, USB_PR_UAS) },
	/* 0xaa is a prototype device I happen to have access to */
	{ USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, USB_SC_SCSI, 0xaa) },
	{ }
};
MODULE_DEVICE_TABLE(usb, uas_usb_ids);

static void uas_configure_endpoints(struct uas_dev_info *devinfo)
{
	struct usb_host_endpoint *eps[4] = { };
	struct usb_interface *intf = devinfo->intf;
	struct usb_device *udev = devinfo->udev;
	struct usb_host_endpoint *endpoint = intf->cur_altsetting->endpoint;
	unsigned i, n_endpoints = intf->cur_altsetting->desc.bNumEndpoints;

	devinfo->uas_sense_old = 0;

	for (i = 0; i < n_endpoints; i++) {
		unsigned char *extra = endpoint[i].extra;
		int len = endpoint[i].extralen;
		while (len > 1) {
			if (extra[1] == USB_DT_PIPE_USAGE) {
				unsigned pipe_id = extra[2];
				if (pipe_id > 0 && pipe_id < 5)
					eps[pipe_id - 1] = &endpoint[i];
				break;
			}
			len -= extra[0];
			extra += extra[0];
		}
	}

	/*
	 * Assume that if we didn't find a control pipe descriptor, we're
	 * using a device with old firmware that happens to be set up like
	 * this.
	 */
	if (!eps[0]) {
		devinfo->cmd_pipe = usb_sndbulkpipe(udev, 1);
		devinfo->status_pipe = usb_rcvbulkpipe(udev, 1);
		devinfo->data_in_pipe = usb_rcvbulkpipe(udev, 2);
		devinfo->data_out_pipe = usb_sndbulkpipe(udev, 2);

		eps[1] = usb_pipe_endpoint(udev, devinfo->status_pipe);
		eps[2] = usb_pipe_endpoint(udev, devinfo->data_in_pipe);
		eps[3] = usb_pipe_endpoint(udev, devinfo->data_out_pipe);
	} else {
		devinfo->cmd_pipe = usb_sndbulkpipe(udev,
						eps[0]->desc.bEndpointAddress);
		devinfo->status_pipe = usb_rcvbulkpipe(udev,
						eps[1]->desc.bEndpointAddress);
		devinfo->data_in_pipe = usb_rcvbulkpipe(udev,
						eps[2]->desc.bEndpointAddress);
		devinfo->data_out_pipe = usb_sndbulkpipe(udev,
						eps[3]->desc.bEndpointAddress);
	}

	devinfo->qdepth = usb_alloc_streams(devinfo->intf, eps + 1, 3, 256,
								GFP_KERNEL);
	if (devinfo->qdepth < 0) {
		devinfo->qdepth = 256;
		devinfo->use_streams = 0;
	} else {
		devinfo->use_streams = 1;
	}
}

/*
 * XXX: What I'd like to do here is register a SCSI host for each USB host in
 * the system.  Follow usb-storage's design of registering a SCSI host for
 * each USB device for the moment.  Can implement this by walking up the
 * USB hierarchy until we find a USB host.
 */
static int uas_probe(struct usb_interface *intf, const struct usb_device_id *id)
{
	int result;
	struct Scsi_Host *shost;
	struct uas_dev_info *devinfo;
	struct usb_device *udev = interface_to_usbdev(intf);

	if (id->bInterfaceProtocol == 0x50) {
		int ifnum = intf->cur_altsetting->desc.bInterfaceNumber;
/* XXX: Shouldn't assume that 1 is the alternative we want */
		int ret = usb_set_interface(udev, ifnum, 1);
		if (ret)
			return -ENODEV;
	}

	devinfo = kmalloc(sizeof(struct uas_dev_info), GFP_KERNEL);
	if (!devinfo)
		return -ENOMEM;

	result = -ENOMEM;
	shost = scsi_host_alloc(&uas_host_template, sizeof(void *));
	if (!shost)
		goto free;

	shost->max_cmd_len = 16 + 252;
	shost->max_id = 1;
	shost->sg_tablesize = udev->bus->sg_tablesize;

	result = scsi_add_host(shost, &intf->dev);
	if (result)
		goto free;
	shost->hostdata[0] = (unsigned long)devinfo;

	devinfo->intf = intf;
	devinfo->udev = udev;
	uas_configure_endpoints(devinfo);

	scsi_scan_host(shost);
	usb_set_intfdata(intf, shost);
	return result;
 free:
	kfree(devinfo);
	if (shost)
		scsi_host_put(shost);
	return result;
}

static int uas_pre_reset(struct usb_interface *intf)
{
/* XXX: Need to return 1 if it's not our device in error handling */
	return 0;
}

static int uas_post_reset(struct usb_interface *intf)
{
/* XXX: Need to return 1 if it's not our device in error handling */
	return 0;
}

static void uas_disconnect(struct usb_interface *intf)
{
	struct usb_device *udev = interface_to_usbdev(intf);
	struct usb_host_endpoint *eps[3];
	struct Scsi_Host *shost = usb_get_intfdata(intf);
	struct uas_dev_info *devinfo = (void *)shost->hostdata[0];

	scsi_remove_host(shost);

	eps[0] = usb_pipe_endpoint(udev, devinfo->status_pipe);
	eps[1] = usb_pipe_endpoint(udev, devinfo->data_in_pipe);
	eps[2] = usb_pipe_endpoint(udev, devinfo->data_out_pipe);
	usb_free_streams(intf, eps, 3, GFP_KERNEL);

	kfree(devinfo);
}

/*
 * XXX: Should this plug into libusual so we can auto-upgrade devices from
 * Bulk-Only to UAS?
 */
static struct usb_driver uas_driver = {
	.name = "uas",
	.probe = uas_probe,
	.disconnect = uas_disconnect,
	.pre_reset = uas_pre_reset,
	.post_reset = uas_post_reset,
	.id_table = uas_usb_ids,
};

static int uas_init(void)
{
	return usb_register(&uas_driver);
}

static void uas_exit(void)
{
	usb_deregister(&uas_driver);
}

module_init(uas_init);
module_exit(uas_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Matthew Wilcox and Sarah Sharp");
Commit	Line	Data
115bb1ff MW	1	/*
	2	* USB Attached SCSI
	3	* Note that this is not the same as the USB Mass Storage driver
	4	*
	5	* Copyright Matthew Wilcox for Intel Corp, 2010
	6	* Copyright Sarah Sharp for Intel Corp, 2010
	7	*
	8	* Distributed under the terms of the GNU GPL, version two.
	9	*/
	10
	11	#include <linux/blkdev.h>
	12	#include <linux/slab.h>
	13	#include <linux/types.h>
	14	#include <linux/usb.h>
	15	#include <linux/usb/storage.h>
	16
	17	#include <scsi/scsi.h>
	18	#include <scsi/scsi_dbg.h>
	19	#include <scsi/scsi_cmnd.h>
	20	#include <scsi/scsi_device.h>
	21	#include <scsi/scsi_host.h>
	22	#include <scsi/scsi_tcq.h>
	23
	24	/* Common header for all IUs */
	25	struct iu {
	26	__u8 iu_id;
	27	__u8 rsvd1;
	28	__be16 tag;
	29	};
	30
	31	enum {
	32	IU_ID_COMMAND = 0x01,
	33	IU_ID_STATUS = 0x03,
	34	IU_ID_RESPONSE = 0x04,
	35	IU_ID_TASK_MGMT = 0x05,
	36	IU_ID_READ_READY = 0x06,
	37	IU_ID_WRITE_READY = 0x07,
	38	};
	39
	40	struct command_iu {
	41	__u8 iu_id;
	42	__u8 rsvd1;
	43	__be16 tag;
	44	__u8 prio_attr;
	45	__u8 rsvd5;
	46	__u8 len;
	47	__u8 rsvd7;
	48	struct scsi_lun lun;
	49	__u8 cdb[16]; /* XXX: Overflow-checking tools may misunderstand */
	50	};
	51
	52	struct sense_iu {
	53	__u8 iu_id;
	54	__u8 rsvd1;
	55	__be16 tag;
	56	__be16 status_qual;
	57	__u8 status;
	58	__u8 service_response;
	59	__u8 rsvd8[6];
	60	__be16 len;
	61	__u8 sense[SCSI_SENSE_BUFFERSIZE];
	62	};
	63
	64	/*
65	* The r00-r01c specs define this version of the SENSE IU data structure.
66	* It's still in use by several different firmware releases.
67	*/
68	struct sense_iu_old {
69	__u8 iu_id;
70	__u8 rsvd1;
71	__be16 tag;
72	__be16 len;
73	__u8 status;
74	__u8 service_response;
75	__u8 sense[SCSI_SENSE_BUFFERSIZE];
76	};
77
78	enum {
79	CMD_PIPE_ID = 1,
80	STATUS_PIPE_ID = 2,
81	DATA_IN_PIPE_ID = 3,
82	DATA_OUT_PIPE_ID = 4,
83
84	UAS_SIMPLE_TAG = 0,
85	UAS_HEAD_TAG = 1,
86	UAS_ORDERED_TAG = 2,
87	UAS_ACA = 4,
88	};
89
90	struct uas_dev_info {
91	struct usb_interface *intf;
92	struct usb_device *udev;
93	int qdepth;
94	unsigned cmd_pipe, status_pipe, data_in_pipe, data_out_pipe;
95	unsigned use_streams:1;
96	unsigned uas_sense_old:1;
97	};
98
99	enum {
100	ALLOC_SENSE_URB = (1 << 0),
101	SUBMIT_SENSE_URB = (1 << 1),
102	ALLOC_DATA_IN_URB = (1 << 2),
103	SUBMIT_DATA_IN_URB = (1 << 3),
104	ALLOC_DATA_OUT_URB = (1 << 4),
105	SUBMIT_DATA_OUT_URB = (1 << 5),
106	ALLOC_CMD_URB = (1 << 6),
107	SUBMIT_CMD_URB = (1 << 7),
108	};
109
110	/* Overrides scsi_pointer */
111	struct uas_cmd_info {
112	unsigned int state;
113	unsigned int stream;
114	struct urb *cmd_urb;
115	struct urb *sense_urb;
116	struct urb *data_in_urb;
117	struct urb *data_out_urb;
118	struct list_head list;
119	};
120
121	/* I hate forward declarations, but I actually have a loop */
122	static int uas_submit_urbs(struct scsi_cmnd *cmnd,
123	struct uas_dev_info *devinfo, gfp_t gfp);
124
125	static DEFINE_SPINLOCK(uas_work_lock);
126	static LIST_HEAD(uas_work_list);
127
128	static void uas_do_work(struct work_struct *work)
129	{
130	struct uas_cmd_info *cmdinfo;
131	struct list_head list;
132
133	spin_lock_irq(&uas_work_lock);
134	list_replace_init(&uas_work_list, &list);
135	spin_unlock_irq(&uas_work_lock);
136
137	list_for_each_entry(cmdinfo, &list, list) {
138	struct scsi_pointer scp = (void )cmdinfo;
139	struct scsi_cmnd *cmnd = container_of(scp,
140	struct scsi_cmnd, SCp);
141	uas_submit_urbs(cmnd, cmnd->device->hostdata, GFP_KERNEL);
142	}
143	}
144
145	static DECLARE_WORK(uas_work, uas_do_work);
146
147	static void uas_sense(struct urb urb, struct scsi_cmnd cmnd)
148	{
149	struct sense_iu *sense_iu = urb->transfer_buffer;
150	struct scsi_device *sdev = cmnd->device;
151
152	if (urb->actual_length > 16) {
153	unsigned len = be16_to_cpup(&sense_iu->len);
154	if (len + 16 != urb->actual_length) {
155	int newlen = min(len + 16, urb->actual_length) - 16;
156	if (newlen < 0)
157	newlen = 0;
158	sdev_printk(KERN_INFO, sdev, "%s: urb length %d "
159	"disagrees with IU sense data length %d, "
160	"using %d bytes of sense data\n", __func__,
161	urb->actual_length, len, newlen);
162	len = newlen;
163	}
164	memcpy(cmnd->sense_buffer, sense_iu->sense, len);
165	}
166
167	cmnd->result = sense_iu->status;
168	if (sdev->current_cmnd)
169	sdev->current_cmnd = NULL;
170	cmnd->scsi_done(cmnd);
171	usb_free_urb(urb);
172	}
173
174	static void uas_sense_old(struct urb urb, struct scsi_cmnd cmnd)
175	{
176	struct sense_iu_old *sense_iu = urb->transfer_buffer;
177	struct scsi_device *sdev = cmnd->device;
178
179	if (urb->actual_length > 8) {
180	unsigned len = be16_to_cpup(&sense_iu->len) - 2;
181	if (len + 8 != urb->actual_length) {
182	int newlen = min(len + 8, urb->actual_length) - 8;
183	if (newlen < 0)
184	newlen = 0;
185	sdev_printk(KERN_INFO, sdev, "%s: urb length %d "
186	"disagrees with IU sense data length %d, "
187	"using %d bytes of sense data\n", __func__,
188	urb->actual_length, len, newlen);
189	len = newlen;
190	}
191	memcpy(cmnd->sense_buffer, sense_iu->sense, len);
192	}
193
194	cmnd->result = sense_iu->status;
195	if (sdev->current_cmnd)
196	sdev->current_cmnd = NULL;
197	cmnd->scsi_done(cmnd);
198	usb_free_urb(urb);
199	}
200
201	static void uas_xfer_data(struct urb urb, struct scsi_cmnd cmnd,
202	unsigned direction)
203	{
204	struct uas_cmd_info cmdinfo = (void )&cmnd->SCp;
205	int err;
206
207	cmdinfo->state = direction \| SUBMIT_SENSE_URB;
208	err = uas_submit_urbs(cmnd, cmnd->device->hostdata, GFP_ATOMIC);
209	if (err) {
210	spin_lock(&uas_work_lock);
211	list_add_tail(&cmdinfo->list, &uas_work_list);
212	spin_unlock(&uas_work_lock);
213	schedule_work(&uas_work);
214	}
215	}
216
217	static void uas_stat_cmplt(struct urb *urb)
218	{
219	struct iu *iu = urb->transfer_buffer;
220	struct scsi_device *sdev = urb->context;
221	struct uas_dev_info *devinfo = sdev->hostdata;
222	struct scsi_cmnd *cmnd;
223	u16 tag;
224
225	if (urb->status) {
226	dev_err(&urb->dev->dev, "URB BAD STATUS %d\n", urb->status);
227	usb_free_urb(urb);
228	return;
229	}
230
231	tag = be16_to_cpup(&iu->tag) - 1;
232	if (sdev->current_cmnd)
233	cmnd = sdev->current_cmnd;
234	else
235	cmnd = scsi_find_tag(sdev, tag);
236	if (!cmnd)
237	return;
238
239	switch (iu->iu_id) {
240	case IU_ID_STATUS:
241	if (urb->actual_length < 16)
242	devinfo->uas_sense_old = 1;
243	if (devinfo->uas_sense_old)
244	uas_sense_old(urb, cmnd);
245	else
246	uas_sense(urb, cmnd);
247	break;
248	case IU_ID_READ_READY:
249	uas_xfer_data(urb, cmnd, SUBMIT_DATA_IN_URB);
250	break;
251	case IU_ID_WRITE_READY:
252	uas_xfer_data(urb, cmnd, SUBMIT_DATA_OUT_URB);
253	break;
254	default:
255	scmd_printk(KERN_ERR, cmnd,
256	"Bogus IU (%d) received on status pipe\n", iu->iu_id);
257	}
258	}
259
260	static void uas_data_cmplt(struct urb *urb)
261	{
262	struct scsi_data_buffer *sdb = urb->context;
263	sdb->resid = sdb->length - urb->actual_length;
264	usb_free_urb(urb);
265	}
266
267	static struct urb uas_alloc_data_urb(struct uas_dev_info devinfo, gfp_t gfp,
268	unsigned int pipe, u16 stream_id,
269	struct scsi_data_buffer *sdb,
270	enum dma_data_direction dir)
271	{
272	struct usb_device *udev = devinfo->udev;
273	struct urb *urb = usb_alloc_urb(0, gfp);
274
275	if (!urb)
276	goto out;
277	usb_fill_bulk_urb(urb, udev, pipe, NULL, sdb->length, uas_data_cmplt,
278	sdb);
279	if (devinfo->use_streams)
280	urb->stream_id = stream_id;
281	urb->num_sgs = udev->bus->sg_tablesize ? sdb->table.nents : 0;
282	urb->sg = sdb->table.sgl;
283	out:
284	return urb;
285	}
286
287	static struct urb uas_alloc_sense_urb(struct uas_dev_info devinfo, gfp_t gfp,
288	struct scsi_cmnd *cmnd, u16 stream_id)
289	{
290	struct usb_device *udev = devinfo->udev;
291	struct urb *urb = usb_alloc_urb(0, gfp);
292	struct sense_iu *iu;
293
294	if (!urb)
295	goto out;
296
297	iu = kmalloc(sizeof(*iu), gfp);
298	if (!iu)
299	goto free;
300
301	usb_fill_bulk_urb(urb, udev, devinfo->status_pipe, iu, sizeof(*iu),
302	uas_stat_cmplt, cmnd->device);
303	urb->stream_id = stream_id;
304	urb->transfer_flags \|= URB_FREE_BUFFER;
305	out:
306	return urb;
307	free:
308	usb_free_urb(urb);
309	return NULL;
310	}
311
312	static struct urb uas_alloc_cmd_urb(struct uas_dev_info devinfo, gfp_t gfp,
313	struct scsi_cmnd *cmnd, u16 stream_id)
314	{
315	struct usb_device *udev = devinfo->udev;
316	struct scsi_device *sdev = cmnd->device;
317	struct urb *urb = usb_alloc_urb(0, gfp);
318	struct command_iu *iu;
319	int len;
320
321	if (!urb)
322	goto out;
323
324	len = cmnd->cmd_len - 16;
325	if (len < 0)
326	len = 0;
327	len = ALIGN(len, 4);
328	iu = kmalloc(sizeof(*iu) + len, gfp);
329	if (!iu)
330	goto free;
331
332	iu->iu_id = IU_ID_COMMAND;
333	iu->tag = cpu_to_be16(stream_id);
02e031cb	334	iu->prio_attr = UAS_SIMPLE_TAG;
115bb1ff MW	335	iu->len = len;
	336	int_to_scsilun(sdev->lun, &iu->lun);
	337	memcpy(iu->cdb, cmnd->cmnd, cmnd->cmd_len);
	338
	339	usb_fill_bulk_urb(urb, udev, devinfo->cmd_pipe, iu, sizeof(*iu) + len,
	340	usb_free_urb, NULL);
	341	urb->transfer_flags \|= URB_FREE_BUFFER;
	342	out:
	343	return urb;
	344	free:
	345	usb_free_urb(urb);
	346	return NULL;
	347	}
	348
	349	/*
	350	* Why should I request the Status IU before sending the Command IU? Spec
	351	* says to, but also says the device may receive them in any order. Seems
	352	* daft to me.
	353	*/
	354
	355	static int uas_submit_urbs(struct scsi_cmnd *cmnd,
	356	struct uas_dev_info *devinfo, gfp_t gfp)
	357	{
	358	struct uas_cmd_info cmdinfo = (void )&cmnd->SCp;
	359
	360	if (cmdinfo->state & ALLOC_SENSE_URB) {
	361	cmdinfo->sense_urb = uas_alloc_sense_urb(devinfo, gfp, cmnd,
	362	cmdinfo->stream);
	363	if (!cmdinfo->sense_urb)
	364	return SCSI_MLQUEUE_DEVICE_BUSY;
	365	cmdinfo->state &= ~ALLOC_SENSE_URB;
	366	}
	367
	368	if (cmdinfo->state & SUBMIT_SENSE_URB) {
	369	if (usb_submit_urb(cmdinfo->sense_urb, gfp)) {
	370	scmd_printk(KERN_INFO, cmnd,
	371	"sense urb submission failure\n");
	372	return SCSI_MLQUEUE_DEVICE_BUSY;
	373	}
	374	cmdinfo->state &= ~SUBMIT_SENSE_URB;
	375	}
	376
	377	if (cmdinfo->state & ALLOC_DATA_IN_URB) {
	378	cmdinfo->data_in_urb = uas_alloc_data_urb(devinfo, gfp,
	379	devinfo->data_in_pipe, cmdinfo->stream,
	380	scsi_in(cmnd), DMA_FROM_DEVICE);
	381	if (!cmdinfo->data_in_urb)
	382	return SCSI_MLQUEUE_DEVICE_BUSY;
	383	cmdinfo->state &= ~ALLOC_DATA_IN_URB;
	384	}
	385
	386	if (cmdinfo->state & SUBMIT_DATA_IN_URB) {
	387	if (usb_submit_urb(cmdinfo->data_in_urb, gfp)) {
	388	scmd_printk(KERN_INFO, cmnd,
	389	"data in urb submission failure\n");
	390	return SCSI_MLQUEUE_DEVICE_BUSY;
	391	}
	392	cmdinfo->state &= ~SUBMIT_DATA_IN_URB;
	393	}
	394
	395	if (cmdinfo->state & ALLOC_DATA_OUT_URB) {
	396	cmdinfo->data_out_urb = uas_alloc_data_urb(devinfo, gfp,
	397	devinfo->data_out_pipe, cmdinfo->stream,
	398	scsi_out(cmnd), DMA_TO_DEVICE);
399	if (!cmdinfo->data_out_urb)
400	return SCSI_MLQUEUE_DEVICE_BUSY;
401	cmdinfo->state &= ~ALLOC_DATA_OUT_URB;
402	}
403
404	if (cmdinfo->state & SUBMIT_DATA_OUT_URB) {
405	if (usb_submit_urb(cmdinfo->data_out_urb, gfp)) {
406	scmd_printk(KERN_INFO, cmnd,
407	"data out urb submission failure\n");
408	return SCSI_MLQUEUE_DEVICE_BUSY;
409	}
410	cmdinfo->state &= ~SUBMIT_DATA_OUT_URB;
411	}
412
413	if (cmdinfo->state & ALLOC_CMD_URB) {
414	cmdinfo->cmd_urb = uas_alloc_cmd_urb(devinfo, gfp, cmnd,
415	cmdinfo->stream);
416	if (!cmdinfo->cmd_urb)
417	return SCSI_MLQUEUE_DEVICE_BUSY;
418	cmdinfo->state &= ~ALLOC_CMD_URB;
419	}
420
421	if (cmdinfo->state & SUBMIT_CMD_URB) {
422	if (usb_submit_urb(cmdinfo->cmd_urb, gfp)) {
423	scmd_printk(KERN_INFO, cmnd,
424	"cmd urb submission failure\n");
425	return SCSI_MLQUEUE_DEVICE_BUSY;
426	}
427	cmdinfo->state &= ~SUBMIT_CMD_URB;
428	}
429
430	return 0;
431	}
432
433	static int uas_queuecommand(struct scsi_cmnd *cmnd,
434	void (done)(struct scsi_cmnd ))
435	{
436	struct scsi_device *sdev = cmnd->device;
437	struct uas_dev_info *devinfo = sdev->hostdata;
438	struct uas_cmd_info cmdinfo = (void )&cmnd->SCp;
439	int err;
440
441	BUILD_BUG_ON(sizeof(struct uas_cmd_info) > sizeof(struct scsi_pointer));
442
443	if (!cmdinfo->sense_urb && sdev->current_cmnd)
444	return SCSI_MLQUEUE_DEVICE_BUSY;
445
446	if (blk_rq_tagged(cmnd->request)) {
447	cmdinfo->stream = cmnd->request->tag + 1;
448	} else {
449	sdev->current_cmnd = cmnd;
450	cmdinfo->stream = 1;
451	}
452
453	cmnd->scsi_done = done;
454
455	cmdinfo->state = ALLOC_SENSE_URB \| SUBMIT_SENSE_URB \|
456	ALLOC_CMD_URB \| SUBMIT_CMD_URB;
457
458	switch (cmnd->sc_data_direction) {
459	case DMA_FROM_DEVICE:
460	cmdinfo->state \|= ALLOC_DATA_IN_URB \| SUBMIT_DATA_IN_URB;
461	break;
462	case DMA_BIDIRECTIONAL:
463	cmdinfo->state \|= ALLOC_DATA_IN_URB \| SUBMIT_DATA_IN_URB;
464	case DMA_TO_DEVICE:
465	cmdinfo->state \|= ALLOC_DATA_OUT_URB \| SUBMIT_DATA_OUT_URB;
466	case DMA_NONE:
467	break;
468	}
469
470	if (!devinfo->use_streams) {
471	cmdinfo->state &= ~(SUBMIT_DATA_IN_URB \| SUBMIT_DATA_OUT_URB);
472	cmdinfo->stream = 0;
473	}
474
475	err = uas_submit_urbs(cmnd, devinfo, GFP_ATOMIC);
476	if (err) {
477	/* If we did nothing, give up now */
478	if (cmdinfo->state & SUBMIT_SENSE_URB) {
479	usb_free_urb(cmdinfo->sense_urb);
480	return SCSI_MLQUEUE_DEVICE_BUSY;
481	}
482	spin_lock(&uas_work_lock);
483	list_add_tail(&cmdinfo->list, &uas_work_list);
484	spin_unlock(&uas_work_lock);
485	schedule_work(&uas_work);
486	}
487
488	return 0;
489	}
490
491	static int uas_eh_abort_handler(struct scsi_cmnd *cmnd)
492	{
493	struct scsi_device *sdev = cmnd->device;
494	sdev_printk(KERN_INFO, sdev, "%s tag %d\n", __func__,
495	cmnd->request->tag);
496
497	/* XXX: Send ABORT TASK Task Management command */
498	return FAILED;
499	}
500
501	static int uas_eh_device_reset_handler(struct scsi_cmnd *cmnd)
502	{
503	struct scsi_device *sdev = cmnd->device;
504	sdev_printk(KERN_INFO, sdev, "%s tag %d\n", __func__,
505	cmnd->request->tag);
506
507	/* XXX: Send LOGICAL UNIT RESET Task Management command */
508	return FAILED;
509	}
510
511	static int uas_eh_target_reset_handler(struct scsi_cmnd *cmnd)
512	{
513	struct scsi_device *sdev = cmnd->device;
514	sdev_printk(KERN_INFO, sdev, "%s tag %d\n", __func__,
515	cmnd->request->tag);
516
517	/* XXX: Can we reset just the one USB interface?
518	* Would calling usb_set_interface() have the right effect?
519	*/
520	return FAILED;
521	}
522
523	static int uas_eh_bus_reset_handler(struct scsi_cmnd *cmnd)
524	{
525	struct scsi_device *sdev = cmnd->device;
526	struct uas_dev_info *devinfo = sdev->hostdata;
527	struct usb_device *udev = devinfo->udev;
528
529	sdev_printk(KERN_INFO, sdev, "%s tag %d\n", __func__,
530	cmnd->request->tag);
531
532	if (usb_reset_device(udev))
533	return SUCCESS;
534
535	return FAILED;
536	}
537
538	static int uas_slave_alloc(struct scsi_device *sdev)
539	{
540	sdev->hostdata = (void *)sdev->host->hostdata[0];
541	return 0;
542	}
543
544	static int uas_slave_configure(struct scsi_device *sdev)
545	{
546	struct uas_dev_info *devinfo = sdev->hostdata;
547	scsi_set_tag_type(sdev, MSG_ORDERED_TAG);
548	scsi_activate_tcq(sdev, devinfo->qdepth - 1);
549	return 0;
550	}
551
552	static struct scsi_host_template uas_host_template = {
553	.module = THIS_MODULE,
554	.name = "uas",
555	.queuecommand = uas_queuecommand,
556	.slave_alloc = uas_slave_alloc,
557	.slave_configure = uas_slave_configure,
558	.eh_abort_handler = uas_eh_abort_handler,
559	.eh_device_reset_handler = uas_eh_device_reset_handler,
560	.eh_target_reset_handler = uas_eh_target_reset_handler,
561	.eh_bus_reset_handler = uas_eh_bus_reset_handler,
562	.can_queue = 65536, /* Is there a limit on the _host_ ? */
563	.this_id = -1,
564	.sg_tablesize = SG_NONE,
565	.cmd_per_lun = 1, /* until we override it */
566	.skip_settle_delay = 1,
567	.ordered_tag = 1,
568	};
569
570	static struct usb_device_id uas_usb_ids[] = {
571	{ USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, USB_SC_SCSI, USB_PR_BULK) },
572	{ USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, USB_SC_SCSI, USB_PR_UAS) },
573	/* 0xaa is a prototype device I happen to have access to */
574	{ USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, USB_SC_SCSI, 0xaa) },
575	{ }
576	};
577	MODULE_DEVICE_TABLE(usb, uas_usb_ids);
578
579	static void uas_configure_endpoints(struct uas_dev_info *devinfo)
580	{
581	struct usb_host_endpoint *eps[4] = { };
582	struct usb_interface *intf = devinfo->intf;
583	struct usb_device *udev = devinfo->udev;
584	struct usb_host_endpoint *endpoint = intf->cur_altsetting->endpoint;
585	unsigned i, n_endpoints = intf->cur_altsetting->desc.bNumEndpoints;
586
587	devinfo->uas_sense_old = 0;
588
589	for (i = 0; i < n_endpoints; i++) {
590	unsigned char *extra = endpoint[i].extra;
591	int len = endpoint[i].extralen;
592	while (len > 1) {
593	if (extra[1] == USB_DT_PIPE_USAGE) {
594	unsigned pipe_id = extra[2];
595	if (pipe_id > 0 && pipe_id < 5)
596	eps[pipe_id - 1] = &endpoint[i];
597	break;
598	}
599	len -= extra[0];
600	extra += extra[0];
601	}
602	}
603
604	/*
605	* Assume that if we didn't find a control pipe descriptor, we're
606	* using a device with old firmware that happens to be set up like
607	* this.
608	*/
609	if (!eps[0]) {
610	devinfo->cmd_pipe = usb_sndbulkpipe(udev, 1);
611	devinfo->status_pipe = usb_rcvbulkpipe(udev, 1);
612	devinfo->data_in_pipe = usb_rcvbulkpipe(udev, 2);
613	devinfo->data_out_pipe = usb_sndbulkpipe(udev, 2);
614
615	eps[1] = usb_pipe_endpoint(udev, devinfo->status_pipe);
616	eps[2] = usb_pipe_endpoint(udev, devinfo->data_in_pipe);
617	eps[3] = usb_pipe_endpoint(udev, devinfo->data_out_pipe);
618	} else {
619	devinfo->cmd_pipe = usb_sndbulkpipe(udev,
620	eps[0]->desc.bEndpointAddress);
621	devinfo->status_pipe = usb_rcvbulkpipe(udev,
622	eps[1]->desc.bEndpointAddress);
623	devinfo->data_in_pipe = usb_rcvbulkpipe(udev,
624	eps[2]->desc.bEndpointAddress);
625	devinfo->data_out_pipe = usb_sndbulkpipe(udev,
626	eps[3]->desc.bEndpointAddress);
627	}
628
629	devinfo->qdepth = usb_alloc_streams(devinfo->intf, eps + 1, 3, 256,
630	GFP_KERNEL);
631	if (devinfo->qdepth < 0) {
632	devinfo->qdepth = 256;
633	devinfo->use_streams = 0;
634	} else {
635	devinfo->use_streams = 1;
636	}
637	}
638
639	/*
640	* XXX: What I'd like to do here is register a SCSI host for each USB host in
641	* the system. Follow usb-storage's design of registering a SCSI host for
642	* each USB device for the moment. Can implement this by walking up the
643	* USB hierarchy until we find a USB host.
644	*/
645	static int uas_probe(struct usb_interface intf, const struct usb_device_id id)
646	{
647	int result;
648	struct Scsi_Host *shost;
649	struct uas_dev_info *devinfo;
650	struct usb_device *udev = interface_to_usbdev(intf);
651
652	if (id->bInterfaceProtocol == 0x50) {
653	int ifnum = intf->cur_altsetting->desc.bInterfaceNumber;
654	/* XXX: Shouldn't assume that 1 is the alternative we want */
655	int ret = usb_set_interface(udev, ifnum, 1);
656	if (ret)
657	return -ENODEV;
658	}
659
660	devinfo = kmalloc(sizeof(struct uas_dev_info), GFP_KERNEL);
661	if (!devinfo)
662	return -ENOMEM;
663
664	result = -ENOMEM;
665	shost = scsi_host_alloc(&uas_host_template, sizeof(void *));
666	if (!shost)
667	goto free;
668
669	shost->max_cmd_len = 16 + 252;
670	shost->max_id = 1;
671	shost->sg_tablesize = udev->bus->sg_tablesize;
672
673	result = scsi_add_host(shost, &intf->dev);
674	if (result)
675	goto free;
676	shost->hostdata[0] = (unsigned long)devinfo;
677
678	devinfo->intf = intf;
679	devinfo->udev = udev;
680	uas_configure_endpoints(devinfo);
681
682	scsi_scan_host(shost);
683	usb_set_intfdata(intf, shost);
684	return result;
685	free:
686	kfree(devinfo);
687	if (shost)
688	scsi_host_put(shost);
689	return result;
690	}
691
692	static int uas_pre_reset(struct usb_interface *intf)
693	{
694	/* XXX: Need to return 1 if it's not our device in error handling */
695	return 0;
696	}
697
698	static int uas_post_reset(struct usb_interface *intf)
699	{
700	/* XXX: Need to return 1 if it's not our device in error handling */
701	return 0;
702	}
703
704	static void uas_disconnect(struct usb_interface *intf)
705	{
706	struct usb_device *udev = interface_to_usbdev(intf);
707	struct usb_host_endpoint *eps[3];
708	struct Scsi_Host *shost = usb_get_intfdata(intf);
709	struct uas_dev_info devinfo = (void )shost->hostdata[0];
710
711	scsi_remove_host(shost);
712
713	eps[0] = usb_pipe_endpoint(udev, devinfo->status_pipe);
714	eps[1] = usb_pipe_endpoint(udev, devinfo->data_in_pipe);
715	eps[2] = usb_pipe_endpoint(udev, devinfo->data_out_pipe);
716	usb_free_streams(intf, eps, 3, GFP_KERNEL);
717
718	kfree(devinfo);
719	}
720
721	/*
722	* XXX: Should this plug into libusual so we can auto-upgrade devices from
723	* Bulk-Only to UAS?
724	*/
725	static struct usb_driver uas_driver = {
726	.name = "uas",
727	.probe = uas_probe,
728	.disconnect = uas_disconnect,
729	.pre_reset = uas_pre_reset,
730	.post_reset = uas_post_reset,
731	.id_table = uas_usb_ids,
732	};
733
734	static int uas_init(void)
735	{
736	return usb_register(&uas_driver);
737	}
738
739	static void uas_exit(void)
740	{
741	usb_deregister(&uas_driver);
742	}
743
744	module_init(uas_init);
745	module_exit(uas_exit);
746
747	MODULE_LICENSE("GPL");
748	MODULE_AUTHOR("Matthew Wilcox and Sarah Sharp");