[PATCH 0/2] scsi: ufs: Add support to control UFS device background operations

[PATCH 0/2] scsi: ufs: Add support to control UFS device background operations

[Sujit Reddy Thumma]

Add host assisted background operations for UFS device and runtime PM
helpers for ufshcd platform and pci glue drivers. The background operations
are disabled during runtime resume and enabled when the device is idle and
runtime suspended.

These patches depends on:
[PATCH 2/8] scsi: ufs: wrap the i/o access operations
[PATCH 3/8] scsi: ufs: amend interrupt configuration
[PATCH 4/8] scsi: ufs: remove version check before IS reg clear
[PATCH 5/8] scsi: ufs: rework link start-up process
[PATCH 1/2] scsi: ufs: Add support for sending NOP OUT UPIU
[PATCH 2/2] scsi: ufs: Set fDeviceInit flag to initiate device initialization

Sujit Reddy Thumma (2):
  scsi: ufs: Add support for host assisted background operations
  scsi: ufs: Add runtime PM helpers for UFS host driver

 drivers/scsi/ufs/ufs.h           |   25 +++-
 drivers/scsi/ufs/ufshcd-pci.c    |   60 ++++++-
 drivers/scsi/ufs/ufshcd-pltfrm.c |   41 +++++
 drivers/scsi/ufs/ufshcd.c        |  343 ++++++++++++++++++++++++++++++++++++++
 drivers/scsi/ufs/ufshcd.h        |   10 +
 5 files changed, 472 insertions(+), 7 deletions(-)

-- 
QUALCOMM INDIA, on behalf of Qualcomm Innovation Center, Inc. is a member
of Code Aurora Forum, hosted by The Linux Foundation.

[PATCH 1/2] scsi: ufs: Add support for host assisted background operations

[Sujit Reddy Thumma]

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@codeaurora.org>
---
 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))
+				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.

Re: [PATCH 1/2] scsi: ufs: Add support for host assisted background operations

[Santosh Y]

On Thu, Jun 13, 2013 at 7:50 PM, Sujit Reddy Thumma
<sthumma@codeaurora.org> 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@codeaurora.org>
> ---
>  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

Re: [PATCH 1/2] scsi: ufs: Add support for host assisted background operations

[Sujit Reddy Thumma]

On 6/26/2013 11:06 PM, Santosh Y wrote:
>> +/**
>> >   * 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.
>

According to the specification, the host should put in all measures to 
ensure that the device doesn't enter into URGENT_BKOPS need because the 
device may not operate optimally in that case. If your sequence is used 
then we expect a case where URGENT_BKOPS is needed if the runtime PM is 
disabled or prohibited soon after startup.

We wouldn't want to disable auto bkops by default without knowing that 
the runtime PM is enabled, since the device/host/software idleness is 
determined by runtime PM operation as explained in the commit text.

-- 
Regards,
Sujit

[PATCH 2/2] scsi: ufs: Add runtime PM helpers for UFS host driver

[Sujit Reddy Thumma]

Add runtime PM helpers to suspend/resume the UFS controller
device at runtime.

Change-Id: I70b8f7ab9c5a806234701a5eb7735910ee6d052e
Signed-off-by: Sujit Reddy Thumma <sthumma@codeaurora.org>
---
 drivers/scsi/ufs/ufshcd-pci.c    |   60 ++++++++++++++++++++++++++++++++++----
 drivers/scsi/ufs/ufshcd-pltfrm.c |   41 ++++++++++++++++++++++++++
 2 files changed, 95 insertions(+), 6 deletions(-)

diff --git a/drivers/scsi/ufs/ufshcd-pci.c b/drivers/scsi/ufs/ufshcd-pci.c
index 5cb1d75..589a64e 100644
--- a/drivers/scsi/ufs/ufshcd-pci.c
+++ b/drivers/scsi/ufs/ufshcd-pci.c
@@ -35,6 +35,7 @@
 
 #include "ufshcd.h"
 #include <linux/pci.h>
+#include <linux/pm_runtime.h>
 
 #ifdef CONFIG_PM
 /**
@@ -44,7 +45,7 @@
  *
  * Returns -ENOSYS
  */
-static int ufshcd_pci_suspend(struct pci_dev *pdev, pm_message_t state)
+static int ufshcd_pci_suspend(struct device *dev)
 {
 	/*
 	 * TODO:
@@ -61,7 +62,7 @@ static int ufshcd_pci_suspend(struct pci_dev *pdev, pm_message_t state)
  *
  * Returns -ENOSYS
  */
-static int ufshcd_pci_resume(struct pci_dev *pdev)
+static int ufshcd_pci_resume(struct device *dev)
 {
 	/*
 	 * TODO:
@@ -71,8 +72,48 @@ static int ufshcd_pci_resume(struct pci_dev *pdev)
 
 	return -ENOSYS;
 }
+#else
+#define ufshcd_pci_suspend	NULL
+#define ufshcd_pci_resume	NULL
 #endif /* CONFIG_PM */
 
+#ifdef CONFIG_PM_RUNTIME
+static int ufshcd_pci_runtime_suspend(struct device *dev)
+{
+	struct pci_dev *pdev = container_of(dev, struct pci_dev, dev);
+	struct ufs_hba *hba = pci_get_drvdata(pdev);
+
+	if (!hba)
+		return 0;
+
+	return ufshcd_runtime_suspend(hba);
+}
+static int ufshcd_pci_runtime_resume(struct device *dev)
+{
+	struct pci_dev *pdev = container_of(dev, struct pci_dev, dev);
+	struct ufs_hba *hba = pci_get_drvdata(pdev);
+
+	if (!hba)
+		return 0;
+
+	return ufshcd_runtime_resume(hba);
+}
+static int ufshcd_pci_runtime_idle(struct device *dev)
+{
+	struct pci_dev *pdev = container_of(dev, struct pci_dev, dev);
+	struct ufs_hba *hba = pci_get_drvdata(pdev);
+
+	if (!hba)
+		return 0;
+
+	return ufshcd_runtime_idle(hba);
+}
+#else /* !CONFIG_PM_RUNTIME */
+#define ufshcd_pci_runtime_suspend	NULL
+#define ufshcd_pci_runtime_resume	NULL
+#define ufshcd_pci_runtime_idle	NULL
+#endif /* CONFIG_PM_RUNTIME */
+
 /**
  * ufshcd_pci_shutdown - main function to put the controller in reset state
  * @pdev: pointer to PCI device handle
@@ -183,6 +224,14 @@ out_error:
 	return err;
 }
 
+static const struct dev_pm_ops ufshcd_pci_pm_ops = {
+	.suspend	= ufshcd_pci_suspend,
+	.resume		= ufshcd_pci_resume,
+	.runtime_suspend = ufshcd_pci_runtime_suspend,
+	.runtime_resume  = ufshcd_pci_runtime_resume,
+	.runtime_idle    = ufshcd_pci_runtime_idle,
+};
+
 static DEFINE_PCI_DEVICE_TABLE(ufshcd_pci_tbl) = {
 	{ PCI_VENDOR_ID_SAMSUNG, 0xC00C, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
 	{ }	/* terminate list */
@@ -196,10 +245,9 @@ static struct pci_driver ufshcd_pci_driver = {
 	.probe = ufshcd_pci_probe,
 	.remove = ufshcd_pci_remove,
 	.shutdown = ufshcd_pci_shutdown,
-#ifdef CONFIG_PM
-	.suspend = ufshcd_pci_suspend,
-	.resume = ufshcd_pci_resume,
-#endif
+	.driver = {
+		.pm = &ufshcd_pci_pm_ops
+	},
 };
 
 module_pci_driver(ufshcd_pci_driver);
diff --git a/drivers/scsi/ufs/ufshcd-pltfrm.c b/drivers/scsi/ufs/ufshcd-pltfrm.c
index 3db2ee1..a7054dd 100644
--- a/drivers/scsi/ufs/ufshcd-pltfrm.c
+++ b/drivers/scsi/ufs/ufshcd-pltfrm.c
@@ -35,6 +35,7 @@
 
 #include "ufshcd.h"
 #include <linux/platform_device.h>
+#include <linux/pm_runtime.h>
 
 #ifdef CONFIG_PM
 /**
@@ -86,6 +87,43 @@ static int ufshcd_pltfrm_resume(struct device *dev)
 #define ufshcd_pltfrm_resume	NULL
 #endif
 
+#ifdef CONFIG_PM_RUNTIME
+static int ufshcd_pltfrm_runtime_suspend(struct device *dev)
+{
+	struct platform_device *pdev = to_platform_device(dev);
+	struct ufs_hba *hba =  platform_get_drvdata(pdev);
+
+	if (!hba)
+		return 0;
+
+	return ufshcd_runtime_suspend(hba);
+}
+static int ufshcd_pltfrm_runtime_resume(struct device *dev)
+{
+	struct platform_device *pdev = to_platform_device(dev);
+	struct ufs_hba *hba =  platform_get_drvdata(pdev);
+
+	if (!hba)
+		return 0;
+
+	return ufshcd_runtime_resume(hba);
+}
+static int ufshcd_pltfrm_runtime_idle(struct device *dev)
+{
+	struct platform_device *pdev = to_platform_device(dev);
+	struct ufs_hba *hba =  platform_get_drvdata(pdev);
+
+	if (!hba)
+		return 0;
+
+	return ufshcd_runtime_idle(hba);
+}
+#else /* !CONFIG_PM_RUNTIME */
+#define ufshcd_pltfrm_runtime_suspend	NULL
+#define ufshcd_pltfrm_runtime_resume	NULL
+#define ufshcd_pltfrm_runtime_idle	NULL
+#endif /* CONFIG_PM_RUNTIME */
+
 /**
  * ufshcd_pltfrm_probe - probe routine of the driver
  * @pdev: pointer to Platform device handle
@@ -194,6 +232,9 @@ static const struct of_device_id ufs_of_match[] = {
 static const struct dev_pm_ops ufshcd_dev_pm_ops = {
 	.suspend	= ufshcd_pltfrm_suspend,
 	.resume		= ufshcd_pltfrm_resume,
+	.runtime_suspend = ufshcd_pltfrm_runtime_suspend,
+	.runtime_resume  = ufshcd_pltfrm_runtime_resume,
+	.runtime_idle    = ufshcd_pltfrm_runtime_idle,
 };
 
 static struct platform_driver ufshcd_pltfrm_driver = {
-- 
QUALCOMM INDIA, on behalf of Qualcomm Innovation Center, Inc. is a member
of Code Aurora Forum, hosted by The Linux Foundation.