lkml.org 
[lkml]   [2012]   [Feb]   [6]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    Date
    SubjectRe: [PATCH 4/4] [SCSI] ufshcd: SCSI error handling
    From
    Hi,

    In function:
    +static int ufshcd_abort(struct scsi_cmnd *cmd)
    +{...
    - int err;
    + int err = -1;
    ...
    + spin_lock_irqsave(host->host_lock, flags);
    + pos = (1 << tag);
    +
    + /* check if command is still pending */
    + if (!(hba->outstanding_reqs & pos)) {
    - err = -1;
    - spin_unlock_irqrestore(host->host_lock, flags);
    + goto out;
    + }
    ...
    ...
    +out:
    + spin_unlock_irqrestore(host->host_lock, flags);
    + return err;
    +}
    this will also take of matching out
    spin_lock_irqsave()->spin_unlock_irqrestore() before exiting the
    function.

    In function:
    +static int
    +ufshcd_issue_tm_cmd(struct ufs_hba *hba,
    + struct ufshcd_lrb *lrbp,
    + u8 tm_function)
    ...
    + spin_lock_irqsave(host->host_lock, flags);
    +
    + /* If task management queue is full */
    + if (!ufshcd_is_tmq_full(hba->outstanding_tasks)) {
    + dev_err(&hba->pdev->dev, "Task management queue full\n");
    I think this will map to a Buffered printf - which can potentially
    result in BUG: Schedule while atomic()...
    + spin_unlock_irqrestore(host->host_lock, flags);
    + return err;
    + }
    So, it could be like this:
    + spin_lock_irqsave(host->host_lock, flags);
    +
    + /* If task management queue is full */
    + if (!ufshcd_is_tmq_full(hba->outstanding_tasks)) {
    + spin_unlock_irqrestore(host->host_lock, flags);
    + dev_err(&hba->pdev->dev, "Task management queue full\n");
    + return err;
    + }

    Thanks & Regards,
    Amit Sahrawat


    On Thu, Feb 2, 2012 at 10:27 AM, Vinayak Holikatti
    <vinholikatti@gmail.com> wrote:
    > From: Santosh Yaraganavi <santoshsy@gmail.com>
    >
    > UFSHCD SCSI error handling includes following implementations,
    >  - Abort task
    >  - Device reset
    >  - Host reset
    >
    > Signed-off-by: Santosh Yaraganavi <santoshsy@gmail.com>
    > Signed-off-by: Vinayak Holikatti <vinholikatti@gmail.com>
    > Reviewed-by: Arnd Bergmann <arnd@arndb.de>
    > Reviewed-by: Saugata Das <saugata.das@linaro.org>
    > Reviewed-by: Vishak G <vishak.g@samsung.com>
    > Reviewed-by: Girish K S <girish.shivananjappa@linaro.org>
    > ---
    >  drivers/scsi/ufs/ufshcd.c |  312 +++++++++++++++++++++++++++++++++++++++++++++
    >  1 files changed, 312 insertions(+), 0 deletions(-)
    >
    > diff --git a/drivers/scsi/ufs/ufshcd.c b/drivers/scsi/ufs/ufshcd.c
    > index 1bfae84..7589dd1 100644
    > --- a/drivers/scsi/ufs/ufshcd.c
    > +++ b/drivers/scsi/ufs/ufshcd.c
    > @@ -76,6 +76,8 @@
    >  #define NULL 0
    >  #endif  /* NULL */
    >
    > +#define UFSHCD_MAX_TM_SLOTS    0xFF
    > +
    >  #define BYTES_TO_DWORDS(p)     (p >> 2)
    >  #define UFSHCD_MMIO_BASE       (hba->mmio_base)
    >
    > @@ -83,6 +85,7 @@ enum {
    >        UFSHCD_MAX_CHANNEL      = 1,
    >        UFSHCD_MAX_ID           = 1,
    >        UFSHCD_MAX_LUNS         = 8,
    > +       UFSHCD_MAX_TM_CMDS      = 8,
    >        UFSHCD_CMD_PER_LUN      = 16,
    >        UFSHCD_CAN_QUEUE        = 32,
    >        BYTES_128               = 128,
    > @@ -149,6 +152,7 @@ struct uic_command {
    >  * @host: Scsi_Host instance of the driver
    >  * @pdev: PCI device handle
    >  * @lrb: local reference block
    > + * @outstanding_tasks: Bits representing outstanding task requests
    >  * @outstanding_reqs: Bits representing outstanding transfer requests
    >  * @capabilities: UFS Controller Capabilities
    >  * @nutrs: Transfer Request Queue depth supported by controller
    > @@ -192,6 +196,7 @@ struct ufs_hba {
    >
    >        struct ufshcd_lrb *lrb;
    >
    > +       u32 outstanding_tasks;
    >        u32 outstanding_reqs;
    >
    >        u32 capabilities;
    > @@ -200,6 +205,8 @@ struct ufs_hba {
    >        u32 ufs_version;
    >
    >        struct uic_command active_uic_cmd;
    > +       wait_queue_head_t ufshcd_tm_wait_queue;
    > +       u8 tm_condition[UFSHCD_MAX_TM_CMDS];
    >
    >        u32 ufshcd_state;
    >        u32 int_enable_mask;
    > @@ -278,6 +285,30 @@ static inline int ufshcd_get_tr_ocs(struct ufshcd_lrb *lrbp)
    >  }
    >
    >  /**
    > + * ufshcd_get_tmr_ocs - Get the UTMRD Overall Command Status
    > + * @task_req_descp: pointer to utp_task_req_desc structure
    > + *
    > + * This function is used to get the OCS field from UTMRD
    > + * Returns the OCS field in the UTMRD
    > + */
    > +static inline int
    > +ufshcd_get_tmr_ocs(struct utp_task_req_desc *task_req_descp)
    > +{
    > +       return task_req_descp->header.dword_2 & MASK_OCS;
    > +}
    > +
    > +/**
    > + * ufshcd_is_tmq_full - checks if the task management slots are full
    > + * @outstanding_tasks: contains the task management doorbell value
    > + *
    > + * Returns 1 if a free slot available, 0 if task slots are full
    > + */
    > +static inline int ufshcd_is_tmq_full(u32 outstanding_tasks)
    > +{
    > +       return (UFSHCD_MAX_TM_SLOTS == outstanding_tasks) ? 0 : 1;
    > +}
    > +
    > +/**
    >  * ufshcd_get_lists_status - Check UCRDY, UTRLRDY and UTMRLRDY
    >  * @reg: Register value of host controller status
    >  *
    > @@ -1098,6 +1129,45 @@ static void ufshcd_slave_destroy(struct scsi_device *sdev)
    >  }
    >
    >  /**
    > + * ufshcd_task_req_compl - handle task management request completion
    > + * @hba: per adapter instance
    > + * @index: index of the completed request
    > + *
    > + * Returns 0 on success, non-zero value on failure
    > + */
    > +static int ufshcd_task_req_compl(struct ufs_hba *hba, u32 index)
    > +{
    > +       struct utp_upiu_task_rsp *task_rsp_upiup;
    > +       struct utp_task_req_desc *task_req_descp;
    > +       unsigned long flags;
    > +       int ocs_value;
    > +       int task_response = -1;
    > +
    > +       spin_lock_irqsave(hba->host->host_lock, flags);
    > +
    > +       /* clear completed tasks from outstanding_tasks */
    > +       hba->outstanding_tasks ^= index;
    > +
    > +       task_req_descp =
    > +               (struct utp_task_req_desc *)hba->utmrdl_virt_addr_aligned;
    > +       ocs_value = ufshcd_get_tmr_ocs(&task_req_descp[index]);
    > +
    > +       if (OCS_SUCCESS == ocs_value) {
    > +
    > +               task_rsp_upiup = (struct utp_upiu_task_rsp *)
    > +                                task_req_descp[index].task_rsp_upiu;
    > +               task_response = be32_to_cpu(task_rsp_upiup->header.dword_1);
    > +               task_response = ((task_response & MASK_TASK_RESPONSE) >> 8);
    > +
    > +               /* clear task response */
    > +               memset(task_rsp_upiup, 0, sizeof(struct utp_upiu_task_rsp));
    > +       }
    > +       spin_unlock_irqrestore(hba->host->host_lock, flags);
    > +
    > +       return task_response;
    > +}
    > +
    > +/**
    >  * ufshcd_scsi_cmd_status - Update SCSI command result based on scsi status
    >  * @lrb: pointer to local reference block of completed command
    >  * @scsi_status: SCSI command status
    > @@ -1314,6 +1384,31 @@ fatal_eh:
    >  }
    >
    >  /**
    > + * ufshcd_tmc_handler - handle task management function completion
    > + * @hba: per adapter instance
    > + */
    > +static void ufshcd_tmc_handler(struct ufs_hba *hba)
    > +{
    > +       u32 completed_reqs;
    > +       u32 tm_doorbell;
    > +       int i;
    > +
    > +       tm_doorbell = readl(hba->mmio_base + REG_UTP_TASK_REQ_DOOR_BELL);
    > +       completed_reqs = tm_doorbell ^ hba->outstanding_tasks;
    > +       for (i = 0; i < hba->nutmrs; i++) {
    > +               if (completed_reqs & (1 << i)) {
    > +
    > +                       /*
    > +                        * Change the default value 0xFF to 0 to indicate
    > +                        * completion of respective task management command
    > +                        */
    > +                       hba->tm_condition[i] = 0;
    > +                       wake_up_interruptible(&hba->ufshcd_tm_wait_queue);
    > +               }
    > +       }
    > +}
    > +
    > +/**
    >  * ufshcd_sl_intr - Interrupt service routine
    >  * @hba: per adapter instance
    >  * @intr_status: contains interrupts generated by the controller
    > @@ -1327,6 +1422,9 @@ static void ufshcd_sl_intr(struct ufs_hba *hba, u32 intr_status)
    >        if (intr_status & UIC_COMMAND_COMPL)
    >                schedule_work(&hba->uic_workq);
    >
    > +       if (intr_status & UTP_TASK_REQ_COMPL)
    > +               ufshcd_tmc_handler(hba);
    > +
    >        if (intr_status & UTP_TRANSFER_REQ_COMPL)
    >                ufshcd_transfer_req_compl(hba);
    >  }
    > @@ -1362,6 +1460,209 @@ static irqreturn_t ufshcd_intr(int irq, void *__hba)
    >        return retval;
    >  }
    >
    > +/**
    > + * ufshcd_issue_tm_cmd - issues task management commands to controller
    > + * @hba: per adapter instance
    > + * @lrbp: pointer to local reference block
    > + *
    > + * Returns 0 on success, non-zero value on failure
    > + */
    > +static int
    > +ufshcd_issue_tm_cmd(struct ufs_hba *hba,
    > +                   struct ufshcd_lrb *lrbp,
    > +                   u8 tm_function)
    > +{
    > +       struct utp_task_req_desc *task_req_descp;
    > +       struct utp_upiu_task_req *task_req_upiup;
    > +       struct Scsi_Host *host;
    > +       unsigned long flags;
    > +       int i;
    > +       int free_slot = 0;
    > +       int err = -1;
    > +
    > +       host = hba->host;
    > +
    > +       spin_lock_irqsave(host->host_lock, flags);
    > +
    > +       /* If task management queue is full */
    > +       if (!ufshcd_is_tmq_full(hba->outstanding_tasks)) {
    > +               dev_err(&hba->pdev->dev, "Task management queue full\n");
    > +               spin_unlock_irqrestore(host->host_lock, flags);
    > +               return err;
    > +       }
    > +
    > +       for (i = 0; i < hba->nutmrs; i++) {
    > +               if (!(hba->outstanding_tasks & (1 << i))) {
    > +                       free_slot = i;
    > +                       break;
    > +               }
    > +       }
    > +
    > +       /* Configure task request descriptor */
    > +       task_req_descp =
    > +               (struct utp_task_req_desc *) hba->utmrdl_virt_addr_aligned;
    > +       task_req_descp += free_slot;
    > +
    > +       memset(task_req_descp, 0, sizeof(struct utp_task_req_desc));
    > +       task_req_descp->header.dword_0 = cpu_to_le32(UTP_REQ_DESC_INT_CMD);
    > +       task_req_descp->header.dword_2 =
    > +                       cpu_to_le32(OCS_INVALID_COMMAND_STATUS);
    > +
    > +       /* Configure task request UPIU */
    > +       task_req_upiup =
    > +               (struct utp_upiu_task_req *) task_req_descp->task_req_upiu;
    > +       task_req_upiup->header.dword_0 =
    > +               cpu_to_be32(UPIU_HEADER_DWORD(UPIU_TRANSACTION_TASK_REQ, 0,
    > +                                             lrbp->lun, lrbp->task_tag));
    > +       task_req_upiup->header.dword_1 =
    > +       cpu_to_be32(UPIU_HEADER_DWORD(0, tm_function, 0, 0));
    > +
    > +       task_req_upiup->input_param1 = lrbp->lun;
    > +       task_req_upiup->input_param1 =
    > +               cpu_to_be32(task_req_upiup->input_param1);
    > +       task_req_upiup->input_param2 = lrbp->task_tag;
    > +       task_req_upiup->input_param2 =
    > +               cpu_to_be32(task_req_upiup->input_param2);
    > +
    > +       /* send command to the controller */
    > +       hba->outstanding_tasks |= (1 << free_slot);
    > +       writel((1 << free_slot),
    > +              (UFSHCD_MMIO_BASE + REG_UTP_TASK_REQ_DOOR_BELL));
    > +
    > +       spin_unlock_irqrestore(host->host_lock, flags);
    > +
    > +       /* wait until the task management command is completed */
    > +       err = wait_event_interruptible_timeout(hba->ufshcd_tm_wait_queue,
    > +                                        (hba->tm_condition[free_slot] != 0),
    > +                                        60 * HZ);
    > +       hba->tm_condition[free_slot] = 0xFF;
    > +       if (!err) {
    > +               dev_err(&hba->pdev->dev,
    > +                       "Task management command timed-out\n");
    > +               return err;
    > +       }
    > +       return ufshcd_task_req_compl(hba, free_slot);
    > +}
    > +
    > +/**
    > + * ufshcd_device_reset - reset device and abort all the pending commands
    > + * @cmd: SCSI command pointer
    > + *
    > + * Returns 0 on success, non-zero value on failure
    > + */
    > +static int ufshcd_device_reset(struct scsi_cmnd *cmd)
    > +{
    > +       struct Scsi_Host *host;
    > +       struct ufs_hba *hba;
    > +       unsigned long flags;
    > +       int reset_lun;
    > +       unsigned int tag;
    > +       u32 i;
    > +       u32 pos; /* pos: represents a bit in a register */
    > +       int err = -1;
    > +
    > +       host = cmd->device->host;
    > +       hba = (struct ufs_hba *)host->hostdata;
    > +       tag = cmd->request->tag;
    > +
    > +       if ((hba->lrb[tag].cmd == cmd))
    > +               reset_lun = hba->lrb[tag].lun;
    > +       else
    > +               goto out;
    > +
    > +       err = ufshcd_issue_tm_cmd(hba, &hba->lrb[tag], UFS_LOGICAL_RESET);
    > +       if (!err) {
    > +               spin_lock_irqsave(host->host_lock, flags);
    > +               for (i = 0; i < hba->nutrs; i++) {
    > +                       pos = (1 << i);
    > +                       if ((pos & hba->outstanding_reqs) &&
    > +                           (reset_lun == hba->lrb[i].lun)) {
    > +
    > +                               /* clear the respective UTRLCLR bit */
    > +                               writel(~pos, (UFSHCD_MMIO_BASE +
    > +                               REG_UTP_TRANSFER_REQ_LIST_CLEAR));
    > +
    > +                               hba->outstanding_reqs ^= pos;
    > +
    > +                               if (hba->lrb[i].cmd) {
    > +                                       scsi_dma_unmap(hba->lrb[i].cmd);
    > +                                       hba->lrb[i].cmd->result =
    > +                                                       DID_ABORT << 16;
    > +                                       hba->lrb[i].cmd->scsi_done(cmd);
    > +                                       hba->lrb[i].cmd = NULL;
    > +                               }
    > +                       }
    > +               } /* end of for */
    > +               spin_unlock_irqrestore(host->host_lock, flags);
    > +       } /*end of if */
    > +out:
    > +       return err;
    > +}
    > +
    > +/**
    > + * ufshcd_host_reset - Main reset function registered with scsi layer
    > + * @cmd: SCSI command pointer
    > + *
    > + * Returns 0 on success, non-zero value on failure
    > + */
    > +static int ufshcd_host_reset(struct scsi_cmnd *cmd)
    > +{
    > +       struct ufs_hba *hba = NULL;
    > +
    > +       hba = (struct ufs_hba *) &cmd->device->host->hostdata[0];
    > +
    > +       if (UFSHCD_STATE_RESET == hba->ufshcd_state)
    > +               return 0;
    > +
    > +       return ufshcd_do_reset(hba) ? -1 : 0;
    > +}
    > +
    > +/**
    > + * ufshcd_abort - abort a specific command
    > + * @cmd: SCSI command pointer
    > + *
    > + * Returns 0 on success, non-zero value on failure
    > + */
    > +static int ufshcd_abort(struct scsi_cmnd *cmd)
    > +{
    > +       struct Scsi_Host *host;
    > +       struct ufs_hba *hba;
    > +       unsigned long flags;
    > +       unsigned int tag;
    > +       unsigned int pos;
    > +       int err;
    > +
    > +       host = cmd->device->host;
    > +       hba = (struct ufs_hba *) host->hostdata;
    > +       tag = cmd->request->tag;
    > +
    > +       spin_lock_irqsave(host->host_lock, flags);
    > +       pos = (1 << tag);
    > +
    > +       /* check if command is still pending */
    > +       if (!(hba->outstanding_reqs & pos)) {
    > +               err = -1;
    > +               spin_unlock_irqrestore(host->host_lock, flags);
    > +               goto out;
    > +       }
    > +
    > +       err = ufshcd_issue_tm_cmd(hba, &hba->lrb[tag], UFS_ABORT_TASK);
    > +       if (!err) {
    > +               spin_lock_irqsave(host->host_lock, flags);
    > +               scsi_dma_unmap(cmd);
    > +
    > +               /* clear the respective UTRLCLR bit */
    > +               writel(~pos,
    > +                       (UFSHCD_MMIO_BASE +
    > +                        REG_UTP_TRANSFER_REQ_LIST_CLEAR));
    > +               hba->outstanding_reqs &= ~pos;
    > +               hba->lrb[tag].cmd = NULL;
    > +               spin_unlock_irqrestore(host->host_lock, flags);
    > +       }
    > +out:
    > +       return err;
    > +}
    > +
    >  static struct scsi_host_template ufshcd_driver_template = {
    >        .module                 = THIS_MODULE,
    >        .name                   = UFSHCD,
    > @@ -1369,6 +1670,9 @@ static struct scsi_host_template ufshcd_driver_template = {
    >        .queuecommand           = ufshcd_queuecommand,
    >        .slave_alloc            = ufshcd_slave_alloc,
    >        .slave_destroy          = ufshcd_slave_destroy,
    > +       .eh_abort_handler       = ufshcd_abort,
    > +       .eh_device_reset_handler = ufshcd_device_reset,
    > +       .eh_host_reset_handler  = ufshcd_host_reset,
    >        .this_id                = -1,
    >        .sg_tablesize           = SG_ALL,
    >        .cmd_per_lun            = UFSHCD_CMD_PER_LUN,
    > @@ -1483,6 +1787,7 @@ ufshcd_probe(struct pci_dev *pdev, const struct pci_device_id *id)
    >        struct Scsi_Host *host;
    >        struct ufs_hba *hba;
    >        int ufs_hba_len;
    > +       int index;
    >        int err;
    >
    >        ufs_hba_len = sizeof(struct ufs_hba);
    > @@ -1547,6 +1852,13 @@ ufshcd_probe(struct pci_dev *pdev, const struct pci_device_id *id)
    >        host->unique_id = host->host_no;
    >        host->max_cmd_len = MAX_CDB_SIZE;
    >
    > +       /* Initailze wait queue for task management */
    > +       init_waitqueue_head(&hba->ufshcd_tm_wait_queue);
    > +
    > +       /* Initially assign invalid value to tm_condition */
    > +       for (index = 0; index < hba->nutmrs; index++)
    > +               hba->tm_condition[index] = 0xFF;
    > +
    >        /* Initialize work queues */
    >        INIT_WORK(&hba->uic_workq, ufshcd_uic_cc_handler);
    >        INIT_WORK(&hba->feh_workq, ufshcd_fatal_err_handler);
    > --
    > 1.7.5.4
    >
    > --
    > To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
    > the body of a message to majordomo@vger.kernel.org
    > More majordomo info at  http://vger.kernel.org/majordomo-info.html
    > Please read the FAQ at  http://www.tux.org/lkml/
    --
    To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
    the body of a message to majordomo@vger.kernel.org
    More majordomo info at http://vger.kernel.org/majordomo-info.html
    Please read the FAQ at http://www.tux.org/lkml/

    \
     
     \ /
      Last update: 2012-02-06 08:19    [W:0.070 / U:0.128 seconds]
    ©2003-2016 Jasper Spaans. hosted at Digital OceanAdvertise on this site