Skip to contentSkip to conversation

scsi: ufs: Add Host Performance Booster Support

RFC PATCH Superseded Daejun Park 5 participants 30 messages Jun 15, 2020 – Jun 22, 2020 1 message not in the archive SCSI

v2 of 40 Superseded Latest is v40 →

lore
Share & tools
lore

A message that is not in the archive (sent off-list or not yet received): CGME20200615062708epcms2p19a7fbc051bcd5e843c29dcd58fff4210@epcms2p1

#1 lore raw

v2 cover scsi: ufs: Add Host Performance Booster Support

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 4 parts to support HPB feature.

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

The UFS-feature is an additional layer to avoid the structure in which the UFS-core driver and the UFS-feature are entangled with each other in a single module.
By adding the layer, UFS-features composed of various combinations can be supported. Also, even if a new feature is added, modification of the UFS-core driver can be minimized.

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 module.

The HPB module manages the L2P map using information received from the device. For active sub-region, the HPB module caches through ufshpb_map request. For the in-active region, the HPB module 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]

This series patches are based on the 5.8/scsi-queue branch.

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

Changelog:

v1 -> v2
1. Change sub-region context DS static allocation to dynamic allocation.
2. Change the full boilerplate text to SPDX style.
3. Other cleanups.

Daejun park (5):
scsi: ufs: Add UFS feature related parameter
scsi: ufs: Add UFS feature layer
scsi: ufs: Introduce HPB module
scsi: ufs: L2P map management for HPB read
scsi: ufs: Prepare HPB read for cached sub-region

 drivers/scsi/ufs/Kconfig      |    9 +
 drivers/scsi/ufs/Makefile     |    3 +-
 drivers/scsi/ufs/ufs.h        |   12 +
 drivers/scsi/ufs/ufsfeature.c |  148 +++
 drivers/scsi/ufs/ufsfeature.h |   69 ++
 drivers/scsi/ufs/ufshcd.c     |   19 +
 drivers/scsi/ufs/ufshcd.h     |    3 +
 drivers/scsi/ufs/ufshpb.c     | 1988 ++++++++++++++++++++++++++++++++++++
 drivers/scsi/ufs/ufshpb.h     |  234 +++++
 9 files changed, 2484 insertions(+), 1 deletion(-)

created mode 100644 drivers/scsi/ufs/ufsfeature.c created mode 100644 drivers/scsi/ufs/ufsfeature.h created mode 100644 drivers/scsi/ufs/ufshpb.c created mode 100644 drivers/scsi/ufs/ufshpb.h

#2 lore raw

RFC PATCH v2 1/5 scsi: ufs: Add UFS feature related parameter

This is a patch for parameters to be used for UFS features layer and HPB module.

---
 drivers/scsi/ufs/ufs.h | 12 ++++++++++++
 1 file changed, 12 insertions(+)
drivers/scsi/ufs/ufs.h +12 -0
index c70845d41449..f3efa3424fc0 100644
@@ -146,6 +146,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 */
@@ -229,6 +230,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_HPB_LU_MAX_ACTIVE_REGIONS	= 0x23,
+	UNIT_DESC_HPB_LU_PIN_REGION_START_OFFSET	= 0x25,
+	UNIT_DESC_HPB_LU_NUM_PIN_REGIONS	= 0x27,
 	UNIT_DESC_PARAM_WB_BUF_ALLOC_UNITS	= 0x29,
 };
 
@@ -269,6 +273,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,
@@ -317,6 +323,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_HPB_REGION_SIZE		= 0x48,
+	GEOMETRY_DESC_HPB_NUMBER_LU		= 0x49,
+	GEOMETRY_DESC_HPB_SUBREGION_SIZE	= 0x4A,
+	GEOMETRY_DESC_HPB_DEVICE_MAX_ACTIVE_REGIONS	= 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,
@@ -361,6 +371,7 @@ enum {
 
 /* Possible values for dExtendedUFSFeaturesSupport */
 enum {
+	UFS_DEV_HPB_SUPPORT		= BIT(7),
 	UFS_DEV_WRITE_BOOSTER_SUP	= BIT(8),
 };
 
@@ -571,6 +582,7 @@ struct ufs_dev_info {
 	u8 *model;
 	u16 wspecversion;
 	u32 clk_gating_wait_us;
+	u8 b_ufs_feature_sup;
 	u32 d_ext_ufs_feature_sup;
 	u8 b_wb_buffer_type;
 	u32 d_wb_alloc_units;
Signature · 1 line
2.17.1
#3 lore raw

RFC PATCH v2 2/5 scsi: ufs: Add UFS-feature layer

This patch is adding UFS feature layer to UFS core driver.

UFS Driver data structure (struct ufs_hba)

	│
┌--------------┐
│ UFS feature  │ <-- HPB module
│    layer     │ <-- other extended feature module
└--------------┘

Each extended UFS-Feature module has a bus of ufs-ext feature type. The UFS feature layer manages common APIs used by each extended feature module. The APIs are set of UFS Query requests and UFS Vendor commands related to each extended feature module.

Other extended features can also be implemented using the proposed APIs. For example, in Write Booster, "prep_fn" can be used to guarantee the lifetime of UFS by updating the amount of write IO.
And reset/reset_host/suspend/resume can be used to manage the kernel task for checking lifetime of UFS.

The following 6 callback functions have been added to "ufshcd.c".
prep_fn: called after construct upiu structure
reset: called after proving hba
reset_host: called before ufshcd_host_reset_and_restore
suspend: called before ufshcd_suspend
resume: called after ufshcd_resume
rsp_upiu: called in ufshcd_transfer_rsp_status with SAM_STAT_GOOD state

---
 drivers/scsi/ufs/Makefile     |   2 +-
 drivers/scsi/ufs/ufsfeature.c | 148 ++++++++++++++++++++++++++++++++++
 drivers/scsi/ufs/ufsfeature.h |  69 ++++++++++++++++
 drivers/scsi/ufs/ufshcd.c     |  17 ++++
 drivers/scsi/ufs/ufshcd.h     |   3 +
 5 files changed, 238 insertions(+), 1 deletion(-)
 create mode 100644 drivers/scsi/ufs/ufsfeature.c
 create mode 100644 drivers/scsi/ufs/ufsfeature.h
drivers/scsi/ufs/Makefile +1 -1
index 94c6c5d7334b..fe3a92b06c87 100644
@@ -5,7 +5,7 @@ obj-$(CONFIG_SCSI_UFS_DWC_TC_PLATFORM) += tc-dwc-g210-pltfrm.o ufshcd-dwc.o tc-d
 obj-$(CONFIG_SCSI_UFS_CDNS_PLATFORM) += cdns-pltfrm.o
 obj-$(CONFIG_SCSI_UFS_QCOM) += ufs-qcom.o
 obj-$(CONFIG_SCSI_UFSHCD) += ufshcd-core.o
-ufshcd-core-y				+= ufshcd.o ufs-sysfs.o
+ufshcd-core-y				+= ufshcd.o ufs-sysfs.o ufsfeature.o
 ufshcd-core-$(CONFIG_SCSI_UFS_BSG)	+= ufs_bsg.o
 obj-$(CONFIG_SCSI_UFSHCD_PCI) += ufshcd-pci.o
 obj-$(CONFIG_SCSI_UFSHCD_PLATFORM) += ufshcd-pltfrm.o
drivers/scsi/ufs/ufsfeature.c new file +148 -0

148 lines not on this page · raw message

drivers/scsi/ufs/ufsfeature.h new file +69 -0

69 lines not on this page · raw message

drivers/scsi/ufs/ufshcd.c +17 -0
index ad4fc829cbb2..74849c742c0f 100644
@@ -2525,6 +2525,8 @@ static int ufshcd_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *cmd)
 
 	ufshcd_comp_scsi_upiu(hba, lrbp);
 
+	ufsf_ops_prep_fn(hba, lrbp);
+
 	err = ufshcd_map_sg(hba, lrbp);
 	if (err) {
 		lrbp->cmd = NULL;
@@ -4645,6 +4647,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;
 
+	ufsf_slave_configure(hba, sdev);
+
 	blk_queue_update_dma_pad(q, PRDT_DATA_BYTE_COUNT_PAD - 1);
 
 	if (ufshcd_is_rpm_autosuspend_allowed(hba))
@@ -4765,6 +4769,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)
+				ufsf_ops_rsp_upiu(hba, lrbp);
 			break;
 		case UPIU_TRANSACTION_REJECT_UPIU:
 			/* TODO: handle Reject UPIU Response */
@@ -6508,6 +6515,8 @@ static int ufshcd_host_reset_and_restore(struct ufs_hba *hba)
 	 * Stop the host controller and complete the requests
 	 * cleared by h/w
 	 */
+	ufsf_ops_reset_host(hba);
+
 	ufshcd_hba_stop(hba);
 
 	spin_lock_irqsave(hba->host->host_lock, flags);
@@ -6934,6 +6943,7 @@ 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];
+	dev_info->b_ufs_feature_sup = desc_buf[DEVICE_DESC_PARAM_UFS_FEAT];
 
 	model_index = desc_buf[DEVICE_DESC_PARAM_PRDCT_NAME];
 
@@ -7350,6 +7360,7 @@ static int ufshcd_add_lus(struct ufs_hba *hba)
 	}
 
 	ufs_bsg_probe(hba);
+	ufsf_scan_features(hba);
 	scsi_scan_host(hba->host);
 	pm_runtime_put_sync(hba->dev);
 
@@ -7438,6 +7449,7 @@ static int ufshcd_probe_hba(struct ufs_hba *hba, bool async)
 	/* Enable Auto-Hibernate if configured */
 	ufshcd_auto_hibern8_enable(hba);
 
+	ufsf_ops_reset(hba);
 out:
 
 	trace_ufshcd_init(dev_name(hba->dev), ret,
@@ -8195,6 +8207,8 @@ static int ufshcd_suspend(struct ufs_hba *hba, enum ufs_pm_op pm_op)
 		req_link_state = UIC_LINK_OFF_STATE;
 	}
 
+	ufsf_ops_suspend(hba);
+
 	/*
 	 * If we can't transition into any of the low power modes
 	 * just gate the clocks.
@@ -8316,6 +8330,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);
+	ufsf_ops_resume(hba);
 out:
 	if (hba->dev_info.b_rpm_dev_flush_capable) {
 		schedule_delayed_work(&hba->rpm_dev_flush_recheck_work,
@@ -8412,6 +8427,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);
 
+	ufsf_ops_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);
drivers/scsi/ufs/ufshcd.h +3 -0
index bf97d616e597..47866ab722ff 100644
@@ -71,6 +71,7 @@
 #include "ufs.h"
 #include "ufs_quirks.h"
 #include "ufshci.h"
+#include "ufsfeature.h"
 
 #define UFSHCD "ufshcd"
 #define UFSHCD_DRIVER_VERSION "0.2"
@@ -746,6 +747,8 @@ struct ufs_hba {
 	bool wb_buf_flush_enabled;
 	bool wb_enabled;
 	struct delayed_work rpm_dev_flush_recheck_work;
+
+	struct ufsf_feature_info ufsf;
 };
 
 /* Returns true if clocks can be gated. Otherwise false */
Signature · 1 line
2.17.1
#4 lore raw

RFC PATCH v2 3/5 scsi: ufs: Introduce HPB module

This is a patch for the HPB module.
The HPB module queries UFS for device information during initialization. We added the export symbol to two functions in ufshcd.c to initialize the HPB module.

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

To gurantee a minimum memory pool size of 4MB:

$ insmod ufshpb.ko ufshpb_host_map_kbytes=4096
---
 drivers/scsi/ufs/Kconfig  |   9 +
 drivers/scsi/ufs/Makefile |   1 +
 drivers/scsi/ufs/ufshcd.c |   2 +
 drivers/scsi/ufs/ufshpb.c | 789 ++++++++++++++++++++++++++++++++++++++
 drivers/scsi/ufs/ufshpb.h | 162 ++++++++
 5 files changed, 963 insertions(+)
 create mode 100644 drivers/scsi/ufs/ufshpb.c
 create mode 100644 drivers/scsi/ufs/ufshpb.h
drivers/scsi/ufs/Kconfig +9 -0
index e2005aeddc2d..f7c79c369f1d 100644
@@ -160,3 +160,12 @@ config SCSI_UFS_BSG
 
 	  Select this if you need a bsg device node for your UFS controller.
 	  If unsure, say N.
+
+config UFSHPB
+	tristate "Support UFS Host Performance Booster"
+	depends on SCSI_UFSHCD
+	help
+	  A UFS HPB Feature improves random read performance. It caches
+	  L2P map of UFS to host DRAM. The driver uses HPB read command
+	  by piggybacking physical page number for bypassing FTL's L2P address
+	  translation.
drivers/scsi/ufs/Makefile +1 -0
index fe3a92b06c87..0baf28d674c6 100644
@@ -7,6 +7,7 @@ obj-$(CONFIG_SCSI_UFS_QCOM) += ufs-qcom.o
 obj-$(CONFIG_SCSI_UFSHCD) += ufshcd-core.o
 ufshcd-core-y				+= ufshcd.o ufs-sysfs.o ufsfeature.o
 ufshcd-core-$(CONFIG_SCSI_UFS_BSG)	+= ufs_bsg.o
+obj-$(CONFIG_UFSHPB) += ufshpb.o
 obj-$(CONFIG_SCSI_UFSHCD_PCI) += ufshcd-pci.o
 obj-$(CONFIG_SCSI_UFSHCD_PLATFORM) += ufshcd-pltfrm.o
 obj-$(CONFIG_SCSI_UFS_HISI) += ufs-hisi.o
drivers/scsi/ufs/ufshcd.c +2 -0
index 74849c742c0f..2f334a0b6bd6 100644
@@ -2855,6 +2855,7 @@ int ufshcd_query_flag(struct ufs_hba *hba, enum query_opcode opcode,
 	ufshcd_release(hba);
 	return err;
 }
+EXPORT_SYMBOL(ufshcd_query_flag);
 
 /**
  * ufshcd_query_attr - API function for sending attribute requests
@@ -3053,6 +3054,7 @@ int ufshcd_query_descriptor_retry(struct ufs_hba *hba,
 
 	return err;
 }
+EXPORT_SYMBOL(ufshcd_query_descriptor_retry);
 
 /**
  * ufshcd_read_desc_length - read the specified descriptor length from header
drivers/scsi/ufs/ufshpb.c new file +789 -0

789 lines not on this page · raw message

drivers/scsi/ufs/ufshpb.h new file +162 -0

162 lines not on this page · raw message

Signature · 1 line
2.17.1
#5 lore raw

RFC PATCH v2 4/5 scsi: ufs: L2P map management for HPB read

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 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.

---
 drivers/scsi/ufs/ufshpb.c | 971 +++++++++++++++++++++++++++++++++++++-
 drivers/scsi/ufs/ufshpb.h |  72 +++
 2 files changed, 1040 insertions(+), 3 deletions(-)
drivers/scsi/ufs/ufshpb.c +968 -3
index 07490679d2f1..6229c6fcb5e1 100644
@@ -25,6 +25,63 @@ static inline int ufshpb_is_valid_srgn(struct ufshpb_region *rgn,
 		srgn->srgn_state == HPB_SRGN_VALID;
 }
 
+static inline bool ufshpb_is_general_lun(int lun)
+{
+	return lun < UFS_UPIU_MAX_UNIT_NUM_ID;
+}
+
+static inline 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 bool ufshpb_is_empty_rsp_lists(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);
+
+	return ret;
+}
+
+static inline int ufshpb_may_field_valid(struct ufs_hba *hba,
+					 struct ufshcd_lrb *lrbp,
+					 struct ufshpb_rsp_field *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_type == 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 -EINVAL;
+
+	if (!ufshpb_is_general_lun(lrbp->lun)) {
+		dev_warn(hba->dev, "ufshpb: lun(%d) not supported\n",
+			 lrbp->lun);
+		return -EINVAL;
+	}
+
+	return 0;
+}
+
+
+static inline struct ufshpb_lu *ufshpb_get_hpb_data(struct scsi_cmnd *cmd)
+{
+	return cmd->device->hostdata;
+}
+
 static inline int ufshpb_get_state(struct ufshpb_lu *hpb)
 {
 	return atomic_read(&hpb->hpb_state);
@@ -59,6 +116,767 @@ static inline void ufshpb_lu_put(struct ufshpb_lu *hpb)
 	put_device(&hpb->hpb_lu_dev);
 }
 
+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, BLK_MQ_REQ_PREEMPT);
+	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;
+	map_req->lun = hpb->lun;
+
+	return map_req;
+
+free_map_req:
+	kmem_cache_free(hpb->map_req_cache, map_req);
+	return NULL;
+}
+
+static inline 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 inline 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 (srgn_idx = 0; srgn_idx < rgn->srgn_cnt; srgn_idx++) {
+		srgn = rgn->srgn_tbl + srgn_idx;
+
+		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 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->hpb_lu_dev,
+			"region %d subregion %d evicted\n",
+			srgn->rgn_idx, srgn->srgn_idx);
+		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;
+
+	spin_lock_irqsave(&hpb->hpb_state_lock, flags);
+	ufshpb_activate_subregion(hpb, srgn);
+	spin_unlock_irqrestore(&hpb->hpb_state_lock, flags);
+
+	ufshpb_put_map_req(map_req->hpb, map_req);
+	ufshpb_lu_put(hpb);
+}
+
+static inline 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_map_req_add_bio_page(struct ufshpb_lu *hpb,
+				       struct request_queue *q, struct bio *bio,
+				       struct ufshpb_map_ctx *mctx)
+{
+	int i, ret = 0;
+
+	for (i = 0; i < hpb->pages_per_srgn; i++) {
+		ret = bio_add_pc_page(q, bio, mctx->m_page[i], PAGE_SIZE, 0);
+		if (ret != PAGE_SIZE) {
+			dev_notice(&hpb->hpb_lu_dev,
+				   "bio_add_pc_page fail %d\n", ret);
+			return -ENOMEM;
+		}
+	}
+
+	return 0;
+}
+
+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;
+
+	q = hpb->sdev_ufs_lu->request_queue;
+	ret = ufshpb_map_req_add_bio_page(hpb, q, map_req->bio,
+					  map_req->mctx);
+	if (ret) {
+		dev_notice(&hpb->hpb_lu_dev,
+			   "map_req_add_bio_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->timeout = 0;
+	req->end_io_data = (void *)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);
+
+	atomic_inc(&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_drv.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_drv.ufshpb_page_pool,
+						GFP_KERNEL);
+		if (!mctx->m_page[i]) {
+			for (j = 0; j < i; j++)
+				mempool_free(mctx->m_page[j],
+					     ufshpb_drv.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_drv.ufshpb_mctx_pool);
+	return NULL;
+}
+
+static inline 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_drv.ufshpb_page_pool);
+
+	bitmap_free(mctx->ppn_dirty);
+	kmem_cache_free(hpb->m_page_cache, mctx->m_page);
+	mempool_free(mctx, ufshpb_drv.ufshpb_mctx_pool);
+}
+
+static int ufshpb_check_issue_state_srgns(struct ufshpb_lu *hpb,
+					  struct ufshpb_region *rgn)
+{
+	struct ufshpb_subregion *srgn;
+	int srgn_idx;
+
+	for (srgn_idx = 0; srgn_idx < rgn->srgn_cnt; srgn_idx++) {
+		srgn  = rgn->srgn_tbl + srgn_idx;
+
+		if (srgn->srgn_state == HPB_SRGN_ISSUED)
+			return -EPERM;
+	}
+	return 0;
+}
+
+static inline 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 inline 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_issue_state_srgns(hpb, rgn))
+			continue;
+
+		victim_rgn = rgn;
+		break;
+	}
+
+	return victim_rgn;
+}
+
+static inline 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 inline 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->hpb_lu_dev, "evict region %d\n", rgn->rgn_idx);
+
+	ufshpb_cleanup_lru_info(lru_info, rgn);
+
+	for (srgn_idx = 0; srgn_idx < rgn->srgn_cnt; srgn_idx++) {
+		srgn = rgn->srgn_tbl + srgn_idx;
+
+		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->hpb_state_lock, flags);
+	if (rgn->rgn_state == HPB_RGN_PINNED) {
+		dev_warn(&hpb->hpb_lu_dev,
+			 "pinned region cannot drop-out. region %d\n",
+			 rgn->rgn_idx);
+		goto out;
+	}
+	if (!list_empty(&rgn->list_lru_rgn)) {
+		if (ufshpb_check_issue_state_srgns(hpb, rgn)) {
+			ret = -EBUSY;
+			goto out;
+		}
+
+		__ufshpb_evict_region(hpb, rgn);
+	}
+out:
+	spin_unlock_irqrestore(&hpb->hpb_state_lock, flags);
+	return ret;
+}
+
+static inline struct
+ufshpb_rsp_field *ufshpb_get_hpb_rsp(struct ufshcd_lrb *lrbp)
+{
+	return (struct ufshpb_rsp_field *)&lrbp->ucd_rsp_ptr->sr.sense_data_len;
+}
+
+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_RGN_STATE state = HPB_SRGN_INVALID;
+
+	spin_lock_irqsave(&hpb->hpb_state_lock, flags);
+	/*
+	 * Since the region state change occurs only in the map_work,
+	 * the state of the region cannot HPB_RGN_INACTIVE at this point.
+	 * The region state must be changed in the map_work
+	 */
+	WARN_ON(rgn->rgn_state == HPB_RGN_INACTIVE);
+
+	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->hpb_state_lock, flags);
+
+	if (alloc_required) {
+		WARN_ON(srgn->mctx);
+		srgn->mctx = ufshpb_get_map_ctx(hpb);
+		if (!srgn->mctx) {
+			dev_notice(&hpb->hpb_lu_dev,
+			    "get map_ctx failed. region %d - %d\n",
+			    rgn->rgn_idx, srgn->srgn_idx);
+			state = HPB_SRGN_UNUSED;
+			goto change_srgn_state;
+		}
+	}
+
+	ufshpb_clear_dirty_bitmap(hpb, srgn);
+	map_req = ufshpb_get_map_req(hpb, srgn);
+	if (!map_req)
+		goto change_srgn_state;
+
+	ret = ufshpb_lu_get(hpb);
+	if (unlikely(ret)) {
+		dev_notice(&hpb->hpb_lu_dev,
+			   "%s: ufshpb_lu_get failed: %d", __func__, ret);
+		goto free_map_req;
+	}
+
+	ret = ufshpb_execute_map_req(hpb, map_req);
+	if (ret) {
+		dev_notice(&hpb->hpb_lu_dev,
+			   "%s: issue map_req failed: %d, region %d - %d\n",
+			   __func__, ret, srgn->rgn_idx, srgn->srgn_idx);
+		ufshpb_lu_put(hpb);
+		goto free_map_req;
+	}
+	return 0;
+
+free_map_req:
+	ufshpb_put_map_req(hpb, map_req);
+change_srgn_state:
+	spin_lock_irqsave(&hpb->hpb_state_lock, flags);
+	srgn->srgn_state = state;
+unlock_out:
+	spin_unlock_irqrestore(&hpb->hpb_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->hpb_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->hpb_lu_dev,
+				    "cannot get victim region error\n");
+				ret = -ENOMEM;
+				goto out;
+			}
+
+			dev_dbg(&hpb->hpb_lu_dev,
+				"LRU full (%d), choost 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->hpb_state_lock, flags);
+	return ret;
+}
+
+static void ufshpb_rsp_req_region_update(struct ufshpb_lu *hpb,
+					 struct ufshpb_rsp_field *rsp_field)
+{
+	int i, rgn_idx, srgn_idx;
+
+	/*
+	 * 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->hpb_lu_dev, "activate(%d) region %d - %d\n",
+			i, rgn_idx, srgn_idx);
+		ufshpb_update_active_info(hpb, rgn_idx, srgn_idx);
+		atomic_inc(&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->hpb_lu_dev, "inactivate(%d) region %d\n",
+			i, rgn_idx);
+		ufshpb_update_inactive_info(hpb, rgn_idx);
+		atomic_inc(&hpb->stats.rb_inactive_cnt);
+	}
+	spin_unlock(&hpb->rsp_list_lock);
+
+	dev_dbg(&hpb->hpb_lu_dev, "Noti: #ACT %u #INACT %u\n",
+		rsp_field->active_rgn_cnt, rsp_field->inactive_rgn_cnt);
+
+	queue_work(ufshpb_drv.ufshpb_wq, &hpb->map_work);
+}
+
+/* routine : isr (ufs) */
+static void ufshpb_rsp_upiu(struct ufs_hba *hba, struct ufshcd_lrb *lrbp)
+{
+	struct ufshpb_lu *hpb;
+	struct ufshpb_rsp_field *rsp_field;
+	int data_seg_len, ret;
+
+	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;
+
+		hpb = ufshpb_get_hpb_data(lrbp->cmd);
+		ret = ufshpb_lu_get(hpb);
+		if (ret)
+			return;
+
+		if (!ufshpb_is_empty_rsp_lists(hpb))
+			queue_work(ufshpb_drv.ufshpb_wq, &hpb->map_work);
+
+		goto put_hpb;
+	}
+
+	/* Check HPB_UPDATE_ALERT */
+	if (!(lrbp->ucd_rsp_ptr->header.dword_2 &
+	      UPIU_HEADER_DWORD(0, 2, 0, 0)))
+		return;
+
+	rsp_field = ufshpb_get_hpb_rsp(lrbp);
+	if (ufshpb_may_field_valid(hba, lrbp, rsp_field))
+		return;
+
+	hpb = ufshpb_get_hpb_data(lrbp->cmd);
+	ret = ufshpb_lu_get(hpb);
+	if (ret)
+		return;
+
+	atomic_inc(&hpb->stats.rb_noti_cnt);
+
+	switch (rsp_field->hpb_type) {
+	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->hpb_lu_dev,
+			 "UFS device lost HPB information during PM.\n");
+		break;
+	default:
+		dev_notice(&hpb->hpb_lu_dev, "hpb_type is not available: %d\n",
+			   rsp_field->hpb_type);
+		break;
+	}
+put_hpb:
+	ufshpb_lu_put(hpb);
+}
+
+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 (srgn_idx = 0; srgn_idx < rgn->srgn_cnt; srgn_idx++) {
+		srgn = rgn->srgn_tbl + srgn_idx;
+
+		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;
+	struct ufshpb_map_ctx *mctx;
+	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))) {
+		list_del_init(&srgn->list_act_srgn);
+		spin_unlock_irqrestore(&hpb->rsp_list_lock, flags);
+
+		rgn = hpb->rgn_tbl + srgn->rgn_idx;
+		mctx = NULL;
+		ret = ufshpb_add_region(hpb, rgn);
+		if (ret)
+			break;
+
+		ret = ufshpb_issue_map_req(hpb, rgn, srgn);
+		if (ret) {
+			dev_notice(&hpb->hpb_lu_dev,
+			    "issue map_req failed. ret %d, region %d - %d\n",
+			    ret, rgn->rgn_idx, srgn->srgn_idx);
+			break;
+		}
+		spin_lock_irqsave(&hpb->rsp_list_lock, flags);
+	}
+
+	if (ret) {
+		dev_notice(&hpb->hpb_lu_dev, "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))) {
+		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;
+	int ret;
+
+	hpb = container_of(work, struct ufshpb_lu, map_work);
+	ret = ufshpb_lu_get(hpb);
+	if (ret) {
+		dev_info(&hpb->hpb_lu_dev, "%s: exit, state %d\n",
+			 __func__, ufshpb_get_state(hpb));
+		return;
+	}
+
+	ufshpb_run_inactive_region_list(hpb);
+	ufshpb_run_active_subregion_list(hpb);
+
+	ufshpb_lu_put(hpb);
+}
+
+/*
+ * this function doesn't need to hold lock due to be called in init.
+ * (hpb_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 (srgn_idx = 0; srgn_idx < rgn->srgn_cnt; srgn_idx++) {
+		srgn = rgn->srgn_tbl + srgn_idx;
+
+		srgn->mctx = ufshpb_get_map_ctx(hpb);
+		srgn->srgn_state = HPB_SRGN_INVALID;
+		if (!srgn->mctx) {
+			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)
 {
@@ -101,6 +919,8 @@ static void ufshpb_init_lu_parameter(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_BLOCK_SIZE * HPB_ENTRY_SIZE;
@@ -154,6 +974,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;
@@ -163,7 +986,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;
@@ -187,7 +1016,10 @@ static void ufshpb_destroy_subregion_tbl(struct ufshpb_lu *hpb,
 		struct ufshpb_subregion *srgn;
 
 		srgn = rgn->srgn_tbl + srgn_idx;
-		srgn->srgn_state = HPB_SRGN_UNUSED;
+		if (srgn->srgn_state != HPB_SRGN_UNUSED) {
+			srgn->srgn_state = HPB_SRGN_UNUSED;
+			ufshpb_put_map_ctx(hpb, srgn->mctx);
+		}
 	}
 }
 
@@ -217,6 +1049,33 @@ static int ufshpb_lu_hpb_init(struct ufs_hba *hba, struct ufshpb_lu *hpb,
 	int ret;
 
 	spin_lock_init(&hpb->hpb_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)
@@ -230,6 +1089,10 @@ static int ufshpb_lu_hpb_init(struct ufs_hba *hba, struct ufshpb_lu *hpb,
 
 release_rgn_table:
 	ufshpb_destroy_region_tbl(hpb);
+release_m_page_cache:
+	kmem_cache_destroy(hpb->m_page_cache);
+release_req_cache:
+	kmem_cache_destroy(hpb->map_req_cache);
 	return ret;
 }
 
@@ -261,10 +1124,42 @@ 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 inline void ufshpb_cancel_jobs(struct ufshpb_lu *hpb)
+{
+	cancel_work_sync(&hpb->map_work);
+}
+
 static void ufshpb_lu_release(struct ufshpb_lu *hpb)
 {
+	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);
 }
 
@@ -351,6 +1246,9 @@ static void ufshpb_reset_host(struct ufs_hba *hba)
 		dev_info(&hpb->hpb_lu_dev, "ufshpb run reset_host");
 
 		ufshpb_set_state(hpb, HPB_RESET);
+		ufshpb_cancel_jobs(hpb);
+		ufshpb_discard_rsp_lists(hpb);
+
 		ufshpb_lu_put(hpb);
 	}
 }
@@ -365,6 +1263,7 @@ static void ufshpb_suspend(struct ufs_hba *hba)
 
 		dev_info(&hpb->hpb_lu_dev, "ufshpb goto suspend");
 		ufshpb_set_state(hpb, HPB_SUSPEND);
+		ufshpb_cancel_jobs(hpb);
 
 		ufshpb_lu_put(hpb);
 	}
@@ -380,6 +1279,9 @@ static void ufshpb_resume(struct ufs_hba *hba)
 
 		dev_info(&hpb->hpb_lu_dev, "ufshpb resume");
 		ufshpb_set_state(hpb, HPB_PRESENT);
+		if (!ufshpb_is_empty_rsp_lists(hpb))
+			queue_work(ufshpb_drv.ufshpb_wq, &hpb->map_work);
+
 		ufshpb_lu_put(hpb);
 	}
 }
@@ -661,6 +1563,14 @@ static void ufshpb_scan_hpb_lu(struct ufs_hba *hba,
 		list_for_each_entry(hpb, &ufshpb_drv.lh_hpb_lu, list_hpb_lu) {
 			dev_info(&hpb->hpb_lu_dev, "set state to present\n");
 			ufshpb_set_state(hpb, HPB_PRESENT);
+
+			if ((hpb->lu_pinned_end - hpb->lu_pinned_start) > 0) {
+				dev_info(&hpb->hpb_lu_dev,
+				    "loading pinned regions %d - %d\n",
+				    hpb->lu_pinned_start, hpb->lu_pinned_end);
+				queue_work(ufshpb_drv.ufshpb_wq,
+					&hpb->map_work);
+			}
 		}
 	}
 }
@@ -728,6 +1638,8 @@ static int ufshpb_remove(struct device *dev)
 		sdev = hpb->sdev_ufs_lu;
 		sdev->hostdata = NULL;
 
+		ufshpb_cancel_jobs(hpb);
+
 		device_del(&hpb->hpb_lu_dev);
 
 		dev_info(&hpb->hpb_lu_dev, "hpb_lu_dev refcnt %d\n",
@@ -768,16 +1680,69 @@ static int __init ufshpb_init(void)
 	unsigned int pool_size;
 	int ret;
 
+
+	ufshpb_drv.ufshpb_mctx_cache = kmem_cache_create("ufshpb_mctx_cache",
+					sizeof(struct ufshpb_map_ctx),
+					0, 0, NULL);
+	if (!ufshpb_drv.ufshpb_mctx_cache) {
+		pr_err("ufshpb: cannot init mctx cache\n");
+		return -ENOMEM;
+	}
+
+	pool_size = DIV_ROUND_UP(ufshpb_host_map_kbytes * 1024, 4096);
+	pr_info("%s:%d ufshpb_host_map_kbytes %u pool_size %u\n",
+	       __func__, __LINE__, ufshpb_host_map_kbytes, pool_size);
+
+	ufshpb_drv.ufshpb_mctx_pool = mempool_create_slab_pool(
+				     pool_size, ufshpb_drv.ufshpb_mctx_cache);
+	if (!ufshpb_drv.ufshpb_mctx_pool) {
+		pr_err("ufshpb: cannot init mctx pool\n");
+		ret = -ENOMEM;
+		goto release_mctx_cache;
+	}
+
+	ufshpb_drv.ufshpb_page_pool = mempool_create_page_pool(pool_size, 0);
+	if (!ufshpb_drv.ufshpb_page_pool) {
+		pr_err("ufshpb: cannot init page pool\n");
+		ret = -ENOMEM;
+		goto release_mctx_pool;
+	}
+
+	ufshpb_drv.ufshpb_wq = alloc_workqueue("ufshpb-wq",
+					WQ_UNBOUND | WQ_MEM_RECLAIM, 0);
+	if (!ufshpb_drv.ufshpb_wq) {
+		pr_err("ufshpb: alloc workqueue failed\n");
+		ret = -ENOMEM;
+		goto release_page_pool;
+	}
+
 	ret = driver_register(&ufshpb_drv.drv);
-	if (ret)
+	if (ret) {
 		pr_err("ufshpb: driver register failed\n");
+		goto release_wq;
+	}
 
+	return 0;
+release_wq:
+	destroy_workqueue(ufshpb_drv.ufshpb_wq);
+release_page_pool:
+	mempool_destroy(ufshpb_drv.ufshpb_page_pool);
+release_mctx_pool:
+	mempool_destroy(ufshpb_drv.ufshpb_mctx_pool);
+release_mctx_cache:
+	kmem_cache_destroy(ufshpb_drv.ufshpb_mctx_cache);
 	return ret;
 }
 
 static void __exit ufshpb_exit(void)
 {
 	driver_unregister(&ufshpb_drv.drv);
+
+	mempool_destroy(ufshpb_drv.ufshpb_page_pool);
+	mempool_destroy(ufshpb_drv.ufshpb_mctx_pool);
+	kmem_cache_destroy(ufshpb_drv.ufshpb_mctx_cache);
+
+	destroy_workqueue(ufshpb_drv.ufshpb_wq);
 }
 
 MODULE_AUTHOR("Yongmyong Lee <[email protected]>");
drivers/scsi/ufs/ufshpb.h +72 -0

100 lines not on this page · raw message

Signature · 1 line
2.17.1
#6 lore raw

RFC PATCH v2 5/5 scsi: ufs: Prepare HPB read for cached sub-region

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.

---
 drivers/scsi/ufs/ufshpb.c | 234 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 234 insertions(+)
drivers/scsi/ufs/ufshpb.c +234 -0
index 6229c6fcb5e1..848f51e9a1a1 100644
@@ -25,6 +25,22 @@ static inline int ufshpb_is_valid_srgn(struct ufshpb_region *rgn,
 		srgn->srgn_state == HPB_SRGN_VALID;
 }
 
+static inline bool ufshpb_is_read_cmd(struct scsi_cmnd *cmd)
+{
+	return req_op(cmd->request) == REQ_OP_READ;
+}
+
+static inline bool ufshpb_is_write_discard_cmd(struct scsi_cmnd *cmd)
+{
+	return op_is_write(req_op(cmd->request)) ||
+	       op_is_discard(req_op(cmd->request));
+}
+
+static inline bool ufshpb_is_support_chunk(int transfer_len)
+{
+	return transfer_len <= HPB_MULTI_CHUNK_HIGH;
+}
+
 static inline bool ufshpb_is_general_lun(int lun)
 {
 	return lun < UFS_UPIU_MAX_UNIT_NUM_ID;
@@ -116,6 +132,224 @@ static inline void ufshpb_lu_put(struct ufshpb_lu *hpb)
 	put_device(&hpb->hpb_lu_dev);
 }
 
+static inline u32 ufshpb_get_lpn(struct scsi_cmnd *cmnd)
+{
+	return blk_rq_pos(cmnd->request) >>
+		(ilog2(cmnd->device->sector_size) - 9);
+}
+
+static inline unsigned int ufshpb_get_len(struct scsi_cmnd *cmnd)
+{
+	return blk_rq_sectors(cmnd->request) >>
+		(ilog2(cmnd->device->sector_size) - 9);
+}
+
+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->hpb_lu_dev,
+			"error. cannot find page in mctx\n");
+		return 0;
+	}
+
+	ppn_table = page_address(page);
+	if (unlikely(!ppn_table)) {
+		*error = -ENOMEM;
+		dev_err(&hpb->hpb_lu_dev, "error. cannot get ppn_table\n");
+		return 0;
+	}
+
+	return ppn_table[offset];
+}
+
+static inline 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->ucd_req_ptr->sc.cdb;
+
+	cdb[0] = UFSHPB_READ;
+
+	put_unaligned_be64(ppn, &cdb[6]);
+	cdb[14] = transfer_len;
+}
+
+/* routine : READ10 -> HPB_READ  */
+static void ufshpb_prep_fn(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);
+	err = ufshpb_lu_get(hpb);
+	if (unlikely(err))
+		return;
+
+	WARN_ON(hpb->lun != cmd->device->lun);
+	if (!ufshpb_is_write_discard_cmd(cmd) &&
+	    !ufshpb_is_read_cmd(cmd))
+		goto put_hpb;
+
+	transfer_len = ufshpb_get_len(cmd);
+	if (unlikely(!transfer_len))
+		goto put_hpb;
+
+	lpn = ufshpb_get_lpn(cmd);
+	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_discard_cmd(cmd)) {
+		spin_lock_irqsave(&hpb->hpb_state_lock, flags);
+		ufshpb_set_ppn_dirty(hpb, rgn_idx, srgn_idx, srgn_offset,
+				 transfer_len);
+		spin_unlock_irqrestore(&hpb->hpb_state_lock, flags);
+		goto put_hpb;
+	}
+
+	WARN_ON(!ufshpb_is_read_cmd(cmd));
+
+	if (!ufshpb_is_support_chunk(transfer_len))
+		goto put_hpb;
+
+	spin_lock_irqsave(&hpb->hpb_state_lock, flags);
+	if (ufshpb_test_ppn_dirty(hpb, rgn_idx, srgn_idx, srgn_offset,
+				   transfer_len)) {
+		atomic_inc(&hpb->stats.miss_cnt);
+		spin_unlock_irqrestore(&hpb->hpb_state_lock, flags);
+		goto put_hpb;
+	}
+
+	ppn = ufshpb_get_ppn(hpb, srgn->mctx, srgn_offset, &err);
+	spin_unlock_irqrestore(&hpb->hpb_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(&hpb->hpb_lu_dev,
+			"ufshpb_get_ppn failed. err %d\n", err);
+		goto put_hpb;
+	}
+
+	ufshpb_set_hpb_read_to_upiu(hpb, lrbp, lpn, ppn, transfer_len);
+
+	atomic_inc(&hpb->stats.hit_cnt);
+put_hpb:
+	ufshpb_lu_put(hpb);
+}
+
 static struct ufshpb_req *ufshpb_get_map_req(struct ufshpb_lu *hpb,
 					     struct ufshpb_subregion *srgn)
 {
Signature · 1 line
2.17.1
#7 lore raw

Re: [RFC PATCH v2 4/5] scsi: ufs: L2P map management for HPB read

In reply to Daejun Park

Hi Daejun

Quoted 32 lines · Daejun Park
drivers/scsi/ufs/ufshpb.c +28 -0
+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;
+
+       q = hpb->sdev_ufs_lu->request_queue;
+       ret = ufshpb_map_req_add_bio_page(hpb, q, map_req->bio,
+                                         map_req->mctx);
+       if (ret) {
+               dev_notice(&hpb->hpb_lu_dev,
+                          "map_req_add_bio_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->timeout = 0;
+       req->end_io_data = (void *)map_req;
+
+       rq = scsi_req(req);
+       ufshpb_set_read_buf_cmd(rq->cmd, map_req->rgn_idx,
+                               map_req->srgn_idx, hpb-
Quoted 1 line

srgn_mem_size);

drivers/scsi/ufs/ufshpb.c +3 -0
+       rq->cmd_len = HPB_READ_BUFFER_CMD_LENGTH;
+
+       blk_execute_rq_nowait(q, NULL, req, 1,
Quoted 1 line

ufshpb_map_req_compl_fn);

HPB map_req is now being en-queued in sdev->request_queue. This is ok for the HPB v1.0. Have you ever been thinking about changing this way to directly issue HPB requests to UFS?

Actually, there are two reasons for this way:

1. Latency of loading mapping entries is lower comparing to your curret approach.
2. Also, it is preparing for the HPB v2.0. After all HPB 1.0 only supports 4KB read, this is useless, I am looking for the HPB v2.0.

Thanks,
Bean

#8 lore raw

Re: [RFC PATCH v2 4/5] scsi: ufs: L2P map management for HPB read

Hi Bean

Quoted 38 lines · Daejun Park
Quoted 32 lines
drivers/scsi/ufs/ufshpb.c +28 -0
+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;
+
+       q = hpb->sdev_ufs_lu->request_queue;
+       ret = ufshpb_map_req_add_bio_page(hpb, q, map_req->bio,
+                                         map_req->mctx);
+       if (ret) {
+               dev_notice(&hpb->hpb_lu_dev,
+                          "map_req_add_bio_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->timeout = 0;
+       req->end_io_data = (void *)map_req;
+
+       rq = scsi_req(req);
+       ufshpb_set_read_buf_cmd(rq->cmd, map_req->rgn_idx,
+                               map_req->srgn_idx, hpb-
Quoted 1 line

srgn_mem_size);

drivers/scsi/ufs/ufshpb.c +3 -0
+       rq->cmd_len = HPB_READ_BUFFER_CMD_LENGTH;
+
+       blk_execute_rq_nowait(q, NULL, req, 1,
Quoted 1 line

ufshpb_map_req_compl_fn);

Quoted 3 lines

HPB map_req is now being en-queued in sdev->request_queue. This is ok for the HPB v1.0. Have you ever been thinking about changing this way to directly issue HPB requests to UFS?

I think it is enough to support HPB.

Quoted 4 lines

Actually, there are two reasons for this way:

1. Latency of loading mapping entries is lower comparing to your curret approach.

Our map request style utilizes block layer API. It makes the codes keep simple and reliable. Also, I think the latency of loading mapping entries is not critical for HPB. Futhermore, I think the other requests from user is important than loading mapping entries. If the map_work issues map request directly, the user requests can be disturbed by map requests.

Quoted 2 lines

2. Also, it is preparing for the HPB v2.0. After all HPB 1.0 only supports 4KB read, this is useless, I am looking for the HPB v2.0.

I don't understand this comment. In HPB v2.0, this code can be used without changing.

Thanks,
Daejun

#9 lore raw

RE: [RFC PATCH v2 4/5] scsi: ufs: L2P map management for HPB read

In reply to Daejun Park

drivers/scsi/ufs/ufshpb.c static inline void ufshpb_lu_put(struct ufshpb_lu *hpb) · line 323

Quoted 10 lines
drivers/scsi/ufs/ufshpb.c +9 -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_drv.ufshpb_mctx_pool, GFP_KERNEL);
+       if (!mctx)
+               return NULL;

So you use ufshpb_host_map_kbytes as the min_nr in your mempool_create,
But you know that you need max_lru_active_cnt x srgns_per_rgn such mapping context elements. So you are
a) failing to provide the slab allocator an information that you already have, and
b) selecting from a finite pool will assure that you'll never exceed max-active-regions, even if some corner case fails your logic.

#10 lore raw

RE: [RFC PATCH v2 4/5] scsi: ufs: L2P map management for HPB read

Quoted 15 lines

+

drivers/scsi/ufs/ufshpb.c static inline void ufshpb_lu_put(struct ufshpb_lu *hpb) · line 323

Quoted 8 lines
drivers/scsi/ufs/ufshpb.c +8 -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_drv.ufshpb_mctx_pool, GFP_KERNEL);
+       if (!mctx)
+               return NULL;

So you use ufshpb_host_map_kbytes as the min_nr in your mempool_create,
But you know that you need max_lru_active_cnt x srgns_per_rgn such mapping context elements. So you are
a) failing to provide the slab allocator an information that you already have, and
b) selecting from a finite pool will assure that you'll never exceed max-active-regions, even if some corner case fails your logic.

It was intend to provide user-configurable pre-allocated memory to reduce latency due to memory allocation. The value of ufshpb_host_map_kbytes can be set to max_lru_active_cnt x srgns_per_rgn, if the user want to.

Thanks,
Daejun

#11 lore raw

RE: [RFC PATCH v2 4/5] scsi: ufs: L2P map management for HPB read

Quoted 17 lines
Quoted 3 lines

+

Quoted 1 line

+static struct ufshpb_map_ctx *ufshpb_get_map_ctx(struct ufshpb_lu

*hpb)

Quoted 8 lines

drivers/scsi/ufs/ufshpb.c static inline void ufshpb_lu_put(struct ufshpb_lu *hpb) · line 323

Quoted 7 lines
drivers/scsi/ufs/ufshpb.c +7 -0
+{
+       struct ufshpb_map_ctx *mctx;
+       int i, j;
+
+       mctx = mempool_alloc(ufshpb_drv.ufshpb_mctx_pool, GFP_KERNEL);
+       if (!mctx)
+               return NULL;

So you use ufshpb_host_map_kbytes as the min_nr in your

mempool_create,

Quoted 1 line

But you know that you need max_lru_active_cnt x srgns_per_rgn such

mapping context elements.

Quoted 2 lines

So you are
a) failing to provide the slab allocator an information that you already have,

Quoted 7 lines

and

Quoted 1 line

b) selecting from a finite pool will assure that you'll never exceed max-

active-regions,

Quoted 1 line

even if some corner case fails your logic.

It was intend to provide user-configurable pre-allocated memory to reduce latency due to memory allocation. The value of ufshpb_host_map_kbytes can be set to max_lru_active_cnt x srgns_per_rgn, if the user want to.

Ok, I see your point.
It is as if you expect that a "user" will query the unit descriptors first, Make some calculations, and then will run modprobe with the proper value. Are you assuming that an "intelligent" user does all that?

The reasonable scenario IMO, is that OEMs will initiate a service in their ramdisk/init.rc with some default value.

Don't you see the damage potential in using a wrong value here?

#12 lore raw

RE: [RFC PATCH v2 4/5] scsi: ufs: L2P map management for HPB read

Quoted 28 lines
Quoted 16 lines
Quoted 2 lines

+

Quoted 1 line

+static struct ufshpb_map_ctx *ufshpb_get_map_ctx(struct ufshpb_lu

*hpb)

Quoted 8 lines

drivers/scsi/ufs/ufshpb.c static inline void ufshpb_lu_put(struct ufshpb_lu *hpb) · line 323

Quoted 7 lines
drivers/scsi/ufs/ufshpb.c +7 -0
+{
+       struct ufshpb_map_ctx *mctx;
+       int i, j;
+
+       mctx = mempool_alloc(ufshpb_drv.ufshpb_mctx_pool, GFP_KERNEL);
+       if (!mctx)
+               return NULL;

So you use ufshpb_host_map_kbytes as the min_nr in your

mempool_create,

Quoted 1 line

But you know that you need max_lru_active_cnt x srgns_per_rgn such

mapping context elements.

Quoted 2 lines

So you are
a) failing to provide the slab allocator an information that you already have,

Quoted 7 lines

and

Quoted 1 line

b) selecting from a finite pool will assure that you'll never exceed max-

active-regions,

Quoted 1 line

even if some corner case fails your logic.

It was intend to provide user-configurable pre-allocated memory to reduce latency due to memory allocation. The value of ufshpb_host_map_kbytes can be set to max_lru_active_cnt x srgns_per_rgn, if the user want to.

Ok, I see your point.
It is as if you expect that a "user" will query the unit descriptors first, Make some calculations, and then will run modprobe with the proper value. Are you assuming that an "intelligent" user does all that?

Quoted 5 lines

The reasonable scenario IMO, is that OEMs will initiate a service in their ramdisk/init.rc with some default value.

Don't you see the damage potential in using a wrong value here?

I understand your scenario. I will remove module parameter and set min_nr value of memory pool as "max_lru_active_cnt x srgns_per_rgn" size.

Thanks,
Daejun

#13 lore raw

RE: [RFC PATCH v2 4/5] scsi: ufs: L2P map management for HPB read

In reply to Daejun Park

drivers/scsi/ufs/ufshpb.c static inline void ufshpb_lu_put(struct ufshpb_lu *hpb) · line 760

Quoted 6 lines
drivers/scsi/ufs/ufshpb.c +5 -0
+static void ufshpb_run_active_subregion_list(struct ufshpb_lu *hpb)
+{
+       struct ufshpb_region *rgn;
+       struct ufshpb_subregion *srgn;
+       struct ufshpb_map_ctx *mctx;

mctx doesn't really do anything here

Quoted 34 lines
drivers/scsi/ufs/ufshpb.c +34 -0
+       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))) {
+               list_del_init(&srgn->list_act_srgn);
+               spin_unlock_irqrestore(&hpb->rsp_list_lock, flags);
+
+               rgn = hpb->rgn_tbl + srgn->rgn_idx;
+               mctx = NULL;
+               ret = ufshpb_add_region(hpb, rgn);
+               if (ret)
+                       break;
+
+               ret = ufshpb_issue_map_req(hpb, rgn, srgn);
+               if (ret) {
+                       dev_notice(&hpb->hpb_lu_dev,
+                           "issue map_req failed. ret %d, region %d - %d\n",
+                           ret, rgn->rgn_idx, srgn->srgn_idx);
+                       break;
+               }
+               spin_lock_irqsave(&hpb->rsp_list_lock, flags);
+       }
+
+       if (ret) {
+               dev_notice(&hpb->hpb_lu_dev, "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);
+}
#14 lore raw

RE: [RFC PATCH v2 4/5] scsi: ufs: L2P map management for HPB read

Quoted 6 lines

+static void ufshpb_run_active_subregion_list(struct ufshpb_lu *hpb)

drivers/scsi/ufs/ufshpb.c static inline void ufshpb_lu_put(struct ufshpb_lu *hpb) · line 760

Quoted 4 lines
drivers/scsi/ufs/ufshpb.c +4 -0
+{
+       struct ufshpb_region *rgn;
+       struct ufshpb_subregion *srgn;
+       struct ufshpb_map_ctx *mctx;

mctx doesn't really do anything here

OK, I will delete it.

Quoted 36 lines
Quoted 34 lines
drivers/scsi/ufs/ufshpb.c +34 -0
+       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))) {
+               list_del_init(&srgn->list_act_srgn);
+               spin_unlock_irqrestore(&hpb->rsp_list_lock, flags);
+
+               rgn = hpb->rgn_tbl + srgn->rgn_idx;
+               mctx = NULL;
+               ret = ufshpb_add_region(hpb, rgn);
+               if (ret)
+                       break;
+
+               ret = ufshpb_issue_map_req(hpb, rgn, srgn);
+               if (ret) {
+                       dev_notice(&hpb->hpb_lu_dev,
+                           "issue map_req failed. ret %d, region %d - %d\n",
+                           ret, rgn->rgn_idx, srgn->srgn_idx);
+                       break;
+               }
+               spin_lock_irqsave(&hpb->rsp_list_lock, flags);
+       }
+
+       if (ret) {
+               dev_notice(&hpb->hpb_lu_dev, "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);
+}
#15 lore raw

RE: [RFC PATCH v2 3/5] scsi: ufs: Introduce HPB module

In reply to Daejun Park
Quoted 9 lines

This is a patch for the HPB module.
The HPB module queries UFS for device information during initialization. We added the export symbol to two functions in ufshcd.c to initialize the HPB module.

The HPB module can be loaded or built-in as needed. The mininum size of the memory pool used in the HPB module is

Typo minimum

Quoted 5 lines

implemented
as a module parameter, so that it can be configurable by the user.

To gurantee a minimum memory pool size of 4MB:

$ insmod ufshpb.ko ufshpb_host_map_kbytes=4096

You are going through a lot of troubles to make it a loadable module. What are, in your opinion, the pros and cons of this design decision?

#16 lore raw

RE: [RFC PATCH v2 3/5] scsi: ufs: Introduce HPB module

Quoted 10 lines
Quoted 8 lines

This is a patch for the HPB module.
The HPB module queries UFS for device information during initialization. We added the export symbol to two functions in ufshcd.c to initialize the HPB module.

The HPB module can be loaded or built-in as needed. The mininum size of the memory pool used in the HPB module is

Typo minimum

Quoted 7 lines
Quoted 5 lines

implemented
as a module parameter, so that it can be configurable by the user.

To gurantee a minimum memory pool size of 4MB:

$ insmod ufshpb.ko ufshpb_host_map_kbytes=4096

You are going through a lot of troubles to make it a loadable module. What are, in your opinion, the pros and cons of this design decision?

In my opinion...

pros:
1. A user can unload an unnecessary module when there is an insufficient memory situation (HPB case).
2. Since each UFS vendor has a different way of implementing UFS features, it can be supported as a separate module. Otherwise, many quirks must be attached to module, which is not desirable way.
3. It is possible to distinguish parts that are not necessary for essential ufs operation.
4. It is advantageous to implement the latest functions according to the development speed of UFS.

cons:
1. It is difficult work to be implemented as a module.
2. Modifying "ufsfeature.c" is required to implement the feature that can not supported by the exsiting "ufsf_operation".

Thanks,
Daejun

#17 lore raw

Re: [RFC PATCH v2 3/5] scsi: ufs: Introduce HPB module

Quoted 29 lines · Daejun Park
Quoted 11 lines
Quoted 6 lines

implemented
as a module parameter, so that it can be configurable by the user.

To gurantee a minimum memory pool size of 4MB:

$ insmod ufshpb.ko ufshpb_host_map_kbytes=4096

You are going through a lot of troubles to make it a loadable module.
What are, in your opinion, the pros and cons of this design decision?

In my opinion...

pros:
1. A user can unload an unnecessary module when there is an insufficient
memory situation (HPB case).
2. Since each UFS vendor has a different way of implementing UFS features,
it can be supported as a separate module. Otherwise, many quirks must be attached to module, which is not desirable way.
3. It is possible to distinguish parts that are not necessary for essential
ufs operation.
4. It is advantageous to implement the latest functions according to the
development speed of UFS.

Quoted 8 lines

cons:
1. It is difficult work to be implemented as a module.
2. Modifying "ufsfeature.c" is required to implement the feature that can
not supported by the exsiting "ufsf_operation".

Thanks,
Daejun

Dear Avri, Daejun, Bart

It is true that it is very difficult to make everyone happy. We now have three HPB drivers in the patchwork, but I still didn't see a final agreement. Please tell me which one do you want to focus on?

Bean

#18 lore raw

Re: [RFC PATCH v2 3/5] scsi: ufs: Introduce HPB module

Quoted 35 lines
Quoted 35 lines
Quoted 11 lines

implemented

Quoted 5 lines

as a module parameter, so that it can be configurable by the user.

To gurantee a minimum memory pool size of 4MB:

$ insmod ufshpb.ko ufshpb_host_map_kbytes=4096

You are going through a lot of troubles to make it a loadable module.
What are, in your opinion, the pros and cons of this design decision?

In my opinion...

pros:
1. A user can unload an unnecessary module when there is an insufficient
memory situation (HPB case).
2. Since each UFS vendor has a different way of implementing UFS features,
it can be supported as a separate module. Otherwise, many quirks must be attached to module, which is not desirable way.
3. It is possible to distinguish parts that are not necessary for essential
ufs operation.
4. It is advantageous to implement the latest functions according to the
development speed of UFS.

cons:
1. It is difficult work to be implemented as a module.
2. Modifying "ufsfeature.c" is required to implement the feature that can
not supported by the exsiting "ufsf_operation".

Quoted 8 lines
Quoted 2 lines

Thanks,
Daejun

Dear Avri, Daejun, Bart

It is true that it is very difficult to make everyone happy. We now have three HPB drivers in the patchwork, but I still didn't see a final agreement. Please tell me which one do you want to focus on?

The HPB driver has been greatly improved in the process of being applied to mobile devices since the release of the first HPB version in openMPDK. We want to contribute to the linux mainline with the knowledge obtained through the experience.
I find it difficult to make everyone happy, but I think it is possible that everyone can accept the HPB driver through several revisions.

Thanks,
Daejun

#19 lore raw

RE: [RFC PATCH v2 3/5] scsi: ufs: Introduce HPB module

Quoted 45 lines
Quoted 37 lines
Quoted 37 lines
Quoted 6 lines

implemented

Quoted 3 lines

as a module parameter, so that it can be configurable by the user.

Quoted 7 lines
Quoted 2 lines

To gurantee a minimum memory pool size of 4MB:

$ insmod ufshpb.ko ufshpb_host_map_kbytes=4096

You are going through a lot of troubles to make it a loadable module.
What are, in your opinion, the pros and cons of this design decision?

In my opinion...

pros:
1. A user can unload an unnecessary module when there is an insufficient
memory situation (HPB case).
2. Since each UFS vendor has a different way of implementing UFS features,
it can be supported as a separate module. Otherwise, many quirks must be attached to module, which is not desirable way.
3. It is possible to distinguish parts that are not necessary for essential
ufs operation.
4. It is advantageous to implement the latest functions according to the
development speed of UFS.

cons:
1. It is difficult work to be implemented as a module.
2. Modifying "ufsfeature.c" is required to implement the feature that can
not supported by the exsiting "ufsf_operation".

Quoted 8 lines
Quoted 2 lines

Thanks,
Daejun

Dear Avri, Daejun, Bart

It is true that it is very difficult to make everyone happy. We now have three HPB drivers in the patchwork, but I still didn't see a final agreement. Please tell me which one do you want to focus on?

Quoted 6 lines

The HPB driver has been greatly improved in the process of being applied to mobile devices since the release of the first HPB version in openMPDK. We want to contribute to the linux mainline with the knowledge obtained through the experience.
I find it difficult to make everyone happy, but I think it is possible that everyone can accept the HPB driver through several revisions.

Ack on that.
For me, it was very clear that Bart prefers the Samsung approach, Hence I withdrew from my RFC and switch to support Daejun's.

Thanks,
Avri

#20 lore raw

RE: [RFC PATCH v2 3/5] scsi: ufs: Introduce HPB module

In reply to Daejun Park

drivers/scsi/ufs/ufshpb.c line 223

Quoted 11 lines
drivers/scsi/ufs/ufshpb.c new file +10 -0
+static int ufshpb_lu_hpb_init(struct ufs_hba *hba, struct ufshpb_lu *hpb,
+                             struct ufshpb_dev_info *hpb_dev_info)
+{
+       int ret;
+
+       spin_lock_init(&hpb->hpb_state_lock);
+
+       ret = ufshpb_alloc_region_tbl(hba, hpb);
+       if (ret)
+               goto release_m_page_cache;

This label is added only on 4/5

drivers/scsi/ufs/ufshpb.c line 768

Quoted 3 lines
drivers/scsi/ufs/ufshpb.c new file +3 -0
+static int __init ufshpb_init(void)
+{
+       unsigned int pool_size;

Unused variable

Quoted 8 lines
drivers/scsi/ufs/ufshpb.c new file +8 -0
+       int ret;
+
+       ret = driver_register(&ufshpb_drv.drv);
+       if (ret)
+               pr_err("ufshpb: driver register failed\n");
+
+       return ret;
+}
#21 lore raw

RE: [RFC PATCH v2 3/5] scsi: ufs: Introduce HPB module

Quoted 17 lines

+static int ufshpb_lu_hpb_init(struct ufs_hba *hba, struct ufshpb_lu *hpb,

drivers/scsi/ufs/ufshpb.c line 223

Quoted 9 lines
drivers/scsi/ufs/ufshpb.c new file +9 -0
+                             struct ufshpb_dev_info *hpb_dev_info)
+{
+       int ret;
+
+       spin_lock_init(&hpb->hpb_state_lock);
+
+       ret = ufshpb_alloc_region_tbl(hba, hpb);
+       if (ret)
+               goto release_m_page_cache;

This label is added only on 4/5

drivers/scsi/ufs/ufshpb.c line 768

Quoted 3 lines
drivers/scsi/ufs/ufshpb.c new file +3 -0
+static int __init ufshpb_init(void)
+{
+       unsigned int pool_size;

Unused variable

Quoted 8 lines

drivers/scsi/ufs/ufshpb.c line 776

Quoted 8 lines
drivers/scsi/ufs/ufshpb.c new file +8 -0
+       int ret;
+
+       ret = driver_register(&ufshpb_drv.drv);
+       if (ret)
+               pr_err("ufshpb: driver register failed\n");
+
+       return ret;
+}

OK, I will fix it.

#22 lore raw

Re: [RFC PATCH v2 2/5] scsi: ufs: Add UFS-feature layer

In reply to Daejun Park

Hi, Daejun

drivers/scsi/ufs/ufsfeature.c

Quoted 9 lines · Daejun Park
drivers/scsi/ufs/ufsfeature.c new file +9 -0
+void ufsf_scan_features(struct ufs_hba *hba)
+{
+       int ret;
+
+       init_waitqueue_head(&hba->ufsf.sdev_wait);
+       atomic_set(&hba->ufsf.slave_conf_cnt, 0);
+
+       if (hba->dev_info.wspecversion >= HPB_SUPPORTED_VERSION &&
+           (hba->dev_info.b_ufs_feature_sup & UFS_DEV_HPB_SUPPORT)) 

How about removing this check "(hba->dev_info.wspecversion >= HPB_SUPPORTED_VERSION" since ufs with lower version than v3.1 can add HPB feature by FFU,
if (hba->dev_info.b_ufs_feature_sup &UFS_FEATURE_SUPPORT_HPB_BIT) is enough.

Quoted 2 lines

+#define HPB_SUPPORTED_VERSION 0x0310

Thank,
Bean

#23 lore raw

Re: [RFC PATCH v2 2/5] scsi: ufs: Add UFS-feature layer

Hi, Bean

Quoted 9 lines · Daejun Park
Quoted 7 lines
drivers/scsi/ufs/ufsfeature.c new file +7 -0
+void ufsf_scan_features(struct ufs_hba *hba)
+{
+       int ret;
+
+       init_waitqueue_head(&hba->ufsf.sdev_wait);
+       atomic_set(&hba->ufsf.slave_conf_cnt, 0);
+
Quoted 8 lines

Review

Quoted 2 lines
(quoted diff) +2 -0
+       if (hba->dev_info.wspecversion >= HPB_SUPPORTED_VERSION &&
+           (hba->dev_info.b_ufs_feature_sup & UFS_DEV_HPB_SUPPORT)) 

How about removing this check "(hba->dev_info.wspecversion >= HPB_SUPPORTED_VERSION" since ufs with lower version than v3.1 can add HPB feature by FFU,
if (hba->dev_info.b_ufs_feature_sup &UFS_FEATURE_SUPPORT_HPB_BIT) is enough.

OK, changing it seems no problem. But I want to know what other people think about this version checking code.

Thanks,
Daejun

#24 lore raw

RE: [RFC PATCH v2 2/5] scsi: ufs: Add UFS-feature layer

Quoted 19 lines

Hi, Bean

Quoted 9 lines · Daejun Park
Quoted 7 lines
drivers/scsi/ufs/ufsfeature.c new file +7 -0
+void ufsf_scan_features(struct ufs_hba *hba)
+{
+       int ret;
+
+       init_waitqueue_head(&hba->ufsf.sdev_wait);
+       atomic_set(&hba->ufsf.slave_conf_cnt, 0);
+
Quoted 8 lines

Review

Quoted 2 lines
(quoted diff) +2 -0
+       if (hba->dev_info.wspecversion >= HPB_SUPPORTED_VERSION &&
+           (hba->dev_info.b_ufs_feature_sup & UFS_DEV_HPB_SUPPORT))

How about removing this check "(hba->dev_info.wspecversion >= HPB_SUPPORTED_VERSION" since ufs with lower version than v3.1 can add HPB feature by FFU,
if (hba->dev_info.b_ufs_feature_sup &UFS_FEATURE_SUPPORT_HPB_BIT) is enough.

Quoted 3 lines

OK, changing it seems no problem. But I want to know what other people think
about this version checking code.

HPB1.0 isn't part of ufs3.1, but published only later.
Allowing earlier versions will required to quirk the descriptor sizes.
I see Bean's point here, but I vote for adding it in a single quirk, when the time comes.

Thanks,
Avri

#25 lore raw

Re: [RFC PATCH v2 2/5] scsi: ufs: Add UFS-feature layer

Quoted 20 lines · Avri Altman
Quoted 20 lines

Hi, Bean

Quoted 17 lines · Daejun Park

drivers/scsi/ufs/ufsfeature.c

Quoted 9 lines
drivers/scsi/ufs/ufsfeature.c new file +9 -0
+void ufsf_scan_features(struct ufs_hba *hba)
+{
+       int ret;
+
+       init_waitqueue_head(&hba->ufsf.sdev_wait);
+       atomic_set(&hba->ufsf.slave_conf_cnt, 0);
+
+       if (hba->dev_info.wspecversion >= HPB_SUPPORTED_VERSION &&
+           (hba->dev_info.b_ufs_feature_sup & UFS_DEV_HPB_SUPPORT))

How about removing this check "(hba->dev_info.wspecversion >= HPB_SUPPORTED_VERSION" since ufs with lower version than v3.1 can add HPB feature by FFU,
if (hba->dev_info.b_ufs_feature_sup &UFS_FEATURE_SUPPORT_HPB_BIT) is enough.

Quoted 7 lines
Quoted 3 lines

OK, changing it seems no problem. But I want to know what other people think
about this version checking code.

HPB1.0 isn't part of ufs3.1, but published only later.
Allowing earlier versions will required to quirk the descriptor sizes.
I see Bean's point here, but I vote for adding it in a single quirk, when the time comes.

I second Avri here, older devices need a quirk to handle, let do that as a separate patch.

Quoted 2 lines

Thanks,
Avri

Signature · 2 lines
Regards,
Alim
#26 lore raw

Re: [RFC PATCH v2 2/5] scsi: ufs: Add UFS-feature layer

Quoted 28 lines · Alim Akhtar
Quoted 21 lines
Quoted 16 lines
Quoted 8 lines
Quoted 7 lines
drivers/scsi/ufs/ufsfeature.c new file +4 -0
+       init_waitqueue_head(&hba->ufsf.sdev_wait);
+       atomic_set(&hba->ufsf.slave_conf_cnt, 0);
+
+       if (hba->dev_info.wspecversion >=

HPB_SUPPORTED_VERSION &&
+ (hba->dev_info.b_ufs_feature_sup &
UFS_DEV_HPB_SUPPORT))

Quoted 7 lines

How about removing this check "(hba->dev_info.wspecversion >= HPB_SUPPORTED_VERSION" since ufs with lower version than v3.1 can add
HPB feature by FFU,
if (hba->dev_info.b_ufs_feature_sup &UFS_FEATURE_SUPPORT_HPB_BIT) is
enough.

Quoted 4 lines

OK, changing it seems no problem. But I want to know what other people
think
about this version checking code.

Quoted 6 lines

HPB1.0 isn't part of ufs3.1, but published only later. Allowing earlier versions will required to quirk the descriptor sizes.
I see Bean's point here, but I vote for adding it in a single quirk, when the time comes.

Quoted 6 lines

I second Avri here, older devices need a quirk to handle, let do that as a separate patch.

Quoted 2 lines

Thanks,
Avri

what is useful point of adding a quirk for this?

From the customer side piont, they just get our FW image, and then do FFU. If adding a quirk here, that means they also need to change UFS driver. Also, you expand the qurik structure.

from cambridge dictionary:
Qurik:
an unusual habit or part of someone's personality, or something that
is strange and unexpected.

HPB feature is unexpected??

please tell me the useful point of adding a Quirk.

Bean

Quoted 1 line
#27 lore raw

Re: [RFC PATCH v2 2/5] scsi: ufs: Add UFS-feature layer

Hi Bean,

Quoted 28 lines · Bean Huo
Quoted 8 lines
Quoted 7 lines

HPB1.0 isn't part of ufs3.1, but published only later. Allowing earlier versions will required to quirk the descriptor sizes.
I see Bean's point here, but I vote for adding it in a single quirk, when the time comes.

Quoted 6 lines

I second Avri here, older devices need a quirk to handle, let do that as a separate patch.

Quoted 2 lines

Thanks,
Avri

what is useful point of adding a quirk for this?

From the customer side piont, they just get our FW image, and then do FFU. If adding a quirk here, that means they also need to change UFS driver. Also, you expand the qurik structure.

from cambridge dictionary:
Qurik:
an unusual habit or part of someone's personality, or something that
is strange and unexpected.

Quoted 5 lines

HPB feature is unexpected??

please tell me the useful point of adding a Quirk.

The point is not about adding a quirk per say, it's about doing that as a separate patch so that we know which device/ features are added and why it is added. Please understand there is no denial about your proposal or thought.
Thanks!!

Quoted 3 lines

Bean

Quoted 1 line
Signature · 2 lines
Regards,
Alim
#28 lore raw

RE: [RFC PATCH v2 2/5] scsi: ufs: Add UFS-feature layer

In reply to Daejun Park
Quoted 49 lines

This patch is adding UFS feature layer to UFS core driver.

UFS Driver data structure (struct ufs_hba)

        │
┌--------------┐
│ UFS feature  │ <-- HPB module
│    layer     │ <-- other extended feature module
└--------------┘

Each extended UFS-Feature module has a bus of ufs-ext feature type. The UFS feature layer manages common APIs used by each extended feature module. The APIs are set of UFS Query requests and UFS Vendor commands related to each extended feature module.

Other extended features can also be implemented using the proposed APIs. For example, in Write Booster, "prep_fn" can be used to guarantee the lifetime of UFS by updating the amount of write IO.
And reset/reset_host/suspend/resume can be used to manage the kernel task for checking lifetime of UFS.

The following 6 callback functions have been added to "ufshcd.c".
prep_fn: called after construct upiu structure
reset: called after proving hba
reset_host: called before ufshcd_host_reset_and_restore
suspend: called before ufshcd_suspend
resume: called after ufshcd_resume
rsp_upiu: called in ufshcd_transfer_rsp_status with SAM_STAT_GOOD state

---
 drivers/scsi/ufs/Makefile     |   2 +-
 drivers/scsi/ufs/ufsfeature.c | 148 ++++++++++++++++++++++++++++++++++
 drivers/scsi/ufs/ufsfeature.h |  69 ++++++++++++++++
 drivers/scsi/ufs/ufshcd.c     |  17 ++++
 drivers/scsi/ufs/ufshcd.h     |   3 +
 5 files changed, 238 insertions(+), 1 deletion(-)
 create mode 100644 drivers/scsi/ufs/ufsfeature.c
 create mode 100644 drivers/scsi/ufs/ufsfeature.h
drivers/scsi/ufs/Makefile +0 -0
index 94c6c5d7334b..fe3a92b06c87 100644
@@ -5,7 +5,7 @@ obj-$(CONFIG_SCSI_UFS_DWC_TC_PLATFORM) += tc-dwc-

g210-pltfrm.o ufshcd-dwc.o tc-d
obj-$(CONFIG_SCSI_UFS_CDNS_PLATFORM) += cdns-pltfrm.o obj-$(CONFIG_SCSI_UFS_QCOM) += ufs-qcom.o obj-$(CONFIG_SCSI_UFSHCD) += ufshcd-core.o

drivers/scsi/ufs/Makefile obj-$(CONFIG_SCSI_UFS_DWC_TC_PLATFORM) += tc-dwc-g210-pltfrm.o ufshcd-dwc.o tc-d · line 8

Quoted 2 lines
drivers/scsi/ufs/Makefile +1 -1
-ufshcd-core-y                          += ufshcd.o ufs-sysfs.o
+ufshcd-core-y                          += ufshcd.o ufs-sysfs.o ufsfeature.o

How about making it

Quoted 1 line

ufshcd-core-$(CONFIG_UFS_FEATURES) += ufsfeature.o

So that you won't check none-hpb driver on every response etc.

#29 lore raw

RE: [RFC PATCH v2 2/5] scsi: ufs: Add UFS-feature layer

Quoted 50 lines
Quoted 47 lines

This patch is adding UFS feature layer to UFS core driver.

UFS Driver data structure (struct ufs_hba)

        │
┌--------------┐
│ UFS feature  │ <-- HPB module
│    layer     │ <-- other extended feature module
└--------------┘

Each extended UFS-Feature module has a bus of ufs-ext feature type. The UFS feature layer manages common APIs used by each extended feature module. The APIs are set of UFS Query requests and UFS Vendor commands related to each extended feature module.

Other extended features can also be implemented using the proposed APIs. For example, in Write Booster, "prep_fn" can be used to guarantee the lifetime of UFS by updating the amount of write IO.
And reset/reset_host/suspend/resume can be used to manage the kernel task for checking lifetime of UFS.

The following 6 callback functions have been added to "ufshcd.c".
prep_fn: called after construct upiu structure
reset: called after proving hba
reset_host: called before ufshcd_host_reset_and_restore
suspend: called before ufshcd_suspend
resume: called after ufshcd_resume
rsp_upiu: called in ufshcd_transfer_rsp_status with SAM_STAT_GOOD state

---
 drivers/scsi/ufs/Makefile     |   2 +-
 drivers/scsi/ufs/ufsfeature.c | 148 ++++++++++++++++++++++++++++++++++
 drivers/scsi/ufs/ufsfeature.h |  69 ++++++++++++++++
 drivers/scsi/ufs/ufshcd.c     |  17 ++++
 drivers/scsi/ufs/ufshcd.h     |   3 +
 5 files changed, 238 insertions(+), 1 deletion(-)
 create mode 100644 drivers/scsi/ufs/ufsfeature.c
 create mode 100644 drivers/scsi/ufs/ufsfeature.h
drivers/scsi/ufs/Makefile +0 -0
index 94c6c5d7334b..fe3a92b06c87 100644
@@ -5,7 +5,7 @@ obj-$(CONFIG_SCSI_UFS_DWC_TC_PLATFORM) += tc-dwc-

g210-pltfrm.o ufshcd-dwc.o tc-d
obj-$(CONFIG_SCSI_UFS_CDNS_PLATFORM) += cdns-pltfrm.o obj-$(CONFIG_SCSI_UFS_QCOM) += ufs-qcom.o obj-$(CONFIG_SCSI_UFSHCD) += ufshcd-core.o

drivers/scsi/ufs/Makefile obj-$(CONFIG_SCSI_UFS_DWC_TC_PLATFORM) += tc-dwc-g210-pltfrm.o ufshcd-dwc.o tc-d · line 8

Quoted 2 lines
drivers/scsi/ufs/Makefile +1 -1
-ufshcd-core-y                          += ufshcd.o ufs-sysfs.o
+ufshcd-core-y                          += ufshcd.o ufs-sysfs.o ufsfeature.o

How about making it

Quoted 2 lines
Quoted 1 line

ufshcd-core-$(CONFIG_UFS_FEATURES) += ufsfeature.o

So that you won't check none-hpb driver on every response etc.

It's not a big problem because it only needs a simple checking.
In addition, I think that it is not necessary to separate them because the UFS feature is enabled in most of the user cases.

Thanks,
Daejun

#30 lore raw
In reply to Daejun Park
Quoted 7 lines · Daejun Park

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

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

I'm still not enthusiast about the choice for a bus to connect UFS core and the HPB module. But if others are fine with this choice, I won't object.

Bart.