Skip to contentSkip to conversation

ufs: core: mcq: Add ufshcd_abort() and error handler support in MCQ mode

PATCH Superseded Bao D. Nguyen 4 participants 18 messages Apr 17, 2023 – May 4, 2023

Subsystems (4)

v2 of 7 Superseded Latest is v7 →

lore
Share & tools
lore
#0 lore raw

v2 cover ufs: core: mcq: Add ufshcd_abort() and error handler support in MCQ mode

This patch series enable support for ufshcd_abort() and error handler in MCQ mode. The first 3 patches are for supporting ufshcd_abort().
The 4th and 5th patches are for supporting error handler.

Bao D. Nguyen (5):
ufs: mcq: Add supporting functions for mcq abort
ufs: mcq: Add support for clean up mcq resources
ufs: mcq: Added ufshcd_mcq_abort()
ufs: mcq: Use ufshcd_mcq_poll_cqe_lock() in mcq mode
ufs: core: Add error handling for MCQ mode
---
v1->v2:
patch #1: Addressed Powen's comment. Replaced read_poll_timeout() with ufshcd_mcq_poll_register(). The function read_poll_timeout() may sleep while the caller is holding a spin_lock(). Poll the registers in a tight loop instead.
---

 drivers/ufs/core/ufs-mcq.c     | 258 ++++++++++++++++++++++++++++++++++++++++-
 drivers/ufs/core/ufshcd-priv.h |  15 ++-
 drivers/ufs/core/ufshcd.c      | 140 ++++++++++++++++++----
 drivers/ufs/host/ufs-qcom.c    |   2 +-
 include/ufs/ufshcd.h           |   2 +-
 include/ufs/ufshci.h           |  17 +++
 6 files changed, 404 insertions(+), 30 deletions(-)
Signature · 1 line
2.7.4
#1 lore raw

PATCH v2 1/5 ufs: mcq: Add supporting functions for mcq abort

Add supporting functions to handle ufs abort in mcq mode.

---
 drivers/ufs/core/ufs-mcq.c     | 190 +++++++++++++++++++++++++++++++++++++++++
 drivers/ufs/core/ufshcd-priv.h |  10 +++
 drivers/ufs/core/ufshcd.c      |   2 -
 include/ufs/ufshci.h           |  17 ++++
 4 files changed, 217 insertions(+), 2 deletions(-)
drivers/ufs/core/ufs-mcq.c +190 -0
index 31df052..a463674 100644
@@ -12,6 +12,9 @@
 #include <linux/module.h>
 #include <linux/platform_device.h>
 #include "ufshcd-priv.h"
+#include <linux/delay.h>
+#include <scsi/scsi_cmnd.h>
+#include <linux/bitfield.h>
 
 #define MAX_QUEUE_SUP GENMASK(7, 0)
 #define UFS_MCQ_MIN_RW_QUEUES 2
@@ -27,6 +30,9 @@
 #define MCQ_ENTRY_SIZE_IN_DWORD	8
 #define CQE_UCD_BA GENMASK_ULL(63, 7)
 
+/* Max mcq register polling time in milisecond unit */
+#define MCQ_POLL_MS 500
+
 static int rw_queue_count_set(const char *val, const struct kernel_param *kp)
 {
 	return param_set_uint_minmax(val, kp, UFS_MCQ_MIN_RW_QUEUES,
@@ -429,3 +435,187 @@ int ufshcd_mcq_init(struct ufs_hba *hba)
 	host->host_tagset = 1;
 	return 0;
 }
+
+static int ufshcd_mcq_poll_register(void __iomem *reg, u32 mask,
+				u32 val, unsigned long timeout_ms)
+{
+	unsigned long timeout = jiffies + msecs_to_jiffies(timeout_ms);
+	int err = 0;
+
+	/* ignore bits that we don't intend to wait on */
+	val = val & mask;
+
+	while ((readl(reg) & mask) != val) {
+		udelay(20);
+		if (time_after(jiffies, timeout)) {
+			err = -ETIMEDOUT;
+			break;
+		}
+	}
+
+	return err;
+}
+
+static int ufshcd_mcq_sq_stop(struct ufs_hba *hba, struct ufs_hw_queue *hwq)
+{
+	void __iomem *reg;
+	u32 i = hwq->id;
+	int err;
+
+	writel(SQ_STOP, mcq_opr_base(hba, OPR_SQD, i) + REG_SQRTC);
+	reg = mcq_opr_base(hba, OPR_SQD, i) + REG_SQRTS;
+	err = ufshcd_mcq_poll_register(reg, SQ_STS, SQ_STS, MCQ_POLL_MS);
+	if (err)
+		dev_err(hba->dev, "%s: failed. hwq-id=%d, err=%d\n",
+			__func__, i, err);
+	return err;
+}
+
+static int ufshcd_mcq_sq_start(struct ufs_hba *hba, struct ufs_hw_queue *hwq)
+{
+	void __iomem *reg;
+	u32 i = hwq->id;
+	int err;
+
+	writel(SQ_START, mcq_opr_base(hba, OPR_SQD, i) + REG_SQRTC);
+	reg = mcq_opr_base(hba, OPR_SQD, i) + REG_SQRTS;
+	err = ufshcd_mcq_poll_register(reg, SQ_STS, 0, MCQ_POLL_MS);
+	if (err)
+		dev_err(hba->dev, "%s: failed. hwq-id=%d, err=%d\n",
+			__func__, i, err);
+	return err;
+}
+
+/**
+ * ufshcd_mcq_sq_cleanup - Clean up Submission Queue resources
+ * associated with the pending command.
+ * @hba - per adapter instance.
+ * @task_tag - The command's task tag.
+ * @result - Result of the Clean up operation.
+ *
+ * Returns 0 and result on completion. Returns error code if
+ * the operation fails.
+ */
+int ufshcd_mcq_sq_cleanup(struct ufs_hba *hba, int task_tag, int *result)
+{
+	struct ufshcd_lrb *lrbp = &hba->lrb[task_tag];
+	struct scsi_cmnd *cmd = lrbp->cmd;
+	struct ufs_hw_queue *hwq;
+	void __iomem *reg, *opr_sqd_base;
+	u32 nexus, i;
+	int err;
+
+	if (task_tag != hba->nutrs - UFSHCD_NUM_RESERVED) {
+		if (!cmd)
+			return FAILED;
+		hwq = ufshcd_mcq_req_to_hwq(hba, scsi_cmd_to_rq(cmd));
+	} else {
+		hwq = hba->dev_cmd_queue;
+	}
+
+	i = hwq->id;
+
+	spin_lock(&hwq->sq_lock);
+
+	/* stop the SQ fetching before working on it */
+	err = ufshcd_mcq_sq_stop(hba, hwq);
+	if (err)
+		goto unlock;
+
+	/* SQCTI = EXT_IID, IID, LUN, Task Tag */
+	nexus = lrbp->lun << 8 | task_tag;
+	opr_sqd_base = mcq_opr_base(hba, OPR_SQD, i);
+	writel(nexus, opr_sqd_base + REG_SQCTI);
+
+	/* SQRTCy.ICU = 1 */
+	writel(SQ_ICU, opr_sqd_base + REG_SQRTC);
+
+	/* Poll SQRTSy.CUS = 1. Return result from SQRTSy.RTC */
+	reg = opr_sqd_base + REG_SQRTS;
+	err = ufshcd_mcq_poll_register(reg, SQ_CUS, SQ_CUS, MCQ_POLL_MS);
+	if (err)
+		dev_err(hba->dev, "%s: failed. hwq=%d, lun=0x%x, tag=%d\n",
+			__func__, i, lrbp->lun, task_tag);
+
+	*result = FIELD_GET(SQ_ICU_ERR_CODE_MASK, readl(reg));
+
+	if (ufshcd_mcq_sq_start(hba, hwq))
+		err = FAILED;
+
+unlock:
+	spin_unlock(&hwq->sq_lock);
+	return err;
+}
+
+static u64 ufshcd_mcq_get_cmd_desc_addr(struct ufs_hba *hba,
+					int task_tag)
+{
+	struct ufshcd_lrb *lrbp = &hba->lrb[task_tag];
+	__le32 hi = lrbp->utr_descriptor_ptr->command_desc_base_addr_hi;
+	__le32 lo = lrbp->utr_descriptor_ptr->command_desc_base_addr_lo;
+
+	return le64_to_cpu((__le64)hi << 32 | lo);
+}
+
+/**
+ * ufshcd_mcq_nullify_cmd - Nullify utrd. Host controller does not fetch
+ * transfer with Command Type = 0xF. post the Completion Queue with OCS=ABORTED.
+ * @hba - per adapter instance.
+ * @hwq - Hardware Queue of the nullified utrd.
+ */
+static void ufshcd_mcq_nullify_cmd(struct ufs_hba *hba, struct ufs_hw_queue *hwq)
+{
+	struct utp_transfer_req_desc *utrd;
+	u32 dword_0;
+
+	utrd = (struct utp_transfer_req_desc *)(hwq->sqe_base_addr +
+			hwq->id * sizeof(struct utp_transfer_req_desc));
+	dword_0 = le32_to_cpu(utrd->header.dword_0);
+	dword_0 &= ~UPIU_COMMAND_TYPE_MASK;
+	dword_0 |= FIELD_PREP(UPIU_COMMAND_TYPE_MASK, 0xF);
+	utrd->header.dword_0 = cpu_to_le32(dword_0);
+}
+
+/**
+ * ufshcd_mcq_sqe_search - Search for the cmd in the Submission Queue (SQ)
+ * @hba - per adapter instance.
+ * @hwq - Hardware Queue to be searched.
+ * @task_tag - The command's task tag.
+ *
+ * Returns true if the SQE containing the command is present in the SQ
+ * (not fetched by the controller); returns false if the SQE is not in the SQ.
+ */
+static bool ufshcd_mcq_sqe_search(struct ufs_hba *hba,
+				struct ufs_hw_queue *hwq, int task_tag)
+{
+	struct utp_transfer_req_desc *utrd;
+	u32 mask = hwq->max_entries - 1;
+	bool ret = false;
+	u64 addr, match;
+	u32 sq_head_slot;
+
+	spin_lock(&hwq->sq_lock);
+
+	ufshcd_mcq_sq_stop(hba, hwq);
+	sq_head_slot = ufshcd_mcq_get_sq_head_slot(hwq);
+	if (sq_head_slot == hwq->sq_tail_slot)
+		goto out;
+
+	addr = ufshcd_mcq_get_cmd_desc_addr(hba, task_tag);
+	while (sq_head_slot != hwq->sq_tail_slot) {
+		utrd = (struct utp_transfer_req_desc *)(hwq->sqe_base_addr +
+				sq_head_slot * sizeof(struct utp_transfer_req_desc));
+		match = le64_to_cpu((__le64)utrd->command_desc_base_addr_hi << 32 |
+				utrd->command_desc_base_addr_lo) & CQE_UCD_BA;
+		if (addr == match) {
+			ret = true;
+			goto out;
+		}
+		sq_head_slot = (sq_head_slot + 1) & mask;
+	}
+
+out:
+	ufshcd_mcq_sq_start(hba, hwq);
+	spin_unlock(&hwq->sq_lock);
+	return ret;
+}
drivers/ufs/core/ufshcd-priv.h +10 -0
index 529f850..1a40cf7 100644
@@ -78,6 +78,8 @@ struct ufs_hw_queue *ufshcd_mcq_req_to_hwq(struct ufs_hba *hba,
 unsigned long ufshcd_mcq_poll_cqe_lock(struct ufs_hba *hba,
 				       struct ufs_hw_queue *hwq);
 
+int ufshcd_mcq_sq_cleanup(struct ufs_hba *hba, int task_tag, int *result);
+
 #define UFSHCD_MCQ_IO_QUEUE_OFFSET	1
 #define SD_ASCII_STD true
 #define SD_RAW false
@@ -403,4 +405,12 @@ static inline struct cq_entry *ufshcd_mcq_cur_cqe(struct ufs_hw_queue *q)
 
 	return cqe + q->cq_head_slot;
 }
+
+static inline u32 ufshcd_mcq_get_sq_head_slot(struct ufs_hw_queue *q)
+{
+	u32 val = readl(q->mcq_sq_head);
+
+	return val / sizeof(struct utp_transfer_req_desc);
+}
+
 #endif /* _UFSHCD_PRIV_H_ */
drivers/ufs/core/ufshcd.c +0 -2
index 35a3bd9..808387c 100644
@@ -56,7 +56,6 @@
 #define NOP_OUT_RETRIES    10
 /* Timeout after 50 msecs if NOP OUT hangs without response */
 #define NOP_OUT_TIMEOUT    50 /* msecs */
-
 /* Query request retries */
 #define QUERY_REQ_RETRIES 3
 /* Query request timeout */
@@ -173,7 +172,6 @@ EXPORT_SYMBOL_GPL(ufshcd_dump_regs);
 enum {
 	UFSHCD_MAX_CHANNEL	= 0,
 	UFSHCD_MAX_ID		= 1,
-	UFSHCD_NUM_RESERVED	= 1,
 	UFSHCD_CMD_PER_LUN	= 32 - UFSHCD_NUM_RESERVED,
 	UFSHCD_CAN_QUEUE	= 32 - UFSHCD_NUM_RESERVED,
 };
include/ufs/ufshci.h +17 -0
index 11424bb..ceb8664 100644
@@ -99,6 +99,9 @@ enum {
 enum {
 	REG_SQHP		= 0x0,
 	REG_SQTP		= 0x4,
+	REG_SQRTC		= 0x8,
+	REG_SQCTI		= 0xC,
+	REG_SQRTS		= 0x10,
 };
 
 enum {
@@ -111,12 +114,26 @@ enum {
 	REG_CQIE		= 0x4,
 };
 
+enum {
+	SQ_START		= 0x0,
+	SQ_STOP			= 0x1,
+	SQ_ICU			= 0x2,
+};
+
+enum {
+	SQ_STS			= 0x1,
+	SQ_CUS			= 0x2,
+};
+
+#define SQ_ICU_ERR_CODE_MASK		GENMASK(7, 4)
+#define UPIU_COMMAND_TYPE_MASK		GENMASK(31, 28)
 #define UFS_MASK(mask, offset)		((mask) << (offset))
 
 /* UFS Version 08h */
 #define MINOR_VERSION_NUM_MASK		UFS_MASK(0xFFFF, 0)
 #define MAJOR_VERSION_NUM_MASK		UFS_MASK(0xFFFF, 16)
 
+#define UFSHCD_NUM_RESERVED	1
 /*
  * Controller UFSHCI version
  * - 2.x and newer use the following scheme:
Signature · 1 line
2.7.4
#2 lore raw

Re: [PATCH v2 1/5] ufs: mcq: Add supporting functions for mcq abort

Quoted 1 line · Bao D. Nguyen

+/* Max mcq register polling time in milisecond unit */

A nit: please change "millisecond unit" into "milliseconds".

drivers/ufs/core/ufs-mcq.c int ufshcd_mcq_init(struct ufs_hba *hba) · line 448

Quoted 10 lines
drivers/ufs/core/ufs-mcq.c +10 -0
+static int ufshcd_mcq_poll_register(void __iomem *reg, u32 mask,
+				u32 val, unsigned long timeout_ms)
+{
+	unsigned long timeout = jiffies + msecs_to_jiffies(timeout_ms);
+	int err = 0;
+
+	/* ignore bits that we don't intend to wait on */
+	val = val & mask;
+
+	while ((readl(reg) & mask) != val) {

& has a higher precedence than != so one pair of parentheses can be left out.

drivers/ufs/core/ufs-mcq.c int ufshcd_mcq_init(struct ufs_hba *hba) · line 450

Quoted 2 lines
drivers/ufs/core/ufs-mcq.c +2 -0
+		udelay(20);
+		if (time_after(jiffies, timeout)) {

Please use time_is_before_jiffies() instead of time_after(jiffies, ...).

drivers/ufs/core/ufs-mcq.c int ufshcd_mcq_init(struct ufs_hba *hba) · line 457

Quoted 7 lines
drivers/ufs/core/ufs-mcq.c +7 -0
+			err = -ETIMEDOUT;
+			break;
+		}
+	}
+
+	return err;
+}

Please remove the variable 'err' and return the return value directly.

drivers/ufs/core/ufs-mcq.c int ufshcd_mcq_init(struct ufs_hba *hba) · line 462

Quoted 5 lines
drivers/ufs/core/ufs-mcq.c +5 -0
+
+static int ufshcd_mcq_sq_stop(struct ufs_hba *hba, struct ufs_hw_queue *hwq)
+{
+	void __iomem *reg;
+	u32 i = hwq->id;

Please use another variable name than 'i' for a hardware queue ID ('id'?).

Review

Quoted 1 line
(quoted diff) +1 -0
+	u32 i = hwq->id;

Same comment here.

Quoted 2 lines

+/**
+ * ufshcd_mcq_sq_cleanup - Clean up Submission Queue resources

A nit: please use lower case text for "submission queue" and also in the comments below ("Clean up" -> "clean up").

drivers/ufs/core/ufs-mcq.c int ufshcd_mcq_init(struct ufs_hba *hba) · line 523

Quoted 6 lines
drivers/ufs/core/ufs-mcq.c +6 -0
+	spin_lock(&hwq->sq_lock);
+
+	/* stop the SQ fetching before working on it */
+	err = ufshcd_mcq_sq_stop(hba, hwq);
+	if (err)
+		goto unlock;

No spin locks around delay loops please. Is there anything that prevents to change sq_lock from a spin lock into a mutex?

drivers/ufs/core/ufs-mcq.c int ufshcd_mcq_init(struct ufs_hba *hba) · line 558

Quoted 9 lines
drivers/ufs/core/ufs-mcq.c +9 -0
+static u64 ufshcd_mcq_get_cmd_desc_addr(struct ufs_hba *hba,
+					int task_tag)
+{
+	struct ufshcd_lrb *lrbp = &hba->lrb[task_tag];
+	__le32 hi = lrbp->utr_descriptor_ptr->command_desc_base_addr_hi;
+	__le32 lo = lrbp->utr_descriptor_ptr->command_desc_base_addr_lo;
+
+	return le64_to_cpu((__le64)hi << 32 | lo);
+}

Please add a new patch at the head of this series that modifies struct utp_transfer_req_desc such that command_desc_base_addr_lo and command_desc_base_addr_hi are combined into a single __le64 variable.

drivers/ufs/core/ufs-mcq.c int ufshcd_mcq_init(struct ufs_hba *hba) · line 572

Quoted 13 lines
drivers/ufs/core/ufs-mcq.c +13 -0
+/**
+ * ufshcd_mcq_nullify_cmd - Nullify utrd. Host controller does not fetch
+ * transfer with Command Type = 0xF. post the Completion Queue with OCS=ABORTED.
+ * @hba - per adapter instance.
+ * @hwq - Hardware Queue of the nullified utrd.
+ */
+static void ufshcd_mcq_nullify_cmd(struct ufs_hba *hba, struct ufs_hw_queue *hwq)
+{
+	struct utp_transfer_req_desc *utrd;
+	u32 dword_0;
+
+	utrd = (struct utp_transfer_req_desc *)(hwq->sqe_base_addr +
+			hwq->id * sizeof(struct utp_transfer_req_desc));

Please double check this function. It has "cmd" in the function name but none of the arguments passed to this function allows to uniquely identify a command. Is an argument perhaps missing from this function?

Additionally, hwq->sqe_base_addr points to an array of SQE entries. I do not understand why hwq->id * sizeof(struct utp_transfer_req_desc) is added to that base address. Please clarify.

Review

Quoted 2 lines
(quoted diff) +2 -0
+		utrd = (struct utp_transfer_req_desc *)(hwq->sqe_base_addr +
+				sq_head_slot * sizeof(struct utp_transfer_req_desc));

hwq->sqe_base_addr already has type struct utp_transfer_req_desc * so the " * sizeof(struct utp_transfer_req_desc)" part looks wrong to me.

drivers/ufs/core/ufshcd.c line 61

Quoted 12 lines
drivers/ufs/core/ufshcd.c +0 -1
index 35a3bd9..808387c 100644
@@ -56,7 +56,6 @@
  #define NOP_OUT_RETRIES    10
  /* Timeout after 50 msecs if NOP OUT hangs without response */
  #define NOP_OUT_TIMEOUT    50 /* msecs */
-
  /* Query request retries */
  #define QUERY_REQ_RETRIES 3
  /* Query request timeout */

Is the above change really necessary?

drivers/ufs/core/ufshcd.c EXPORT_SYMBOL_GPL(ufshcd_dump_regs); · line 177

Quoted 8 lines
drivers/ufs/core/ufshcd.c +0 -1
@@ -173,7 +172,6 @@ EXPORT_SYMBOL_GPL(ufshcd_dump_regs);
  enum {
  	UFSHCD_MAX_CHANNEL	= 0,
  	UFSHCD_MAX_ID		= 1,
-	UFSHCD_NUM_RESERVED	= 1,
  	UFSHCD_CMD_PER_LUN	= 32 - UFSHCD_NUM_RESERVED,
  	UFSHCD_CAN_QUEUE	= 32 - UFSHCD_NUM_RESERVED,
  };

Same question here - is this change really necessary?

Thanks,

Bart.

#3 lore raw

Re: [PATCH v2 1/5] ufs: mcq: Add supporting functions for mcq abort

Hi Bart,
Thank you so much for a detailed code review.

Quoted 4 lines · Bart Van Assche
Quoted 1 line · Bao D. Nguyen

+/* Max mcq register polling time in milisecond unit */

A nit: please change "millisecond unit" into "milliseconds".

Yes I will change.

Quoted 13 lines

drivers/ufs/core/ufs-mcq.c int ufshcd_mcq_init(struct ufs_hba *hba) · line 448

Quoted 11 lines
drivers/ufs/core/ufs-mcq.c +10 -0
+static int ufshcd_mcq_poll_register(void __iomem *reg, u32 mask,
+                u32 val, unsigned long timeout_ms)
+{
+    unsigned long timeout = jiffies + msecs_to_jiffies(timeout_ms);
+    int err = 0;
+
+    /* ignore bits that we don't intend to wait on */
+    val = val & mask;
+
+    while ((readl(reg) & mask) != val) {

& has a higher precedence than != so one pair of parentheses can be left out.

I think it is is actually the other way. & has lower precedence than !=. Please correct me if I am wrong.

Quoted 5 lines
Quoted 3 lines

+        udelay(20);
+        if (time_after(jiffies, timeout)) {

Please use time_is_before_jiffies() instead of time_after(jiffies, ...).

time_is_before_jiffies() seems to be defined as time_after(). Could you please explain the benefits to choose one over the other?

Quoted 10 lines

drivers/ufs/core/ufs-mcq.c int ufshcd_mcq_init(struct ufs_hba *hba) · line 457

Quoted 8 lines

+            err = -ETIMEDOUT;
+            break;
+        }
+    }

drivers/ufs/core/ufs-mcq.c +3 -0
+
+    return err;
+}

Please remove the variable 'err' and return the return value directly.

Yes I will change.

Quoted 8 lines
Quoted 6 lines
(quoted diff) +2 -0
+
+static int ufshcd_mcq_sq_stop(struct ufs_hba *hba, struct 

ufs_hw_queue *hwq)
+{
+    void __iomem *reg;
+    u32 i = hwq->id;

Please use another variable name than 'i' for a hardware queue ID ('id'?).

Yes I will change.

Quoted 4 lines
Quoted 2 lines

+    u32 i = hwq->id;

Same comment here.

Yes I will change.

Quoted 5 lines
Quoted 3 lines

+/**
+ * ufshcd_mcq_sq_cleanup - Clean up Submission Queue resources

A nit: please use lower case text for "submission queue" and also in the comments below ("Clean up" -> "clean up").

The UFS Host Controller specification uses upper case for the Submission Queue and Completion Queue, so I tried to follow the the spec language. I don't have a preference. I will make the change.

Quoted 9 lines
Quoted 7 lines

+    spin_lock(&hwq->sq_lock);
+
+    /* stop the SQ fetching before working on it */ +    err = ufshcd_mcq_sq_stop(hba, hwq);
+    if (err)
+        goto unlock;

No spin locks around delay loops please. Is there anything that prevents to change sq_lock from a spin lock into a mutex?

This function can be called from multiple non-interrupt contexts. I needed to prevent concurrent accesses to the sq hw, so yes mutex would work better. I will change.

Quoted 12 lines

drivers/ufs/core/ufs-mcq.c int ufshcd_mcq_init(struct ufs_hba *hba) · line 558

Quoted 10 lines
drivers/ufs/core/ufs-mcq.c +9 -0
+static u64 ufshcd_mcq_get_cmd_desc_addr(struct ufs_hba *hba,
+                    int task_tag)
+{
+    struct ufshcd_lrb *lrbp = &hba->lrb[task_tag];
+    __le32 hi = lrbp->utr_descriptor_ptr->command_desc_base_addr_hi;
+    __le32 lo = lrbp->utr_descriptor_ptr->command_desc_base_addr_lo;
+
+    return le64_to_cpu((__le64)hi << 32 | lo);
+}

Please add a new patch at the head of this series that modifies struct utp_transfer_req_desc such that command_desc_base_addr_lo and command_desc_base_addr_hi are combined into a single __le64 variable.

Yes, I will add this as a separate patch.

Quoted 10 lines
Quoted 10 lines

+/**
+ * ufshcd_mcq_nullify_cmd - Nullify utrd. Host controller does not fetch
+ * transfer with Command Type = 0xF. post the Completion Queue with OCS=ABORTED.
+ * @hba - per adapter instance.
+ * @hwq - Hardware Queue of the nullified utrd.
+ */
+static void ufshcd_mcq_nullify_cmd(struct ufs_hba *hba, struct ufs_hw_queue *hwq)

Quoted 8 lines

drivers/ufs/core/ufs-mcq.c int ufshcd_mcq_init(struct ufs_hba *hba) · line 572

Quoted 6 lines
drivers/ufs/core/ufs-mcq.c +6 -0
+{
+    struct utp_transfer_req_desc *utrd;
+    u32 dword_0;
+
+    utrd = (struct utp_transfer_req_desc *)(hwq->sqe_base_addr +
+            hwq->id * sizeof(struct utp_transfer_req_desc));

Please double check this function. It has "cmd" in the function name but none of the arguments passed to this function allows to uniquely identify a command. Is an argument perhaps missing from this function?

Yes, I will make the correction to this function and rename it to ufshcd_mcq_nullify_sqe()

Quoted 6 lines

Additionally, hwq->sqe_base_addr points to an array of SQE entries. I do not understand why hwq->id * sizeof(struct utp_transfer_req_desc) is added to that base address. Please clarify. >

Quoted 2 lines

+        utrd = (struct utp_transfer_req_desc *)(hwq->sqe_base_addr + +                sq_head_slot * sizeof(struct utp_transfer_req_desc));

hwq->sqe_base_addr already has type struct utp_transfer_req_desc * so the " * sizeof(struct utp_transfer_req_desc)" part looks wrong to me.

Yes, I will correct this.

Quoted 15 lines

drivers/ufs/core/ufshcd.c line 61

Quoted 13 lines
drivers/ufs/core/ufshcd.c +0 -1
index 35a3bd9..808387c 100644
@@ -56,7 +56,6 @@
   #define NOP_OUT_RETRIES    10
   /* Timeout after 50 msecs if NOP OUT hangs without response */
   #define NOP_OUT_TIMEOUT    50 /* msecs */
-
   /* Query request retries */
   #define QUERY_REQ_RETRIES 3
   /* Query request timeout */

Is the above change really necessary?

The blank line was removed by mistake. I will put it back.

Quoted 10 lines

drivers/ufs/core/ufshcd.c EXPORT_SYMBOL_GPL(ufshcd_dump_regs); · line 177

Quoted 8 lines
drivers/ufs/core/ufshcd.c +0 -1
@@ -173,7 +172,6 @@ EXPORT_SYMBOL_GPL(ufshcd_dump_regs);
   enum {
       UFSHCD_MAX_CHANNEL    = 0,
       UFSHCD_MAX_ID        = 1,
-    UFSHCD_NUM_RESERVED    = 1,
       UFSHCD_CMD_PER_LUN    = 32 - UFSHCD_NUM_RESERVED,
       UFSHCD_CAN_QUEUE    = 32 - UFSHCD_NUM_RESERVED,
   };

Same question here - is this change really necessary?

I am moving the definition of UFSHCD_NUM_RESERVED to include/ufs/ufshci.h file so that I can access it from /core/ufs-mcq.c

Quoted 3 lines

Thanks,

Bart.

#4 lore raw

PATCH v2 2/5 ufs: mcq: Add support for clean up mcq resources

In reply to Bao D. Nguyen

Update ufshcd_clear_cmds() to clean up the mcq resources similar to the function ufshcd_utrl_clear() does for sdb mode.

Update ufshcd_try_to_abort_task() to support mcq mode so that this function can be invoked in either mcq or sdb mode.

---
 drivers/ufs/core/ufshcd.c | 45 +++++++++++++++++++++++++++++++++++++++------
 1 file changed, 39 insertions(+), 6 deletions(-)
drivers/ufs/core/ufshcd.c +39 -6
index 808387c..ffccb91 100644
@@ -3007,10 +3007,28 @@ static int ufshcd_compose_dev_cmd(struct ufs_hba *hba,
  * @mask and wait until the controller confirms that these requests have been
  * cleared.
  */
-static int ufshcd_clear_cmds(struct ufs_hba *hba, u32 mask)
+static int ufshcd_clear_cmds(struct ufs_hba *hba, unsigned long mask)
 {
 	unsigned long flags;
+	int err, tag, result = FAILED;
 
+	if (is_mcq_enabled(hba)) {
+		/*
+		 * MCQ mode. Clean up the MCQ resources similar to
+		 * what the ufshcd_utrl_clear() does for SDB mode.
+		 */
+		for_each_set_bit(tag, &mask, hba->nutrs) {
+			err = ufshcd_mcq_sq_cleanup(hba, tag, &result);
+			if (err || result) {
+				dev_err(hba->dev, "%s: failed tag=%d. err=%d, result=%d\n",
+					__func__, tag, err, result);
+				return FAILED;
+			}
+		}
+		return 0;
+	}
+
+	/* Single Doorbell Mode */
 	/* clear outstanding transaction before retry */
 	spin_lock_irqsave(hba->host->host_lock, flags);
 	ufshcd_utrl_clear(hba, mask);
@@ -3110,7 +3128,7 @@ static int ufshcd_wait_for_dev_cmd(struct ufs_hba *hba,
 		err = -ETIMEDOUT;
 		dev_dbg(hba->dev, "%s: dev_cmd request timedout, tag %d\n",
 			__func__, lrbp->task_tag);
-		if (ufshcd_clear_cmds(hba, 1U << lrbp->task_tag) == 0) {
+		if (ufshcd_clear_cmds(hba, 1UL << lrbp->task_tag) == 0) {
 			/* successfully cleared the command, retry if needed */
 			err = -EAGAIN;
 			/*
@@ -7379,6 +7397,20 @@ static int ufshcd_try_to_abort_task(struct ufs_hba *hba, int tag)
 			 */
 			dev_err(hba->dev, "%s: cmd at tag %d not pending in the device.\n",
 				__func__, tag);
+			if (is_mcq_enabled(hba)) {
+				/* MCQ mode */
+				if (lrbp->cmd) {
+					/* sleep for max. 200us to stabilize */
+					usleep_range(100, 200);
+					continue;
+				}
+				/* command completed already */
+				dev_err(hba->dev, "%s: cmd at tag=%d is cleared.\n",
+					__func__, tag);
+				goto out;
+			}
+
+			/* Single Doorbell Mode */
 			reg = ufshcd_readl(hba, REG_UTP_TRANSFER_REQ_DOOR_BELL);
 			if (reg & (1 << tag)) {
 				/* sleep for max. 200us to stabilize */
@@ -7415,7 +7447,7 @@ static int ufshcd_try_to_abort_task(struct ufs_hba *hba, int tag)
 		goto out;
 	}
 
-	err = ufshcd_clear_cmds(hba, 1U << tag);
+	err = ufshcd_clear_cmds(hba, 1UL << tag);
 	if (err)
 		dev_err(hba->dev, "%s: Failed clearing cmd at tag %d, err %d\n",
 			__func__, tag, err);
@@ -7445,8 +7477,8 @@ static int ufshcd_abort(struct scsi_cmnd *cmd)
 
 	ufshcd_hold(hba, false);
 	reg = ufshcd_readl(hba, REG_UTP_TRANSFER_REQ_DOOR_BELL);
-	/* If command is already aborted/completed, return FAILED. */
-	if (!(test_bit(tag, &hba->outstanding_reqs))) {
+	if (!is_mcq_enabled(hba) && !(test_bit(tag, &hba->outstanding_reqs))) {
+		/* If command is already aborted/completed, return FAILED. */
 		dev_err(hba->dev,
 			"%s: cmd at tag %d already completed, outstanding=0x%lx, doorbell=0x%x\n",
 			__func__, tag, hba->outstanding_reqs, reg);
@@ -7475,7 +7507,8 @@ static int ufshcd_abort(struct scsi_cmnd *cmd)
 	}
 	hba->req_abort_count++;
 
-	if (!(reg & (1 << tag))) {
+	if (!is_mcq_enabled(hba) && !(reg & (1 << tag))) {
+		/* only execute this code in single doorbell mode */
 		dev_err(hba->dev,
 		"%s: cmd was completed, but without a notifying intr, tag = %d",
 		__func__, tag);
Signature · 1 line
2.7.4
#5 lore raw

Re: [PATCH v2 2/5] ufs: mcq: Add support for clean up mcq resources

drivers/ufs/core/ufshcd.c static int ufshcd_wait_for_dev_cmd(struct ufs_hba *hba, · line 3134

Quoted 9 lines · Bao D. Nguyen
drivers/ufs/core/ufshcd.c +1 -1
@@ -3110,7 +3128,7 @@ static int ufshcd_wait_for_dev_cmd(struct ufs_hba *hba,
  		err = -ETIMEDOUT;
  		dev_dbg(hba->dev, "%s: dev_cmd request timedout, tag %d\n",
  			__func__, lrbp->task_tag);
-		if (ufshcd_clear_cmds(hba, 1U << lrbp->task_tag) == 0) {
+		if (ufshcd_clear_cmds(hba, 1UL << lrbp->task_tag) == 0) {
  			/* successfully cleared the command, retry if needed */
  			err = -EAGAIN;
  			/*

Is this change necessary?

drivers/ufs/core/ufshcd.c static int ufshcd_try_to_abort_task(struct ufs_hba *hba, int tag) · line 7403

Quoted 8 lines
drivers/ufs/core/ufshcd.c +4 -0
@@ -7379,6 +7397,20 @@ static int ufshcd_try_to_abort_task(struct ufs_hba *hba, int tag)
  			 */
  			dev_err(hba->dev, "%s: cmd at tag %d not pending in the device.\n",
  				__func__, tag);
+			if (is_mcq_enabled(hba)) {
+				/* MCQ mode */
+				if (lrbp->cmd) {
+					/* sleep for max. 200us to stabilize */

What is being stabilized here? Please make this comment more clear.

drivers/ufs/core/ufshcd.c static int ufshcd_try_to_abort_task(struct ufs_hba *hba, int tag) · line 7411

Quoted 8 lines
drivers/ufs/core/ufshcd.c +8 -0
+					usleep_range(100, 200);
+					continue;
+				}
+				/* command completed already */
+				dev_err(hba->dev, "%s: cmd at tag=%d is cleared.\n",
+					__func__, tag);
+				goto out;
+			}

Please do not use lrbp->cmd to check whether or not a command has completed. See also my patch "scsi: ufs: Fix handling of lrbp->cmd".

drivers/ufs/core/ufshcd.c static int ufshcd_try_to_abort_task(struct ufs_hba *hba, int tag) · line 7453

Quoted 9 lines
drivers/ufs/core/ufshcd.c +1 -1
@@ -7415,7 +7447,7 @@ static int ufshcd_try_to_abort_task(struct ufs_hba *hba, int tag)
  		goto out;
  	}
 
-	err = ufshcd_clear_cmds(hba, 1U << tag);
+	err = ufshcd_clear_cmds(hba, 1UL << tag);
  	if (err)
  		dev_err(hba->dev, "%s: Failed clearing cmd at tag %d, err %d\n",
  			__func__, tag, err);

Is this change necessary?

drivers/ufs/core/ufshcd.c static int ufshcd_abort(struct scsi_cmnd *cmd) · line 7480

Quoted 2 lines
drivers/ufs/core/ufshcd.c +1 -1
-	if (!(test_bit(tag, &hba->outstanding_reqs))) {
+	if (!is_mcq_enabled(hba) && !(test_bit(tag, &hba->outstanding_reqs))) {

Please leave out one pair of superfluous parentheses from the above expression.

Thanks,

Bart.

#6 lore raw

Re: [PATCH v2 2/5] ufs: mcq: Add support for clean up mcq resources

Quoted 13 lines · Bart Van Assche
Quoted 10 lines · Bao D. Nguyen
drivers/ufs/core/ufshcd.c +1 -1
@@ -3110,7 +3128,7 @@ static int ufshcd_wait_for_dev_cmd(struct 
 ufs_hba *hba,
           err = -ETIMEDOUT;
           dev_dbg(hba->dev, "%s: dev_cmd request timedout, tag %d\n",
               __func__, lrbp->task_tag);
-        if (ufshcd_clear_cmds(hba, 1U << lrbp->task_tag) == 0) {
+        if (ufshcd_clear_cmds(hba, 1UL << lrbp->task_tag) == 0) {
               /* successfully cleared the command, retry if needed */
               err = -EAGAIN;

              /*

Is this change necessary?

My intention was to support tag greater than 31 and less than 64. The 1U << only works up to 32 bits.

Quoted 12 lines

drivers/ufs/core/ufshcd.c static int ufshcd_try_to_abort_task(struct · line 7404

Quoted 10 lines
drivers/ufs/core/ufshcd.c +4 -0
@@ -7379,6 +7397,20 @@ static int ufshcd_try_to_abort_task(struct 
 ufs_hba *hba, int tag)
                */
               dev_err(hba->dev, "%s: cmd at tag %d not pending in the device.\n",
                   __func__, tag);
+            if (is_mcq_enabled(hba)) {
+                /* MCQ mode */
+                if (lrbp->cmd) {
+                    /* sleep for max. 200us to stabilize */

What is being stabilized here? Please make this comment more clear.

This is to keep the same operation/timing as in SDB mode.

Quoted 11 lines

drivers/ufs/core/ufshcd.c static int ufshcd_try_to_abort_task(struct ufs_hba *hba, int tag) · line 7411

Quoted 9 lines
drivers/ufs/core/ufshcd.c +8 -0
+                    usleep_range(100, 200);
+                    continue;
+                }
+                /* command completed already */
+                dev_err(hba->dev, "%s: cmd at tag=%d is cleared.\n",
+                    __func__, tag);
+                goto out;
+            }

Please do not use lrbp->cmd to check whether or not a command has completed. See also my patch "scsi: ufs: Fix handling of lrbp->cmd".

I have been thinking how to replace lrbp->cmd, but could not find a good solution. Throughout this patch series, I am using lrbp->cmd as a way to find the pending command that is being aborted and clean up the resources associated with it. Any suggestions to achieve it? Thanks.

Quoted 12 lines

drivers/ufs/core/ufshcd.c static int ufshcd_try_to_abort_task(struct · line 7453

Quoted 10 lines
drivers/ufs/core/ufshcd.c +1 -1
@@ -7415,7 +7447,7 @@ static int ufshcd_try_to_abort_task(struct 
 ufs_hba *hba, int tag)
           goto out;
       }
-    err = ufshcd_clear_cmds(hba, 1U << tag);
+    err = ufshcd_clear_cmds(hba, 1UL << tag);
       if (err)
           dev_err(hba->dev, "%s: Failed clearing cmd at tag %d, err %d\n",
               __func__, tag, err);

Is this change necessary?

Same as above, I intended to support 64 > tag > 31

Quoted 6 lines
Quoted 4 lines

-    if (!(test_bit(tag, &hba->outstanding_reqs))) { +    if (!is_mcq_enabled(hba) && !(test_bit(tag, &hba->outstanding_reqs))) {

Please leave out one pair of superfluous parentheses from the above expression.

Yes, I will change.

Quoted 4 lines

Thanks,

Bart.

#7 lore raw

Re: [PATCH v2 2/5] ufs: mcq: Add support for clean up mcq resources

Quoted 13 lines · Bao D. Nguyen
Quoted 12 lines · Bart Van Assche

drivers/ufs/core/ufshcd.c static int ufshcd_wait_for_dev_cmd(struct ufs_hba *hba, · line 3134

Quoted 9 lines · Bao D. Nguyen
drivers/ufs/core/ufshcd.c +1 -1
@@ -3110,7 +3128,7 @@ static int ufshcd_wait_for_dev_cmd(struct ufs_hba *hba,
           err = -ETIMEDOUT;
           dev_dbg(hba->dev, "%s: dev_cmd request timedout, tag %d\n",
               __func__, lrbp->task_tag);
-        if (ufshcd_clear_cmds(hba, 1U << lrbp->task_tag) == 0) {
+        if (ufshcd_clear_cmds(hba, 1UL << lrbp->task_tag) == 0) {
               /* successfully cleared the command, retry if needed */
               err = -EAGAIN;
               /*

Is this change necessary?

Quoted 2 lines

My intention was to support tag greater than 31 and less than 64. The 1U << only works up to 32 bits.

The UFSHCI 4.0 standard and also the Linux kernel UFS driver support more than 64 outstanding commands so the above change is not sufficient.

Quoted 2 lines
Quoted 1 line

Please do not use lrbp->cmd to check whether or not a command has completed. See also my patch "scsi: ufs: Fix handling of lrbp->cmd".

I have been thinking how to replace lrbp->cmd, but could not find a good solution. Throughout this patch series, I am using lrbp->cmd as a way to find the pending command that is being aborted and clean up the resources associated with it. Any suggestions to achieve it?

Using lrbp->cmd is fine but checking whether or not it is NULL is not OK. How about using blk_mq_request_started() to check whether or not a request is still pending?

Thanks,

Bart.

#8 lore raw

PATCH v2 3/5 ufs: mcq: Added ufshcd_mcq_abort()

In reply to Bao D. Nguyen

Add ufshcd_mcq_abort() to support ufs abort in mcq mode.

---
 drivers/ufs/core/ufs-mcq.c     | 62 ++++++++++++++++++++++++++++++++++++++++++
 drivers/ufs/core/ufshcd-priv.h |  5 +++-
 drivers/ufs/core/ufshcd.c      | 11 ++++++--
 3 files changed, 74 insertions(+), 4 deletions(-)
drivers/ufs/core/ufs-mcq.c +62 -0
index a463674..e3031cd 100644
@@ -619,3 +619,65 @@ static bool ufshcd_mcq_sqe_search(struct ufs_hba *hba,
 	spin_unlock(&hwq->sq_lock);
 	return ret;
 }
+
+/**
+ * ufshcd_mcq_abort - Abort the command in MCQ.
+ * @cmd - The command to be aborted.
+ *
+ * Returns SUCCESS or FAILED error codes
+ */
+int ufshcd_mcq_abort(struct scsi_cmnd *cmd)
+{
+	struct Scsi_Host *host = cmd->device->host;
+	struct ufs_hba *hba = shost_priv(host);
+	int tag = scsi_cmd_to_rq(cmd)->tag;
+	struct ufshcd_lrb *lrbp = &hba->lrb[tag];
+	struct ufs_hw_queue *hwq;
+	int err = FAILED;
+
+	if (!lrbp->cmd) {
+		dev_err(hba->dev,
+			"%s: skip abort. cmd at tag %d already completed.\n",
+			__func__, tag);
+		goto out;
+	}
+
+	/* Skip task abort in case previous aborts failed and report failure */
+	if (lrbp->req_abort_skip) {
+		dev_err(hba->dev, "%s: skip abort. tag %d failed earlier\n",
+			__func__, tag);
+		goto out;
+	}
+
+	hwq = ufshcd_mcq_req_to_hwq(hba, scsi_cmd_to_rq(cmd));
+
+	if (ufshcd_mcq_sqe_search(hba, hwq, tag)) {
+		/*
+		 * Failure. The command should not be "stuck" in SQ for
+		 * a long time which resulted in command being aborted.
+		 */
+		dev_err(hba->dev, "%s: cmd found in sq. hwq=%d, tag=%d\n",
+				__func__, hwq->id, tag);
+		/* Set the Command Type to 0xF per the spec */
+		ufshcd_mcq_nullify_cmd(hba, hwq);
+		goto out;
+	}
+
+	/*
+	 * The command is not in the Submission Queue, and it is not
+	 * in the Completion Queue either. Query the device to see if
+	 * the command is being processed in the device.
+	 */
+	if (ufshcd_try_to_abort_task(hba, tag)) {
+		dev_err(hba->dev, "%s: device abort failed %d\n", __func__, err);
+		lrbp->req_abort_skip = true;
+		goto out;
+	}
+
+	err = SUCCESS;
+	if (lrbp->cmd)
+		ufshcd_release_scsi_cmd(hba, lrbp);
+
+out:
+	return err;
+}
drivers/ufs/core/ufshcd-priv.h +4 -1
index 1a40cf7..ef66151 100644
@@ -79,7 +79,10 @@ unsigned long ufshcd_mcq_poll_cqe_lock(struct ufs_hba *hba,
 				       struct ufs_hw_queue *hwq);
 
 int ufshcd_mcq_sq_cleanup(struct ufs_hba *hba, int task_tag, int *result);
-
+int ufshcd_mcq_abort(struct scsi_cmnd *cmd);
+int ufshcd_try_to_abort_task(struct ufs_hba *hba, int tag);
+void ufshcd_release_scsi_cmd(struct ufs_hba *hba,
+				struct ufshcd_lrb *lrbp);
 #define UFSHCD_MCQ_IO_QUEUE_OFFSET	1
 #define SD_ASCII_STD true
 #define SD_RAW false
drivers/ufs/core/ufshcd.c +8 -3
index ffccb91..84efb52 100644
@@ -299,7 +299,6 @@ static int ufshcd_setup_hba_vreg(struct ufs_hba *hba, bool on);
 static int ufshcd_setup_vreg(struct ufs_hba *hba, bool on);
 static inline int ufshcd_config_vreg_hpm(struct ufs_hba *hba,
 					 struct ufs_vreg *vreg);
-static int ufshcd_try_to_abort_task(struct ufs_hba *hba, int tag);
 static void ufshcd_wb_toggle_buf_flush_during_h8(struct ufs_hba *hba,
 						 bool enable);
 static void ufshcd_hba_vreg_set_lpm(struct ufs_hba *hba);
@@ -5438,7 +5437,7 @@ static irqreturn_t ufshcd_uic_cmd_compl(struct ufs_hba *hba, u32 intr_status)
 }
 
 /* Release the resources allocated for processing a SCSI command. */
-static void ufshcd_release_scsi_cmd(struct ufs_hba *hba,
+void ufshcd_release_scsi_cmd(struct ufs_hba *hba,
 				    struct ufshcd_lrb *lrbp)
 {
 	struct scsi_cmnd *cmd = lrbp->cmd;
@@ -7374,7 +7373,7 @@ static void ufshcd_set_req_abort_skip(struct ufs_hba *hba, unsigned long bitmap)
  *
  * Returns zero on success, non-zero on failure
  */
-static int ufshcd_try_to_abort_task(struct ufs_hba *hba, int tag)
+int ufshcd_try_to_abort_task(struct ufs_hba *hba, int tag)
 {
 	struct ufshcd_lrb *lrbp = &hba->lrb[tag];
 	int err = 0;
@@ -7534,6 +7533,12 @@ static int ufshcd_abort(struct scsi_cmnd *cmd)
 		goto release;
 	}
 
+	if (is_mcq_enabled(hba)) {
+		/* MCQ mode. Branch off to handle abort for mcq mode */
+		err = ufshcd_mcq_abort(cmd);
+		goto release;
+	}
+
 	/* Skip task abort in case previous aborts failed and report failure */
 	if (lrbp->req_abort_skip) {
 		dev_err(hba->dev, "%s: skipping abort\n", __func__);
Signature · 1 line
2.7.4
#9 lore raw

Re: [PATCH v2 3/5] ufs: mcq: Added ufshcd_mcq_abort()

drivers/ufs/core/ufs-mcq.c static bool ufshcd_mcq_sqe_search(struct ufs_hba *hba, · line 643

Quoted 6 lines · Bao D. Nguyen
drivers/ufs/core/ufs-mcq.c +6 -0
+	if (!lrbp->cmd) {
+		dev_err(hba->dev,
+			"%s: skip abort. cmd at tag %d already completed.\n",
+			__func__, tag);
+		goto out;
+	}

Please do not use lrbp->cmd to check whether or not a command has completed.

drivers/ufs/core/ufs-mcq.c static bool ufshcd_mcq_sqe_search(struct ufs_hba *hba, · line 662

Quoted 9 lines
drivers/ufs/core/ufs-mcq.c +9 -0
+	if (ufshcd_mcq_sqe_search(hba, hwq, tag)) {
+		/*
+		 * Failure. The command should not be "stuck" in SQ for
+		 * a long time which resulted in command being aborted.
+		 */
+		dev_err(hba->dev, "%s: cmd found in sq. hwq=%d, tag=%d\n",
+				__func__, hwq->id, tag);
+		/* Set the Command Type to 0xF per the spec */
+		ufshcd_mcq_nullify_cmd(hba, hwq);

The above looks wrong to me. How can ufshcd_mcq_nullify_cmd() identify a command if the 'tag' argument is not passed to that function?

drivers/ufs/core/ufs-mcq.c static bool ufshcd_mcq_sqe_search(struct ufs_hba *hba, · line 670

Quoted 5 lines
drivers/ufs/core/ufs-mcq.c +5 -0
+	/*
+	 * The command is not in the Submission Queue, and it is not
+	 * in the Completion Queue either. Query the device to see if
+	 * the command is being processed in the device.
+	 */

Please only use capitals if these are required.

drivers/ufs/core/ufs-mcq.c static bool ufshcd_mcq_sqe_search(struct ufs_hba *hba, · line 679

Quoted 2 lines
drivers/ufs/core/ufs-mcq.c +2 -0
+	if (lrbp->cmd)
+		ufshcd_release_scsi_cmd(hba, lrbp);

Same comment here - do not use lrbp->cmd to check for completion.

Thanks,

Bart.

#10 lore raw

Re: [PATCH v2 3/5] ufs: mcq: Added ufshcd_mcq_abort()

Quoted 9 lines · Bart Van Assche
Quoted 6 lines · Bao D. Nguyen

+    if (!lrbp->cmd) {
+        dev_err(hba->dev,
+            "%s: skip abort. cmd at tag %d already completed.\n", +            __func__, tag);
+        goto out;
+    }

Please do not use lrbp->cmd to check whether or not a command has completed.

Yes. Same comment as in patch #2.

Quoted 11 lines
Quoted 10 lines

+    if (ufshcd_mcq_sqe_search(hba, hwq, tag)) {
+        /*
+         * Failure. The command should not be "stuck" in SQ for +         * a long time which resulted in command being aborted. +         */
+        dev_err(hba->dev, "%s: cmd found in sq. hwq=%d, tag=%d\n", +                __func__, hwq->id, tag);
+        /* Set the Command Type to 0xF per the spec */ +        ufshcd_mcq_nullify_cmd(hba, hwq);

Quoted 1 line

The above looks wrong to me. How can ufshcd_mcq_nullify_cmd() identify a command if the 'tag' argument is not passed to that function?

Same comment as in patch #1. I will change this function.

Quoted 7 lines
Quoted 5 lines
Quoted 1 line

+    /*

+     * The command is not in the Submission Queue, and it is not +     * in the Completion Queue either. Query the device to see if +     * the command is being processed in the device.
+     */

Please only use capitals if these are required.

Yes, I will change.

Quoted 5 lines
Quoted 3 lines

+    if (lrbp->cmd)
+        ufshcd_release_scsi_cmd(hba, lrbp);

Same comment here - do not use lrbp->cmd to check for completion.

Yes.

Quoted 4 lines

Thanks,

Bart.

#11 lore raw

PATCH v2 4/5 ufs: mcq: Use ufshcd_mcq_poll_cqe_lock() in mcq mode

In reply to Bao D. Nguyen

In preparation for adding mcq error handler support, update the mcq code to use the ufshcd_mcq_poll_cqe_lock() in interrupt context instead of using ufshcd_mcq_poll_cqe_nolock(). This is to keep synchronization between mcq interrupt and error handler contexts because both need to access the mcq hardware in separate contexts.

---
 drivers/ufs/core/ufs-mcq.c     | 6 +++---
 drivers/ufs/core/ufshcd-priv.h | 2 --
 drivers/ufs/core/ufshcd.c      | 2 +-
 drivers/ufs/host/ufs-qcom.c    | 2 +-
 include/ufs/ufshcd.h           | 2 +-
 5 files changed, 6 insertions(+), 8 deletions(-)
drivers/ufs/core/ufs-mcq.c +3 -3
index e3031cd..ede4343 100644
@@ -283,8 +283,8 @@ static void ufshcd_mcq_process_cqe(struct ufs_hba *hba,
 	ufshcd_compl_one_cqe(hba, tag, cqe);
 }
 
-unsigned long ufshcd_mcq_poll_cqe_nolock(struct ufs_hba *hba,
-					 struct ufs_hw_queue *hwq)
+static unsigned long ufshcd_mcq_poll_cqe_nolock(struct ufs_hba *hba,
+						struct ufs_hw_queue *hwq)
 {
 	unsigned long completed_reqs = 0;
 
@@ -300,7 +300,6 @@ unsigned long ufshcd_mcq_poll_cqe_nolock(struct ufs_hba *hba,
 
 	return completed_reqs;
 }
-EXPORT_SYMBOL_GPL(ufshcd_mcq_poll_cqe_nolock);
 
 unsigned long ufshcd_mcq_poll_cqe_lock(struct ufs_hba *hba,
 				       struct ufs_hw_queue *hwq)
@@ -313,6 +312,7 @@ unsigned long ufshcd_mcq_poll_cqe_lock(struct ufs_hba *hba,
 
 	return completed_reqs;
 }
+EXPORT_SYMBOL_GPL(ufshcd_mcq_poll_cqe_lock);
 
 void ufshcd_mcq_make_queues_operational(struct ufs_hba *hba)
 {
drivers/ufs/core/ufshcd-priv.h +0 -2
index ef66151..70b7ffc 100644
@@ -71,8 +71,6 @@ void ufshcd_mcq_config_mac(struct ufs_hba *hba, u32 max_active_cmds);
 void ufshcd_mcq_select_mcq_mode(struct ufs_hba *hba);
 u32 ufshcd_mcq_read_cqis(struct ufs_hba *hba, int i);
 void ufshcd_mcq_write_cqis(struct ufs_hba *hba, u32 val, int i);
-unsigned long ufshcd_mcq_poll_cqe_nolock(struct ufs_hba *hba,
-					 struct ufs_hw_queue *hwq);
 struct ufs_hw_queue *ufshcd_mcq_req_to_hwq(struct ufs_hba *hba,
 					   struct request *req);
 unsigned long ufshcd_mcq_poll_cqe_lock(struct ufs_hba *hba,
drivers/ufs/core/ufshcd.c +1 -1
index 84efb52..fef1907 100644
@@ -6792,7 +6792,7 @@ static irqreturn_t ufshcd_handle_mcq_cq_events(struct ufs_hba *hba)
 			ufshcd_mcq_write_cqis(hba, events, i);
 
 		if (events & UFSHCD_MCQ_CQIS_TAIL_ENT_PUSH_STS)
-			ufshcd_mcq_poll_cqe_nolock(hba, hwq);
+			ufshcd_mcq_poll_cqe_lock(hba, hwq);
 	}
 
 	return IRQ_HANDLED;
drivers/ufs/host/ufs-qcom.c +1 -1
index 6568fdf..34d3814 100644
@@ -1558,7 +1558,7 @@ static irqreturn_t ufs_qcom_mcq_esi_handler(int irq, void *__hba)
 	struct ufs_hw_queue *hwq = &hba->uhq[id];
 
 	ufshcd_mcq_write_cqis(hba, 0x1, id);
-	ufshcd_mcq_poll_cqe_nolock(hba, hwq);
+	ufshcd_mcq_poll_cqe_lock(hba, hwq);
 
 	return IRQ_HANDLED;
 }
include/ufs/ufshcd.h +1 -1
index 25aab8e..3fca558 100644
@@ -1246,7 +1246,7 @@ void ufshcd_update_evt_hist(struct ufs_hba *hba, u32 id, u32 val);
 void ufshcd_hba_stop(struct ufs_hba *hba);
 void ufshcd_schedule_eh_work(struct ufs_hba *hba);
 void ufshcd_mcq_write_cqis(struct ufs_hba *hba, u32 val, int i);
-unsigned long ufshcd_mcq_poll_cqe_nolock(struct ufs_hba *hba,
+unsigned long ufshcd_mcq_poll_cqe_lock(struct ufs_hba *hba,
 					 struct ufs_hw_queue *hwq);
 void ufshcd_mcq_enable_esi(struct ufs_hba *hba);
 void ufshcd_mcq_config_esi(struct ufs_hba *hba, struct msi_msg *msg);
Signature · 1 line
2.7.4
#12 lore raw

PATCH v2 5/5 ufs: core: Add error handling for MCQ mode

In reply to Bao D. Nguyen

Add support for error handling for MCQ mode.

---
 drivers/ufs/core/ufshcd.c | 80 ++++++++++++++++++++++++++++++++++++++++-------
 1 file changed, 69 insertions(+), 11 deletions(-)
drivers/ufs/core/ufshcd.c +69 -11
index fef1907..e947f7f 100644
@@ -3127,6 +3127,12 @@ static int ufshcd_wait_for_dev_cmd(struct ufs_hba *hba,
 		err = -ETIMEDOUT;
 		dev_dbg(hba->dev, "%s: dev_cmd request timedout, tag %d\n",
 			__func__, lrbp->task_tag);
+
+		/* MCQ mode */
+		if (is_mcq_enabled(hba))
+			return ufshcd_clear_cmds(hba, 1UL << lrbp->task_tag);
+
+		/* SDB mode */
 		if (ufshcd_clear_cmds(hba, 1UL << lrbp->task_tag) == 0) {
 			/* successfully cleared the command, retry if needed */
 			err = -EAGAIN;
@@ -5562,6 +5568,10 @@ static int ufshcd_poll(struct Scsi_Host *shost, unsigned int queue_num)
  */
 static irqreturn_t ufshcd_transfer_req_compl(struct ufs_hba *hba)
 {
+	struct ufshcd_lrb *lrbp;
+	u32 hwq_num, utag;
+	int tag;
+
 	/* Resetting interrupt aggregation counters first and reading the
 	 * DOOR_BELL afterward allows us to handle all the completed requests.
 	 * In order to prevent other interrupts starvation the DB is read once
@@ -5580,7 +5590,22 @@ static irqreturn_t ufshcd_transfer_req_compl(struct ufs_hba *hba)
 	 * Ignore the ufshcd_poll() return value and return IRQ_HANDLED since we
 	 * do not want polling to trigger spurious interrupt complaints.
 	 */
-	ufshcd_poll(hba->host, UFSHCD_POLL_FROM_INTERRUPT_CONTEXT);
+	if (!is_mcq_enabled(hba)) {
+		ufshcd_poll(hba->host, UFSHCD_POLL_FROM_INTERRUPT_CONTEXT);
+		goto out;
+	}
+
+	/* MCQ mode */
+	for (tag = 0; tag < hba->nutrs; tag++) {
+		lrbp = &hba->lrb[tag];
+		if (lrbp->cmd) {
+			utag = blk_mq_unique_tag(scsi_cmd_to_rq(lrbp->cmd));
+			hwq_num = blk_mq_unique_tag_to_hwq(utag);
+			ufshcd_poll(hba->host, hwq_num);
+		}
+	}
+
+out:
 
 	return IRQ_HANDLED;
 }
@@ -6359,18 +6384,36 @@ static bool ufshcd_abort_all(struct ufs_hba *hba)
 	bool needs_reset = false;
 	int tag, ret;
 
-	/* Clear pending transfer requests */
-	for_each_set_bit(tag, &hba->outstanding_reqs, hba->nutrs) {
-		ret = ufshcd_try_to_abort_task(hba, tag);
-		dev_err(hba->dev, "Aborting tag %d / CDB %#02x %s\n", tag,
-			hba->lrb[tag].cmd ? hba->lrb[tag].cmd->cmnd[0] : -1,
-			ret ? "failed" : "succeeded");
-		if (ret) {
-			needs_reset = true;
-			goto out;
+	if (is_mcq_enabled(hba)) {
+		struct ufshcd_lrb *lrbp;
+		int tag;
+
+		for (tag = 0; tag < hba->nutrs; tag++) {
+			lrbp = &hba->lrb[tag];
+			if (lrbp->cmd) {
+				ret = ufshcd_try_to_abort_task(hba, tag);
+				dev_err(hba->dev, "Aborting tag %d / CDB %#02x %s\n", tag,
+					hba->lrb[tag].cmd ? hba->lrb[tag].cmd->cmnd[0] : -1,
+					ret ? "failed" : "succeeded");
+			}
+			if (ret) {
+				needs_reset = true;
+				goto out;
+			}
+		}
+	} else {
+		/* Clear pending transfer requests */
+		for_each_set_bit(tag, &hba->outstanding_reqs, hba->nutrs) {
+			ret = ufshcd_try_to_abort_task(hba, tag);
+			dev_err(hba->dev, "Aborting tag %d / CDB %#02x %s\n", tag,
+				hba->lrb[tag].cmd ? hba->lrb[tag].cmd->cmnd[0] : -1,
+				ret ? "failed" : "succeeded");
+			if (ret) {
+				needs_reset = true;
+				goto out;
+			}
 		}
 	}
-
 	/* Clear pending task management requests */
 	for_each_set_bit(tag, &hba->outstanding_tasks, hba->nutmrs) {
 		if (ufshcd_clear_tm_cmd(hba, tag)) {
@@ -7302,6 +7345,8 @@ static int ufshcd_eh_device_reset_handler(struct scsi_cmnd *cmd)
 	unsigned long flags, pending_reqs = 0, not_cleared = 0;
 	struct Scsi_Host *host;
 	struct ufs_hba *hba;
+	struct ufs_hw_queue *hwq;
+	struct ufshcd_lrb *lrbp;
 	u32 pos;
 	int err;
 	u8 resp = 0xF, lun;
@@ -7317,6 +7362,19 @@ static int ufshcd_eh_device_reset_handler(struct scsi_cmnd *cmd)
 		goto out;
 	}
 
+	if (is_mcq_enabled(hba)) {
+		for (pos = 0; pos < hba->nutrs; pos++) {
+			lrbp = &hba->lrb[pos];
+			if (lrbp->cmd && lrbp->lun == lun) {
+				ufshcd_clear_cmds(hba, 1UL << pos);
+				hwq = ufshcd_mcq_req_to_hwq(hba, scsi_cmd_to_rq(lrbp->cmd));
+				ufshcd_mcq_poll_cqe_lock(hba, hwq);
+			}
+		}
+		err = 0;
+		goto out;
+	}
+
 	/* clear the commands that were pending for corresponding LUN */
 	spin_lock_irqsave(&hba->outstanding_lock, flags);
 	for_each_set_bit(pos, &hba->outstanding_reqs, hba->nutrs)
Signature · 1 line
2.7.4
#13 lore raw

Re: [PATCH v2 5/5] ufs: core: Add error handling for MCQ mode

drivers/ufs/core/ufshcd.c static int ufshcd_wait_for_dev_cmd(struct ufs_hba *hba, · line 3133

Quoted 3 lines · Bao D. Nguyen
drivers/ufs/core/ufshcd.c +3 -0
+		/* MCQ mode */
+		if (is_mcq_enabled(hba))
+			return ufshcd_clear_cmds(hba, 1UL << lrbp->task_tag);

The above code will trigger an overflow if lrbp->task_tag >= 8 * sizeof(unsigned long). That's not acceptable.

Quoted 18 lines
  static irqreturn_t ufshcd_transfer_req_compl(struct ufs_hba *hba)
  {
drivers/ufs/core/ufshcd.c +8 -1
+	struct ufshcd_lrb *lrbp;
+	u32 hwq_num, utag;
+	int tag;
+
  	/* Resetting interrupt aggregation counters first and reading the
  	 * DOOR_BELL afterward allows us to handle all the completed requests.
  	 * In order to prevent other interrupts starvation the DB is read once
@@ -5580,7 +5590,22 @@ static irqreturn_t ufshcd_transfer_req_compl(struct ufs_hba *hba)
  	 * Ignore the ufshcd_poll() return value and return IRQ_HANDLED since we
  	 * do not want polling to trigger spurious interrupt complaints.
  	 */
-	ufshcd_poll(hba->host, UFSHCD_POLL_FROM_INTERRUPT_CONTEXT);
+	if (!is_mcq_enabled(hba)) {
+		ufshcd_poll(hba->host, UFSHCD_POLL_FROM_INTERRUPT_CONTEXT);
+		goto out;
+	}

drivers/ufs/core/ufshcd.c static irqreturn_t ufshcd_transfer_req_compl(struct ufs_hba *hba) · line 5606

Quoted 10 lines
drivers/ufs/core/ufshcd.c +10 -0
+
+	/* MCQ mode */
+	for (tag = 0; tag < hba->nutrs; tag++) {
+		lrbp = &hba->lrb[tag];
+		if (lrbp->cmd) {
+			utag = blk_mq_unique_tag(scsi_cmd_to_rq(lrbp->cmd));
+			hwq_num = blk_mq_unique_tag_to_hwq(utag);
+			ufshcd_poll(hba->host, hwq_num);
+		}
+	}

Is my understanding correct that ufshcd_transfer_req_compl() is only called from single doorbell code paths and hence that the above change is not necessary?

Quoted 20 lines
drivers/ufs/core/ufshcd.c +20 -0
+	if (is_mcq_enabled(hba)) {
+		struct ufshcd_lrb *lrbp;
+		int tag;
+
+		for (tag = 0; tag < hba->nutrs; tag++) {
+			lrbp = &hba->lrb[tag];
+			if (lrbp->cmd) {
+				ret = ufshcd_try_to_abort_task(hba, tag);
+				dev_err(hba->dev, "Aborting tag %d / CDB %#02x %s\n", tag,
+					hba->lrb[tag].cmd ? hba->lrb[tag].cmd->cmnd[0] : -1,
+					ret ? "failed" : "succeeded");
+			}
+			if (ret) {
+				needs_reset = true;
+				goto out;
+			}
+		}
+	} else {
+		/* Clear pending transfer requests */
+		for_each_set_bit(tag, &hba->outstanding_reqs, hba->nutrs) {

drivers/ufs/core/ufshcd.c static bool ufshcd_abort_all(struct ufs_hba *hba) · line 6416

Quoted 10 lines
drivers/ufs/core/ufshcd.c +8 -0
+			ret = ufshcd_try_to_abort_task(hba, tag);
+			dev_err(hba->dev, "Aborting tag %d / CDB %#02x %s\n", tag,
+				hba->lrb[tag].cmd ? hba->lrb[tag].cmd->cmnd[0] : -1,
+				ret ? "failed" : "succeeded");
+			if (ret) {
+				needs_reset = true;
+				goto out;
+			}
  		}
  	}

Please introduce helper functions for the MCQ and SDB code paths such that the nesting level of the above code is reduced.

Thanks,

Bart.

#14 lore raw

Re: [PATCH v2 5/5] ufs: core: Add error handling for MCQ mode

Quoted 6 lines · Bart Van Assche
Quoted 3 lines · Bao D. Nguyen

+        /* MCQ mode */
+        if (is_mcq_enabled(hba))
+            return ufshcd_clear_cmds(hba, 1UL << lrbp->task_tag);

The above code will trigger an overflow if lrbp->task_tag >= 8 * sizeof(unsigned long). That's not acceptable.

This ufshcd_clear_cmds() uses a bit map. There are multiple places in the UFS code have this limitation if the queue depth grows to be greater than 64. I am thinking:
1. Current ufs controllers in the market probably support queue depth 64 or less, so it may not be a problem today if host controller cap is set to 64 queue depth, but can be a problem in multiple places in the code later.
2. In mcq mode, we can pass a tag number into this api ufshcd_clear_cmds(); while in SDB mode, pass the tag's bit mask as before.
3. Use sbitmask() to support large queue depth? Thanks for any suggestions.

Quoted 24 lines
Quoted 24 lines

  static irqreturn_t ufshcd_transfer_req_compl(struct ufs_hba *hba) {
+    struct ufshcd_lrb *lrbp;
+    u32 hwq_num, utag;
+    int tag;
+
      /* Resetting interrupt aggregation counters first and reading the
       * DOOR_BELL afterward allows us to handle all the completed requests.
       * In order to prevent other interrupts starvation the DB is read once

drivers/ufs/core/ufshcd.c +8 -1
@@ -5580,7 +5590,22 @@ static irqreturn_t 
 ufshcd_transfer_req_compl(struct ufs_hba *hba)
        * Ignore the ufshcd_poll() return value and return IRQ_HANDLED since we
        * do not want polling to trigger spurious interrupt complaints.
        */
-    ufshcd_poll(hba->host, UFSHCD_POLL_FROM_INTERRUPT_CONTEXT);
+    if (!is_mcq_enabled(hba)) {
+        ufshcd_poll(hba->host, UFSHCD_POLL_FROM_INTERRUPT_CONTEXT);
+        goto out;
+    }
+
+    /* MCQ mode */
+    for (tag = 0; tag < hba->nutrs; tag++) {
+        lrbp = &hba->lrb[tag];
Quoted 8 lines

drivers/ufs/core/ufshcd.c static irqreturn_t ufshcd_transfer_req_compl(struct ufs_hba *hba) · line 5606

Quoted 6 lines
drivers/ufs/core/ufshcd.c +6 -0
+        if (lrbp->cmd) {
+            utag = blk_mq_unique_tag(scsi_cmd_to_rq(lrbp->cmd));
+            hwq_num = blk_mq_unique_tag_to_hwq(utag);
+            ufshcd_poll(hba->host, hwq_num);
+        }
+    }

Is my understanding correct that ufshcd_transfer_req_compl() is only called from single doorbell code paths and hence that the above change is not necessary?

ufshcd_transfer_req_compl() can be invoked from MCQ mode such as the ufshcd_err_handler() as below:
ufshcd_err_handler()-->ufshcd_complete_requests()-->ufshcd_transfer_req_compl()

Quoted 34 lines
Quoted 25 lines
drivers/ufs/core/ufshcd.c +9 -0
+    if (is_mcq_enabled(hba)) {
+        struct ufshcd_lrb *lrbp;
+        int tag;
+
+        for (tag = 0; tag < hba->nutrs; tag++) {
+            lrbp = &hba->lrb[tag];
+            if (lrbp->cmd) {
+                ret = ufshcd_try_to_abort_task(hba, tag);
+                dev_err(hba->dev, "Aborting tag %d / CDB %#02x %s\n", 

tag,
+                    hba->lrb[tag].cmd ? hba->lrb[tag].cmd->cmnd[0] : -1, +                    ret ? "failed" : "succeeded");
+            }
+            if (ret) {
+                needs_reset = true;
+                goto out;
+            }
+        }
+    } else {
+        /* Clear pending transfer requests */
+        for_each_set_bit(tag, &hba->outstanding_reqs, hba->nutrs) { +            ret = ufshcd_try_to_abort_task(hba, tag);
+            dev_err(hba->dev, "Aborting tag %d / CDB %#02x %s\n", tag,

Quoted 8 lines

+                hba->lrb[tag].cmd ? hba->lrb[tag].cmd->cmnd[0] : -1, +                ret ? "failed" : "succeeded");
+            if (ret) {
+                needs_reset = true;
+                goto out;
+            }
          }
      }

Quoted 1 line

Please introduce helper functions for the MCQ and SDB code paths such that the nesting level of the above code is reduced.

Sure. I will change.

Quoted 4 lines

Thanks,

Bart.

#15 lore raw

Re: [PATCH v2 5/5] ufs: core: Add error handling for MCQ mode

Quoted 11 lines · Bao D. Nguyen
Quoted 6 lines · Bart Van Assche
Quoted 3 lines · Bao D. Nguyen

+        /* MCQ mode */
+        if (is_mcq_enabled(hba))
+            return ufshcd_clear_cmds(hba, 1UL << lrbp->task_tag);

The above code will trigger an overflow if lrbp->task_tag >= 8 * sizeof(unsigned long). That's not acceptable.

This ufshcd_clear_cmds() uses a bit map. There are multiple places in the UFS code have this limitation if the queue depth grows to be greater than 64. I am thinking:
1. Current ufs controllers in the market probably support queue depth 64 or less, so it may not be a problem today if host controller cap is set to 64 queue depth, but can be a problem in multiple places in the code later.
2. In mcq mode, we can pass a tag number into this api ufshcd_clear_cmds(); while in SDB mode, pass the tag's bit mask as before.
3. Use sbitmask() to support large queue depth? Thanks for any suggestions.

The UFS driver is the only block driver I know that tracks which commands are pending in a bitmap. Please pass the lrbp pointer or the task_tag directly to ufshcd_clear_cmds() instead of passing a bitmap to that function. Please also introduce a loop in ufshcd_eh_device_reset_handler() around the ufshcd_clear_cmds() call instead of passing a bitmap to ufshcd_clear_cmds().

Quoted 30 lines
Quoted 22 lines
Quoted 22 lines

  static irqreturn_t ufshcd_transfer_req_compl(struct ufs_hba *hba) {
+    struct ufshcd_lrb *lrbp;
+    u32 hwq_num, utag;
+    int tag;
+
      /* Resetting interrupt aggregation counters first and reading the
       * DOOR_BELL afterward allows us to handle all the completed requests.
       * In order to prevent other interrupts starvation the DB is read once

drivers/ufs/core/ufshcd.c +8 -1
@@ -5580,7 +5590,22 @@ static irqreturn_t ufshcd_transfer_req_compl(struct ufs_hba *hba)
        * Ignore the ufshcd_poll() return value and return IRQ_HANDLED since we
        * do not want polling to trigger spurious interrupt complaints.
        */
-    ufshcd_poll(hba->host, UFSHCD_POLL_FROM_INTERRUPT_CONTEXT);
+    if (!is_mcq_enabled(hba)) {
+        ufshcd_poll(hba->host, UFSHCD_POLL_FROM_INTERRUPT_CONTEXT);
+        goto out;
+    }
+
+    /* MCQ mode */
+    for (tag = 0; tag < hba->nutrs; tag++) {
+        lrbp = &hba->lrb[tag];
Quoted 8 lines

drivers/ufs/core/ufshcd.c static irqreturn_t ufshcd_transfer_req_compl(struct ufs_hba *hba) · line 5606

Quoted 6 lines
drivers/ufs/core/ufshcd.c +6 -0
+        if (lrbp->cmd) {
+            utag = blk_mq_unique_tag(scsi_cmd_to_rq(lrbp->cmd));
+            hwq_num = blk_mq_unique_tag_to_hwq(utag);
+            ufshcd_poll(hba->host, hwq_num);
+        }
+    }

Is my understanding correct that ufshcd_transfer_req_compl() is only called from single doorbell code paths and hence that the above change is not necessary?

Quoted 2 lines

ufshcd_transfer_req_compl() can be invoked from MCQ mode such as the ufshcd_err_handler() as below:
ufshcd_err_handler()-->ufshcd_complete_requests()-->ufshcd_transfer_req_compl()

Since there are multiple statements in ufshcd_transfer_req_compl() that assume SDB mode (resetting SDB interrupt aggregation and calling ufshcd_poll()), please move the is_mcq_enabled() test from ufshcd_transfer_req_compl() into the callers of that function.

Thanks,

Bart.

Reviewed-by on the v2 series
#16 lore raw
In reply to Bao D. Nguyen

Bao D. Nguyen <[email protected]> 於 2023年4月18日 週二 上午5:12寫道:

Quoted 27 lines

This patch series enable support for ufshcd_abort() and error handler in MCQ mode. The first 3 patches are for supporting ufshcd_abort().
The 4th and 5th patches are for supporting error handler.

Bao D. Nguyen (5):
ufs: mcq: Add supporting functions for mcq abort
ufs: mcq: Add support for clean up mcq resources
ufs: mcq: Added ufshcd_mcq_abort()
ufs: mcq: Use ufshcd_mcq_poll_cqe_lock() in mcq mode
ufs: core: Add error handling for MCQ mode
---
v1->v2:
patch #1: Addressed Powen's comment. Replaced read_poll_timeout() with ufshcd_mcq_poll_register(). The function read_poll_timeout() may sleep while the caller is holding a spin_lock(). Poll the registers in a tight loop instead.
---

 drivers/ufs/core/ufs-mcq.c     | 258 ++++++++++++++++++++++++++++++++++++++++-
 drivers/ufs/core/ufshcd-priv.h |  15 ++-
 drivers/ufs/core/ufshcd.c      | 140 ++++++++++++++++++----
 drivers/ufs/host/ufs-qcom.c    |   2 +-
 include/ufs/ufshcd.h           |   2 +-
 include/ufs/ufshci.h           |  17 +++
 6 files changed, 404 insertions(+), 30 deletions(-)
Quoted 3 lines

--
2.7.4

This series looks good to me.

Reviewed-by on the v2 series
#17 lore raw
In reply to Bao D. Nguyen
Quoted 33 lines · Bao D. Nguyen

External email : Please do not click links or open attachments until you have verified the sender or the content.

This patch series enable support for ufshcd_abort() and error handler in MCQ mode.
The first 3 patches are for supporting ufshcd_abort().
The 4th and 5th patches are for supporting error handler.

Bao D. Nguyen (5):
ufs: mcq: Add supporting functions for mcq abort
ufs: mcq: Add support for clean up mcq resources
ufs: mcq: Added ufshcd_mcq_abort()
ufs: mcq: Use ufshcd_mcq_poll_cqe_lock() in mcq mode
ufs: core: Add error handling for MCQ mode
---
v1->v2:
patch #1: Addressed Powen's comment. Replaced read_poll_timeout() with ufshcd_mcq_poll_register(). The function read_poll_timeout() may sleep while the caller is holding a spin_lock(). Poll the registers
in a tight loop instead.
---

 drivers/ufs/core/ufs-mcq.c     | 258
++++++++++++++++++++++++++++++++++++++++-
 drivers/ufs/core/ufshcd-priv.h |  15 ++-
 drivers/ufs/core/ufshcd.c      | 140 ++++++++++++++++++----
 drivers/ufs/host/ufs-qcom.c    |   2 +-
 include/ufs/ufshcd.h           |   2 +-
 include/ufs/ufshci.h           |  17 +++
 6 files changed, 404 insertions(+), 30 deletions(-)
Quoted 3 lines

--
2.7.4