On Thu, Jun 13, 2013 at 7:50 PM, Sujit Reddy Thumma
<sthumma@xxxxxxxxxxxxxx> wrote:
>
> Background operations in the UFS device can be disabled by
> the host to reduce the response latency of transfer requests.
> Add support for enabling/disabling the background operations
> during runtime suspend/resume of the device.
>
> If the device is in critical need of BKOPS it will raise an
> URGENT_BKOPS exception which should be handled by the host to
> make sure the device performs as expected.
>
> During bootup, the BKOPS is enabled in the device by default.
> The disable of BKOPS is supported only when the driver supports
> runtime suspend/resume operations as the runtime PM framework
> provides a way to determine the device idleness and hence BKOPS
> can be managed effectively. During runtime resume the BKOPS is
> disabled to reduce latency and during runtime suspend the BKOPS
> is enabled to allow device to carry out idle time BKOPS.
>
> In some cases where the BKOPS is disabled during runtime resume
> and due to continuous data transfers the runtime suspend is not
> triggered, the BKOPS is enabled when the device raises a level-2
> exception (outstanding operations - performance impact).
>
> Change-Id: I8853c528af3bec2adaf49923d21cabca32b99142
> Signed-off-by: Sujit Reddy Thumma <sthumma@xxxxxxxxxxxxxx>
> ---
> drivers/scsi/ufs/ufs.h | 25 +++-
> drivers/scsi/ufs/ufshcd.c | 343
> +++++++++++++++++++++++++++++++++++++++++++++
> drivers/scsi/ufs/ufshcd.h | 10 ++
> 3 files changed, 377 insertions(+), 1 deletions(-)
>
> diff --git a/drivers/scsi/ufs/ufs.h b/drivers/scsi/ufs/ufs.h
> index 5484c59..24e589c 100644
> --- a/drivers/scsi/ufs/ufs.h
> +++ b/drivers/scsi/ufs/ufs.h
> @@ -107,7 +107,29 @@ enum {
>
> /* Flag idn for Query Requests*/
> enum flag_idn {
> - QUERY_FLAG_IDN_FDEVICEINIT = 0x01,
> + QUERY_FLAG_IDN_FDEVICEINIT = 0x01,
> + QUERY_FLAG_IDN_BKOPS_EN = 0x04,
> +};
> +
> +/* Attribute idn for Query requests */
> +enum attr_idn {
> + QUERY_ATTR_IDN_BKOPS_STATUS = 0x05,
> + QUERY_ATTR_IDN_EE_CONTROL = 0x0D,
> + QUERY_ATTR_IDN_EE_STATUS = 0x0E,
> +};
> +
> +/* Exception event mask values */
> +enum {
> + MASK_EE_STATUS = 0xFFFF,
> + MASK_EE_URGENT_BKOPS = (1 << 2),
> +};
> +
> +/* Background operation status */
> +enum {
> + BKOPS_STATUS_NO_OP = 0x0,
> + BKOPS_STATUS_NON_CRITICAL = 0x1,
> + BKOPS_STATUS_PERF_IMPACT = 0x2,
> + BKOPS_STATUS_CRITICAL = 0x3,
> };
>
> /* UTP QUERY Transaction Specific Fields OpCode */
> @@ -156,6 +178,7 @@ enum {
> MASK_TASK_RESPONSE = 0xFF00,
> MASK_RSP_UPIU_RESULT = 0xFFFF,
> MASK_QUERY_DATA_SEG_LEN = 0xFFFF,
> + MASK_RSP_EXCEPTION_EVENT = 0x10000,
> };
>
> /* Task management service response */
> diff --git a/drivers/scsi/ufs/ufshcd.c b/drivers/scsi/ufs/ufshcd.c
> index 6693ee9..aa1f11e 100644
> --- a/drivers/scsi/ufs/ufshcd.c
> +++ b/drivers/scsi/ufs/ufshcd.c
> @@ -298,6 +298,21 @@ ufshcd_get_rsp_upiu_result(struct utp_upiu_rsp
> *ucd_rsp_ptr)
> }
>
> /**
> + * ufshcd_is_exception_event - Check if the device raised an exception
> event
> + * @ucd_rsp_ptr: pointer to response UPIU
> + *
> + * The function checks if the device raised and exception event indicated
> in
> + * the Device Information field of response UPIU.
> + *
> + * Returns true if exception is raised, false otherwise.
> + */
> +static inline bool ufshcd_is_exception_event(struct utp_upiu_rsp
> *ucd_rsp_ptr)
> +{
> + return be32_to_cpu(ucd_rsp_ptr->header.dword_2) &
> + MASK_RSP_EXCEPTION_EVENT ? true : false;
> +}
> +
> +/**
> * ufshcd_config_int_aggr - Configure interrupt aggregation values.
> * Currently there is no use case where we want to configure
> * interrupt aggregation dynamically. So to configure
> interrupt
> @@ -1137,6 +1152,92 @@ out_no_mem:
> }
>
> /**
> + * ufshcd_query_attr - Helper function for composing attribute requests
> + * hba: per-adapter instance
> + * opcode: attribute opcode
> + * idn: attribute idn to access
> + * index: index field
> + * selector: selector field
> + * attr_val: the attribute value after the query request completes
> + *
> + * Returns 0 for success, non-zero in case of failure
> +*/
> +int ufshcd_query_attr(struct ufs_hba *hba, enum query_opcode opcode,
> + enum attr_idn idn, u8 index, u8 selector, u32
> *attr_val)
> +{
> + struct ufs_query_req *query;
> + struct ufs_query_res *response;
> + int err = -ENOMEM;
> +
> + query = kzalloc(sizeof(struct ufs_query_req), GFP_KERNEL);
> + if (!query) {
> + dev_err(hba->dev,
> + "%s: Failed allocating ufs_query_req instance\n",
> + __func__);
> + goto out_no_mem;
> + }
> +
> + response = kzalloc(sizeof(struct ufs_query_res), GFP_KERNEL);
> + if (!response) {
> + dev_err(hba->dev,
> + "%s: Failed allocating ufs_query_res instance\n",
> + __func__);
> + goto out_free_query;
> + }
> +
> + switch (opcode) {
> + case UPIU_QUERY_OPCODE_WRITE_ATTR:
> + query->query_func =
> UPIU_QUERY_FUNC_STANDARD_WRITE_REQUEST;
> + if (attr_val) {
> + query->upiu_req.value = *attr_val;
> + } else {
> + dev_err(hba->dev, "%s: attribute value required
> for write request\n",
> + __func__);
> + err = -EINVAL;
> + goto out;
> + }
> + break;
> + case UPIU_QUERY_OPCODE_READ_ATTR:
> + query->query_func = UPIU_QUERY_FUNC_STANDARD_READ_REQUEST;
> + if (!attr_val) {
> + /* No dummy reads */
> + err = 0;
> + goto out;
> + }
> + break;
> + default:
> + dev_err(hba->dev, "%s: Expected query attr opcode but got
> = %d\n",
> + __func__, opcode);
> + err = -EINVAL;
> + goto out;
> + }
> +
> + query->upiu_req.opcode = opcode;
> + query->upiu_req.idn = idn;
> + query->upiu_req.index = index;
> + query->upiu_req.selector = selector;
> +
> + /* Send query request */
> + err = ufshcd_send_query_request(hba, query, NULL, response);
> +
> + if (err) {
> + dev_err(hba->dev, "%s: Sending query attr for idn %d
> failed, err = %d\n",
> + __func__, idn, err);
> + goto out;
> + }
> +
> + if (attr_val)
> + *attr_val = response->upiu_res.value;
> +
> +out:
> + kfree(response);
> +out_free_query:
> + kfree(query);
> +out_no_mem:
> + return err;
> +}
> +
> +/**
> * ufshcd_memory_alloc - allocate memory for host memory space data
> structures
> * @hba: per adapter instance
> *
> @@ -1803,6 +1904,9 @@ ufshcd_transfer_rsp_status(struct ufs_hba *hba,
> struct ufshcd_lrb *lrbp)
> */
> scsi_status = result & MASK_SCSI_STATUS;
> result = ufshcd_scsi_cmd_status(lrbp,
> scsi_status);
> +
> + if (ufshcd_is_exception_event(lrbp->ucd_rsp_ptr))
^^^^^
This condition will not satisfy until a runtime suspend/resume cycle
completes. Is there any specific reason it is only being enabled in
runtime-resume routine?
As the fBackgroundOpsEn = 1 by default, shouldn't the sequence be 1.
ufshcd_disable_auto_bkops() 2. ufshcd_enable_ee() during the startup.
> + schedule_work(&hba->eeh_work);
> break;
> case UPIU_TRANSACTION_REJECT_UPIU:
> /* TODO: handle Reject UPIU Response */
> @@ -1899,6 +2003,216 @@ static void ufshcd_transfer_req_compl(struct
> ufs_hba *hba)
> }
>
> /**
> + * ufshcd_disable_ee - disable exception event
> + * @hba: per-adapter instance
> + * @mask: exception event to disable
> + *
> + * Disables exception event in the device so that the EVENT_ALERT
> + * bit is not set.
> + *
> + * Returns zero on success, non-zero error value on failure.
> + */
> +static int ufshcd_disable_ee(struct ufs_hba *hba, int mask)
> +{
> + int err = 0;
> + u32 val = 0;
> +
> + if (!(hba->ee_ctrl_mask & mask))
> + goto out;
> +
> + val = hba->ee_ctrl_mask & ~mask;
> + val &= 0xFFFF; /* 2 bytes */
> + err = ufshcd_query_attr(hba, UPIU_QUERY_OPCODE_WRITE_ATTR,
> + QUERY_ATTR_IDN_EE_CONTROL, 0, 0, &val);
> + if (!err)
> + hba->ee_ctrl_mask &= ~mask;
> +out:
> + return err;
> +}
> +
> +/**
> + * ufshcd_enable_ee - enable exception event
> + * @hba: per-adapter instance
> + * @mask: exception event to enable
> + *
> + * Enable corresponding exception event in the device to allow
> + * device to alert host in critical scenarios.
> + *
> + * Returns zero on success, non-zero error value on failure.
> + */
> +static int ufshcd_enable_ee(struct ufs_hba *hba, int mask)
> +{
> + int err = 0;
> + u32 val = 0;
> +
> + if (hba->ee_ctrl_mask & mask)
> + goto out;
> +
> + val = hba->ee_ctrl_mask | mask;
> + val &= 0xFFFF; /* 2 bytes */
> + err = ufshcd_query_attr(hba, UPIU_QUERY_OPCODE_WRITE_ATTR,
> + QUERY_ATTR_IDN_EE_CONTROL, 0, 0, &val);
> + if (!err)
> + hba->ee_ctrl_mask |= mask;
> +out:
> + return err;
> +}
> +
> +/**
> + * ufshcd_enable_auto_bkops - Allow device managed BKOPS
> + * @hba: per-adapter instance
> + *
> + * Allow device to manage background operations on its own. Enabling
> + * this might lead to inconsistent latencies during normal data transfers
> + * as the device is allowed to manage its own way of handling background
> + * operations.
> + *
> + * Returns zero on success, non-zero on failure.
> + */
> +static int ufshcd_enable_auto_bkops(struct ufs_hba *hba)
> +{
> + int err = 0;
> +
> + if (!hba->auto_bkops_disabled)
> + goto out;
> +
> + err = ufshcd_query_flag(hba, UPIU_QUERY_OPCODE_SET_FLAG,
> + QUERY_FLAG_IDN_BKOPS_EN, NULL);
> + if (err) {
> + dev_err(hba->dev, "%s: failed to enable bkops %d\n",
> + __func__, err);
> + goto out;
> + }
> +
> + hba->auto_bkops_disabled = false;
> +
> + /* No need of URGENT_BKOPS exception from the device */
> + err = ufshcd_disable_ee(hba, MASK_EE_URGENT_BKOPS);
> + if (err)
> + dev_err(hba->dev, "%s: failed to disable exception event
> %d\n",
> + __func__, err);
> +out:
> + return err;
> +}
> +
> +/**
> + * ufshcd_disable_auto_bkops - block device in doing background
> operations
> + * @hba: per-adapter instance
> + *
> + * Disabling background operations improves command response latency but
> + * has drawback of device moving into critical state where the device is
> + * not-operable. Make sure to call ufshcd_enable_auto_bkops() whenever
> the
> + * host is idle so that BKOPS are managed effectively without any
> negative
> + * impacts.
> + *
> + * Returns zero on success, non-zero on failure.
> + */
> +static int ufshcd_disable_auto_bkops(struct ufs_hba *hba)
> +{
> + int err = 0;
> +
> + if (hba->auto_bkops_disabled)
> + goto out;
> +
> + /*
> + * If host assisted BKOPs is to be enabled, make sure
> + * urgent bkops exception is allowed.
> + */
> + err = ufshcd_enable_ee(hba, MASK_EE_URGENT_BKOPS);
> + if (err) {
> + dev_err(hba->dev, "%s: failed to enable exception event
> %d\n",
> + __func__, err);
> + goto out;
> + }
> +
> + err = ufshcd_query_flag(hba, UPIU_QUERY_OPCODE_CLEAR_FLAG,
> + QUERY_FLAG_IDN_BKOPS_EN, NULL);
> + if (err) {
> + dev_err(hba->dev, "%s: failed to disable bkops %d\n",
> + __func__, err);
> + ufshcd_disable_ee(hba, MASK_EE_URGENT_BKOPS);
> + goto out;
> + }
> +
> + hba->auto_bkops_disabled = true;
> +out:
> + return err;
> +}
> +
> +static inline int ufshcd_get_bkops_status(struct ufs_hba *hba, u32
> *status)
> +{
> + return ufshcd_query_attr(hba, UPIU_QUERY_OPCODE_READ_ATTR,
> + QUERY_ATTR_IDN_BKOPS_STATUS, 0, 0, status);
> +}
> +
> +/**
> + * ufshcd_urgent_bkops - handle urgent bkops exception event
> + * @hba: per-adapter instance
> + *
> + * Enable fBackgroundOpsEn flag in the device to permit background
> + * operations.
> + */
> +static int ufshcd_urgent_bkops(struct ufs_hba *hba)
> +{
> + int err;
> + u32 status = 0;
> +
> + err = ufshcd_get_bkops_status(hba, &status);
> + if (err) {
> + dev_err(hba->dev, "%s: failed to get BKOPS status %d\n",
> + __func__, err);
> + goto out;
> + }
> +
> + status = status & 0xF;
> +
> + /* handle only if status indicates performance impact or critical
> */
> + if (status == BKOPS_STATUS_PERF_IMPACT ||
> + status == BKOPS_STATUS_CRITICAL)
> + err = ufshcd_enable_auto_bkops(hba);
> +out:
> + return err;
> +}
> +
> +static inline int ufshcd_get_ee_status(struct ufs_hba *hba, u32 *status)
> +{
> + return ufshcd_query_attr(hba, UPIU_QUERY_OPCODE_READ_ATTR,
> + QUERY_ATTR_IDN_EE_STATUS, 0, 0, status);
> +}
> +
> +/**
> + * ufshcd_exception_event_handler - handle exceptions raised by device
> + * @work: pointer to work data
> + *
> + * Read bExceptionEventStatus attribute from the device and handle the
> + * exception event accordingly.
> + */
> +static void ufshcd_exception_event_handler(struct work_struct *work)
> +{
> + struct ufs_hba *hba;
> + int err;
> + u32 status = 0;
> + hba = container_of(work, struct ufs_hba, eeh_work);
> +
> + err = ufshcd_get_ee_status(hba, &status);
> + if (err) {
> + dev_err(hba->dev, "%s: failed to get exception status
> %d\n",
> + __func__, err);
> + goto out;
> + }
> +
> + status = status & hba->ee_ctrl_mask;
> + if (status & MASK_EE_URGENT_BKOPS) {
> + err = ufshcd_urgent_bkops(hba);
> + if (err)
> + dev_err(hba->dev, "%s: failed to handle urgent
> bkops %d\n",
> + __func__, err);
> + }
> +out:
> + return;
> +}
> +
> +/**
> * ufshcd_fatal_err_handler - handle fatal errors
> * @hba: per adapter instance
> */
> @@ -2273,6 +2587,34 @@ int ufshcd_resume(struct ufs_hba *hba)
> }
> EXPORT_SYMBOL_GPL(ufshcd_resume);
>
> +int ufshcd_runtime_suspend(struct ufs_hba *hba)
> +{
> + if (!hba)
> + return 0;
> +
> + /*
> + * The device is idle with no requests in the queue,
> + * allow background operations.
> + */
> + return ufshcd_enable_auto_bkops(hba);
> +}
> +EXPORT_SYMBOL(ufshcd_runtime_suspend);
> +
> +int ufshcd_runtime_resume(struct ufs_hba *hba)
> +{
> + if (!hba)
> + return 0;
> +
> + return ufshcd_disable_auto_bkops(hba);
> +}
> +EXPORT_SYMBOL(ufshcd_runtime_resume);
> +
> +int ufshcd_runtime_idle(struct ufs_hba *hba)
> +{
> + return 0;
> +}
> +EXPORT_SYMBOL(ufshcd_runtime_idle);
> +
> /**
> * ufshcd_hba_free - free allocated memory for
> * host memory space data structures
> @@ -2376,6 +2718,7 @@ int ufshcd_init(struct device *dev, struct ufs_hba
> **hba_handle,
>
> /* Initialize work queues */
> INIT_WORK(&hba->feh_workq, ufshcd_fatal_err_handler);
> + INIT_WORK(&hba->eeh_work, ufshcd_exception_event_handler);
>
> /* Initialize UIC command mutex */
> mutex_init(&hba->uic_cmd_mutex);
> diff --git a/drivers/scsi/ufs/ufshcd.h b/drivers/scsi/ufs/ufshcd.h
> index 4e4c56f..682c285 100644
> --- a/drivers/scsi/ufs/ufshcd.h
> +++ b/drivers/scsi/ufs/ufshcd.h
> @@ -176,9 +176,12 @@ struct ufs_internal_cmd {
> * @tm_condition: condition variable for task management
> * @ufshcd_state: UFSHCD states
> * @intr_mask: Interrupt Mask Bits
> + * @ee_ctrl_mask: Exception event control mask
> * @feh_workq: Work queue for fatal controller error handling
> + * @eeh_work: Worker to handle exception events
> * @errors: HBA errors
> * @i_cmd: ufs internal command information
> + * @auto_bkops_disabled: to track whether bkops is enabled in device
> */
> struct ufs_hba {
> void __iomem *mmio_base;
> @@ -215,15 +218,19 @@ struct ufs_hba {
>
> u32 ufshcd_state;
> u32 intr_mask;
> + u16 ee_ctrl_mask;
>
> /* Work Queues */
> struct work_struct feh_workq;
> + struct work_struct eeh_work;
>
> /* HBA Errors */
> u32 errors;
>
> /* Internal Request data */
> struct ufs_internal_cmd i_cmd;
> +
> + bool auto_bkops_disabled;
> };
>
> #define ufshcd_writel(hba, val, reg) \
> @@ -244,4 +251,7 @@ static inline void ufshcd_hba_stop(struct ufs_hba
> *hba)
> ufshcd_writel(hba, CONTROLLER_DISABLE, REG_CONTROLLER_ENABLE);
> }
>
> +extern int ufshcd_runtime_suspend(struct ufs_hba *hba);
> +extern int ufshcd_runtime_resume(struct ufs_hba *hba);
> +extern int ufshcd_runtime_idle(struct ufs_hba *hba);
> #endif /* End of Header */
> --
> QUALCOMM INDIA, on behalf of Qualcomm Innovation Center, Inc. is a member
> of Code Aurora Forum, hosted by The Linux Foundation.
>
--
~Santosh
--
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
