Forwarding to the linux-scsi list too.
Sarah Sharp
On Thu, Apr 01, 2010 at 10:38:51AM -0700, Hrant Dalalyan wrote:
> Implementation of USB Attached SCSI Protocol per UASP Specification
> (Rev.1, July 9, 2008). Below is the list of the enhancements made to
> the usb-storage driver.
>
> - Enhanced probe routine to identify UASP devices.
> - Allocation/deallocation of UASP specific resources.
> - Various enhancements to existing infrastructure to invoke UASP
> specific routines.
> - Added SCSI command queueing mechanism and state machine for
> handling multiple commands.
> - Implemented 'abort task' and 'reset nexus' task management
> functions.
>
> Limitations:
>
> - Considered that the endpoint descriptors are received from the device
> side in the following order:
> - Command endpoint descriptor.
> - Bulk in endpoint descriptor.
> - Bulk out endpoint descriptor.
> - Status endpoint descriptor.
> because in the noted revision of the UASP Specification were not defined
> pipe usage descriptors.
>
> - The max number of streams are not retrieved through the superspeed
> endpoint companion descriptor and are fixed to 2 streams per
> endpoint.
> - Device supported LUNs are assumed to be 1.
> - Concurrent processing of SCSI commands is not yet tested due to due
> to some device limitations. The driver is currently set to process
> only 1 command at a time.
> - Abort task, Reset nexus task management functions, as well as some
> error conditions and recovery situations are not yet tested.
>
> Signed-off-by: Hrant Dalalyan <dalalyan@xxxxxxxxxxxx>
> ---
>
> drivers/usb/storage/protocol.c | 5 +-
> drivers/usb/storage/scsiglue.c | 126 +++-
> drivers/usb/storage/transport.c | 1268 +++++++++++++++++++++++++++++++++++-
> drivers/usb/storage/transport.h | 150 +++++
> drivers/usb/storage/unusual_devs.h | 3 +
> drivers/usb/storage/usb.c | 445 ++++++++++---
> drivers/usb/storage/usb.h | 59 ++
> include/linux/usb_usual.h | 1 +
> 8 files changed, 1931 insertions(+), 126 deletions(-)
>
> diff --git a/drivers/usb/storage/protocol.c b/drivers/usb/storage/protocol.c
> index fc310f7..a8882f1 100644
> --- a/drivers/usb/storage/protocol.c
> +++ b/drivers/usb/storage/protocol.c
> @@ -119,7 +119,10 @@ void usb_stor_transparent_scsi_command(struct scsi_cmnd *srb,
> struct us_data *us)
> {
> /* send the command to the transport layer */
> - usb_stor_invoke_transport(srb, us);
> + if (us->protocol == US_PR_UASP)
> + usb_stor_invoke_UASP_transport(us);
> + else
> + usb_stor_invoke_transport(srb, us);
> }
> EXPORT_SYMBOL_GPL(usb_stor_transparent_scsi_command);
>
> diff --git a/drivers/usb/storage/scsiglue.c b/drivers/usb/storage/scsiglue.c
> index cfa26d5..dc8c602 100644
> --- a/drivers/usb/storage/scsiglue.c
> +++ b/drivers/usb/storage/scsiglue.c
> @@ -102,7 +102,7 @@ static int slave_alloc (struct scsi_device *sdev)
> * values can be as large as 2048. To make that work properly
> * will require changes to the block layer.
> */
> - blk_queue_update_dma_alignment(sdev->request_queue, (512 - 1));
> + blk_queue_update_dma_alignment(sdev->request_queue, (1024 - 1));
>
> /*
> * The UFI spec treates the Peripheral Qualifier bits in an
> @@ -281,11 +281,13 @@ static int queuecommand(struct scsi_cmnd *srb,
> void (*done)(struct scsi_cmnd *))
> {
> struct us_data *us = host_to_us(srb->device->host);
> + struct cmd_iu *cmdiu;
> + unsigned long flags;
>
> US_DEBUGP("%s called\n", __func__);
>
> /* check for state-transition errors */
> - if (us->srb != NULL) {
> + if (us->protocol != US_PR_UASP && us->srb != NULL) {
> printk(KERN_ERR USB_STORAGE "Error in %s: us->srb = %p\n",
> __func__, us->srb);
> return SCSI_MLQUEUE_HOST_BUSY;
> @@ -299,10 +301,33 @@ static int queuecommand(struct scsi_cmnd *srb,
> return 0;
> }
>
> - /* enqueue the command and wake up the control thread */
> - srb->scsi_done = done;
> - us->srb = srb;
> - complete(&us->cmnd_ready);
> + if (us->protocol != US_PR_UASP) {
> + /* enqueue the command and wake up the control thread */
> + srb->scsi_done = done;
> + us->srb = srb;
> + complete(&us->cmnd_ready);
> + } else {
> + cmdiu = kzalloc(sizeof(struct cmd_iu), GFP_ATOMIC);
> + if (!cmdiu)
> + return SCSI_MLQUEUE_HOST_BUSY;
> +
> + cmdiu->cmd_iu_id = IU_ID_COMMAND;
> + cmdiu->ipt_tag = cpu_to_be16(usb_stor_get_tag(us));
> + cmdiu->length = cpu_to_be16(30);
> + cmdiu->lun[7] = srb->device->lun;
> + memcpy(cmdiu->cdb, srb->cmnd, srb->cmd_len);
> + cmdiu->cmd = srb;
> + cmdiu->cmd->scsi_done = done;
> + cmdiu->state = COMMAND_STATE_IDLE;
> + cmdiu->us = us;
> +
> + spin_lock_irqsave(&us->lock, flags);
> + list_add_tail(&cmdiu->node, &us->temp_scsi_cmnd_queue);
> + us->new_command = 1;
> + spin_unlock_irqrestore(&us->lock, flags);
> +
> + wake_up(&us->uasp_wq);
> + }
>
> return 0;
> }
> @@ -310,39 +335,92 @@ static int queuecommand(struct scsi_cmnd *srb,
> /***********************************************************************
> * Error handling functions
> ***********************************************************************/
> +static struct cmd_iu *find_cmd_by_ptr(struct us_data *us,
> + struct scsi_cmnd *srb)
> +{
> + struct cmd_iu *cmdiu = 0;
> +
> + list_for_each_entry(cmdiu, &us->scsi_cmnd_queue, node) {
> + if (cmdiu->cmd == srb)
> + return cmdiu;
> + }
> +
> + list_for_each_entry(cmdiu, &us->temp_scsi_cmnd_queue, node) {
> + if (cmdiu->cmd == srb)
> + return cmdiu;
> + }
> +
> + return 0;
> +}
>
> /* Command timeout and abort */
> static int command_abort(struct scsi_cmnd *srb)
> {
> struct us_data *us = host_to_us(srb->device->host);
> + struct cmd_iu *cmdiu;
> + unsigned long flags;
>
> US_DEBUGP("%s called\n", __func__);
>
> - /* us->srb together with the TIMED_OUT, RESETTING, and ABORTING
> - * bits are protected by the host lock. */
> - scsi_lock(us_to_host(us));
> + if (us->protocol != US_PR_UASP) {
> + /* us->srb together with the TIMED_OUT, RESETTING, and
> + * ABORTING bits are protected by the host lock.
> + */
> + scsi_lock(us_to_host(us));
>
> - /* Is this command still active? */
> - if (us->srb != srb) {
> + /* Is this command still active? */
> + if (us->srb != srb) {
> + scsi_unlock(us_to_host(us));
> + US_DEBUGP("-- nothing to abort\n");
> + return FAILED;
> + }
> + /* Set the TIMED_OUT bit. Also set the ABORTING bit, but only
> + * if a device reset isn't already in progress (to avoid
> + * interfering with the reset). Note that we must retain the
> + * host lock while calling usb_stor_stop_transport();
> + * otherwise it might interfere with an auto-reset that
> + * begins as soon as we release the lock.
> + */
> + set_bit(US_FLIDX_TIMED_OUT, &us->dflags);
> + if (!test_bit(US_FLIDX_RESETTING, &us->dflags)) {
> + set_bit(US_FLIDX_ABORTING, &us->dflags);
> + usb_stor_stop_transport(us);
> + }
> scsi_unlock(us_to_host(us));
> - US_DEBUGP ("-- nothing to abort\n");
> - return FAILED;
> - }
> -
> - /* Set the TIMED_OUT bit. Also set the ABORTING bit, but only if
> - * a device reset isn't already in progress (to avoid interfering
> - * with the reset). Note that we must retain the host lock while
> - * calling usb_stor_stop_transport(); otherwise it might interfere
> - * with an auto-reset that begins as soon as we release the lock. */
> - set_bit(US_FLIDX_TIMED_OUT, &us->dflags);
> - if (!test_bit(US_FLIDX_RESETTING, &us->dflags)) {
> + } else {
> + /* If we are disconnecting */
> + if (test_bit(US_FLIDX_DISCONNECTING, &us->dflags))
> + return FAILED;
> +
> + /* If reset bit is set */
> + if (test_bit(US_FLIDX_RESETTING, &us->dflags))
> + return FAILED;
> +
> + spin_lock_irqsave(&us->lock, flags);
> + cmdiu = find_cmd_by_ptr(us, srb);
> + spin_unlock_irqrestore(&us->lock, flags);
> + /* Is this command still active? */
> + if (!cmdiu)
> + return FAILED;
> +
> + spin_lock_irqsave(&us->lock, flags);
> + memset(us->abort_task_tmf, 0, TM_FUNCTION_IU_SIZE);
> + us->abort_task_tmf->cmdiu = cmdiu;
> + us->abort_task_tmf->tm_iu_id = IU_ID_TASK_MANAGEMENT;
> + us->abort_task_tmf->ipt_tag = cpu_to_be16(usb_stor_get_tag(us));
> + us->abort_task_tmf->tm_function = TM_FUNCTION_ABORT_TASK;
> + us->abort_task_tmf->task_tag = cmdiu->ipt_tag;
> + memcpy(us->abort_task_tmf->lun, cmdiu->lun, 8);
> + us->abort_task_tmf->state = COMMAND_STATE_IDLE;
> set_bit(US_FLIDX_ABORTING, &us->dflags);
> - usb_stor_stop_transport(us);
> + spin_unlock_irqrestore(&us->lock, flags);
> +
> + wake_up(&us->uasp_wq);
> }
> - scsi_unlock(us_to_host(us));
>
> /* Wait for the aborted command to finish */
> wait_for_completion(&us->notify);
> +
> return SUCCESS;
> }
>
> diff --git a/drivers/usb/storage/transport.c b/drivers/usb/storage/transport.c
> index 589f6b4..e24a02f 100644
> --- a/drivers/usb/storage/transport.c
> +++ b/drivers/usb/storage/transport.c
> @@ -175,7 +175,7 @@ static int usb_stor_msg_common(struct us_data *us, int timeout)
> /* wait for the completion of the URB */
> timeleft = wait_for_completion_interruptible_timeout(
> &urb_done, timeout ? : MAX_SCHEDULE_TIMEOUT);
> -
> +
> clear_bit(US_FLIDX_URB_ACTIVE, &us->dflags);
>
> if (timeleft <= 0) {
> @@ -1305,3 +1305,1269 @@ int usb_stor_port_reset(struct us_data *us)
> }
> return result;
> }
> +
> +void usb_stor_transfer_UASP_sglist(struct work_struct *work)
> +{
> + struct stor_sg_req *sg_req = container_of(work,
> + struct stor_sg_req,
> + work);
> + struct us_data *us = sg_req->us;
> + struct cmd_iu *cmdiu = sg_req->cmdiu;
> + unsigned int pipe = cmdiu->cmd->sc_data_direction == DMA_FROM_DEVICE ?
> + us->recv_bulk_pipe : us->send_bulk_pipe;
> + unsigned long flags;
> + int tag;
> + int i;
> +
> + US_DEBUGP("%s called\n", __func__);
> +
> + /* The command is aborted by abort task or reset nexus */
> + if (cmdiu->state == COMMAND_STATE_ABORTED)
> + goto ret;
> +
> + /* The command is halted by abort task or reset nexus */
> + if (cmdiu->state == COMMAND_STATE_HALTED)
> + goto ret;
> +
> + /* Sense iu received earlier */
> + if (cmdiu->state == COMMAND_STATE_STATUS)
> + goto ret;
> +
> + /* Disconnect bit is set */
> + if (test_bit(US_FLIDX_DISCONNECTING, &us->dflags))
> + goto ret;
> +
> + /* Reset bit is set */
> + if (test_bit(US_FLIDX_RESETTING, &us->dflags))
> + goto ret;
> +
> + sg_req->result = usb_sg_init(&sg_req->sg_req,
> + us->pusb_dev,
> + pipe,
> + 0,
> + scsi_sglist(cmdiu->cmd),
> + scsi_sg_count(cmdiu->cmd),
> + scsi_bufflen(cmdiu->cmd),
> + GFP_NOIO);
> +
> + if (sg_req->result)
> + goto ret;
> +
> + /*
> + * workaround for setting stream_id for each urb of sg_request,
> + * this should be implemented in usbcore driver.
> + */
> + tag = be16_to_cpu(cmdiu->ipt_tag);
> + for (i = 0; i < sg_req->sg_req.entries; i++)
> + sg_req->sg_req.urbs[i]->stream_id = tag;
> +
> + /* wait for the completion of the transfer */
> + usb_sg_wait(&sg_req->sg_req);
> + scsi_set_resid(cmdiu->cmd, scsi_bufflen(cmdiu->cmd) -
> + sg_req->sg_req.bytes);
> +
> +ret:
> + spin_lock_irqsave(&us->lock, flags);
> + /* This means that status received earlier with error code */
> + if (cmdiu->state == COMMAND_STATE_STATUS)
> + cmdiu->iobuf_sts = REQ_COMPLETED;
> +
> + cmdiu->sgreq_sts = REQ_COMPLETED;
> +
> + us->active_requests--;
> + us->pending_requests++;
> + spin_unlock_irqrestore(&us->lock, flags);
> +
> + wake_up(&us->uasp_wq);
> +}
> +
> +static int usb_stor_transfer_UASP_buf(struct us_data *us,
> + unsigned int pipe,
> + struct urb *cur_urb,
> + struct stor_iobuf *iobuf,
> + unsigned int length,
> + unsigned short stream_id,
> + void (*urb_complete)(struct urb *urb),
> + void *context)
> +{
> + int result;
> +
> + US_DEBUGP("%s called\n", __func__);
> +
> + /* fill and submit the URB */
> + usb_fill_bulk_urb(cur_urb,
> + us->pusb_dev,
> + pipe,
> + iobuf->buf,
> + length,
> + urb_complete,
> + context);
> +
> + /* fill the common fields in the URB */
> + cur_urb->transfer_flags = URB_NO_TRANSFER_DMA_MAP;
> + cur_urb->transfer_dma = iobuf->dma;
> + cur_urb->actual_length = 0;
> + cur_urb->error_count = 0;
> + cur_urb->status = 0;
> + cur_urb->stream_id = stream_id;
> +
> + /* submit the URB */
> + result = usb_submit_urb(cur_urb, GFP_NOIO);
> + if (result)
> + return result;
> +
> + return 0;
> +}
> +
> +static void usb_stor_cmd_urb_complete(struct urb *urb)
> +{
> + unsigned long flags;
> + struct cmd_iu *cmdiu = urb->context;
> + struct us_data *us = cmdiu->us;
> +
> + US_DEBUGP("%s called\n", __func__);
> +
> + us->command_pipe_sts = COMMAND_PIPE_IDLE;
> +
> + spin_lock_irqsave(&us->lock, flags);
> + cmdiu->iobuf_sts = REQ_COMPLETED;
> + us->active_requests--;
> + us->pending_requests++;
> + spin_unlock_irqrestore(&us->lock, flags);
> +
> + wake_up(&us->uasp_wq);
> +}
> +
> +static void usb_stor_status_urb_complete(struct urb *urb)
> +{
> + unsigned long flags;
> + struct cmd_iu *cmdiu = urb->context;
> + struct us_data *us = cmdiu->us;
> + struct s_iu *siu = (struct s_iu *)cmdiu->iobuf->buf;
> +
> + US_DEBUGP("%s called\n", __func__);
> +
> + spin_lock_irqsave(&us->lock, flags);
> + /*
> + * Everything is correct. If status completes earlier than data,
> + * just wait for data completion.
> + */
> + if (!urb->status && siu->status == STATUS_GOOD)
> + ;
> + /* The urb is completed with error,
> + * or the sense iu status is not good.
> + * Change cmdiu->state to COMMAND_STATE_STATUS.
> + */
> + else {
> + /* Command is
> + * halted
> + * aborted
> + * reset or
> + * disconnect bit is set.
> + */
> + if (cmdiu->state == COMMAND_STATE_ABORTED ||
> + cmdiu->state == COMMAND_STATE_HALTED ||
> + test_bit(US_FLIDX_RESETTING, &us->dflags) ||
> + test_bit(US_FLIDX_DISCONNECTING, &us->dflags))
> + ;
> + else
> + cmdiu->state = COMMAND_STATE_STATUS;
> + }
> +
> + cmdiu->iobuf_sts = REQ_COMPLETED;
> + us->active_requests--;
> + us->pending_requests++;
> + spin_unlock_irqrestore(&us->lock, flags);
> +
> + wake_up(&us->uasp_wq);
> +}
> +
> +static struct cmd_iu *usb_stor_find_cmd_iu_by_tag(
> + struct list_head *scsi_cmnd_queue,
> + __u16 ipt_tag)
> +{
> + struct cmd_iu *cmdiu = 0;
> +
> + US_DEBUGP("%s called\n", __func__);
> +
> + list_for_each_entry(cmdiu, scsi_cmnd_queue, node)
> + if (cmdiu->ipt_tag == ipt_tag)
> + return cmdiu;
> +
> + return 0;
> +}
> +
> +static struct stor_iobuf *usb_stor_get_iobuf(struct us_data *us)
> +{
> + int i;
> +
> + US_DEBUGP("%s called\n", __func__);
> +
> + for (i = 0; i < MAX_IOBUF_COUNT; i++) {
> + if (us->iobufs[i].sts == STOR_IOBUF_STATE_FREE) {
> + us->iobufs[i].sts = STOR_IOBUF_STATE_BUSY;
> + return &us->iobufs[i];
> + }
> + }
> +
> + return 0;
> +}
> +
> +static struct stor_urb *usb_stor_get_urb(struct us_data *us)
> +{
> + int i;
> +
> + US_DEBUGP("%s called\n", __func__);
> +
> + for (i = 0; i < MAX_URB_COUNT; i++) {
> + if (us->urbs[i].sts == STOR_URB_STATE_FREE) {
> + us->urbs[i].sts = STOR_URB_STATE_BUSY;
> + return &us->urbs[i];
> + }
> + }
> +
> + return 0;
> +}
> +
> +static struct stor_sg_req *usb_stor_get_sg_req(struct us_data *us)
> +{
> + int i;
> +
> + US_DEBUGP("%s called\n", __func__);
> +
> + for (i = 0; i < MAX_SG_REQ_COUNT; i++) {
> + if (us->sg_reqs[i].sts == STOR_SG_REQ_STATE_FREE) {
> + us->sg_reqs[i].sts = STOR_SG_REQ_STATE_BUSY;
> + return &us->sg_reqs[i];
> + }
> + }
> +
> + return 0;
> +}
> +
> +static void usb_stor_update_scsi_cmnd_queue(struct us_data *us)
> +{
> + struct cmd_iu *cmdiu1;
> + struct cmd_iu *cmdiu2;
> +
> + US_DEBUGP("%s called\n", __func__);
> +
> + list_for_each_entry_safe(cmdiu1, cmdiu2,
> + &us->temp_scsi_cmnd_queue, node) {
> + list_del(&cmdiu1->node);
> + list_add_tail(&cmdiu1->node, &us->scsi_cmnd_queue);
> + }
> +}
> +
> +static int usb_stor_check_scsi_cmnd(struct us_data *us, struct cmd_iu *cmdiu)
> +{
> + US_DEBUGP("%s called\n", __func__);
> +
> + /* Reject the command if the direction indicator is UNKNOWN */
> + if (cmdiu->cmd->sc_data_direction == DMA_BIDIRECTIONAL) {
> + US_DEBUGP("%s - UNKNOWN data direction\n", __func__);
> + cmdiu->cmd->result = DID_ERROR << 16;
> + return -1;
> + }
> + /* Reject if target != 0 */
> + else if (cmdiu->cmd->device->id) {
> + US_DEBUGP("%s - Bad target number (%d:%d)\n",
> + __func__,
> + cmdiu->cmd->device->id,
> + cmdiu->cmd->device->lun);
> + cmdiu->cmd->result = DID_BAD_TARGET << 16;
> + return -1;
> + }
> + /* or if LUN is higher than the maximum known LUN */
> + else if (cmdiu->cmd->device->lun > us->max_lun) {
> + US_DEBUGP("%s - Bad LUN (%d:%d)\n",
> + __func__,
> + cmdiu->cmd->device->id,
> + cmdiu->cmd->device->lun);
> + cmdiu->cmd->result = DID_BAD_TARGET << 16;
> + return -1;
> + }
> +
> + return 0;
> +}
> +
> +static int usb_stor_process_scsi_cmnd(struct us_data *us, struct cmd_iu *cmdiu)
> +{
> + unsigned int transfer_length;
> + unsigned int pipe;
> + unsigned long flags;
> + int result = 0;
> + int status = 0;
> + struct s_iu *siu = NULL;
> +
> + US_DEBUGP("%s called\n", __func__);
> +
> +start:
> + switch (cmdiu->state) {
> + case COMMAND_STATE_IDLE:
> + /* If the command is incorrest */
> + if (usb_stor_check_scsi_cmnd(us, cmdiu)) {
> + scsi_lock(us_to_host(us));
> + cmdiu->cmd->scsi_done(cmdiu->cmd);
> + cmdiu->iobuf->sts = STOR_IOBUF_STATE_FREE;
> + cmdiu->urb->sts = STOR_URB_STATE_FREE;
> + cmdiu->sg_req->sts = STOR_SG_REQ_STATE_FREE;
> + list_del(&cmdiu->node);
> + kfree(cmdiu);
> + scsi_unlock(us_to_host(us));
> + return result;
> + }
> +
> + /* Move to command state */
> + cmdiu->state = COMMAND_STATE_COMMAND;
> + cmdiu->iobuf_sts = REQ_NOT_SUBMITTED;
> + cmdiu->sgreq_sts = REQ_NOT_SUBMITTED;
> + goto start;
> +
> + case COMMAND_STATE_COMMAND:
> + /* Create the command buffer and submit the urb */
> + if (cmdiu->iobuf_sts == REQ_NOT_SUBMITTED) {
> + us->command_pipe_sts = COMMAND_PIPE_BUSY;
> + memcpy(cmdiu->iobuf->buf,
> + (unsigned char *)cmdiu,
> + COMMAND_IU_SIZE);
> +
> + status = usb_stor_transfer_UASP_buf(us,
> + us->command_pipe,
> + cmdiu->urb->req,
> + cmdiu->iobuf,
> + COMMAND_IU_SIZE,
> + 0,
> + usb_stor_cmd_urb_complete,
> + cmdiu);
> +
> + if (status) {
> + us->command_pipe_sts = COMMAND_PIPE_IDLE;
> + cmdiu->state = COMMAND_STATE_COMPLETED;
> + result = interpret_urb_result(us,
> + us->command_pipe,
> + COMMAND_IU_SIZE,
> + status,
> + cmdiu->urb->req->actual_length);
> + } else {
> + spin_lock_irqsave(&us->lock, flags);
> + us->active_requests++;
> +
> + if (cmdiu->iobuf_sts == REQ_NOT_SUBMITTED) {
> + US_DEBUGP("%s URB is not completed\n",
> + __func__);
> + cmdiu->iobuf_sts = REQ_IN_PROGRESS;
> + } else {
> + US_DEBUGP("%s URB is completed\n",
> + __func__);
> + }
> + spin_unlock_irqrestore(&us->lock, flags);
> + }
> + }
> + /* Do nothing if the submitted urb is in progress */
> + else if (cmdiu->iobuf_sts == REQ_IN_PROGRESS)
> + ;
> + /* Submitted urb is completed
> + * 1. Check for errors, if any, return it.
> + * 2. If no any error move to the data or status stage.
> + */
> + else if (cmdiu->iobuf_sts == REQ_COMPLETED) {
> + transfer_length = scsi_bufflen(cmdiu->cmd);
> +
> + result = interpret_urb_result(us,
> + us->command_pipe,
> + COMMAND_IU_SIZE,
> + cmdiu->urb->req->status,
> + cmdiu->urb->req->actual_length);
> +
> + cmdiu->iobuf_sts = REQ_NOT_SUBMITTED;
> +
> + if (result == USB_STOR_XFER_GOOD) {
> + if (transfer_length)
> + cmdiu->state = COMMAND_STATE_DATA;
> + else
> + cmdiu->state = COMMAND_STATE_STATUS;
> +
> + goto start;
> + } else
> + cmdiu->state = COMMAND_STATE_COMPLETED;
> + }
> + break;
> +
> + case COMMAND_STATE_DATA:
> + if (cmdiu->sgreq_sts == REQ_NOT_SUBMITTED) {
> + /* Run work, which will process the sg request */
> + cmdiu->sgreq_sts = REQ_IN_PROGRESS;
> + queue_work(us->sg_wq, &cmdiu->sg_req->work);
> +
> + spin_lock_irqsave(&us->lock, flags);
> + us->active_requests++;
> + spin_unlock_irqrestore(&us->lock, flags);
> +
> + /*
> + * Submit buffer on status endpoint too,
> + * maybe device will response with error
> + * status and not start the data stage.
> + */
> + status = usb_stor_transfer_UASP_buf(us,
> + us->status_pipe,
> + cmdiu->urb->req,
> + cmdiu->iobuf,
> + SENSE_IU_SIZE,
> + be16_to_cpu(cmdiu->ipt_tag),
> + usb_stor_status_urb_complete,
> + cmdiu);
> +
> + if (status) {
> + result = interpret_urb_result(us,
> + us->status_pipe,
> + SENSE_IU_SIZE,
> + status,
> + cmdiu->urb->req->actual_length);
> + } else {
> + spin_lock_irqsave(&us->lock, flags);
> + if (cmdiu->iobuf_sts == REQ_NOT_SUBMITTED) {
> + US_DEBUGP("%s URB is not completed\n",
> + __func__);
> + cmdiu->iobuf_sts = REQ_IN_PROGRESS;
> + } else
> + US_DEBUGP("%s URB is completed\n",
> + __func__);
> +
> + us->active_requests++;
> + spin_unlock_irqrestore(&us->lock, flags);
> + }
> + }
> + /* Do nothing if the submitted sg_req is in progress */
> + else if (cmdiu->sgreq_sts == REQ_IN_PROGRESS)
> + ;
> + /* Submitted sg_req is completed
> + * 1. Check for errors, if any, return it.
> + * 2. If no any error move to status stage.
> + */
> + else if (cmdiu->sgreq_sts == REQ_COMPLETED) {
> + pipe = cmdiu->cmd->sc_data_direction ==
> + DMA_FROM_DEVICE ? us->recv_bulk_pipe :
> + us->send_bulk_pipe;
> + transfer_length = scsi_bufflen(cmdiu->cmd);
> + cmdiu->sgreq_sts = REQ_NOT_SUBMITTED;
> +
> + if (cmdiu->sg_req->result)
> + result = USB_STOR_XFER_ERROR;
> + else {
> + result = interpret_urb_result(us,
> + pipe,
> + transfer_length,
> + cmdiu->sg_req->sg_req.status,
> + cmdiu->sg_req->sg_req.bytes);
> +
> + if (result == USB_STOR_XFER_ERROR) {
> + result = USB_STOR_TRANSPORT_ERROR;
> + } else {
> + result = USB_STOR_XFER_GOOD;
> + cmdiu->state = COMMAND_STATE_STATUS;
> + goto start;
> + }
> + }
> + }
> + break;
> +
> + case COMMAND_STATE_STATUS:
> + if (cmdiu->iobuf_sts == REQ_NOT_SUBMITTED) {
> + status = usb_stor_transfer_UASP_buf(us,
> + us->status_pipe,
> + cmdiu->urb->req,
> + cmdiu->iobuf,
> + SENSE_IU_SIZE,
> + be16_to_cpu(cmdiu->ipt_tag),
> + usb_stor_status_urb_complete,
> + cmdiu);
> +
> + if (status) {
> + result = interpret_urb_result(us,
> + us->status_pipe,
> + SENSE_IU_SIZE,
> + status,
> + cmdiu->urb->req->actual_length);
> + } else {
> + spin_lock_irqsave(&us->lock, flags);
> + if (cmdiu->iobuf_sts == REQ_NOT_SUBMITTED) {
> + US_DEBUGP("%s URB is not completed\n",
> + __func__);
> + cmdiu->iobuf_sts = REQ_IN_PROGRESS;
> + } else
> + US_DEBUGP("%s URB is completed\n",
> + __func__);
> +
> + us->active_requests++;
> + spin_unlock_irqrestore(&us->lock, flags);
> + }
> + } else if (cmdiu->iobuf_sts == REQ_IN_PROGRESS)
> + ;
> + else if (cmdiu->iobuf_sts == REQ_COMPLETED) {
> + /*
> + * Sense iu received before DATA stage,
> + * that means something goes wrong on device side
> + */
> + spin_lock_irqsave(&us->lock, flags);
> + if (cmdiu->sgreq_sts == REQ_IN_PROGRESS) {
> + US_DEBUGP("%s Sense IU completes early\n",
> + __func__);
> + siu = (struct s_iu *)cmdiu->iobuf->buf;
> +
> + /* Sense iu with error. Cancel sg_list on the
> + * data pipe. After the sg_list proper
> + * cancelation return to the status stage and
> + * complete the command.
> + */
> + if (!cmdiu->urb->req->status &&
> + siu->status != STATUS_GOOD)
> + cmdiu->iobuf_sts = REQ_IN_PROGRESS;
> +
> + spin_unlock_irqrestore(&us->lock, flags);
> + US_DEBUGP("%s Cancelling sg request\n",
> + __func__);
> + usb_sg_cancel(&cmdiu->sg_req->sg_req);
> +
> + if (!cmdiu->urb->req->status)
> + break;
> +
> + spin_lock_irqsave(&us->lock, flags);
> + }
> + spin_unlock_irqrestore(&us->lock, flags);
> +
> + result = interpret_urb_result(us,
> + us->command_pipe,
> + SENSE_IU_SIZE,
> + cmdiu->urb->req->status,
> + cmdiu->urb->req->actual_length);
> +
> + cmdiu->iobuf_sts = REQ_NOT_SUBMITTED;
> + cmdiu->state = COMMAND_STATE_COMPLETED;
> +
> + if (result == USB_STOR_XFER_GOOD)
> + goto start;
> + }
> + break;
> +
> + case COMMAND_STATE_COMPLETED:
> + scsi_lock(us_to_host(us));
> + siu = (struct s_iu *)cmdiu->iobuf->buf;
> +
> + /* Status is GOOD */
> + if (siu->status == STATUS_GOOD)
> + cmdiu->cmd->result = SAM_STAT_GOOD;
> + /* Status is CHECK CONDITION. Provide with the sense data */
> + else if (siu->status == STATUS_CHECK_CONDITION) {
> + memset(cmdiu->cmd->sense_buffer, 0, 18);
> + cmdiu->cmd->sense_buffer[0] = 0x70;
> + cmdiu->cmd->sense_buffer[2] = siu->sense_data[0];
> + cmdiu->cmd->sense_buffer[7] = 10;
> + cmdiu->cmd->sense_buffer[12] = siu->sense_data[1];
> + cmdiu->cmd->sense_buffer[13] = siu->sense_data[2];
> + cmdiu->cmd->result = SAM_STAT_CHECK_CONDITION;
> + }
> +
> + cmdiu->cmd->scsi_done(cmdiu->cmd);
> + cmdiu->iobuf->sts = STOR_IOBUF_STATE_FREE;
> + cmdiu->urb->sts = STOR_URB_STATE_FREE;
> + cmdiu->sg_req->sts = STOR_SG_REQ_STATE_FREE;
> + list_del(&cmdiu->node);
> + kfree(cmdiu);
> + scsi_unlock(us_to_host(us));
> + break;
> +
> + case COMMAND_STATE_ABORTED:
> + /* If the command is aborted, we should not call scsi_done() */
> + if (cmdiu->iobuf)
> + cmdiu->iobuf->sts = STOR_IOBUF_STATE_FREE;
> + if (cmdiu->urb)
> + cmdiu->urb->sts = STOR_URB_STATE_FREE;
> + if (cmdiu->sg_req)
> + cmdiu->sg_req->sts = STOR_SG_REQ_STATE_FREE;
> +
> + list_del(&cmdiu->node);
> + kfree(cmdiu);
> + break;
> +
> + default:
> + US_DEBUGP("%s - Unknown cmdiu->state %d!\n",
> + __func__,
> + cmdiu->state);
> + }
> +
> + return result;
> +}
> +
> +unsigned int usb_stor_get_tag(struct us_data *us)
> +{
> + US_DEBUGP("%s called\n", __func__);
> +
> + us->tag++;
> + if (us->tag > USB_STOR_NUM_STREAMS)
> + us->tag = 0;
> +
> + if (!us->tag)
> + us->tag++;
> +
> + return us->tag;
> +}
> +
> +int usb_stor_UASP_transport(struct scsi_cmnd *srb, struct us_data *us)
> +{
> + struct cmd_iu *cmdiu1;
> + struct cmd_iu *cmdiu2;
> + unsigned long flags;
> + int cmd_is_active = 0;
> + int result = 0;
> +
> + US_DEBUGP("%s called\n", __func__);
> +
> + spin_lock_irqsave(&us->lock, flags);
> + us->pending_requests = 0;
> + us->new_command = 0;
> + spin_unlock_irqrestore(&us->lock, flags);
> +
> + /* Move commands from temp_scsi_cmnd_queue to scsi_cmnd_queue */
> + spin_lock_irqsave(&us->lock, flags);
> + usb_stor_update_scsi_cmnd_queue(us);
> + spin_unlock_irqrestore(&us->lock, flags);
> +
> + list_for_each_entry_safe(cmdiu1, cmdiu2, &us->scsi_cmnd_queue, node) {
> + /* Disconnect bit is set */
> + if (test_bit(US_FLIDX_DISCONNECTING, &us->dflags)) {
> + US_DEBUGP("%s Disconnect bit is set\n", __func__);
> + break;
> + }
> +
> + /* Reset bit is set */
> + if (test_bit(US_FLIDX_RESETTING, &us->dflags)) {
> + US_DEBUGP("%s Reset bit is set\n", __func__);
> + break;
> + }
> +
> + /* If command state is idle */
> + if (cmdiu1->state == COMMAND_STATE_IDLE) {
> + /* If command pipe is busy */
> + if (us->command_pipe_sts == COMMAND_PIPE_BUSY) {
> + /* We have an unprocessed command */
> + spin_lock_irqsave(&us->lock, flags);
> + us->new_command = 1;
> + spin_unlock_irqrestore(&us->lock, flags);
> + continue;
> + }
> +
> + /* Tries to get buffer for this cmdiu */
> + cmdiu1->iobuf = usb_stor_get_iobuf(us);
> + if (cmdiu1->iobuf == 0)
> + continue;
> +
> + /* Tries to get urb for this cmdiu */
> + cmdiu1->urb = usb_stor_get_urb(us);
> + if (cmdiu1->urb == 0) {
> + cmdiu1->iobuf->sts = STOR_IOBUF_STATE_FREE;
> + continue;
> + }
> +
> + /* Tries to sg request for this cmdiu */
> + cmdiu1->sg_req = usb_stor_get_sg_req(us);
> + if (cmdiu1->sg_req == 0) {
> + cmdiu1->iobuf->sts = STOR_IOBUF_STATE_FREE;
> + cmdiu1->urb->sts = STOR_URB_STATE_FREE;
> + continue;
> + } else {
> + cmdiu1->sg_req->cmdiu = cmdiu1;
> + cmdiu1->sg_req->us = us;
> + }
> + }
> + /*
> + * The processing of the command is halted because
> + * of abort task or reset nexus task management
> + * function processing
> + */
> + if (cmdiu1->state == COMMAND_STATE_HALTED)
> + continue;
> +
> + /*
> + * Workaround - not perform other queued commands while
> + * curretn is active
> + */
> + if (cmdiu1->state == COMMAND_STATE_COMMAND &&
> + cmdiu1->iobuf_sts == REQ_COMPLETED &&
> + cmd_is_active) {
> + US_DEBUGP("%s - Command is sent to device, but " \
> + "other command still active\n", __func__);
> + continue;
> + }
> +
> + result = usb_stor_process_scsi_cmnd(us, cmdiu1);
> + if (result)
> + break;
> +
> + if (cmdiu1->state == COMMAND_STATE_DATA ||
> + cmdiu1->state == COMMAND_STATE_STATUS) {
> + cmd_is_active = 1;
> + US_DEBUGP("%s - There is an active command\n",
> + __func__);
> + }
> + }
> +
> + return result;
> +}
> +
> +static void usb_stor_abort_task_urb_complete(struct urb *urb)
> +{
> + unsigned long flags;
> + struct us_data *us = urb->context;
> +
> + US_DEBUGP("%s called\n", __func__);
> +
> + us->abort_task_tmf->req_sts = REQ_COMPLETED;
> +
> + spin_lock_irqsave(&us->lock, flags);
> + us->active_requests--;
> + us->pending_requests++;
> + spin_unlock_irqrestore(&us->lock, flags);
> +
> + wake_up(&us->uasp_wq);
> +}
> +
> +static int usb_stor_abort_task(struct us_data *us)
> +{
> + int status;
> + int result = USB_STOR_TRANSPORT_GOOD;
> + unsigned long flags;
> + struct cmd_iu *cmdiu;
> +
> + US_DEBUGP("%s called\n", __func__);
> +
> + if (us->abort_task_tmf->state == COMMAND_STATE_COMMAND ||
> + us->abort_task_tmf->state == COMMAND_STATE_STATUS)
> + goto start;
> +
> + /* Try to find the command again */
> + scsi_lock(us_to_host(us));
> + usb_stor_update_scsi_cmnd_queue(us);
> + scsi_unlock(us_to_host(us));
> + cmdiu = usb_stor_find_cmd_iu_by_tag(
> + &us->scsi_cmnd_queue,
> + us->abort_task_tmf->task_tag);
> +
> + /*
> + * Command IU is not found, notify to SCSI layer
> + * that abort is done
> + */
> + if (cmdiu == NULL) {
> + US_DEBUGP("%s Command is not found\n", __func__);
> + us->abort_task_tmf->state = COMMAND_STATE_COMPLETED;
> + clear_bit(US_FLIDX_ABORTING, &us->dflags);
> + complete(&us->notify);
> + return result;
> + }
> +
> + /*
> + * The processing of the Command IU is not started yet,
> + * or is finished, or aborted. Notify to SCSI layer that"
> + * abort is done.
> + */
> + if (cmdiu->state == COMMAND_STATE_IDLE ||
> + cmdiu->state == COMMAND_STATE_COMPLETED ||
> + cmdiu->state == COMMAND_STATE_ABORTED) {
> + US_DEBUGP("%s Processing of the command is finished\n",
> + __func__);
> + cmdiu->state = COMMAND_STATE_ABORTED;
> + us->abort_task_tmf->state = COMMAND_STATE_COMPLETED;
> + clear_bit(US_FLIDX_ABORTING, &us->dflags);
> + complete(&us->notify);
> + return result;
> + }
> +
> + /* Get buffer for processing */
> + us->abort_task_tmf->iobuf = usb_stor_get_iobuf(us);
> + if (us->abort_task_tmf->iobuf == 0)
> + return result;
> +
> + /* Get urb for processing */
> + us->abort_task_tmf->urb = usb_stor_get_urb(us);
> + if (us->abort_task_tmf->urb == 0) {
> + us->abort_task_tmf->iobuf->sts = STOR_IOBUF_STATE_FREE;
> + return result;
> + }
> +
> + /* If the command pipe is busy, wait for idle */
> + if (us->command_pipe_sts == COMMAND_PIPE_BUSY) {
> + US_DEBUGP("%s Waiting for command pipe idle\n", __func__);
> + wait_event(us->uasp_wq,
> + (us->command_pipe_sts == COMMAND_PIPE_IDLE));
> + }
> +
> + if (test_bit(US_FLIDX_DISCONNECTING, &us->dflags)) {
> + US_DEBUGP("%s Disconnect bit is set\n", __func__);
> + return result;
> + }
> +
> + if (test_bit(US_FLIDX_RESETTING, &us->dflags)) {
> + US_DEBUGP("%s Reset bit is set\n", __func__);
> + return result;
> + }
> +
> + us->abort_task_tmf->state = COMMAND_STATE_COMMAND;
> + us->abort_task_tmf->req_sts = REQ_NOT_SUBMITTED;
> +
> +start:
> + switch (us->abort_task_tmf->state) {
> + case COMMAND_STATE_COMMAND:
> + US_DEBUGP("%s Command state\n", __func__);
> + if (us->abort_task_tmf->req_sts == REQ_NOT_SUBMITTED) {
> + spin_lock_irqsave(&us->lock, flags);
> + us->abort_task_tmf->cmdiu->state =
> + COMMAND_STATE_HALTED;
> + spin_unlock_irqrestore(&us->lock, flags);
> +
> + /* Send abort task tmf to device */
> + memcpy(us->abort_task_tmf->iobuf->buf,
> + (void *)us->abort_task_tmf,
> + TM_FUNCTION_IU_SIZE);
> +
> + us->command_pipe_sts = COMMAND_PIPE_BUSY;
> + status = usb_stor_transfer_UASP_buf(us,
> + us->command_pipe,
> + us->abort_task_tmf->urb->req,
> + us->abort_task_tmf->iobuf,
> + TM_FUNCTION_IU_SIZE,
> + 0,
> + usb_stor_abort_task_urb_complete,
> + us);
> +
> + /* Something went wrong, need to reset */
> + if (status) {
> + us->command_pipe_sts = COMMAND_PIPE_IDLE;
> + result = interpret_urb_result(us,
> + us->command_pipe,
> + TM_FUNCTION_IU_SIZE,
> + status,
> + us->abort_task_tmf->urb->req->
> + actual_length);
> +
> + us->abort_task_tmf->iobuf->sts =
> + STOR_IOBUF_STATE_FREE;
> + us->abort_task_tmf->urb->sts =
> + STOR_URB_STATE_FREE;
> + } else {
> + spin_lock_irqsave(&us->lock, flags);
> + if (us->abort_task_tmf->req_sts ==
> + REQ_NOT_SUBMITTED) {
> + US_DEBUGP("%s URB is not completed\n",
> + __func__);
> + us->abort_task_tmf->req_sts =
> + REQ_IN_PROGRESS;
> + } else
> + US_DEBUGP("%s URB is completed\n",
> + __func__);
> +
> + us->active_requests++;
> + spin_unlock_irqrestore(&us->lock, flags);
> + }
> + } else if (us->abort_task_tmf->req_sts == REQ_IN_PROGRESS)
> + ;
> + else if (us->abort_task_tmf->req_sts == REQ_COMPLETED) {
> + result = interpret_urb_result(us,
> + us->command_pipe,
> + TM_FUNCTION_IU_SIZE,
> + us->abort_task_tmf->urb->req->status,
> + us->abort_task_tmf->urb->req->actual_length);
> +
> + /* Something went wrong, need to reset */
> + if (result) {
> + us->abort_task_tmf->iobuf->sts =
> + STOR_IOBUF_STATE_FREE;
> + us->abort_task_tmf->urb->sts =
> + STOR_URB_STATE_FREE;
> + } else {
> + us->abort_task_tmf->state =
> + COMMAND_STATE_STATUS;
> + us->abort_task_tmf->req_sts =
> + REQ_NOT_SUBMITTED;
> + goto start;
> + }
> + }
> + break;
> +
> + case COMMAND_STATE_STATUS:
> + US_DEBUGP("%s Status state\n", __func__);
> +
> + if (us->abort_task_tmf->req_sts == REQ_NOT_SUBMITTED) {
> + status = usb_stor_transfer_UASP_buf(us,
> + us->status_pipe,
> + us->abort_task_tmf->urb->req,
> + us->abort_task_tmf->iobuf,
> + RESPONSE_IU_SIZE,
> + be16_to_cpu(us->abort_task_tmf->
> + ipt_tag),
> + usb_stor_abort_task_urb_complete,
> + us);
> +
> + if (status) {
> + result = interpret_urb_result(us,
> + us->status_pipe,
> + RESPONSE_IU_SIZE,
> + status,
> + us->abort_task_tmf->urb->req->
> + actual_length);
> +
> + us->abort_task_tmf->iobuf->sts =
> + STOR_IOBUF_STATE_FREE;
> + us->abort_task_tmf->urb->sts =
> + STOR_URB_STATE_FREE;
> + } else {
> + spin_lock_irqsave(&us->lock, flags);
> + if (us->abort_task_tmf->req_sts ==
> + REQ_NOT_SUBMITTED) {
> + US_DEBUGP("%s URB is not completed\n",
> + __func__);
> + us->abort_task_tmf->req_sts =
> + REQ_IN_PROGRESS;
> + } else {
> + US_DEBUGP("%s URB is completed\n",
> + __func__);
> + }
> + us->active_requests++;
> + spin_unlock_irqrestore(&us->lock, flags);
> + }
> + } else if (us->abort_task_tmf->req_sts == REQ_IN_PROGRESS)
> + ;
> + else if (us->abort_task_tmf->req_sts == REQ_COMPLETED) {
> + result = interpret_urb_result(us,
> + us->status_pipe,
> + RESPONSE_IU_SIZE,
> + us->abort_task_tmf->urb->req->status,
> + us->abort_task_tmf->urb->req->
> + actual_length);
> +
> + us->abort_task_tmf->iobuf->sts = STOR_IOBUF_STATE_FREE;
> + us->abort_task_tmf->urb->sts = STOR_URB_STATE_FREE;
> +
> + if (!result) {
> + /*
> + * Kill all the active requests
> + * connected to the aborted COMMAND IU
> + */
> + if (us->abort_task_tmf->cmdiu->iobuf_sts ==
> + REQ_IN_PROGRESS)
> + usb_kill_urb(us->abort_task_tmf->
> + cmdiu->urb->req);
> +
> + if (us->abort_task_tmf->cmdiu->sgreq_sts ==
> + REQ_IN_PROGRESS)
> + usb_sg_cancel(&us->abort_task_tmf->
> + cmdiu->sg_req->sg_req);
> + /*
> + * FIXME maybe here we need to add a mechanism
> + * for waiting of the completion of the command
> + * related urbs and sg_reqs.
> + */
> + us->abort_task_tmf->state =
> + COMMAND_STATE_COMPLETED;
> + clear_bit(US_FLIDX_ABORTING, &us->dflags);
> + complete(&us->notify);
> + }
> + }
> +
> + break;
> + }
> +
> + return result;
> +}
> +
> +void usb_stor_kill_all_requests(struct us_data *us)
> +{
> + struct cmd_iu *cmdiu;
> + US_DEBUGP("%s called\n", __func__);
> +
> + /* Move commands from temp_scsi_cmnd_queue to scsi_cmnd_queue */
> + scsi_lock(us_to_host(us));
> + usb_stor_update_scsi_cmnd_queue(us);
> + scsi_unlock(us_to_host(us));
> +
> + /* Abort all the commands */
> + list_for_each_entry(cmdiu, &us->scsi_cmnd_queue, node) {
> + scsi_lock(us_to_host(us));
> + cmdiu->state = COMMAND_STATE_ABORTED;
> + scsi_unlock(us_to_host(us));
> +
> + /* FIXME do we need this? */
> + if (test_bit(US_FLIDX_DISCONNECTING, &us->dflags)) {
> + US_DEBUGP("%s Disconnect bit is set\n", __func__);
> + cmdiu->cmd->result = DID_NO_CONNECT << 16;
> + }
> + /* FIXME do we need this? */
> + if (test_bit(US_FLIDX_RESETTING, &us->dflags)) {
> + US_DEBUGP("%s Reset bit is set\n", __func__);
> + cmdiu->cmd->result = DID_ERROR << 16;
> + }
> + if (cmdiu->iobuf_sts == REQ_IN_PROGRESS) {
> + US_DEBUGP("%s Kill the active urb\n", __func__);
> + usb_kill_urb(cmdiu->urb->req);
> + }
> + if (cmdiu->sgreq_sts == REQ_IN_PROGRESS) {
> + US_DEBUGP("%s - Kill the active sg_req\n", __func__);
> + usb_sg_cancel(&cmdiu->sg_req->sg_req);
> + }
> + }
> + /* If the abort command tm function is in progress, kill it */
> + us->abort_task_tmf->state = COMMAND_STATE_COMPLETED;
> +
> + if (us->abort_task_tmf->req_sts == REQ_IN_PROGRESS) {
> + clear_bit(US_FLIDX_ABORTING, &us->dflags);
> + usb_kill_urb(us->abort_task_tmf->urb->req);
> + /* FIXME do we need to notify during reset? */
> + complete(&us->notify);
> + }
> +
> + US_DEBUGP("%s - Waiting for completion for all aborted commands\n",
> + __func__);
> + wait_event(us->uasp_wq, (us->active_requests == 0));
> +}
> +
> +static void usb_stor_complete_reset_nexus(struct urb *urb)
> +{
> + struct completion *urb_done_ptr = urb->context;
> + US_DEBUGP("%s called\n", __func__);
> +
> + complete(urb_done_ptr);
> +}
> +
> +int usb_stor_UASP_reset(struct us_data *us)
> +{
> + long timeleft;
> + int tag, result;
> + struct tm_iu *tmiu;
> + struct r_iu *riu;
> + struct stor_iobuf *iobuf;
> + struct stor_urb *urb;
> + struct completion urb_done;
> +
> + US_DEBUGP("%s called\n", __func__);
> +
> + if (test_bit(US_FLIDX_DISCONNECTING, &us->dflags)) {
> + US_DEBUGP("%s Disconnect bit is set\n", __func__);
> + return -1;
> + }
> +
> + /* Kill all the active requests, and wait for completion */
> + usb_stor_kill_all_requests(us);
> +
> + if (test_bit(US_FLIDX_DISCONNECTING, &us->dflags)) {
> + US_DEBUGP("%s Disconnect bit is set\n", __func__);
> + return -1;
> + }
> +
> + /* Get the buffer */
> + iobuf = usb_stor_get_iobuf(us);
> + if (!iobuf)
> + return -1;
> +
> + /* Get the urb */
> + urb = usb_stor_get_urb(us);
> + if (!urb) {
> + iobuf->sts = STOR_IOBUF_STATE_FREE;
> + return -1;
> + }
> +
> + tag = usb_stor_get_tag(us);
> +
> + /* Initialize the command buffer */
> + tmiu = (struct tm_iu *)iobuf->buf;
> + memset(tmiu, 0, TM_FUNCTION_IU_SIZE);
> + tmiu->tm_iu_id = IU_ID_TASK_MANAGEMENT;
> + tmiu->reserved1 = 0;
> + tmiu->ipt_tag = cpu_to_be16(tag);
> + tmiu->tm_function = 0;
> + tmiu->reserved2 = 0;
> + tmiu->task_tag = 0;
> + memset(tmiu->lun, 0, 8);
> +
> + /* Fill the URB */
> + usb_fill_bulk_urb(urb->req,
> + us->pusb_dev,
> + us->command_pipe,
> + iobuf->buf,
> + TM_FUNCTION_IU_SIZE,
> + usb_stor_complete_reset_nexus,
> + NULL);
> +
> + init_completion(&urb_done);
> +
> + /* Fill the common fields in the URB */
> + urb->req->context = &urb_done;
> + urb->req->actual_length = 0;
> + urb->req->error_count = 0;
> + urb->req->status = 0;
> + urb->req->transfer_flags = URB_NO_TRANSFER_DMA_MAP;
> + urb->req->stream_id = 0;
> + urb->req->transfer_buffer = iobuf->buf;
> + urb->req->transfer_dma = iobuf->dma;
> +
> + result = usb_submit_urb(urb->req, GFP_NOIO);
> + if (result)
> + goto err;
> +
> + US_DEBUGP("%s - Waiting for completion of the submitted urb\n",
> + __func__);
> +
> + /* wait for the completion of the URB */
> + timeleft = wait_for_completion_interruptible_timeout(&urb_done,
> + MAX_SCHEDULE_TIMEOUT);
> +
> + if (test_bit(US_FLIDX_DISCONNECTING, &us->dflags)) {
> + US_DEBUGP("%s Disconnect bit is set\n", __func__);
> + goto err;
> + }
> +
> + if (timeleft <= 0) {
> + usb_kill_urb(us->current_urb);
> + goto err;
> + }
> +
> + if (interpret_urb_result(us,
> + us->command_pipe,
> + TM_FUNCTION_IU_SIZE,
> + result,
> + urb->req->actual_length))
> + goto err;
> +
> + /* Initialize the response buffer */
> + riu = (struct r_iu *)iobuf->buf;
> + memset(riu, 0, RESPONSE_IU_SIZE);
> +
> + /* Fill the URB */
> + usb_fill_bulk_urb(urb->req,
> + us->pusb_dev,
> + us->status_pipe,
> + iobuf->buf,
> + RESPONSE_IU_SIZE,
> + usb_stor_complete_reset_nexus,
> + NULL);
> +
> + init_completion(&urb_done);
> +
> + /* Fill the common fields in the URB */
> + urb->req->context = &urb_done;
> + urb->req->actual_length = 0;
> + urb->req->error_count = 0;
> + urb->req->status = 0;
> + urb->req->transfer_flags = URB_NO_TRANSFER_DMA_MAP;
> + urb->req->stream_id = tag;
> + urb->req->transfer_buffer = iobuf->buf;
> + urb->req->transfer_dma = iobuf->dma;
> +
> + result = usb_submit_urb(urb->req, GFP_NOIO);
> + if (result)
> + goto err;
> +
> + US_DEBUGP("%s - Waiting for completion of the submitted urb\n",
> + __func__);
> +
> + /* wait for the completion of the URB */
> + timeleft = wait_for_completion_interruptible_timeout(
> + &urb_done, MAX_SCHEDULE_TIMEOUT);
> +
> + if (timeleft <= 0) {
> + usb_kill_urb(us->current_urb);
> + goto err;
> + }
> +
> + if (interpret_urb_result(us,
> + us->command_pipe,
> + RESPONSE_IU_SIZE,
> + result,
> + urb->req->actual_length))
> + goto err;
> +
> + iobuf->sts = STOR_IOBUF_STATE_FREE;
> + urb->sts = STOR_URB_STATE_FREE;
> + return 0;
> +err:
> + US_DEBUGP("%s - Error\n", __func__);
> +
> + iobuf->sts = STOR_IOBUF_STATE_FREE;
> + urb->sts = STOR_URB_STATE_FREE;
> + return -1;
> +}
> +
> +int usb_stor_UASP_max_lun(struct us_data *us)
> +{
> + /*
> + * FIXME perform this action properly. REPORT LUNS SCSI command
> + * should be performed for getting all LUN related information.
> + * Currently on UASP mode assumes, that device is working with
> + * one LUN.
> + */
> + us->max_lun = 0;
> + return 0;
> +}
> +
> +void usb_stor_invoke_UASP_transport(struct us_data *us)
> +{
> + int result = 0;
> +
> + US_DEBUGP("%s called\n", __func__);
> +
> + if (test_bit(US_FLIDX_ABORTING, &us->dflags)) {
> + US_DEBUGP("%s abort bit is set\n", __func__);
> + result = usb_stor_abort_task(us);
> + /* Transport error, do reset */
> + if (result)
> + goto reset;
> + }
> +
> + /* If Disconnect bit is set */
> + if (test_bit(US_FLIDX_DISCONNECTING, &us->dflags)) {
> + US_DEBUGP("%s Disconnect bit is set\n", __func__);
> + return;
> + }
> +
> + /* If Reset bit is set */
> + if (test_bit(US_FLIDX_RESETTING, &us->dflags)) {
> + US_DEBUGP("%s Reset bit is set\n", __func__);
> + return;
> + }
> +
> + result = us->transport(0, us);
> +
> + /* Transport error, do reset */
> + if (result) {
> + /* If Disconnect bit is set */
> + if (test_bit(US_FLIDX_DISCONNECTING, &us->dflags)) {
> + US_DEBUGP("%s Disconnect bit is set\n", __func__);
> + return;
> + }
> +
> + /* If Reset bit is set */
> + if (test_bit(US_FLIDX_RESETTING, &us->dflags)) {
> + US_DEBUGP("%s Reset bit is set\n", __func__);
> + return;
> + }
> +
> + US_DEBUGP("%s Goto reset\n", __func__);
> + goto reset;
> + }
> +
> + return;
> +reset:
> + scsi_lock(us_to_host(us));
> + set_bit(US_FLIDX_RESETTING, &us->dflags);
> + scsi_unlock(us_to_host(us));
> +
> + mutex_unlock(&us->dev_mutex);
> + result = usb_stor_port_reset(us);
> + mutex_lock(&us->dev_mutex);
> +
> + if (result < 0) {
> + scsi_lock(us_to_host(us));
> + usb_stor_report_device_reset(us);
> + scsi_unlock(us_to_host(us));
> + us->transport_reset(us);
> + }
> + clear_bit(US_FLIDX_RESETTING, &us->dflags);
> +}
> diff --git a/drivers/usb/storage/transport.h b/drivers/usb/storage/transport.h
> index 242ff5e..ebb86ed 100644
> --- a/drivers/usb/storage/transport.h
> +++ b/drivers/usb/storage/transport.h
> @@ -113,13 +113,163 @@ struct bulk_cs_wrap {
>
> #define US_CBI_ADSC 0
>
> +/* IU identifier summary */
> +enum iu_id {
> + IU_ID_COMMAND = 0x01,
> + IU_ID_SENSE = 0x03,
> + IU_ID_RESPONSE = 0x04,
> + IU_ID_TASK_MANAGEMENT = 0x05,
> + IU_ID_READ_READY = 0x06,
> + IU_ID_WRITE_READY = 0x07,
> +};
> +
> +/* Task Attribute field */
> +enum task_attribute_data {
> + TASK_ATTR_SIMPLE = 0,
> + TASK_ATTR_HEAD_OF_QUEUE = 1,
> + TASK_ATTR_ORDERED = 2,
> + TASK_ATTR_ACA = 4,
> +};
> +
> +/* Command or Task Management Function IU state */
> +enum command_state {
> + COMMAND_STATE_IDLE = 0,
> + COMMAND_STATE_COMMAND = 1,
> + COMMAND_STATE_DATA = 2,
> + COMMAND_STATE_STATUS = 3,
> + COMMAND_STATE_ABORTED = 4,
> + COMMAND_STATE_COMPLETED = 5,
> + COMMAND_STATE_HALTED = 6,
> +};
> +
> +#define COMMAND_IU_SIZE 36
> +/* Command IU */
> +struct cmd_iu {
> + __u8 cmd_iu_id;
> + __u8 reserved;
> + __u16 ipt_tag;
> + __u16 length;
> +
> + struct {
> + unsigned int reserved:1;
> + unsigned int task_priority:4;
> + unsigned int task_attribute:3;
> + } b;
> +
> + __u8 lun[8];
> + __u8 cdb[16];
> + __u8 add_cdb[5];
> +
> + struct scsi_cmnd *cmd;
> +
> +#define REQ_NOT_SUBMITTED 0
> +#define REQ_IN_PROGRESS 1
> +#define REQ_COMPLETED 2
> + int iobuf_sts;
> + int sgreq_sts;
> + int state;
> +
> + struct stor_iobuf *iobuf;
> + struct stor_urb *urb;
> + struct stor_sg_req *sg_req;
> + struct us_data *us;
> +
> + struct list_head node;
> +};
> +
> +/* Task Management Function IU types */
> +enum tm_function_data {
> + TM_FUNCTION_ABORT_TASK = 0x01,
> + TM_FUNCTION_ABORT_TASK_SET = 0x02,
> + TM_FUNCTION_CLEAR_TASK_SET = 0x04,
> + TM_FUNCTION_RESET_LUN = 0x08,
> + TM_FUNCTION_IT_NEXUS_RESET = 0x10,
> + TM_FUNCTION_CLEAR_ACA = 0x40,
> + TM_FUNCTION_QUERY_TASK = 0x80,
> + TM_FUNCTION_QUERY_TASK_SET = 0x81,
> + TM_FUNCTION_QUERY_UNIT_ATTENTION = 0x82,
> +};
> +
> +#define TM_FUNCTION_IU_SIZE 16
> +/* Task Management Function IU */
> +struct tm_iu {
> + __u8 tm_iu_id;
> + __u8 reserved1;
> + __u16 ipt_tag;
> + __u8 tm_function;
> + __u8 reserved2;
> + __u16 task_tag;
> + __u8 lun[8];
> +
> + struct stor_iobuf *iobuf;
> + struct stor_urb *urb;
> + int state;
> + int req_sts;
> + struct cmd_iu *cmdiu;
> +
> + struct list_head node;
> +};
> +
> +/* Status values of Sense IU*/
> +enum status_code_data {
> + STATUS_GOOD = 0x00,
> + STATUS_CHECK_CONDITION = 0x02,
> + STATUS_CONDITION_MET = 0x04,
> + STATUS_BUSY = 0x08,
> + STATUS_RESERVATION_CONFLICT = 0x18,
> + STATUS_TASK_SET_FULL = 0x28,
> + STATUS_ACA_ACTIVE = 0x30,
> + STATUS_TASK_ABORTED = 0x40,
> +};
> +
> +#define SENSE_IU_SIZE 13
> +/* Sense IU */
> +struct s_iu {
> + __u8 s_iu_id;
> + __u8 reserved1;
> + __u16 ipt_tag;
> + __u16 length;
> + __u8 status;
> + __u8 reserved2;
> + __u8 sense_data[5];
> +};
> +
> +/* Status values of Response IU */
> +enum response_code_data {
> + RESPONSE_TM_FUNCTION_COMPLETE = 0x00,
> + RESPONSE_INVALID_IU = 0x02,
> + RESPONSE_TM_FUNCTION_NOT_SUPPORTED = 0x04,
> + RESPONSE_TM_FUNCTION_FAILED = 0x05,
> + RESPONSE_TM_FUNCTION_SUCCEEDED = 0x08,
> + RESPONSE_INCORRECT_LUN = 0x09,
> + RESPONSE_OVERLAPPED_TAG_ATTEMPTED = 0x0A,
> +};
> +
> +#define RESPONSE_IU_SIZE 8
> +/* Response IU */
> +struct r_iu {
> + __u8 r_iu_id;
> + __u8 reserved;
> + __u16 ipt_tag;
> + __u8 resp_info[3];
> + __u8 status;
> +};
> +
> extern int usb_stor_CB_transport(struct scsi_cmnd *, struct us_data*);
> extern int usb_stor_CB_reset(struct us_data*);
>
> extern int usb_stor_Bulk_transport(struct scsi_cmnd *, struct us_data*);
> extern int usb_stor_Bulk_max_lun(struct us_data*);
> extern int usb_stor_Bulk_reset(struct us_data*);
> +extern void usb_stor_transfer_UASP_sglist(struct work_struct *work);
> +extern void usb_stor_kill_all_requests(struct us_data *us);
> +extern unsigned int usb_stor_get_tag(struct us_data *us);
> +
> +extern int usb_stor_UASP_transport(struct scsi_cmnd *, struct us_data*);
> +extern int usb_stor_UASP_max_lun(struct us_data *);
> +extern int usb_stor_UASP_reset(struct us_data *);
>
> +extern void usb_stor_invoke_UASP_transport(struct us_data *us);
> extern void usb_stor_invoke_transport(struct scsi_cmnd *, struct us_data*);
> extern void usb_stor_stop_transport(struct us_data*);
>
> diff --git a/drivers/usb/storage/unusual_devs.h b/drivers/usb/storage/unusual_devs.h
> index d4f034e..b9809d5 100644
> --- a/drivers/usb/storage/unusual_devs.h
> +++ b/drivers/usb/storage/unusual_devs.h
> @@ -1875,3 +1875,6 @@ USUAL_DEV(US_SC_QIC, US_PR_BULK, USB_US_TYPE_STOR),
> USUAL_DEV(US_SC_UFI, US_PR_BULK, USB_US_TYPE_STOR),
> USUAL_DEV(US_SC_8070, US_PR_BULK, USB_US_TYPE_STOR),
> USUAL_DEV(US_SC_SCSI, US_PR_BULK, 0),
> +
> +/* UASP transport */
> +USUAL_DEV(US_SC_SCSI, US_PR_UASP, 0),
> diff --git a/drivers/usb/storage/usb.c b/drivers/usb/storage/usb.c
> index 8060b85..2960f68 100644
> --- a/drivers/usb/storage/usb.c
> +++ b/drivers/usb/storage/usb.c
> @@ -256,125 +256,203 @@ void fill_inquiry_response(struct us_data *us, unsigned char *data,
> }
> EXPORT_SYMBOL_GPL(fill_inquiry_response);
>
> +static int usb_stor_something_happen(struct us_data *us)
> +{
> + /* Disconnect bit is set */
> + if (test_bit(US_FLIDX_DISCONNECTING, &us->dflags)) {
> + US_DEBUGP("%s - Disconnect bit is set\n", __func__);
> + return 1;
> + }
> +
> + /* Reset bit is set by SCSI or USB CORE */
> + if (test_bit(US_FLIDX_RESETTING, &us->dflags)) {
> + US_DEBUGP("%s - Reset bit is set\n", __func__);
> + return 1;
> + }
> +
> + /* Some of the submitted requests finished */
> + if (us->pending_requests) {
> + US_DEBUGP("%s - There are pending requests\n", __func__);
> + return 1;
> + }
> +
> + /* New command is received and command pipe is idle*/
> + if (us->new_command && us->command_pipe_sts == COMMAND_PIPE_IDLE) {
> + US_DEBUGP("%s - New command is received from SCSI layer\n",
> + __func__);
> + return 1;
> + }
> +
> + /* Abort task is received from SCSI */
> + if (us->abort_task_tmf->state == COMMAND_STATE_IDLE) {
> + US_DEBUGP("%s - The task is aborted from SCSI layer\n",
> + __func__);
> + return 1;
> + }
> +
> + return 0;
> +}
> +
> static int usb_stor_control_thread(void * __us)
> {
> struct us_data *us = (struct us_data *)__us;
> struct Scsi_Host *host = us_to_host(us);
>
> - for(;;) {
> - US_DEBUGP("*** thread sleeping.\n");
> - if (wait_for_completion_interruptible(&us->cmnd_ready))
> - break;
> -
> - US_DEBUGP("*** thread awakened.\n");
> + if (us->protocol == US_PR_UASP) {
> + for (;;) {
> + US_DEBUGP("%s Thread sleeping\n", __func__);
> + wait_event(us->uasp_wq, usb_stor_something_happen(us));
> + US_DEBUGP("%s Thread wakes up\n", __func__);
>
> - /* lock the device pointers */
> - mutex_lock(&(us->dev_mutex));
> + /* Disconnect bit is set */
> + if (test_bit(US_FLIDX_DISCONNECTING, &us->dflags))
> + break;
>
> - /* lock access to the state */
> - scsi_lock(host);
> + /* Reset bit is set */
> + if (test_bit(US_FLIDX_RESETTING, &us->dflags)) {
> + wait_event(us->uasp_wq,
> + !test_bit(US_FLIDX_RESETTING,
> + &us->dflags));
> + }
>
> - /* When we are called with no command pending, we're done */
> - if (us->srb == NULL) {
> - scsi_unlock(host);
> + mutex_lock(&(us->dev_mutex));
> + us->proto_handler(0, us);
> mutex_unlock(&us->dev_mutex);
> - US_DEBUGP("-- exiting\n");
> - break;
> - }
> + } /* for (;;) */
> +
> + /*
> + * If we get here, that means Disconnect bit is set.
> + * Kill all active requests then clear Disconnect bit.
> + */
> + usb_stor_kill_all_requests(us);
> + clear_bit(US_FLIDX_DISCONNECTING, &us->dflags);
> + wake_up(&us->uasp_wq);
> + } else {
> + for (;;) {
> + US_DEBUGP("*** thread sleeping.\n");
> + if (wait_for_completion_interruptible(&us->cmnd_ready))
> + break;
>
> - /* has the command timed out *already* ? */
> - if (test_bit(US_FLIDX_TIMED_OUT, &us->dflags)) {
> - us->srb->result = DID_ABORT << 16;
> - goto SkipForAbort;
> - }
> + US_DEBUGP("*** thread awakened.\n");
>
> - scsi_unlock(host);
> + /* lock the device pointers */
> + mutex_lock(&(us->dev_mutex));
>
> - /* reject the command if the direction indicator
> - * is UNKNOWN
> - */
> - if (us->srb->sc_data_direction == DMA_BIDIRECTIONAL) {
> - US_DEBUGP("UNKNOWN data direction\n");
> - us->srb->result = DID_ERROR << 16;
> - }
> + /* lock access to the state */
> + scsi_lock(host);
>
> - /* reject if target != 0 or if LUN is higher than
> - * the maximum known LUN
> - */
> - else if (us->srb->device->id &&
> - !(us->fflags & US_FL_SCM_MULT_TARG)) {
> - US_DEBUGP("Bad target number (%d:%d)\n",
> - us->srb->device->id, us->srb->device->lun);
> - us->srb->result = DID_BAD_TARGET << 16;
> - }
> + /*
> + * When we are called with no command pending,
> + * we're done
> + */
> + if (us->srb == NULL) {
> + scsi_unlock(host);
> + mutex_unlock(&us->dev_mutex);
> + US_DEBUGP("-- exiting\n");
> + break;
> + }
>
> - else if (us->srb->device->lun > us->max_lun) {
> - US_DEBUGP("Bad LUN (%d:%d)\n",
> - us->srb->device->id, us->srb->device->lun);
> - us->srb->result = DID_BAD_TARGET << 16;
> - }
> + /* has the command timed out *already* ? */
> + if (test_bit(US_FLIDX_TIMED_OUT, &us->dflags)) {
> + us->srb->result = DID_ABORT << 16;
> + goto SkipForAbort;
> + }
>
> - /* Handle those devices which need us to fake
> - * their inquiry data */
> - else if ((us->srb->cmnd[0] == INQUIRY) &&
> - (us->fflags & US_FL_FIX_INQUIRY)) {
> - unsigned char data_ptr[36] = {
> - 0x00, 0x80, 0x02, 0x02,
> - 0x1F, 0x00, 0x00, 0x00};
> -
> - US_DEBUGP("Faking INQUIRY command\n");
> - fill_inquiry_response(us, data_ptr, 36);
> - us->srb->result = SAM_STAT_GOOD;
> - }
> + scsi_unlock(host);
>
> - /* we've got a command, let's do it! */
> - else {
> - US_DEBUG(usb_stor_show_command(us->srb));
> - us->proto_handler(us->srb, us);
> - }
> + /* reject the command if the direction indicator
> + * is UNKNOWN
> + */
> + if (us->srb->sc_data_direction == DMA_BIDIRECTIONAL) {
> + US_DEBUGP("UNKNOWN data direction\n");
> + us->srb->result = DID_ERROR << 16;
> + }
> +
> + /* reject if target != 0 or if LUN is higher than
> + * the maximum known LUN
> + */
> + else if (us->srb->device->id &&
> + !(us->fflags & US_FL_SCM_MULT_TARG)) {
> + US_DEBUGP("Bad target number (%d:%d)\n",
> + us->srb->device->id,
> + us->srb->device->lun);
> + us->srb->result = DID_BAD_TARGET << 16;
> + }
>
> - /* lock access to the state */
> - scsi_lock(host);
> + else if (us->srb->device->lun > us->max_lun) {
> + US_DEBUGP("Bad LUN (%d:%d)\n",
> + us->srb->device->id,
> + us->srb->device->lun);
> + us->srb->result = DID_BAD_TARGET << 16;
> + }
>
> - /* indicate that the command is done */
> - if (us->srb->result != DID_ABORT << 16) {
> - US_DEBUGP("scsi cmd done, result=0x%x\n",
> - us->srb->result);
> - us->srb->scsi_done(us->srb);
> - } else {
> + /* Handle those devices which need us to fake
> + * their inquiry data */
> + else if ((us->srb->cmnd[0] == INQUIRY) &&
> + (us->fflags & US_FL_FIX_INQUIRY)) {
> + unsigned char data_ptr[36] = {
> + 0x00, 0x80, 0x02, 0x02,
> + 0x1F, 0x00, 0x00, 0x00};
> +
> + US_DEBUGP("Faking INQUIRY command\n");
> + fill_inquiry_response(us, data_ptr, 36);
> + us->srb->result = SAM_STAT_GOOD;
> + }
> +
> + /* we've got a command, let's do it! */
> + else {
> + US_DEBUG(usb_stor_show_command(us->srb));
> + us->proto_handler(us->srb, us);
> + }
> +
> + /* lock access to the state */
> + scsi_lock(host);
> +
> + /* indicate that the command is done */
> + if (us->srb->result != DID_ABORT << 16) {
> + US_DEBUGP("scsi cmd done, result=0x%x\n",
> + us->srb->result);
> + us->srb->scsi_done(us->srb);
> + } else {
> SkipForAbort:
> - US_DEBUGP("scsi command aborted\n");
> - }
> + US_DEBUGP("scsi command aborted\n");
> + }
>
> - /* If an abort request was received we need to signal that
> - * the abort has finished. The proper test for this is
> - * the TIMED_OUT flag, not srb->result == DID_ABORT, because
> - * the timeout might have occurred after the command had
> - * already completed with a different result code. */
> - if (test_bit(US_FLIDX_TIMED_OUT, &us->dflags)) {
> - complete(&(us->notify));
> -
> - /* Allow USB transfers to resume */
> - clear_bit(US_FLIDX_ABORTING, &us->dflags);
> - clear_bit(US_FLIDX_TIMED_OUT, &us->dflags);
> - }
> + /*
> + * If an abort request was received we need to signal
> + * that the abort has finished. The proper test for
> + * this is the TIMED_OUT flag, not srb->result ==
> + * DID_ABORT, because the timeout might have occurred
> + * after the command had already completed with a
> + * different result code.
> + */
> + if (test_bit(US_FLIDX_TIMED_OUT, &us->dflags)) {
> + complete(&(us->notify));
> +
> + /* Allow USB transfers to resume */
> + clear_bit(US_FLIDX_ABORTING, &us->dflags);
> + clear_bit(US_FLIDX_TIMED_OUT, &us->dflags);
> + }
>
> - /* finished working on this command */
> - us->srb = NULL;
> - scsi_unlock(host);
> + /* finished working on this command */
> + us->srb = NULL;
> + scsi_unlock(host);
>
> - /* unlock the device pointers */
> - mutex_unlock(&us->dev_mutex);
> - } /* for (;;) */
> + /* unlock the device pointers */
> + mutex_unlock(&us->dev_mutex);
> + } /* for (;;) */
>
> - /* Wait until we are told to stop */
> - for (;;) {
> - set_current_state(TASK_INTERRUPTIBLE);
> - if (kthread_should_stop())
> - break;
> - schedule();
> + /* Wait until we are told to stop */
> + for (;;) {
> + set_current_state(TASK_INTERRUPTIBLE);
> + if (kthread_should_stop())
> + break;
> + schedule();
> + }
> + __set_current_state(TASK_RUNNING);
> }
> - __set_current_state(TASK_RUNNING);
> +
> + US_DEBUGP("%s - Thread exits\n", __func__);
> return 0;
> }
>
> @@ -385,6 +463,7 @@ SkipForAbort:
> /* Associate our private data with the USB device */
> static int associate_dev(struct us_data *us, struct usb_interface *intf)
> {
> + int i;
> US_DEBUGP("-- %s\n", __func__);
>
> /* Fill in the device-related fields */
> @@ -416,6 +495,20 @@ static int associate_dev(struct us_data *us, struct usb_interface *intf)
> US_DEBUGP("I/O buffer allocation failed\n");
> return -ENOMEM;
> }
> +
> + /* Allocate in/out buffers for UASP needs */
> + for (i = 0; i < MAX_IOBUF_COUNT; i++) {
> + us->iobufs[i].sts = STOR_IOBUF_STATE_FREE;
> + us->iobufs[i].buf = usb_buffer_alloc(us->pusb_dev,
> + US_IOBUF_SIZE,
> + GFP_KERNEL,
> + &us->iobufs[i].dma);
> +
> + if (!us->iobufs[i].buf) {
> + US_DEBUGP("UASP I/O buffer allocation failed\n");
> + return -ENOMEM;
> + }
> + }
> return 0;
> }
>
> @@ -588,6 +681,12 @@ static void get_transport(struct us_data *us)
> us->transport = usb_stor_Bulk_transport;
> us->transport_reset = usb_stor_Bulk_reset;
> break;
> +
> + case US_PR_UASP:
> + us->transport_name = "UASP";
> + us->transport = usb_stor_UASP_transport;
> + us->transport_reset = usb_stor_UASP_reset;
> + break;
> }
> }
>
> @@ -640,12 +739,45 @@ static int get_pipes(struct us_data *us)
> struct usb_endpoint_descriptor *ep_in = NULL;
> struct usb_endpoint_descriptor *ep_out = NULL;
> struct usb_endpoint_descriptor *ep_int = NULL;
> + struct usb_endpoint_descriptor *ep_cmnd = NULL;
> + struct usb_endpoint_descriptor *ep_sts = NULL;
> + struct usb_host_endpoint *eps[3];
> +
> + /* Allocate streams in case of UASP */
> + if (us->protocol == US_PR_UASP) {
> + for (i = 1; i < altsetting->desc.bNumEndpoints; i++)
> + eps[i - 1] = &altsetting->endpoint[i];
> +
> + i = usb_alloc_streams(us->pusb_intf,
> + eps,
> + 3,
> + USB_STOR_NUM_STREAMS,
> + GFP_KERNEL);
> + if (i < 0) {
> + US_DEBUGP("Cannot allocate streams\n");
> + return i;
> + }
> + }
>
> /*
> * Find the first endpoint of each type we need.
> * We are expecting a minimum of 2 endpoints - in and out (bulk).
> * An optional interrupt-in is OK (necessary for CBI protocol).
> + * In case of UASP we will need additional 2 bulk endpoints.
> * We will ignore any others.
> + *
> + * In current version of UASP implementation not included support
> + * of Pipe Usage Descriptors. Therefore by somehow we need to know
> + * which pipe for what should be used. For example from device we
> + * will receive two In Endpoint Descriptors(Bulk In and Status), but
> + * we cannot identify which one is for Bulk In and which one is for
> + * Status. For that purposes in current UASP implementation assumes
> + * that Endpoint Descriptors received from device side should be in
> + * the following order.
> + * 1. Command Endpoint Descriptor.
> + * 2. Bulk In Endpoint Descriptor.
> + * 3. Bulk Out Endpoint Descriptor.
> + * 4. Status Endpoint Descriptor.
> */
> for (i = 0; i < altsetting->desc.bNumEndpoints; i++) {
> ep = &altsetting->endpoint[i].desc;
> @@ -654,8 +786,13 @@ static int get_pipes(struct us_data *us)
> if (usb_endpoint_dir_in(ep)) {
> if (!ep_in)
> ep_in = ep;
> + else if (us->protocol == US_PR_UASP &&
> + !ep_sts)
> + ep_sts = ep;
> } else {
> - if (!ep_out)
> + if (us->protocol == US_PR_UASP && !ep_cmnd)
> + ep_cmnd = ep;
> + else if (!ep_out)
> ep_out = ep;
> }
> }
> @@ -666,7 +803,8 @@ static int get_pipes(struct us_data *us)
> }
> }
>
> - if (!ep_in || !ep_out || (us->protocol == US_PR_CBI && !ep_int)) {
> + if (!ep_in || !ep_out || (us->protocol == US_PR_CBI && !ep_int) ||
> + ((!ep_sts || !ep_cmnd) && us->protocol == US_PR_UASP)) {
> US_DEBUGP("Endpoint sanity check failed! Rejecting dev.\n");
> return -EIO;
> }
> @@ -678,6 +816,17 @@ static int get_pipes(struct us_data *us)
> usb_endpoint_num(ep_out));
> us->recv_bulk_pipe = usb_rcvbulkpipe(us->pusb_dev,
> usb_endpoint_num(ep_in));
> + /* UASP command pipe */
> + if (ep_cmnd) {
> + us->command_pipe = usb_sndbulkpipe(us->pusb_dev,
> + usb_endpoint_num(ep_cmnd));
> + us->command_pipe_sts = COMMAND_PIPE_IDLE;
> + }
> + /* UASP status pipe */
> + if (ep_sts) {
> + us->status_pipe = usb_rcvbulkpipe(us->pusb_dev,
> + usb_endpoint_num(ep_sts));
> + }
> if (ep_int) {
> us->recv_intr_pipe = usb_rcvintpipe(us->pusb_dev,
> usb_endpoint_num(ep_int));
> @@ -698,6 +847,21 @@ static int usb_stor_acquire_resources(struct us_data *us)
> return -ENOMEM;
> }
>
> + /* Allocate urbs for UASP*/
> + for (p = 0; p < MAX_URB_COUNT; p++) {
> + us->urbs[p].sts = STOR_SG_REQ_STATE_FREE;
> +
> + us->urbs[p].req = usb_alloc_urb(0, GFP_KERNEL);
> + if (!us->urbs[p].req) {
> + US_DEBUGP("URB allocation for UASP failed\n");
> + return -ENOMEM;
> + }
> + }
> +
> + /* Initialize works for UASP Scatter-Gather requests */
> + for (p = 0; p < MAX_SG_REQ_COUNT; p++)
> + INIT_WORK(&us->sg_reqs[p].work, usb_stor_transfer_UASP_sglist);
> +
> /* Just before we start our control thread, initialize
> * the device if it needs initialization */
> if (us->unusual_dev->initFunction) {
> @@ -718,9 +882,22 @@ static int usb_stor_acquire_resources(struct us_data *us)
> return 0;
> }
>
> +/* Releases the given Command IU queue */
> +static void release_scsi_cmnd_queue(struct list_head *queue)
> +{
> + struct cmd_iu *cmdiu1;
> + struct cmd_iu *cmdiu2;
> +
> + list_for_each_entry_safe(cmdiu1, cmdiu2, queue, node) {
> + list_del(&cmdiu1->node);
> + kfree(cmdiu1);
> + }
> +}
> +
> /* Release all our dynamic resources */
> static void usb_stor_release_resources(struct us_data *us)
> {
> + int i;
> US_DEBUGP("-- %s\n", __func__);
>
> /* Tell the control thread to exit. The SCSI host must
> @@ -728,9 +905,16 @@ static void usb_stor_release_resources(struct us_data *us)
> * so that we won't accept any more commands.
> */
> US_DEBUGP("-- sending exit command to thread\n");
> - complete(&us->cmnd_ready);
> - if (us->ctl_thread)
> - kthread_stop(us->ctl_thread);
> +
> + if (us->protocol != US_PR_UASP) {
> + complete(&us->cmnd_ready);
> + if (us->ctl_thread)
> + kthread_stop(us->ctl_thread);
> + } else {
> + wake_up(&us->uasp_wq);
> + wait_event(us->uasp_wq,
> + !test_bit(US_FLIDX_DISCONNECTING, &us->dflags));
> + }
>
> /* Call the destructor routine, if it exists */
> if (us->extra_destructor) {
> @@ -741,11 +925,29 @@ static void usb_stor_release_resources(struct us_data *us)
> /* Free the extra data and the URB */
> kfree(us->extra);
> usb_free_urb(us->current_urb);
> +
> + /* Destroy workqueue */
> + if (us->sg_wq)
> + destroy_workqueue(us->sg_wq);
> +
> + /* Free UASP related URB-s */
> + for (i = 0; i < MAX_URB_COUNT; i++)
> + usb_free_urb(us->urbs[i].req);
> +
> + kfree(us->abort_task_tmf);
> +
> + /* Release all Command IU queues */
> + release_scsi_cmnd_queue(&us->scsi_cmnd_queue);
> + release_scsi_cmnd_queue(&us->temp_scsi_cmnd_queue);
> }
>
> /* Dissociate from the USB device */
> static void dissociate_dev(struct us_data *us)
> {
> + int i;
> + struct usb_host_endpoint *eps[3];
> + struct usb_host_interface *altsetting = us->pusb_intf->cur_altsetting;
> +
> US_DEBUGP("-- %s\n", __func__);
>
> /* Free the device-related DMA-mapped buffers */
> @@ -756,6 +958,24 @@ static void dissociate_dev(struct us_data *us)
> usb_buffer_free(us->pusb_dev, US_IOBUF_SIZE, us->iobuf,
> us->iobuf_dma);
>
> + /* Release allocated streams */
> + if (us->protocol == US_PR_UASP) {
> + for (i = 1; i < altsetting->desc.bNumEndpoints; i++)
> + eps[i - 1] = &altsetting->endpoint[i];
> +
> + usb_free_streams(us->pusb_intf, eps, 3, GFP_KERNEL);
> + }
> +
> + /* Release In/Out buffers allocated for UASP */
> + for (i = 0; i < MAX_IOBUF_COUNT; i++) {
> + if (us->iobufs[i].buf) {
> + usb_buffer_free(us->pusb_dev,
> + US_IOBUF_SIZE,
> + us->iobufs[i].buf,
> + us->iobufs[i].dma);
> + }
> + }
> +
> /* Remove our private data from the interface */
> usb_set_intfdata(us->pusb_intf, NULL);
> }
> @@ -831,6 +1051,12 @@ static int usb_stor_scan_thread(void * __us)
> us->max_lun = usb_stor_Bulk_max_lun(us);
> mutex_unlock(&us->dev_mutex);
> }
> + /* In case of UASP */
> + else if (us->protocol == US_PR_UASP) {
> + mutex_lock(&us->dev_mutex);
> + us->max_lun = usb_stor_UASP_max_lun(us);
> + mutex_unlock(&us->dev_mutex);
> + }
> scsi_scan_host(us_to_host(us));
> printk(KERN_DEBUG "usb-storage: device scan complete\n");
>
> @@ -876,6 +1102,25 @@ int usb_stor_probe1(struct us_data **pus,
> init_waitqueue_head(&us->delay_wait);
> init_completion(&us->scanning_done);
>
> + init_waitqueue_head(&us->uasp_wq);
> + INIT_LIST_HEAD(&us->scsi_cmnd_queue);
> + INIT_LIST_HEAD(&us->temp_scsi_cmnd_queue);
> + spin_lock_init(&us->lock);
> +
> + us->abort_task_tmf = kzalloc(sizeof(struct tm_iu), GFP_KERNEL);
> + if (!us->abort_task_tmf) {
> + result = -ENOMEM;
> + goto BadDevice;
> + }
> + us->abort_task_tmf->state = COMMAND_STATE_COMPLETED;
> +
> + US_DEBUGP("Create workqueue\n");
> + us->sg_wq = create_singlethread_workqueue("USB Storage WQ");
> + if (us->sg_wq == NULL) {
> + result = -ENOMEM;
> + goto BadDevice;
> + }
> +
> /* Associate the us_data structure with the USB device */
> result = associate_dev(us, intf);
> if (result)
> diff --git a/drivers/usb/storage/usb.h b/drivers/usb/storage/usb.h
> index 2609efb..b9a7f17 100644
> --- a/drivers/usb/storage/usb.h
> +++ b/drivers/usb/storage/usb.h
> @@ -95,6 +95,47 @@ typedef void (*pm_hook)(struct us_data *, int); /* power management hook */
> #define US_SUSPEND 0
> #define US_RESUME 1
>
> +/* Number of streams we need to allocate */
> +#define USB_STOR_NUM_STREAMS 2
> +
> +/* Max number of Command IU-s could be queued */
> +#define MAX_COMMAND_COUNT 16
> +/* Max number of In/Out buffers */
> +#define MAX_IOBUF_COUNT (MAX_COMMAND_COUNT << 1)
> +/* Max number of URBs */
> +#define MAX_URB_COUNT (MAX_COMMAND_COUNT << 1)
> +/* Max number of Scatter-Gather requests */
> +#define MAX_SG_REQ_COUNT (MAX_COMMAND_COUNT << 1)
> +
> +#define STOR_IOBUF_STATE_FREE 0
> +#define STOR_IOBUF_STATE_BUSY 1
> +/* used as an In/Out buffers for UASP only */
> +struct stor_iobuf {
> + unsigned char *buf;
> + dma_addr_t dma;
> + int sts;
> +};
> +
> +#define STOR_URB_STATE_FREE 0
> +#define STOR_URB_STATE_BUSY 1
> +/* used as an URB for UASP only */
> +struct stor_urb {
> + struct urb *req;
> + int sts;
> +};
> +
> +#define STOR_SG_REQ_STATE_FREE 0
> +#define STOR_SG_REQ_STATE_BUSY 1
> +/* used as a Scatter-Gather request for UASP only */
> +struct stor_sg_req {
> + struct usb_sg_request sg_req;
> + int sts;
> + int result;
> + struct work_struct work;
> + struct cmd_iu *cmdiu;
> + struct us_data *us;
> +};
> +
> /* we allocate one of these for every device that we remember */
> struct us_data {
> /* The device we're working with
> @@ -112,6 +153,12 @@ struct us_data {
> unsigned int send_ctrl_pipe;
> unsigned int recv_ctrl_pipe;
> unsigned int recv_intr_pipe;
> + unsigned int command_pipe;
> + unsigned int status_pipe;
> +
> +#define COMMAND_PIPE_IDLE 0
> +#define COMMAND_PIPE_BUSY 1
> + int command_pipe_sts;
>
> /* information about the device */
> char *transport_name;
> @@ -132,6 +179,9 @@ struct us_data {
> /* SCSI interfaces */
> struct scsi_cmnd *srb; /* current srb */
> unsigned int tag; /* current dCBWTag */
> + struct list_head scsi_cmnd_queue;
> + struct list_head temp_scsi_cmnd_queue;
> + struct tm_iu *abort_task_tmf;
>
> /* control and bulk communications data */
> struct urb *current_urb; /* USB requests */
> @@ -140,6 +190,9 @@ struct us_data {
> unsigned char *iobuf; /* I/O buffer */
> dma_addr_t cr_dma; /* buffer DMA addresses */
> dma_addr_t iobuf_dma;
> + struct stor_iobuf iobufs[MAX_IOBUF_COUNT];
> + struct stor_urb urbs[MAX_URB_COUNT];
> + struct stor_sg_req sg_reqs[MAX_SG_REQ_COUNT];
> struct task_struct *ctl_thread; /* the control thread */
>
> /* mutual exclusion and synchronization structures */
> @@ -147,6 +200,12 @@ struct us_data {
> struct completion notify; /* thread begin/end */
> wait_queue_head_t delay_wait; /* wait during scan, reset */
> struct completion scanning_done; /* wait for scan thread */
> + wait_queue_head_t uasp_wq;
> + struct workqueue_struct *sg_wq;
> + spinlock_t lock;
> + int pending_requests;
> + int active_requests;
> + int new_command;
>
> /* subdriver information */
> void *extra; /* Any extra data */
> diff --git a/include/linux/usb_usual.h b/include/linux/usb_usual.h
> index 3d15fb9..a1a9d86 100644
> --- a/include/linux/usb_usual.h
> +++ b/include/linux/usb_usual.h
> @@ -96,6 +96,7 @@ enum { US_DO_ALL_FLAGS };
> #define US_PR_CBI 0x00 /* Control/Bulk/Interrupt */
> #define US_PR_CB 0x01 /* Control/Bulk w/o interrupt */
> #define US_PR_BULK 0x50 /* bulk only */
> +#define US_PR_UASP 0x62 /* UASP */
>
> #define US_PR_USBAT 0x80 /* SCM-ATAPI bridge */
> #define US_PR_EUSB_SDDR09 0x81 /* SCM-SCSI bridge for SDDR-09 */
> --
> 1.6.0.6
>
--
To unsubscribe from this list: send the line "unsubscribe linux-scsi" in
the body of a message to majordomo@xxxxxxxxxxxxxxx
More majordomo info at http://vger.kernel.org/majordomo-info.html
