Patch retracted for this still-born driver. Instead please use superior uasp.c which was recently submitted.
--- On Fri, 11/5/10, Luben Tuikov <ltuikov@xxxxxxxxx> wrote:
> From: Luben Tuikov <ltuikov@xxxxxxxxx>
> Subject: [PATCH] [USB] UAS: Achitecture; TMF; more
> To: "Greg KH" <greg@xxxxxxxxx>, linux-usb@xxxxxxxxxxxxxxx, linux-kernel@xxxxxxxxxxxxxxx, "Matthew Wilcox" <willy@xxxxxxxxxxxxxxx>
> Date: Friday, November 5, 2010, 9:46 PM
> * Fix sense IU layout
>
> * Command delivery to the service delivery subsystem
> should
> be an atomic transaction. Fix this in
> this driver by
> removing the work thread which retried
> allocating and
> sending urbs. First allocate the urbs
> we'll need up
> front; second recycle them
> (sense<-RRIU in High-Speed
> UAS); third if any operation with the SDS
> fails, report
> this to the application client.
>
> * Rename uas_dev_info->uas_tport_info to more
> correctly
> portray the capabilities of the target
> port. Decouple
> that from the sdev structure as it now
> has a uas_lu_info
> (new) which assists in TMF processing and
> error
> recovery. So now uas_cmd_info lives in
> scsi_cmd;
> uas_lu_info lives in scsi_device and
> uas_tport_info lives
> in scsi_host.
>
> * Redo uas_sense. Make it more general and print a more
> informative message if the sense data
> were short.
>
> * uas_xfer_data for High-Speed doesn't retry but fails if
> the SDS is down. This means that we
> cannot reach the
> target port, so we let error recovery
> kick in.
>
> * Add common urb initializers/fillers for the command and
> status pipe. This generalizes output
> transactions on the
> command pipe to always free the urb and
> the buffer, and
> input transactions on the status pipe to
> always have a
> buffer holding the max size of struct
> sense_iu and
> complete in the same place,
> uas_stat_cmplt, in order to
> accommodate both High-Speed devices and
> SuperSpeed
> (USB3.0) devices.
>
> * Gracefully free the urbs if the SDS is down or we have
> no
> memory for all urbs, at queuecommand
> entry.
>
> * Fix a shortcoming of SCSI Core where some commands
> coming
> into the driver are NOT tagged and some
> are tagged. The
> SDS (UAS) needs everything to be tagged
> and tagged
> correctly. Use tag 1 for untagged
> commands and tags 2 to
> FFEFh for tagged commands. In practice we
> use much less
> and target ports will report much less
> than that.
>
> * If the target port is SuperSpeed request a macro
> defined
> number of streams (128) for this I_T
> nexus. Target ports
> will report less. If usb_alloc_streams
> complains, we know
> we can handle at least one stream. Else
> if the port is
> High-Speed, set the number of tags we use
> to some sane
> value (32). Else the desired number of
> tags is set.
>
> * Implement TMF. All TMFs are supported. As we're not in
> control of the tags, nor can we, at the
> time of this
> commit, request a free tag from the block
> layer, we
> allocate tags for TMFs with range [130,
> 1153]
> (130+1024-1), as an increasing sequence.
>
> Signed-off-by: Luben Tuikov <ltuikov@xxxxxxxxx>
> ---
>
> This patch changes 86% of the driver. More is to come, but
> this is
> a self-contained patch so it can be applied.
>
> drivers/usb/storage/uas.c | 970
> ++++++++++++++++++++++++++++++---------------
> 1 files changed, 656 insertions(+), 314 deletions(-)
>
> diff --git a/drivers/usb/storage/uas.c
> b/drivers/usb/storage/uas.c
> index ef6e707..ed1a82f 100644
> --- a/drivers/usb/storage/uas.c
> +++ b/drivers/usb/storage/uas.c
> @@ -4,6 +4,7 @@
> *
> * Copyright Matthew Wilcox for Intel Corp, 2010
> * Copyright Sarah Sharp for Intel Corp, 2010
> + * Copyright Luben Tuikov, 2010
> *
> * Distributed under the terms of the GNU GPL,
> version two.
> */
> @@ -13,6 +14,7 @@
> #include <linux/types.h>
> #include <linux/usb.h>
> #include <linux/usb/storage.h>
> +#include <linux/completion.h>
>
> #include <scsi/scsi.h>
> #include <scsi/scsi_dbg.h>
> @@ -29,12 +31,18 @@
> #define UAS_DPRINTK(fmt, ...)
> #endif
>
> +/* Define the number of streams to ask to allocate,
> essentially
> + * the maximum number of tags which we are asking to be
> able to send
> + * to the device. Devices may report much less.
> + */
> +#define UAS_MAX_STREAMS 128
> +
> /* Common header for all IUs */
> struct iu {
> __u8 iu_id;
> __u8 rsvd1;
> __be16 tag;
> -};
> +} __packed;
>
> enum {
> IU_ID_COMMAND
> = 0x01,
> @@ -55,7 +63,7 @@ struct command_iu {
> __u8 rsvd7;
> struct scsi_lun lun;
> __u8 cdb[16]; /* XXX:
> Overflow-checking tools may misunderstand */
> -};
> +} __packed;
>
> struct sense_iu {
> __u8 iu_id;
> @@ -63,11 +71,12 @@ struct sense_iu {
> __be16 tag;
> __be16 status_qual;
> __u8 status;
> - __u8 service_response;
> - __u8 rsvd8[6];
> + __u8 rsvd8[7];
> __be16 len;
> __u8 sense[SCSI_SENSE_BUFFERSIZE];
> -};
> +} __packed;
> +
> +#define SENSE_IU_SIZE sizeof(struct
> sense_iu)
>
> /*
> * The r00-r01c specs define this version of the
> SENSE IU data structure.
> @@ -81,6 +90,56 @@ struct sense_iu_old {
> __u8 status;
> __u8 service_response;
> __u8 sense[SCSI_SENSE_BUFFERSIZE];
> +} __packed;
> +
> +struct tmf_iu {
> + __u8 iu_id;
> + __u8 rsvd1;
> + __be16 tag;
> + __u8 tmf;
> + __u8 rsvd5;
> + __u16 ttbm;
> + struct scsi_lun lun;
> +} __packed;
> +
> +enum {
> + TMF_ABORT_TASK = 1,
> + TMF_ABORT_TASK_SET = 2,
> + TMF_CLEAR_TASK_SET = 4,
> + TMF_LU_RESET = 8,
> + TMF_IT_NEXUS_RESET = 0x10,
> + TMF_CLEAR_ACA = 0x40,
> + TMF_QUERY_TASK = 0x80,
> + TMF_QUERY_TASK_SET = 0x81,
> + TMF_QUERY_ASYNC_EVENT = 0x82,
> +};
> +
> +struct resp_iu {
> + __u8 iu_id;
> + __u8 rsvd1;
> + __be16 tag;
> + __be32 resp;
> +} __packed;
> +
> +#define TMR_RESPONSE_CODE_MASK 0xFF
> +#define TMR_RESPONSE_CODE_SHIFT 0
> +#define TMR_RESPONSE_INFO_MASK 0xFFFFFF00
> +#define TMR_RESPONSE_INFO_SHIFT 8
> +
> +#define TMR_RESPONSE_CODE(__Val)
>
> \
> + (((__Val) & TMR_RESPONSE_CODE_MASK)
> >> TMR_RESPONSE_CODE_SHIFT)
> +
> +#define TMR_RESPONSE_INFO(__Val)
>
> \
> + (((__Val) & TMR_RESPONSE_INFO_MASK)
> >> TMR_RESPONSE_INFO_SHIFT)
> +
> +enum tmf_resp_code {
> + TMR_COMPLETE = 0,
> + TMR_IIU
> = 2,
> + TMR_UNSUPP = 4,
> + TMR_FAILED = 5,
> + TMR_SUCC = 8,
> + TMR_ILUN = 9,
> + TMR_OLAP = 0xA,
> };
>
> enum {
> @@ -95,89 +154,73 @@ enum {
> UAS_ACA
> = 4,
> };
>
> -struct uas_dev_info {
> +/* Lives in the SCSI host, hostdata points to it.
> + */
> +struct uas_tport_info {
> struct usb_interface *intf;
> struct usb_device *udev;
> - int qdepth;
> + int num_tags;
> unsigned cmd_pipe, status_pipe,
> data_in_pipe, data_out_pipe;
> unsigned use_streams:1;
> unsigned uas_sense_old:1;
> };
>
> -enum {
> - ALLOC_STATUS_URB = (1
> << 0),
> - SUBMIT_STATUS_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),
> +/* Lives in the scsi device, hostdata points to it.
> + */
> +struct uas_lu_info {
> + struct completion tmf_completion;
> + struct resp_iu resp;
> + struct urb *freed_urb;
> };
>
> -/* Overrides scsi_pointer */
> +/* Lives in the scsi command, overrides SCp.
> + */
> struct uas_cmd_info {
> - unsigned int state;
> - unsigned int stream;
> + int tag;
> struct urb *cmd_urb;
> struct urb *status_urb;
> struct urb *data_in_urb;
> struct urb *data_out_urb;
> - struct list_head list;
> };
>
> -static int uas_submit_urbs(struct scsi_cmnd *cmnd,
> -
> struct uas_dev_info *devinfo, gfp_t
> gfp);
> +#define UAS_CMD_INFO(__Scmd) ((struct uas_cmd_info
> *)(&(__Scmd)->SCp))
> +#define UAS_TPORT_INFO(__Scmd) \
> + ((struct uas_tport_info
> *)((__Scmd)->device->host->hostdata[0]))
> +#define SDEV_TPORT_INFO(__Sdev) \
> + ((struct uas_tport_info
> *)((__Sdev)->host->hostdata[0]))
>
> -static DEFINE_SPINLOCK(uas_work_lock);
> -static LIST_HEAD(uas_work_list);
> +#define SDEV_LU_INFO(__Sdev) ((struct uas_lu_info
> *)((__Sdev)->hostdata))
>
> -static void uas_do_work(struct work_struct *work)
> -{
> - struct uas_cmd_info *cmdinfo;
> - struct list_head list;
> - int res;
> -
> - 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);
> - res =
> uas_submit_urbs(cmnd, cmnd->device->hostdata,
> GFP_KERNEL);
> - UAS_DPRINTK("%s:
> cmd:%p, res:%d, state:0x%x\n", __FUNCTION__,
> -
> cmnd, res, cmdinfo->state);
> - }
> -}
> -
> -static DECLARE_WORK(uas_work, uas_do_work);
> +/* ---------- IU processors ---------- */
>
> -static void uas_sense(struct urb *urb, struct scsi_cmnd
> *cmnd)
> +static void uas_sense(struct urb *urb, struct scsi_cmnd
> *cmd)
> {
> struct sense_iu *sense_iu =
> urb->transfer_buffer;
> - struct scsi_device *sdev =
> cmnd->device;
> + struct scsi_device *sdev =
> cmd->device;
> +
> + cmd->result = sense_iu->status;
>
> 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;
> + unsigned slen =
> be16_to_cpup(&sense_iu->len);
> +
> + if
> (urb->actual_length >= 16 + slen) {
> +
> slen = min(slen, (unsigned) SCSI_SENSE_BUFFERSIZE);
> + } else {
> +
> unsigned dlen = slen;
> +
> +
> slen = min(urb->actual_length - 16,
> +
> (unsigned)
> SCSI_SENSE_BUFFERSIZE);
> +
> +
> sdev_printk(KERN_INFO, sdev,
> +
> "%s: short SENSE IU by %d
> bytes, "
> +
> "using %d/%d bytes of sense
> data\n",
> +
> __func__, 16 + slen -
> urb->actual_length,
> +
> slen, dlen);
> }
> -
> memcpy(cmnd->sense_buffer, sense_iu->sense, len);
> +
> memcpy(cmd->sense_buffer, sense_iu->sense, slen);
> }
> -
> - cmnd->result = sense_iu->status;
> - if (sdev->current_cmnd)
> -
> sdev->current_cmnd = NULL;
> - cmnd->scsi_done(cmnd);
> + sdev->current_cmnd = NULL;
> + cmd->scsi_done(cmd);
> usb_free_urb(urb);
> }
>
> @@ -200,73 +243,105 @@ static void uas_sense_old(struct urb
> *urb, struct scsi_cmnd *cmnd)
> }
>
> memcpy(cmnd->sense_buffer, sense_iu->sense, len);
> }
> -
> cmnd->result = sense_iu->status;
> - if (sdev->current_cmnd)
> -
> sdev->current_cmnd = NULL;
> + 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)
> +/* Let High-Speed devices fail here instead of
> accommodating EAGAIN
> + * and racing with the error handler, if EAGAIN takes
> longer than the
> + * command completion timeout. SuperSpeed devices
> never get here.
> + */
> +static void uas_xfer_data(struct urb *urb, struct
> scsi_cmnd *cmd,
> +
> struct uas_tport_info *tpinfo,
> +
> enum dma_data_direction dir, int tag)
> {
> - struct uas_cmd_info *cmdinfo = (void
> *)&cmnd->SCp;
> - int err;
> + struct uas_cmd_info *cmdinfo =
> UAS_CMD_INFO(cmd);
> + int res = 0;
> +
> + res = usb_submit_urb(urb, GFP_ATOMIC);
>
> - cmdinfo->state = direction |
> SUBMIT_STATUS_URB;
> - err = uas_submit_urbs(cmnd,
> cmnd->device->hostdata, GFP_ATOMIC);
> - UAS_DPRINTK("%s: cmd:%p, err:%d,
> state:0x%x\n", __FUNCTION__,
> - cmnd,
> err, cmdinfo->state);
> - if (err) {
> -
> spin_lock(&uas_work_lock);
> -
> list_add_tail(&cmdinfo->list, &uas_work_list);
> -
> spin_unlock(&uas_work_lock);
> -
> schedule_work(&uas_work);
> + if (res == 0) {
> + if (dir ==
> DMA_FROM_DEVICE)
> +
> res = usb_submit_urb(cmdinfo->data_in_urb, GFP_ATOMIC);
> + else
> +
> res = usb_submit_urb(cmdinfo->data_out_urb,GFP_ATOMIC);
> }
> +
> + UAS_DPRINTK("%s: cmd:%p res:%d
> tag:%d\n", __func__, cmd, res,
> +
> cmdinfo->tag);
> }
>
> +/**
> + * uas_stat_cmplt -- Status pipe urb completion
> + * @urb: the URB that completed
> + *
> + * Anything we expect to come back on the status pipe
> + * comes here.
> + */
> 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 uas_tport_info *tpinfo =
> SDEV_TPORT_INFO(sdev);
> struct scsi_cmnd *cmnd;
> - u16 tag;
> + int tag;
> +
> + UAS_DPRINTK("%s: IU ID:%d tag:%d\n",
> __func__, iu->iu_id,
> +
> be16_to_cpup(&iu->tag));
>
> if (urb->status) {
>
> dev_err(&urb->dev->dev, "%s: URB BAD STATUS
> %d\n",
> -
> __FUNCTION__, urb->status);
> +
> __func__, urb->status);
> + usb_free_urb(urb);
> + return;
> + }
> +
> + if (iu->iu_id == IU_ID_RESPONSE) {
> + struct uas_lu_info
> *luinfo = SDEV_LU_INFO(sdev);
> +
> +
> memcpy(&luinfo->resp, urb->transfer_buffer,
> +
> sizeof(struct resp_iu));
> +
> complete(&luinfo->tmf_completion);
> + luinfo->freed_urb
> = urb;
> usb_free_urb(urb);
> return;
> }
>
> - tag = be16_to_cpup(&iu->tag) -
> 1;
> + tag = be16_to_cpup(&iu->tag);
> if (sdev->current_cmnd)
> cmnd =
> sdev->current_cmnd;
> else
> - cmnd =
> scsi_find_tag(sdev, tag);
> - if (!cmnd)
> + cmnd =
> scsi_find_tag(sdev, tag-2);
> +
> + if (!cmnd) {
> + UAS_DPRINTK("%s: No
> command!?\n", __func__);
> + usb_free_urb(urb);
> return;
> + }
>
> switch (iu->iu_id) {
> case IU_ID_STATUS:
> - if
> (urb->actual_length < 16)
> -
> devinfo->uas_sense_old = 1;
> - if
> (devinfo->uas_sense_old)
> + if
> (unlikely(urb->actual_length < 16))
> +
> tpinfo->uas_sense_old = 1;
> + if
> (unlikely(tpinfo->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);
> + uas_xfer_data(urb,
> cmnd, tpinfo, DMA_FROM_DEVICE, tag);
> break;
> case IU_ID_WRITE_READY:
> - uas_xfer_data(urb,
> cmnd, SUBMIT_DATA_OUT_URB);
> + uas_xfer_data(urb,
> cmnd, tpinfo, DMA_TO_DEVICE, tag);
> break;
> default:
>
> scmd_printk(KERN_ERR, cmnd,
> -
> "Bogus IU (%d) received on status pipe\n", iu->iu_id);
> +
> "Unknown IU ID %d received on the status
> pipe\n",
> +
> iu->iu_id);
> + usb_free_urb(urb);
> + break;
> }
> }
>
> @@ -274,333 +349,594 @@ static void uas_data_cmplt(struct
> urb *urb)
> {
> struct scsi_data_buffer *sdb =
> urb->context;
>
> - if (urb->status) {
> + if (!urb->status)
> + sdb->resid =
> sdb->length - urb->actual_length;
> + else
>
> dev_err(&urb->dev->dev, "%s: URB BAD STATUS
> %d\n",
> -
> __FUNCTION__, urb->status);
> - usb_free_urb(urb);
> - return;
> - }
> -
> - sdb->resid = sdb->length -
> urb->actual_length;
> +
> __func__, urb->status);
> +
> 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)
> +/* ---------- URB allocators and submission ---------- */
> +
> +/**
> + * uas_fill_cmdp_urb -- Fill in a command pipe urb
> + * @urb: the urb
> + * @tpinfo: the UAS device info struct
> + * @transfer_buffer: the IU
> + * @buffer_length: the size of the IU
> + *
> + * A unified place to initialize a command pipe urb so
> that
> + * all command pipe urbs are freed in the same manner.
> + */
> +static void uas_fill_cmdp_urb(struct urb *urb, struct
> uas_tport_info *tpinfo,
> +
> void *transfer_buffer, int
> buffer_length)
> +{
> + usb_fill_bulk_urb(urb, tpinfo->udev,
> tpinfo->cmd_pipe,
> +
> transfer_buffer, buffer_length,
> +
> usb_free_urb, NULL);
> + urb->transfer_flags |=
> URB_FREE_BUFFER;
> +}
> +
> +/**
> + * uas_fill_statp_urb -- Fill in a status pipe urb
> + * @urb: the urb
> + * @dev: the scsi device
> + * @transfer_buffer: the transfer buffer of size
> SENSE_IU_SIZE
> + * @tag: the tag
> + *
> + * The callback is responsible to free/recycle the urb and
> the
> + * transfer buffer.
> + */
> +static void uas_fill_statp_urb(struct urb *urb, struct
> scsi_device *sdev,
> +
> void *transfer_buffer, int
> tag)
> +{
> + struct uas_tport_info *tpinfo =
> SDEV_TPORT_INFO(sdev);
> +
> + usb_fill_bulk_urb(urb, tpinfo->udev,
> tpinfo->status_pipe,
> +
> transfer_buffer, SENSE_IU_SIZE,
> +
> uas_stat_cmplt, sdev);
> + urb->transfer_flags |=
> URB_FREE_BUFFER;
> + if (tpinfo->use_streams)
> + urb->stream_id =
> tag;
> +}
> +
> +static struct urb *uas_alloc_data_urb(struct
> uas_tport_info *tpinfo, gfp_t gfp,
> +
> unsigned int
> data_pipe, u16 tag,
> +
> struct
> scsi_data_buffer *sdb)
> {
> - struct usb_device *udev =
> devinfo->udev;
> + struct usb_device *udev =
> tpinfo->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;
> + goto Out;
> +
> + usb_fill_bulk_urb(urb, udev, data_pipe,
> NULL, sdb->length,
> +
> uas_data_cmplt, sdb);
> + if (tpinfo->use_streams)
> + urb->stream_id =
> tag;
> urb->num_sgs =
> udev->bus->sg_tablesize ? sdb->table.nents : 0;
> urb->sg = sdb->table.sgl;
> - out:
> + 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)
> +static struct urb *uas_alloc_status_urb(struct scsi_cmnd
> *cmd, gfp_t gfp)
> +
>
> {
> - struct usb_device *udev =
> devinfo->udev;
> - struct urb *urb = usb_alloc_urb(0,
> gfp);
> - struct sense_iu *iu;
> + struct sense_iu *siu;
> + struct urb *urb;
>
> + urb = usb_alloc_urb(0, gfp);
> if (!urb)
> - goto out;
> + return NULL;
>
> - iu = kzalloc(sizeof(*iu), gfp);
> - if (!iu)
> - goto free;
> + siu = kzalloc(SENSE_IU_SIZE, gfp);
> + if (!siu)
> + goto Out_free;
> +
> + uas_fill_statp_urb(urb, cmd->device,
> siu, UAS_CMD_INFO(cmd)->tag);
>
> - 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:
> + Out_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)
> +static struct urb *uas_alloc_cmd_urb(struct scsi_cmnd
> *cmd, gfp_t gfp)
> {
> - struct usb_device *udev =
> devinfo->udev;
> - struct scsi_device *sdev =
> cmnd->device;
> + struct uas_cmd_info *cmdinfo =
> UAS_CMD_INFO(cmd);
> + struct uas_tport_info *tpinfo =
> UAS_TPORT_INFO(cmd);
> + struct usb_device *udev =
> tpinfo->udev;
> + struct scsi_device *sdev =
> cmd->device;
> struct urb *urb = usb_alloc_urb(0,
> gfp);
> - struct command_iu *iu;
> + struct command_iu *ciu;
> int len;
>
> if (!urb)
> - goto out;
> + return NULL;
>
> - len = cmnd->cmd_len - 16;
> + len = cmd->cmd_len - 16;
> if (len < 0)
> len = 0;
> - len = ALIGN(len, 4);
> - iu = kzalloc(sizeof(*iu) + len, gfp);
> - if (!iu)
> + else
> + len = ALIGN(len,
> 4);
> +
> + ciu = kzalloc(sizeof(*ciu) + len,
> gfp);
> + if (!ciu)
> goto free;
>
> - iu->iu_id = IU_ID_COMMAND;
> - iu->tag = cpu_to_be16(stream_id);
> - if (sdev->ordered_tags &&
> (cmnd->request->cmd_flags & REQ_HARDBARRIER))
> - iu->prio_attr =
> UAS_ORDERED_TAG;
> + ciu->iu_id = IU_ID_COMMAND;
> + ciu->tag =
> cpu_to_be16(cmdinfo->tag);
> + if (sdev->ordered_tags &&
> (cmd->request->cmd_flags & REQ_HARDBARRIER))
> + ciu->prio_attr =
> UAS_ORDERED_TAG;
> else
> - iu->prio_attr =
> UAS_SIMPLE_TAG;
> - iu->len = len;
> - int_to_scsilun(sdev->lun,
> &iu->lun);
> - memcpy(iu->cdb, cmnd->cmnd,
> cmnd->cmd_len);
> + ciu->prio_attr =
> UAS_SIMPLE_TAG;
> + ciu->len = len;
> + int_to_scsilun(sdev->lun,
> &ciu->lun);
> + memcpy(ciu->cdb, cmd->cmnd,
> cmd->cmd_len);
>
> - usb_fill_bulk_urb(urb, udev,
> devinfo->cmd_pipe, iu, sizeof(*iu) + len,
> + usb_fill_bulk_urb(urb, udev,
> tpinfo->cmd_pipe, ciu, sizeof(*ciu) + 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)
> +static int uas_alloc_urbs(struct scsi_cmnd *cmd, gfp_t
> gfp)
> {
> - struct uas_cmd_info *cmdinfo = (void
> *)&cmnd->SCp;
> - int res;
> + struct uas_cmd_info *cmdinfo =
> UAS_CMD_INFO(cmd);
> + struct uas_tport_info *tpinfo =
> UAS_TPORT_INFO(cmd);
>
> - if (cmdinfo->state &
> ALLOC_STATUS_URB) {
> -
> cmdinfo->status_urb = uas_alloc_sense_urb(devinfo, gfp,
> cmnd,
> -
>
> cmdinfo->stream);
> - if
> (!cmdinfo->status_urb)
> -
> return -ENOMEM;
> - cmdinfo->state
> &= ~ALLOC_STATUS_URB;
> - }
> + cmdinfo->status_urb = NULL;
> + cmdinfo->data_in_urb = NULL;
> + cmdinfo->data_out_urb = NULL;
> + cmdinfo->cmd_urb = NULL;
>
> - if (cmdinfo->state &
> SUBMIT_STATUS_URB) {
> - res =
> usb_submit_urb(cmdinfo->status_urb, gfp);
> - if (res) {
> -
> scmd_printk(KERN_INFO, cmnd,
> -
> "sense urb submission
> failure (%d)\n",
> -
> res);
> -
> return res;
> + cmdinfo->status_urb =
> uas_alloc_status_urb(cmd, gfp);
> + cmdinfo->cmd_urb =
> uas_alloc_cmd_urb(cmd, gfp);
> + if (!cmdinfo->cmd_urb ||
> !cmdinfo->status_urb)
> + goto Out_err1;
> +
> + switch (cmd->sc_data_direction) {
> + case DMA_BIDIRECTIONAL:
> + case DMA_TO_DEVICE:
> +
> cmdinfo->data_out_urb =
> +
> uas_alloc_data_urb(tpinfo, gfp,
> +
>
> tpinfo->data_out_pipe,
> +
>
> cmdinfo->tag,
> +
>
> scsi_out(cmd));
> + if
> (!cmdinfo->data_out_urb)
> +
> goto Out_err2;
> + if
> (cmd->sc_data_direction != DMA_BIDIRECTIONAL)
> +
> break;
> + else {
> + case DMA_FROM_DEVICE:
> +
> cmdinfo->data_in_urb =
> +
> uas_alloc_data_urb(tpinfo, gfp,
> +
>
> tpinfo->data_in_pipe,
> +
>
> cmdinfo->tag,
> +
>
> scsi_in(cmd));
> + if
> (!cmdinfo->data_in_urb)
> +
> goto Out_err2;
> }
> - cmdinfo->state
> &= ~SUBMIT_STATUS_URB;
> + break;
> + case DMA_NONE:
> + break;
> }
>
> - 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 -ENOMEM;
> - cmdinfo->state
> &= ~ALLOC_DATA_IN_URB;
> + return 0;
> +
> + Out_err2:
> + usb_free_urb(cmdinfo->data_in_urb);
> +
> usb_free_urb(cmdinfo->data_out_urb);
> + Out_err1:
> + usb_free_urb(cmdinfo->cmd_urb);
> + return -ENOMEM;
> +}
> +
> +static int uas_submit_urbs(struct scsi_cmnd *cmd, gfp_t
> gfp)
> +{
> + struct uas_cmd_info *cmdinfo =
> UAS_CMD_INFO(cmd);
> + struct uas_tport_info *tpinfo =
> UAS_TPORT_INFO(cmd);
> + int res;
> +
> + UAS_DPRINTK("%s: cmd:%p (0x%02x)
> tag:%d\n", __func__,
> + cmd,
> cmd->cmnd[0], cmdinfo->tag);
> +
> + res =
> usb_submit_urb(cmdinfo->status_urb, gfp);
> + if (res) {
> +
> scmd_printk(KERN_INFO, cmd,
> +
> "sense urb submission failure (%d)\n", res);
> + return res;
> }
>
> - if (cmdinfo->state &
> SUBMIT_DATA_IN_URB) {
> + if (cmdinfo->data_in_urb &&
> tpinfo->use_streams) {
> res =
> usb_submit_urb(cmdinfo->data_in_urb, gfp);
> if (res) {
> -
> scmd_printk(KERN_INFO, cmnd,
> +
> scmd_printk(KERN_INFO, cmd,
>
> "data in urb submission
> failure (%d)\n",
>
> res);
>
> return res;
> }
> - 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 -ENOMEM;
> - cmdinfo->state
> &= ~ALLOC_DATA_OUT_URB;
> - }
> -
> - if (cmdinfo->state &
> SUBMIT_DATA_OUT_URB) {
> + if (cmdinfo->data_out_urb &&
> tpinfo->use_streams) {
> res =
> usb_submit_urb(cmdinfo->data_out_urb, gfp);
> if (res) {
> -
> scmd_printk(KERN_INFO, cmnd,
> +
> scmd_printk(KERN_INFO, cmd,
>
> "data out urb submission
> failure (%d)\n",
>
> res);
>
> return res;
> }
> - 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 -ENOMEM;
> - cmdinfo->state
> &= ~ALLOC_CMD_URB;
> }
>
> - if (cmdinfo->state &
> SUBMIT_CMD_URB) {
> - res =
> usb_submit_urb(cmdinfo->cmd_urb, gfp);
> - if (res) {
> -
> scmd_printk(KERN_INFO, cmnd,
> -
> "cmd urb submission failure
> (%d)\n", res);
> -
> return res;
> - }
> - cmdinfo->state
> &= ~SUBMIT_CMD_URB;
> + res =
> usb_submit_urb(cmdinfo->cmd_urb, gfp);
> + if (res) {
> +
> scmd_printk(KERN_INFO, cmd,
> +
> "cmd urb submission failure (%d)\n", res);
> + return res;
> }
>
> return 0;
> }
>
> -static int uas_queuecommand(struct scsi_cmnd *cmnd,
> +static void uas_free_urbs(struct scsi_cmnd *cmd)
> +{
> + struct uas_cmd_info *cmdinfo =
> UAS_CMD_INFO(cmd);
> + int res;
> +
> + if (cmdinfo->cmd_urb) {
> + res =
> usb_unlink_urb(cmdinfo->cmd_urb);
> + if (res !=
> -EINPROGRESS)
> +
> usb_free_urb(cmdinfo->cmd_urb);
> + }
> + if (cmdinfo->status_urb) {
> + res =
> usb_unlink_urb(cmdinfo->status_urb);
> + if (res !=
> -EINPROGRESS)
> +
> usb_free_urb(cmdinfo->status_urb);
> + }
> + if (cmdinfo->data_in_urb) {
> + res =
> usb_unlink_urb(cmdinfo->data_in_urb);
> + if (res !=
> -EINPROGRESS)
> +
> usb_free_urb(cmdinfo->data_in_urb);
> + }
> + if (cmdinfo->data_out_urb) {
> + res =
> usb_unlink_urb(cmdinfo->data_out_urb);
> + if (res !=
> -EINPROGRESS)
> +
> usb_free_urb(cmdinfo->data_out_urb);
> + }
> +}
> +
> +static int uas_queuecommand(struct scsi_cmnd *cmd,
>
> 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;
> + struct scsi_device *sdev =
> cmd->device;
> + struct uas_cmd_info *cmdinfo =
> UAS_CMD_INFO(cmd);
> int res;
>
> BUILD_BUG_ON(sizeof(struct
> uas_cmd_info) > sizeof(struct scsi_pointer));
>
> - if (!cmdinfo->status_urb &&
> sdev->current_cmnd)
> - return
> SCSI_MLQUEUE_DEVICE_BUSY;
> -
> - if (blk_rq_tagged(cmnd->request)) {
> - cmdinfo->stream =
> cmnd->request->tag + 1;
> + /* If LLDD are NOT to maintain their
> own tags, (but the block
> + * layer would), THEN ANY AND
> ALL scsi_cmnds passed to the
> + * queuecommand entry of a
> LLDD MUST HAVE A VALID,
> + * REVERSE-MAPPABLE tag,
> REGARDLESS of where the command came
> + * from, regardless of
> whether the device supports tags, and
> + * regardless of how many
> tags it supports.
> + */
> + if (blk_rq_tagged(cmd->request)) {
> + cmdinfo->tag =
> cmd->request->tag + 2;
> + } else if (sdev->current_cmnd ==
> NULL) {
> +
> sdev->current_cmnd = cmd; /* Hilarious, isn't it?! */
> + cmdinfo->tag =
> 1;
> } else {
> -
> sdev->current_cmnd = cmnd;
> - cmdinfo->stream =
> 1;
> + cmd->result =
> DID_ABORT << 16;
> + goto Out_err;
> }
>
> - cmnd->scsi_done = done;
> -
> - cmdinfo->state = ALLOC_STATUS_URB |
> SUBMIT_STATUS_URB |
> -
> ALLOC_CMD_URB | SUBMIT_CMD_URB;
> + cmd->scsi_done = done;
>
> - 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;
> + res = uas_alloc_urbs(cmd, GFP_ATOMIC);
> + if (res) {
> + cmd->result =
> DID_ABORT << 16;
> + goto Out_err;
> }
>
> - if (!devinfo->use_streams) {
> - cmdinfo->state
> &= ~(SUBMIT_DATA_IN_URB | SUBMIT_DATA_OUT_URB);
> - cmdinfo->stream =
> 0;
> + res = uas_submit_urbs(cmd,
> GFP_ATOMIC);
> + if (res) {
> + cmd->result =
> DID_NO_CONNECT << 16;
> + uas_free_urbs(cmd);
> + goto Out_err;
> }
> +
> + UAS_DPRINTK("%s: cmd:%p (0x%02x) res:%d
> tag:%d\n",
> +
> __func__, cmd, cmd->cmnd[0], res, cmdinfo->tag);
>
> - res = uas_submit_urbs(cmnd, devinfo,
> GFP_ATOMIC);
> - UAS_DPRINTK("%s: cmd:%p (0x%02x),
> err:%d, state:0x%x\n", __FUNCTION__,
> - cmnd,
> cmnd->cmnd[0], res, cmdinfo->state);
> - if (res) {
> -
> usb_unlink_urb(cmdinfo->status_urb);
> -
> usb_unlink_urb(cmdinfo->data_in_urb);
> -
> usb_unlink_urb(cmdinfo->data_out_urb);
> -
> usb_unlink_urb(cmdinfo->cmd_urb);
> + return 0;
> + Out_err:
> + sdev->current_cmnd = NULL;
> + done(cmd);
> +
> + return 0;
> +}
>
> -
> sdev->current_cmnd = NULL;
> +/* ---------- Error Recovery ---------- */
>
> - cmnd->result =
> DID_NO_CONNECT << 16;
> - done(cmnd);
> - }
> +/* [1, UAS_MAX_STREAMS+1] belong to commands.
> + * [UAS_MAX_STREAMS+2, UAS_MAX_STREAMS+2+TMF_MAX_TAGS)
> belong to TMFs.
> + */
> +#define TMF_TAG_FIRST (UAS_MAX_STREAMS
> + 2)
> +#define TMF_MAX_TAGS 1024
> +
> +static int uas_get_tmf_tag(void)
> +{
> + static int tmf_tag = 0;
> + int res;
> +
> + /* [TMF_TAG_FIRST, TMF_MAX_TAGS +
> TMF_MAX_TAGS) */
> + res = tmf_tag + TMF_TAG_FIRST;
> +
> + tmf_tag += 1;
> + tmf_tag %= TMF_MAX_TAGS; /*
> [0,TMF_MAX_TAGS) */
> +
> + return res;
> +}
> +
> +static int uas_alloc_tmf_urb(struct urb **urb, struct
> uas_tport_info *tpinfo,
> +
> u8 tmf, u16 ttbm, struct scsi_lun
> *lun)
> +{
> + struct tmf_iu *tmf_iu;
> +
> + *urb = usb_alloc_urb(0, GFP_KERNEL);
> + if (!*urb)
> + return -ENOMEM;
> + tmf_iu = kzalloc(sizeof(*tmf_iu),
> GFP_KERNEL);
> + if (!tmf_iu)
> + goto Out_err;
> +
> + /* If LLDD are NOT to maintain their
> own tags, (but the block
> + * layer would), THEN LLDDs
> must be able to call a function of
> + * some sort and reserve a
> tag from the same pool and obtain
> + * it for their own use, as
> well as being able to free it back
> + * later.
> + */
> + tmf_iu->iu_id = IU_ID_TASK_MGMT;
> + tmf_iu->tag =
> cpu_to_be16(uas_get_tmf_tag());
> + tmf_iu->tmf = tmf;
> + tmf_iu->ttbm = cpu_to_be16(ttbm);
> + tmf_iu->lun = *lun;
> +
> + uas_fill_cmdp_urb(*urb, tpinfo, tmf_iu,
> sizeof(*tmf_iu));
>
> return 0;
> + Out_err:
> + usb_free_urb(*urb);
> + return -ENOMEM;
> }
>
> -static int uas_eh_abort_handler(struct scsi_cmnd *cmnd)
> +static int uas_alloc_resp_urb(struct urb **urb, struct
> scsi_device *sdev,
> +
> struct resp_iu *resp, int tag)
> {
> - struct scsi_device *sdev =
> cmnd->device;
> - sdev_printk(KERN_INFO, sdev, "%s tag
> %d\n", __func__,
> -
>
> cmnd->request->tag);
> + *urb = usb_alloc_urb(0, GFP_KERNEL);
> + if (!*urb)
> + return -ENOMEM;
>
> -/* XXX: Send ABORT TASK Task Management command */
> - return FAILED;
> + uas_fill_statp_urb(*urb, sdev, resp,
> tag);
> +
> + return 0;
> }
>
> -static int uas_eh_device_reset_handler(struct scsi_cmnd
> *cmnd)
> +#define UAS_TMF_TIMEOUT (5*HZ)
> +
> +/**
> + * uas_do_tmf -- Execute the desired TMF
> + * @sdev: the device to which we should send the TMF
> + * @tmf: the task management function to execute
> + * @ttbm: the tag of task to be managed
> + *
> + * This function returns a negative value on error
> (-ENOMEM, etc), or
> + * an integer with bytes 3, 2 and 1 being the high to low
> byte of the
> + * Additional Response Information field and byte 0 being
> the Response
> + * code of the Response IU.
> + *
> + * If the response code is 0xFF, then the TMF timed out.
> + */
> +static int uas_do_tmf(struct scsi_cmnd *cmd, u8 tmf, u8
> ttbm)
> {
> - struct scsi_device *sdev =
> cmnd->device;
> - sdev_printk(KERN_INFO, sdev, "%s tag
> %d\n", __func__,
> -
>
> cmnd->request->tag);
> + struct scsi_device *sdev =
> cmd->device;
> + struct uas_tport_info *tpinfo =
> SDEV_TPORT_INFO(sdev);
> + struct
> uas_lu_info *luinfo= SDEV_LU_INFO(sdev);
> + struct uas_cmd_info *cmdinfo =
> UAS_CMD_INFO(cmd);
> + struct urb *tmf_urb = NULL;
> + struct urb *resp_urb = NULL;
> + struct scsi_lun lun;
> + long timeout;
> + int res;
>
> -/* XXX: Send LOGICAL UNIT RESET Task Management command
> */
> - return FAILED;
> + /* scsi_dev should contain u8[8] for a
> LUN, not an unsigned int!
> + */
> + int_to_scsilun(sdev->lun,
> &lun);
> + res = uas_alloc_tmf_urb(&tmf_urb,
> tpinfo, tmf, ttbm, &lun);
> + if (res)
> + return -ENOMEM;
> +
> + /* If we're not using streams, we'll
> get the Response IU via
> + * the sense urb we previosly
> submitted, so there is no need
> + * to allocate a response
> urb.
> + * If we're using streams, we
> need a response urb.
> + * Or we need a response urb
> if we've previosly executed a TMF
> + * which used up the sense
> urb as a response urb.
> + */
> + if (tpinfo->use_streams ||
> luinfo->freed_urb == cmdinfo->status_urb) {
> + struct tmf_iu
> *tmf_iu;
> + struct resp_iu *resp
> = NULL;
> +
> + resp =
> kzalloc(SENSE_IU_SIZE, GFP_KERNEL);
> + if (!resp) {
> +
> usb_free_urb(tmf_urb);
> +
> return -ENOMEM;
> + }
> +
> + tmf_iu =
> tmf_urb->transfer_buffer;
> + res =
> uas_alloc_resp_urb(&resp_urb, sdev, resp,
> +
>
> be16_to_cpu(tmf_iu->tag));
> + if (res) {
> +
> usb_free_urb(tmf_urb);
> +
> kfree(resp);
> +
> return -ENOMEM;
> + }
> + }
> +
> + /* Now submit them */
> +
> +
> init_completion(&luinfo->tmf_completion);
> + luinfo->resp.resp = 0xFFFFFFFF;
> +
> + if (tpinfo->use_streams ||
> luinfo->freed_urb == cmdinfo->status_urb) {
> + res =
> usb_submit_urb(resp_urb, GFP_KERNEL);
> + if (res) {
> +
> complete(&luinfo->tmf_completion);
> +
> usb_free_urb(tmf_urb);
> +
> res = usb_unlink_urb(resp_urb);
> +
> if (res != -EINPROGRESS)
> +
> usb_free_urb(resp_urb);
> +
> return res;
> + }
> + }
> +
> + res = usb_submit_urb(tmf_urb,
> GFP_KERNEL);
> + if (res) {
> +
> complete(&luinfo->tmf_completion);
> + res =
> usb_unlink_urb(tmf_urb);
> + if (res !=
> -EINPROGRESS)
> +
> usb_free_urb(tmf_urb);
> + if
> (tpinfo->use_streams ||
> +
> luinfo->freed_urb == cmdinfo->status_urb) {
> +
> res = usb_unlink_urb(resp_urb);
> +
> if (res != -EINPROGRESS)
> +
> usb_free_urb(resp_urb);
> +
> return res;
> + }
> + }
> +
> + timeout =
> wait_for_completion_timeout(&luinfo->tmf_completion,
> +
>
> UAS_TMF_TIMEOUT);
> + if (timeout &&
> luinfo->resp.iu_id == IU_ID_RESPONSE &&
> +
> be16_to_cpup(&luinfo->resp.tag) >= TMF_TAG_FIRST)
> {
> + res =
> be32_to_cpup(&luinfo->resp.resp);
> + } else {
> + res = 0xFF;
> + }
> + return res;
> }
>
> -static int uas_eh_target_reset_handler(struct scsi_cmnd
> *cmnd)
> +static int uas_er_tmf(struct scsi_cmnd *cmd, u8 tmf)
> {
> - struct scsi_device *sdev =
> cmnd->device;
> - sdev_printk(KERN_INFO, sdev, "%s tag
> %d\n", __func__,
> -
>
> cmnd->request->tag);
> + struct scsi_device *sdev =
> cmd->device;
> + int tag;
> + int res;
>
> -/* XXX: Can we reset just the one USB interface?
> - * Would calling usb_set_interface() have the right
> effect?
> - */
> - return FAILED;
> + if (sdev->current_cmnd == cmd)
> + tag = 1;
> + else
> + tag =
> cmd->request->tag + 2;
> +
> + res = uas_do_tmf(cmd, tmf, tag);
> +
> + UAS_DPRINTK("%s: cmd:%p (0x%02x) tag:%d
> tmf:0x%02x resp:0x%08x\n",
> +
> __func__, cmd, cmd->cmnd[0], tag, tmf, res);
> +
> + switch (TMR_RESPONSE_CODE(res)) {
> + case TMR_COMPLETE:
> + case TMR_SUCC:
> + return SUCCESS;
> + default:
> + return FAILED;
> + }
> }
>
> -static int uas_eh_bus_reset_handler(struct scsi_cmnd
> *cmnd)
> +static int uas_eh_abort_handler(struct scsi_cmnd *cmd)
> {
> - struct scsi_device *sdev =
> cmnd->device;
> - struct uas_dev_info *devinfo =
> sdev->hostdata;
> - struct usb_device *udev =
> devinfo->udev;
> + return uas_er_tmf(cmd,
> TMF_ABORT_TASK);
> +}
> +
> +static int uas_eh_device_reset_handler(struct scsi_cmnd
> *cmd)
> +{
> + return uas_er_tmf(cmd, TMF_LU_RESET);
> +}
>
> - sdev_printk(KERN_INFO, sdev, "%s tag
> %d\n", __func__,
> -
>
> cmnd->request->tag);
> +static int uas_eh_target_reset_handler(struct scsi_cmnd
> *cmd)
> +{
> + return uas_er_tmf(cmd,
> TMF_IT_NEXUS_RESET);
> +}
> +
> +static int uas_eh_bus_reset_handler(struct scsi_cmnd
> *cmd)
> +{
> + struct scsi_device *sdev =
> cmd->device;
> + struct uas_tport_info *tpinfo =
> SDEV_TPORT_INFO(sdev);
> + struct usb_device *udev =
> tpinfo->udev;
> + int res;
> +
> + res = usb_reset_device(udev);
>
> - if (usb_reset_device(udev))
> + UAS_DPRINTK("%s: cmd:%p (0x%02x)
> res:0x%08x\n",
> +
> __func__, cmd, cmd->cmnd[0], res);
> +
> + if (res)
> return SUCCESS;
>
> return FAILED;
> }
>
> +/* ---------- SCSI Host support ---------- */
> +
> static int uas_slave_alloc(struct scsi_device *sdev)
> {
> - sdev->hostdata = (void
> *)sdev->host->hostdata[0];
> + sdev->hostdata =
> kzalloc(sizeof(struct uas_lu_info), GFP_KERNEL);
> + if (sdev->hostdata == NULL)
> + return -ENOMEM;
> return 0;
> }
>
> static int uas_slave_configure(struct scsi_device *sdev)
> {
> - struct uas_dev_info *devinfo =
> sdev->hostdata;
> + struct uas_tport_info *tpinfo =
> SDEV_TPORT_INFO(sdev);
> +
> scsi_set_tag_type(sdev,
> MSG_ORDERED_TAG);
> - scsi_activate_tcq(sdev,
> devinfo->qdepth - 1);
> + scsi_activate_tcq(sdev,
> tpinfo->num_tags);
> +
> return 0;
> }
>
> +static void uas_slave_destroy(struct scsi_device *sdev)
> +{
> + kfree(sdev->hostdata);
> +}
> +
> 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,
> + .slave_destroy = uas_slave_destroy,
> .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_ ? */
> + .can_queue = 0xFFEF,
> /* [1, 0xFFF0) */
> .this_id = -1,
> .sg_tablesize = SG_NONE,
> - .cmd_per_lun = 1, /*
> until we override it */
> + .cmd_per_lun = 1,
> /* until we override it */
> .skip_settle_delay = 1,
> .ordered_tag = 1,
> };
>
> +/* ---------- USB related ---------- */
> +
> 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) },
> @@ -610,15 +946,15 @@ static struct usb_device_id
> uas_usb_ids[] = {
> };
> MODULE_DEVICE_TABLE(usb, uas_usb_ids);
>
> -static void uas_configure_endpoints(struct uas_dev_info
> *devinfo)
> +static void uas_configure_endpoints(struct uas_tport_info
> *tpinfo)
> {
> struct usb_host_endpoint *eps[4] = {
> };
> - struct usb_interface *intf =
> devinfo->intf;
> - struct usb_device *udev =
> devinfo->udev;
> + struct usb_interface *intf =
> tpinfo->intf;
> + struct usb_device *udev =
> tpinfo->udev;
> struct usb_host_endpoint *endpoint =
> intf->cur_altsetting->endpoint;
> unsigned i, n_endpoints =
> intf->cur_altsetting->desc.bNumEndpoints;
>
> - devinfo->uas_sense_old = 0;
> + tpinfo->uas_sense_old = 0;
>
> for (i = 0; i < n_endpoints; i++) {
> unsigned char *extra
> = endpoint[i].extra;
> @@ -641,32 +977,38 @@ static void
> uas_configure_endpoints(struct uas_dev_info *devinfo)
> * 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);
> + tpinfo->cmd_pipe
> = usb_sndbulkpipe(udev, 1);
> +
> tpinfo->status_pipe = usb_rcvbulkpipe(udev, 1);
> +
> tpinfo->data_in_pipe = usb_rcvbulkpipe(udev, 2);
> +
> tpinfo->data_out_pipe = usb_sndbulkpipe(udev, 2);
> +
> + eps[1] =
> usb_pipe_endpoint(udev, tpinfo->status_pipe);
> + eps[2] =
> usb_pipe_endpoint(udev, tpinfo->data_in_pipe);
> + eps[3] =
> usb_pipe_endpoint(udev, tpinfo->data_out_pipe);
> } else {
> - devinfo->cmd_pipe
> = usb_sndbulkpipe(udev,
> + tpinfo->cmd_pipe
> = usb_sndbulkpipe(udev,
>
>
> eps[0]->desc.bEndpointAddress);
> -
> devinfo->status_pipe = usb_rcvbulkpipe(udev,
> +
> tpinfo->status_pipe = usb_rcvbulkpipe(udev,
>
>
> eps[1]->desc.bEndpointAddress);
> -
> devinfo->data_in_pipe = usb_rcvbulkpipe(udev,
> +
> tpinfo->data_in_pipe = usb_rcvbulkpipe(udev,
>
>
> eps[2]->desc.bEndpointAddress);
> -
> devinfo->data_out_pipe = usb_sndbulkpipe(udev,
> +
> tpinfo->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;
> + if (udev->speed == USB_SPEED_SUPER)
> {
> +
> tpinfo->use_streams = 1;
> + tpinfo->num_tags
> = usb_alloc_streams(tpinfo->intf,
> +
>
> eps + 1, 3,
> +
>
> UAS_MAX_STREAMS,
> +
>
> GFP_KERNEL);
> +
> + if
> (tpinfo->num_tags <= 0)
> +
> tpinfo->num_tags = 1;
> } else {
> -
> devinfo->use_streams = 1;
> + /* Be conservative
> */
> + tpinfo->num_tags
> = 32;
> +
> tpinfo->use_streams = 0;
> }
> }
>
> @@ -680,7 +1022,7 @@ 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 uas_tport_info *tpinfo;
> struct usb_device *udev =
> interface_to_usbdev(intf);
>
> if (id->bInterfaceProtocol == 0x50)
> {
> @@ -691,8 +1033,8 @@ static int uas_probe(struct
> usb_interface *intf, const struct usb_device_id *id)
>
> return -ENODEV;
> }
>
> - devinfo = kzalloc(sizeof(struct
> uas_dev_info), GFP_KERNEL);
> - if (!devinfo)
> + tpinfo = kzalloc(sizeof(struct
> uas_tport_info), GFP_KERNEL);
> + if (!tpinfo)
> return -ENOMEM;
>
> result = -ENOMEM;
> @@ -707,17 +1049,17 @@ static int uas_probe(struct
> usb_interface *intf, const struct usb_device_id *id)
> result = scsi_add_host(shost,
> &intf->dev);
> if (result)
> goto free;
> - shost->hostdata[0] = (unsigned
> long)devinfo;
> + shost->hostdata[0] = (unsigned
> long)tpinfo;
>
> - devinfo->intf = intf;
> - devinfo->udev = udev;
> - uas_configure_endpoints(devinfo);
> + tpinfo->intf = intf;
> + tpinfo->udev = udev;
> + uas_configure_endpoints(tpinfo);
>
> scsi_scan_host(shost);
> usb_set_intfdata(intf, shost);
> return result;
> free:
> - kfree(devinfo);
> + kfree(tpinfo);
> if (shost)
>
> scsi_host_put(shost);
> return result;
> @@ -740,16 +1082,16 @@ 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];
> + struct uas_tport_info *tpinfo = (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);
> + eps[0] = usb_pipe_endpoint(udev,
> tpinfo->status_pipe);
> + eps[1] = usb_pipe_endpoint(udev,
> tpinfo->data_in_pipe);
> + eps[2] = usb_pipe_endpoint(udev,
> tpinfo->data_out_pipe);
> usb_free_streams(intf, eps, 3,
> GFP_KERNEL);
>
> - kfree(devinfo);
> + kfree(tpinfo);
> }
>
> /*
> --
> 1.7.0.1
>
>
--
To unsubscribe from this list: send the line "unsubscribe linux-usb" in
the body of a message to majordomo@xxxxxxxxxxxxxxx
More majordomo info at http://vger.kernel.org/majordomo-info.html
