[PATCH v19 0/3] scsi: ufs: Add Host Performance Booster Support

[PATCH v19 0/3] scsi: ufs: Add Host Performance Booster Support

[Daejun Park]

Changelog:

v18 -> 19
1. Fix null pointer error when printing sysfs from non-HPB LU.
2. Apply HPB read opcode in lrbp->cmd->cmnd (from Can Guo's review).
3. Rebase the patch on 5.12/scsi-queue.

v17 -> v18
Fix build error which reported by kernel test robot.

v16 -> v17
1. Rename hpb_state_lock to rgn_state_lock and move it to corresponding
patch.
2. Remove redundant information messages.

v15 -> v16
1. Add missed sysfs ABI documentation.

v14 -> v15
1. Remove duplicated sysfs ABI entries in documentation.
2. Add experiment result of HPB performance testing with iozone.

v13 -> v14
1. Cleanup codes by commentted in Greg's review.
2. Add documentation for sysfs entries (from Greg's review).
3. Add experiment result of HPB performance testing.

v12 -> v13
1. Cleanup codes by comments from Can Guo.
2. Add HPB related descriptor/flag/attributes in sysfs.
3. Change base commit from 5.10/scsi-queue to 5.11/scsi-queue.

v11 -> v12
1. Fixed to return error value when HPB fails to initialize pinned active 
region.
2. Fixed to disable HPB feature if HPB fails to allocate essential memory
and workqueue.
3. Fixed to change proper sub-region state when region is already evicted.

v10 -> v11
Add a newline at end the last line on Kconfig file.

v9 -> v10
1. Fixed 64-bit division error
2. Fixed problems commentted in Bart's review.

v8 -> v9
1. Change sysfs initialization.
2. Change reading descriptor during HPB initialization
3. Fixed problems commentted in Bart's review.
4. Change base commit from 5.9/scsi-queue to 5.10/scsi-queue.

v7 -> v8
Remove wrongly added tags.

v6 -> v7
1. Remove UFS feature layer.
2. Cleanup for sparse error.

v5 -> v6
Change base commit to b53293fa662e28ae0cdd40828dc641c09f133405

v4 -> v5
Delete unused macro define.

v3 -> v4
1. Cleanup.

v2 -> v3
1. Add checking input module parameter value.
2. Change base commit from 5.8/scsi-queue to 5.9/scsi-queue.
3. Cleanup for unused variables and label.

v1 -> v2
1. Change the full boilerplate text to SPDX style.
2. Adopt dynamic allocation for sub-region data structure.
3. Cleanup.

NAND flash memory-based storage devices use Flash Translation Layer (FTL)
to translate logical addresses of I/O requests to corresponding flash
memory addresses. Mobile storage devices typically have RAM with
constrained size, thus lack in memory to keep the whole mapping table.
Therefore, mapping tables are partially retrieved from NAND flash on
demand, causing random-read performance degradation.

To improve random read performance, JESD220-3 (HPB v1.0) proposes HPB
(Host Performance Booster) which uses host system memory as a cache for the
FTL mapping table. By using HPB, FTL data can be read from host memory
faster than from NAND flash memory. 

The current version only supports the DCM (device control mode).
This patch consists of 3 parts to support HPB feature.

1) HPB probe and initialization process
2) READ -> HPB READ using cached map information
3) L2P (logical to physical) map management

In the HPB probe and init process, the device information of the UFS is
queried. After checking supported features, the data structure for the HPB
is initialized according to the device information.

A read I/O in the active sub-region where the map is cached is changed to
HPB READ by the HPB.

The HPB manages the L2P map using information received from the
device. For active sub-region, the HPB caches through ufshpb_map
request. For the in-active region, the HPB discards the L2P map.
When a write I/O occurs in an active sub-region area, associated dirty
bitmap checked as dirty for preventing stale read.

HPB is shown to have a performance improvement of 58 - 67% for random read
workload. [1]

[1]:
https://www.usenix.org/conference/hotstorage17/program/presentation/jeong

Daejun Park (3):
  scsi: ufs: Introduce HPB feature
  scsi: ufs: L2P map management for HPB read
  scsi: ufs: Prepare HPB read for cached sub-region

 Documentation/ABI/testing/sysfs-driver-ufs |   71 +
 drivers/scsi/ufs/Kconfig                   |    9 +
 drivers/scsi/ufs/Makefile                  |    1 +
 drivers/scsi/ufs/ufs-sysfs.c               |   18 +
 drivers/scsi/ufs/ufs.h                     |   51 +
 drivers/scsi/ufs/ufshcd.c                  |   55 +
 drivers/scsi/ufs/ufshcd.h                  |   22 +
 drivers/scsi/ufs/ufshpb.c                  | 1758 ++++++++++++++++++++
 drivers/scsi/ufs/ufshpb.h                  |  231 +++
 9 files changed, 2216 insertions(+)
 create mode 100644 drivers/scsi/ufs/ufshpb.c
 create mode 100644 drivers/scsi/ufs/ufshpb.h

-- 
2.25.1

[PATCH v19 2/3] scsi: ufs: L2P map management for HPB read

[Daejun Park]

This is a patch for managing L2P map in HPB module.

The HPB divides logical addresses into several regions. A region consists
of several sub-regions. The sub-region is a basic unit where L2P mapping is
managed. The driver loads L2P mapping data of each sub-region. The loaded
sub-region is called active-state. The HPB driver unloads L2P mapping data
as region unit. The unloaded region is called inactive-state.

Sub-region/region candidates to be loaded and unloaded are delivered from
the UFS device. The UFS device delivers the recommended active sub-region
and inactivate region to the driver using sensedata.
The HPB module performs L2P mapping management on the host through the
delivered information.

A pinned region is a pre-set regions on the UFS device that is always
activate-state.

The data structure for map data request and L2P map uses mempool API,
minimizing allocation overhead while avoiding static allocation.

The mininum size of the memory pool used in the HPB is implemented
as a module parameter, so that it can be configurable by the user.

To gurantee a minimum memory pool size of 4MB: ufshpb_host_map_kbytes=4096

The map_work manages active/inactive by 2 "to-do" lists.
Each hpb lun maintains 2 "to-do" lists:
  hpb->lh_inact_rgn - regions to be inactivated, and
  hpb->lh_act_srgn - subregions to be activated
Those lists are maintained on IO completion.

Reviewed-by: Bart Van Assche <bvanassche@acm.org>
Reviewed-by: Can Guo <cang@codeaurora.org>
Acked-by: Avri Altman <Avri.Altman@wdc.com>
Tested-by: Bean Huo <beanhuo@micron.com>
Signed-off-by: Daejun Park <daejun7.park@samsung.com>
---
 drivers/scsi/ufs/ufs.h    |  36 ++
 drivers/scsi/ufs/ufshcd.c |   4 +
 drivers/scsi/ufs/ufshpb.c | 993 +++++++++++++++++++++++++++++++++++++-
 drivers/scsi/ufs/ufshpb.h |  65 +++
 4 files changed, 1083 insertions(+), 15 deletions(-)

diff --git a/drivers/scsi/ufs/ufs.h b/drivers/scsi/ufs/ufs.h
index 65563635e20e..075c12e7de7e 100644
--- a/drivers/scsi/ufs/ufs.h
+++ b/drivers/scsi/ufs/ufs.h
@@ -472,6 +472,41 @@ struct utp_cmd_rsp {
 	u8 sense_data[UFS_SENSE_SIZE];
 };
 
+struct ufshpb_active_field {
+	__be16 active_rgn;
+	__be16 active_srgn;
+};
+#define HPB_ACT_FIELD_SIZE 4
+
+/**
+ * struct utp_hpb_rsp - Response UPIU structure
+ * @residual_transfer_count: Residual transfer count DW-3
+ * @reserved1: Reserved double words DW-4 to DW-7
+ * @sense_data_len: Sense data length DW-8 U16
+ * @desc_type: Descriptor type of sense data
+ * @additional_len: Additional length of sense data
+ * @hpb_op: HPB operation type
+ * @reserved2: Reserved field
+ * @active_rgn_cnt: Active region count
+ * @inactive_rgn_cnt: Inactive region count
+ * @hpb_active_field: Recommended to read HPB region and subregion
+ * @hpb_inactive_field: To be inactivated HPB region and subregion
+ */
+struct utp_hpb_rsp {
+	__be32 residual_transfer_count;
+	__be32 reserved1[4];
+	__be16 sense_data_len;
+	u8 desc_type;
+	u8 additional_len;
+	u8 hpb_op;
+	u8 reserved2;
+	u8 active_rgn_cnt;
+	u8 inactive_rgn_cnt;
+	struct ufshpb_active_field hpb_active_field[2];
+	__be16 hpb_inactive_field[2];
+};
+#define UTP_HPB_RSP_SIZE 40
+
 /**
  * struct utp_upiu_rsp - general upiu response structure
  * @header: UPIU header structure DW-0 to DW-2
@@ -482,6 +517,7 @@ struct utp_upiu_rsp {
 	struct utp_upiu_header header;
 	union {
 		struct utp_cmd_rsp sr;
+		struct utp_hpb_rsp hr;
 		struct utp_upiu_query qr;
 	};
 };
diff --git a/drivers/scsi/ufs/ufshcd.c b/drivers/scsi/ufs/ufshcd.c
index b8d6a52f5603..52e48de8d27c 100644
--- a/drivers/scsi/ufs/ufshcd.c
+++ b/drivers/scsi/ufs/ufshcd.c
@@ -5018,6 +5018,9 @@ ufshcd_transfer_rsp_status(struct ufs_hba *hba, struct ufshcd_lrb *lrbp)
 				 */
 				pm_runtime_get_noresume(hba->dev);
 			}
+
+			if (scsi_status == SAM_STAT_GOOD)
+				ufshpb_rsp_upiu(hba, lrbp);
 			break;
 		case UPIU_TRANSACTION_REJECT_UPIU:
 			/* TODO: handle Reject UPIU Response */
@@ -9228,6 +9231,7 @@ EXPORT_SYMBOL(ufshcd_shutdown);
 void ufshcd_remove(struct ufs_hba *hba)
 {
 	ufs_bsg_remove(hba);
+	ufshpb_remove(hba);
 	ufs_sysfs_remove_nodes(hba->dev);
 	blk_cleanup_queue(hba->tmf_queue);
 	blk_mq_free_tag_set(&hba->tmf_tag_set);
diff --git a/drivers/scsi/ufs/ufshpb.c b/drivers/scsi/ufs/ufshpb.c
index 1f84141ed384..48edfdd0f606 100644
--- a/drivers/scsi/ufs/ufshpb.c
+++ b/drivers/scsi/ufs/ufshpb.c
@@ -16,11 +16,73 @@
 #include "ufshpb.h"
 #include "../sd.h"
 
+/* memory management */
+static struct kmem_cache *ufshpb_mctx_cache;
+static mempool_t *ufshpb_mctx_pool;
+static mempool_t *ufshpb_page_pool;
+/* A cache size of 2MB can cache ppn in the 1GB range. */
+static unsigned int ufshpb_host_map_kbytes = 2048;
+static int tot_active_srgn_pages;
+
+static struct workqueue_struct *ufshpb_wq;
+
 bool ufshpb_is_allowed(struct ufs_hba *hba)
 {
 	return !(hba->ufshpb_dev.hpb_disabled);
 }
 
+static bool ufshpb_is_general_lun(int lun)
+{
+	return lun < UFS_UPIU_MAX_UNIT_NUM_ID;
+}
+
+static bool
+ufshpb_is_pinned_region(struct ufshpb_lu *hpb, int rgn_idx)
+{
+	if (hpb->lu_pinned_end != PINNED_NOT_SET &&
+	    rgn_idx >= hpb->lu_pinned_start &&
+	    rgn_idx <= hpb->lu_pinned_end)
+		return true;
+
+	return false;
+}
+
+static void ufshpb_kick_map_work(struct ufshpb_lu *hpb)
+{
+	bool ret = true;
+	unsigned long flags;
+
+	spin_lock_irqsave(&hpb->rsp_list_lock, flags);
+	if (!list_empty(&hpb->lh_inact_rgn) || !list_empty(&hpb->lh_act_srgn))
+		ret = false;
+	spin_unlock_irqrestore(&hpb->rsp_list_lock, flags);
+
+	if (ret)
+		queue_work(ufshpb_wq, &hpb->map_work);
+}
+
+static bool ufshpb_is_hpb_rsp_valid(struct ufs_hba *hba,
+					 struct ufshcd_lrb *lrbp,
+					 struct utp_hpb_rsp *rsp_field)
+{
+	if (be16_to_cpu(rsp_field->sense_data_len) != DEV_SENSE_SEG_LEN ||
+	    rsp_field->desc_type != DEV_DES_TYPE ||
+	    rsp_field->additional_len != DEV_ADDITIONAL_LEN ||
+	    rsp_field->hpb_op == HPB_RSP_NONE ||
+	    rsp_field->active_rgn_cnt > MAX_ACTIVE_NUM ||
+	    rsp_field->inactive_rgn_cnt > MAX_INACTIVE_NUM ||
+	    (!rsp_field->active_rgn_cnt && !rsp_field->inactive_rgn_cnt))
+		return false;
+
+	if (!ufshpb_is_general_lun(lrbp->lun)) {
+		dev_warn(hba->dev, "ufshpb: lun(%d) not supported\n",
+			 lrbp->lun);
+		return false;
+	}
+
+	return true;
+}
+
 static struct ufshpb_lu *ufshpb_get_hpb_data(struct scsi_device *sdev)
 {
 	return sdev->hostdata;
@@ -36,13 +98,741 @@ static void ufshpb_set_state(struct ufshpb_lu *hpb, int state)
 	atomic_set(&hpb->hpb_state, state);
 }
 
+static struct ufshpb_req *ufshpb_get_map_req(struct ufshpb_lu *hpb,
+					     struct ufshpb_subregion *srgn)
+{
+	struct ufshpb_req *map_req;
+	struct request *req;
+	struct bio *bio;
+
+	map_req = kmem_cache_alloc(hpb->map_req_cache, GFP_KERNEL);
+	if (!map_req)
+		return NULL;
+
+	req = blk_get_request(hpb->sdev_ufs_lu->request_queue,
+			      REQ_OP_SCSI_IN, 0);
+	if (IS_ERR(req))
+		goto free_map_req;
+
+	bio = bio_alloc(GFP_KERNEL, hpb->pages_per_srgn);
+	if (!bio) {
+		blk_put_request(req);
+		goto free_map_req;
+	}
+
+	map_req->hpb = hpb;
+	map_req->req = req;
+	map_req->bio = bio;
+
+	map_req->rgn_idx = srgn->rgn_idx;
+	map_req->srgn_idx = srgn->srgn_idx;
+	map_req->mctx = srgn->mctx;
+
+	return map_req;
+
+free_map_req:
+	kmem_cache_free(hpb->map_req_cache, map_req);
+	return NULL;
+}
+
+static void ufshpb_put_map_req(struct ufshpb_lu *hpb,
+				      struct ufshpb_req *map_req)
+{
+	bio_put(map_req->bio);
+	blk_put_request(map_req->req);
+	kmem_cache_free(hpb->map_req_cache, map_req);
+}
+
+static int ufshpb_clear_dirty_bitmap(struct ufshpb_lu *hpb,
+				     struct ufshpb_subregion *srgn)
+{
+	WARN_ON(!srgn->mctx);
+	bitmap_zero(srgn->mctx->ppn_dirty, hpb->entries_per_srgn);
+	return 0;
+}
+
+static void ufshpb_update_active_info(struct ufshpb_lu *hpb, int rgn_idx,
+				      int srgn_idx)
+{
+	struct ufshpb_region *rgn;
+	struct ufshpb_subregion *srgn;
+
+	rgn = hpb->rgn_tbl + rgn_idx;
+	srgn = rgn->srgn_tbl + srgn_idx;
+
+	list_del_init(&rgn->list_inact_rgn);
+
+	if (list_empty(&srgn->list_act_srgn))
+		list_add_tail(&srgn->list_act_srgn, &hpb->lh_act_srgn);
+}
+
+static void ufshpb_update_inactive_info(struct ufshpb_lu *hpb, int rgn_idx)
+{
+	struct ufshpb_region *rgn;
+	struct ufshpb_subregion *srgn;
+	int srgn_idx;
+
+	rgn = hpb->rgn_tbl + rgn_idx;
+
+	for_each_sub_region(rgn, srgn_idx, srgn)
+		list_del_init(&srgn->list_act_srgn);
+
+	if (list_empty(&rgn->list_inact_rgn))
+		list_add_tail(&rgn->list_inact_rgn, &hpb->lh_inact_rgn);
+}
+
+static void ufshpb_activate_subregion(struct ufshpb_lu *hpb,
+					  struct ufshpb_subregion *srgn)
+{
+	struct ufshpb_region *rgn;
+
+	/*
+	 * If there is no mctx in subregion
+	 * after I/O progress for HPB_READ_BUFFER, the region to which the
+	 * subregion belongs was evicted.
+	 * Mask sure the region must not evict in I/O progress
+	 */
+	WARN_ON(!srgn->mctx);
+
+	rgn = hpb->rgn_tbl + srgn->rgn_idx;
+
+	if (unlikely(rgn->rgn_state == HPB_RGN_INACTIVE)) {
+		dev_err(&hpb->sdev_ufs_lu->sdev_dev,
+			"region %d subregion %d evicted\n",
+			srgn->rgn_idx, srgn->srgn_idx);
+		srgn->srgn_state = HPB_SRGN_INVALID;
+		return;
+	}
+	srgn->srgn_state = HPB_SRGN_VALID;
+}
+
+static void ufshpb_map_req_compl_fn(struct request *req, blk_status_t error)
+{
+	struct ufshpb_req *map_req = (struct ufshpb_req *) req->end_io_data;
+	struct ufshpb_lu *hpb = map_req->hpb;
+	struct ufshpb_subregion *srgn;
+	unsigned long flags;
+
+	srgn = hpb->rgn_tbl[map_req->rgn_idx].srgn_tbl +
+		map_req->srgn_idx;
+
+	ufshpb_clear_dirty_bitmap(hpb, srgn);
+	spin_lock_irqsave(&hpb->rgn_state_lock, flags);
+	ufshpb_activate_subregion(hpb, srgn);
+	spin_unlock_irqrestore(&hpb->rgn_state_lock, flags);
+
+	ufshpb_put_map_req(map_req->hpb, map_req);
+}
+
+static void ufshpb_set_read_buf_cmd(unsigned char *cdb, int rgn_idx,
+					   int srgn_idx, int srgn_mem_size)
+{
+	cdb[0] = UFSHPB_READ_BUFFER;
+	cdb[1] = UFSHPB_READ_BUFFER_ID;
+
+	put_unaligned_be16(rgn_idx, &cdb[2]);
+	put_unaligned_be16(srgn_idx, &cdb[4]);
+	put_unaligned_be24(srgn_mem_size, &cdb[6]);
+
+	cdb[9] = 0x00;
+}
+
+static int ufshpb_execute_map_req(struct ufshpb_lu *hpb,
+				  struct ufshpb_req *map_req)
+{
+	struct request_queue *q;
+	struct request *req;
+	struct scsi_request *rq;
+	int ret = 0;
+	int i;
+
+	q = hpb->sdev_ufs_lu->request_queue;
+	for (i = 0; i < hpb->pages_per_srgn; i++) {
+		ret = bio_add_pc_page(q, map_req->bio, map_req->mctx->m_page[i],
+				      PAGE_SIZE, 0);
+		if (ret != PAGE_SIZE) {
+			dev_err(&hpb->sdev_ufs_lu->sdev_dev,
+				   "bio_add_pc_page fail %d - %d\n",
+				   map_req->rgn_idx, map_req->srgn_idx);
+			return ret;
+		}
+	}
+
+	req = map_req->req;
+
+	blk_rq_append_bio(req, &map_req->bio);
+
+	req->end_io_data = map_req;
+
+	rq = scsi_req(req);
+	ufshpb_set_read_buf_cmd(rq->cmd, map_req->rgn_idx,
+				map_req->srgn_idx, hpb->srgn_mem_size);
+	rq->cmd_len = HPB_READ_BUFFER_CMD_LENGTH;
+
+	blk_execute_rq_nowait(q, NULL, req, 1, ufshpb_map_req_compl_fn);
+
+	hpb->stats.map_req_cnt++;
+	return 0;
+}
+
+static struct ufshpb_map_ctx *ufshpb_get_map_ctx(struct ufshpb_lu *hpb)
+{
+	struct ufshpb_map_ctx *mctx;
+	int i, j;
+
+	mctx = mempool_alloc(ufshpb_mctx_pool, GFP_KERNEL);
+	if (!mctx)
+		return NULL;
+
+	mctx->m_page = kmem_cache_alloc(hpb->m_page_cache, GFP_KERNEL);
+	if (!mctx->m_page)
+		goto release_mctx;
+
+	mctx->ppn_dirty = bitmap_zalloc(hpb->entries_per_srgn, GFP_KERNEL);
+	if (!mctx->ppn_dirty)
+		goto release_m_page;
+
+	for (i = 0; i < hpb->pages_per_srgn; i++) {
+		mctx->m_page[i] = mempool_alloc(ufshpb_page_pool, GFP_KERNEL);
+		if (!mctx->m_page[i]) {
+			for (j = 0; j < i; j++)
+				mempool_free(mctx->m_page[j], ufshpb_page_pool);
+			goto release_ppn_dirty;
+		}
+		clear_page(page_address(mctx->m_page[i]));
+	}
+
+	return mctx;
+
+release_ppn_dirty:
+	bitmap_free(mctx->ppn_dirty);
+release_m_page:
+	kmem_cache_free(hpb->m_page_cache, mctx->m_page);
+release_mctx:
+	mempool_free(mctx, ufshpb_mctx_pool);
+	return NULL;
+}
+
+static void ufshpb_put_map_ctx(struct ufshpb_lu *hpb,
+				      struct ufshpb_map_ctx *mctx)
+{
+	int i;
+
+	for (i = 0; i < hpb->pages_per_srgn; i++)
+		mempool_free(mctx->m_page[i], ufshpb_page_pool);
+
+	bitmap_free(mctx->ppn_dirty);
+	kmem_cache_free(hpb->m_page_cache, mctx->m_page);
+	mempool_free(mctx, ufshpb_mctx_pool);
+}
+
+static int ufshpb_check_srgns_issue_state(struct ufshpb_lu *hpb,
+					  struct ufshpb_region *rgn)
+{
+	struct ufshpb_subregion *srgn;
+	int srgn_idx;
+
+	for_each_sub_region(rgn, srgn_idx, srgn)
+		if (srgn->srgn_state == HPB_SRGN_ISSUED)
+			return -EPERM;
+
+	return 0;
+}
+
+static void ufshpb_add_lru_info(struct victim_select_info *lru_info,
+				       struct ufshpb_region *rgn)
+{
+	rgn->rgn_state = HPB_RGN_ACTIVE;
+	list_add_tail(&rgn->list_lru_rgn, &lru_info->lh_lru_rgn);
+	atomic_inc(&lru_info->active_cnt);
+}
+
+static void ufshpb_hit_lru_info(struct victim_select_info *lru_info,
+				       struct ufshpb_region *rgn)
+{
+	list_move_tail(&rgn->list_lru_rgn, &lru_info->lh_lru_rgn);
+}
+
+static struct ufshpb_region *ufshpb_victim_lru_info(struct ufshpb_lu *hpb)
+{
+	struct victim_select_info *lru_info = &hpb->lru_info;
+	struct ufshpb_region *rgn, *victim_rgn = NULL;
+
+	list_for_each_entry(rgn, &lru_info->lh_lru_rgn, list_lru_rgn) {
+		WARN_ON(!rgn);
+		if (ufshpb_check_srgns_issue_state(hpb, rgn))
+			continue;
+
+		victim_rgn = rgn;
+		break;
+	}
+
+	return victim_rgn;
+}
+
+static void ufshpb_cleanup_lru_info(struct victim_select_info *lru_info,
+					   struct ufshpb_region *rgn)
+{
+	list_del_init(&rgn->list_lru_rgn);
+	rgn->rgn_state = HPB_RGN_INACTIVE;
+	atomic_dec(&lru_info->active_cnt);
+}
+
+static void ufshpb_purge_active_subregion(struct ufshpb_lu *hpb,
+						 struct ufshpb_subregion *srgn)
+{
+	if (srgn->srgn_state != HPB_SRGN_UNUSED) {
+		ufshpb_put_map_ctx(hpb, srgn->mctx);
+		srgn->srgn_state = HPB_SRGN_UNUSED;
+		srgn->mctx = NULL;
+	}
+}
+
+static void __ufshpb_evict_region(struct ufshpb_lu *hpb,
+				  struct ufshpb_region *rgn)
+{
+	struct victim_select_info *lru_info;
+	struct ufshpb_subregion *srgn;
+	int srgn_idx;
+
+	lru_info = &hpb->lru_info;
+
+	dev_dbg(&hpb->sdev_ufs_lu->sdev_dev, "evict region %d\n", rgn->rgn_idx);
+
+	ufshpb_cleanup_lru_info(lru_info, rgn);
+
+	for_each_sub_region(rgn, srgn_idx, srgn)
+		ufshpb_purge_active_subregion(hpb, srgn);
+}
+
+static int ufshpb_evict_region(struct ufshpb_lu *hpb, struct ufshpb_region *rgn)
+{
+	unsigned long flags;
+	int ret = 0;
+
+	spin_lock_irqsave(&hpb->rgn_state_lock, flags);
+	if (rgn->rgn_state == HPB_RGN_PINNED) {
+		dev_warn(&hpb->sdev_ufs_lu->sdev_dev,
+			 "pinned region cannot drop-out. region %d\n",
+			 rgn->rgn_idx);
+		goto out;
+	}
+	if (!list_empty(&rgn->list_lru_rgn)) {
+		if (ufshpb_check_srgns_issue_state(hpb, rgn)) {
+			ret = -EBUSY;
+			goto out;
+		}
+
+		__ufshpb_evict_region(hpb, rgn);
+	}
+out:
+	spin_unlock_irqrestore(&hpb->rgn_state_lock, flags);
+	return ret;
+}
+
+static int ufshpb_issue_map_req(struct ufshpb_lu *hpb,
+				struct ufshpb_region *rgn,
+				struct ufshpb_subregion *srgn)
+{
+	struct ufshpb_req *map_req;
+	unsigned long flags;
+	int ret;
+	int err = -EAGAIN;
+	bool alloc_required = false;
+	enum HPB_SRGN_STATE state = HPB_SRGN_INVALID;
+
+	spin_lock_irqsave(&hpb->rgn_state_lock, flags);
+
+	if (ufshpb_get_state(hpb) != HPB_PRESENT) {
+		dev_notice(&hpb->sdev_ufs_lu->sdev_dev,
+			   "%s: ufshpb state is not PRESENT\n", __func__);
+		goto unlock_out;
+	}
+
+	if ((rgn->rgn_state == HPB_RGN_INACTIVE) &&
+	    (srgn->srgn_state == HPB_SRGN_INVALID)) {
+		err = 0;
+		goto unlock_out;
+	}
+
+	if (srgn->srgn_state == HPB_SRGN_UNUSED)
+		alloc_required = true;
+
+	/*
+	 * If the subregion is already ISSUED state,
+	 * a specific event (e.g., GC or wear-leveling, etc.) occurs in
+	 * the device and HPB response for map loading is received.
+	 * In this case, after finishing the HPB_READ_BUFFER,
+	 * the next HPB_READ_BUFFER is performed again to obtain the latest
+	 * map data.
+	 */
+	if (srgn->srgn_state == HPB_SRGN_ISSUED)
+		goto unlock_out;
+
+	srgn->srgn_state = HPB_SRGN_ISSUED;
+	spin_unlock_irqrestore(&hpb->rgn_state_lock, flags);
+
+	if (alloc_required) {
+		WARN_ON(srgn->mctx);
+		srgn->mctx = ufshpb_get_map_ctx(hpb);
+		if (!srgn->mctx) {
+			dev_err(&hpb->sdev_ufs_lu->sdev_dev,
+			    "get map_ctx failed. region %d - %d\n",
+			    rgn->rgn_idx, srgn->srgn_idx);
+			state = HPB_SRGN_UNUSED;
+			goto change_srgn_state;
+		}
+	}
+
+	map_req = ufshpb_get_map_req(hpb, srgn);
+	if (!map_req)
+		goto change_srgn_state;
+
+
+	ret = ufshpb_execute_map_req(hpb, map_req);
+	if (ret) {
+		dev_err(&hpb->sdev_ufs_lu->sdev_dev,
+			   "%s: issue map_req failed: %d, region %d - %d\n",
+			   __func__, ret, srgn->rgn_idx, srgn->srgn_idx);
+		goto free_map_req;
+	}
+	return 0;
+
+free_map_req:
+	ufshpb_put_map_req(hpb, map_req);
+change_srgn_state:
+	spin_lock_irqsave(&hpb->rgn_state_lock, flags);
+	srgn->srgn_state = state;
+unlock_out:
+	spin_unlock_irqrestore(&hpb->rgn_state_lock, flags);
+	return err;
+}
+
+static int ufshpb_add_region(struct ufshpb_lu *hpb, struct ufshpb_region *rgn)
+{
+	struct ufshpb_region *victim_rgn;
+	struct victim_select_info *lru_info = &hpb->lru_info;
+	unsigned long flags;
+	int ret = 0;
+
+	spin_lock_irqsave(&hpb->rgn_state_lock, flags);
+	/*
+	 * If region belongs to lru_list, just move the region
+	 * to the front of lru list. because the state of the region
+	 * is already active-state
+	 */
+	if (!list_empty(&rgn->list_lru_rgn)) {
+		ufshpb_hit_lru_info(lru_info, rgn);
+		goto out;
+	}
+
+	if (rgn->rgn_state == HPB_RGN_INACTIVE) {
+		if (atomic_read(&lru_info->active_cnt) ==
+		    lru_info->max_lru_active_cnt) {
+			/*
+			 * If the maximum number of active regions
+			 * is exceeded, evict the least recently used region.
+			 * This case may occur when the device responds
+			 * to the eviction information late.
+			 * It is okay to evict the least recently used region,
+			 * because the device could detect this region
+			 * by not issuing HPB_READ
+			 */
+			victim_rgn = ufshpb_victim_lru_info(hpb);
+			if (!victim_rgn) {
+				dev_warn(&hpb->sdev_ufs_lu->sdev_dev,
+				    "cannot get victim region error\n");
+				ret = -ENOMEM;
+				goto out;
+			}
+
+			dev_dbg(&hpb->sdev_ufs_lu->sdev_dev,
+				"LRU full (%d), choose victim %d\n",
+				atomic_read(&lru_info->active_cnt),
+				victim_rgn->rgn_idx);
+			__ufshpb_evict_region(hpb, victim_rgn);
+		}
+
+		/*
+		 * When a region is added to lru_info list_head,
+		 * it is guaranteed that the subregion has been
+		 * assigned all mctx. If failed, try to receive mctx again
+		 * without being added to lru_info list_head
+		 */
+		ufshpb_add_lru_info(lru_info, rgn);
+	}
+out:
+	spin_unlock_irqrestore(&hpb->rgn_state_lock, flags);
+	return ret;
+}
+
+static void ufshpb_rsp_req_region_update(struct ufshpb_lu *hpb,
+					 struct utp_hpb_rsp *rsp_field)
+{
+	int i, rgn_idx, srgn_idx;
+
+	BUILD_BUG_ON(sizeof(struct ufshpb_active_field) != HPB_ACT_FIELD_SIZE);
+	/*
+	 * If the active region and the inactive region are the same,
+	 * we will inactivate this region.
+	 * The device could check this (region inactivated) and
+	 * will response the proper active region information
+	 */
+	spin_lock(&hpb->rsp_list_lock);
+	for (i = 0; i < rsp_field->active_rgn_cnt; i++) {
+		rgn_idx =
+			be16_to_cpu(rsp_field->hpb_active_field[i].active_rgn);
+		srgn_idx =
+			be16_to_cpu(rsp_field->hpb_active_field[i].active_srgn);
+
+		dev_dbg(&hpb->sdev_ufs_lu->sdev_dev,
+			"activate(%d) region %d - %d\n", i, rgn_idx, srgn_idx);
+		ufshpb_update_active_info(hpb, rgn_idx, srgn_idx);
+		hpb->stats.rb_active_cnt++;
+	}
+
+	for (i = 0; i < rsp_field->inactive_rgn_cnt; i++) {
+		rgn_idx = be16_to_cpu(rsp_field->hpb_inactive_field[i]);
+		dev_dbg(&hpb->sdev_ufs_lu->sdev_dev,
+			"inactivate(%d) region %d\n", i, rgn_idx);
+		ufshpb_update_inactive_info(hpb, rgn_idx);
+		hpb->stats.rb_inactive_cnt++;
+	}
+	spin_unlock(&hpb->rsp_list_lock);
+
+	dev_dbg(&hpb->sdev_ufs_lu->sdev_dev, "Noti: #ACT %u #INACT %u\n",
+		rsp_field->active_rgn_cnt, rsp_field->inactive_rgn_cnt);
+
+	queue_work(ufshpb_wq, &hpb->map_work);
+}
+
+/*
+ * This function will parse recommended active subregion information in sense
+ * data field of response UPIU with SAM_STAT_GOOD state.
+ */
+void ufshpb_rsp_upiu(struct ufs_hba *hba, struct ufshcd_lrb *lrbp)
+{
+	struct ufshpb_lu *hpb = ufshpb_get_hpb_data(lrbp->cmd->device);
+	struct utp_hpb_rsp *rsp_field;
+	int data_seg_len;
+
+	if (!hpb)
+		return;
+
+	if (ufshpb_get_state(hpb) != HPB_PRESENT) {
+		dev_notice(&hpb->sdev_ufs_lu->sdev_dev,
+			   "%s: ufshpb state is not PRESENT\n", __func__);
+		return;
+	}
+
+	data_seg_len = be32_to_cpu(lrbp->ucd_rsp_ptr->header.dword_2)
+		& MASK_RSP_UPIU_DATA_SEG_LEN;
+
+	/* To flush remained rsp_list, we queue the map_work task */
+	if (!data_seg_len) {
+		if (!ufshpb_is_general_lun(lrbp->lun))
+			return;
+
+		ufshpb_kick_map_work(hpb);
+		return;
+	}
+
+	/* Check HPB_UPDATE_ALERT */
+	if (!(lrbp->ucd_rsp_ptr->header.dword_2 &
+	      UPIU_HEADER_DWORD(0, 2, 0, 0)))
+		return;
+
+	rsp_field = &lrbp->ucd_rsp_ptr->hr;
+	BUILD_BUG_ON(sizeof(struct utp_hpb_rsp) != UTP_HPB_RSP_SIZE);
+
+	if (!ufshpb_is_hpb_rsp_valid(hba, lrbp, rsp_field))
+		return;
+
+	hpb->stats.rb_noti_cnt++;
+
+	switch (rsp_field->hpb_op) {
+	case HPB_RSP_NONE:
+		/* nothing to do */
+		break;
+	case HPB_RSP_REQ_REGION_UPDATE:
+		WARN_ON(data_seg_len != DEV_DATA_SEG_LEN);
+		ufshpb_rsp_req_region_update(hpb, rsp_field);
+		break;
+	case HPB_RSP_DEV_RESET:
+		dev_warn(&hpb->sdev_ufs_lu->sdev_dev,
+			 "UFS device lost HPB information during PM.\n");
+		break;
+	default:
+		dev_notice(&hpb->sdev_ufs_lu->sdev_dev,
+			   "hpb_op is not available: %d\n",
+			   rsp_field->hpb_op);
+		break;
+	}
+}
+
+static void ufshpb_add_active_list(struct ufshpb_lu *hpb,
+				   struct ufshpb_region *rgn,
+				   struct ufshpb_subregion *srgn)
+{
+	if (!list_empty(&rgn->list_inact_rgn))
+		return;
+
+	if (!list_empty(&srgn->list_act_srgn)) {
+		list_move(&srgn->list_act_srgn, &hpb->lh_act_srgn);
+		return;
+	}
+
+	list_add(&srgn->list_act_srgn, &hpb->lh_act_srgn);
+}
+
+static void ufshpb_add_pending_evict_list(struct ufshpb_lu *hpb,
+				    struct ufshpb_region *rgn,
+				    struct list_head *pending_list)
+{
+	struct ufshpb_subregion *srgn;
+	int srgn_idx;
+
+	if (!list_empty(&rgn->list_inact_rgn))
+		return;
+
+	for_each_sub_region(rgn, srgn_idx, srgn)
+		if (!list_empty(&srgn->list_act_srgn))
+			return;
+
+	list_add_tail(&rgn->list_inact_rgn, pending_list);
+}
+
+static void ufshpb_run_active_subregion_list(struct ufshpb_lu *hpb)
+{
+	struct ufshpb_region *rgn;
+	struct ufshpb_subregion *srgn;
+	unsigned long flags;
+	int ret = 0;
+
+	spin_lock_irqsave(&hpb->rsp_list_lock, flags);
+	while ((srgn = list_first_entry_or_null(&hpb->lh_act_srgn,
+						struct ufshpb_subregion,
+						list_act_srgn))) {
+		if (ufshpb_get_state(hpb) == HPB_SUSPEND)
+			break;
+
+		list_del_init(&srgn->list_act_srgn);
+		spin_unlock_irqrestore(&hpb->rsp_list_lock, flags);
+
+		rgn = hpb->rgn_tbl + srgn->rgn_idx;
+		ret = ufshpb_add_region(hpb, rgn);
+		if (ret)
+			goto active_failed;
+
+		ret = ufshpb_issue_map_req(hpb, rgn, srgn);
+		if (ret) {
+			dev_err(&hpb->sdev_ufs_lu->sdev_dev,
+			    "issue map_req failed. ret %d, region %d - %d\n",
+			    ret, rgn->rgn_idx, srgn->srgn_idx);
+			goto active_failed;
+		}
+		spin_lock_irqsave(&hpb->rsp_list_lock, flags);
+	}
+	spin_unlock_irqrestore(&hpb->rsp_list_lock, flags);
+	return;
+
+active_failed:
+	dev_err(&hpb->sdev_ufs_lu->sdev_dev, "failed to activate region %d - %d, will retry\n",
+		   rgn->rgn_idx, srgn->srgn_idx);
+	spin_lock_irqsave(&hpb->rsp_list_lock, flags);
+	ufshpb_add_active_list(hpb, rgn, srgn);
+	spin_unlock_irqrestore(&hpb->rsp_list_lock, flags);
+}
+
+static void ufshpb_run_inactive_region_list(struct ufshpb_lu *hpb)
+{
+	struct ufshpb_region *rgn;
+	unsigned long flags;
+	int ret;
+	LIST_HEAD(pending_list);
+
+	spin_lock_irqsave(&hpb->rsp_list_lock, flags);
+	while ((rgn = list_first_entry_or_null(&hpb->lh_inact_rgn,
+					       struct ufshpb_region,
+					       list_inact_rgn))) {
+		if (ufshpb_get_state(hpb) == HPB_SUSPEND)
+			break;
+
+		list_del_init(&rgn->list_inact_rgn);
+		spin_unlock_irqrestore(&hpb->rsp_list_lock, flags);
+
+		ret = ufshpb_evict_region(hpb, rgn);
+		if (ret) {
+			spin_lock_irqsave(&hpb->rsp_list_lock, flags);
+			ufshpb_add_pending_evict_list(hpb, rgn, &pending_list);
+			spin_unlock_irqrestore(&hpb->rsp_list_lock, flags);
+		}
+
+		spin_lock_irqsave(&hpb->rsp_list_lock, flags);
+	}
+
+	list_splice(&pending_list, &hpb->lh_inact_rgn);
+	spin_unlock_irqrestore(&hpb->rsp_list_lock, flags);
+}
+
+static void ufshpb_map_work_handler(struct work_struct *work)
+{
+	struct ufshpb_lu *hpb = container_of(work, struct ufshpb_lu, map_work);
+
+	if (ufshpb_get_state(hpb) != HPB_PRESENT) {
+		dev_notice(&hpb->sdev_ufs_lu->sdev_dev,
+			   "%s: ufshpb state is not PRESENT\n", __func__);
+		return;
+	}
+
+	ufshpb_run_inactive_region_list(hpb);
+	ufshpb_run_active_subregion_list(hpb);
+}
+
+/*
+ * this function doesn't need to hold lock due to be called in init.
+ * (rgn_state_lock, rsp_list_lock, etc..)
+ */
+static int ufshpb_init_pinned_active_region(struct ufs_hba *hba,
+					    struct ufshpb_lu *hpb,
+					    struct ufshpb_region *rgn)
+{
+	struct ufshpb_subregion *srgn;
+	int srgn_idx, i;
+	int err = 0;
+
+	for_each_sub_region(rgn, srgn_idx, srgn) {
+		srgn->mctx = ufshpb_get_map_ctx(hpb);
+		srgn->srgn_state = HPB_SRGN_INVALID;
+		if (!srgn->mctx) {
+			err = -ENOMEM;
+			dev_err(hba->dev,
+				"alloc mctx for pinned region failed\n");
+			goto release;
+		}
+
+		list_add_tail(&srgn->list_act_srgn, &hpb->lh_act_srgn);
+	}
+
+	rgn->rgn_state = HPB_RGN_PINNED;
+	return 0;
+
+release:
+	for (i = 0; i < srgn_idx; i++) {
+		srgn = rgn->srgn_tbl + i;
+		ufshpb_put_map_ctx(hpb, srgn->mctx);
+	}
+	return err;
+}
+
 static void ufshpb_init_subregion_tbl(struct ufshpb_lu *hpb,
 				      struct ufshpb_region *rgn)
 {
 	int srgn_idx;
+	struct ufshpb_subregion *srgn;
 
-	for (srgn_idx = 0; srgn_idx < rgn->srgn_cnt; srgn_idx++) {
-		struct ufshpb_subregion *srgn = rgn->srgn_tbl + srgn_idx;
+	for_each_sub_region(rgn, srgn_idx, srgn) {
+		INIT_LIST_HEAD(&srgn->list_act_srgn);
 
 		srgn->rgn_idx = rgn->rgn_idx;
 		srgn->srgn_idx = srgn_idx;
@@ -75,6 +865,8 @@ static void ufshpb_lu_parameter_init(struct ufs_hba *hba,
 	hpb->lu_pinned_end = hpb_lu_info->num_pinned ?
 		(hpb_lu_info->pinned_start + hpb_lu_info->num_pinned - 1)
 		: PINNED_NOT_SET;
+	hpb->lru_info.max_lru_active_cnt =
+		hpb_lu_info->max_active_rgns - hpb_lu_info->num_pinned;
 
 	rgn_mem_size = (1ULL << hpb_dev_info->rgn_size) * HPB_RGN_SIZE_UNIT
 			* HPB_ENTRY_SIZE;
@@ -123,6 +915,9 @@ static int ufshpb_alloc_region_tbl(struct ufs_hba *hba, struct ufshpb_lu *hpb)
 		rgn = rgn_table + rgn_idx;
 		rgn->rgn_idx = rgn_idx;
 
+		INIT_LIST_HEAD(&rgn->list_inact_rgn);
+		INIT_LIST_HEAD(&rgn->list_lru_rgn);
+
 		if (rgn_idx == hpb->rgns_per_lu - 1)
 			srgn_cnt = ((hpb->srgns_per_lu - 1) %
 				    hpb->srgns_per_rgn) + 1;
@@ -132,7 +927,13 @@ static int ufshpb_alloc_region_tbl(struct ufs_hba *hba, struct ufshpb_lu *hpb)
 			goto release_srgn_table;
 		ufshpb_init_subregion_tbl(hpb, rgn);
 
-		rgn->rgn_state = HPB_RGN_INACTIVE;
+		if (ufshpb_is_pinned_region(hpb, rgn_idx)) {
+			ret = ufshpb_init_pinned_active_region(hba, hpb, rgn);
+			if (ret)
+				goto release_srgn_table;
+		} else {
+			rgn->rgn_state = HPB_RGN_INACTIVE;
+		}
 	}
 
 	return 0;
@@ -151,13 +952,13 @@ static void ufshpb_destroy_subregion_tbl(struct ufshpb_lu *hpb,
 					 struct ufshpb_region *rgn)
 {
 	int srgn_idx;
+	struct ufshpb_subregion *srgn;
 
-	for (srgn_idx = 0; srgn_idx < rgn->srgn_cnt; srgn_idx++) {
-		struct ufshpb_subregion *srgn;
-
-		srgn = rgn->srgn_tbl + srgn_idx;
-		srgn->srgn_state = HPB_SRGN_UNUSED;
-	}
+	for_each_sub_region(rgn, srgn_idx, srgn)
+		if (srgn->srgn_state != HPB_SRGN_UNUSED) {
+			srgn->srgn_state = HPB_SRGN_UNUSED;
+			ufshpb_put_map_ctx(hpb, srgn->mctx);
+		}
 }
 
 static void ufshpb_destroy_region_tbl(struct ufshpb_lu *hpb)
@@ -231,11 +1032,47 @@ static int ufshpb_lu_hpb_init(struct ufs_hba *hba, struct ufshpb_lu *hpb)
 {
 	int ret;
 
+	spin_lock_init(&hpb->rgn_state_lock);
+	spin_lock_init(&hpb->rsp_list_lock);
+
+	INIT_LIST_HEAD(&hpb->lru_info.lh_lru_rgn);
+	INIT_LIST_HEAD(&hpb->lh_act_srgn);
+	INIT_LIST_HEAD(&hpb->lh_inact_rgn);
+	INIT_LIST_HEAD(&hpb->list_hpb_lu);
+
+	INIT_WORK(&hpb->map_work, ufshpb_map_work_handler);
+
+	hpb->map_req_cache = kmem_cache_create("ufshpb_req_cache",
+			  sizeof(struct ufshpb_req), 0, 0, NULL);
+	if (!hpb->map_req_cache) {
+		dev_err(hba->dev, "ufshpb(%d) ufshpb_req_cache create fail",
+			hpb->lun);
+		return -ENOMEM;
+	}
+
+	hpb->m_page_cache = kmem_cache_create("ufshpb_m_page_cache",
+			  sizeof(struct page *) * hpb->pages_per_srgn,
+			  0, 0, NULL);
+	if (!hpb->m_page_cache) {
+		dev_err(hba->dev, "ufshpb(%d) ufshpb_m_page_cache create fail",
+			hpb->lun);
+		ret = -ENOMEM;
+		goto release_req_cache;
+	}
+
 	ret = ufshpb_alloc_region_tbl(hba, hpb);
+	if (ret)
+		goto release_m_page_cache;
 
 	ufshpb_stat_init(hpb);
 
 	return 0;
+
+release_m_page_cache:
+	kmem_cache_destroy(hpb->m_page_cache);
+release_req_cache:
+	kmem_cache_destroy(hpb->map_req_cache);
+	return ret;
 }
 
 static struct ufshpb_lu *ufshpb_alloc_hpb_lu(struct ufs_hba *hba, int lun,
@@ -266,6 +1103,33 @@ static struct ufshpb_lu *ufshpb_alloc_hpb_lu(struct ufs_hba *hba, int lun,
 	return NULL;
 }
 
+static void ufshpb_discard_rsp_lists(struct ufshpb_lu *hpb)
+{
+	struct ufshpb_region *rgn, *next_rgn;
+	struct ufshpb_subregion *srgn, *next_srgn;
+	unsigned long flags;
+
+	/*
+	 * If the device reset occurred, the remained HPB region information
+	 * may be stale. Therefore, by dicarding the lists of HPB response
+	 * that remained after reset, it prevents unnecessary work.
+	 */
+	spin_lock_irqsave(&hpb->rsp_list_lock, flags);
+	list_for_each_entry_safe(rgn, next_rgn, &hpb->lh_inact_rgn,
+				 list_inact_rgn)
+		list_del_init(&rgn->list_inact_rgn);
+
+	list_for_each_entry_safe(srgn, next_srgn, &hpb->lh_act_srgn,
+				 list_act_srgn)
+		list_del_init(&srgn->list_act_srgn);
+	spin_unlock_irqrestore(&hpb->rsp_list_lock, flags);
+}
+
+static void ufshpb_cancel_jobs(struct ufshpb_lu *hpb)
+{
+	cancel_work_sync(&hpb->map_work);
+}
+
 static bool ufshpb_check_hpb_reset_query(struct ufs_hba *hba)
 {
 	int err = 0;
@@ -309,7 +1173,7 @@ void ufshpb_reset(struct ufs_hba *hba)
 	struct scsi_device *sdev;
 
 	shost_for_each_device(sdev, hba->host) {
-		hpb = sdev->hostdata;
+		hpb = ufshpb_get_hpb_data(sdev);
 		if (!hpb)
 			continue;
 
@@ -326,13 +1190,15 @@ void ufshpb_reset_host(struct ufs_hba *hba)
 	struct scsi_device *sdev;
 
 	shost_for_each_device(sdev, hba->host) {
-		hpb = sdev->hostdata;
+		hpb = ufshpb_get_hpb_data(sdev);
 		if (!hpb)
 			continue;
 
 		if (ufshpb_get_state(hpb) != HPB_PRESENT)
 			continue;
 		ufshpb_set_state(hpb, HPB_RESET);
+		ufshpb_cancel_jobs(hpb);
+		ufshpb_discard_rsp_lists(hpb);
 	}
 }
 
@@ -342,13 +1208,14 @@ void ufshpb_suspend(struct ufs_hba *hba)
 	struct scsi_device *sdev;
 
 	shost_for_each_device(sdev, hba->host) {
-		hpb = sdev->hostdata;
+		hpb = ufshpb_get_hpb_data(sdev);
 		if (!hpb)
 			continue;
 
 		if (ufshpb_get_state(hpb) != HPB_PRESENT)
 			continue;
 		ufshpb_set_state(hpb, HPB_SUSPEND);
+		ufshpb_cancel_jobs(hpb);
 	}
 }
 
@@ -358,7 +1225,7 @@ void ufshpb_resume(struct ufs_hba *hba)
 	struct scsi_device *sdev;
 
 	shost_for_each_device(sdev, hba->host) {
-		hpb = sdev->hostdata;
+		hpb = ufshpb_get_hpb_data(sdev);
 		if (!hpb)
 			continue;
 
@@ -366,6 +1233,7 @@ void ufshpb_resume(struct ufs_hba *hba)
 		    (ufshpb_get_state(hpb) != HPB_SUSPEND))
 			continue;
 		ufshpb_set_state(hpb, HPB_PRESENT);
+		ufshpb_kick_map_work(hpb);
 	}
 }
 
@@ -418,7 +1286,7 @@ static int ufshpb_get_lu_info(struct ufs_hba *hba, int lun,
 
 void ufshpb_destroy_lu(struct ufs_hba *hba, struct scsi_device *sdev)
 {
-	struct ufshpb_lu *hpb = sdev->hostdata;
+	struct ufshpb_lu *hpb = ufshpb_get_hpb_data(sdev);
 
 	if (!hpb)
 		return;
@@ -428,8 +1296,13 @@ void ufshpb_destroy_lu(struct ufs_hba *hba, struct scsi_device *sdev)
 	sdev = hpb->sdev_ufs_lu;
 	sdev->hostdata = NULL;
 
+	ufshpb_cancel_jobs(hpb);
+
 	ufshpb_destroy_region_tbl(hpb);
 
+	kmem_cache_destroy(hpb->map_req_cache);
+	kmem_cache_destroy(hpb->m_page_cache);
+
 	list_del_init(&hpb->list_hpb_lu);
 
 	kfree(hpb);
@@ -437,24 +1310,41 @@ void ufshpb_destroy_lu(struct ufs_hba *hba, struct scsi_device *sdev)
 
 static void ufshpb_hpb_lu_prepared(struct ufs_hba *hba)
 {
+	int pool_size;
 	struct ufshpb_lu *hpb;
 	struct scsi_device *sdev;
 	bool init_success;
 
+	if (tot_active_srgn_pages == 0) {
+		ufshpb_remove(hba);
+		return;
+	}
+
 	init_success = !ufshpb_check_hpb_reset_query(hba);
 
+	pool_size = PAGE_ALIGN(ufshpb_host_map_kbytes * 1024) / PAGE_SIZE;
+	if (pool_size > tot_active_srgn_pages) {
+		mempool_resize(ufshpb_mctx_pool, tot_active_srgn_pages);
+		mempool_resize(ufshpb_page_pool, tot_active_srgn_pages);
+	}
+
 	shost_for_each_device(sdev, hba->host) {
-		hpb = sdev->hostdata;
+		hpb = ufshpb_get_hpb_data(sdev);
 		if (!hpb)
 			continue;
 
 		if (init_success) {
 			ufshpb_set_state(hpb, HPB_PRESENT);
+			if ((hpb->lu_pinned_end - hpb->lu_pinned_start) > 0)
+				queue_work(ufshpb_wq, &hpb->map_work);
 		} else {
 			dev_err(hba->dev, "destroy HPB lu %d\n", hpb->lun);
 			ufshpb_destroy_lu(hba, sdev);
 		}
 	}
+
+	if (!init_success)
+		ufshpb_remove(hba);
 }
 
 void ufshpb_init_hpb_lu(struct ufs_hba *hba, struct scsi_device *sdev)
@@ -476,6 +1366,9 @@ void ufshpb_init_hpb_lu(struct ufs_hba *hba, struct scsi_device *sdev)
 	if (!hpb)
 		goto out;
 
+	tot_active_srgn_pages += hpb_lu_info.max_active_rgns *
+			hpb->srgns_per_rgn * hpb->pages_per_srgn;
+
 	hpb->sdev_ufs_lu = sdev;
 	sdev->hostdata = hpb;
 
@@ -485,6 +1378,57 @@ void ufshpb_init_hpb_lu(struct ufs_hba *hba, struct scsi_device *sdev)
 		ufshpb_hpb_lu_prepared(hba);
 }
 
+static int ufshpb_init_mem_wq(void)
+{
+	int ret;
+	unsigned int pool_size;
+
+	ufshpb_mctx_cache = kmem_cache_create("ufshpb_mctx_cache",
+					sizeof(struct ufshpb_map_ctx),
+					0, 0, NULL);
+	if (!ufshpb_mctx_cache) {
+		pr_err("ufshpb: cannot init mctx cache\n");
+		return -ENOMEM;
+	}
+
+	pool_size = PAGE_ALIGN(ufshpb_host_map_kbytes * 1024) / PAGE_SIZE;
+	pr_info("%s:%d ufshpb_host_map_kbytes %u pool_size %u\n",
+	       __func__, __LINE__, ufshpb_host_map_kbytes, pool_size);
+
+	ufshpb_mctx_pool = mempool_create_slab_pool(pool_size,
+						    ufshpb_mctx_cache);
+	if (!ufshpb_mctx_pool) {
+		pr_err("ufshpb: cannot init mctx pool\n");
+		ret = -ENOMEM;
+		goto release_mctx_cache;
+	}
+
+	ufshpb_page_pool = mempool_create_page_pool(pool_size, 0);
+	if (!ufshpb_page_pool) {
+		pr_err("ufshpb: cannot init page pool\n");
+		ret = -ENOMEM;
+		goto release_mctx_pool;
+	}
+
+	ufshpb_wq = alloc_workqueue("ufshpb-wq",
+					WQ_UNBOUND | WQ_MEM_RECLAIM, 0);
+	if (!ufshpb_wq) {
+		pr_err("ufshpb: alloc workqueue failed\n");
+		ret = -ENOMEM;
+		goto release_page_pool;
+	}
+
+	return 0;
+
+release_page_pool:
+	mempool_destroy(ufshpb_page_pool);
+release_mctx_pool:
+	mempool_destroy(ufshpb_mctx_pool);
+release_mctx_cache:
+	kmem_cache_destroy(ufshpb_mctx_cache);
+	return ret;
+}
+
 void ufshpb_get_geo_info(struct ufs_hba *hba, u8 *geo_buf)
 {
 	struct ufshpb_dev_info *hpb_dev_info = &hba->ufshpb_dev;
@@ -550,7 +1494,13 @@ void ufshpb_init(struct ufs_hba *hba)
 	if (!ufshpb_is_allowed(hba))
 		return;
 
+	if (ufshpb_init_mem_wq()) {
+		hpb_dev_info->hpb_disabled = true;
+		return;
+	}
+
 	atomic_set(&hpb_dev_info->slave_conf_cnt, hpb_dev_info->num_lu);
+	tot_active_srgn_pages = 0;
 	/* issue HPB reset query */
 	for (try = 0; try < HPB_RESET_REQ_RETRIES; try++) {
 		ret = ufshcd_query_flag(hba, UPIU_QUERY_OPCODE_SET_FLAG,
@@ -559,3 +1509,16 @@ void ufshpb_init(struct ufs_hba *hba)
 			break;
 	}
 }
+
+void ufshpb_remove(struct ufs_hba *hba)
+{
+	mempool_destroy(ufshpb_page_pool);
+	mempool_destroy(ufshpb_mctx_pool);
+	kmem_cache_destroy(ufshpb_mctx_cache);
+
+	destroy_workqueue(ufshpb_wq);
+}
+
+module_param(ufshpb_host_map_kbytes, uint, 0644);
+MODULE_PARM_DESC(ufshpb_host_map_kbytes,
+	"ufshpb host mapping memory kilo-bytes for ufshpb memory-pool");
diff --git a/drivers/scsi/ufs/ufshpb.h b/drivers/scsi/ufs/ufshpb.h
index 50523821cac8..e40b016971ac 100644
--- a/drivers/scsi/ufs/ufshpb.h
+++ b/drivers/scsi/ufs/ufshpb.h
@@ -83,10 +83,19 @@ struct ufshpb_lu_info {
 	int max_active_rgns;
 };
 
+struct ufshpb_map_ctx {
+	struct page **m_page;
+	unsigned long *ppn_dirty;
+};
+
 struct ufshpb_subregion {
+	struct ufshpb_map_ctx *mctx;
 	enum HPB_SRGN_STATE srgn_state;
 	int rgn_idx;
 	int srgn_idx;
+
+	/* below information is used by rsp_list */
+	struct list_head list_act_srgn;
 };
 
 struct ufshpb_region {
@@ -94,6 +103,43 @@ struct ufshpb_region {
 	enum HPB_RGN_STATE rgn_state;
 	int rgn_idx;
 	int srgn_cnt;
+
+	/* below information is used by rsp_list */
+	struct list_head list_inact_rgn;
+
+	/* below information is used by lru */
+	struct list_head list_lru_rgn;
+};
+
+#define for_each_sub_region(rgn, i, srgn)				\
+	for ((i) = 0;							\
+	     ((i) < (rgn)->srgn_cnt) && ((srgn) = &(rgn)->srgn_tbl[i]); \
+	     (i)++)
+
+/**
+ * struct ufshpb_req - UFSHPB READ BUFFER (for caching map) request structure
+ * @req: block layer request for READ BUFFER
+ * @bio: bio for holding map page
+ * @hpb: ufshpb_lu structure that related to the L2P map
+ * @mctx: L2P map information
+ * @rgn_idx: target region index
+ * @srgn_idx: target sub-region index
+ * @lun: target logical unit number
+ */
+struct ufshpb_req {
+	struct request *req;
+	struct bio *bio;
+	struct ufshpb_lu *hpb;
+	struct ufshpb_map_ctx *mctx;
+
+	unsigned int rgn_idx;
+	unsigned int srgn_idx;
+};
+
+struct victim_select_info {
+	struct list_head lh_lru_rgn; /* LRU list of regions */
+	int max_lru_active_cnt; /* supported hpb #region - pinned #region */
+	atomic_t active_cnt;
 };
 
 struct ufshpb_stats {
@@ -108,10 +154,22 @@ struct ufshpb_stats {
 struct ufshpb_lu {
 	int lun;
 	struct scsi_device *sdev_ufs_lu;
+
+	spinlock_t rgn_state_lock; /* for protect rgn/srgn state */
 	struct ufshpb_region *rgn_tbl;
 
 	atomic_t hpb_state;
 
+	spinlock_t rsp_list_lock;
+	struct list_head lh_act_srgn; /* hold rsp_list_lock */
+	struct list_head lh_inact_rgn; /* hold rsp_list_lock */
+
+	/* cached L2P map management worker */
+	struct work_struct map_work;
+
+	/* for selecting victim */
+	struct victim_select_info lru_info;
+
 	/* pinned region information */
 	u32 lu_pinned_start;
 	u32 lu_pinned_end;
@@ -130,6 +188,9 @@ struct ufshpb_lu {
 
 	struct ufshpb_stats stats;
 
+	struct kmem_cache *map_req_cache;
+	struct kmem_cache *m_page_cache;
+
 	struct list_head list_hpb_lu;
 };
 
@@ -137,6 +198,7 @@ struct ufs_hba;
 struct ufshcd_lrb;
 
 #ifndef CONFIG_SCSI_UFS_HPB
+static void ufshpb_rsp_upiu(struct ufs_hba *hba, struct ufshcd_lrb *lrbp) {}
 static void ufshpb_resume(struct ufs_hba *hba) {}
 static void ufshpb_suspend(struct ufs_hba *hba) {}
 static void ufshpb_reset(struct ufs_hba *hba) {}
@@ -144,10 +206,12 @@ static void ufshpb_reset_host(struct ufs_hba *hba) {}
 static void ufshpb_init(struct ufs_hba *hba) {}
 static void ufshpb_init_hpb_lu(struct ufs_hba *hba, struct scsi_device *sdev) {}
 static void ufshpb_destroy_lu(struct ufs_hba *hba, struct scsi_device *sdev) {}
+static void ufshpb_remove(struct ufs_hba *hba) {}
 static bool ufshpb_is_allowed(struct ufs_hba *hba) { return false; }
 static void ufshpb_get_geo_info(struct ufs_hba *hba, u8 *geo_buf) {}
 static void ufshpb_get_dev_info(struct ufs_hba *hba, u8 *desc_buf) {}
 #else
+void ufshpb_rsp_upiu(struct ufs_hba *hba, struct ufshcd_lrb *lrbp);
 void ufshpb_resume(struct ufs_hba *hba);
 void ufshpb_suspend(struct ufs_hba *hba);
 void ufshpb_reset(struct ufs_hba *hba);
@@ -155,6 +219,7 @@ void ufshpb_reset_host(struct ufs_hba *hba);
 void ufshpb_init(struct ufs_hba *hba);
 void ufshpb_init_hpb_lu(struct ufs_hba *hba, struct scsi_device *sdev);
 void ufshpb_destroy_lu(struct ufs_hba *hba, struct scsi_device *sdev);
+void ufshpb_remove(struct ufs_hba *hba);
 bool ufshpb_is_allowed(struct ufs_hba *hba);
 void ufshpb_get_geo_info(struct ufs_hba *hba, u8 *geo_buf);
 void ufshpb_get_dev_info(struct ufs_hba *hba, u8 *desc_buf);
-- 
2.25.1

Re: [PATCH v19 2/3] scsi: ufs: L2P map management for HPB read

[Bean Huo]

On Fri, 2021-01-29 at 14:30 +0900, Daejun Park wrote:
> +static void ufshpb_set_read_buf_cmd(unsigned char *cdb, int rgn_idx,
> +                                          int srgn_idx, int
> srgn_mem_size)
> +{
> +       cdb[0] = UFSHPB_READ_BUFFER;
> +       cdb[1] = UFSHPB_READ_BUFFER_ID;
> +
> +       put_unaligned_be16(rgn_idx, &cdb[2]);
> +       put_unaligned_be16(srgn_idx, &cdb[4]);
> +       put_unaligned_be24(srgn_mem_size, &cdb[6]);
> +
> +       cdb[9] = 0x00;
> +}
> +
> +static int ufshpb_execute_map_req(struct ufshpb_lu *hpb,
> +                                 struct ufshpb_req *map_req)
> +{
> +       struct request_queue *q;
> +       struct request *req;
> +       struct scsi_request *rq;
> +       int ret = 0;
> +       int i;
> +
> +       q = hpb->sdev_ufs_lu->request_queue;
> +       for (i = 0; i < hpb->pages_per_srgn; i++) {
> +               ret = bio_add_pc_page(q, map_req->bio, map_req->mctx-
> >m_page[i],
> +                                     PAGE_SIZE, 0);
> +               if (ret != PAGE_SIZE) {
> +                       dev_err(&hpb->sdev_ufs_lu->sdev_dev,
> +                                  "bio_add_pc_page fail %d - %d\n",
> +                                  map_req->rgn_idx, map_req-
> >srgn_idx);
> +                       return ret;
> +               }
> +       }
> +
> +       req = map_req->req;
> +
> +       blk_rq_append_bio(req, &map_req->bio);
> +
> +       req->end_io_data = map_req;
> +
> +       rq = scsi_req(req);
> +       ufshpb_set_read_buf_cmd(rq->cmd, map_req->rgn_idx,
> +                               map_req->srgn_idx, hpb-
> >srgn_mem_size);

Hi Daejun

Thanks for your hard-working on the HPB driver.

I found you didn't take into account of allocation Length of the last
sub-region of the last region.

UFS HPB spec: 

"If the requested field of the HPB Region or HPB Sub-Region is out of
range, then the device shall terminate the command by sending RESPONSE
UPIU with CHECK CONDITION status, with the SENSE KEY set to ILLEGAL
REQUEST, and the additional sense code set to INVALID FIELD IN CDB"


Below codes are from my RFC HPB patchset:

https://patchwork.kernel.org/project/linux-scsi/patch/20200504142032.16619-6-beanhuo@micron.com/

+	alloc_len = hpb->hba->hpb_geo.subregion_entry_sz;
+	/*
+	 * HPB Sub-Regions are equally sized except for the last one
which is
+	 * smaller if the last hpb Region is not an integer multiple of
+	 * bHPBSubRegionSize.
+	 */
+	if (map_req->region == (hpb->lu_region_cnt - 1) &&
+	    map_req->subregion == (hpb->subregions_in_last_region - 1))
+		alloc_len = hpb->last_subregion_entry_size;
+
+	ufshpb_prepare_read_buf_cmd(ureq->cmd, map_req->region,
+				    map_req->subregion, alloc_len);
+	if (!ureq->req) {
+		ureq->req = blk_get_request(q, REQ_OP_SCSI_IN, 0);
+		if (IS_ERR(ureq->req)) {
+			ret =  PTR_ERR(ureq->req);
+			goto free_mem;
+		}
+	}

please fix it in your next version patch. thanks.


Kind regards,
Bean

RE: [PATCH v19 2/3] scsi: ufs: L2P map management for HPB read

[Avri Altman]

> Hi Daejun
> 
> Thanks for your hard-working on the HPB driver.
> 
> I found you didn't take into account of allocation Length of the last
> sub-region of the last region.
> 
> UFS HPB spec:
> 
> "If the requested field of the HPB Region or HPB Sub-Region is out of
> range, then the device shall terminate the command by sending RESPONSE
> UPIU with CHECK CONDITION status, with the SENSE KEY set to ILLEGAL
> REQUEST, and the additional sense code set to INVALID FIELD IN CDB"
You don't need to worry about setting invalid ppn to HPB-READ command - 
you'll never get a read request for those LBAs.

Say all subregions are 16MB and the last subregion of the last region is 10MB.
Keep all sizes the same - 16MB, and the ppn of the last subregion contain some invalid data.
But you'll never get a read request for those LBAs anyway - they don't exist,
so you'll never get to use those invalid ppns.

Thanks,
Avri

Re: [PATCH v19 2/3] scsi: ufs: L2P map management for HPB read

[Bean Huo]

On Fri, 2021-02-05 at 11:42 +0000, Avri Altman wrote:
> > "If the requested field of the HPB Region or HPB Sub-Region is out
> > of
> > range, then the device shall terminate the command by sending
> > RESPONSE
> > UPIU with CHECK CONDITION status, with the SENSE KEY set to ILLEGAL
> > REQUEST, and the additional sense code set to INVALID FIELD IN CDB"
> 
> You don't need to worry about setting invalid ppn to HPB-READ command
> - 
> you'll never get a read request for those LBAs.
> 
> Say all subregions are 16MB and the last subregion of the last region
> is 10MB.
> Keep all sizes the same - 16MB, and the ppn of the last subregion
> contain some invalid data.
> But you'll never get a read request for those LBAs anyway - they
> don't exist,
> so you'll never get to use those invalid ppns.
> 
> Thanks,
> Avri

Hi Avri
ah, I don't know if your above comments are inline with Spec.

Spec:
"A HPB Region is divided into HPB Sub-Regions. HPB Sub-Region size is
specified by the bHPBSubRegionSize parameter of Geometry Descriptor.
HPB Sub-Regions are equally sized except for the last one which is
smaller if the last HPB Region is not an interger multiple of
bHPBSubRegionSize."

It is not invalidate ppn concern, it is illegal request issue in sense
key.

Kind regards,
Bean

RE: Re: [PATCH v19 2/3] scsi: ufs: L2P map management for HPB read

[Daejun Park]

> > >"If the requested field of the HPB Region or HPB Sub-Region is out
> > > of
> > > range, then the device shall terminate the command by sending
> > > RESPONSE
> > > UPIU with CHECK CONDITION status, with the SENSE KEY set to ILLEGAL
> > > REQUEST, and the additional sense code set to INVALID FIELD IN CDB"
> > 
> > You don't need to worry about setting invalid ppn to HPB-READ command
> > - 
> > you'll never get a read request for those LBAs.
> > 
> > Say all subregions are 16MB and the last subregion of the last region
> > is 10MB.
> > Keep all sizes the same - 16MB, and the ppn of the last subregion
> > contain some invalid data.
> > But you'll never get a read request for those LBAs anyway - they
> > don't exist,
> > so you'll never get to use those invalid ppns.
> > 
> > Thanks,
> > Avri
>  
> Hi Avri
> ah, I don't know if your above comments are inline with Spec.
>  
> Spec:
> "A HPB Region is divided into HPB Sub-Regions. HPB Sub-Region size is
> specified by the bHPBSubRegionSize parameter of Geometry Descriptor.
> HPB Sub-Regions are equally sized except for the last one which is
> smaller if the last HPB Region is not an interger multiple of
> bHPBSubRegionSize."
>  
> It is not invalidate ppn concern, it is illegal request issue in sense
> key.
>  
> Kind regards,
> Bean

That's a good point.
If the size of the last sub-region is not specified correctly, the map data
cannot be properly fetched. I will support the non-full sized last
sub-region in a new patch.

Thanks,
Daejun

Re: [PATCH v19 2/3] scsi: ufs: L2P map management for HPB read

[Can Guo]

On 2021-01-29 13:30, Daejun Park wrote:
> This is a patch for managing L2P map in HPB module.
> 
> The HPB divides logical addresses into several regions. A region 
> consists
> of several sub-regions. The sub-region is a basic unit where L2P 
> mapping is
> managed. The driver loads L2P mapping data of each sub-region. The 
> loaded
> sub-region is called active-state. The HPB driver unloads L2P mapping 
> data
> as region unit. The unloaded region is called inactive-state.
> 
> Sub-region/region candidates to be loaded and unloaded are delivered 
> from
> the UFS device. The UFS device delivers the recommended active 
> sub-region
> and inactivate region to the driver using sensedata.
> The HPB module performs L2P mapping management on the host through the
> delivered information.
> 
> A pinned region is a pre-set regions on the UFS device that is always
> activate-state.
> 
> The data structure for map data request and L2P map uses mempool API,
> minimizing allocation overhead while avoiding static allocation.
> 
> The mininum size of the memory pool used in the HPB is implemented
> as a module parameter, so that it can be configurable by the user.
> 
> To gurantee a minimum memory pool size of 4MB: 
> ufshpb_host_map_kbytes=4096
> 
> The map_work manages active/inactive by 2 "to-do" lists.
> Each hpb lun maintains 2 "to-do" lists:
>   hpb->lh_inact_rgn - regions to be inactivated, and
>   hpb->lh_act_srgn - subregions to be activated
> Those lists are maintained on IO completion.
> 
> Reviewed-by: Bart Van Assche <bvanassche@acm.org>
> Reviewed-by: Can Guo <cang@codeaurora.org>
> Acked-by: Avri Altman <Avri.Altman@wdc.com>
> Tested-by: Bean Huo <beanhuo@micron.com>
> Signed-off-by: Daejun Park <daejun7.park@samsung.com>
> ---
>  drivers/scsi/ufs/ufs.h    |  36 ++
>  drivers/scsi/ufs/ufshcd.c |   4 +
>  drivers/scsi/ufs/ufshpb.c | 993 +++++++++++++++++++++++++++++++++++++-
>  drivers/scsi/ufs/ufshpb.h |  65 +++
>  4 files changed, 1083 insertions(+), 15 deletions(-)
> 
> diff --git a/drivers/scsi/ufs/ufs.h b/drivers/scsi/ufs/ufs.h
> index 65563635e20e..075c12e7de7e 100644
> --- a/drivers/scsi/ufs/ufs.h
> +++ b/drivers/scsi/ufs/ufs.h
> @@ -472,6 +472,41 @@ struct utp_cmd_rsp {
>  	u8 sense_data[UFS_SENSE_SIZE];
>  };
> 
> +struct ufshpb_active_field {
> +	__be16 active_rgn;
> +	__be16 active_srgn;
> +};
> +#define HPB_ACT_FIELD_SIZE 4
> +
> +/**
> + * struct utp_hpb_rsp - Response UPIU structure
> + * @residual_transfer_count: Residual transfer count DW-3
> + * @reserved1: Reserved double words DW-4 to DW-7
> + * @sense_data_len: Sense data length DW-8 U16
> + * @desc_type: Descriptor type of sense data
> + * @additional_len: Additional length of sense data
> + * @hpb_op: HPB operation type
> + * @reserved2: Reserved field
> + * @active_rgn_cnt: Active region count
> + * @inactive_rgn_cnt: Inactive region count
> + * @hpb_active_field: Recommended to read HPB region and subregion
> + * @hpb_inactive_field: To be inactivated HPB region and subregion
> + */
> +struct utp_hpb_rsp {
> +	__be32 residual_transfer_count;
> +	__be32 reserved1[4];
> +	__be16 sense_data_len;
> +	u8 desc_type;
> +	u8 additional_len;
> +	u8 hpb_op;
> +	u8 reserved2;
> +	u8 active_rgn_cnt;
> +	u8 inactive_rgn_cnt;
> +	struct ufshpb_active_field hpb_active_field[2];
> +	__be16 hpb_inactive_field[2];
> +};
> +#define UTP_HPB_RSP_SIZE 40
> +
>  /**
>   * struct utp_upiu_rsp - general upiu response structure
>   * @header: UPIU header structure DW-0 to DW-2
> @@ -482,6 +517,7 @@ struct utp_upiu_rsp {
>  	struct utp_upiu_header header;
>  	union {
>  		struct utp_cmd_rsp sr;
> +		struct utp_hpb_rsp hr;
>  		struct utp_upiu_query qr;
>  	};
>  };
> diff --git a/drivers/scsi/ufs/ufshcd.c b/drivers/scsi/ufs/ufshcd.c
> index b8d6a52f5603..52e48de8d27c 100644
> --- a/drivers/scsi/ufs/ufshcd.c
> +++ b/drivers/scsi/ufs/ufshcd.c
> @@ -5018,6 +5018,9 @@ ufshcd_transfer_rsp_status(struct ufs_hba *hba,
> struct ufshcd_lrb *lrbp)
>  				 */
>  				pm_runtime_get_noresume(hba->dev);
>  			}
> +
> +			if (scsi_status == SAM_STAT_GOOD)
> +				ufshpb_rsp_upiu(hba, lrbp);
>  			break;
>  		case UPIU_TRANSACTION_REJECT_UPIU:
>  			/* TODO: handle Reject UPIU Response */
> @@ -9228,6 +9231,7 @@ EXPORT_SYMBOL(ufshcd_shutdown);
>  void ufshcd_remove(struct ufs_hba *hba)
>  {
>  	ufs_bsg_remove(hba);
> +	ufshpb_remove(hba);
>  	ufs_sysfs_remove_nodes(hba->dev);
>  	blk_cleanup_queue(hba->tmf_queue);
>  	blk_mq_free_tag_set(&hba->tmf_tag_set);
> diff --git a/drivers/scsi/ufs/ufshpb.c b/drivers/scsi/ufs/ufshpb.c
> index 1f84141ed384..48edfdd0f606 100644
> --- a/drivers/scsi/ufs/ufshpb.c
> +++ b/drivers/scsi/ufs/ufshpb.c
> @@ -16,11 +16,73 @@
>  #include "ufshpb.h"
>  #include "../sd.h"
> 
> +/* memory management */
> +static struct kmem_cache *ufshpb_mctx_cache;
> +static mempool_t *ufshpb_mctx_pool;
> +static mempool_t *ufshpb_page_pool;
> +/* A cache size of 2MB can cache ppn in the 1GB range. */
> +static unsigned int ufshpb_host_map_kbytes = 2048;
> +static int tot_active_srgn_pages;
> +
> +static struct workqueue_struct *ufshpb_wq;
> +
>  bool ufshpb_is_allowed(struct ufs_hba *hba)
>  {
>  	return !(hba->ufshpb_dev.hpb_disabled);
>  }
> 
> +static bool ufshpb_is_general_lun(int lun)
> +{
> +	return lun < UFS_UPIU_MAX_UNIT_NUM_ID;
> +}
> +
> +static bool
> +ufshpb_is_pinned_region(struct ufshpb_lu *hpb, int rgn_idx)
> +{
> +	if (hpb->lu_pinned_end != PINNED_NOT_SET &&
> +	    rgn_idx >= hpb->lu_pinned_start &&
> +	    rgn_idx <= hpb->lu_pinned_end)
> +		return true;
> +
> +	return false;
> +}
> +
> +static void ufshpb_kick_map_work(struct ufshpb_lu *hpb)
> +{
> +	bool ret = true;

-> ret = false;

> +	unsigned long flags;
> +
> +	spin_lock_irqsave(&hpb->rsp_list_lock, flags);
> +	if (!list_empty(&hpb->lh_inact_rgn) || 
> !list_empty(&hpb->lh_act_srgn))
> +		ret = false;

-> ret = true;

> +	spin_unlock_irqrestore(&hpb->rsp_list_lock, flags);
> +
> +	if (ret)
> +		queue_work(ufshpb_wq, &hpb->map_work);
> +}
> +
> +static bool ufshpb_is_hpb_rsp_valid(struct ufs_hba *hba,
> +					 struct ufshcd_lrb *lrbp,
> +					 struct utp_hpb_rsp *rsp_field)
> +{
> +	if (be16_to_cpu(rsp_field->sense_data_len) != DEV_SENSE_SEG_LEN ||
> +	    rsp_field->desc_type != DEV_DES_TYPE ||
> +	    rsp_field->additional_len != DEV_ADDITIONAL_LEN ||
> +	    rsp_field->hpb_op == HPB_RSP_NONE ||

HPB_RSP_NONE is checked again in switch-case, no need of this line.

> +	    rsp_field->active_rgn_cnt > MAX_ACTIVE_NUM ||
> +	    rsp_field->inactive_rgn_cnt > MAX_INACTIVE_NUM ||
> +	    (!rsp_field->active_rgn_cnt && !rsp_field->inactive_rgn_cnt))
> +		return false;
> +
> +	if (!ufshpb_is_general_lun(lrbp->lun)) {
> +		dev_warn(hba->dev, "ufshpb: lun(%d) not supported\n",
> +			 lrbp->lun);
> +		return false;
> +	}
> +
> +	return true;
> +}
> +
>  static struct ufshpb_lu *ufshpb_get_hpb_data(struct scsi_device *sdev)
>  {
>  	return sdev->hostdata;
> @@ -36,13 +98,741 @@ static void ufshpb_set_state(struct ufshpb_lu
> *hpb, int state)
>  	atomic_set(&hpb->hpb_state, state);
>  }
> 
> +static struct ufshpb_req *ufshpb_get_map_req(struct ufshpb_lu *hpb,
> +					     struct ufshpb_subregion *srgn)
> +{
> +	struct ufshpb_req *map_req;
> +	struct request *req;
> +	struct bio *bio;
> +
> +	map_req = kmem_cache_alloc(hpb->map_req_cache, GFP_KERNEL);
> +	if (!map_req)
> +		return NULL;
> +
> +	req = blk_get_request(hpb->sdev_ufs_lu->request_queue,
> +			      REQ_OP_SCSI_IN, 0);
> +	if (IS_ERR(req))
> +		goto free_map_req;
> +
> +	bio = bio_alloc(GFP_KERNEL, hpb->pages_per_srgn);
> +	if (!bio) {
> +		blk_put_request(req);
> +		goto free_map_req;
> +	}
> +
> +	map_req->hpb = hpb;
> +	map_req->req = req;
> +	map_req->bio = bio;
> +
> +	map_req->rgn_idx = srgn->rgn_idx;
> +	map_req->srgn_idx = srgn->srgn_idx;
> +	map_req->mctx = srgn->mctx;
> +
> +	return map_req;
> +
> +free_map_req:
> +	kmem_cache_free(hpb->map_req_cache, map_req);
> +	return NULL;
> +}
> +
> +static void ufshpb_put_map_req(struct ufshpb_lu *hpb,
> +				      struct ufshpb_req *map_req)
> +{
> +	bio_put(map_req->bio);
> +	blk_put_request(map_req->req);
> +	kmem_cache_free(hpb->map_req_cache, map_req);
> +}
> +
> +static int ufshpb_clear_dirty_bitmap(struct ufshpb_lu *hpb,
> +				     struct ufshpb_subregion *srgn)
> +{
> +	WARN_ON(!srgn->mctx);
> +	bitmap_zero(srgn->mctx->ppn_dirty, hpb->entries_per_srgn);
> +	return 0;
> +}
> +
> +static void ufshpb_update_active_info(struct ufshpb_lu *hpb, int 
> rgn_idx,
> +				      int srgn_idx)
> +{
> +	struct ufshpb_region *rgn;
> +	struct ufshpb_subregion *srgn;
> +
> +	rgn = hpb->rgn_tbl + rgn_idx;
> +	srgn = rgn->srgn_tbl + srgn_idx;
> +
> +	list_del_init(&rgn->list_inact_rgn);
> +
> +	if (list_empty(&srgn->list_act_srgn))
> +		list_add_tail(&srgn->list_act_srgn, &hpb->lh_act_srgn);
> +}
> +
> +static void ufshpb_update_inactive_info(struct ufshpb_lu *hpb, int 
> rgn_idx)
> +{
> +	struct ufshpb_region *rgn;
> +	struct ufshpb_subregion *srgn;
> +	int srgn_idx;
> +
> +	rgn = hpb->rgn_tbl + rgn_idx;
> +
> +	for_each_sub_region(rgn, srgn_idx, srgn)
> +		list_del_init(&srgn->list_act_srgn);
> +
> +	if (list_empty(&rgn->list_inact_rgn))
> +		list_add_tail(&rgn->list_inact_rgn, &hpb->lh_inact_rgn);
> +}
> +
> +static void ufshpb_activate_subregion(struct ufshpb_lu *hpb,
> +					  struct ufshpb_subregion *srgn)
> +{
> +	struct ufshpb_region *rgn;
> +
> +	/*
> +	 * If there is no mctx in subregion
> +	 * after I/O progress for HPB_READ_BUFFER, the region to which the
> +	 * subregion belongs was evicted.
> +	 * Mask sure the region must not evict in I/O progress
> +	 */
> +	WARN_ON(!srgn->mctx);
> +
> +	rgn = hpb->rgn_tbl + srgn->rgn_idx;
> +
> +	if (unlikely(rgn->rgn_state == HPB_RGN_INACTIVE)) {
> +		dev_err(&hpb->sdev_ufs_lu->sdev_dev,
> +			"region %d subregion %d evicted\n",
> +			srgn->rgn_idx, srgn->srgn_idx);
> +		srgn->srgn_state = HPB_SRGN_INVALID;
> +		return;
> +	}
> +	srgn->srgn_state = HPB_SRGN_VALID;
> +}
> +
> +static void ufshpb_map_req_compl_fn(struct request *req, blk_status_t 
> error)
> +{
> +	struct ufshpb_req *map_req = (struct ufshpb_req *) req->end_io_data;
> +	struct ufshpb_lu *hpb = map_req->hpb;
> +	struct ufshpb_subregion *srgn;
> +	unsigned long flags;
> +
> +	srgn = hpb->rgn_tbl[map_req->rgn_idx].srgn_tbl +
> +		map_req->srgn_idx;
> +
> +	ufshpb_clear_dirty_bitmap(hpb, srgn);
> +	spin_lock_irqsave(&hpb->rgn_state_lock, flags);
> +	ufshpb_activate_subregion(hpb, srgn);
> +	spin_unlock_irqrestore(&hpb->rgn_state_lock, flags);
> +
> +	ufshpb_put_map_req(map_req->hpb, map_req);
> +}
> +
> +static void ufshpb_set_read_buf_cmd(unsigned char *cdb, int rgn_idx,
> +					   int srgn_idx, int srgn_mem_size)
> +{
> +	cdb[0] = UFSHPB_READ_BUFFER;
> +	cdb[1] = UFSHPB_READ_BUFFER_ID;
> +
> +	put_unaligned_be16(rgn_idx, &cdb[2]);
> +	put_unaligned_be16(srgn_idx, &cdb[4]);
> +	put_unaligned_be24(srgn_mem_size, &cdb[6]);
> +
> +	cdb[9] = 0x00;
> +}
> +
> +static int ufshpb_execute_map_req(struct ufshpb_lu *hpb,
> +				  struct ufshpb_req *map_req)
> +{
> +	struct request_queue *q;
> +	struct request *req;
> +	struct scsi_request *rq;
> +	int ret = 0;
> +	int i;
> +
> +	q = hpb->sdev_ufs_lu->request_queue;
> +	for (i = 0; i < hpb->pages_per_srgn; i++) {
> +		ret = bio_add_pc_page(q, map_req->bio, map_req->mctx->m_page[i],
> +				      PAGE_SIZE, 0);
> +		if (ret != PAGE_SIZE) {
> +			dev_err(&hpb->sdev_ufs_lu->sdev_dev,
> +				   "bio_add_pc_page fail %d - %d\n",
> +				   map_req->rgn_idx, map_req->srgn_idx);
> +			return ret;
> +		}
> +	}
> +
> +	req = map_req->req;
> +
> +	blk_rq_append_bio(req, &map_req->bio);
> +
> +	req->end_io_data = map_req;
> +
> +	rq = scsi_req(req);
> +	ufshpb_set_read_buf_cmd(rq->cmd, map_req->rgn_idx,
> +				map_req->srgn_idx, hpb->srgn_mem_size);
> +	rq->cmd_len = HPB_READ_BUFFER_CMD_LENGTH;
> +
> +	blk_execute_rq_nowait(q, NULL, req, 1, ufshpb_map_req_compl_fn);
> +
> +	hpb->stats.map_req_cnt++;
> +	return 0;
> +}
> +
> +static struct ufshpb_map_ctx *ufshpb_get_map_ctx(struct ufshpb_lu 
> *hpb)
> +{
> +	struct ufshpb_map_ctx *mctx;
> +	int i, j;
> +
> +	mctx = mempool_alloc(ufshpb_mctx_pool, GFP_KERNEL);
> +	if (!mctx)
> +		return NULL;
> +
> +	mctx->m_page = kmem_cache_alloc(hpb->m_page_cache, GFP_KERNEL);
> +	if (!mctx->m_page)
> +		goto release_mctx;
> +
> +	mctx->ppn_dirty = bitmap_zalloc(hpb->entries_per_srgn, GFP_KERNEL);
> +	if (!mctx->ppn_dirty)
> +		goto release_m_page;
> +
> +	for (i = 0; i < hpb->pages_per_srgn; i++) {
> +		mctx->m_page[i] = mempool_alloc(ufshpb_page_pool, GFP_KERNEL);
> +		if (!mctx->m_page[i]) {
> +			for (j = 0; j < i; j++)
> +				mempool_free(mctx->m_page[j], ufshpb_page_pool);
> +			goto release_ppn_dirty;
> +		}
> +		clear_page(page_address(mctx->m_page[i]));
> +	}
> +
> +	return mctx;
> +
> +release_ppn_dirty:
> +	bitmap_free(mctx->ppn_dirty);
> +release_m_page:
> +	kmem_cache_free(hpb->m_page_cache, mctx->m_page);
> +release_mctx:
> +	mempool_free(mctx, ufshpb_mctx_pool);
> +	return NULL;
> +}
> +
> +static void ufshpb_put_map_ctx(struct ufshpb_lu *hpb,
> +				      struct ufshpb_map_ctx *mctx)
> +{
> +	int i;
> +
> +	for (i = 0; i < hpb->pages_per_srgn; i++)
> +		mempool_free(mctx->m_page[i], ufshpb_page_pool);
> +
> +	bitmap_free(mctx->ppn_dirty);
> +	kmem_cache_free(hpb->m_page_cache, mctx->m_page);
> +	mempool_free(mctx, ufshpb_mctx_pool);
> +}
> +
> +static int ufshpb_check_srgns_issue_state(struct ufshpb_lu *hpb,
> +					  struct ufshpb_region *rgn)
> +{
> +	struct ufshpb_subregion *srgn;
> +	int srgn_idx;
> +
> +	for_each_sub_region(rgn, srgn_idx, srgn)
> +		if (srgn->srgn_state == HPB_SRGN_ISSUED)
> +			return -EPERM;
> +
> +	return 0;
> +}
> +
> +static void ufshpb_add_lru_info(struct victim_select_info *lru_info,
> +				       struct ufshpb_region *rgn)
> +{
> +	rgn->rgn_state = HPB_RGN_ACTIVE;
> +	list_add_tail(&rgn->list_lru_rgn, &lru_info->lh_lru_rgn);
> +	atomic_inc(&lru_info->active_cnt);
> +}
> +
> +static void ufshpb_hit_lru_info(struct victim_select_info *lru_info,
> +				       struct ufshpb_region *rgn)
> +{
> +	list_move_tail(&rgn->list_lru_rgn, &lru_info->lh_lru_rgn);
> +}
> +
> +static struct ufshpb_region *ufshpb_victim_lru_info(struct ufshpb_lu 
> *hpb)
> +{
> +	struct victim_select_info *lru_info = &hpb->lru_info;
> +	struct ufshpb_region *rgn, *victim_rgn = NULL;
> +
> +	list_for_each_entry(rgn, &lru_info->lh_lru_rgn, list_lru_rgn) {
> +		WARN_ON(!rgn);
> +		if (ufshpb_check_srgns_issue_state(hpb, rgn))
> +			continue;
> +
> +		victim_rgn = rgn;
> +		break;
> +	}
> +
> +	return victim_rgn;
> +}
> +
> +static void ufshpb_cleanup_lru_info(struct victim_select_info 
> *lru_info,
> +					   struct ufshpb_region *rgn)
> +{
> +	list_del_init(&rgn->list_lru_rgn);
> +	rgn->rgn_state = HPB_RGN_INACTIVE;
> +	atomic_dec(&lru_info->active_cnt);
> +}
> +
> +static void ufshpb_purge_active_subregion(struct ufshpb_lu *hpb,
> +						 struct ufshpb_subregion *srgn)
> +{
> +	if (srgn->srgn_state != HPB_SRGN_UNUSED) {
> +		ufshpb_put_map_ctx(hpb, srgn->mctx);
> +		srgn->srgn_state = HPB_SRGN_UNUSED;
> +		srgn->mctx = NULL;
> +	}
> +}
> +
> +static void __ufshpb_evict_region(struct ufshpb_lu *hpb,
> +				  struct ufshpb_region *rgn)
> +{
> +	struct victim_select_info *lru_info;
> +	struct ufshpb_subregion *srgn;
> +	int srgn_idx;
> +
> +	lru_info = &hpb->lru_info;
> +
> +	dev_dbg(&hpb->sdev_ufs_lu->sdev_dev, "evict region %d\n", 
> rgn->rgn_idx);
> +
> +	ufshpb_cleanup_lru_info(lru_info, rgn);
> +
> +	for_each_sub_region(rgn, srgn_idx, srgn)
> +		ufshpb_purge_active_subregion(hpb, srgn);
> +}
> +
> +static int ufshpb_evict_region(struct ufshpb_lu *hpb, struct
> ufshpb_region *rgn)
> +{
> +	unsigned long flags;
> +	int ret = 0;
> +
> +	spin_lock_irqsave(&hpb->rgn_state_lock, flags);
> +	if (rgn->rgn_state == HPB_RGN_PINNED) {
> +		dev_warn(&hpb->sdev_ufs_lu->sdev_dev,
> +			 "pinned region cannot drop-out. region %d\n",
> +			 rgn->rgn_idx);
> +		goto out;
> +	}
> +	if (!list_empty(&rgn->list_lru_rgn)) {
> +		if (ufshpb_check_srgns_issue_state(hpb, rgn)) {
> +			ret = -EBUSY;
> +			goto out;
> +		}
> +
> +		__ufshpb_evict_region(hpb, rgn);
> +	}
> +out:
> +	spin_unlock_irqrestore(&hpb->rgn_state_lock, flags);
> +	return ret;
> +}
> +
> +static int ufshpb_issue_map_req(struct ufshpb_lu *hpb,
> +				struct ufshpb_region *rgn,
> +				struct ufshpb_subregion *srgn)
> +{
> +	struct ufshpb_req *map_req;
> +	unsigned long flags;
> +	int ret;
> +	int err = -EAGAIN;
> +	bool alloc_required = false;
> +	enum HPB_SRGN_STATE state = HPB_SRGN_INVALID;
> +
> +	spin_lock_irqsave(&hpb->rgn_state_lock, flags);
> +
> +	if (ufshpb_get_state(hpb) != HPB_PRESENT) {
> +		dev_notice(&hpb->sdev_ufs_lu->sdev_dev,
> +			   "%s: ufshpb state is not PRESENT\n", __func__);
> +		goto unlock_out;
> +	}
> +
> +	if ((rgn->rgn_state == HPB_RGN_INACTIVE) &&
> +	    (srgn->srgn_state == HPB_SRGN_INVALID)) {
> +		err = 0;
> +		goto unlock_out;
> +	}
> +
> +	if (srgn->srgn_state == HPB_SRGN_UNUSED)
> +		alloc_required = true;
> +
> +	/*
> +	 * If the subregion is already ISSUED state,
> +	 * a specific event (e.g., GC or wear-leveling, etc.) occurs in
> +	 * the device and HPB response for map loading is received.
> +	 * In this case, after finishing the HPB_READ_BUFFER,
> +	 * the next HPB_READ_BUFFER is performed again to obtain the latest
> +	 * map data.
> +	 */
> +	if (srgn->srgn_state == HPB_SRGN_ISSUED)
> +		goto unlock_out;
> +
> +	srgn->srgn_state = HPB_SRGN_ISSUED;
> +	spin_unlock_irqrestore(&hpb->rgn_state_lock, flags);
> +
> +	if (alloc_required) {
> +		WARN_ON(srgn->mctx);
> +		srgn->mctx = ufshpb_get_map_ctx(hpb);
> +		if (!srgn->mctx) {
> +			dev_err(&hpb->sdev_ufs_lu->sdev_dev,
> +			    "get map_ctx failed. region %d - %d\n",
> +			    rgn->rgn_idx, srgn->srgn_idx);
> +			state = HPB_SRGN_UNUSED;
> +			goto change_srgn_state;
> +		}
> +	}
> +
> +	map_req = ufshpb_get_map_req(hpb, srgn);
> +	if (!map_req)
> +		goto change_srgn_state;
> +
> +
> +	ret = ufshpb_execute_map_req(hpb, map_req);
> +	if (ret) {
> +		dev_err(&hpb->sdev_ufs_lu->sdev_dev,
> +			   "%s: issue map_req failed: %d, region %d - %d\n",
> +			   __func__, ret, srgn->rgn_idx, srgn->srgn_idx);
> +		goto free_map_req;
> +	}
> +	return 0;
> +
> +free_map_req:
> +	ufshpb_put_map_req(hpb, map_req);
> +change_srgn_state:
> +	spin_lock_irqsave(&hpb->rgn_state_lock, flags);
> +	srgn->srgn_state = state;
> +unlock_out:
> +	spin_unlock_irqrestore(&hpb->rgn_state_lock, flags);
> +	return err;
> +}
> +
> +static int ufshpb_add_region(struct ufshpb_lu *hpb, struct 
> ufshpb_region *rgn)
> +{
> +	struct ufshpb_region *victim_rgn;
> +	struct victim_select_info *lru_info = &hpb->lru_info;
> +	unsigned long flags;
> +	int ret = 0;
> +
> +	spin_lock_irqsave(&hpb->rgn_state_lock, flags);
> +	/*
> +	 * If region belongs to lru_list, just move the region
> +	 * to the front of lru list. because the state of the region
> +	 * is already active-state
> +	 */
> +	if (!list_empty(&rgn->list_lru_rgn)) {
> +		ufshpb_hit_lru_info(lru_info, rgn);
> +		goto out;
> +	}
> +
> +	if (rgn->rgn_state == HPB_RGN_INACTIVE) {
> +		if (atomic_read(&lru_info->active_cnt) ==
> +		    lru_info->max_lru_active_cnt) {
> +			/*
> +			 * If the maximum number of active regions
> +			 * is exceeded, evict the least recently used region.
> +			 * This case may occur when the device responds
> +			 * to the eviction information late.
> +			 * It is okay to evict the least recently used region,
> +			 * because the device could detect this region
> +			 * by not issuing HPB_READ
> +			 */
> +			victim_rgn = ufshpb_victim_lru_info(hpb);
> +			if (!victim_rgn) {
> +				dev_warn(&hpb->sdev_ufs_lu->sdev_dev,
> +				    "cannot get victim region error\n");
> +				ret = -ENOMEM;
> +				goto out;
> +			}
> +
> +			dev_dbg(&hpb->sdev_ufs_lu->sdev_dev,
> +				"LRU full (%d), choose victim %d\n",
> +				atomic_read(&lru_info->active_cnt),
> +				victim_rgn->rgn_idx);
> +			__ufshpb_evict_region(hpb, victim_rgn);
> +		}
> +
> +		/*
> +		 * When a region is added to lru_info list_head,
> +		 * it is guaranteed that the subregion has been
> +		 * assigned all mctx. If failed, try to receive mctx again
> +		 * without being added to lru_info list_head
> +		 */
> +		ufshpb_add_lru_info(lru_info, rgn);
> +	}
> +out:
> +	spin_unlock_irqrestore(&hpb->rgn_state_lock, flags);
> +	return ret;
> +}
> +
> +static void ufshpb_rsp_req_region_update(struct ufshpb_lu *hpb,
> +					 struct utp_hpb_rsp *rsp_field)
> +{
> +	int i, rgn_idx, srgn_idx;
> +
> +	BUILD_BUG_ON(sizeof(struct ufshpb_active_field) != 
> HPB_ACT_FIELD_SIZE);
> +	/*
> +	 * If the active region and the inactive region are the same,
> +	 * we will inactivate this region.
> +	 * The device could check this (region inactivated) and
> +	 * will response the proper active region information
> +	 */
> +	spin_lock(&hpb->rsp_list_lock);
> +	for (i = 0; i < rsp_field->active_rgn_cnt; i++) {
> +		rgn_idx =
> +			be16_to_cpu(rsp_field->hpb_active_field[i].active_rgn);
> +		srgn_idx =
> +			be16_to_cpu(rsp_field->hpb_active_field[i].active_srgn);
> +
> +		dev_dbg(&hpb->sdev_ufs_lu->sdev_dev,
> +			"activate(%d) region %d - %d\n", i, rgn_idx, srgn_idx);
> +		ufshpb_update_active_info(hpb, rgn_idx, srgn_idx);
> +		hpb->stats.rb_active_cnt++;
> +	}
> +
> +	for (i = 0; i < rsp_field->inactive_rgn_cnt; i++) {
> +		rgn_idx = be16_to_cpu(rsp_field->hpb_inactive_field[i]);
> +		dev_dbg(&hpb->sdev_ufs_lu->sdev_dev,
> +			"inactivate(%d) region %d\n", i, rgn_idx);
> +		ufshpb_update_inactive_info(hpb, rgn_idx);
> +		hpb->stats.rb_inactive_cnt++;
> +	}
> +	spin_unlock(&hpb->rsp_list_lock);
> +
> +	dev_dbg(&hpb->sdev_ufs_lu->sdev_dev, "Noti: #ACT %u #INACT %u\n",
> +		rsp_field->active_rgn_cnt, rsp_field->inactive_rgn_cnt);
> +
> +	queue_work(ufshpb_wq, &hpb->map_work);
> +}
> +
> +/*
> + * This function will parse recommended active subregion information 
> in sense
> + * data field of response UPIU with SAM_STAT_GOOD state.
> + */
> +void ufshpb_rsp_upiu(struct ufs_hba *hba, struct ufshcd_lrb *lrbp)
> +{
> +	struct ufshpb_lu *hpb = ufshpb_get_hpb_data(lrbp->cmd->device);
> +	struct utp_hpb_rsp *rsp_field;
> +	int data_seg_len;
> +
> +	if (!hpb)
> +		return;

You are assuming HPB recommandations only come in responses to LUs
with HPB enabled, but the specs says the recommandations can come
in any responses with GOOD status, meaning you should check the *hpb
which belongs to the LUN in res_field, but not the one belongs to
lrbp->cmd->device.

Regards,

Can Guo

> +
> +	if (ufshpb_get_state(hpb) != HPB_PRESENT) {
> +		dev_notice(&hpb->sdev_ufs_lu->sdev_dev,
> +			   "%s: ufshpb state is not PRESENT\n", __func__);
> +		return;
> +	}
> +
> +	data_seg_len = be32_to_cpu(lrbp->ucd_rsp_ptr->header.dword_2)
> +		& MASK_RSP_UPIU_DATA_SEG_LEN;
> +
> +	/* To flush remained rsp_list, we queue the map_work task */
> +	if (!data_seg_len) {
> +		if (!ufshpb_is_general_lun(lrbp->lun))
> +			return;
> +
> +		ufshpb_kick_map_work(hpb);
> +		return;
> +	}
> +
> +	/* Check HPB_UPDATE_ALERT */
> +	if (!(lrbp->ucd_rsp_ptr->header.dword_2 &
> +	      UPIU_HEADER_DWORD(0, 2, 0, 0)))
> +		return;
> +
> +	rsp_field = &lrbp->ucd_rsp_ptr->hr;
> +	BUILD_BUG_ON(sizeof(struct utp_hpb_rsp) != UTP_HPB_RSP_SIZE);
> +
> +	if (!ufshpb_is_hpb_rsp_valid(hba, lrbp, rsp_field))
> +		return;
> +
> +	hpb->stats.rb_noti_cnt++;
> +
> +	switch (rsp_field->hpb_op) {
> +	case HPB_RSP_NONE:
> +		/* nothing to do */
> +		break;
> +	case HPB_RSP_REQ_REGION_UPDATE:
> +		WARN_ON(data_seg_len != DEV_DATA_SEG_LEN);
> +		ufshpb_rsp_req_region_update(hpb, rsp_field);
> +		break;
> +	case HPB_RSP_DEV_RESET:
> +		dev_warn(&hpb->sdev_ufs_lu->sdev_dev,
> +			 "UFS device lost HPB information during PM.\n");
> +		break;
> +	default:
> +		dev_notice(&hpb->sdev_ufs_lu->sdev_dev,
> +			   "hpb_op is not available: %d\n",
> +			   rsp_field->hpb_op);
> +		break;
> +	}
> +}
> +
> +static void ufshpb_add_active_list(struct ufshpb_lu *hpb,
> +				   struct ufshpb_region *rgn,
> +				   struct ufshpb_subregion *srgn)
> +{
> +	if (!list_empty(&rgn->list_inact_rgn))
> +		return;
> +
> +	if (!list_empty(&srgn->list_act_srgn)) {
> +		list_move(&srgn->list_act_srgn, &hpb->lh_act_srgn);
> +		return;
> +	}
> +
> +	list_add(&srgn->list_act_srgn, &hpb->lh_act_srgn);
> +}
> +
> +static void ufshpb_add_pending_evict_list(struct ufshpb_lu *hpb,
> +				    struct ufshpb_region *rgn,
> +				    struct list_head *pending_list)
> +{
> +	struct ufshpb_subregion *srgn;
> +	int srgn_idx;
> +
> +	if (!list_empty(&rgn->list_inact_rgn))
> +		return;
> +
> +	for_each_sub_region(rgn, srgn_idx, srgn)
> +		if (!list_empty(&srgn->list_act_srgn))
> +			return;
> +
> +	list_add_tail(&rgn->list_inact_rgn, pending_list);
> +}
> +
> +static void ufshpb_run_active_subregion_list(struct ufshpb_lu *hpb)
> +{
> +	struct ufshpb_region *rgn;
> +	struct ufshpb_subregion *srgn;
> +	unsigned long flags;
> +	int ret = 0;
> +
> +	spin_lock_irqsave(&hpb->rsp_list_lock, flags);
> +	while ((srgn = list_first_entry_or_null(&hpb->lh_act_srgn,
> +						struct ufshpb_subregion,
> +						list_act_srgn))) {
> +		if (ufshpb_get_state(hpb) == HPB_SUSPEND)
> +			break;
> +
> +		list_del_init(&srgn->list_act_srgn);
> +		spin_unlock_irqrestore(&hpb->rsp_list_lock, flags);
> +
> +		rgn = hpb->rgn_tbl + srgn->rgn_idx;
> +		ret = ufshpb_add_region(hpb, rgn);
> +		if (ret)
> +			goto active_failed;
> +
> +		ret = ufshpb_issue_map_req(hpb, rgn, srgn);
> +		if (ret) {
> +			dev_err(&hpb->sdev_ufs_lu->sdev_dev,
> +			    "issue map_req failed. ret %d, region %d - %d\n",
> +			    ret, rgn->rgn_idx, srgn->srgn_idx);
> +			goto active_failed;
> +		}
> +		spin_lock_irqsave(&hpb->rsp_list_lock, flags);
> +	}
> +	spin_unlock_irqrestore(&hpb->rsp_list_lock, flags);
> +	return;
> +
> +active_failed:
> +	dev_err(&hpb->sdev_ufs_lu->sdev_dev, "failed to activate region %d -
> %d, will retry\n",
> +		   rgn->rgn_idx, srgn->srgn_idx);
> +	spin_lock_irqsave(&hpb->rsp_list_lock, flags);
> +	ufshpb_add_active_list(hpb, rgn, srgn);
> +	spin_unlock_irqrestore(&hpb->rsp_list_lock, flags);
> +}
> +
> +static void ufshpb_run_inactive_region_list(struct ufshpb_lu *hpb)
> +{
> +	struct ufshpb_region *rgn;
> +	unsigned long flags;
> +	int ret;
> +	LIST_HEAD(pending_list);
> +
> +	spin_lock_irqsave(&hpb->rsp_list_lock, flags);
> +	while ((rgn = list_first_entry_or_null(&hpb->lh_inact_rgn,
> +					       struct ufshpb_region,
> +					       list_inact_rgn))) {
> +		if (ufshpb_get_state(hpb) == HPB_SUSPEND)
> +			break;
> +
> +		list_del_init(&rgn->list_inact_rgn);
> +		spin_unlock_irqrestore(&hpb->rsp_list_lock, flags);
> +
> +		ret = ufshpb_evict_region(hpb, rgn);
> +		if (ret) {
> +			spin_lock_irqsave(&hpb->rsp_list_lock, flags);
> +			ufshpb_add_pending_evict_list(hpb, rgn, &pending_list);
> +			spin_unlock_irqrestore(&hpb->rsp_list_lock, flags);
> +		}
> +
> +		spin_lock_irqsave(&hpb->rsp_list_lock, flags);
> +	}
> +
> +	list_splice(&pending_list, &hpb->lh_inact_rgn);
> +	spin_unlock_irqrestore(&hpb->rsp_list_lock, flags);
> +}
> +
> +static void ufshpb_map_work_handler(struct work_struct *work)
> +{
> +	struct ufshpb_lu *hpb = container_of(work, struct ufshpb_lu, 
> map_work);
> +
> +	if (ufshpb_get_state(hpb) != HPB_PRESENT) {
> +		dev_notice(&hpb->sdev_ufs_lu->sdev_dev,
> +			   "%s: ufshpb state is not PRESENT\n", __func__);
> +		return;
> +	}
> +
> +	ufshpb_run_inactive_region_list(hpb);
> +	ufshpb_run_active_subregion_list(hpb);
> +}
> +
> +/*
> + * this function doesn't need to hold lock due to be called in init.
> + * (rgn_state_lock, rsp_list_lock, etc..)
> + */
> +static int ufshpb_init_pinned_active_region(struct ufs_hba *hba,
> +					    struct ufshpb_lu *hpb,
> +					    struct ufshpb_region *rgn)
> +{
> +	struct ufshpb_subregion *srgn;
> +	int srgn_idx, i;
> +	int err = 0;
> +
> +	for_each_sub_region(rgn, srgn_idx, srgn) {
> +		srgn->mctx = ufshpb_get_map_ctx(hpb);
> +		srgn->srgn_state = HPB_SRGN_INVALID;
> +		if (!srgn->mctx) {
> +			err = -ENOMEM;
> +			dev_err(hba->dev,
> +				"alloc mctx for pinned region failed\n");
> +			goto release;
> +		}
> +
> +		list_add_tail(&srgn->list_act_srgn, &hpb->lh_act_srgn);
> +	}
> +
> +	rgn->rgn_state = HPB_RGN_PINNED;
> +	return 0;
> +
> +release:
> +	for (i = 0; i < srgn_idx; i++) {
> +		srgn = rgn->srgn_tbl + i;
> +		ufshpb_put_map_ctx(hpb, srgn->mctx);
> +	}
> +	return err;
> +}
> +
>  static void ufshpb_init_subregion_tbl(struct ufshpb_lu *hpb,
>  				      struct ufshpb_region *rgn)
>  {
>  	int srgn_idx;
> +	struct ufshpb_subregion *srgn;
> 
> -	for (srgn_idx = 0; srgn_idx < rgn->srgn_cnt; srgn_idx++) {
> -		struct ufshpb_subregion *srgn = rgn->srgn_tbl + srgn_idx;
> +	for_each_sub_region(rgn, srgn_idx, srgn) {
> +		INIT_LIST_HEAD(&srgn->list_act_srgn);
> 
>  		srgn->rgn_idx = rgn->rgn_idx;
>  		srgn->srgn_idx = srgn_idx;
> @@ -75,6 +865,8 @@ static void ufshpb_lu_parameter_init(struct ufs_hba 
> *hba,
>  	hpb->lu_pinned_end = hpb_lu_info->num_pinned ?
>  		(hpb_lu_info->pinned_start + hpb_lu_info->num_pinned - 1)
>  		: PINNED_NOT_SET;
> +	hpb->lru_info.max_lru_active_cnt =
> +		hpb_lu_info->max_active_rgns - hpb_lu_info->num_pinned;
> 
>  	rgn_mem_size = (1ULL << hpb_dev_info->rgn_size) * HPB_RGN_SIZE_UNIT
>  			* HPB_ENTRY_SIZE;
> @@ -123,6 +915,9 @@ static int ufshpb_alloc_region_tbl(struct ufs_hba
> *hba, struct ufshpb_lu *hpb)
>  		rgn = rgn_table + rgn_idx;
>  		rgn->rgn_idx = rgn_idx;
> 
> +		INIT_LIST_HEAD(&rgn->list_inact_rgn);
> +		INIT_LIST_HEAD(&rgn->list_lru_rgn);
> +
>  		if (rgn_idx == hpb->rgns_per_lu - 1)
>  			srgn_cnt = ((hpb->srgns_per_lu - 1) %
>  				    hpb->srgns_per_rgn) + 1;
> @@ -132,7 +927,13 @@ static int ufshpb_alloc_region_tbl(struct ufs_hba
> *hba, struct ufshpb_lu *hpb)
>  			goto release_srgn_table;
>  		ufshpb_init_subregion_tbl(hpb, rgn);
> 
> -		rgn->rgn_state = HPB_RGN_INACTIVE;
> +		if (ufshpb_is_pinned_region(hpb, rgn_idx)) {
> +			ret = ufshpb_init_pinned_active_region(hba, hpb, rgn);
> +			if (ret)
> +				goto release_srgn_table;
> +		} else {
> +			rgn->rgn_state = HPB_RGN_INACTIVE;
> +		}
>  	}
> 
>  	return 0;
> @@ -151,13 +952,13 @@ static void ufshpb_destroy_subregion_tbl(struct
> ufshpb_lu *hpb,
>  					 struct ufshpb_region *rgn)
>  {
>  	int srgn_idx;
> +	struct ufshpb_subregion *srgn;
> 
> -	for (srgn_idx = 0; srgn_idx < rgn->srgn_cnt; srgn_idx++) {
> -		struct ufshpb_subregion *srgn;
> -
> -		srgn = rgn->srgn_tbl + srgn_idx;
> -		srgn->srgn_state = HPB_SRGN_UNUSED;
> -	}
> +	for_each_sub_region(rgn, srgn_idx, srgn)
> +		if (srgn->srgn_state != HPB_SRGN_UNUSED) {
> +			srgn->srgn_state = HPB_SRGN_UNUSED;
> +			ufshpb_put_map_ctx(hpb, srgn->mctx);
> +		}
>  }
> 
>  static void ufshpb_destroy_region_tbl(struct ufshpb_lu *hpb)
> @@ -231,11 +1032,47 @@ static int ufshpb_lu_hpb_init(struct ufs_hba
> *hba, struct ufshpb_lu *hpb)
>  {
>  	int ret;
> 
> +	spin_lock_init(&hpb->rgn_state_lock);
> +	spin_lock_init(&hpb->rsp_list_lock);
> +
> +	INIT_LIST_HEAD(&hpb->lru_info.lh_lru_rgn);
> +	INIT_LIST_HEAD(&hpb->lh_act_srgn);
> +	INIT_LIST_HEAD(&hpb->lh_inact_rgn);
> +	INIT_LIST_HEAD(&hpb->list_hpb_lu);
> +
> +	INIT_WORK(&hpb->map_work, ufshpb_map_work_handler);
> +
> +	hpb->map_req_cache = kmem_cache_create("ufshpb_req_cache",
> +			  sizeof(struct ufshpb_req), 0, 0, NULL);
> +	if (!hpb->map_req_cache) {
> +		dev_err(hba->dev, "ufshpb(%d) ufshpb_req_cache create fail",
> +			hpb->lun);
> +		return -ENOMEM;
> +	}
> +
> +	hpb->m_page_cache = kmem_cache_create("ufshpb_m_page_cache",
> +			  sizeof(struct page *) * hpb->pages_per_srgn,
> +			  0, 0, NULL);
> +	if (!hpb->m_page_cache) {
> +		dev_err(hba->dev, "ufshpb(%d) ufshpb_m_page_cache create fail",
> +			hpb->lun);
> +		ret = -ENOMEM;
> +		goto release_req_cache;
> +	}
> +
>  	ret = ufshpb_alloc_region_tbl(hba, hpb);
> +	if (ret)
> +		goto release_m_page_cache;
> 
>  	ufshpb_stat_init(hpb);
> 
>  	return 0;
> +
> +release_m_page_cache:
> +	kmem_cache_destroy(hpb->m_page_cache);
> +release_req_cache:
> +	kmem_cache_destroy(hpb->map_req_cache);
> +	return ret;
>  }
> 
>  static struct ufshpb_lu *ufshpb_alloc_hpb_lu(struct ufs_hba *hba, int 
> lun,
> @@ -266,6 +1103,33 @@ static struct ufshpb_lu
> *ufshpb_alloc_hpb_lu(struct ufs_hba *hba, int lun,
>  	return NULL;
>  }
> 
> +static void ufshpb_discard_rsp_lists(struct ufshpb_lu *hpb)
> +{
> +	struct ufshpb_region *rgn, *next_rgn;
> +	struct ufshpb_subregion *srgn, *next_srgn;
> +	unsigned long flags;
> +
> +	/*
> +	 * If the device reset occurred, the remained HPB region information
> +	 * may be stale. Therefore, by dicarding the lists of HPB response
> +	 * that remained after reset, it prevents unnecessary work.
> +	 */
> +	spin_lock_irqsave(&hpb->rsp_list_lock, flags);
> +	list_for_each_entry_safe(rgn, next_rgn, &hpb->lh_inact_rgn,
> +				 list_inact_rgn)
> +		list_del_init(&rgn->list_inact_rgn);
> +
> +	list_for_each_entry_safe(srgn, next_srgn, &hpb->lh_act_srgn,
> +				 list_act_srgn)
> +		list_del_init(&srgn->list_act_srgn);
> +	spin_unlock_irqrestore(&hpb->rsp_list_lock, flags);
> +}
> +
> +static void ufshpb_cancel_jobs(struct ufshpb_lu *hpb)
> +{
> +	cancel_work_sync(&hpb->map_work);
> +}
> +
>  static bool ufshpb_check_hpb_reset_query(struct ufs_hba *hba)
>  {
>  	int err = 0;
> @@ -309,7 +1173,7 @@ void ufshpb_reset(struct ufs_hba *hba)
>  	struct scsi_device *sdev;
> 
>  	shost_for_each_device(sdev, hba->host) {
> -		hpb = sdev->hostdata;
> +		hpb = ufshpb_get_hpb_data(sdev);
>  		if (!hpb)
>  			continue;
> 
> @@ -326,13 +1190,15 @@ void ufshpb_reset_host(struct ufs_hba *hba)
>  	struct scsi_device *sdev;
> 
>  	shost_for_each_device(sdev, hba->host) {
> -		hpb = sdev->hostdata;
> +		hpb = ufshpb_get_hpb_data(sdev);
>  		if (!hpb)
>  			continue;
> 
>  		if (ufshpb_get_state(hpb) != HPB_PRESENT)
>  			continue;
>  		ufshpb_set_state(hpb, HPB_RESET);
> +		ufshpb_cancel_jobs(hpb);
> +		ufshpb_discard_rsp_lists(hpb);
>  	}
>  }
> 
> @@ -342,13 +1208,14 @@ void ufshpb_suspend(struct ufs_hba *hba)
>  	struct scsi_device *sdev;
> 
>  	shost_for_each_device(sdev, hba->host) {
> -		hpb = sdev->hostdata;
> +		hpb = ufshpb_get_hpb_data(sdev);
>  		if (!hpb)
>  			continue;
> 
>  		if (ufshpb_get_state(hpb) != HPB_PRESENT)
>  			continue;
>  		ufshpb_set_state(hpb, HPB_SUSPEND);
> +		ufshpb_cancel_jobs(hpb);
>  	}
>  }
> 
> @@ -358,7 +1225,7 @@ void ufshpb_resume(struct ufs_hba *hba)
>  	struct scsi_device *sdev;
> 
>  	shost_for_each_device(sdev, hba->host) {
> -		hpb = sdev->hostdata;
> +		hpb = ufshpb_get_hpb_data(sdev);
>  		if (!hpb)
>  			continue;
> 
> @@ -366,6 +1233,7 @@ void ufshpb_resume(struct ufs_hba *hba)
>  		    (ufshpb_get_state(hpb) != HPB_SUSPEND))
>  			continue;
>  		ufshpb_set_state(hpb, HPB_PRESENT);
> +		ufshpb_kick_map_work(hpb);
>  	}
>  }
> 
> @@ -418,7 +1286,7 @@ static int ufshpb_get_lu_info(struct ufs_hba *hba, 
> int lun,
> 
>  void ufshpb_destroy_lu(struct ufs_hba *hba, struct scsi_device *sdev)
>  {
> -	struct ufshpb_lu *hpb = sdev->hostdata;
> +	struct ufshpb_lu *hpb = ufshpb_get_hpb_data(sdev);
> 
>  	if (!hpb)
>  		return;
> @@ -428,8 +1296,13 @@ void ufshpb_destroy_lu(struct ufs_hba *hba,
> struct scsi_device *sdev)
>  	sdev = hpb->sdev_ufs_lu;
>  	sdev->hostdata = NULL;
> 
> +	ufshpb_cancel_jobs(hpb);
> +
>  	ufshpb_destroy_region_tbl(hpb);
> 
> +	kmem_cache_destroy(hpb->map_req_cache);
> +	kmem_cache_destroy(hpb->m_page_cache);
> +
>  	list_del_init(&hpb->list_hpb_lu);
> 
>  	kfree(hpb);
> @@ -437,24 +1310,41 @@ void ufshpb_destroy_lu(struct ufs_hba *hba,
> struct scsi_device *sdev)
> 
>  static void ufshpb_hpb_lu_prepared(struct ufs_hba *hba)
>  {
> +	int pool_size;
>  	struct ufshpb_lu *hpb;
>  	struct scsi_device *sdev;
>  	bool init_success;
> 
> +	if (tot_active_srgn_pages == 0) {
> +		ufshpb_remove(hba);
> +		return;
> +	}
> +
>  	init_success = !ufshpb_check_hpb_reset_query(hba);
> 
> +	pool_size = PAGE_ALIGN(ufshpb_host_map_kbytes * 1024) / PAGE_SIZE;
> +	if (pool_size > tot_active_srgn_pages) {
> +		mempool_resize(ufshpb_mctx_pool, tot_active_srgn_pages);
> +		mempool_resize(ufshpb_page_pool, tot_active_srgn_pages);
> +	}
> +
>  	shost_for_each_device(sdev, hba->host) {
> -		hpb = sdev->hostdata;
> +		hpb = ufshpb_get_hpb_data(sdev);
>  		if (!hpb)
>  			continue;
> 
>  		if (init_success) {
>  			ufshpb_set_state(hpb, HPB_PRESENT);
> +			if ((hpb->lu_pinned_end - hpb->lu_pinned_start) > 0)
> +				queue_work(ufshpb_wq, &hpb->map_work);
>  		} else {
>  			dev_err(hba->dev, "destroy HPB lu %d\n", hpb->lun);
>  			ufshpb_destroy_lu(hba, sdev);
>  		}
>  	}
> +
> +	if (!init_success)
> +		ufshpb_remove(hba);
>  }
> 
>  void ufshpb_init_hpb_lu(struct ufs_hba *hba, struct scsi_device *sdev)
> @@ -476,6 +1366,9 @@ void ufshpb_init_hpb_lu(struct ufs_hba *hba,
> struct scsi_device *sdev)
>  	if (!hpb)
>  		goto out;
> 
> +	tot_active_srgn_pages += hpb_lu_info.max_active_rgns *
> +			hpb->srgns_per_rgn * hpb->pages_per_srgn;
> +
>  	hpb->sdev_ufs_lu = sdev;
>  	sdev->hostdata = hpb;
> 
> @@ -485,6 +1378,57 @@ void ufshpb_init_hpb_lu(struct ufs_hba *hba,
> struct scsi_device *sdev)
>  		ufshpb_hpb_lu_prepared(hba);
>  }
> 
> +static int ufshpb_init_mem_wq(void)
> +{
> +	int ret;
> +	unsigned int pool_size;
> +
> +	ufshpb_mctx_cache = kmem_cache_create("ufshpb_mctx_cache",
> +					sizeof(struct ufshpb_map_ctx),
> +					0, 0, NULL);
> +	if (!ufshpb_mctx_cache) {
> +		pr_err("ufshpb: cannot init mctx cache\n");
> +		return -ENOMEM;
> +	}
> +
> +	pool_size = PAGE_ALIGN(ufshpb_host_map_kbytes * 1024) / PAGE_SIZE;
> +	pr_info("%s:%d ufshpb_host_map_kbytes %u pool_size %u\n",
> +	       __func__, __LINE__, ufshpb_host_map_kbytes, pool_size);
> +
> +	ufshpb_mctx_pool = mempool_create_slab_pool(pool_size,
> +						    ufshpb_mctx_cache);
> +	if (!ufshpb_mctx_pool) {
> +		pr_err("ufshpb: cannot init mctx pool\n");
> +		ret = -ENOMEM;
> +		goto release_mctx_cache;
> +	}
> +
> +	ufshpb_page_pool = mempool_create_page_pool(pool_size, 0);
> +	if (!ufshpb_page_pool) {
> +		pr_err("ufshpb: cannot init page pool\n");
> +		ret = -ENOMEM;
> +		goto release_mctx_pool;
> +	}
> +
> +	ufshpb_wq = alloc_workqueue("ufshpb-wq",
> +					WQ_UNBOUND | WQ_MEM_RECLAIM, 0);
> +	if (!ufshpb_wq) {
> +		pr_err("ufshpb: alloc workqueue failed\n");
> +		ret = -ENOMEM;
> +		goto release_page_pool;
> +	}
> +
> +	return 0;
> +
> +release_page_pool:
> +	mempool_destroy(ufshpb_page_pool);
> +release_mctx_pool:
> +	mempool_destroy(ufshpb_mctx_pool);
> +release_mctx_cache:
> +	kmem_cache_destroy(ufshpb_mctx_cache);
> +	return ret;
> +}
> +
>  void ufshpb_get_geo_info(struct ufs_hba *hba, u8 *geo_buf)
>  {
>  	struct ufshpb_dev_info *hpb_dev_info = &hba->ufshpb_dev;
> @@ -550,7 +1494,13 @@ void ufshpb_init(struct ufs_hba *hba)
>  	if (!ufshpb_is_allowed(hba))
>  		return;
> 
> +	if (ufshpb_init_mem_wq()) {
> +		hpb_dev_info->hpb_disabled = true;
> +		return;
> +	}
> +
>  	atomic_set(&hpb_dev_info->slave_conf_cnt, hpb_dev_info->num_lu);
> +	tot_active_srgn_pages = 0;
>  	/* issue HPB reset query */
>  	for (try = 0; try < HPB_RESET_REQ_RETRIES; try++) {
>  		ret = ufshcd_query_flag(hba, UPIU_QUERY_OPCODE_SET_FLAG,
> @@ -559,3 +1509,16 @@ void ufshpb_init(struct ufs_hba *hba)
>  			break;
>  	}
>  }
> +
> +void ufshpb_remove(struct ufs_hba *hba)
> +{
> +	mempool_destroy(ufshpb_page_pool);
> +	mempool_destroy(ufshpb_mctx_pool);
> +	kmem_cache_destroy(ufshpb_mctx_cache);
> +
> +	destroy_workqueue(ufshpb_wq);
> +}
> +
> +module_param(ufshpb_host_map_kbytes, uint, 0644);
> +MODULE_PARM_DESC(ufshpb_host_map_kbytes,
> +	"ufshpb host mapping memory kilo-bytes for ufshpb memory-pool");
> diff --git a/drivers/scsi/ufs/ufshpb.h b/drivers/scsi/ufs/ufshpb.h
> index 50523821cac8..e40b016971ac 100644
> --- a/drivers/scsi/ufs/ufshpb.h
> +++ b/drivers/scsi/ufs/ufshpb.h
> @@ -83,10 +83,19 @@ struct ufshpb_lu_info {
>  	int max_active_rgns;
>  };
> 
> +struct ufshpb_map_ctx {
> +	struct page **m_page;
> +	unsigned long *ppn_dirty;
> +};
> +
>  struct ufshpb_subregion {
> +	struct ufshpb_map_ctx *mctx;
>  	enum HPB_SRGN_STATE srgn_state;
>  	int rgn_idx;
>  	int srgn_idx;
> +
> +	/* below information is used by rsp_list */
> +	struct list_head list_act_srgn;
>  };
> 
>  struct ufshpb_region {
> @@ -94,6 +103,43 @@ struct ufshpb_region {
>  	enum HPB_RGN_STATE rgn_state;
>  	int rgn_idx;
>  	int srgn_cnt;
> +
> +	/* below information is used by rsp_list */
> +	struct list_head list_inact_rgn;
> +
> +	/* below information is used by lru */
> +	struct list_head list_lru_rgn;
> +};
> +
> +#define for_each_sub_region(rgn, i, srgn)				\
> +	for ((i) = 0;							\
> +	     ((i) < (rgn)->srgn_cnt) && ((srgn) = &(rgn)->srgn_tbl[i]); \
> +	     (i)++)
> +
> +/**
> + * struct ufshpb_req - UFSHPB READ BUFFER (for caching map) request 
> structure
> + * @req: block layer request for READ BUFFER
> + * @bio: bio for holding map page
> + * @hpb: ufshpb_lu structure that related to the L2P map
> + * @mctx: L2P map information
> + * @rgn_idx: target region index
> + * @srgn_idx: target sub-region index
> + * @lun: target logical unit number
> + */
> +struct ufshpb_req {
> +	struct request *req;
> +	struct bio *bio;
> +	struct ufshpb_lu *hpb;
> +	struct ufshpb_map_ctx *mctx;
> +
> +	unsigned int rgn_idx;
> +	unsigned int srgn_idx;
> +};
> +
> +struct victim_select_info {
> +	struct list_head lh_lru_rgn; /* LRU list of regions */
> +	int max_lru_active_cnt; /* supported hpb #region - pinned #region */
> +	atomic_t active_cnt;
>  };
> 
>  struct ufshpb_stats {
> @@ -108,10 +154,22 @@ struct ufshpb_stats {
>  struct ufshpb_lu {
>  	int lun;
>  	struct scsi_device *sdev_ufs_lu;
> +
> +	spinlock_t rgn_state_lock; /* for protect rgn/srgn state */
>  	struct ufshpb_region *rgn_tbl;
> 
>  	atomic_t hpb_state;
> 
> +	spinlock_t rsp_list_lock;
> +	struct list_head lh_act_srgn; /* hold rsp_list_lock */
> +	struct list_head lh_inact_rgn; /* hold rsp_list_lock */
> +
> +	/* cached L2P map management worker */
> +	struct work_struct map_work;
> +
> +	/* for selecting victim */
> +	struct victim_select_info lru_info;
> +
>  	/* pinned region information */
>  	u32 lu_pinned_start;
>  	u32 lu_pinned_end;
> @@ -130,6 +188,9 @@ struct ufshpb_lu {
> 
>  	struct ufshpb_stats stats;
> 
> +	struct kmem_cache *map_req_cache;
> +	struct kmem_cache *m_page_cache;
> +
>  	struct list_head list_hpb_lu;
>  };
> 
> @@ -137,6 +198,7 @@ struct ufs_hba;
>  struct ufshcd_lrb;
> 
>  #ifndef CONFIG_SCSI_UFS_HPB
> +static void ufshpb_rsp_upiu(struct ufs_hba *hba, struct ufshcd_lrb 
> *lrbp) {}
>  static void ufshpb_resume(struct ufs_hba *hba) {}
>  static void ufshpb_suspend(struct ufs_hba *hba) {}
>  static void ufshpb_reset(struct ufs_hba *hba) {}
> @@ -144,10 +206,12 @@ static void ufshpb_reset_host(struct ufs_hba 
> *hba) {}
>  static void ufshpb_init(struct ufs_hba *hba) {}
>  static void ufshpb_init_hpb_lu(struct ufs_hba *hba, struct
> scsi_device *sdev) {}
>  static void ufshpb_destroy_lu(struct ufs_hba *hba, struct scsi_device 
> *sdev) {}
> +static void ufshpb_remove(struct ufs_hba *hba) {}
>  static bool ufshpb_is_allowed(struct ufs_hba *hba) { return false; }
>  static void ufshpb_get_geo_info(struct ufs_hba *hba, u8 *geo_buf) {}
>  static void ufshpb_get_dev_info(struct ufs_hba *hba, u8 *desc_buf) {}
>  #else
> +void ufshpb_rsp_upiu(struct ufs_hba *hba, struct ufshcd_lrb *lrbp);
>  void ufshpb_resume(struct ufs_hba *hba);
>  void ufshpb_suspend(struct ufs_hba *hba);
>  void ufshpb_reset(struct ufs_hba *hba);
> @@ -155,6 +219,7 @@ void ufshpb_reset_host(struct ufs_hba *hba);
>  void ufshpb_init(struct ufs_hba *hba);
>  void ufshpb_init_hpb_lu(struct ufs_hba *hba, struct scsi_device 
> *sdev);
>  void ufshpb_destroy_lu(struct ufs_hba *hba, struct scsi_device *sdev);
> +void ufshpb_remove(struct ufs_hba *hba);
>  bool ufshpb_is_allowed(struct ufs_hba *hba);
>  void ufshpb_get_geo_info(struct ufs_hba *hba, u8 *geo_buf);
>  void ufshpb_get_dev_info(struct ufs_hba *hba, u8 *desc_buf);

Re: [PATCH v19 2/3] scsi: ufs: L2P map management for HPB read

[Bean Huo]

On Sat, 2021-02-06 at 15:23 +0800, Can Guo wrote:
> > +     dev_dbg(&hpb->sdev_ufs_lu->sdev_dev, "Noti: #ACT %u #INACT
> > %u\n",
> > +             rsp_field->active_rgn_cnt, rsp_field-
> > >inactive_rgn_cnt);
> > +
> > +     queue_work(ufshpb_wq, &hpb->map_work);
> > +}
> > +
> > +/*
> > + * This function will parse recommended active subregion
> > information 
> > in sense
> > + * data field of response UPIU with SAM_STAT_GOOD state.
> > + */
> > +void ufshpb_rsp_upiu(struct ufs_hba *hba, struct ufshcd_lrb *lrbp)
> > +{
> > +     struct ufshpb_lu *hpb = ufshpb_get_hpb_data(lrbp->cmd-
> > >device);
> > +     struct utp_hpb_rsp *rsp_field;
> > +     int data_seg_len;
> > +
> > +     if (!hpb)
> > +             return;
> 
> You are assuming HPB recommandations only come in responses to LUs
> with HPB enabled, but the specs says the recommandations can come
> in any responses with GOOD status, meaning you should check the *hpb
> which belongs to the LUN in res_field, but not the one belongs to
> lrbp->cmd->device.
> 

correct, see here HPB driver patch :).


https://patchwork.kernel.org/project/linux-scsi/patch/20200504142032.16619-6-beanhuo@micron.com/

+
+#if defined(CONFIG_SCSI_UFSHPB)
+			/*
+			 * HPB recommendations are provided in RESPONSE
UPIU
+			 * packets of successfully completed commands,
which
+			 * are commands terminated with GOOD status.
+			 */
+			if (scsi_status == SAM_STAT_GOOD)
+				ufshpb_rsp_handler(hba, lrbp);
+#endif
 			break;
 		case UPIU_TRANSACTION_REJECT_UPIU:
 			/* TODO: handle Reject UPIU Response */

we need re-test this series patch seriously.


Thanks Can.


Bean


> Regards,
> 
> Can Guo

RE: [PATCH v19 2/3] scsi: ufs: L2P map management for HPB read

[Avri Altman]

> > +struct utp_hpb_rsp {
> > +     __be32 residual_transfer_count;
> > +     __be32 reserved1[4];
> > +     __be16 sense_data_len;
> > +     u8 desc_type;
> > +     u8 additional_len;
> > +     u8 hpb_op;
> > +     u8 reserved2;
While at it - can fix reserved2 -> lun

> > +     u8 active_rgn_cnt;
> > +     u8 inactive_rgn_cnt;
> > +     struct ufshpb_active_field hpb_active_field[2];
> > +     __be16 hpb_inactive_field[2];
> > +};

Thanks,
Avri

> > +void ufshpb_rsp_upiu(struct ufs_hba *hba, struct ufshcd_lrb *lrbp)
> > +{
> > +     struct ufshpb_lu *hpb = ufshpb_get_hpb_data(lrbp->cmd->device);
> > +     struct utp_hpb_rsp *rsp_field;
> > +     int data_seg_len;
> > +
> > +     if (!hpb)
> > +             return;
> 
> You are assuming HPB recommandations only come in responses to LUs
> with HPB enabled, but the specs says the recommandations can come
> in any responses with GOOD status, meaning you should check the *hpb
> which belongs to the LUN in res_field, but not the one belongs to
> lrbp->cmd->device.
> 
> Regards,
> 
> Can Guo

Re: [PATCH v19 2/3] scsi: ufs: L2P map management for HPB read

[Can Guo]

On 2021-01-29 13:30, Daejun Park wrote:
> This is a patch for managing L2P map in HPB module.
> 
> The HPB divides logical addresses into several regions. A region 
> consists
> of several sub-regions. The sub-region is a basic unit where L2P 
> mapping is
> managed. The driver loads L2P mapping data of each sub-region. The 
> loaded
> sub-region is called active-state. The HPB driver unloads L2P mapping 
> data
> as region unit. The unloaded region is called inactive-state.
> 
> Sub-region/region candidates to be loaded and unloaded are delivered 
> from
> the UFS device. The UFS device delivers the recommended active 
> sub-region
> and inactivate region to the driver using sensedata.
> The HPB module performs L2P mapping management on the host through the
> delivered information.
> 
> A pinned region is a pre-set regions on the UFS device that is always
> activate-state.
> 
> The data structure for map data request and L2P map uses mempool API,
> minimizing allocation overhead while avoiding static allocation.
> 
> The mininum size of the memory pool used in the HPB is implemented
> as a module parameter, so that it can be configurable by the user.
> 
> To gurantee a minimum memory pool size of 4MB: 
> ufshpb_host_map_kbytes=4096
> 
> The map_work manages active/inactive by 2 "to-do" lists.
> Each hpb lun maintains 2 "to-do" lists:
>   hpb->lh_inact_rgn - regions to be inactivated, and
>   hpb->lh_act_srgn - subregions to be activated
> Those lists are maintained on IO completion.
> 
> Reviewed-by: Bart Van Assche <bvanassche@acm.org>
> Reviewed-by: Can Guo <cang@codeaurora.org>
> Acked-by: Avri Altman <Avri.Altman@wdc.com>
> Tested-by: Bean Huo <beanhuo@micron.com>
> Signed-off-by: Daejun Park <daejun7.park@samsung.com>
> ---
>  drivers/scsi/ufs/ufs.h    |  36 ++
>  drivers/scsi/ufs/ufshcd.c |   4 +
>  drivers/scsi/ufs/ufshpb.c | 993 +++++++++++++++++++++++++++++++++++++-
>  drivers/scsi/ufs/ufshpb.h |  65 +++
>  4 files changed, 1083 insertions(+), 15 deletions(-)
> 
> diff --git a/drivers/scsi/ufs/ufs.h b/drivers/scsi/ufs/ufs.h
> index 65563635e20e..075c12e7de7e 100644
> --- a/drivers/scsi/ufs/ufs.h
> +++ b/drivers/scsi/ufs/ufs.h
> @@ -472,6 +472,41 @@ struct utp_cmd_rsp {
>  	u8 sense_data[UFS_SENSE_SIZE];
>  };
> 
> +struct ufshpb_active_field {
> +	__be16 active_rgn;
> +	__be16 active_srgn;
> +};
> +#define HPB_ACT_FIELD_SIZE 4
> +
> +/**
> + * struct utp_hpb_rsp - Response UPIU structure
> + * @residual_transfer_count: Residual transfer count DW-3
> + * @reserved1: Reserved double words DW-4 to DW-7
> + * @sense_data_len: Sense data length DW-8 U16
> + * @desc_type: Descriptor type of sense data
> + * @additional_len: Additional length of sense data
> + * @hpb_op: HPB operation type
> + * @reserved2: Reserved field
> + * @active_rgn_cnt: Active region count
> + * @inactive_rgn_cnt: Inactive region count
> + * @hpb_active_field: Recommended to read HPB region and subregion
> + * @hpb_inactive_field: To be inactivated HPB region and subregion
> + */
> +struct utp_hpb_rsp {
> +	__be32 residual_transfer_count;
> +	__be32 reserved1[4];
> +	__be16 sense_data_len;
> +	u8 desc_type;
> +	u8 additional_len;
> +	u8 hpb_op;
> +	u8 reserved2;
> +	u8 active_rgn_cnt;
> +	u8 inactive_rgn_cnt;
> +	struct ufshpb_active_field hpb_active_field[2];
> +	__be16 hpb_inactive_field[2];
> +};
> +#define UTP_HPB_RSP_SIZE 40
> +
>  /**
>   * struct utp_upiu_rsp - general upiu response structure
>   * @header: UPIU header structure DW-0 to DW-2
> @@ -482,6 +517,7 @@ struct utp_upiu_rsp {
>  	struct utp_upiu_header header;
>  	union {
>  		struct utp_cmd_rsp sr;
> +		struct utp_hpb_rsp hr;
>  		struct utp_upiu_query qr;
>  	};
>  };
> diff --git a/drivers/scsi/ufs/ufshcd.c b/drivers/scsi/ufs/ufshcd.c
> index b8d6a52f5603..52e48de8d27c 100644
> --- a/drivers/scsi/ufs/ufshcd.c
> +++ b/drivers/scsi/ufs/ufshcd.c
> @@ -5018,6 +5018,9 @@ ufshcd_transfer_rsp_status(struct ufs_hba *hba,
> struct ufshcd_lrb *lrbp)
>  				 */
>  				pm_runtime_get_noresume(hba->dev);
>  			}
> +
> +			if (scsi_status == SAM_STAT_GOOD)
> +				ufshpb_rsp_upiu(hba, lrbp);
>  			break;
>  		case UPIU_TRANSACTION_REJECT_UPIU:
>  			/* TODO: handle Reject UPIU Response */
> @@ -9228,6 +9231,7 @@ EXPORT_SYMBOL(ufshcd_shutdown);
>  void ufshcd_remove(struct ufs_hba *hba)
>  {
>  	ufs_bsg_remove(hba);
> +	ufshpb_remove(hba);
>  	ufs_sysfs_remove_nodes(hba->dev);
>  	blk_cleanup_queue(hba->tmf_queue);
>  	blk_mq_free_tag_set(&hba->tmf_tag_set);
> diff --git a/drivers/scsi/ufs/ufshpb.c b/drivers/scsi/ufs/ufshpb.c
> index 1f84141ed384..48edfdd0f606 100644
> --- a/drivers/scsi/ufs/ufshpb.c
> +++ b/drivers/scsi/ufs/ufshpb.c
> @@ -16,11 +16,73 @@
>  #include "ufshpb.h"
>  #include "../sd.h"
> 
> +/* memory management */
> +static struct kmem_cache *ufshpb_mctx_cache;
> +static mempool_t *ufshpb_mctx_pool;
> +static mempool_t *ufshpb_page_pool;
> +/* A cache size of 2MB can cache ppn in the 1GB range. */
> +static unsigned int ufshpb_host_map_kbytes = 2048;
> +static int tot_active_srgn_pages;
> +
> +static struct workqueue_struct *ufshpb_wq;
> +
>  bool ufshpb_is_allowed(struct ufs_hba *hba)
>  {
>  	return !(hba->ufshpb_dev.hpb_disabled);
>  }
> 
> +static bool ufshpb_is_general_lun(int lun)
> +{
> +	return lun < UFS_UPIU_MAX_UNIT_NUM_ID;
> +}
> +
> +static bool
> +ufshpb_is_pinned_region(struct ufshpb_lu *hpb, int rgn_idx)
> +{
> +	if (hpb->lu_pinned_end != PINNED_NOT_SET &&
> +	    rgn_idx >= hpb->lu_pinned_start &&
> +	    rgn_idx <= hpb->lu_pinned_end)
> +		return true;
> +
> +	return false;
> +}
> +
> +static void ufshpb_kick_map_work(struct ufshpb_lu *hpb)
> +{
> +	bool ret = true;
> +	unsigned long flags;
> +
> +	spin_lock_irqsave(&hpb->rsp_list_lock, flags);
> +	if (!list_empty(&hpb->lh_inact_rgn) || 
> !list_empty(&hpb->lh_act_srgn))
> +		ret = false;
> +	spin_unlock_irqrestore(&hpb->rsp_list_lock, flags);
> +
> +	if (ret)
> +		queue_work(ufshpb_wq, &hpb->map_work);
> +}
> +
> +static bool ufshpb_is_hpb_rsp_valid(struct ufs_hba *hba,
> +					 struct ufshcd_lrb *lrbp,
> +					 struct utp_hpb_rsp *rsp_field)
> +{
> +	if (be16_to_cpu(rsp_field->sense_data_len) != DEV_SENSE_SEG_LEN ||
> +	    rsp_field->desc_type != DEV_DES_TYPE ||
> +	    rsp_field->additional_len != DEV_ADDITIONAL_LEN ||
> +	    rsp_field->hpb_op == HPB_RSP_NONE ||
> +	    rsp_field->active_rgn_cnt > MAX_ACTIVE_NUM ||
> +	    rsp_field->inactive_rgn_cnt > MAX_INACTIVE_NUM ||
> +	    (!rsp_field->active_rgn_cnt && !rsp_field->inactive_rgn_cnt))
> +		return false;
> +
> +	if (!ufshpb_is_general_lun(lrbp->lun)) {
> +		dev_warn(hba->dev, "ufshpb: lun(%d) not supported\n",
> +			 lrbp->lun);
> +		return false;
> +	}
> +
> +	return true;
> +}
> +
>  static struct ufshpb_lu *ufshpb_get_hpb_data(struct scsi_device *sdev)
>  {
>  	return sdev->hostdata;
> @@ -36,13 +98,741 @@ static void ufshpb_set_state(struct ufshpb_lu
> *hpb, int state)
>  	atomic_set(&hpb->hpb_state, state);
>  }
> 
> +static struct ufshpb_req *ufshpb_get_map_req(struct ufshpb_lu *hpb,
> +					     struct ufshpb_subregion *srgn)
> +{
> +	struct ufshpb_req *map_req;
> +	struct request *req;
> +	struct bio *bio;
> +
> +	map_req = kmem_cache_alloc(hpb->map_req_cache, GFP_KERNEL);
> +	if (!map_req)
> +		return NULL;
> +
> +	req = blk_get_request(hpb->sdev_ufs_lu->request_queue,
> +			      REQ_OP_SCSI_IN, 0);
> +	if (IS_ERR(req))
> +		goto free_map_req;
> +
> +	bio = bio_alloc(GFP_KERNEL, hpb->pages_per_srgn);
> +	if (!bio) {
> +		blk_put_request(req);
> +		goto free_map_req;
> +	}
> +
> +	map_req->hpb = hpb;
> +	map_req->req = req;
> +	map_req->bio = bio;
> +
> +	map_req->rgn_idx = srgn->rgn_idx;
> +	map_req->srgn_idx = srgn->srgn_idx;
> +	map_req->mctx = srgn->mctx;
> +
> +	return map_req;
> +
> +free_map_req:
> +	kmem_cache_free(hpb->map_req_cache, map_req);
> +	return NULL;
> +}
> +
> +static void ufshpb_put_map_req(struct ufshpb_lu *hpb,
> +				      struct ufshpb_req *map_req)
> +{
> +	bio_put(map_req->bio);
> +	blk_put_request(map_req->req);
> +	kmem_cache_free(hpb->map_req_cache, map_req);
> +}
> +
> +static int ufshpb_clear_dirty_bitmap(struct ufshpb_lu *hpb,
> +				     struct ufshpb_subregion *srgn)
> +{
> +	WARN_ON(!srgn->mctx);
> +	bitmap_zero(srgn->mctx->ppn_dirty, hpb->entries_per_srgn);
> +	return 0;
> +}
> +
> +static void ufshpb_update_active_info(struct ufshpb_lu *hpb, int 
> rgn_idx,
> +				      int srgn_idx)
> +{
> +	struct ufshpb_region *rgn;
> +	struct ufshpb_subregion *srgn;
> +
> +	rgn = hpb->rgn_tbl + rgn_idx;
> +	srgn = rgn->srgn_tbl + srgn_idx;
> +
> +	list_del_init(&rgn->list_inact_rgn);
> +
> +	if (list_empty(&srgn->list_act_srgn))
> +		list_add_tail(&srgn->list_act_srgn, &hpb->lh_act_srgn);
> +}
> +
> +static void ufshpb_update_inactive_info(struct ufshpb_lu *hpb, int 
> rgn_idx)
> +{
> +	struct ufshpb_region *rgn;
> +	struct ufshpb_subregion *srgn;
> +	int srgn_idx;
> +
> +	rgn = hpb->rgn_tbl + rgn_idx;
> +
> +	for_each_sub_region(rgn, srgn_idx, srgn)
> +		list_del_init(&srgn->list_act_srgn);
> +
> +	if (list_empty(&rgn->list_inact_rgn))
> +		list_add_tail(&rgn->list_inact_rgn, &hpb->lh_inact_rgn);
> +}
> +
> +static void ufshpb_activate_subregion(struct ufshpb_lu *hpb,
> +					  struct ufshpb_subregion *srgn)
> +{
> +	struct ufshpb_region *rgn;
> +
> +	/*
> +	 * If there is no mctx in subregion
> +	 * after I/O progress for HPB_READ_BUFFER, the region to which the
> +	 * subregion belongs was evicted.
> +	 * Mask sure the region must not evict in I/O progress
> +	 */
> +	WARN_ON(!srgn->mctx);
> +
> +	rgn = hpb->rgn_tbl + srgn->rgn_idx;
> +
> +	if (unlikely(rgn->rgn_state == HPB_RGN_INACTIVE)) {
> +		dev_err(&hpb->sdev_ufs_lu->sdev_dev,
> +			"region %d subregion %d evicted\n",
> +			srgn->rgn_idx, srgn->srgn_idx);
> +		srgn->srgn_state = HPB_SRGN_INVALID;
> +		return;
> +	}
> +	srgn->srgn_state = HPB_SRGN_VALID;
> +}
> +
> +static void ufshpb_map_req_compl_fn(struct request *req, blk_status_t 
> error)
> +{
> +	struct ufshpb_req *map_req = (struct ufshpb_req *) req->end_io_data;
> +	struct ufshpb_lu *hpb = map_req->hpb;
> +	struct ufshpb_subregion *srgn;
> +	unsigned long flags;
> +
> +	srgn = hpb->rgn_tbl[map_req->rgn_idx].srgn_tbl +
> +		map_req->srgn_idx;
> +
> +	ufshpb_clear_dirty_bitmap(hpb, srgn);
> +	spin_lock_irqsave(&hpb->rgn_state_lock, flags);
> +	ufshpb_activate_subregion(hpb, srgn);
> +	spin_unlock_irqrestore(&hpb->rgn_state_lock, flags);
> +
> +	ufshpb_put_map_req(map_req->hpb, map_req);
> +}
> +
> +static void ufshpb_set_read_buf_cmd(unsigned char *cdb, int rgn_idx,
> +					   int srgn_idx, int srgn_mem_size)
> +{
> +	cdb[0] = UFSHPB_READ_BUFFER;
> +	cdb[1] = UFSHPB_READ_BUFFER_ID;
> +
> +	put_unaligned_be16(rgn_idx, &cdb[2]);
> +	put_unaligned_be16(srgn_idx, &cdb[4]);
> +	put_unaligned_be24(srgn_mem_size, &cdb[6]);
> +
> +	cdb[9] = 0x00;
> +}
> +
> +static int ufshpb_execute_map_req(struct ufshpb_lu *hpb,
> +				  struct ufshpb_req *map_req)
> +{
> +	struct request_queue *q;
> +	struct request *req;
> +	struct scsi_request *rq;
> +	int ret = 0;
> +	int i;
> +
> +	q = hpb->sdev_ufs_lu->request_queue;
> +	for (i = 0; i < hpb->pages_per_srgn; i++) {
> +		ret = bio_add_pc_page(q, map_req->bio, map_req->mctx->m_page[i],
> +				      PAGE_SIZE, 0);
> +		if (ret != PAGE_SIZE) {
> +			dev_err(&hpb->sdev_ufs_lu->sdev_dev,
> +				   "bio_add_pc_page fail %d - %d\n",
> +				   map_req->rgn_idx, map_req->srgn_idx);
> +			return ret;
> +		}
> +	}
> +
> +	req = map_req->req;
> +
> +	blk_rq_append_bio(req, &map_req->bio);
> +
> +	req->end_io_data = map_req;
> +
> +	rq = scsi_req(req);
> +	ufshpb_set_read_buf_cmd(rq->cmd, map_req->rgn_idx,
> +				map_req->srgn_idx, hpb->srgn_mem_size);
> +	rq->cmd_len = HPB_READ_BUFFER_CMD_LENGTH;
> +
> +	blk_execute_rq_nowait(q, NULL, req, 1, ufshpb_map_req_compl_fn);
> +
> +	hpb->stats.map_req_cnt++;
> +	return 0;
> +}
> +
> +static struct ufshpb_map_ctx *ufshpb_get_map_ctx(struct ufshpb_lu 
> *hpb)
> +{
> +	struct ufshpb_map_ctx *mctx;
> +	int i, j;
> +
> +	mctx = mempool_alloc(ufshpb_mctx_pool, GFP_KERNEL);
> +	if (!mctx)
> +		return NULL;
> +
> +	mctx->m_page = kmem_cache_alloc(hpb->m_page_cache, GFP_KERNEL);
> +	if (!mctx->m_page)
> +		goto release_mctx;
> +
> +	mctx->ppn_dirty = bitmap_zalloc(hpb->entries_per_srgn, GFP_KERNEL);
> +	if (!mctx->ppn_dirty)
> +		goto release_m_page;
> +
> +	for (i = 0; i < hpb->pages_per_srgn; i++) {
> +		mctx->m_page[i] = mempool_alloc(ufshpb_page_pool, GFP_KERNEL);
> +		if (!mctx->m_page[i]) {
> +			for (j = 0; j < i; j++)
> +				mempool_free(mctx->m_page[j], ufshpb_page_pool);
> +			goto release_ppn_dirty;
> +		}
> +		clear_page(page_address(mctx->m_page[i]));
> +	}
> +
> +	return mctx;
> +
> +release_ppn_dirty:
> +	bitmap_free(mctx->ppn_dirty);
> +release_m_page:
> +	kmem_cache_free(hpb->m_page_cache, mctx->m_page);
> +release_mctx:
> +	mempool_free(mctx, ufshpb_mctx_pool);
> +	return NULL;
> +}
> +
> +static void ufshpb_put_map_ctx(struct ufshpb_lu *hpb,
> +				      struct ufshpb_map_ctx *mctx)
> +{
> +	int i;
> +
> +	for (i = 0; i < hpb->pages_per_srgn; i++)
> +		mempool_free(mctx->m_page[i], ufshpb_page_pool);
> +
> +	bitmap_free(mctx->ppn_dirty);
> +	kmem_cache_free(hpb->m_page_cache, mctx->m_page);
> +	mempool_free(mctx, ufshpb_mctx_pool);
> +}
> +
> +static int ufshpb_check_srgns_issue_state(struct ufshpb_lu *hpb,
> +					  struct ufshpb_region *rgn)
> +{
> +	struct ufshpb_subregion *srgn;
> +	int srgn_idx;
> +
> +	for_each_sub_region(rgn, srgn_idx, srgn)
> +		if (srgn->srgn_state == HPB_SRGN_ISSUED)
> +			return -EPERM;
> +
> +	return 0;
> +}
> +
> +static void ufshpb_add_lru_info(struct victim_select_info *lru_info,
> +				       struct ufshpb_region *rgn)
> +{
> +	rgn->rgn_state = HPB_RGN_ACTIVE;
> +	list_add_tail(&rgn->list_lru_rgn, &lru_info->lh_lru_rgn);
> +	atomic_inc(&lru_info->active_cnt);
> +}
> +
> +static void ufshpb_hit_lru_info(struct victim_select_info *lru_info,
> +				       struct ufshpb_region *rgn)
> +{
> +	list_move_tail(&rgn->list_lru_rgn, &lru_info->lh_lru_rgn);
> +}
> +
> +static struct ufshpb_region *ufshpb_victim_lru_info(struct ufshpb_lu 
> *hpb)
> +{
> +	struct victim_select_info *lru_info = &hpb->lru_info;
> +	struct ufshpb_region *rgn, *victim_rgn = NULL;
> +
> +	list_for_each_entry(rgn, &lru_info->lh_lru_rgn, list_lru_rgn) {
> +		WARN_ON(!rgn);
> +		if (ufshpb_check_srgns_issue_state(hpb, rgn))
> +			continue;
> +
> +		victim_rgn = rgn;
> +		break;
> +	}
> +
> +	return victim_rgn;
> +}
> +
> +static void ufshpb_cleanup_lru_info(struct victim_select_info 
> *lru_info,
> +					   struct ufshpb_region *rgn)
> +{
> +	list_del_init(&rgn->list_lru_rgn);
> +	rgn->rgn_state = HPB_RGN_INACTIVE;
> +	atomic_dec(&lru_info->active_cnt);
> +}
> +
> +static void ufshpb_purge_active_subregion(struct ufshpb_lu *hpb,
> +						 struct ufshpb_subregion *srgn)
> +{
> +	if (srgn->srgn_state != HPB_SRGN_UNUSED) {
> +		ufshpb_put_map_ctx(hpb, srgn->mctx);
> +		srgn->srgn_state = HPB_SRGN_UNUSED;
> +		srgn->mctx = NULL;
> +	}
> +}
> +
> +static void __ufshpb_evict_region(struct ufshpb_lu *hpb,
> +				  struct ufshpb_region *rgn)
> +{
> +	struct victim_select_info *lru_info;
> +	struct ufshpb_subregion *srgn;
> +	int srgn_idx;
> +
> +	lru_info = &hpb->lru_info;
> +
> +	dev_dbg(&hpb->sdev_ufs_lu->sdev_dev, "evict region %d\n", 
> rgn->rgn_idx);
> +
> +	ufshpb_cleanup_lru_info(lru_info, rgn);
> +
> +	for_each_sub_region(rgn, srgn_idx, srgn)
> +		ufshpb_purge_active_subregion(hpb, srgn);
> +}
> +
> +static int ufshpb_evict_region(struct ufshpb_lu *hpb, struct
> ufshpb_region *rgn)
> +{
> +	unsigned long flags;
> +	int ret = 0;
> +
> +	spin_lock_irqsave(&hpb->rgn_state_lock, flags);
> +	if (rgn->rgn_state == HPB_RGN_PINNED) {
> +		dev_warn(&hpb->sdev_ufs_lu->sdev_dev,
> +			 "pinned region cannot drop-out. region %d\n",
> +			 rgn->rgn_idx);
> +		goto out;
> +	}
> +	if (!list_empty(&rgn->list_lru_rgn)) {
> +		if (ufshpb_check_srgns_issue_state(hpb, rgn)) {
> +			ret = -EBUSY;
> +			goto out;
> +		}
> +
> +		__ufshpb_evict_region(hpb, rgn);
> +	}
> +out:
> +	spin_unlock_irqrestore(&hpb->rgn_state_lock, flags);
> +	return ret;
> +}
> +
> +static int ufshpb_issue_map_req(struct ufshpb_lu *hpb,
> +				struct ufshpb_region *rgn,
> +				struct ufshpb_subregion *srgn)
> +{
> +	struct ufshpb_req *map_req;
> +	unsigned long flags;
> +	int ret;
> +	int err = -EAGAIN;
> +	bool alloc_required = false;
> +	enum HPB_SRGN_STATE state = HPB_SRGN_INVALID;
> +
> +	spin_lock_irqsave(&hpb->rgn_state_lock, flags);
> +
> +	if (ufshpb_get_state(hpb) != HPB_PRESENT) {
> +		dev_notice(&hpb->sdev_ufs_lu->sdev_dev,
> +			   "%s: ufshpb state is not PRESENT\n", __func__);
> +		goto unlock_out;
> +	}
> +
> +	if ((rgn->rgn_state == HPB_RGN_INACTIVE) &&
> +	    (srgn->srgn_state == HPB_SRGN_INVALID)) {
> +		err = 0;
> +		goto unlock_out;
> +	}
> +
> +	if (srgn->srgn_state == HPB_SRGN_UNUSED)
> +		alloc_required = true;
> +
> +	/*
> +	 * If the subregion is already ISSUED state,
> +	 * a specific event (e.g., GC or wear-leveling, etc.) occurs in
> +	 * the device and HPB response for map loading is received.
> +	 * In this case, after finishing the HPB_READ_BUFFER,
> +	 * the next HPB_READ_BUFFER is performed again to obtain the latest
> +	 * map data.
> +	 */
> +	if (srgn->srgn_state == HPB_SRGN_ISSUED)
> +		goto unlock_out;
> +
> +	srgn->srgn_state = HPB_SRGN_ISSUED;
> +	spin_unlock_irqrestore(&hpb->rgn_state_lock, flags);
> +
> +	if (alloc_required) {
> +		WARN_ON(srgn->mctx);
> +		srgn->mctx = ufshpb_get_map_ctx(hpb);
> +		if (!srgn->mctx) {
> +			dev_err(&hpb->sdev_ufs_lu->sdev_dev,
> +			    "get map_ctx failed. region %d - %d\n",
> +			    rgn->rgn_idx, srgn->srgn_idx);
> +			state = HPB_SRGN_UNUSED;
> +			goto change_srgn_state;
> +		}
> +	}
> +
> +	map_req = ufshpb_get_map_req(hpb, srgn);
> +	if (!map_req)
> +		goto change_srgn_state;
> +
> +
> +	ret = ufshpb_execute_map_req(hpb, map_req);
> +	if (ret) {
> +		dev_err(&hpb->sdev_ufs_lu->sdev_dev,
> +			   "%s: issue map_req failed: %d, region %d - %d\n",
> +			   __func__, ret, srgn->rgn_idx, srgn->srgn_idx);
> +		goto free_map_req;
> +	}
> +	return 0;
> +
> +free_map_req:
> +	ufshpb_put_map_req(hpb, map_req);
> +change_srgn_state:
> +	spin_lock_irqsave(&hpb->rgn_state_lock, flags);
> +	srgn->srgn_state = state;
> +unlock_out:
> +	spin_unlock_irqrestore(&hpb->rgn_state_lock, flags);
> +	return err;
> +}
> +
> +static int ufshpb_add_region(struct ufshpb_lu *hpb, struct 
> ufshpb_region *rgn)
> +{
> +	struct ufshpb_region *victim_rgn;
> +	struct victim_select_info *lru_info = &hpb->lru_info;
> +	unsigned long flags;
> +	int ret = 0;
> +
> +	spin_lock_irqsave(&hpb->rgn_state_lock, flags);
> +	/*
> +	 * If region belongs to lru_list, just move the region
> +	 * to the front of lru list. because the state of the region
> +	 * is already active-state
> +	 */
> +	if (!list_empty(&rgn->list_lru_rgn)) {
> +		ufshpb_hit_lru_info(lru_info, rgn);
> +		goto out;
> +	}
> +
> +	if (rgn->rgn_state == HPB_RGN_INACTIVE) {
> +		if (atomic_read(&lru_info->active_cnt) ==
> +		    lru_info->max_lru_active_cnt) {
> +			/*
> +			 * If the maximum number of active regions
> +			 * is exceeded, evict the least recently used region.
> +			 * This case may occur when the device responds
> +			 * to the eviction information late.
> +			 * It is okay to evict the least recently used region,
> +			 * because the device could detect this region
> +			 * by not issuing HPB_READ
> +			 */
> +			victim_rgn = ufshpb_victim_lru_info(hpb);
> +			if (!victim_rgn) {
> +				dev_warn(&hpb->sdev_ufs_lu->sdev_dev,
> +				    "cannot get victim region error\n");
> +				ret = -ENOMEM;
> +				goto out;
> +			}
> +
> +			dev_dbg(&hpb->sdev_ufs_lu->sdev_dev,
> +				"LRU full (%d), choose victim %d\n",
> +				atomic_read(&lru_info->active_cnt),
> +				victim_rgn->rgn_idx);
> +			__ufshpb_evict_region(hpb, victim_rgn);
> +		}
> +
> +		/*
> +		 * When a region is added to lru_info list_head,
> +		 * it is guaranteed that the subregion has been
> +		 * assigned all mctx. If failed, try to receive mctx again
> +		 * without being added to lru_info list_head
> +		 */
> +		ufshpb_add_lru_info(lru_info, rgn);
> +	}
> +out:
> +	spin_unlock_irqrestore(&hpb->rgn_state_lock, flags);
> +	return ret;
> +}
> +
> +static void ufshpb_rsp_req_region_update(struct ufshpb_lu *hpb,
> +					 struct utp_hpb_rsp *rsp_field)
> +{
> +	int i, rgn_idx, srgn_idx;
> +
> +	BUILD_BUG_ON(sizeof(struct ufshpb_active_field) != 
> HPB_ACT_FIELD_SIZE);
> +	/*
> +	 * If the active region and the inactive region are the same,
> +	 * we will inactivate this region.
> +	 * The device could check this (region inactivated) and
> +	 * will response the proper active region information
> +	 */
> +	spin_lock(&hpb->rsp_list_lock);
> +	for (i = 0; i < rsp_field->active_rgn_cnt; i++) {
> +		rgn_idx =
> +			be16_to_cpu(rsp_field->hpb_active_field[i].active_rgn);
> +		srgn_idx =
> +			be16_to_cpu(rsp_field->hpb_active_field[i].active_srgn);
> +
> +		dev_dbg(&hpb->sdev_ufs_lu->sdev_dev,
> +			"activate(%d) region %d - %d\n", i, rgn_idx, srgn_idx);
> +		ufshpb_update_active_info(hpb, rgn_idx, srgn_idx);
> +		hpb->stats.rb_active_cnt++;
> +	}
> +
> +	for (i = 0; i < rsp_field->inactive_rgn_cnt; i++) {
> +		rgn_idx = be16_to_cpu(rsp_field->hpb_inactive_field[i]);
> +		dev_dbg(&hpb->sdev_ufs_lu->sdev_dev,
> +			"inactivate(%d) region %d\n", i, rgn_idx);
> +		ufshpb_update_inactive_info(hpb, rgn_idx);
> +		hpb->stats.rb_inactive_cnt++;
> +	}
> +	spin_unlock(&hpb->rsp_list_lock);
> +
> +	dev_dbg(&hpb->sdev_ufs_lu->sdev_dev, "Noti: #ACT %u #INACT %u\n",
> +		rsp_field->active_rgn_cnt, rsp_field->inactive_rgn_cnt);
> +
> +	queue_work(ufshpb_wq, &hpb->map_work);
> +}
> +
> +/*
> + * This function will parse recommended active subregion information 
> in sense
> + * data field of response UPIU with SAM_STAT_GOOD state.
> + */
> +void ufshpb_rsp_upiu(struct ufs_hba *hba, struct ufshcd_lrb *lrbp)
> +{
> +	struct ufshpb_lu *hpb = ufshpb_get_hpb_data(lrbp->cmd->device);
> +	struct utp_hpb_rsp *rsp_field;
> +	int data_seg_len;
> +
> +	if (!hpb)
> +		return;
> +
> +	if (ufshpb_get_state(hpb) != HPB_PRESENT) {
> +		dev_notice(&hpb->sdev_ufs_lu->sdev_dev,
> +			   "%s: ufshpb state is not PRESENT\n", __func__);
> +		return;
> +	}
> +
> +	data_seg_len = be32_to_cpu(lrbp->ucd_rsp_ptr->header.dword_2)
> +		& MASK_RSP_UPIU_DATA_SEG_LEN;
> +
> +	/* To flush remained rsp_list, we queue the map_work task */
> +	if (!data_seg_len) {
> +		if (!ufshpb_is_general_lun(lrbp->lun))
> +			return;
> +
> +		ufshpb_kick_map_work(hpb);
> +		return;
> +	}
> +
> +	/* Check HPB_UPDATE_ALERT */
> +	if (!(lrbp->ucd_rsp_ptr->header.dword_2 &
> +	      UPIU_HEADER_DWORD(0, 2, 0, 0)))
> +		return;
> +
> +	rsp_field = &lrbp->ucd_rsp_ptr->hr;
> +	BUILD_BUG_ON(sizeof(struct utp_hpb_rsp) != UTP_HPB_RSP_SIZE);
> +
> +	if (!ufshpb_is_hpb_rsp_valid(hba, lrbp, rsp_field))
> +		return;
> +
> +	hpb->stats.rb_noti_cnt++;
> +
> +	switch (rsp_field->hpb_op) {
> +	case HPB_RSP_NONE:
> +		/* nothing to do */
> +		break;
> +	case HPB_RSP_REQ_REGION_UPDATE:
> +		WARN_ON(data_seg_len != DEV_DATA_SEG_LEN);
> +		ufshpb_rsp_req_region_update(hpb, rsp_field);
> +		break;
> +	case HPB_RSP_DEV_RESET:
> +		dev_warn(&hpb->sdev_ufs_lu->sdev_dev,
> +			 "UFS device lost HPB information during PM.\n");
> +		break;
> +	default:
> +		dev_notice(&hpb->sdev_ufs_lu->sdev_dev,
> +			   "hpb_op is not available: %d\n",
> +			   rsp_field->hpb_op);
> +		break;
> +	}
> +}
> +
> +static void ufshpb_add_active_list(struct ufshpb_lu *hpb,
> +				   struct ufshpb_region *rgn,
> +				   struct ufshpb_subregion *srgn)
> +{
> +	if (!list_empty(&rgn->list_inact_rgn))
> +		return;
> +
> +	if (!list_empty(&srgn->list_act_srgn)) {
> +		list_move(&srgn->list_act_srgn, &hpb->lh_act_srgn);
> +		return;
> +	}
> +
> +	list_add(&srgn->list_act_srgn, &hpb->lh_act_srgn);
> +}
> +
> +static void ufshpb_add_pending_evict_list(struct ufshpb_lu *hpb,
> +				    struct ufshpb_region *rgn,
> +				    struct list_head *pending_list)
> +{
> +	struct ufshpb_subregion *srgn;
> +	int srgn_idx;
> +
> +	if (!list_empty(&rgn->list_inact_rgn))
> +		return;
> +
> +	for_each_sub_region(rgn, srgn_idx, srgn)
> +		if (!list_empty(&srgn->list_act_srgn))
> +			return;
> +
> +	list_add_tail(&rgn->list_inact_rgn, pending_list);
> +}
> +
> +static void ufshpb_run_active_subregion_list(struct ufshpb_lu *hpb)
> +{
> +	struct ufshpb_region *rgn;
> +	struct ufshpb_subregion *srgn;
> +	unsigned long flags;
> +	int ret = 0;
> +
> +	spin_lock_irqsave(&hpb->rsp_list_lock, flags);
> +	while ((srgn = list_first_entry_or_null(&hpb->lh_act_srgn,
> +						struct ufshpb_subregion,
> +						list_act_srgn))) {
> +		if (ufshpb_get_state(hpb) == HPB_SUSPEND)
> +			break;
> +
> +		list_del_init(&srgn->list_act_srgn);
> +		spin_unlock_irqrestore(&hpb->rsp_list_lock, flags);
> +
> +		rgn = hpb->rgn_tbl + srgn->rgn_idx;
> +		ret = ufshpb_add_region(hpb, rgn);
> +		if (ret)
> +			goto active_failed;
> +
> +		ret = ufshpb_issue_map_req(hpb, rgn, srgn);
> +		if (ret) {
> +			dev_err(&hpb->sdev_ufs_lu->sdev_dev,
> +			    "issue map_req failed. ret %d, region %d - %d\n",
> +			    ret, rgn->rgn_idx, srgn->srgn_idx);
> +			goto active_failed;
> +		}
> +		spin_lock_irqsave(&hpb->rsp_list_lock, flags);
> +	}
> +	spin_unlock_irqrestore(&hpb->rsp_list_lock, flags);
> +	return;
> +
> +active_failed:
> +	dev_err(&hpb->sdev_ufs_lu->sdev_dev, "failed to activate region %d -
> %d, will retry\n",
> +		   rgn->rgn_idx, srgn->srgn_idx);
> +	spin_lock_irqsave(&hpb->rsp_list_lock, flags);
> +	ufshpb_add_active_list(hpb, rgn, srgn);
> +	spin_unlock_irqrestore(&hpb->rsp_list_lock, flags);
> +}
> +
> +static void ufshpb_run_inactive_region_list(struct ufshpb_lu *hpb)
> +{
> +	struct ufshpb_region *rgn;
> +	unsigned long flags;
> +	int ret;
> +	LIST_HEAD(pending_list);
> +
> +	spin_lock_irqsave(&hpb->rsp_list_lock, flags);
> +	while ((rgn = list_first_entry_or_null(&hpb->lh_inact_rgn,
> +					       struct ufshpb_region,
> +					       list_inact_rgn))) {
> +		if (ufshpb_get_state(hpb) == HPB_SUSPEND)
> +			break;
> +
> +		list_del_init(&rgn->list_inact_rgn);
> +		spin_unlock_irqrestore(&hpb->rsp_list_lock, flags);
> +
> +		ret = ufshpb_evict_region(hpb, rgn);
> +		if (ret) {
> +			spin_lock_irqsave(&hpb->rsp_list_lock, flags);
> +			ufshpb_add_pending_evict_list(hpb, rgn, &pending_list);
> +			spin_unlock_irqrestore(&hpb->rsp_list_lock, flags);
> +		}
> +
> +		spin_lock_irqsave(&hpb->rsp_list_lock, flags);
> +	}
> +
> +	list_splice(&pending_list, &hpb->lh_inact_rgn);
> +	spin_unlock_irqrestore(&hpb->rsp_list_lock, flags);
> +}
> +
> +static void ufshpb_map_work_handler(struct work_struct *work)
> +{
> +	struct ufshpb_lu *hpb = container_of(work, struct ufshpb_lu, 
> map_work);
> +
> +	if (ufshpb_get_state(hpb) != HPB_PRESENT) {
> +		dev_notice(&hpb->sdev_ufs_lu->sdev_dev,
> +			   "%s: ufshpb state is not PRESENT\n", __func__);
> +		return;
> +	}
> +
> +	ufshpb_run_inactive_region_list(hpb);
> +	ufshpb_run_active_subregion_list(hpb);
> +}
> +
> +/*
> + * this function doesn't need to hold lock due to be called in init.
> + * (rgn_state_lock, rsp_list_lock, etc..)
> + */
> +static int ufshpb_init_pinned_active_region(struct ufs_hba *hba,
> +					    struct ufshpb_lu *hpb,
> +					    struct ufshpb_region *rgn)
> +{
> +	struct ufshpb_subregion *srgn;
> +	int srgn_idx, i;
> +	int err = 0;
> +
> +	for_each_sub_region(rgn, srgn_idx, srgn) {
> +		srgn->mctx = ufshpb_get_map_ctx(hpb);
> +		srgn->srgn_state = HPB_SRGN_INVALID;
> +		if (!srgn->mctx) {
> +			err = -ENOMEM;
> +			dev_err(hba->dev,
> +				"alloc mctx for pinned region failed\n");
> +			goto release;
> +		}
> +
> +		list_add_tail(&srgn->list_act_srgn, &hpb->lh_act_srgn);
> +	}
> +
> +	rgn->rgn_state = HPB_RGN_PINNED;
> +	return 0;
> +
> +release:
> +	for (i = 0; i < srgn_idx; i++) {
> +		srgn = rgn->srgn_tbl + i;
> +		ufshpb_put_map_ctx(hpb, srgn->mctx);
> +	}
> +	return err;
> +}
> +
>  static void ufshpb_init_subregion_tbl(struct ufshpb_lu *hpb,
>  				      struct ufshpb_region *rgn)
>  {
>  	int srgn_idx;
> +	struct ufshpb_subregion *srgn;
> 
> -	for (srgn_idx = 0; srgn_idx < rgn->srgn_cnt; srgn_idx++) {
> -		struct ufshpb_subregion *srgn = rgn->srgn_tbl + srgn_idx;
> +	for_each_sub_region(rgn, srgn_idx, srgn) {
> +		INIT_LIST_HEAD(&srgn->list_act_srgn);
> 
>  		srgn->rgn_idx = rgn->rgn_idx;
>  		srgn->srgn_idx = srgn_idx;
> @@ -75,6 +865,8 @@ static void ufshpb_lu_parameter_init(struct ufs_hba 
> *hba,
>  	hpb->lu_pinned_end = hpb_lu_info->num_pinned ?
>  		(hpb_lu_info->pinned_start + hpb_lu_info->num_pinned - 1)
>  		: PINNED_NOT_SET;
> +	hpb->lru_info.max_lru_active_cnt =
> +		hpb_lu_info->max_active_rgns - hpb_lu_info->num_pinned;
> 
>  	rgn_mem_size = (1ULL << hpb_dev_info->rgn_size) * HPB_RGN_SIZE_UNIT
>  			* HPB_ENTRY_SIZE;
> @@ -123,6 +915,9 @@ static int ufshpb_alloc_region_tbl(struct ufs_hba
> *hba, struct ufshpb_lu *hpb)
>  		rgn = rgn_table + rgn_idx;
>  		rgn->rgn_idx = rgn_idx;
> 
> +		INIT_LIST_HEAD(&rgn->list_inact_rgn);
> +		INIT_LIST_HEAD(&rgn->list_lru_rgn);
> +
>  		if (rgn_idx == hpb->rgns_per_lu - 1)
>  			srgn_cnt = ((hpb->srgns_per_lu - 1) %
>  				    hpb->srgns_per_rgn) + 1;
> @@ -132,7 +927,13 @@ static int ufshpb_alloc_region_tbl(struct ufs_hba
> *hba, struct ufshpb_lu *hpb)
>  			goto release_srgn_table;
>  		ufshpb_init_subregion_tbl(hpb, rgn);
> 
> -		rgn->rgn_state = HPB_RGN_INACTIVE;
> +		if (ufshpb_is_pinned_region(hpb, rgn_idx)) {
> +			ret = ufshpb_init_pinned_active_region(hba, hpb, rgn);
> +			if (ret)
> +				goto release_srgn_table;
> +		} else {
> +			rgn->rgn_state = HPB_RGN_INACTIVE;
> +		}
>  	}
> 
>  	return 0;
> @@ -151,13 +952,13 @@ static void ufshpb_destroy_subregion_tbl(struct
> ufshpb_lu *hpb,
>  					 struct ufshpb_region *rgn)
>  {
>  	int srgn_idx;
> +	struct ufshpb_subregion *srgn;
> 
> -	for (srgn_idx = 0; srgn_idx < rgn->srgn_cnt; srgn_idx++) {
> -		struct ufshpb_subregion *srgn;
> -
> -		srgn = rgn->srgn_tbl + srgn_idx;
> -		srgn->srgn_state = HPB_SRGN_UNUSED;
> -	}
> +	for_each_sub_region(rgn, srgn_idx, srgn)
> +		if (srgn->srgn_state != HPB_SRGN_UNUSED) {
> +			srgn->srgn_state = HPB_SRGN_UNUSED;
> +			ufshpb_put_map_ctx(hpb, srgn->mctx);
> +		}
>  }
> 
>  static void ufshpb_destroy_region_tbl(struct ufshpb_lu *hpb)
> @@ -231,11 +1032,47 @@ static int ufshpb_lu_hpb_init(struct ufs_hba
> *hba, struct ufshpb_lu *hpb)
>  {
>  	int ret;
> 
> +	spin_lock_init(&hpb->rgn_state_lock);
> +	spin_lock_init(&hpb->rsp_list_lock);
> +
> +	INIT_LIST_HEAD(&hpb->lru_info.lh_lru_rgn);
> +	INIT_LIST_HEAD(&hpb->lh_act_srgn);
> +	INIT_LIST_HEAD(&hpb->lh_inact_rgn);
> +	INIT_LIST_HEAD(&hpb->list_hpb_lu);
> +
> +	INIT_WORK(&hpb->map_work, ufshpb_map_work_handler);
> +
> +	hpb->map_req_cache = kmem_cache_create("ufshpb_req_cache",
> +			  sizeof(struct ufshpb_req), 0, 0, NULL);
> +	if (!hpb->map_req_cache) {
> +		dev_err(hba->dev, "ufshpb(%d) ufshpb_req_cache create fail",
> +			hpb->lun);
> +		return -ENOMEM;
> +	}
> +
> +	hpb->m_page_cache = kmem_cache_create("ufshpb_m_page_cache",
> +			  sizeof(struct page *) * hpb->pages_per_srgn,
> +			  0, 0, NULL);
> +	if (!hpb->m_page_cache) {
> +		dev_err(hba->dev, "ufshpb(%d) ufshpb_m_page_cache create fail",
> +			hpb->lun);
> +		ret = -ENOMEM;
> +		goto release_req_cache;
> +	}
> +
>  	ret = ufshpb_alloc_region_tbl(hba, hpb);
> +	if (ret)
> +		goto release_m_page_cache;
> 
>  	ufshpb_stat_init(hpb);
> 
>  	return 0;
> +
> +release_m_page_cache:
> +	kmem_cache_destroy(hpb->m_page_cache);
> +release_req_cache:
> +	kmem_cache_destroy(hpb->map_req_cache);
> +	return ret;
>  }
> 
>  static struct ufshpb_lu *ufshpb_alloc_hpb_lu(struct ufs_hba *hba, int 
> lun,
> @@ -266,6 +1103,33 @@ static struct ufshpb_lu
> *ufshpb_alloc_hpb_lu(struct ufs_hba *hba, int lun,
>  	return NULL;
>  }
> 
> +static void ufshpb_discard_rsp_lists(struct ufshpb_lu *hpb)
> +{
> +	struct ufshpb_region *rgn, *next_rgn;
> +	struct ufshpb_subregion *srgn, *next_srgn;
> +	unsigned long flags;
> +
> +	/*
> +	 * If the device reset occurred, the remained HPB region information
> +	 * may be stale. Therefore, by dicarding the lists of HPB response
> +	 * that remained after reset, it prevents unnecessary work.
> +	 */
> +	spin_lock_irqsave(&hpb->rsp_list_lock, flags);
> +	list_for_each_entry_safe(rgn, next_rgn, &hpb->lh_inact_rgn,
> +				 list_inact_rgn)
> +		list_del_init(&rgn->list_inact_rgn);
> +
> +	list_for_each_entry_safe(srgn, next_srgn, &hpb->lh_act_srgn,
> +				 list_act_srgn)
> +		list_del_init(&srgn->list_act_srgn);
> +	spin_unlock_irqrestore(&hpb->rsp_list_lock, flags);
> +}
> +
> +static void ufshpb_cancel_jobs(struct ufshpb_lu *hpb)
> +{
> +	cancel_work_sync(&hpb->map_work);
> +}
> +
>  static bool ufshpb_check_hpb_reset_query(struct ufs_hba *hba)
>  {
>  	int err = 0;
> @@ -309,7 +1173,7 @@ void ufshpb_reset(struct ufs_hba *hba)
>  	struct scsi_device *sdev;
> 
>  	shost_for_each_device(sdev, hba->host) {
> -		hpb = sdev->hostdata;
> +		hpb = ufshpb_get_hpb_data(sdev);
>  		if (!hpb)
>  			continue;
> 
> @@ -326,13 +1190,15 @@ void ufshpb_reset_host(struct ufs_hba *hba)
>  	struct scsi_device *sdev;
> 
>  	shost_for_each_device(sdev, hba->host) {
> -		hpb = sdev->hostdata;
> +		hpb = ufshpb_get_hpb_data(sdev);
>  		if (!hpb)
>  			continue;
> 
>  		if (ufshpb_get_state(hpb) != HPB_PRESENT)
>  			continue;
>  		ufshpb_set_state(hpb, HPB_RESET);
> +		ufshpb_cancel_jobs(hpb);
> +		ufshpb_discard_rsp_lists(hpb);
>  	}
>  }
> 
> @@ -342,13 +1208,14 @@ void ufshpb_suspend(struct ufs_hba *hba)
>  	struct scsi_device *sdev;
> 
>  	shost_for_each_device(sdev, hba->host) {
> -		hpb = sdev->hostdata;
> +		hpb = ufshpb_get_hpb_data(sdev);
>  		if (!hpb)
>  			continue;
> 
>  		if (ufshpb_get_state(hpb) != HPB_PRESENT)
>  			continue;
>  		ufshpb_set_state(hpb, HPB_SUSPEND);
> +		ufshpb_cancel_jobs(hpb);

Here may have a dead lock problem - in the case of runtime suspend,
when ufshpb_suspend() is invoked, all of hba's children scsi devices
are in RPM_SUSPENDED state. When this line tries to cancel a running
map work, i.e. when ufshpb_get_map_req() calls below lines, it will
be stuck at blk_queue_enter().

req = blk_get_request(hpb->sdev_ufs_lu->request_queue,
		      REQ_OP_SCSI_IN, 0);

Please check block layer power management, and see also commit d55d15a33
("scsi: block: Do not accept any requests while suspended").

Regards,

Can Guo.

>  	}
>  }
> 
> @@ -358,7 +1225,7 @@ void ufshpb_resume(struct ufs_hba *hba)
>  	struct scsi_device *sdev;
> 
>  	shost_for_each_device(sdev, hba->host) {
> -		hpb = sdev->hostdata;
> +		hpb = ufshpb_get_hpb_data(sdev);
>  		if (!hpb)
>  			continue;
> 
> @@ -366,6 +1233,7 @@ void ufshpb_resume(struct ufs_hba *hba)
>  		    (ufshpb_get_state(hpb) != HPB_SUSPEND))
>  			continue;
>  		ufshpb_set_state(hpb, HPB_PRESENT);
> +		ufshpb_kick_map_work(hpb);
>  	}
>  }
> 
> @@ -418,7 +1286,7 @@ static int ufshpb_get_lu_info(struct ufs_hba *hba, 
> int lun,
> 
>  void ufshpb_destroy_lu(struct ufs_hba *hba, struct scsi_device *sdev)
>  {
> -	struct ufshpb_lu *hpb = sdev->hostdata;
> +	struct ufshpb_lu *hpb = ufshpb_get_hpb_data(sdev);
> 
>  	if (!hpb)
>  		return;
> @@ -428,8 +1296,13 @@ void ufshpb_destroy_lu(struct ufs_hba *hba,
> struct scsi_device *sdev)
>  	sdev = hpb->sdev_ufs_lu;
>  	sdev->hostdata = NULL;
> 
> +	ufshpb_cancel_jobs(hpb);
> +
>  	ufshpb_destroy_region_tbl(hpb);
> 
> +	kmem_cache_destroy(hpb->map_req_cache);
> +	kmem_cache_destroy(hpb->m_page_cache);
> +
>  	list_del_init(&hpb->list_hpb_lu);
> 
>  	kfree(hpb);
> @@ -437,24 +1310,41 @@ void ufshpb_destroy_lu(struct ufs_hba *hba,
> struct scsi_device *sdev)
> 
>  static void ufshpb_hpb_lu_prepared(struct ufs_hba *hba)
>  {
> +	int pool_size;
>  	struct ufshpb_lu *hpb;
>  	struct scsi_device *sdev;
>  	bool init_success;
> 
> +	if (tot_active_srgn_pages == 0) {
> +		ufshpb_remove(hba);
> +		return;
> +	}
> +
>  	init_success = !ufshpb_check_hpb_reset_query(hba);
> 
> +	pool_size = PAGE_ALIGN(ufshpb_host_map_kbytes * 1024) / PAGE_SIZE;
> +	if (pool_size > tot_active_srgn_pages) {
> +		mempool_resize(ufshpb_mctx_pool, tot_active_srgn_pages);
> +		mempool_resize(ufshpb_page_pool, tot_active_srgn_pages);
> +	}
> +
>  	shost_for_each_device(sdev, hba->host) {
> -		hpb = sdev->hostdata;
> +		hpb = ufshpb_get_hpb_data(sdev);
>  		if (!hpb)
>  			continue;
> 
>  		if (init_success) {
>  			ufshpb_set_state(hpb, HPB_PRESENT);
> +			if ((hpb->lu_pinned_end - hpb->lu_pinned_start) > 0)
> +				queue_work(ufshpb_wq, &hpb->map_work);
>  		} else {
>  			dev_err(hba->dev, "destroy HPB lu %d\n", hpb->lun);
>  			ufshpb_destroy_lu(hba, sdev);
>  		}
>  	}
> +
> +	if (!init_success)
> +		ufshpb_remove(hba);
>  }
> 
>  void ufshpb_init_hpb_lu(struct ufs_hba *hba, struct scsi_device *sdev)
> @@ -476,6 +1366,9 @@ void ufshpb_init_hpb_lu(struct ufs_hba *hba,
> struct scsi_device *sdev)
>  	if (!hpb)
>  		goto out;
> 
> +	tot_active_srgn_pages += hpb_lu_info.max_active_rgns *
> +			hpb->srgns_per_rgn * hpb->pages_per_srgn;
> +
>  	hpb->sdev_ufs_lu = sdev;
>  	sdev->hostdata = hpb;
> 
> @@ -485,6 +1378,57 @@ void ufshpb_init_hpb_lu(struct ufs_hba *hba,
> struct scsi_device *sdev)
>  		ufshpb_hpb_lu_prepared(hba);
>  }
> 
> +static int ufshpb_init_mem_wq(void)
> +{
> +	int ret;
> +	unsigned int pool_size;
> +
> +	ufshpb_mctx_cache = kmem_cache_create("ufshpb_mctx_cache",
> +					sizeof(struct ufshpb_map_ctx),
> +					0, 0, NULL);
> +	if (!ufshpb_mctx_cache) {
> +		pr_err("ufshpb: cannot init mctx cache\n");
> +		return -ENOMEM;
> +	}
> +
> +	pool_size = PAGE_ALIGN(ufshpb_host_map_kbytes * 1024) / PAGE_SIZE;
> +	pr_info("%s:%d ufshpb_host_map_kbytes %u pool_size %u\n",
> +	       __func__, __LINE__, ufshpb_host_map_kbytes, pool_size);
> +
> +	ufshpb_mctx_pool = mempool_create_slab_pool(pool_size,
> +						    ufshpb_mctx_cache);
> +	if (!ufshpb_mctx_pool) {
> +		pr_err("ufshpb: cannot init mctx pool\n");
> +		ret = -ENOMEM;
> +		goto release_mctx_cache;
> +	}
> +
> +	ufshpb_page_pool = mempool_create_page_pool(pool_size, 0);
> +	if (!ufshpb_page_pool) {
> +		pr_err("ufshpb: cannot init page pool\n");
> +		ret = -ENOMEM;
> +		goto release_mctx_pool;
> +	}
> +
> +	ufshpb_wq = alloc_workqueue("ufshpb-wq",
> +					WQ_UNBOUND | WQ_MEM_RECLAIM, 0);
> +	if (!ufshpb_wq) {
> +		pr_err("ufshpb: alloc workqueue failed\n");
> +		ret = -ENOMEM;
> +		goto release_page_pool;
> +	}
> +
> +	return 0;
> +
> +release_page_pool:
> +	mempool_destroy(ufshpb_page_pool);
> +release_mctx_pool:
> +	mempool_destroy(ufshpb_mctx_pool);
> +release_mctx_cache:
> +	kmem_cache_destroy(ufshpb_mctx_cache);
> +	return ret;
> +}
> +
>  void ufshpb_get_geo_info(struct ufs_hba *hba, u8 *geo_buf)
>  {
>  	struct ufshpb_dev_info *hpb_dev_info = &hba->ufshpb_dev;
> @@ -550,7 +1494,13 @@ void ufshpb_init(struct ufs_hba *hba)
>  	if (!ufshpb_is_allowed(hba))
>  		return;
> 
> +	if (ufshpb_init_mem_wq()) {
> +		hpb_dev_info->hpb_disabled = true;
> +		return;
> +	}
> +
>  	atomic_set(&hpb_dev_info->slave_conf_cnt, hpb_dev_info->num_lu);
> +	tot_active_srgn_pages = 0;
>  	/* issue HPB reset query */
>  	for (try = 0; try < HPB_RESET_REQ_RETRIES; try++) {
>  		ret = ufshcd_query_flag(hba, UPIU_QUERY_OPCODE_SET_FLAG,
> @@ -559,3 +1509,16 @@ void ufshpb_init(struct ufs_hba *hba)
>  			break;
>  	}
>  }
> +
> +void ufshpb_remove(struct ufs_hba *hba)
> +{
> +	mempool_destroy(ufshpb_page_pool);
> +	mempool_destroy(ufshpb_mctx_pool);
> +	kmem_cache_destroy(ufshpb_mctx_cache);
> +
> +	destroy_workqueue(ufshpb_wq);
> +}
> +
> +module_param(ufshpb_host_map_kbytes, uint, 0644);
> +MODULE_PARM_DESC(ufshpb_host_map_kbytes,
> +	"ufshpb host mapping memory kilo-bytes for ufshpb memory-pool");
> diff --git a/drivers/scsi/ufs/ufshpb.h b/drivers/scsi/ufs/ufshpb.h
> index 50523821cac8..e40b016971ac 100644
> --- a/drivers/scsi/ufs/ufshpb.h
> +++ b/drivers/scsi/ufs/ufshpb.h
> @@ -83,10 +83,19 @@ struct ufshpb_lu_info {
>  	int max_active_rgns;
>  };
> 
> +struct ufshpb_map_ctx {
> +	struct page **m_page;
> +	unsigned long *ppn_dirty;
> +};
> +
>  struct ufshpb_subregion {
> +	struct ufshpb_map_ctx *mctx;
>  	enum HPB_SRGN_STATE srgn_state;
>  	int rgn_idx;
>  	int srgn_idx;
> +
> +	/* below information is used by rsp_list */
> +	struct list_head list_act_srgn;
>  };
> 
>  struct ufshpb_region {
> @@ -94,6 +103,43 @@ struct ufshpb_region {
>  	enum HPB_RGN_STATE rgn_state;
>  	int rgn_idx;
>  	int srgn_cnt;
> +
> +	/* below information is used by rsp_list */
> +	struct list_head list_inact_rgn;
> +
> +	/* below information is used by lru */
> +	struct list_head list_lru_rgn;
> +};
> +
> +#define for_each_sub_region(rgn, i, srgn)				\
> +	for ((i) = 0;							\
> +	     ((i) < (rgn)->srgn_cnt) && ((srgn) = &(rgn)->srgn_tbl[i]); \
> +	     (i)++)
> +
> +/**
> + * struct ufshpb_req - UFSHPB READ BUFFER (for caching map) request 
> structure
> + * @req: block layer request for READ BUFFER
> + * @bio: bio for holding map page
> + * @hpb: ufshpb_lu structure that related to the L2P map
> + * @mctx: L2P map information
> + * @rgn_idx: target region index
> + * @srgn_idx: target sub-region index
> + * @lun: target logical unit number
> + */
> +struct ufshpb_req {
> +	struct request *req;
> +	struct bio *bio;
> +	struct ufshpb_lu *hpb;
> +	struct ufshpb_map_ctx *mctx;
> +
> +	unsigned int rgn_idx;
> +	unsigned int srgn_idx;
> +};
> +
> +struct victim_select_info {
> +	struct list_head lh_lru_rgn; /* LRU list of regions */
> +	int max_lru_active_cnt; /* supported hpb #region - pinned #region */
> +	atomic_t active_cnt;
>  };
> 
>  struct ufshpb_stats {
> @@ -108,10 +154,22 @@ struct ufshpb_stats {
>  struct ufshpb_lu {
>  	int lun;
>  	struct scsi_device *sdev_ufs_lu;
> +
> +	spinlock_t rgn_state_lock; /* for protect rgn/srgn state */
>  	struct ufshpb_region *rgn_tbl;
> 
>  	atomic_t hpb_state;
> 
> +	spinlock_t rsp_list_lock;
> +	struct list_head lh_act_srgn; /* hold rsp_list_lock */
> +	struct list_head lh_inact_rgn; /* hold rsp_list_lock */
> +
> +	/* cached L2P map management worker */
> +	struct work_struct map_work;
> +
> +	/* for selecting victim */
> +	struct victim_select_info lru_info;
> +
>  	/* pinned region information */
>  	u32 lu_pinned_start;
>  	u32 lu_pinned_end;
> @@ -130,6 +188,9 @@ struct ufshpb_lu {
> 
>  	struct ufshpb_stats stats;
> 
> +	struct kmem_cache *map_req_cache;
> +	struct kmem_cache *m_page_cache;
> +
>  	struct list_head list_hpb_lu;
>  };
> 
> @@ -137,6 +198,7 @@ struct ufs_hba;
>  struct ufshcd_lrb;
> 
>  #ifndef CONFIG_SCSI_UFS_HPB
> +static void ufshpb_rsp_upiu(struct ufs_hba *hba, struct ufshcd_lrb 
> *lrbp) {}
>  static void ufshpb_resume(struct ufs_hba *hba) {}
>  static void ufshpb_suspend(struct ufs_hba *hba) {}
>  static void ufshpb_reset(struct ufs_hba *hba) {}
> @@ -144,10 +206,12 @@ static void ufshpb_reset_host(struct ufs_hba 
> *hba) {}
>  static void ufshpb_init(struct ufs_hba *hba) {}
>  static void ufshpb_init_hpb_lu(struct ufs_hba *hba, struct
> scsi_device *sdev) {}
>  static void ufshpb_destroy_lu(struct ufs_hba *hba, struct scsi_device 
> *sdev) {}
> +static void ufshpb_remove(struct ufs_hba *hba) {}
>  static bool ufshpb_is_allowed(struct ufs_hba *hba) { return false; }
>  static void ufshpb_get_geo_info(struct ufs_hba *hba, u8 *geo_buf) {}
>  static void ufshpb_get_dev_info(struct ufs_hba *hba, u8 *desc_buf) {}
>  #else
> +void ufshpb_rsp_upiu(struct ufs_hba *hba, struct ufshcd_lrb *lrbp);
>  void ufshpb_resume(struct ufs_hba *hba);
>  void ufshpb_suspend(struct ufs_hba *hba);
>  void ufshpb_reset(struct ufs_hba *hba);
> @@ -155,6 +219,7 @@ void ufshpb_reset_host(struct ufs_hba *hba);
>  void ufshpb_init(struct ufs_hba *hba);
>  void ufshpb_init_hpb_lu(struct ufs_hba *hba, struct scsi_device 
> *sdev);
>  void ufshpb_destroy_lu(struct ufs_hba *hba, struct scsi_device *sdev);
> +void ufshpb_remove(struct ufs_hba *hba);
>  bool ufshpb_is_allowed(struct ufs_hba *hba);
>  void ufshpb_get_geo_info(struct ufs_hba *hba, u8 *geo_buf);
>  void ufshpb_get_dev_info(struct ufs_hba *hba, u8 *desc_buf);

[PATCH v19 3/3] scsi: ufs: Prepare HPB read for cached sub-region

[Daejun Park]

This patch changes the read I/O to the HPB read I/O.

If the logical address of the read I/O belongs to active sub-region, the
HPB driver modifies the read I/O command to HPB read. It modifies the UPIU
command of UFS instead of modifying the existing SCSI command.

In the HPB version 1.0, the maximum read I/O size that can be converted to
HPB read is 4KB.

The dirty map of the active sub-region prevents an incorrect HPB read that
has stale physical page number which is updated by previous write I/O.

Reviewed-by: Can Guo <cang@codeaurora.org>
Reviewed-by: Bart Van Assche <bvanassche@acm.org>
Acked-by: Avri Altman <Avri.Altman@wdc.com>
Tested-by: Bean Huo <beanhuo@micron.com>
Signed-off-by: Daejun Park <daejun7.park@samsung.com>
---
 drivers/scsi/ufs/ufshcd.c |   2 +
 drivers/scsi/ufs/ufshpb.c | 234 ++++++++++++++++++++++++++++++++++++++
 drivers/scsi/ufs/ufshpb.h |   2 +
 3 files changed, 238 insertions(+)

diff --git a/drivers/scsi/ufs/ufshcd.c b/drivers/scsi/ufs/ufshcd.c
index 52e48de8d27c..37cb343e9ec1 100644
--- a/drivers/scsi/ufs/ufshcd.c
+++ b/drivers/scsi/ufs/ufshcd.c
@@ -2653,6 +2653,8 @@ static int ufshcd_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *cmd)
 
 	lrbp->req_abort_skip = false;
 
+	ufshpb_prep(hba, lrbp);
+
 	ufshcd_comp_scsi_upiu(hba, lrbp);
 
 	err = ufshcd_map_sg(hba, lrbp);
diff --git a/drivers/scsi/ufs/ufshpb.c b/drivers/scsi/ufs/ufshpb.c
index 48edfdd0f606..73e7b3ed04a4 100644
--- a/drivers/scsi/ufs/ufshpb.c
+++ b/drivers/scsi/ufs/ufshpb.c
@@ -31,6 +31,29 @@ bool ufshpb_is_allowed(struct ufs_hba *hba)
 	return !(hba->ufshpb_dev.hpb_disabled);
 }
 
+static int ufshpb_is_valid_srgn(struct ufshpb_region *rgn,
+			     struct ufshpb_subregion *srgn)
+{
+	return rgn->rgn_state != HPB_RGN_INACTIVE &&
+		srgn->srgn_state == HPB_SRGN_VALID;
+}
+
+static bool ufshpb_is_read_cmd(struct scsi_cmnd *cmd)
+{
+	return req_op(cmd->request) == REQ_OP_READ;
+}
+
+static bool ufshpb_is_write_or_discard_cmd(struct scsi_cmnd *cmd)
+{
+	return op_is_write(req_op(cmd->request)) ||
+	       op_is_discard(req_op(cmd->request));
+}
+
+static bool ufshpb_is_support_chunk(int transfer_len)
+{
+	return transfer_len <= HPB_MULTI_CHUNK_HIGH;
+}
+
 static bool ufshpb_is_general_lun(int lun)
 {
 	return lun < UFS_UPIU_MAX_UNIT_NUM_ID;
@@ -98,6 +121,217 @@ static void ufshpb_set_state(struct ufshpb_lu *hpb, int state)
 	atomic_set(&hpb->hpb_state, state);
 }
 
+static void ufshpb_set_ppn_dirty(struct ufshpb_lu *hpb, int rgn_idx,
+			     int srgn_idx, int srgn_offset, int cnt)
+{
+	struct ufshpb_region *rgn;
+	struct ufshpb_subregion *srgn;
+	int set_bit_len;
+	int bitmap_len = hpb->entries_per_srgn;
+
+next_srgn:
+	rgn = hpb->rgn_tbl + rgn_idx;
+	srgn = rgn->srgn_tbl + srgn_idx;
+
+	if ((srgn_offset + cnt) > bitmap_len)
+		set_bit_len = bitmap_len - srgn_offset;
+	else
+		set_bit_len = cnt;
+
+	if (rgn->rgn_state != HPB_RGN_INACTIVE &&
+	    srgn->srgn_state == HPB_SRGN_VALID)
+		bitmap_set(srgn->mctx->ppn_dirty, srgn_offset, set_bit_len);
+
+	srgn_offset = 0;
+	if (++srgn_idx == hpb->srgns_per_rgn) {
+		srgn_idx = 0;
+		rgn_idx++;
+	}
+
+	cnt -= set_bit_len;
+	if (cnt > 0)
+		goto next_srgn;
+
+	WARN_ON(cnt < 0);
+}
+
+static bool ufshpb_test_ppn_dirty(struct ufshpb_lu *hpb, int rgn_idx,
+				   int srgn_idx, int srgn_offset, int cnt)
+{
+	struct ufshpb_region *rgn;
+	struct ufshpb_subregion *srgn;
+	int bitmap_len = hpb->entries_per_srgn;
+	int bit_len;
+
+next_srgn:
+	rgn = hpb->rgn_tbl + rgn_idx;
+	srgn = rgn->srgn_tbl + srgn_idx;
+
+	if (!ufshpb_is_valid_srgn(rgn, srgn))
+		return true;
+
+	/*
+	 * If the region state is active, mctx must be allocated.
+	 * In this case, check whether the region is evicted or
+	 * mctx allcation fail.
+	 */
+	WARN_ON(!srgn->mctx);
+
+	if ((srgn_offset + cnt) > bitmap_len)
+		bit_len = bitmap_len - srgn_offset;
+	else
+		bit_len = cnt;
+
+	if (find_next_bit(srgn->mctx->ppn_dirty,
+			  bit_len, srgn_offset) >= srgn_offset)
+		return true;
+
+	srgn_offset = 0;
+	if (++srgn_idx == hpb->srgns_per_rgn) {
+		srgn_idx = 0;
+		rgn_idx++;
+	}
+
+	cnt -= bit_len;
+	if (cnt > 0)
+		goto next_srgn;
+
+	return false;
+}
+
+static u64 ufshpb_get_ppn(struct ufshpb_lu *hpb,
+			  struct ufshpb_map_ctx *mctx, int pos, int *error)
+{
+	u64 *ppn_table;
+	struct page *page;
+	int index, offset;
+
+	index = pos / (PAGE_SIZE / HPB_ENTRY_SIZE);
+	offset = pos % (PAGE_SIZE / HPB_ENTRY_SIZE);
+
+	page = mctx->m_page[index];
+	if (unlikely(!page)) {
+		*error = -ENOMEM;
+		dev_err(&hpb->sdev_ufs_lu->sdev_dev,
+			"error. cannot find page in mctx\n");
+		return 0;
+	}
+
+	ppn_table = page_address(page);
+	if (unlikely(!ppn_table)) {
+		*error = -ENOMEM;
+		dev_err(&hpb->sdev_ufs_lu->sdev_dev,
+			"error. cannot get ppn_table\n");
+		return 0;
+	}
+
+	return ppn_table[offset];
+}
+
+static void
+ufshpb_get_pos_from_lpn(struct ufshpb_lu *hpb, unsigned long lpn, int *rgn_idx,
+			int *srgn_idx, int *offset)
+{
+	int rgn_offset;
+
+	*rgn_idx = lpn >> hpb->entries_per_rgn_shift;
+	rgn_offset = lpn & hpb->entries_per_rgn_mask;
+	*srgn_idx = rgn_offset >> hpb->entries_per_srgn_shift;
+	*offset = rgn_offset & hpb->entries_per_srgn_mask;
+}
+
+static void
+ufshpb_set_hpb_read_to_upiu(struct ufshpb_lu *hpb, struct ufshcd_lrb *lrbp,
+				  u32 lpn, u64 ppn,  unsigned int transfer_len)
+{
+	unsigned char *cdb = lrbp->cmd->cmnd;
+
+	cdb[0] = UFSHPB_READ;
+
+	put_unaligned_be64(ppn, &cdb[6]);
+	cdb[14] = transfer_len;
+
+	lrbp->cmd->cmd_len = UFS_CDB_SIZE;
+}
+
+/*
+ * This function will set up HPB read command using host-side L2P map data.
+ * In HPB v1.0, maximum size of HPB read command is 4KB.
+ */
+void ufshpb_prep(struct ufs_hba *hba, struct ufshcd_lrb *lrbp)
+{
+	struct ufshpb_lu *hpb;
+	struct ufshpb_region *rgn;
+	struct ufshpb_subregion *srgn;
+	struct scsi_cmnd *cmd = lrbp->cmd;
+	u32 lpn;
+	u64 ppn;
+	unsigned long flags;
+	int transfer_len, rgn_idx, srgn_idx, srgn_offset;
+	int err = 0;
+
+	hpb = ufshpb_get_hpb_data(cmd->device);
+	if (!hpb)
+		return;
+
+	if (ufshpb_get_state(hpb) != HPB_PRESENT) {
+		dev_notice(&hpb->sdev_ufs_lu->sdev_dev,
+			   "%s: ufshpb state is not PRESENT", __func__);
+		return;
+	}
+
+	if (!ufshpb_is_write_or_discard_cmd(cmd) &&
+	    !ufshpb_is_read_cmd(cmd))
+		return;
+
+	transfer_len = sectors_to_logical(cmd->device, blk_rq_sectors(cmd->request));
+	if (unlikely(!transfer_len))
+		return;
+
+	lpn = sectors_to_logical(cmd->device, blk_rq_pos(cmd->request));
+	ufshpb_get_pos_from_lpn(hpb, lpn, &rgn_idx, &srgn_idx, &srgn_offset);
+	rgn = hpb->rgn_tbl + rgn_idx;
+	srgn = rgn->srgn_tbl + srgn_idx;
+
+	/* If command type is WRITE or DISCARD, set bitmap as drity */
+	if (ufshpb_is_write_or_discard_cmd(cmd)) {
+		spin_lock_irqsave(&hpb->rgn_state_lock, flags);
+		ufshpb_set_ppn_dirty(hpb, rgn_idx, srgn_idx, srgn_offset,
+				 transfer_len);
+		spin_unlock_irqrestore(&hpb->rgn_state_lock, flags);
+		return;
+	}
+
+	if (!ufshpb_is_support_chunk(transfer_len))
+		return;
+
+	spin_lock_irqsave(&hpb->rgn_state_lock, flags);
+	if (ufshpb_test_ppn_dirty(hpb, rgn_idx, srgn_idx, srgn_offset,
+				   transfer_len)) {
+		hpb->stats.miss_cnt++;
+		spin_unlock_irqrestore(&hpb->rgn_state_lock, flags);
+		return;
+	}
+
+	ppn = ufshpb_get_ppn(hpb, srgn->mctx, srgn_offset, &err);
+	spin_unlock_irqrestore(&hpb->rgn_state_lock, flags);
+	if (unlikely(err)) {
+		/*
+		 * In this case, the region state is active,
+		 * but the ppn table is not allocated.
+		 * Make sure that ppn table must be allocated on
+		 * active state.
+		 */
+		WARN_ON(true);
+		dev_err(hba->dev, "ufshpb_get_ppn failed. err %d\n", err);
+		return;
+	}
+
+	ufshpb_set_hpb_read_to_upiu(hpb, lrbp, lpn, ppn, transfer_len);
+
+	hpb->stats.hit_cnt++;
+}
+
 static struct ufshpb_req *ufshpb_get_map_req(struct ufshpb_lu *hpb,
 					     struct ufshpb_subregion *srgn)
 {
diff --git a/drivers/scsi/ufs/ufshpb.h b/drivers/scsi/ufs/ufshpb.h
index e40b016971ac..2c43a03b66b6 100644
--- a/drivers/scsi/ufs/ufshpb.h
+++ b/drivers/scsi/ufs/ufshpb.h
@@ -198,6 +198,7 @@ struct ufs_hba;
 struct ufshcd_lrb;
 
 #ifndef CONFIG_SCSI_UFS_HPB
+static void ufshpb_prep(struct ufs_hba *hba, struct ufshcd_lrb *lrbp) {}
 static void ufshpb_rsp_upiu(struct ufs_hba *hba, struct ufshcd_lrb *lrbp) {}
 static void ufshpb_resume(struct ufs_hba *hba) {}
 static void ufshpb_suspend(struct ufs_hba *hba) {}
@@ -211,6 +212,7 @@ static bool ufshpb_is_allowed(struct ufs_hba *hba) { return false; }
 static void ufshpb_get_geo_info(struct ufs_hba *hba, u8 *geo_buf) {}
 static void ufshpb_get_dev_info(struct ufs_hba *hba, u8 *desc_buf) {}
 #else
+void ufshpb_prep(struct ufs_hba *hba, struct ufshcd_lrb *lrbp);
 void ufshpb_rsp_upiu(struct ufs_hba *hba, struct ufshcd_lrb *lrbp);
 void ufshpb_resume(struct ufs_hba *hba);
 void ufshpb_suspend(struct ufs_hba *hba);
-- 
2.25.1

Re: [PATCH v19 3/3] scsi: ufs: Prepare HPB read for cached sub-region

[Can Guo]

On 2021-01-29 13:30, Daejun Park wrote:
> This patch changes the read I/O to the HPB read I/O.
> 
> If the logical address of the read I/O belongs to active sub-region, 
> the
> HPB driver modifies the read I/O command to HPB read. It modifies the 
> UPIU
> command of UFS instead of modifying the existing SCSI command.
> 
> In the HPB version 1.0, the maximum read I/O size that can be converted 
> to
> HPB read is 4KB.
> 
> The dirty map of the active sub-region prevents an incorrect HPB read 
> that
> has stale physical page number which is updated by previous write I/O.
> 
> Reviewed-by: Can Guo <cang@codeaurora.org>
> Reviewed-by: Bart Van Assche <bvanassche@acm.org>
> Acked-by: Avri Altman <Avri.Altman@wdc.com>
> Tested-by: Bean Huo <beanhuo@micron.com>
> Signed-off-by: Daejun Park <daejun7.park@samsung.com>
> ---
>  drivers/scsi/ufs/ufshcd.c |   2 +
>  drivers/scsi/ufs/ufshpb.c | 234 ++++++++++++++++++++++++++++++++++++++
>  drivers/scsi/ufs/ufshpb.h |   2 +
>  3 files changed, 238 insertions(+)
> 
> diff --git a/drivers/scsi/ufs/ufshcd.c b/drivers/scsi/ufs/ufshcd.c
> index 52e48de8d27c..37cb343e9ec1 100644
> --- a/drivers/scsi/ufs/ufshcd.c
> +++ b/drivers/scsi/ufs/ufshcd.c
> @@ -2653,6 +2653,8 @@ static int ufshcd_queuecommand(struct Scsi_Host
> *host, struct scsi_cmnd *cmd)
> 
>  	lrbp->req_abort_skip = false;
> 
> +	ufshpb_prep(hba, lrbp);
> +
>  	ufshcd_comp_scsi_upiu(hba, lrbp);
> 
>  	err = ufshcd_map_sg(hba, lrbp);
> diff --git a/drivers/scsi/ufs/ufshpb.c b/drivers/scsi/ufs/ufshpb.c
> index 48edfdd0f606..73e7b3ed04a4 100644
> --- a/drivers/scsi/ufs/ufshpb.c
> +++ b/drivers/scsi/ufs/ufshpb.c
> @@ -31,6 +31,29 @@ bool ufshpb_is_allowed(struct ufs_hba *hba)
>  	return !(hba->ufshpb_dev.hpb_disabled);
>  }
> 
> +static int ufshpb_is_valid_srgn(struct ufshpb_region *rgn,
> +			     struct ufshpb_subregion *srgn)
> +{
> +	return rgn->rgn_state != HPB_RGN_INACTIVE &&
> +		srgn->srgn_state == HPB_SRGN_VALID;
> +}
> +
> +static bool ufshpb_is_read_cmd(struct scsi_cmnd *cmd)
> +{
> +	return req_op(cmd->request) == REQ_OP_READ;
> +}
> +
> +static bool ufshpb_is_write_or_discard_cmd(struct scsi_cmnd *cmd)
> +{
> +	return op_is_write(req_op(cmd->request)) ||
> +	       op_is_discard(req_op(cmd->request));
> +}
> +
> +static bool ufshpb_is_support_chunk(int transfer_len)
> +{
> +	return transfer_len <= HPB_MULTI_CHUNK_HIGH;
> +}
> +
>  static bool ufshpb_is_general_lun(int lun)
>  {
>  	return lun < UFS_UPIU_MAX_UNIT_NUM_ID;
> @@ -98,6 +121,217 @@ static void ufshpb_set_state(struct ufshpb_lu
> *hpb, int state)
>  	atomic_set(&hpb->hpb_state, state);
>  }
> 
> +static void ufshpb_set_ppn_dirty(struct ufshpb_lu *hpb, int rgn_idx,
> +			     int srgn_idx, int srgn_offset, int cnt)
> +{
> +	struct ufshpb_region *rgn;
> +	struct ufshpb_subregion *srgn;
> +	int set_bit_len;
> +	int bitmap_len = hpb->entries_per_srgn;
> +
> +next_srgn:
> +	rgn = hpb->rgn_tbl + rgn_idx;
> +	srgn = rgn->srgn_tbl + srgn_idx;
> +
> +	if ((srgn_offset + cnt) > bitmap_len)
> +		set_bit_len = bitmap_len - srgn_offset;
> +	else
> +		set_bit_len = cnt;
> +
> +	if (rgn->rgn_state != HPB_RGN_INACTIVE &&
> +	    srgn->srgn_state == HPB_SRGN_VALID)
> +		bitmap_set(srgn->mctx->ppn_dirty, srgn_offset, set_bit_len);
> +
> +	srgn_offset = 0;
> +	if (++srgn_idx == hpb->srgns_per_rgn) {
> +		srgn_idx = 0;
> +		rgn_idx++;
> +	}
> +
> +	cnt -= set_bit_len;
> +	if (cnt > 0)
> +		goto next_srgn;
> +
> +	WARN_ON(cnt < 0);
> +}
> +
> +static bool ufshpb_test_ppn_dirty(struct ufshpb_lu *hpb, int rgn_idx,
> +				   int srgn_idx, int srgn_offset, int cnt)
> +{
> +	struct ufshpb_region *rgn;
> +	struct ufshpb_subregion *srgn;
> +	int bitmap_len = hpb->entries_per_srgn;
> +	int bit_len;
> +
> +next_srgn:
> +	rgn = hpb->rgn_tbl + rgn_idx;
> +	srgn = rgn->srgn_tbl + srgn_idx;
> +
> +	if (!ufshpb_is_valid_srgn(rgn, srgn))
> +		return true;
> +
> +	/*
> +	 * If the region state is active, mctx must be allocated.
> +	 * In this case, check whether the region is evicted or
> +	 * mctx allcation fail.
> +	 */
> +	WARN_ON(!srgn->mctx);
> +
> +	if ((srgn_offset + cnt) > bitmap_len)
> +		bit_len = bitmap_len - srgn_offset;
> +	else
> +		bit_len = cnt;
> +
> +	if (find_next_bit(srgn->mctx->ppn_dirty,
> +			  bit_len, srgn_offset) >= srgn_offset)
> +		return true;
> +
> +	srgn_offset = 0;
> +	if (++srgn_idx == hpb->srgns_per_rgn) {
> +		srgn_idx = 0;
> +		rgn_idx++;
> +	}
> +
> +	cnt -= bit_len;
> +	if (cnt > 0)
> +		goto next_srgn;
> +
> +	return false;
> +}
> +
> +static u64 ufshpb_get_ppn(struct ufshpb_lu *hpb,
> +			  struct ufshpb_map_ctx *mctx, int pos, int *error)
> +{
> +	u64 *ppn_table;
> +	struct page *page;
> +	int index, offset;
> +
> +	index = pos / (PAGE_SIZE / HPB_ENTRY_SIZE);
> +	offset = pos % (PAGE_SIZE / HPB_ENTRY_SIZE);
> +
> +	page = mctx->m_page[index];
> +	if (unlikely(!page)) {
> +		*error = -ENOMEM;
> +		dev_err(&hpb->sdev_ufs_lu->sdev_dev,
> +			"error. cannot find page in mctx\n");
> +		return 0;
> +	}
> +
> +	ppn_table = page_address(page);
> +	if (unlikely(!ppn_table)) {
> +		*error = -ENOMEM;
> +		dev_err(&hpb->sdev_ufs_lu->sdev_dev,
> +			"error. cannot get ppn_table\n");
> +		return 0;
> +	}
> +
> +	return ppn_table[offset];
> +}
> +
> +static void
> +ufshpb_get_pos_from_lpn(struct ufshpb_lu *hpb, unsigned long lpn, int 
> *rgn_idx,
> +			int *srgn_idx, int *offset)
> +{
> +	int rgn_offset;
> +
> +	*rgn_idx = lpn >> hpb->entries_per_rgn_shift;
> +	rgn_offset = lpn & hpb->entries_per_rgn_mask;
> +	*srgn_idx = rgn_offset >> hpb->entries_per_srgn_shift;
> +	*offset = rgn_offset & hpb->entries_per_srgn_mask;
> +}
> +
> +static void
> +ufshpb_set_hpb_read_to_upiu(struct ufshpb_lu *hpb, struct ufshcd_lrb 
> *lrbp,
> +				  u32 lpn, u64 ppn,  unsigned int transfer_len)
> +{
> +	unsigned char *cdb = lrbp->cmd->cmnd;
> +
> +	cdb[0] = UFSHPB_READ;
> +
> +	put_unaligned_be64(ppn, &cdb[6]);

You are assuming the HPB entries read out by "HPB Read Buffer" cmd are 
in Little
Endian, which is why you are using put_unaligned_be64 here. However, 
this assumption
is not right for all the other flash vendors - HPB entries read out by 
"HPB Read Buffer"
cmd may come in Big Endian, if so, their random read performance are 
screwed.

Actually, I have seen at least two flash vendors acting so. I had to 
modify this line
to get the code work properly on my setups.

Meanwhile, in your cover letter, you mentioned that the performance data 
is collected
on a UFS2.1 device. Please re-collect the data on a real UFS3.1 device 
and let me
know the part number. Otherwise, the data is not quite convincing to us.

Regards,
Can Guo.

> +	cdb[14] = transfer_len;
> +
> +	lrbp->cmd->cmd_len = UFS_CDB_SIZE;
> +}
> +
> +/*
> + * This function will set up HPB read command using host-side L2P map 
> data.
> + * In HPB v1.0, maximum size of HPB read command is 4KB.
> + */
> +void ufshpb_prep(struct ufs_hba *hba, struct ufshcd_lrb *lrbp)
> +{
> +	struct ufshpb_lu *hpb;
> +	struct ufshpb_region *rgn;
> +	struct ufshpb_subregion *srgn;
> +	struct scsi_cmnd *cmd = lrbp->cmd;
> +	u32 lpn;
> +	u64 ppn;
> +	unsigned long flags;
> +	int transfer_len, rgn_idx, srgn_idx, srgn_offset;
> +	int err = 0;
> +
> +	hpb = ufshpb_get_hpb_data(cmd->device);
> +	if (!hpb)
> +		return;
> +
> +	if (ufshpb_get_state(hpb) != HPB_PRESENT) {
> +		dev_notice(&hpb->sdev_ufs_lu->sdev_dev,
> +			   "%s: ufshpb state is not PRESENT", __func__);
> +		return;
> +	}
> +
> +	if (!ufshpb_is_write_or_discard_cmd(cmd) &&
> +	    !ufshpb_is_read_cmd(cmd))
> +		return;
> +
> +	transfer_len = sectors_to_logical(cmd->device, 
> blk_rq_sectors(cmd->request));
> +	if (unlikely(!transfer_len))
> +		return;
> +
> +	lpn = sectors_to_logical(cmd->device, blk_rq_pos(cmd->request));
> +	ufshpb_get_pos_from_lpn(hpb, lpn, &rgn_idx, &srgn_idx, &srgn_offset);
> +	rgn = hpb->rgn_tbl + rgn_idx;
> +	srgn = rgn->srgn_tbl + srgn_idx;
> +
> +	/* If command type is WRITE or DISCARD, set bitmap as drity */
> +	if (ufshpb_is_write_or_discard_cmd(cmd)) {
> +		spin_lock_irqsave(&hpb->rgn_state_lock, flags);
> +		ufshpb_set_ppn_dirty(hpb, rgn_idx, srgn_idx, srgn_offset,
> +				 transfer_len);
> +		spin_unlock_irqrestore(&hpb->rgn_state_lock, flags);
> +		return;
> +	}
> +
> +	if (!ufshpb_is_support_chunk(transfer_len))
> +		return;
> +
> +	spin_lock_irqsave(&hpb->rgn_state_lock, flags);
> +	if (ufshpb_test_ppn_dirty(hpb, rgn_idx, srgn_idx, srgn_offset,
> +				   transfer_len)) {
> +		hpb->stats.miss_cnt++;
> +		spin_unlock_irqrestore(&hpb->rgn_state_lock, flags);
> +		return;
> +	}
> +
> +	ppn = ufshpb_get_ppn(hpb, srgn->mctx, srgn_offset, &err);
> +	spin_unlock_irqrestore(&hpb->rgn_state_lock, flags);
> +	if (unlikely(err)) {
> +		/*
> +		 * In this case, the region state is active,
> +		 * but the ppn table is not allocated.
> +		 * Make sure that ppn table must be allocated on
> +		 * active state.
> +		 */
> +		WARN_ON(true);
> +		dev_err(hba->dev, "ufshpb_get_ppn failed. err %d\n", err);
> +		return;
> +	}
> +
> +	ufshpb_set_hpb_read_to_upiu(hpb, lrbp, lpn, ppn, transfer_len);
> +
> +	hpb->stats.hit_cnt++;
> +}
> +
>  static struct ufshpb_req *ufshpb_get_map_req(struct ufshpb_lu *hpb,
>  					     struct ufshpb_subregion *srgn)
>  {
> diff --git a/drivers/scsi/ufs/ufshpb.h b/drivers/scsi/ufs/ufshpb.h
> index e40b016971ac..2c43a03b66b6 100644
> --- a/drivers/scsi/ufs/ufshpb.h
> +++ b/drivers/scsi/ufs/ufshpb.h
> @@ -198,6 +198,7 @@ struct ufs_hba;
>  struct ufshcd_lrb;
> 
>  #ifndef CONFIG_SCSI_UFS_HPB
> +static void ufshpb_prep(struct ufs_hba *hba, struct ufshcd_lrb *lrbp) 
> {}
>  static void ufshpb_rsp_upiu(struct ufs_hba *hba, struct ufshcd_lrb 
> *lrbp) {}
>  static void ufshpb_resume(struct ufs_hba *hba) {}
>  static void ufshpb_suspend(struct ufs_hba *hba) {}
> @@ -211,6 +212,7 @@ static bool ufshpb_is_allowed(struct ufs_hba *hba)
> { return false; }
>  static void ufshpb_get_geo_info(struct ufs_hba *hba, u8 *geo_buf) {}
>  static void ufshpb_get_dev_info(struct ufs_hba *hba, u8 *desc_buf) {}
>  #else
> +void ufshpb_prep(struct ufs_hba *hba, struct ufshcd_lrb *lrbp);
>  void ufshpb_rsp_upiu(struct ufs_hba *hba, struct ufshcd_lrb *lrbp);
>  void ufshpb_resume(struct ufs_hba *hba);
>  void ufshpb_suspend(struct ufs_hba *hba);

Re: [PATCH v19 3/3] scsi: ufs: Prepare HPB read for cached sub-region

[Bean Huo]

On Fri, 2021-02-05 at 11:29 +0800, Can Guo wrote:
> > +     *rgn_idx = lpn >> hpb->entries_per_rgn_shift;
> > +     rgn_offset = lpn & hpb->entries_per_rgn_mask;
> > +     *srgn_idx = rgn_offset >> hpb->entries_per_srgn_shift;
> > +     *offset = rgn_offset & hpb->entries_per_srgn_mask;
> > +}
> > +
> > +static void
> > +ufshpb_set_hpb_read_to_upiu(struct ufshpb_lu *hpb, struct
> > ufshcd_lrb 
> > *lrbp,
> > +                               u32 lpn, u64 ppn,  unsigned int
> > transfer_len)
> > +{
> > +     unsigned char *cdb = lrbp->cmd->cmnd;
> > +
> > +     cdb[0] = UFSHPB_READ;
> > +
> > +     put_unaligned_be64(ppn, &cdb[6]);
> 
> You are assuming the HPB entries read out by "HPB Read Buffer" cmd
> are 
> in Little
> Endian, which is why you are using put_unaligned_be64 here. However, 
> this assumption
> is not right for all the other flash vendors - HPB entries read out
> by 
> "HPB Read Buffer"
> cmd may come in Big Endian, if so, their random read performance are 
> screwed.

For this question, it is very hard to make a correct format since the
Spec doesn't give a clear definition. Should we have a default format,
if there is conflict, and then add quirk or add a vendor-specific
table?

Hi Avri
Do you have a good idea?

Bean

RE: [PATCH v19 3/3] scsi: ufs: Prepare HPB read for cached sub-region

[Avri Altman]

> > > +     put_unaligned_be64(ppn, &cdb[6]);
> >
> > You are assuming the HPB entries read out by "HPB Read Buffer" cmd
> > are
> > in Little
> > Endian, which is why you are using put_unaligned_be64 here. However,
> > this assumption
> > is not right for all the other flash vendors - HPB entries read out
> > by
> > "HPB Read Buffer"
> > cmd may come in Big Endian, if so, their random read performance are
> > screwed.
> 
> For this question, it is very hard to make a correct format since the
> Spec doesn't give a clear definition. Should we have a default format,
> if there is conflict, and then add quirk or add a vendor-specific
> table?
> 
> Hi Avri
> Do you have a good idea?
I don't know.  Better let Daejun answer this.
This was working for me for both Galaxy S20 (Exynos) as well as Xiaomi Mi10 (8250).

Thanks,
Avri

Re: [PATCH v19 3/3] scsi: ufs: Prepare HPB read for cached sub-region

[Bean Huo]

On Fri, 2021-02-05 at 14:06 +0000, Avri Altman wrote:
> > > > +     put_unaligned_be64(ppn, &cdb[6]);
> > > 
> > > You are assuming the HPB entries read out by "HPB Read Buffer"
> > > cmd
> > > are
> > > in Little
> > > Endian, which is why you are using put_unaligned_be64 here.
> > > However,
> > > this assumption
> > > is not right for all the other flash vendors - HPB entries read
> > > out
> > > by
> > > "HPB Read Buffer"
> > > cmd may come in Big Endian, if so, their random read performance
> > > are
> > > screwed.
> > 
> > For this question, it is very hard to make a correct format since
> > the
> > Spec doesn't give a clear definition. Should we have a default
> > format,
> > if there is conflict, and then add quirk or add a vendor-specific
> > table?
> > 
> > Hi Avri
> > Do you have a good idea?
> 
> I don't know.  Better let Daejun answer this.
> This was working for me for both Galaxy S20 (Exynos) as well as
> Xiaomi Mi10 (8250).
> 

Thanks, I tested Daejun's patchset before, it is also ok (I don't know
which version patchset). maybe we can keep current implementation as
default, then if there is conflict, and submit the quirk.

Thanks,
Bean

> Thanks,
> Avri

Re: [PATCH v19 3/3] scsi: ufs: Prepare HPB read for cached sub-region

[Can Guo]

On 2021-02-05 23:08, Bean Huo wrote:
> On Fri, 2021-02-05 at 14:06 +0000, Avri Altman wrote:
>> > > > +     put_unaligned_be64(ppn, &cdb[6]);
>> > >
>> > > You are assuming the HPB entries read out by "HPB Read Buffer"
>> > > cmd
>> > > are
>> > > in Little
>> > > Endian, which is why you are using put_unaligned_be64 here.
>> > > However,
>> > > this assumption
>> > > is not right for all the other flash vendors - HPB entries read
>> > > out
>> > > by
>> > > "HPB Read Buffer"
>> > > cmd may come in Big Endian, if so, their random read performance
>> > > are
>> > > screwed.
>> >
>> > For this question, it is very hard to make a correct format since
>> > the
>> > Spec doesn't give a clear definition. Should we have a default
>> > format,
>> > if there is conflict, and then add quirk or add a vendor-specific
>> > table?
>> >
>> > Hi Avri
>> > Do you have a good idea?
>> 
>> I don't know.  Better let Daejun answer this.
>> This was working for me for both Galaxy S20 (Exynos) as well as
>> Xiaomi Mi10 (8250).
>> 
> 
> Thanks, I tested Daejun's patchset before, it is also ok (I don't know
> which version patchset). maybe we can keep current implementation as
> default, then if there is conflict, and submit the quirk.
> 

Yeah, you've tested it, are you sure that Micron's UFS devices are OK
with this specific code line?

Micron UFS FW team has confirmed that Micron's HPB entries read out by
"HPB Buffer Read" cmd are in big-endian byte ordering.

If Micron FW team is right, I am pretty sure that you would have seen
random read performance regression on Micron UFS devices caused by
invalid HPB entry format in HPB Read cmd UPIU (which leads to L2P cache
miss in device side all the time) during your test.

Can Guo.

> Thanks,
> Bean
> 
>> Thanks,
>> Avri

Re: [PATCH v19 3/3] scsi: ufs: Prepare HPB read for cached sub-region

[Bean Huo]

On Sun, 2021-02-07 at 15:36 +0800, Can Guo wrote:
> > 
> > Thanks, I tested Daejun's patchset before, it is also ok (I don't
> > know
> > which version patchset). maybe we can keep current implementation
> > as
> > default, then if there is conflict, and submit the quirk.
> > 
> 
> Yeah, you've tested it, are you sure that Micron's UFS devices are OK
> with this specific code line?
> 
> Micron UFS FW team has confirmed that Micron's HPB entries read out
> by
> "HPB Buffer Read" cmd are in big-endian byte ordering.

Aha, I think you didn't check with right person :), ping me, let me
tell you this confusing story. and see my HPB patch, I didn't the same
with here:

https://patchwork.kernel.org/project/linux-scsi/patch/20200504142032.16619-6-beanhuo@micron.com/

Bean

RE: [PATCH v19 3/3] scsi: ufs: Prepare HPB read for cached sub-region

[Avri Altman]

> 
> 
> > > > +     put_unaligned_be64(ppn, &cdb[6]);
> > >
> > > You are assuming the HPB entries read out by "HPB Read Buffer" cmd
> > > are
> > > in Little
> > > Endian, which is why you are using put_unaligned_be64 here. However,
> > > this assumption
> > > is not right for all the other flash vendors - HPB entries read out
> > > by
> > > "HPB Read Buffer"
> > > cmd may come in Big Endian, if so, their random read performance are
> > > screwed.
> >
> > For this question, it is very hard to make a correct format since the
> > Spec doesn't give a clear definition. Should we have a default format,
> > if there is conflict, and then add quirk or add a vendor-specific
> > table?
> >
> > Hi Avri
> > Do you have a good idea?
> I don't know.  Better let Daejun answer this.
> This was working for me for both Galaxy S20 (Exynos) as well as Xiaomi Mi10
> (8250).
As for the endianity issue - 
I don't think that any fix is needed in the hpb driver.
It is readily seen that the ppn from get_ppn, and the one in the upiu cdb (upiu trace) are identical.
Therefore, if an issue exist, it is IMHO a device issue.

kworker/u16:10-315   [001] d..2    62.283264: ufshpb_get_ppn: Avri ppn 480d2f8244c21abd
  kworker/u16:10-315   [001] d..2    62.283336: ufshcd_upiu: v:1.10 send: T:62283314922, HDR:014000000000000000000000, CDB:8800002ddaac480d2f8244c21abd0100, D:

Again, verified on both gs20 (exynos) and mi10 (8250).
Thanks,
Avri

Re: [PATCH v19 3/3] scsi: ufs: Prepare HPB read for cached sub-region

[Bean Huo]

On Tue, 2021-02-09 at 13:25 +0000, Avri Altman wrote:
> > 
> > 
> > > > > +     put_unaligned_be64(ppn, &cdb[6]);
> > > > 
> > > > You are assuming the HPB entries read out by "HPB Read Buffer"
> > > > cmd
> > > > are
> > > > in Little
> > > > Endian, which is why you are using put_unaligned_be64 here.
> > > > However,
> > > > this assumption
> > > > is not right for all the other flash vendors - HPB entries read
> > > > out
> > > > by
> > > > "HPB Read Buffer"
> > > > cmd may come in Big Endian, if so, their random read
> > > > performance are
> > > > screwed.
> > > 
> > > For this question, it is very hard to make a correct format since
> > > the
> > > Spec doesn't give a clear definition. Should we have a default
> > > format,
> > > if there is conflict, and then add quirk or add a vendor-specific
> > > table?
> > > 
> > > Hi Avri
> > > Do you have a good idea?
> > 
> > I don't know.  Better let Daejun answer this.
> > This was working for me for both Galaxy S20 (Exynos) as well as
> > Xiaomi Mi10
> > (8250).
> 
> As for the endianity issue - 
> I don't think that any fix is needed in the hpb driver.
> It is readily seen that the ppn from get_ppn, and the one in the upiu
> cdb (upiu trace) are identical.
> Therefore, if an issue exist, it is IMHO a device issue.
> 
> kworker/u16:10-315   [001] d..2    62.283264: ufshpb_get_ppn: Avri
> ppn 480d2f8244c21abd
>   kworker/u16:10-315   [001] d..2    62.283336: ufshcd_upiu: v:1.10
> send: T:62283314922, HDR:014000000000000000000000,
> CDB:8800002ddaac480d2f8244c21abd0100, D:
> 
> Again, verified on both gs20 (exynos) and mi10 (8250).
> Thanks,
> Avri


Hi Avri,
Your testing method is no problem, the current problem is in function
ufshpb_get_ppn().


+static u64 ufshpb_get_ppn(struct ufshpb_lu *hpb,
+                         struct ufshpb_map_ctx *mctx, int pos, int
*error)
+{
+       u64 *ppn_table; 
+       struct page *page;
+       int index, offset;
+
+       index = pos / (PAGE_SIZE / HPB_ENTRY_SIZE);
+       offset = pos % (PAGE_SIZE / HPB_ENTRY_SIZE);
+
+       page = mctx->m_page[index];
+       if (unlikely(!page)) {
+               *error = -ENOMEM;
+               dev_err(&hpb->sdev_ufs_lu->sdev_dev,
+                       "error. cannot find page in mctx\n");
+               return 0;
+       }
+
+       ppn_table = page_address(page);
+       if (unlikely(!ppn_table)) {
+               *error = -ENOMEM;
+               dev_err(&hpb->sdev_ufs_lu->sdev_dev,
+                       "error. cannot get ppn_table\n");
+               return 0;
+       }
+
+       return ppn_table[offset];
+}


Say, the UFS device outputs the L2P entry in big-endian, which means
the most significant byte of an L2P entry will be output firstly, then
the less significant byte..., let's take an example of one L2P entry:

0x 12 34 56 78 90 12 34 56

0x12 is the most significant byte, will be store in the lowest address
in the L2P cache.

eg,

F0000008: 1234 5678 9012 3456

In the ARM based system, If we use "return ppn_table[offset]",
the original L2P entry 0x1234 5678 9012 3456, will be converted to
0x5634 1290 7856 3412. then use put_unaligned_be64(), UFS receive
unexpected L2P entry(L2P entry miss).

If the UFS output L2P entry in the big-endian, this is a problem.


For the UFS outputs L2P entry in little-endian, no problem,

Because of the L2P entry in the memory:

F0000008: 5634 1290 7856 3412

After return ppn_table[offset], L2P entry will be correct L2P entry:

0x1234567890123456. then use put_unaligned_be64(), UFS can receive
expected L2P etnry(L2P entry hit).


we need to figure out which way is the JEDEC recommended L2P entry
output endianness. otherwise, two methods co-exist in HPB driver, there
will confuse customer.
If you have a look at the JEDEC HPB 2.0, seems the big-endian is
correct way. This need you and Daejun to double check inside your
company.

thanks,
Bean

Re: [PATCH v19 3/3] scsi: ufs: Prepare HPB read for cached sub-region

[Can Guo]

On 2021-02-09 22:21, Bean Huo wrote:
> On Tue, 2021-02-09 at 13:25 +0000, Avri Altman wrote:
>> >
>> >
>> > > > > +     put_unaligned_be64(ppn, &cdb[6]);
>> > > >
>> > > > You are assuming the HPB entries read out by "HPB Read Buffer"
>> > > > cmd
>> > > > are
>> > > > in Little
>> > > > Endian, which is why you are using put_unaligned_be64 here.
>> > > > However,
>> > > > this assumption
>> > > > is not right for all the other flash vendors - HPB entries read
>> > > > out
>> > > > by
>> > > > "HPB Read Buffer"
>> > > > cmd may come in Big Endian, if so, their random read
>> > > > performance are
>> > > > screwed.
>> > >
>> > > For this question, it is very hard to make a correct format since
>> > > the
>> > > Spec doesn't give a clear definition. Should we have a default
>> > > format,
>> > > if there is conflict, and then add quirk or add a vendor-specific
>> > > table?
>> > >
>> > > Hi Avri
>> > > Do you have a good idea?
>> >
>> > I don't know.  Better let Daejun answer this.
>> > This was working for me for both Galaxy S20 (Exynos) as well as
>> > Xiaomi Mi10
>> > (8250).
>> 
>> As for the endianity issue -
>> I don't think that any fix is needed in the hpb driver.
>> It is readily seen that the ppn from get_ppn, and the one in the upiu
>> cdb (upiu trace) are identical.
>> Therefore, if an issue exist, it is IMHO a device issue.
>> 
>> kworker/u16:10-315   [001] d..2    62.283264: ufshpb_get_ppn: Avri
>> ppn 480d2f8244c21abd
>>   kworker/u16:10-315   [001] d..2    62.283336: ufshcd_upiu: v:1.10
>> send: T:62283314922, HDR:014000000000000000000000,
>> CDB:8800002ddaac480d2f8244c21abd0100, D:
>> 
>> Again, verified on both gs20 (exynos) and mi10 (8250).
>> Thanks,
>> Avri
> 
> 
> Hi Avri,
> Your testing method is no problem, the current problem is in function
> ufshpb_get_ppn().
> 
> 
> +static u64 ufshpb_get_ppn(struct ufshpb_lu *hpb,
> +                         struct ufshpb_map_ctx *mctx, int pos, int
> *error)
> +{
> +       u64 *ppn_table;
> +       struct page *page;
> +       int index, offset;
> +
> +       index = pos / (PAGE_SIZE / HPB_ENTRY_SIZE);
> +       offset = pos % (PAGE_SIZE / HPB_ENTRY_SIZE);
> +
> +       page = mctx->m_page[index];
> +       if (unlikely(!page)) {
> +               *error = -ENOMEM;
> +               dev_err(&hpb->sdev_ufs_lu->sdev_dev,
> +                       "error. cannot find page in mctx\n");
> +               return 0;
> +       }
> +
> +       ppn_table = page_address(page);
> +       if (unlikely(!ppn_table)) {
> +               *error = -ENOMEM;
> +               dev_err(&hpb->sdev_ufs_lu->sdev_dev,
> +                       "error. cannot get ppn_table\n");
> +               return 0;
> +       }
> +
> +       return ppn_table[offset];
> +}
> 
> 
> Say, the UFS device outputs the L2P entry in big-endian, which means
> the most significant byte of an L2P entry will be output firstly, then
> the less significant byte..., let's take an example of one L2P entry:
> 
> 0x 12 34 56 78 90 12 34 56
> 
> 0x12 is the most significant byte, will be store in the lowest address
> in the L2P cache.
> 
> eg,
> 
> F0000008: 1234 5678 9012 3456
> 
> In the ARM based system, If we use "return ppn_table[offset]",
> the original L2P entry 0x1234 5678 9012 3456, will be converted to
> 0x5634 1290 7856 3412. then use put_unaligned_be64(), UFS receive
> unexpected L2P entry(L2P entry miss).
> 
> If the UFS output L2P entry in the big-endian, this is a problem.
> 
> 
> For the UFS outputs L2P entry in little-endian, no problem,
> 
> Because of the L2P entry in the memory:
> 
> F0000008: 5634 1290 7856 3412
> 
> After return ppn_table[offset], L2P entry will be correct L2P entry:
> 
> 0x1234567890123456. then use put_unaligned_be64(), UFS can receive
> expected L2P etnry(L2P entry hit).
> 
> 
> we need to figure out which way is the JEDEC recommended L2P entry
> output endianness. otherwise, two methods co-exist in HPB driver, there
> will confuse customer.
> If you have a look at the JEDEC HPB 2.0, seems the big-endian is
> correct way. This need you and Daejun to double check inside your
> company.
> 

Bean is right, finally you know what I was saying...

We need to fix it before move on - all the UFS3.1 HPB parts which I 
tested
over the last few weeks are screwed due to this... I don't care 
where/how
you want to get it fixed in next version.

In my case, which may not be a valid fix, I simply hack the code as 
below
and it works for me.

-      put_unaligned_be64(ppn, &cdb[6]);
+      memcpy(&cdb[6], &ppn, sizeof(u64));

Thanks,
Can Guo.

> thanks,
> Bean

Re: [PATCH v19 3/3] scsi: ufs: Prepare HPB read for cached sub-region

[Bean Huo]

On Fri, 2021-02-05 at 11:29 +0800, Can Guo wrote:
> > +     return ppn_table[offset];
> > +}
> > +
> > +static void
> > +ufshpb_get_pos_from_lpn(struct ufshpb_lu *hpb, unsigned long lpn,
> > int 
> > *rgn_idx,
> > +                     int *srgn_idx, int *offset)
> > +{
> > +     int rgn_offset;
> > +
> > +     *rgn_idx = lpn >> hpb->entries_per_rgn_shift;
> > +     rgn_offset = lpn & hpb->entries_per_rgn_mask;
> > +     *srgn_idx = rgn_offset >> hpb->entries_per_srgn_shift;
> > +     *offset = rgn_offset & hpb->entries_per_srgn_mask;
> > +}
> > +
> > +static void
> > +ufshpb_set_hpb_read_to_upiu(struct ufshpb_lu *hpb, struct
> > ufshcd_lrb 
> > *lrbp,
> > +                               u32 lpn, u64 ppn,  unsigned int
> > transfer_len)
> > +{
> > +     unsigned char *cdb = lrbp->cmd->cmnd;
> > +
> > +     cdb[0] = UFSHPB_READ;
> > +
> > +     put_unaligned_be64(ppn, &cdb[6]);
> 
> You are assuming the HPB entries read out by "HPB Read Buffer" cmd
> are 
> in Little
> Endian, which is why you are using put_unaligned_be64 here. 
> 


Actaully, here uses put_unaligned_be64 is no problem. SCSI command
should be big-endian filled. I Think the problem is that geting ppn
from HPB cache in ufshpb_get_ppn().

...
e0000001f: 12 34 56 78 90 fa de ef
...

+
+static u64 ufshpb_get_ppn(struct ufshpb_lu *hpb,
+			  struct ufshpb_map_ctx *mctx, int pos, int
*error)
+{
+	u64 *ppn_table;  // It s a 64 bits pointer
+	struct page *page;
+	int index, offset;
+
+	index = pos / (PAGE_SIZE / HPB_ENTRY_SIZE);
+	offset = pos % (PAGE_SIZE / HPB_ENTRY_SIZE);
+
+	page = mctx->m_page[index];
+	if (unlikely(!page)) {
+		*error = -ENOMEM;
+		dev_err(&hpb->sdev_ufs_lu->sdev_dev,
+			"error. cannot find page in mctx\n");
+		return 0;
+	}
+
+	ppn_table = page_address(page);
+	if (unlikely(!ppn_table)) {
+		*error = -ENOMEM;
+		dev_err(&hpb->sdev_ufs_lu->sdev_dev,
+			"error. cannot get ppn_table\n");
+		return 0;
+	}
+
+	return ppn_table[offset];
+}




> this assumption
> is not right for all the other flash vendors - HPB entries read out
> by 
> "HPB Read Buffer"
> cmd may come in Big Endian, if so, their random read performance are 
> screwed.
> Actually, I have seen at least two flash vendors acting so. I had to 
> modify this line
> to get the code work properly on my setups.
> 
> Meanwhile, in your cover letter, you mentioned that the performance
> data 
> is collected
> on a UFS2.1 device. Please re-collect the data on a real UFS3.1
> device 
> and let me
> know the part number. Otherwise, the data is not quite convincing to
> us.
> 
> Regards,
> Can Guo.

Re: [PATCH v19 3/3] scsi: ufs: Prepare HPB read for cached sub-region

[Can Guo]

On 2021-02-08 16:16, Bean Huo wrote:
> On Fri, 2021-02-05 at 11:29 +0800, Can Guo wrote:
>> > +     return ppn_table[offset];
>> > +}
>> > +
>> > +static void
>> > +ufshpb_get_pos_from_lpn(struct ufshpb_lu *hpb, unsigned long lpn,
>> > int
>> > *rgn_idx,
>> > +                     int *srgn_idx, int *offset)
>> > +{
>> > +     int rgn_offset;
>> > +
>> > +     *rgn_idx = lpn >> hpb->entries_per_rgn_shift;
>> > +     rgn_offset = lpn & hpb->entries_per_rgn_mask;
>> > +     *srgn_idx = rgn_offset >> hpb->entries_per_srgn_shift;
>> > +     *offset = rgn_offset & hpb->entries_per_srgn_mask;
>> > +}
>> > +
>> > +static void
>> > +ufshpb_set_hpb_read_to_upiu(struct ufshpb_lu *hpb, struct
>> > ufshcd_lrb
>> > *lrbp,
>> > +                               u32 lpn, u64 ppn,  unsigned int
>> > transfer_len)
>> > +{
>> > +     unsigned char *cdb = lrbp->cmd->cmnd;
>> > +
>> > +     cdb[0] = UFSHPB_READ;
>> > +
>> > +     put_unaligned_be64(ppn, &cdb[6]);
>> 
>> You are assuming the HPB entries read out by "HPB Read Buffer" cmd
>> are
>> in Little
>> Endian, which is why you are using put_unaligned_be64 here.
>> 
> 
> 
> Actaully, here uses put_unaligned_be64 is no problem. SCSI command
> should be big-endian filled. I Think the problem is that geting ppn
> from HPB cache in ufshpb_get_ppn().
> 

whatever...

> ...
> e0000001f: 12 34 56 78 90 fa de ef
> ...
> 
> +
> +static u64 ufshpb_get_ppn(struct ufshpb_lu *hpb,
> +			  struct ufshpb_map_ctx *mctx, int pos, int
> *error)
> +{
> +	u64 *ppn_table;  // It s a 64 bits pointer
> +	struct page *page;
> +	int index, offset;
> +
> +	index = pos / (PAGE_SIZE / HPB_ENTRY_SIZE);
> +	offset = pos % (PAGE_SIZE / HPB_ENTRY_SIZE);
> +
> +	page = mctx->m_page[index];
> +	if (unlikely(!page)) {
> +		*error = -ENOMEM;
> +		dev_err(&hpb->sdev_ufs_lu->sdev_dev,
> +			"error. cannot find page in mctx\n");
> +		return 0;
> +	}
> +
> +	ppn_table = page_address(page);
> +	if (unlikely(!ppn_table)) {
> +		*error = -ENOMEM;
> +		dev_err(&hpb->sdev_ufs_lu->sdev_dev,
> +			"error. cannot get ppn_table\n");
> +		return 0;
> +	}
> +
> +	return ppn_table[offset];
> +}
> 
> 
> 
> 
>> this assumption
>> is not right for all the other flash vendors - HPB entries read out
>> by
>> "HPB Read Buffer"
>> cmd may come in Big Endian, if so, their random read performance are
>> screwed.
>> Actually, I have seen at least two flash vendors acting so. I had to
>> modify this line
>> to get the code work properly on my setups.
>> 
>> Meanwhile, in your cover letter, you mentioned that the performance
>> data
>> is collected
>> on a UFS2.1 device. Please re-collect the data on a real UFS3.1
>> device
>> and let me
>> know the part number. Otherwise, the data is not quite convincing to
>> us.
>> 
>> Regards,
>> Can Guo.

RE: [PATCH v19 3/3] scsi: ufs: Prepare HPB read for cached sub-region

[Avri Altman]

> +static bool ufshpb_test_ppn_dirty(struct ufshpb_lu *hpb, int rgn_idx,
> +                                  int srgn_idx, int srgn_offset, int cnt)
> +{
> +       struct ufshpb_region *rgn;
> +       struct ufshpb_subregion *srgn;
> +       int bitmap_len = hpb->entries_per_srgn;
> +       int bit_len;
> +
> +next_srgn:
> +       rgn = hpb->rgn_tbl + rgn_idx;
> +       srgn = rgn->srgn_tbl + srgn_idx;
> +
> +       if (!ufshpb_is_valid_srgn(rgn, srgn))
> +               return true;
The subregion is changing its state to issued, only in ufshpb_issue_map_req.
Although you already know that those physical addresses are no longer valid in ufshpb_update_active_info.
Can we mark that this subregion is no longer valid earlier, so not to keep sending faulty HPB-READ to that subregion?

Thanks,
Avri

RE: Re: [PATCH v19 2/3] scsi: ufs: L2P map management for HPB read

[Daejun Park]

> @@ -342,13 +1208,14 @@ void ufshpb_suspend(struct ufs_hba *hba)
> >  	struct scsi_device *sdev;
> > 
> >  	shost_for_each_device(sdev, hba->host) {
> > -		hpb = sdev->hostdata;
> > +		hpb = ufshpb_get_hpb_data(sdev);
> >  		if (!hpb)
> >  			continue;
> > 
> >  		if (ufshpb_get_state(hpb) != HPB_PRESENT)
> >  			continue;
> >  		ufshpb_set_state(hpb, HPB_SUSPEND);
> > +		ufshpb_cancel_jobs(hpb);
> 
> Here may have a dead lock problem - in the case of runtime suspend,
> when ufshpb_suspend() is invoked, all of hba's children scsi devices
> are in RPM_SUSPENDED state. When this line tries to cancel a running
> map work, i.e. when ufshpb_get_map_req() calls below lines, it will
> be stuck at blk_queue_enter().
> 
> req = blk_get_request(hpb->sdev_ufs_lu->request_queue,
> 		      REQ_OP_SCSI_IN, 0);
> 
> Please check block layer power management, and see also commit d55d15a33
> ("scsi: block: Do not accept any requests while suspended").

I am agree with your comment.
How about add BLK_MQ_REQ_NOWAIT flag on blk_get_request() to avoid hang?

Thanks,
Daejun

Re: [PATCH v19 2/3] scsi: ufs: L2P map management for HPB read

[Can Guo]

On 2021-02-08 16:03, Daejun Park wrote:
>> @@ -342,13 +1208,14 @@ void ufshpb_suspend(struct ufs_hba *hba)
>> >  	struct scsi_device *sdev;
>> >
>> >  	shost_for_each_device(sdev, hba->host) {
>> > -		hpb = sdev->hostdata;
>> > +		hpb = ufshpb_get_hpb_data(sdev);
>> >  		if (!hpb)
>> >  			continue;
>> >
>> >  		if (ufshpb_get_state(hpb) != HPB_PRESENT)
>> >  			continue;
>> >  		ufshpb_set_state(hpb, HPB_SUSPEND);
>> > +		ufshpb_cancel_jobs(hpb);
>> 
>> Here may have a dead lock problem - in the case of runtime suspend,
>> when ufshpb_suspend() is invoked, all of hba's children scsi devices
>> are in RPM_SUSPENDED state. When this line tries to cancel a running
>> map work, i.e. when ufshpb_get_map_req() calls below lines, it will
>> be stuck at blk_queue_enter().
>> 
>> req = blk_get_request(hpb->sdev_ufs_lu->request_queue,
>> 		      REQ_OP_SCSI_IN, 0);
>> 
>> Please check block layer power management, and see also commit 
>> d55d15a33
>> ("scsi: block: Do not accept any requests while suspended").
> 
> I am agree with your comment.
> How about add BLK_MQ_REQ_NOWAIT flag on blk_get_request() to avoid 
> hang?
> 

That won't work - BLK_MQ_REQ_NOWAIT allows one to fast fail from 
blk_mq_get_tag(),
but blk_queue_enter() comes before __blk_mq_alloc_request();

Regards,

Can Guo.

> Thanks,
> Daejun

[PATCH v19 1/3] scsi: ufs: Introduce HPB feature

[Daejun Park]

This is a patch for the HPB initialization and adds HPB function calls to
UFS core driver.

NAND flash-based storage devices, including UFS, have mechanisms to
translate logical addresses of IO requests to the corresponding physical
addresses of the flash storage.
In UFS, Logical-address-to-Physical-address (L2P) map data, which is
required to identify the physical address for the requested IOs, can only
be partially stored in SRAM from NAND flash. Due to this partial loading,
accessing the flash address area where the L2P information for that address
is not loaded in the SRAM can result in serious performance degradation.

The basic concept of HPB is to cache L2P mapping entries in host system
memory so that both physical block address (PBA) and logical block address
(LBA) can be delivered in HPB read command.
The HPB READ command allows to read data faster than a read command in UFS
since it provides the physical address (HPB Entry) of the desired logical
block in addition to its logical address. The UFS device can access the
physical block in NAND directly without searching and uploading L2P mapping
table. This improves read performance because the NAND read operation for
uploading L2P mapping table is removed.

In HPB initialization, the host checks if the UFS device supports HPB
feature and retrieves related device capabilities. Then, some HPB
parameters are configured in the device.

We measured the total start-up time of popular applications and observed
the difference by enabling the HPB.
Popular applications are 12 game apps and 24 non-game apps. Each target
applications were launched in order. The cycle consists of running 36
applications in sequence. We repeated the cycle for observing performance
improvement by L2P mapping cache hit in HPB.

The Following is experiment environment:
 - kernel version: 4.4.0
 - RAM: 8GB
 - UFS 2.1 (64GB)

Result:
+-------+----------+----------+-------+
| cycle | baseline | with HPB | diff  |
+-------+----------+----------+-------+
| 1     | 272.4    | 264.9    | -7.5  |
| 2     | 250.4    | 248.2    | -2.2  |
| 3     | 226.2    | 215.6    | -10.6 |
| 4     | 230.6    | 214.8    | -15.8 |
| 5     | 232.0    | 218.1    | -13.9 |
| 6     | 231.9    | 212.6    | -19.3 |
+-------+----------+----------+-------+

We also measured HPB performance using iozone.
Here is my iozone script:
iozone -r 4k -+n -i2 -ecI -t 16 -l 16 -u 16
-s $IO_RANGE/16 -F mnt/tmp_1 mnt/tmp_2 mnt/tmp_3 mnt/tmp_4 mnt/tmp_5
mnt/tmp_6 mnt/tmp_7 mnt/tmp_8 mnt/tmp_9 mnt/tmp_10 mnt/tmp_11 mnt/tmp_12
mnt/tmp_13 mnt/tmp_14 mnt/tmp_15 mnt/tmp_16

Result:
+----------+--------+---------+
| IO range | HPB on | HPB off |
+----------+--------+---------+
|   1 GB   | 294.8  | 300.87  |
|   4 GB   | 293.51 | 179.35  |
|   8 GB   | 294.85 | 162.52  |
|  16 GB   | 293.45 | 156.26  |
|  32 GB   | 277.4  | 153.25  |
+----------+--------+---------+

Reviewed-by: Bart Van Assche <bvanassche@acm.org>
Reviewed-by: Can Guo <cang@codeaurora.org>
Acked-by: Avri Altman <Avri.Altman@wdc.com>
Tested-by: Bean Huo <beanhuo@micron.com>
Reported-by: kernel test robot <lkp@intel.com>
Signed-off-by: Daejun Park <daejun7.park@samsung.com>
---
 Documentation/ABI/testing/sysfs-driver-ufs |  71 +++
 drivers/scsi/ufs/Kconfig                   |   9 +
 drivers/scsi/ufs/Makefile                  |   1 +
 drivers/scsi/ufs/ufs-sysfs.c               |  18 +
 drivers/scsi/ufs/ufs.h                     |  15 +
 drivers/scsi/ufs/ufshcd.c                  |  49 ++
 drivers/scsi/ufs/ufshcd.h                  |  22 +
 drivers/scsi/ufs/ufshpb.c                  | 561 +++++++++++++++++++++
 drivers/scsi/ufs/ufshpb.h                  | 164 ++++++
 9 files changed, 910 insertions(+)
 create mode 100644 drivers/scsi/ufs/ufshpb.c
 create mode 100644 drivers/scsi/ufs/ufshpb.h

diff --git a/Documentation/ABI/testing/sysfs-driver-ufs b/Documentation/ABI/testing/sysfs-driver-ufs
index 375a10f159b1..f0b3a188af4c 100644
--- a/Documentation/ABI/testing/sysfs-driver-ufs
+++ b/Documentation/ABI/testing/sysfs-driver-ufs
@@ -1164,3 +1164,74 @@ Description:	This node is used to set or display whether UFS WriteBooster is
 		(if the platform supports UFSHCD_CAP_CLK_SCALING). For a
 		platform that doesn't support UFSHCD_CAP_CLK_SCALING, we can
 		disable/enable WriteBooster through this sysfs node.
+
+What:		/sys/bus/platform/drivers/ufshcd/*/device_descriptor/hpb_version
+Date:		January 2021
+Contact:	Daejun Park <daejun7.park@samsung.com>
+Description:	This entry shows the HPB specification version.
+		The full information about the descriptor could be found at UFS
+		HPB (Host Performance Booster) Extension specifications.
+		Example: version 1.2.3 = 0123h
+		The file is read only.
+
+What:		/sys/bus/platform/drivers/ufshcd/*/device_descriptor/hpb_control
+Date:		January 2021
+Contact:	Daejun Park <daejun7.park@samsung.com>
+Description:	This entry shows an indication of the HPB control mode.
+		00h: Host control mode
+		01h: Device control mode
+		The file is read only.
+
+What:		/sys/bus/platform/drivers/ufshcd/*/geometry_descriptor/hpb_region_size
+Date:		January 2021
+Contact:	Daejun Park <daejun7.park@samsung.com>
+Description:	This entry shows the bHPBRegionSize which can be calculated
+		as in the following (in bytes):
+		HPB Region size = 512B * 2^bHPBRegionSize
+		The file is read only.
+
+What:		/sys/bus/platform/drivers/ufshcd/*/geometry_descriptor/hpb_number_lu
+Date:		January 2021
+Contact:	Daejun Park <daejun7.park@samsung.com>
+Description:	This entry shows the maximum number of HPB LU supported	by
+		the device.
+		00h: HPB is not supported by the device.
+		01h ~ 20h: Maximum number of HPB LU supported by the device
+		The file is read only.
+
+What:		/sys/bus/platform/drivers/ufshcd/*/geometry_descriptor/hpb_subregion_size
+Date:		January 2021
+Contact:	Daejun Park <daejun7.park@samsung.com>
+Description:	This entry shows the bHPBSubRegionSize, which can be
+		calculated as in the following (in bytes) and shall be a multiple of
+		logical block size:
+		HPB Sub-Region size = 512B x 2^bHPBSubRegionSize
+		bHPBSubRegionSize shall not exceed bHPBRegionSize.
+		The file is read only.
+
+What:		/sys/bus/platform/drivers/ufshcd/*/geometry_descriptor/hpb_max_active_regions
+Date:		January 2021
+Contact:	Daejun Park <daejun7.park@samsung.com>
+Description:	This entry shows the maximum number of active HPB regions that
+		is supported by the device.
+		The file is read only.
+
+What:		/sys/class/scsi_device/*/device/unit_descriptor/hpb_lu_max_active_regions
+Date:		January 2021
+Contact:	Daejun Park <daejun7.park@samsung.com>
+Description:	This entry shows the maximum number of HPB regions assigned to
+		the HPB logical unit.
+		The file is read only.
+
+What:		/sys/class/scsi_device/*/device/unit_descriptor/hpb_pinned_region_start_offset
+Date:		January 2021
+Contact:	Daejun Park <daejun7.park@samsung.com>
+Description:	This entry shows the start offset of HPB pinned region.
+		The file is read only.
+
+What:		/sys/class/scsi_device/*/device/unit_descriptor/hpb_number_pinned_regions
+Date:		January 2021
+Contact:	Daejun Park <daejun7.park@samsung.com>
+Description:	This entry shows the Number of HPB pinned regions assigned to
+		the HPB logical unit.
+		The file is read only.
diff --git a/drivers/scsi/ufs/Kconfig b/drivers/scsi/ufs/Kconfig
index d0d7ead99eaa..72c0bcb5caa9 100644
--- a/drivers/scsi/ufs/Kconfig
+++ b/drivers/scsi/ufs/Kconfig
@@ -181,3 +181,12 @@ config SCSI_UFS_CRYPTO
 	  Enabling this makes it possible for the kernel to use the crypto
 	  capabilities of the UFS device (if present) to perform crypto
 	  operations on data being transferred to/from the device.
+
+config SCSI_UFS_HPB
+	bool "Support UFS Host Performance Booster"
+	depends on SCSI_UFSHCD
+	help
+	  The UFS HPB feature improves random read performance. It caches
+	  L2P (logical to physical) map of UFS to host DRAM. The driver uses HPB
+	  read command by piggybacking physical page number for bypassing FTL (flash
+	  translation layer)'s L2P address translation.
diff --git a/drivers/scsi/ufs/Makefile b/drivers/scsi/ufs/Makefile
index 06f3a3fe4a44..cce9b3916f5b 100644
--- a/drivers/scsi/ufs/Makefile
+++ b/drivers/scsi/ufs/Makefile
@@ -8,6 +8,7 @@ ufshcd-core-y				+= ufshcd.o ufs-sysfs.o
 ufshcd-core-$(CONFIG_DEBUG_FS)		+= ufs-debugfs.o
 ufshcd-core-$(CONFIG_SCSI_UFS_BSG)	+= ufs_bsg.o
 ufshcd-core-$(CONFIG_SCSI_UFS_CRYPTO)	+= ufshcd-crypto.o
+ufshcd-core-$(CONFIG_SCSI_UFS_HPB)	+= ufshpb.o
 
 obj-$(CONFIG_SCSI_UFS_DWC_TC_PCI) += tc-dwc-g210-pci.o ufshcd-dwc.o tc-dwc-g210.o
 obj-$(CONFIG_SCSI_UFS_DWC_TC_PLATFORM) += tc-dwc-g210-pltfrm.o ufshcd-dwc.o tc-dwc-g210.o
diff --git a/drivers/scsi/ufs/ufs-sysfs.c b/drivers/scsi/ufs/ufs-sysfs.c
index acc54f530f2d..2546e7a1ac4f 100644
--- a/drivers/scsi/ufs/ufs-sysfs.c
+++ b/drivers/scsi/ufs/ufs-sysfs.c
@@ -368,6 +368,8 @@ UFS_DEVICE_DESC_PARAM(device_version, _DEV_VER, 2);
 UFS_DEVICE_DESC_PARAM(number_of_secure_wpa, _NUM_SEC_WPA, 1);
 UFS_DEVICE_DESC_PARAM(psa_max_data_size, _PSA_MAX_DATA, 4);
 UFS_DEVICE_DESC_PARAM(psa_state_timeout, _PSA_TMT, 1);
+UFS_DEVICE_DESC_PARAM(hpb_version, _HPB_VER, 2);
+UFS_DEVICE_DESC_PARAM(hpb_control, _HPB_CONTROL, 1);
 UFS_DEVICE_DESC_PARAM(ext_feature_sup, _EXT_UFS_FEATURE_SUP, 4);
 UFS_DEVICE_DESC_PARAM(wb_presv_us_en, _WB_PRESRV_USRSPC_EN, 1);
 UFS_DEVICE_DESC_PARAM(wb_type, _WB_TYPE, 1);
@@ -400,6 +402,8 @@ static struct attribute *ufs_sysfs_device_descriptor[] = {
 	&dev_attr_number_of_secure_wpa.attr,
 	&dev_attr_psa_max_data_size.attr,
 	&dev_attr_psa_state_timeout.attr,
+	&dev_attr_hpb_version.attr,
+	&dev_attr_hpb_control.attr,
 	&dev_attr_ext_feature_sup.attr,
 	&dev_attr_wb_presv_us_en.attr,
 	&dev_attr_wb_type.attr,
@@ -473,6 +477,10 @@ UFS_GEOMETRY_DESC_PARAM(enh4_memory_max_alloc_units,
 	_ENM4_MAX_NUM_UNITS, 4);
 UFS_GEOMETRY_DESC_PARAM(enh4_memory_capacity_adjustment_factor,
 	_ENM4_CAP_ADJ_FCTR, 2);
+UFS_GEOMETRY_DESC_PARAM(hpb_region_size, _HPB_REGION_SIZE, 1);
+UFS_GEOMETRY_DESC_PARAM(hpb_number_lu, _HPB_NUMBER_LU, 1);
+UFS_GEOMETRY_DESC_PARAM(hpb_subregion_size, _HPB_SUBREGION_SIZE, 1);
+UFS_GEOMETRY_DESC_PARAM(hpb_max_active_regions, _HPB_MAX_ACTIVE_REGS, 2);
 UFS_GEOMETRY_DESC_PARAM(wb_max_alloc_units, _WB_MAX_ALLOC_UNITS, 4);
 UFS_GEOMETRY_DESC_PARAM(wb_max_wb_luns, _WB_MAX_WB_LUNS, 1);
 UFS_GEOMETRY_DESC_PARAM(wb_buff_cap_adj, _WB_BUFF_CAP_ADJ, 1);
@@ -510,6 +518,10 @@ static struct attribute *ufs_sysfs_geometry_descriptor[] = {
 	&dev_attr_enh3_memory_capacity_adjustment_factor.attr,
 	&dev_attr_enh4_memory_max_alloc_units.attr,
 	&dev_attr_enh4_memory_capacity_adjustment_factor.attr,
+	&dev_attr_hpb_region_size.attr,
+	&dev_attr_hpb_number_lu.attr,
+	&dev_attr_hpb_subregion_size.attr,
+	&dev_attr_hpb_max_active_regions.attr,
 	&dev_attr_wb_max_alloc_units.attr,
 	&dev_attr_wb_max_wb_luns.attr,
 	&dev_attr_wb_buff_cap_adj.attr,
@@ -923,6 +935,9 @@ UFS_UNIT_DESC_PARAM(provisioning_type, _PROVISIONING_TYPE, 1);
 UFS_UNIT_DESC_PARAM(physical_memory_resourse_count, _PHY_MEM_RSRC_CNT, 8);
 UFS_UNIT_DESC_PARAM(context_capabilities, _CTX_CAPABILITIES, 2);
 UFS_UNIT_DESC_PARAM(large_unit_granularity, _LARGE_UNIT_SIZE_M1, 1);
+UFS_UNIT_DESC_PARAM(hpb_lu_max_active_regions, _HPB_LU_MAX_ACTIVE_RGNS, 2);
+UFS_UNIT_DESC_PARAM(hpb_pinned_region_start_offset, _HPB_PIN_RGN_START_OFF, 2);
+UFS_UNIT_DESC_PARAM(hpb_number_pinned_regions, _HPB_NUM_PIN_RGNS, 2);
 UFS_UNIT_DESC_PARAM(wb_buf_alloc_units, _WB_BUF_ALLOC_UNITS, 4);
 
 
@@ -940,6 +955,9 @@ static struct attribute *ufs_sysfs_unit_descriptor[] = {
 	&dev_attr_physical_memory_resourse_count.attr,
 	&dev_attr_context_capabilities.attr,
 	&dev_attr_large_unit_granularity.attr,
+	&dev_attr_hpb_lu_max_active_regions.attr,
+	&dev_attr_hpb_pinned_region_start_offset.attr,
+	&dev_attr_hpb_number_pinned_regions.attr,
 	&dev_attr_wb_buf_alloc_units.attr,
 	NULL,
 };
diff --git a/drivers/scsi/ufs/ufs.h b/drivers/scsi/ufs/ufs.h
index bf1897a72532..65563635e20e 100644
--- a/drivers/scsi/ufs/ufs.h
+++ b/drivers/scsi/ufs/ufs.h
@@ -122,6 +122,7 @@ enum flag_idn {
 	QUERY_FLAG_IDN_WB_EN                            = 0x0E,
 	QUERY_FLAG_IDN_WB_BUFF_FLUSH_EN                 = 0x0F,
 	QUERY_FLAG_IDN_WB_BUFF_FLUSH_DURING_HIBERN8     = 0x10,
+	QUERY_FLAG_IDN_HPB_RESET                        = 0x11,
 };
 
 /* Attribute idn for Query requests */
@@ -195,6 +196,9 @@ enum unit_desc_param {
 	UNIT_DESC_PARAM_PHY_MEM_RSRC_CNT	= 0x18,
 	UNIT_DESC_PARAM_CTX_CAPABILITIES	= 0x20,
 	UNIT_DESC_PARAM_LARGE_UNIT_SIZE_M1	= 0x22,
+	UNIT_DESC_PARAM_HPB_LU_MAX_ACTIVE_RGNS	= 0x23,
+	UNIT_DESC_PARAM_HPB_PIN_RGN_START_OFF	= 0x25,
+	UNIT_DESC_PARAM_HPB_NUM_PIN_RGNS	= 0x27,
 	UNIT_DESC_PARAM_WB_BUF_ALLOC_UNITS	= 0x29,
 };
 
@@ -235,6 +239,8 @@ enum device_desc_param {
 	DEVICE_DESC_PARAM_PSA_MAX_DATA		= 0x25,
 	DEVICE_DESC_PARAM_PSA_TMT		= 0x29,
 	DEVICE_DESC_PARAM_PRDCT_REV		= 0x2A,
+	DEVICE_DESC_PARAM_HPB_VER		= 0x40,
+	DEVICE_DESC_PARAM_HPB_CONTROL		= 0x42,
 	DEVICE_DESC_PARAM_EXT_UFS_FEATURE_SUP	= 0x4F,
 	DEVICE_DESC_PARAM_WB_PRESRV_USRSPC_EN	= 0x53,
 	DEVICE_DESC_PARAM_WB_TYPE		= 0x54,
@@ -283,6 +289,10 @@ enum geometry_desc_param {
 	GEOMETRY_DESC_PARAM_ENM4_MAX_NUM_UNITS	= 0x3E,
 	GEOMETRY_DESC_PARAM_ENM4_CAP_ADJ_FCTR	= 0x42,
 	GEOMETRY_DESC_PARAM_OPT_LOG_BLK_SIZE	= 0x44,
+	GEOMETRY_DESC_PARAM_HPB_REGION_SIZE	= 0x48,
+	GEOMETRY_DESC_PARAM_HPB_NUMBER_LU	= 0x49,
+	GEOMETRY_DESC_PARAM_HPB_SUBREGION_SIZE	= 0x4A,
+	GEOMETRY_DESC_PARAM_HPB_MAX_ACTIVE_REGS	= 0x4B,
 	GEOMETRY_DESC_PARAM_WB_MAX_ALLOC_UNITS	= 0x4F,
 	GEOMETRY_DESC_PARAM_WB_MAX_WB_LUNS	= 0x53,
 	GEOMETRY_DESC_PARAM_WB_BUFF_CAP_ADJ	= 0x54,
@@ -327,8 +337,10 @@ enum {
 
 /* Possible values for dExtendedUFSFeaturesSupport */
 enum {
+	UFS_DEV_HPB_SUPPORT		= BIT(7),
 	UFS_DEV_WRITE_BOOSTER_SUP	= BIT(8),
 };
+#define UFS_DEV_HPB_SUPPORT_VERSION		0x310
 
 #define POWER_DESC_MAX_ACTV_ICC_LVLS		16
 
@@ -538,6 +550,9 @@ struct ufs_dev_info {
 	u16	wspecversion;
 	u32	clk_gating_wait_us;
 
+	/* UFS HPB related flag */
+	bool	hpb_enabled;
+
 	/* UFS WB related flags */
 	bool    wb_enabled;
 	bool    wb_buf_flush_enabled;
diff --git a/drivers/scsi/ufs/ufshcd.c b/drivers/scsi/ufs/ufshcd.c
index 9c691e4ab490..b8d6a52f5603 100644
--- a/drivers/scsi/ufs/ufshcd.c
+++ b/drivers/scsi/ufs/ufshcd.c
@@ -23,6 +23,7 @@
 #include "ufs-debugfs.h"
 #include "ufs_bsg.h"
 #include "ufshcd-crypto.h"
+#include "ufshpb.h"
 #include <asm/unaligned.h>
 #include <linux/blkdev.h>
 
@@ -4854,6 +4855,25 @@ static int ufshcd_change_queue_depth(struct scsi_device *sdev, int depth)
 	return scsi_change_queue_depth(sdev, depth);
 }
 
+static void ufshcd_hpb_destroy(struct ufs_hba *hba, struct scsi_device *sdev)
+{
+	/* skip well-known LU */
+	if ((sdev->lun >= UFS_UPIU_MAX_UNIT_NUM_ID) || !ufshpb_is_allowed(hba))
+		return;
+
+	ufshpb_destroy_lu(hba, sdev);
+}
+
+static void ufshcd_hpb_configure(struct ufs_hba *hba, struct scsi_device *sdev)
+{
+	/* skip well-known LU */
+	if ((sdev->lun >= UFS_UPIU_MAX_UNIT_NUM_ID) ||
+	    !(hba->dev_info.hpb_enabled) || !ufshpb_is_allowed(hba))
+		return;
+
+	ufshpb_init_hpb_lu(hba, sdev);
+}
+
 /**
  * ufshcd_slave_configure - adjust SCSI device configurations
  * @sdev: pointer to SCSI device
@@ -4863,6 +4883,8 @@ static int ufshcd_slave_configure(struct scsi_device *sdev)
 	struct ufs_hba *hba = shost_priv(sdev->host);
 	struct request_queue *q = sdev->request_queue;
 
+	ufshcd_hpb_configure(hba, sdev);
+
 	blk_queue_update_dma_pad(q, PRDT_DATA_BYTE_COUNT_PAD - 1);
 	if (hba->quirks & UFSHCD_QUIRK_ALIGN_SG_WITH_PAGE_SIZE)
 		blk_queue_update_dma_alignment(q, PAGE_SIZE - 1);
@@ -4884,6 +4906,9 @@ static void ufshcd_slave_destroy(struct scsi_device *sdev)
 	struct ufs_hba *hba;
 
 	hba = shost_priv(sdev->host);
+
+	ufshcd_hpb_destroy(hba, sdev);
+
 	/* Drop the reference as it won't be needed anymore */
 	if (ufshcd_scsi_to_upiu_lun(sdev->lun) == UFS_UPIU_UFS_DEVICE_WLUN) {
 		unsigned long flags;
@@ -6986,6 +7011,8 @@ static int ufshcd_host_reset_and_restore(struct ufs_hba *hba)
 	 * Stop the host controller and complete the requests
 	 * cleared by h/w
 	 */
+	ufshpb_reset_host(hba);
+
 	ufshcd_hba_stop(hba);
 
 	spin_lock_irqsave(hba->host->host_lock, flags);
@@ -7391,6 +7418,7 @@ static int ufs_get_device_desc(struct ufs_hba *hba)
 {
 	int err;
 	u8 model_index;
+	u8 b_ufs_feature_sup;
 	u8 *desc_buf;
 	struct ufs_dev_info *dev_info = &hba->dev_info;
 
@@ -7418,9 +7446,16 @@ static int ufs_get_device_desc(struct ufs_hba *hba)
 	/* getting Specification Version in big endian format */
 	dev_info->wspecversion = desc_buf[DEVICE_DESC_PARAM_SPEC_VER] << 8 |
 				      desc_buf[DEVICE_DESC_PARAM_SPEC_VER + 1];
+	b_ufs_feature_sup = desc_buf[DEVICE_DESC_PARAM_UFS_FEAT];
 
 	model_index = desc_buf[DEVICE_DESC_PARAM_PRDCT_NAME];
 
+	if (dev_info->wspecversion >= UFS_DEV_HPB_SUPPORT_VERSION &&
+	    (b_ufs_feature_sup & UFS_DEV_HPB_SUPPORT)) {
+		dev_info->hpb_enabled = true;
+		ufshpb_get_dev_info(hba, desc_buf);
+	}
+
 	err = ufshcd_read_string_desc(hba, model_index,
 				      &dev_info->model, SD_ASCII_STD);
 	if (err < 0) {
@@ -7649,6 +7684,10 @@ static int ufshcd_device_geo_params_init(struct ufs_hba *hba)
 	else if (desc_buf[GEOMETRY_DESC_PARAM_MAX_NUM_LUN] == 0)
 		hba->dev_info.max_lu_supported = 8;
 
+	if (hba->desc_size[QUERY_DESC_IDN_GEOMETRY] >=
+		GEOMETRY_DESC_PARAM_HPB_MAX_ACTIVE_REGS)
+		ufshpb_get_geo_info(hba, desc_buf);
+
 out:
 	kfree(desc_buf);
 	return err;
@@ -7789,6 +7828,7 @@ static int ufshcd_add_lus(struct ufs_hba *hba)
 	}
 
 	ufs_bsg_probe(hba);
+	ufshpb_init(hba);
 	scsi_scan_host(hba->host);
 	pm_runtime_put_sync(hba->dev);
 
@@ -7932,6 +7972,7 @@ static int ufshcd_probe_hba(struct ufs_hba *hba, bool async)
 	/* Enable Auto-Hibernate if configured */
 	ufshcd_auto_hibern8_enable(hba);
 
+	ufshpb_reset(hba);
 out:
 	spin_lock_irqsave(hba->host->host_lock, flags);
 	if (ret)
@@ -7981,6 +8022,9 @@ static void ufshcd_async_scan(void *data, async_cookie_t cookie)
 static const struct attribute_group *ufshcd_driver_groups[] = {
 	&ufs_sysfs_unit_descriptor_group,
 	&ufs_sysfs_lun_attributes_group,
+#ifdef CONFIG_SCSI_UFS_HPB
+	&ufs_sysfs_hpb_stat_group,
+#endif
 	NULL,
 };
 
@@ -8697,6 +8741,8 @@ static int ufshcd_suspend(struct ufs_hba *hba, enum ufs_pm_op pm_op)
 		req_link_state = UIC_LINK_OFF_STATE;
 	}
 
+	ufshpb_suspend(hba);
+
 	/*
 	 * If we can't transition into any of the low power modes
 	 * just gate the clocks.
@@ -8831,6 +8877,7 @@ static int ufshcd_suspend(struct ufs_hba *hba, enum ufs_pm_op pm_op)
 	hba->clk_gating.is_suspended = false;
 	hba->dev_info.b_rpm_dev_flush_capable = false;
 	ufshcd_release(hba);
+	ufshpb_resume(hba);
 out:
 	if (hba->dev_info.b_rpm_dev_flush_capable) {
 		schedule_delayed_work(&hba->rpm_dev_flush_recheck_work,
@@ -8935,6 +8982,8 @@ static int ufshcd_resume(struct ufs_hba *hba, enum ufs_pm_op pm_op)
 	/* Enable Auto-Hibernate if configured */
 	ufshcd_auto_hibern8_enable(hba);
 
+	ufshpb_resume(hba);
+
 	if (hba->dev_info.b_rpm_dev_flush_capable) {
 		hba->dev_info.b_rpm_dev_flush_capable = false;
 		cancel_delayed_work(&hba->rpm_dev_flush_recheck_work);
diff --git a/drivers/scsi/ufs/ufshcd.h b/drivers/scsi/ufs/ufshcd.h
index ee61f821f75d..961fc5b77943 100644
--- a/drivers/scsi/ufs/ufshcd.h
+++ b/drivers/scsi/ufs/ufshcd.h
@@ -645,6 +645,25 @@ struct ufs_hba_variant_params {
 	u32 wb_flush_threshold;
 };
 
+#ifdef CONFIG_SCSI_UFS_HPB
+/**
+ * struct ufshpb_dev_info - UFSHPB device related info
+ * @num_lu: the number of user logical unit to check whether all lu finished
+ *          initialization
+ * @rgn_size: device reported HPB region size
+ * @srgn_size: device reported HPB sub-region size
+ * @slave_conf_cnt: counter to check all lu finished initialization
+ * @hpb_disabled: flag to check if HPB is disabled
+ */
+struct ufshpb_dev_info {
+	int num_lu;
+	int rgn_size;
+	int srgn_size;
+	atomic_t slave_conf_cnt;
+	bool hpb_disabled;
+};
+#endif
+
 /**
  * struct ufs_hba - per adapter private structure
  * @mmio_base: UFSHCI base register address
@@ -832,6 +851,9 @@ struct ufs_hba {
 	struct request_queue	*bsg_queue;
 	struct delayed_work rpm_dev_flush_recheck_work;
 
+#ifdef CONFIG_SCSI_UFS_HPB
+	struct ufshpb_dev_info ufshpb_dev;
+#endif
 #ifdef CONFIG_SCSI_UFS_CRYPTO
 	union ufs_crypto_capabilities crypto_capabilities;
 	union ufs_crypto_cap_entry *crypto_cap_array;
diff --git a/drivers/scsi/ufs/ufshpb.c b/drivers/scsi/ufs/ufshpb.c
new file mode 100644
index 000000000000..1f84141ed384
--- /dev/null
+++ b/drivers/scsi/ufs/ufshpb.c
@@ -0,0 +1,561 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Universal Flash Storage Host Performance Booster
+ *
+ * Copyright (C) 2017-2020 Samsung Electronics Co., Ltd.
+ *
+ * Authors:
+ *	Yongmyung Lee <ymhungry.lee@samsung.com>
+ *	Jinyoung Choi <j-young.choi@samsung.com>
+ */
+
+#include <asm/unaligned.h>
+#include <linux/async.h>
+
+#include "ufshcd.h"
+#include "ufshpb.h"
+#include "../sd.h"
+
+bool ufshpb_is_allowed(struct ufs_hba *hba)
+{
+	return !(hba->ufshpb_dev.hpb_disabled);
+}
+
+static struct ufshpb_lu *ufshpb_get_hpb_data(struct scsi_device *sdev)
+{
+	return sdev->hostdata;
+}
+
+static int ufshpb_get_state(struct ufshpb_lu *hpb)
+{
+	return atomic_read(&hpb->hpb_state);
+}
+
+static void ufshpb_set_state(struct ufshpb_lu *hpb, int state)
+{
+	atomic_set(&hpb->hpb_state, state);
+}
+
+static void ufshpb_init_subregion_tbl(struct ufshpb_lu *hpb,
+				      struct ufshpb_region *rgn)
+{
+	int srgn_idx;
+
+	for (srgn_idx = 0; srgn_idx < rgn->srgn_cnt; srgn_idx++) {
+		struct ufshpb_subregion *srgn = rgn->srgn_tbl + srgn_idx;
+
+		srgn->rgn_idx = rgn->rgn_idx;
+		srgn->srgn_idx = srgn_idx;
+		srgn->srgn_state = HPB_SRGN_UNUSED;
+	}
+}
+
+static int ufshpb_alloc_subregion_tbl(struct ufshpb_lu *hpb,
+					     struct ufshpb_region *rgn,
+					     int srgn_cnt)
+{
+	rgn->srgn_tbl = kvcalloc(srgn_cnt, sizeof(struct ufshpb_subregion),
+				 GFP_KERNEL);
+	if (!rgn->srgn_tbl)
+		return -ENOMEM;
+
+	rgn->srgn_cnt = srgn_cnt;
+	return 0;
+}
+
+static void ufshpb_lu_parameter_init(struct ufs_hba *hba,
+				     struct ufshpb_lu *hpb,
+				     struct ufshpb_dev_info *hpb_dev_info,
+				     struct ufshpb_lu_info *hpb_lu_info)
+{
+	u32 entries_per_rgn;
+	u64 rgn_mem_size, tmp;
+
+	hpb->lu_pinned_start = hpb_lu_info->pinned_start;
+	hpb->lu_pinned_end = hpb_lu_info->num_pinned ?
+		(hpb_lu_info->pinned_start + hpb_lu_info->num_pinned - 1)
+		: PINNED_NOT_SET;
+
+	rgn_mem_size = (1ULL << hpb_dev_info->rgn_size) * HPB_RGN_SIZE_UNIT
+			* HPB_ENTRY_SIZE;
+	do_div(rgn_mem_size, HPB_ENTRY_BLOCK_SIZE);
+	hpb->srgn_mem_size = (1ULL << hpb_dev_info->srgn_size)
+		* HPB_RGN_SIZE_UNIT / HPB_ENTRY_BLOCK_SIZE * HPB_ENTRY_SIZE;
+
+	tmp = rgn_mem_size;
+	do_div(tmp, HPB_ENTRY_SIZE);
+	entries_per_rgn = (u32)tmp;
+	hpb->entries_per_rgn_shift = ilog2(entries_per_rgn);
+	hpb->entries_per_rgn_mask = entries_per_rgn - 1;
+
+	hpb->entries_per_srgn = hpb->srgn_mem_size / HPB_ENTRY_SIZE;
+	hpb->entries_per_srgn_shift = ilog2(hpb->entries_per_srgn);
+	hpb->entries_per_srgn_mask = hpb->entries_per_srgn - 1;
+
+	tmp = rgn_mem_size;
+	do_div(tmp, hpb->srgn_mem_size);
+	hpb->srgns_per_rgn = (int)tmp;
+
+	hpb->rgns_per_lu = DIV_ROUND_UP(hpb_lu_info->num_blocks,
+				entries_per_rgn);
+	hpb->srgns_per_lu = DIV_ROUND_UP(hpb_lu_info->num_blocks,
+				(hpb->srgn_mem_size / HPB_ENTRY_SIZE));
+
+	hpb->pages_per_srgn = DIV_ROUND_UP(hpb->srgn_mem_size, PAGE_SIZE);
+}
+
+static int ufshpb_alloc_region_tbl(struct ufs_hba *hba, struct ufshpb_lu *hpb)
+{
+	struct ufshpb_region *rgn_table, *rgn;
+	int rgn_idx, i;
+	int ret = 0;
+
+	rgn_table = kvcalloc(hpb->rgns_per_lu, sizeof(struct ufshpb_region),
+			    GFP_KERNEL);
+	if (!rgn_table)
+		return -ENOMEM;
+
+	hpb->rgn_tbl = rgn_table;
+
+	for (rgn_idx = 0; rgn_idx < hpb->rgns_per_lu; rgn_idx++) {
+		int srgn_cnt = hpb->srgns_per_rgn;
+
+		rgn = rgn_table + rgn_idx;
+		rgn->rgn_idx = rgn_idx;
+
+		if (rgn_idx == hpb->rgns_per_lu - 1)
+			srgn_cnt = ((hpb->srgns_per_lu - 1) %
+				    hpb->srgns_per_rgn) + 1;
+
+		ret = ufshpb_alloc_subregion_tbl(hpb, rgn, srgn_cnt);
+		if (ret)
+			goto release_srgn_table;
+		ufshpb_init_subregion_tbl(hpb, rgn);
+
+		rgn->rgn_state = HPB_RGN_INACTIVE;
+	}
+
+	return 0;
+
+release_srgn_table:
+	for (i = 0; i < rgn_idx; i++) {
+		rgn = rgn_table + i;
+		if (rgn->srgn_tbl)
+			kvfree(rgn->srgn_tbl);
+	}
+	kvfree(rgn_table);
+	return ret;
+}
+
+static void ufshpb_destroy_subregion_tbl(struct ufshpb_lu *hpb,
+					 struct ufshpb_region *rgn)
+{
+	int srgn_idx;
+
+	for (srgn_idx = 0; srgn_idx < rgn->srgn_cnt; srgn_idx++) {
+		struct ufshpb_subregion *srgn;
+
+		srgn = rgn->srgn_tbl + srgn_idx;
+		srgn->srgn_state = HPB_SRGN_UNUSED;
+	}
+}
+
+static void ufshpb_destroy_region_tbl(struct ufshpb_lu *hpb)
+{
+	int rgn_idx;
+
+	for (rgn_idx = 0; rgn_idx < hpb->rgns_per_lu; rgn_idx++) {
+		struct ufshpb_region *rgn;
+
+		rgn = hpb->rgn_tbl + rgn_idx;
+		if (rgn->rgn_state != HPB_RGN_INACTIVE) {
+			rgn->rgn_state = HPB_RGN_INACTIVE;
+
+			ufshpb_destroy_subregion_tbl(hpb, rgn);
+		}
+
+		kvfree(rgn->srgn_tbl);
+	}
+
+	kvfree(hpb->rgn_tbl);
+}
+
+/* SYSFS functions */
+#define ufshpb_sysfs_attr_show_func(__name)				\
+static ssize_t __name##_show(struct device *dev,			\
+	struct device_attribute *attr, char *buf)			\
+{									\
+	struct scsi_device *sdev = to_scsi_device(dev);			\
+	struct ufshpb_lu *hpb = ufshpb_get_hpb_data(sdev);		\
+	if (!hpb)							\
+		return -ENODEV;						\
+									\
+	return sysfs_emit(buf, "%llu\n", hpb->stats.__name);		\
+}									\
+\
+static DEVICE_ATTR_RO(__name)
+
+ufshpb_sysfs_attr_show_func(hit_cnt);
+ufshpb_sysfs_attr_show_func(miss_cnt);
+ufshpb_sysfs_attr_show_func(rb_noti_cnt);
+ufshpb_sysfs_attr_show_func(rb_active_cnt);
+ufshpb_sysfs_attr_show_func(rb_inactive_cnt);
+ufshpb_sysfs_attr_show_func(map_req_cnt);
+
+static struct attribute *hpb_dev_attrs[] = {
+	&dev_attr_hit_cnt.attr,
+	&dev_attr_miss_cnt.attr,
+	&dev_attr_rb_noti_cnt.attr,
+	&dev_attr_rb_active_cnt.attr,
+	&dev_attr_rb_inactive_cnt.attr,
+	&dev_attr_map_req_cnt.attr,
+	NULL,
+};
+
+struct attribute_group ufs_sysfs_hpb_stat_group = {
+	.name = "hpb_sysfs",
+	.attrs = hpb_dev_attrs,
+};
+
+static void ufshpb_stat_init(struct ufshpb_lu *hpb)
+{
+	hpb->stats.hit_cnt = 0;
+	hpb->stats.miss_cnt = 0;
+	hpb->stats.rb_noti_cnt = 0;
+	hpb->stats.rb_active_cnt = 0;
+	hpb->stats.rb_inactive_cnt = 0;
+	hpb->stats.map_req_cnt = 0;
+}
+
+static int ufshpb_lu_hpb_init(struct ufs_hba *hba, struct ufshpb_lu *hpb)
+{
+	int ret;
+
+	ret = ufshpb_alloc_region_tbl(hba, hpb);
+
+	ufshpb_stat_init(hpb);
+
+	return 0;
+}
+
+static struct ufshpb_lu *ufshpb_alloc_hpb_lu(struct ufs_hba *hba, int lun,
+				     struct ufshpb_dev_info *hpb_dev_info,
+				     struct ufshpb_lu_info *hpb_lu_info)
+{
+	struct ufshpb_lu *hpb;
+	int ret;
+
+	hpb = kzalloc(sizeof(struct ufshpb_lu), GFP_KERNEL);
+	if (!hpb)
+		return NULL;
+
+	hpb->lun = lun;
+
+	ufshpb_lu_parameter_init(hba, hpb, hpb_dev_info, hpb_lu_info);
+
+	ret = ufshpb_lu_hpb_init(hba, hpb);
+	if (ret) {
+		dev_err(hba->dev, "hpb lu init failed. ret %d", ret);
+		goto release_hpb;
+	}
+
+	return hpb;
+
+release_hpb:
+	kfree(hpb);
+	return NULL;
+}
+
+static bool ufshpb_check_hpb_reset_query(struct ufs_hba *hba)
+{
+	int err = 0;
+	bool flag_res = true;
+	int try;
+
+	/* wait for the device to complete HPB reset query */
+	for (try = 0; try < HPB_RESET_REQ_RETRIES; try++) {
+		dev_dbg(hba->dev,
+			"%s start flag reset polling %d times\n",
+			__func__, try);
+
+		/* Poll fHpbReset flag to be cleared */
+		err = ufshcd_query_flag(hba, UPIU_QUERY_OPCODE_READ_FLAG,
+				QUERY_FLAG_IDN_HPB_RESET, 0, &flag_res);
+
+		if (err) {
+			dev_err(hba->dev,
+				"%s reading fHpbReset flag failed with error %d\n",
+				__func__, err);
+			return flag_res;
+		}
+
+		if (!flag_res)
+			goto out;
+
+		usleep_range(1000, 1100);
+	}
+	if (flag_res) {
+		dev_err(hba->dev,
+			"%s fHpbReset was not cleared by the device\n",
+			__func__);
+	}
+out:
+	return flag_res;
+}
+
+void ufshpb_reset(struct ufs_hba *hba)
+{
+	struct ufshpb_lu *hpb;
+	struct scsi_device *sdev;
+
+	shost_for_each_device(sdev, hba->host) {
+		hpb = sdev->hostdata;
+		if (!hpb)
+			continue;
+
+		if (ufshpb_get_state(hpb) != HPB_RESET)
+			continue;
+
+		ufshpb_set_state(hpb, HPB_PRESENT);
+	}
+}
+
+void ufshpb_reset_host(struct ufs_hba *hba)
+{
+	struct ufshpb_lu *hpb;
+	struct scsi_device *sdev;
+
+	shost_for_each_device(sdev, hba->host) {
+		hpb = sdev->hostdata;
+		if (!hpb)
+			continue;
+
+		if (ufshpb_get_state(hpb) != HPB_PRESENT)
+			continue;
+		ufshpb_set_state(hpb, HPB_RESET);
+	}
+}
+
+void ufshpb_suspend(struct ufs_hba *hba)
+{
+	struct ufshpb_lu *hpb;
+	struct scsi_device *sdev;
+
+	shost_for_each_device(sdev, hba->host) {
+		hpb = sdev->hostdata;
+		if (!hpb)
+			continue;
+
+		if (ufshpb_get_state(hpb) != HPB_PRESENT)
+			continue;
+		ufshpb_set_state(hpb, HPB_SUSPEND);
+	}
+}
+
+void ufshpb_resume(struct ufs_hba *hba)
+{
+	struct ufshpb_lu *hpb;
+	struct scsi_device *sdev;
+
+	shost_for_each_device(sdev, hba->host) {
+		hpb = sdev->hostdata;
+		if (!hpb)
+			continue;
+
+		if ((ufshpb_get_state(hpb) != HPB_PRESENT) &&
+		    (ufshpb_get_state(hpb) != HPB_SUSPEND))
+			continue;
+		ufshpb_set_state(hpb, HPB_PRESENT);
+	}
+}
+
+static int ufshpb_get_lu_info(struct ufs_hba *hba, int lun,
+				    struct ufshpb_lu_info *hpb_lu_info)
+{
+	u16 max_active_rgns;
+	u8 lu_enable;
+	int size;
+	int ret;
+	char desc_buf[QUERY_DESC_MAX_SIZE];
+
+	ufshcd_map_desc_id_to_length(hba, QUERY_DESC_IDN_UNIT, &size);
+
+	pm_runtime_get_sync(hba->dev);
+	ret = ufshcd_query_descriptor_retry(hba, UPIU_QUERY_OPCODE_READ_DESC,
+					    QUERY_DESC_IDN_UNIT, lun, 0,
+					    desc_buf, &size);
+	pm_runtime_put_sync(hba->dev);
+
+	if (ret) {
+		dev_err(hba->dev,
+			"%s: idn: %d lun: %d  query request failed",
+			__func__, QUERY_DESC_IDN_UNIT, lun);
+		return ret;
+	}
+
+	lu_enable = desc_buf[UNIT_DESC_PARAM_LU_ENABLE];
+	if (lu_enable != LU_ENABLED_HPB_FUNC)
+		return -ENODEV;
+
+	max_active_rgns = get_unaligned_be16(
+			desc_buf + UNIT_DESC_PARAM_HPB_LU_MAX_ACTIVE_RGNS);
+	if (!max_active_rgns) {
+		dev_err(hba->dev,
+			"lun %d wrong number of max active regions\n", lun);
+		return -ENODEV;
+	}
+
+	hpb_lu_info->num_blocks = get_unaligned_be64(
+			desc_buf + UNIT_DESC_PARAM_LOGICAL_BLK_COUNT);
+	hpb_lu_info->pinned_start = get_unaligned_be16(
+			desc_buf + UNIT_DESC_PARAM_HPB_PIN_RGN_START_OFF);
+	hpb_lu_info->num_pinned = get_unaligned_be16(
+			desc_buf + UNIT_DESC_PARAM_HPB_NUM_PIN_RGNS);
+	hpb_lu_info->max_active_rgns = max_active_rgns;
+
+	return 0;
+}
+
+void ufshpb_destroy_lu(struct ufs_hba *hba, struct scsi_device *sdev)
+{
+	struct ufshpb_lu *hpb = sdev->hostdata;
+
+	if (!hpb)
+		return;
+
+	ufshpb_set_state(hpb, HPB_FAILED);
+
+	sdev = hpb->sdev_ufs_lu;
+	sdev->hostdata = NULL;
+
+	ufshpb_destroy_region_tbl(hpb);
+
+	list_del_init(&hpb->list_hpb_lu);
+
+	kfree(hpb);
+}
+
+static void ufshpb_hpb_lu_prepared(struct ufs_hba *hba)
+{
+	struct ufshpb_lu *hpb;
+	struct scsi_device *sdev;
+	bool init_success;
+
+	init_success = !ufshpb_check_hpb_reset_query(hba);
+
+	shost_for_each_device(sdev, hba->host) {
+		hpb = sdev->hostdata;
+		if (!hpb)
+			continue;
+
+		if (init_success) {
+			ufshpb_set_state(hpb, HPB_PRESENT);
+		} else {
+			dev_err(hba->dev, "destroy HPB lu %d\n", hpb->lun);
+			ufshpb_destroy_lu(hba, sdev);
+		}
+	}
+}
+
+void ufshpb_init_hpb_lu(struct ufs_hba *hba, struct scsi_device *sdev)
+{
+	struct ufshpb_lu *hpb;
+	int ret;
+	struct ufshpb_lu_info hpb_lu_info = { 0 };
+	int lun = sdev->lun;
+
+	if (lun >= hba->dev_info.max_lu_supported)
+		goto out;
+
+	ret = ufshpb_get_lu_info(hba, lun, &hpb_lu_info);
+	if (ret)
+		goto out;
+
+	hpb = ufshpb_alloc_hpb_lu(hba, lun, &hba->ufshpb_dev,
+				  &hpb_lu_info);
+	if (!hpb)
+		goto out;
+
+	hpb->sdev_ufs_lu = sdev;
+	sdev->hostdata = hpb;
+
+out:
+	/* All LUs are initialized */
+	if (atomic_dec_and_test(&hba->ufshpb_dev.slave_conf_cnt))
+		ufshpb_hpb_lu_prepared(hba);
+}
+
+void ufshpb_get_geo_info(struct ufs_hba *hba, u8 *geo_buf)
+{
+	struct ufshpb_dev_info *hpb_dev_info = &hba->ufshpb_dev;
+	int hpb_device_max_active_rgns = 0;
+	int hpb_num_lu;
+
+	hpb_num_lu = geo_buf[GEOMETRY_DESC_PARAM_HPB_NUMBER_LU];
+	if (hpb_num_lu == 0) {
+		dev_err(hba->dev, "No HPB LU supported\n");
+		hpb_dev_info->hpb_disabled = true;
+		return;
+	}
+
+	hpb_dev_info->rgn_size = geo_buf[GEOMETRY_DESC_PARAM_HPB_REGION_SIZE];
+	hpb_dev_info->srgn_size = geo_buf[GEOMETRY_DESC_PARAM_HPB_SUBREGION_SIZE];
+	hpb_device_max_active_rgns =
+		get_unaligned_be16(geo_buf +
+			GEOMETRY_DESC_PARAM_HPB_MAX_ACTIVE_REGS);
+
+	if (hpb_dev_info->rgn_size == 0 || hpb_dev_info->srgn_size == 0 ||
+	    hpb_device_max_active_rgns == 0) {
+		dev_err(hba->dev, "No HPB supported device\n");
+		hpb_dev_info->hpb_disabled = true;
+		return;
+	}
+}
+
+void ufshpb_get_dev_info(struct ufs_hba *hba, u8 *desc_buf)
+{
+	struct ufshpb_dev_info *hpb_dev_info = &hba->ufshpb_dev;
+	int version;
+	u8 hpb_mode;
+
+	hpb_mode = desc_buf[DEVICE_DESC_PARAM_HPB_CONTROL];
+	if (hpb_mode == HPB_HOST_CONTROL) {
+		dev_err(hba->dev, "%s: host control mode is not supported.\n",
+			__func__);
+		hpb_dev_info->hpb_disabled = true;
+		return;
+	}
+
+	version = get_unaligned_be16(desc_buf + DEVICE_DESC_PARAM_HPB_VER);
+	if (version != HPB_SUPPORT_VERSION) {
+		dev_err(hba->dev, "%s: HPB %x version is not supported.\n",
+			__func__, version);
+		hpb_dev_info->hpb_disabled = true;
+		return;
+	}
+
+	/*
+	 * Get the number of user logical unit to check whether all
+	 * scsi_device finish initialization
+	 */
+	hpb_dev_info->num_lu = desc_buf[DEVICE_DESC_PARAM_NUM_LU];
+}
+
+void ufshpb_init(struct ufs_hba *hba)
+{
+	struct ufshpb_dev_info *hpb_dev_info = &hba->ufshpb_dev;
+	int try;
+	int ret;
+
+	if (!ufshpb_is_allowed(hba))
+		return;
+
+	atomic_set(&hpb_dev_info->slave_conf_cnt, hpb_dev_info->num_lu);
+	/* issue HPB reset query */
+	for (try = 0; try < HPB_RESET_REQ_RETRIES; try++) {
+		ret = ufshcd_query_flag(hba, UPIU_QUERY_OPCODE_SET_FLAG,
+					QUERY_FLAG_IDN_HPB_RESET, 0, NULL);
+		if (!ret)
+			break;
+	}
+}
diff --git a/drivers/scsi/ufs/ufshpb.h b/drivers/scsi/ufs/ufshpb.h
new file mode 100644
index 000000000000..50523821cac8
--- /dev/null
+++ b/drivers/scsi/ufs/ufshpb.h
@@ -0,0 +1,164 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/*
+ * Universal Flash Storage Host Performance Booster
+ *
+ * Copyright (C) 2017-2020 Samsung Electronics Co., Ltd.
+ *
+ * Authors:
+ *	Yongmyung Lee <ymhungry.lee@samsung.com>
+ *	Jinyoung Choi <j-young.choi@samsung.com>
+ */
+
+#ifndef _UFSHPB_H_
+#define _UFSHPB_H_
+
+/* hpb response UPIU macro */
+#define HPB_RSP_NONE				0x0
+#define HPB_RSP_REQ_REGION_UPDATE		0x1
+#define HPB_RSP_DEV_RESET			0x2
+#define MAX_ACTIVE_NUM				2
+#define MAX_INACTIVE_NUM			2
+#define DEV_DATA_SEG_LEN			0x14
+#define DEV_SENSE_SEG_LEN			0x12
+#define DEV_DES_TYPE				0x80
+#define DEV_ADDITIONAL_LEN			0x10
+
+/* hpb map & entries macro */
+#define HPB_RGN_SIZE_UNIT			512
+#define HPB_ENTRY_BLOCK_SIZE			4096
+#define HPB_ENTRY_SIZE				0x8
+#define PINNED_NOT_SET				U32_MAX
+
+/* hpb support chunk size */
+#define HPB_MULTI_CHUNK_HIGH			1
+
+/* hpb vender defined opcode */
+#define UFSHPB_READ				0xF8
+#define UFSHPB_READ_BUFFER			0xF9
+#define UFSHPB_READ_BUFFER_ID			0x01
+#define HPB_READ_BUFFER_CMD_LENGTH		10
+#define LU_ENABLED_HPB_FUNC			0x02
+
+#define HPB_RESET_REQ_RETRIES			10
+
+#define HPB_SUPPORT_VERSION			0x100
+
+enum UFSHPB_MODE {
+	HPB_HOST_CONTROL,
+	HPB_DEVICE_CONTROL,
+};
+
+enum UFSHPB_STATE {
+	HPB_PRESENT = 1,
+	HPB_SUSPEND,
+	HPB_FAILED,
+	HPB_RESET,
+};
+
+enum HPB_RGN_STATE {
+	HPB_RGN_INACTIVE,
+	HPB_RGN_ACTIVE,
+	/* pinned regions are always active */
+	HPB_RGN_PINNED,
+};
+
+enum HPB_SRGN_STATE {
+	HPB_SRGN_UNUSED,
+	HPB_SRGN_INVALID,
+	HPB_SRGN_VALID,
+	HPB_SRGN_ISSUED,
+};
+
+/**
+ * struct ufshpb_lu_info - UFSHPB logical unit related info
+ * @num_blocks: the number of logical block
+ * @pinned_start: the start region number of pinned region
+ * @num_pinned: the number of pinned regions
+ * @max_active_rgns: maximum number of active regions
+ */
+struct ufshpb_lu_info {
+	int num_blocks;
+	int pinned_start;
+	int num_pinned;
+	int max_active_rgns;
+};
+
+struct ufshpb_subregion {
+	enum HPB_SRGN_STATE srgn_state;
+	int rgn_idx;
+	int srgn_idx;
+};
+
+struct ufshpb_region {
+	struct ufshpb_subregion *srgn_tbl;
+	enum HPB_RGN_STATE rgn_state;
+	int rgn_idx;
+	int srgn_cnt;
+};
+
+struct ufshpb_stats {
+	u64 hit_cnt;
+	u64 miss_cnt;
+	u64 rb_noti_cnt;
+	u64 rb_active_cnt;
+	u64 rb_inactive_cnt;
+	u64 map_req_cnt;
+};
+
+struct ufshpb_lu {
+	int lun;
+	struct scsi_device *sdev_ufs_lu;
+	struct ufshpb_region *rgn_tbl;
+
+	atomic_t hpb_state;
+
+	/* pinned region information */
+	u32 lu_pinned_start;
+	u32 lu_pinned_end;
+
+	/* HPB related configuration */
+	u32 rgns_per_lu;
+	u32 srgns_per_lu;
+	int srgns_per_rgn;
+	u32 srgn_mem_size;
+	u32 entries_per_rgn_mask;
+	u32 entries_per_rgn_shift;
+	u32 entries_per_srgn;
+	u32 entries_per_srgn_mask;
+	u32 entries_per_srgn_shift;
+	u32 pages_per_srgn;
+
+	struct ufshpb_stats stats;
+
+	struct list_head list_hpb_lu;
+};
+
+struct ufs_hba;
+struct ufshcd_lrb;
+
+#ifndef CONFIG_SCSI_UFS_HPB
+static void ufshpb_resume(struct ufs_hba *hba) {}
+static void ufshpb_suspend(struct ufs_hba *hba) {}
+static void ufshpb_reset(struct ufs_hba *hba) {}
+static void ufshpb_reset_host(struct ufs_hba *hba) {}
+static void ufshpb_init(struct ufs_hba *hba) {}
+static void ufshpb_init_hpb_lu(struct ufs_hba *hba, struct scsi_device *sdev) {}
+static void ufshpb_destroy_lu(struct ufs_hba *hba, struct scsi_device *sdev) {}
+static bool ufshpb_is_allowed(struct ufs_hba *hba) { return false; }
+static void ufshpb_get_geo_info(struct ufs_hba *hba, u8 *geo_buf) {}
+static void ufshpb_get_dev_info(struct ufs_hba *hba, u8 *desc_buf) {}
+#else
+void ufshpb_resume(struct ufs_hba *hba);
+void ufshpb_suspend(struct ufs_hba *hba);
+void ufshpb_reset(struct ufs_hba *hba);
+void ufshpb_reset_host(struct ufs_hba *hba);
+void ufshpb_init(struct ufs_hba *hba);
+void ufshpb_init_hpb_lu(struct ufs_hba *hba, struct scsi_device *sdev);
+void ufshpb_destroy_lu(struct ufs_hba *hba, struct scsi_device *sdev);
+bool ufshpb_is_allowed(struct ufs_hba *hba);
+void ufshpb_get_geo_info(struct ufs_hba *hba, u8 *geo_buf);
+void ufshpb_get_dev_info(struct ufs_hba *hba, u8 *desc_buf);
+extern struct attribute_group ufs_sysfs_hpb_stat_group;
+#endif
+
+#endif /* End of Header */
-- 
2.25.1

RE: [PATCH v19 1/3] scsi: ufs: Introduce HPB feature

[Avri Altman]

Daejun,

>  static const struct attribute_group *ufshcd_driver_groups[] = {
>         &ufs_sysfs_unit_descriptor_group,
>         &ufs_sysfs_lun_attributes_group,
> +#ifdef CONFIG_SCSI_UFS_HPB
> +       &ufs_sysfs_hpb_stat_group,
> +#endif
>         NULL,
>  };
Aren’t you creating a hpb_stats entries for every lun (even wlun)?
This is confusing, even if safe (any non-hpb lun returns NODEV).
Also user-space have no way to know which entry is valid.

Can we group those under ufshpb_lu<lun id> for valid hpb luns only?
Also need to document the stats?  Maybe in a separate sysfs-driver-ufs-features?

Thanks,
Avri

Re: [PATCH v19 1/3] scsi: ufs: Introduce HPB feature

[Greg KH]

On Tue, Feb 02, 2021 at 07:46:47AM +0000, Avri Altman wrote:
> Daejun,
> 
> >  static const struct attribute_group *ufshcd_driver_groups[] = {
> >         &ufs_sysfs_unit_descriptor_group,
> >         &ufs_sysfs_lun_attributes_group,
> > +#ifdef CONFIG_SCSI_UFS_HPB
> > +       &ufs_sysfs_hpb_stat_group,
> > +#endif
> >         NULL,
> >  };
> Aren’t you creating a hpb_stats entries for every lun (even wlun)?
> This is confusing, even if safe (any non-hpb lun returns NODEV).
> Also user-space have no way to know which entry is valid.
> 
> Can we group those under ufshpb_lu<lun id> for valid hpb luns only?

How do you determine a valid lun?  If the kernel knows, then it should
just not create the files for any that is "invalid", which it can do by
setting the correct mode in the attribute group.

> Also need to document the stats?  Maybe in a separate sysfs-driver-ufs-features?

Aren't they all documented in the
Documentation/ABI/testing/sysfs-driver-ufs file in this patch?  What is
missing?

thanks,

greg k-h

RE: Re: [PATCH v19 2/3] scsi: ufs: L2P map management for HPB read

[Daejun Park]

>>> @@ -342,13 +1208,14 @@ void ufshpb_suspend(struct ufs_hba *hba)
>>> >          struct scsi_device *sdev;
>>> >
>>> >          shost_for_each_device(sdev, hba->host) {
>>> > -                hpb = sdev->hostdata;
>>> > +                hpb = ufshpb_get_hpb_data(sdev);
>>> >                  if (!hpb)
>>> >                          continue;
>>> >
>>> >                  if (ufshpb_get_state(hpb) != HPB_PRESENT)
>>> >                          continue;
>>> >                  ufshpb_set_state(hpb, HPB_SUSPEND);
>>> > +                ufshpb_cancel_jobs(hpb);
>>> 
>>> Here may have a dead lock problem - in the case of runtime suspend,
>>> when ufshpb_suspend() is invoked, all of hba's children scsi devices
>>> are in RPM_SUSPENDED state. When this line tries to cancel a running
>>> map work, i.e. when ufshpb_get_map_req() calls below lines, it will
>>> be stuck at blk_queue_enter().
>>> 
>>> req = blk_get_request(hpb->sdev_ufs_lu->request_queue,
>>>                       REQ_OP_SCSI_IN, 0);
>>> 
>>> Please check block layer power management, and see also commit 
>>> d55d15a33
>>> ("scsi: block: Do not accept any requests while suspended").
>> 
>> I am agree with your comment.
>> How about add BLK_MQ_REQ_NOWAIT flag on blk_get_request() to avoid 
>> hang?
>> 
> 
>That won't work - BLK_MQ_REQ_NOWAIT allows one to fast fail from 
>blk_mq_get_tag(),
>but blk_queue_enter() comes before __blk_mq_alloc_request();
> 
In blk_queue_enter(), BLK_MQ_REQ_NOWAIT flag can make error than wait rpm
resume. Please refer following code.

int blk_queue_enter(struct request_queue *q, blk_mq_req_flags_t flags)
{
	const bool pm = flags & BLK_MQ_REQ_PM;

	while (true) {
		bool success = false;

		rcu_read_lock();
		if (percpu_ref_tryget_live(&q->q_usage_counter)) {
			/*
			 * The code that increments the pm_only counter is
			 * responsible for ensuring that that counter is
			 * globally visible before the queue is unfrozen.
			 */
			if ((pm && queue_rpm_status(q) != RPM_SUSPENDED) ||
			    !blk_queue_pm_only(q)) {
				success = true;
			} else {
				percpu_ref_put(&q->q_usage_counter);
			}
		}
		rcu_read_unlock();

		if (success)
			return 0;

		if (flags & BLK_MQ_REQ_NOWAIT)
			return -EBUSY;	<-- out from the function.
			
Thanks,
Daejun

Re: [PATCH v19 2/3] scsi: ufs: L2P map management for HPB read

[Can Guo]

On 2021-02-08 16:53, Daejun Park wrote:
>>>> @@ -342,13 +1208,14 @@ void ufshpb_suspend(struct ufs_hba *hba)
>>>> >          struct scsi_device *sdev;
>>>> >
>>>> >          shost_for_each_device(sdev, hba->host) {
>>>> > -                hpb = sdev->hostdata;
>>>> > +                hpb = ufshpb_get_hpb_data(sdev);
>>>> >                  if (!hpb)
>>>> >                          continue;
>>>> >
>>>> >                  if (ufshpb_get_state(hpb) != HPB_PRESENT)
>>>> >                          continue;
>>>> >                  ufshpb_set_state(hpb, HPB_SUSPEND);
>>>> > +                ufshpb_cancel_jobs(hpb);
>>>> 
>>>> Here may have a dead lock problem - in the case of runtime suspend,
>>>> when ufshpb_suspend() is invoked, all of hba's children scsi devices
>>>> are in RPM_SUSPENDED state. When this line tries to cancel a running
>>>> map work, i.e. when ufshpb_get_map_req() calls below lines, it will
>>>> be stuck at blk_queue_enter().
>>>> 
>>>> req = blk_get_request(hpb->sdev_ufs_lu->request_queue,
>>>>                       REQ_OP_SCSI_IN, 0);
>>>> 
>>>> Please check block layer power management, and see also commit
>>>> d55d15a33
>>>> ("scsi: block: Do not accept any requests while suspended").
>>> 
>>> I am agree with your comment.
>>> How about add BLK_MQ_REQ_NOWAIT flag on blk_get_request() to avoid
>>> hang?
>>> 
>> 
>> That won't work - BLK_MQ_REQ_NOWAIT allows one to fast fail from
>> blk_mq_get_tag(),
>> but blk_queue_enter() comes before __blk_mq_alloc_request();
>> 
> In blk_queue_enter(), BLK_MQ_REQ_NOWAIT flag can make error than wait 
> rpm
> resume. Please refer following code.

Oops, sorry, my memory needs to be refreshed on that part.

But will BLK_MQ_REQ_NOWAIT flag breaks your original purpose? When
runtime suspend is out of the picture, if traffic is heavy on the
request queue, map_work() will be stopped frequently once it is
not able to get a request from the queue - that shall pull down the
efficiency of one map_work(), that may hurt random performance...

Can Guo.

> 
> int blk_queue_enter(struct request_queue *q, blk_mq_req_flags_t flags)
> {
> 	const bool pm = flags & BLK_MQ_REQ_PM;
> 
> 	while (true) {
> 		bool success = false;
> 
> 		rcu_read_lock();
> 		if (percpu_ref_tryget_live(&q->q_usage_counter)) {
> 			/*
> 			 * The code that increments the pm_only counter is
> 			 * responsible for ensuring that that counter is
> 			 * globally visible before the queue is unfrozen.
> 			 */
> 			if ((pm && queue_rpm_status(q) != RPM_SUSPENDED) ||
> 			    !blk_queue_pm_only(q)) {
> 				success = true;
> 			} else {
> 				percpu_ref_put(&q->q_usage_counter);
> 			}
> 		}
> 		rcu_read_unlock();
> 
> 		if (success)
> 			return 0;
> 
> 		if (flags & BLK_MQ_REQ_NOWAIT)
> 			return -EBUSY;	<-- out from the function.
> 
> Thanks,
> Daejun

RE: Re: [PATCH v19 2/3] scsi: ufs: L2P map management for HPB read

[Daejun Park]

>>>>> @@ -342,13 +1208,14 @@ void ufshpb_suspend(struct ufs_hba *hba)
>>>>> >          struct scsi_device *sdev;
>>>>> >
>>>>> >          shost_for_each_device(sdev, hba->host) {
>>>>> > -                hpb = sdev->hostdata;
>>>>> > +                hpb = ufshpb_get_hpb_data(sdev);
>>>>> >                  if (!hpb)
>>>>> >                          continue;
>>>>> >
>>>>> >                  if (ufshpb_get_state(hpb) != HPB_PRESENT)
>>>>> >                          continue;
>>>>> >                  ufshpb_set_state(hpb, HPB_SUSPEND);
>>>>> > +                ufshpb_cancel_jobs(hpb);
>>>>> 
>>>>> Here may have a dead lock problem - in the case of runtime suspend,
>>>>> when ufshpb_suspend() is invoked, all of hba's children scsi devices
>>>>> are in RPM_SUSPENDED state. When this line tries to cancel a running
>>>>> map work, i.e. when ufshpb_get_map_req() calls below lines, it will
>>>>> be stuck at blk_queue_enter().
>>>>> 
>>>>> req = blk_get_request(hpb->sdev_ufs_lu->request_queue,
>>>>>                       REQ_OP_SCSI_IN, 0);
>>>>> 
>>>>> Please check block layer power management, and see also commit
>>>>> d55d15a33
>>>>> ("scsi: block: Do not accept any requests while suspended").
>>>> 
>>>> I am agree with your comment.
>>>> How about add BLK_MQ_REQ_NOWAIT flag on blk_get_request() to avoid
>>>> hang?
>>>> 
>>> 
>>> That won't work - BLK_MQ_REQ_NOWAIT allows one to fast fail from
>>> blk_mq_get_tag(),
>>> but blk_queue_enter() comes before __blk_mq_alloc_request();
>>> 
>> In blk_queue_enter(), BLK_MQ_REQ_NOWAIT flag can make error than wait 
>> rpm
>> resume. Please refer following code.
> 
>Oops, sorry, my memory needs to be refreshed on that part.
> 
>But will BLK_MQ_REQ_NOWAIT flag breaks your original purpose? When
>runtime suspend is out of the picture, if traffic is heavy on the
>request queue, map_work() will be stopped frequently once it is
>not able to get a request from the queue - that shall pull down the
>efficiency of one map_work(), that may hurt random performance...

I think deadlock prevention is the most important. So I want to add
BLK_MQ_REQ_NOWAIT flag.
Starvation of map request can be distinguish by return value of
blk_get_request(). -EWOULDBLOCK means there is no available tags for this
request. -EBUSY means failed on blk_queue_enter(). To overcome starvation
of map request, we can try N times in heavy traffic situation (maybe N=3?).

Thanks,
Daejun

Re: [PATCH v19 2/3] scsi: ufs: L2P map management for HPB read

[Can Guo]

On 2021-02-09 09:27, Daejun Park wrote:
>>>>>> @@ -342,13 +1208,14 @@ void ufshpb_suspend(struct ufs_hba *hba)
>>>>>> >          struct scsi_device *sdev;
>>>>>> >
>>>>>> >          shost_for_each_device(sdev, hba->host) {
>>>>>> > -                hpb = sdev->hostdata;
>>>>>> > +                hpb = ufshpb_get_hpb_data(sdev);
>>>>>> >                  if (!hpb)
>>>>>> >                          continue;
>>>>>> >
>>>>>> >                  if (ufshpb_get_state(hpb) != HPB_PRESENT)
>>>>>> >                          continue;
>>>>>> >                  ufshpb_set_state(hpb, HPB_SUSPEND);
>>>>>> > +                ufshpb_cancel_jobs(hpb);
>>>>>> 
>>>>>> Here may have a dead lock problem - in the case of runtime 
>>>>>> suspend,
>>>>>> when ufshpb_suspend() is invoked, all of hba's children scsi 
>>>>>> devices
>>>>>> are in RPM_SUSPENDED state. When this line tries to cancel a 
>>>>>> running
>>>>>> map work, i.e. when ufshpb_get_map_req() calls below lines, it 
>>>>>> will
>>>>>> be stuck at blk_queue_enter().
>>>>>> 
>>>>>> req = blk_get_request(hpb->sdev_ufs_lu->request_queue,
>>>>>>                       REQ_OP_SCSI_IN, 0);
>>>>>> 
>>>>>> Please check block layer power management, and see also commit
>>>>>> d55d15a33
>>>>>> ("scsi: block: Do not accept any requests while suspended").
>>>>> 
>>>>> I am agree with your comment.
>>>>> How about add BLK_MQ_REQ_NOWAIT flag on blk_get_request() to avoid
>>>>> hang?
>>>>> 
>>>> 
>>>> That won't work - BLK_MQ_REQ_NOWAIT allows one to fast fail from
>>>> blk_mq_get_tag(),
>>>> but blk_queue_enter() comes before __blk_mq_alloc_request();
>>>> 
>>> In blk_queue_enter(), BLK_MQ_REQ_NOWAIT flag can make error than wait
>>> rpm
>>> resume. Please refer following code.
>> 
>> Oops, sorry, my memory needs to be refreshed on that part.
>> 
>> But will BLK_MQ_REQ_NOWAIT flag breaks your original purpose? When
>> runtime suspend is out of the picture, if traffic is heavy on the
>> request queue, map_work() will be stopped frequently once it is
>> not able to get a request from the queue - that shall pull down the
>> efficiency of one map_work(), that may hurt random performance...
> 
> I think deadlock prevention is the most important. So I want to add
> BLK_MQ_REQ_NOWAIT flag.
> Starvation of map request can be distinguish by return value of
> blk_get_request(). -EWOULDBLOCK means there is no available tags for 
> this
> request. -EBUSY means failed on blk_queue_enter(). To overcome 
> starvation
> of map request, we can try N times in heavy traffic situation (maybe 
> N=3?).
> 

LGTM. You make the call.

Regards,
Can Guo.

> Thanks,
> Daejun

RE: Re: [PATCH v19 2/3] scsi: ufs: L2P map management for HPB read

[Daejun Park]

> +
> > +static void ufshpb_kick_map_work(struct ufshpb_lu *hpb)
> > +{
> > +        bool ret = true;
>  
> -> ret = false;
>  
> > +        unsigned long flags;
> > +
> > +        spin_lock_irqsave(&hpb->rsp_list_lock, flags);
> > +        if (!list_empty(&hpb->lh_inact_rgn) || 
> > !list_empty(&hpb->lh_act_srgn))
> > +                ret = false;
>  
> -> ret = true;

Thanks, I will fix it.
  
> > +        spin_unlock_irqrestore(&hpb->rsp_list_lock, flags);
> > +
> > +        if (ret)
> > +                queue_work(ufshpb_wq, &hpb->map_work);
> > +}
> > +
> > +static bool ufshpb_is_hpb_rsp_valid(struct ufs_hba *hba,
> > +                                         struct ufshcd_lrb *lrbp,
> > +                                         struct utp_hpb_rsp *rsp_field)
> > +{
> > +        if (be16_to_cpu(rsp_field->sense_data_len) != DEV_SENSE_SEG_LEN ||
> > +            rsp_field->desc_type != DEV_DES_TYPE ||
> > +            rsp_field->additional_len != DEV_ADDITIONAL_LEN ||
> > +            rsp_field->hpb_op == HPB_RSP_NONE ||
>  
> HPB_RSP_NONE is checked again in switch-case, no need of this line.

OK, I agree.

> > +static void ufshpb_rsp_req_region_update(struct ufshpb_lu *hpb,
> > +                                         struct utp_hpb_rsp *rsp_field)
> > +{
> > +        int i, rgn_idx, srgn_idx;
> > +
> > +        BUILD_BUG_ON(sizeof(struct ufshpb_active_field) != 
> > HPB_ACT_FIELD_SIZE);
> > +        /*
> > +         * If the active region and the inactive region are the same,
> > +         * we will inactivate this region.
> > +         * The device could check this (region inactivated) and
> > +         * will response the proper active region information
> > +         */
> > +        spin_lock(&hpb->rsp_list_lock);
> > +        for (i = 0; i < rsp_field->active_rgn_cnt; i++) {
> > +                rgn_idx =
> > +                        be16_to_cpu(rsp_field->hpb_active_field[i].active_rgn);
> > +                srgn_idx =
> > +                        be16_to_cpu(rsp_field->hpb_active_field[i].active_srgn);
> > +
> > +                dev_dbg(&hpb->sdev_ufs_lu->sdev_dev,
> > +                        "activate(%d) region %d - %d\n", i, rgn_idx, srgn_idx);
> > +                ufshpb_update_active_info(hpb, rgn_idx, srgn_idx);
> > +                hpb->stats.rb_active_cnt++;
> > +        }
> > +
> > +        for (i = 0; i < rsp_field->inactive_rgn_cnt; i++) {
> > +                rgn_idx = be16_to_cpu(rsp_field->hpb_inactive_field[i]);
> > +                dev_dbg(&hpb->sdev_ufs_lu->sdev_dev,
> > +                        "inactivate(%d) region %d\n", i, rgn_idx);
> > +                ufshpb_update_inactive_info(hpb, rgn_idx);
> > +                hpb->stats.rb_inactive_cnt++;
> > +        }
> > +        spin_unlock(&hpb->rsp_list_lock);
> > +
> > +        dev_dbg(&hpb->sdev_ufs_lu->sdev_dev, "Noti: #ACT %u #INACT %u\n",
> > +                rsp_field->active_rgn_cnt, rsp_field->inactive_rgn_cnt);
> > +
> > +        queue_work(ufshpb_wq, &hpb->map_work);
> > +}
> > +
> > +/*
> > + * This function will parse recommended active subregion information 
> > in sense
> > + * data field of response UPIU with SAM_STAT_GOOD state.
> > + */
> > +void ufshpb_rsp_upiu(struct ufs_hba *hba, struct ufshcd_lrb *lrbp)
> > +{
> > +        struct ufshpb_lu *hpb = ufshpb_get_hpb_data(lrbp->cmd->device);
> > +        struct utp_hpb_rsp *rsp_field;
> > +        int data_seg_len;
> > +
> > +        if (!hpb)
> > +                return;
>  
> You are assuming HPB recommandations only come in responses to LUs
> with HPB enabled, but the specs says the recommandations can come
> in any responses with GOOD status, meaning you should check the *hpb
> which belongs to the LUN in res_field, but not the one belongs to
> lrbp->cmd->device.

I will add codes for checking lun to prevent getting wrong HPB
recommandations.

Thanks,
Daejun