* [PATCH v31 1/4] scsi: ufs: Introduce HPB feature
2021-03-22 6:51 ` [PATCH v31 0/4] scsi: ufs: Add Host Performance Booster Support Daejun Park
@ 2021-03-22 6:53 ` Daejun Park
2021-03-22 6:54 ` [PATCH v31 2/4] scsi: ufs: L2P map management for HPB read Daejun Park
` (2 subsequent siblings)
3 siblings, 0 replies; 26+ messages in thread
From: Daejun Park @ 2021-03-22 6:53 UTC (permalink / raw)
To: Daejun Park, Greg KH, avri.altman@wdc.com, jejb@linux.ibm.com,
martin.petersen@oracle.com, asutoshd@codeaurora.org,
stanley.chu@mediatek.com, cang@codeaurora.org, bvanassche@acm.org,
huobean@gmail.com, linux-scsi@vger.kernel.org,
linux-kernel@vger.kernel.org, ALIM AKHTAR, JinHwan Park,
Javier Gonzalez, Sung-Jun Park, Jinyoung CHOI, Dukhyun Kwon,
Keoseong Park, Jaemyung Lee, Jieon Seol
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 | 127 +++++
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 | 569 +++++++++++++++++++++
drivers/scsi/ufs/ufshpb.h | 167 ++++++
9 files changed, 977 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 d1bc23cb6a9d..528bf89fc98b 100644
--- a/Documentation/ABI/testing/sysfs-driver-ufs
+++ b/Documentation/ABI/testing/sysfs-driver-ufs
@@ -1172,3 +1172,130 @@ 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: March 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: March 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: March 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: March 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: March 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: March 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: March 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: March 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: March 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.
+
+What: /sys/class/scsi_device/*/device/hpb_sysfs/hit_cnt
+Date: March 2021
+Contact: Daejun Park <daejun7.park@samsung.com>
+Description: This entry shows the number of reads that changed to HPB read.
+
+ The file is read only.
+
+What: /sys/class/scsi_device/*/device/hpb_sysfs/miss_cnt
+Date: March 2021
+Contact: Daejun Park <daejun7.park@samsung.com>
+Description: This entry shows the number of reads that cannot be changed to
+ HPB read.
+
+ The file is read only.
+
+What: /sys/class/scsi_device/*/device/hpb_sysfs/rb_noti_cnt
+Date: March 2021
+Contact: Daejun Park <daejun7.park@samsung.com>
+Description: This entry shows the number of response UPIUs that has
+ recommendations for activating sub-regions and/or inactivating region.
+
+ The file is read only.
+
+What: /sys/class/scsi_device/*/device/hpb_sysfs/rb_active_cnt
+Date: March 2021
+Contact: Daejun Park <daejun7.park@samsung.com>
+Description: This entry shows the number of active sub-regions recommended by
+ response UPIUs.
+
+ The file is read only.
+
+What: /sys/class/scsi_device/*/device/hpb_sysfs/rb_inactive_cnt
+Date: March 2021
+Contact: Daejun Park <daejun7.park@samsung.com>
+Description: This entry shows the number of inactive regions recommended by
+ response UPIUs.
+
+ The file is read only.
+
+What: /sys/class/scsi_device/*/device/hpb_sysfs/map_req_cnt
+Date: March 2021
+Contact: Daejun Park <daejun7.park@samsung.com>
+Description: This entry shows the number of read buffer commands for
+ activating sub-regions recommended by response UPIUs.
+
+ The file is read only.
diff --git a/drivers/scsi/ufs/Kconfig b/drivers/scsi/ufs/Kconfig
index 07cf415367b4..29ec6e4a87bd 100644
--- a/drivers/scsi/ufs/Kconfig
+++ b/drivers/scsi/ufs/Kconfig
@@ -182,3 +182,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 cb80b9670bfe..4eee7e31d08d 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
@@ -544,6 +556,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 ab9a1b15d223..ddeb5bb9fb88 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>
#define CREATE_TRACE_POINTS
@@ -4856,6 +4857,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
@@ -4865,6 +4885,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);
@@ -4886,6 +4908,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);
@@ -7388,6 +7415,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;
@@ -7415,9 +7443,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) {
@@ -7646,6 +7681,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;
@@ -7788,6 +7827,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);
@@ -7933,6 +7973,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)
@@ -7980,6 +8021,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,
};
@@ -8696,6 +8740,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->dev_info.b_rpm_dev_flush_capable = false;
ufshcd_clear_ua_wluns(hba);
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,
@@ -8938,6 +8985,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 1af91661dc83..008a5f7146c0 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
@@ -835,6 +854,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..1a72f6541510
--- /dev/null
+++ b/drivers/scsi/ufs/ufshpb.c
@@ -0,0 +1,569 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Universal Flash Storage Host Performance Booster
+ *
+ * Copyright (C) 2017-2021 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, bool last)
+{
+ int srgn_idx;
+ struct ufshpb_subregion *srgn;
+
+ for (srgn_idx = 0; srgn_idx < rgn->srgn_cnt; srgn_idx++) {
+ srgn = rgn->srgn_tbl + srgn_idx;
+
+ srgn->rgn_idx = rgn->rgn_idx;
+ srgn->srgn_idx = srgn_idx;
+ srgn->srgn_state = HPB_SRGN_UNUSED;
+ }
+
+ if (unlikely(last && hpb->last_srgn_entries))
+ srgn->is_last = true;
+}
+
+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->last_srgn_entries = 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;
+ bool last_srgn = false;
+
+ 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;
+ last_srgn = true;
+ }
+
+ ret = ufshpb_alloc_subregion_tbl(hpb, rgn, srgn_cnt);
+ if (ret)
+ goto release_srgn_table;
+ ufshpb_init_subregion_tbl(hpb, rgn, last_srgn);
+
+ 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_info = &hba->ufshpb_dev;
+ int 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_info->hpb_disabled = true;
+ return;
+ }
+
+ hpb_info->rgn_size = geo_buf[GEOMETRY_DESC_PARAM_HPB_REGION_SIZE];
+ hpb_info->srgn_size = geo_buf[GEOMETRY_DESC_PARAM_HPB_SUBREGION_SIZE];
+ max_active_rgns = get_unaligned_be16(geo_buf +
+ GEOMETRY_DESC_PARAM_HPB_MAX_ACTIVE_REGS);
+
+ if (hpb_info->rgn_size == 0 || hpb_info->srgn_size == 0 ||
+ max_active_rgns == 0) {
+ dev_err(hba->dev, "No HPB supported device\n");
+ hpb_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) || !hba->dev_info.hpb_enabled)
+ 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..fa311ed3fa94
--- /dev/null
+++ b/drivers/scsi/ufs/ufshpb.h
@@ -0,0 +1,167 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/*
+ * Universal Flash Storage Host Performance Booster
+ *
+ * Copyright (C) 2017-2021 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_INIT = 0,
+ 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;
+ bool is_last;
+};
+
+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;
+ u32 last_srgn_entries;
+ 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
^ permalink raw reply related [flat|nested] 26+ messages in thread* [PATCH v31 2/4] scsi: ufs: L2P map management for HPB read
2021-03-22 6:51 ` [PATCH v31 0/4] scsi: ufs: Add Host Performance Booster Support Daejun Park
2021-03-22 6:53 ` [PATCH v31 1/4] scsi: ufs: Introduce HPB feature Daejun Park
@ 2021-03-22 6:54 ` Daejun Park
2021-03-22 9:11 ` Bean Huo
2021-03-22 6:54 ` [PATCH v31 3/4] scsi: ufs: Prepare HPB read for cached sub-region Daejun Park
2021-03-22 6:55 ` [PATCH v31 4/4] scsi: ufs: Add HPB 2.0 support Daejun Park
3 siblings, 1 reply; 26+ messages in thread
From: Daejun Park @ 2021-03-22 6:54 UTC (permalink / raw)
To: Daejun Park, Greg KH, avri.altman@wdc.com, jejb@linux.ibm.com,
martin.petersen@oracle.com, asutoshd@codeaurora.org,
stanley.chu@mediatek.com, cang@codeaurora.org, bvanassche@acm.org,
huobean@gmail.com, linux-scsi@vger.kernel.org,
linux-kernel@vger.kernel.org, ALIM AKHTAR, JinHwan Park,
Javier Gonzalez, Sung-Jun Park, Jinyoung CHOI, Dukhyun Kwon,
Keoseong Park, Jaemyung Lee, Jieon Seol
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 | 1088 ++++++++++++++++++++++++++++++++++++-
drivers/scsi/ufs/ufshpb.h | 65 +++
4 files changed, 1178 insertions(+), 15 deletions(-)
diff --git a/drivers/scsi/ufs/ufs.h b/drivers/scsi/ufs/ufs.h
index 4eee7e31d08d..bfb84d2ba990 100644
--- a/drivers/scsi/ufs/ufs.h
+++ b/drivers/scsi/ufs/ufs.h
@@ -478,6 +478,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
+ * @lun: LUN of response UPIU
+ * @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 lun;
+ 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
@@ -488,6 +523,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 ddeb5bb9fb88..88280310bb64 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 */
@@ -9233,6 +9236,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 1a72f6541510..c67acfc8c6bf 100644
--- a/drivers/scsi/ufs/ufshpb.c
+++ b/drivers/scsi/ufs/ufshpb.c
@@ -16,6 +16,16 @@
#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);
@@ -36,14 +46,889 @@ static void ufshpb_set_state(struct ufshpb_lu *hpb, int state)
atomic_set(&hpb->hpb_state, state);
}
+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 = false;
+ unsigned long flags;
+
+ if (ufshpb_get_state(hpb) != HPB_PRESENT)
+ return;
+
+ spin_lock_irqsave(&hpb->rsp_list_lock, flags);
+ if (!list_empty(&hpb->lh_inact_rgn) || !list_empty(&hpb->lh_act_srgn))
+ 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)
+{
+ /* Check HPB_UPDATE_ALERT */
+ if (!(lrbp->ucd_rsp_ptr->header.dword_2 &
+ UPIU_HEADER_DWORD(0, 2, 0, 0)))
+ return false;
+
+ 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->active_rgn_cnt > MAX_ACTIVE_NUM ||
+ rsp_field->inactive_rgn_cnt > MAX_INACTIVE_NUM ||
+ rsp_field->hpb_op == HPB_RSP_NONE ||
+ (rsp_field->hpb_op == HPB_RSP_REQ_REGION_UPDATE &&
+ !rsp_field->active_rgn_cnt && !rsp_field->inactive_rgn_cnt))
+ return false;
+
+ if (!ufshpb_is_general_lun(rsp_field->lun)) {
+ dev_warn(hba->dev, "ufshpb: lun(%d) not supported\n",
+ lrbp->lun);
+ return false;
+ }
+
+ return true;
+}
+
+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;
+ int retries = HPB_MAP_REQ_RETRIES;
+
+ map_req = kmem_cache_alloc(hpb->map_req_cache, GFP_KERNEL);
+ if (!map_req)
+ return NULL;
+
+retry:
+ req = blk_get_request(hpb->sdev_ufs_lu->request_queue,
+ REQ_OP_SCSI_IN, BLK_MQ_REQ_NOWAIT);
+
+ if ((PTR_ERR(req) == -EWOULDBLOCK) && (--retries > 0)) {
+ usleep_range(3000, 3100);
+ goto retry;
+ }
+
+ 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)
+{
+ u32 num_entries = hpb->entries_per_srgn;
+
+ if (!srgn->mctx) {
+ dev_err(&hpb->sdev_ufs_lu->sdev_dev,
+ "no mctx in region %d subregion %d.\n",
+ srgn->rgn_idx, srgn->srgn_idx);
+ return -1;
+ }
+
+ if (unlikely(srgn->is_last))
+ num_entries = hpb->last_srgn_entries;
+
+ bitmap_zero(srgn->mctx->ppn_dirty, num_entries);
+ 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.
+ * Make sure the region must not evict in I/O progress
+ */
+ if (!srgn->mctx) {
+ dev_err(&hpb->sdev_ufs_lu->sdev_dev,
+ "no mctx in region %d subregion %d.\n",
+ srgn->rgn_idx, srgn->srgn_idx);
+ srgn->srgn_state = HPB_SRGN_INVALID;
+ return;
+ }
+
+ 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, bool last)
+{
+ struct request_queue *q;
+ struct request *req;
+ struct scsi_request *rq;
+ int mem_size = hpb->srgn_mem_size;
+ 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);
+
+ if (unlikely(last))
+ mem_size = hpb->last_srgn_entries * HPB_ENTRY_SIZE;
+
+ ufshpb_set_read_buf_cmd(rq->cmd, map_req->rgn_idx,
+ map_req->srgn_idx, mem_size);
+ rq->cmd_len = HPB_READ_BUFFER_CMD_LENGTH;
+
+ blk_execute_rq_nowait(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,
+ bool last)
+{
+ struct ufshpb_map_ctx *mctx;
+ u32 num_entries = hpb->entries_per_srgn;
+ 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;
+
+ if (unlikely(last))
+ num_entries = hpb->last_srgn_entries;
+
+ mctx->ppn_dirty = bitmap_zalloc(num_entries, 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) {
+ if (!rgn) {
+ dev_err(&hpb->sdev_ufs_lu->sdev_dev,
+ "%s: no region allocated\n",
+ __func__);
+ return NULL;
+ }
+ 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) {
+ srgn->mctx = ufshpb_get_map_ctx(hpb, srgn->is_last);
+ 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, srgn->is_last);
+ 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)
+{
+ struct ufshpb_region *rgn;
+ struct ufshpb_subregion *srgn;
+ int i, rgn_i, srgn_i;
+
+ 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
+ */
+ for (i = 0; i < rsp_field->active_rgn_cnt; i++) {
+ rgn_i =
+ be16_to_cpu(rsp_field->hpb_active_field[i].active_rgn);
+ srgn_i =
+ 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_i, srgn_i);
+
+ spin_lock(&hpb->rsp_list_lock);
+ ufshpb_update_active_info(hpb, rgn_i, srgn_i);
+ spin_unlock(&hpb->rsp_list_lock);
+
+ rgn = hpb->rgn_tbl + rgn_i;
+ srgn = rgn->srgn_tbl + srgn_i;
+
+ /* blocking HPB_READ */
+ spin_lock(&hpb->rgn_state_lock);
+ if (srgn->srgn_state == HPB_SRGN_VALID)
+ srgn->srgn_state = HPB_SRGN_INVALID;
+ spin_unlock(&hpb->rgn_state_lock);
+ hpb->stats.rb_active_cnt++;
+ }
+
+ for (i = 0; i < rsp_field->inactive_rgn_cnt; i++) {
+ rgn_i = be16_to_cpu(rsp_field->hpb_inactive_field[i]);
+ dev_dbg(&hpb->sdev_ufs_lu->sdev_dev,
+ "inactivate(%d) region %d\n", i, rgn_i);
+
+ spin_lock(&hpb->rsp_list_lock);
+ ufshpb_update_inactive_info(hpb, rgn_i);
+ spin_unlock(&hpb->rsp_list_lock);
+
+ rgn = hpb->rgn_tbl + rgn_i;
+
+ spin_lock(&hpb->rgn_state_lock);
+ if (rgn->rgn_state != HPB_RGN_INACTIVE) {
+ for (srgn_i = 0; srgn_i < rgn->srgn_cnt; srgn_i++) {
+ srgn = rgn->srgn_tbl + srgn_i;
+ if (srgn->srgn_state == HPB_SRGN_VALID)
+ srgn->srgn_state = HPB_SRGN_INVALID;
+ }
+ }
+ spin_unlock(&hpb->rgn_state_lock);
+
+ hpb->stats.rb_inactive_cnt++;
+ }
+
+ dev_dbg(&hpb->sdev_ufs_lu->sdev_dev, "Noti: #ACT %u #INACT %u\n",
+ rsp_field->active_rgn_cnt, rsp_field->inactive_rgn_cnt);
+
+ if (ufshpb_get_state(hpb) == HPB_PRESENT)
+ 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 = &lrbp->ucd_rsp_ptr->hr;
+ int data_seg_len;
+
+ if (unlikely(lrbp->lun != rsp_field->lun)) {
+ struct scsi_device *sdev;
+ bool found = false;
+
+ __shost_for_each_device(sdev, hba->host) {
+ hpb = ufshpb_get_hpb_data(sdev);
+
+ if (!hpb)
+ continue;
+
+ if (rsp_field->lun == hpb->lun) {
+ found = true;
+ break;
+ }
+ }
+
+ if (!found)
+ return;
+ }
+
+ if (!hpb)
+ return;
+
+ if (ufshpb_get_state(hpb) == HPB_INIT)
+ return;
+
+ if ((ufshpb_get_state(hpb) != HPB_PRESENT) &&
+ (ufshpb_get_state(hpb) != HPB_SUSPEND)) {
+ dev_notice(&hpb->sdev_ufs_lu->sdev_dev,
+ "%s: ufshpb state is not PRESENT/SUSPEND\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(hpb->lun))
+ return;
+
+ ufshpb_kick_map_work(hpb);
+ return;
+ }
+
+ 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_REQ_REGION_UPDATE:
+ if (data_seg_len != DEV_DATA_SEG_LEN)
+ dev_warn(&hpb->sdev_ufs_lu->sdev_dev,
+ "%s: data seg length is not same.\n",
+ __func__);
+ 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->is_last);
+ 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, bool last)
{
int srgn_idx;
struct ufshpb_subregion *srgn;
- for (srgn_idx = 0; srgn_idx < rgn->srgn_cnt; srgn_idx++) {
- 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;
@@ -78,6 +963,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;
@@ -129,6 +1016,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;
@@ -140,7 +1030,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, last_srgn);
- 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;
@@ -159,13 +1055,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)
@@ -239,11 +1135,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 *
@@ -275,6 +1207,33 @@ 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;
@@ -318,7 +1277,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;
@@ -335,13 +1294,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);
}
}
@@ -351,13 +1312,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);
}
}
@@ -367,7 +1329,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;
@@ -375,6 +1337,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);
}
}
@@ -427,7 +1390,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;
@@ -437,8 +1400,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);
@@ -446,24 +1414,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)
@@ -485,6 +1470,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;
@@ -494,6 +1482,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(struct ufs_hba *hba)
+{
+ 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) {
+ dev_err(hba->dev, "ufshpb: cannot init mctx cache\n");
+ return -ENOMEM;
+ }
+
+ pool_size = PAGE_ALIGN(ufshpb_host_map_kbytes * 1024) / PAGE_SIZE;
+ dev_info(hba->dev, "%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) {
+ dev_err(hba->dev, "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) {
+ dev_err(hba->dev, "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) {
+ dev_err(hba->dev, "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_info = &hba->ufshpb_dev;
@@ -558,7 +1597,13 @@ void ufshpb_init(struct ufs_hba *hba)
if (!ufshpb_is_allowed(hba) || !hba->dev_info.hpb_enabled)
return;
+ if (ufshpb_init_mem_wq(hba)) {
+ 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,
@@ -567,3 +1612,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 fa311ed3fa94..dcc0ca3b8158 100644
--- a/drivers/scsi/ufs/ufshpb.h
+++ b/drivers/scsi/ufs/ufshpb.h
@@ -40,6 +40,7 @@
#define LU_ENABLED_HPB_FUNC 0x02
#define HPB_RESET_REQ_RETRIES 10
+#define HPB_MAP_REQ_RETRIES 5
#define HPB_SUPPORT_VERSION 0x100
@@ -84,11 +85,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;
bool is_last;
+ /* below information is used by rsp_list */
+ struct list_head list_act_srgn;
};
struct ufshpb_region {
@@ -96,6 +105,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 {
@@ -110,10 +156,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;
@@ -133,6 +191,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;
};
@@ -140,6 +201,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) {}
@@ -147,10 +209,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);
@@ -158,6 +222,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
^ permalink raw reply related [flat|nested] 26+ messages in thread* Re: [PATCH v31 2/4] scsi: ufs: L2P map management for HPB read
2021-03-22 6:54 ` [PATCH v31 2/4] scsi: ufs: L2P map management for HPB read Daejun Park
@ 2021-03-22 9:11 ` Bean Huo
2021-03-22 9:45 ` Daejun Park
2021-03-23 4:22 ` Can Guo
0 siblings, 2 replies; 26+ messages in thread
From: Bean Huo @ 2021-03-22 9:11 UTC (permalink / raw)
To: daejun7.park, Greg KH, avri.altman@wdc.com, jejb@linux.ibm.com,
martin.petersen@oracle.com, asutoshd@codeaurora.org,
stanley.chu@mediatek.com, cang@codeaurora.org, bvanassche@acm.org,
linux-scsi@vger.kernel.org, linux-kernel@vger.kernel.org,
ALIM AKHTAR, JinHwan Park, Javier Gonzalez, Sung-Jun Park,
Jinyoung CHOI, Dukhyun Kwon, Keoseong Park, Jaemyung Lee,
Jieon Seol
On Mon, 2021-03-22 at 15:54 +0900, Daejun Park wrote:
> + switch (rsp_field->hpb_op) {
>
> + case HPB_RSP_REQ_REGION_UPDATE:
>
> + if (data_seg_len != DEV_DATA_SEG_LEN)
>
> + dev_warn(&hpb->sdev_ufs_lu->sdev_dev,
>
> + "%s: data seg length is not
> same.\n",
>
> + __func__);
>
> + 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;
Hi Deajun,
This series looks good to me. Just here I have one question. You didn't
handle HPB_RSP_DEV_RESET, just a warning. Based on your SS UFS, how to
handle HPB_RSP_DEV_RESET from the host side? Do you think we shoud
reset host side HPB entry as well or what else?
Bean
^ permalink raw reply [flat|nested] 26+ messages in thread* RE: Re: [PATCH v31 2/4] scsi: ufs: L2P map management for HPB read
2021-03-22 9:11 ` Bean Huo
@ 2021-03-22 9:45 ` Daejun Park
2021-03-23 4:22 ` Can Guo
1 sibling, 0 replies; 26+ messages in thread
From: Daejun Park @ 2021-03-22 9:45 UTC (permalink / raw)
To: Bean Huo, Daejun Park, Greg KH, avri.altman@wdc.com,
jejb@linux.ibm.com, martin.petersen@oracle.com,
asutoshd@codeaurora.org, stanley.chu@mediatek.com,
cang@codeaurora.org, bvanassche@acm.org,
linux-scsi@vger.kernel.org, linux-kernel@vger.kernel.org,
ALIM AKHTAR, JinHwan Park, Javier Gonzalez, Sung-Jun Park,
Jinyoung CHOI, Dukhyun Kwon, Keoseong Park, Jaemyung Lee,
Jieon Seol
Hi Bean,
>On Mon, 2021-03-22 at 15:54 +0900, Daejun Park wrote:
>> + switch (rsp_field->hpb_op) {
>>
>> + case HPB_RSP_REQ_REGION_UPDATE:
>>
>> + if (data_seg_len != DEV_DATA_SEG_LEN)
>>
>> + dev_warn(&hpb->sdev_ufs_lu->sdev_dev,
>>
>> + "%s: data seg length is not
>> same.\n",
>>
>> + __func__);
>>
>> + 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;
>
>Hi Deajun,
>This series looks good to me. Just here I have one question. You didn't
Thanks.
>handle HPB_RSP_DEV_RESET, just a warning. Based on your SS UFS, how to
>handle HPB_RSP_DEV_RESET from the host side? Do you think we shoud
>reset host side HPB entry as well or what else?
In the JEDEC HPB spec, it as follows:
When the device is powered off by the host, the device may restore L2P map
data upon power up or build from the host’s HPB READ command.
So I think there is nothing to do, because UFS can build from host's
command. Moreover, in the case of the HPB read with invalid information by
dev reset, it just processed as normal read.
Thanks,
Daejun
>
>
>Bean
>
>
>
>
^ permalink raw reply [flat|nested] 26+ messages in thread* Re: [PATCH v31 2/4] scsi: ufs: L2P map management for HPB read
2021-03-22 9:11 ` Bean Huo
2021-03-22 9:45 ` Daejun Park
@ 2021-03-23 4:22 ` Can Guo
2021-03-23 4:33 ` Can Guo
1 sibling, 1 reply; 26+ messages in thread
From: Can Guo @ 2021-03-23 4:22 UTC (permalink / raw)
To: Bean Huo
Cc: daejun7.park, Greg KH, avri.altman, jejb, martin.petersen,
asutoshd, stanley.chu, bvanassche, linux-scsi, linux-kernel,
ALIM AKHTAR, JinHwan Park, Javier Gonzalez, Sung-Jun Park,
Jinyoung CHOI, Dukhyun Kwon, Keoseong Park, Jaemyung Lee,
Jieon Seol
On 2021-03-22 17:11, Bean Huo wrote:
> On Mon, 2021-03-22 at 15:54 +0900, Daejun Park wrote:
>> + switch (rsp_field->hpb_op) {
>>
>> + case HPB_RSP_REQ_REGION_UPDATE:
>>
>> + if (data_seg_len != DEV_DATA_SEG_LEN)
>>
>> + dev_warn(&hpb->sdev_ufs_lu->sdev_dev,
>>
>> + "%s: data seg length is not
>> same.\n",
>>
>> + __func__);
>>
>> + 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;
>
> Hi Deajun,
> This series looks good to me. Just here I have one question. You didn't
> handle HPB_RSP_DEV_RESET, just a warning. Based on your SS UFS, how to
> handle HPB_RSP_DEV_RESET from the host side? Do you think we shoud
> reset host side HPB entry as well or what else?
>
>
> Bean
Same question here - I am still collecting feedbacks from flash vendors
about
what is recommanded host behavior on reception of HPB Op code 0x2, since
it
is not cleared defined in HPB2.0 specs.
Can Guo.
^ permalink raw reply [flat|nested] 26+ messages in thread* Re: [PATCH v31 2/4] scsi: ufs: L2P map management for HPB read
2021-03-23 4:22 ` Can Guo
@ 2021-03-23 4:33 ` Can Guo
2021-03-23 5:37 ` Daejun Park
0 siblings, 1 reply; 26+ messages in thread
From: Can Guo @ 2021-03-23 4:33 UTC (permalink / raw)
To: Bean Huo
Cc: daejun7.park, Greg KH, avri.altman, jejb, martin.petersen,
asutoshd, stanley.chu, bvanassche, linux-scsi, linux-kernel,
ALIM AKHTAR, JinHwan Park, Javier Gonzalez, Sung-Jun Park,
Jinyoung CHOI, Dukhyun Kwon, Keoseong Park, Jaemyung Lee,
Jieon Seol
On 2021-03-23 12:22, Can Guo wrote:
> On 2021-03-22 17:11, Bean Huo wrote:
>> On Mon, 2021-03-22 at 15:54 +0900, Daejun Park wrote:
>>> + switch (rsp_field->hpb_op) {
>>>
>>> + case HPB_RSP_REQ_REGION_UPDATE:
>>>
>>> + if (data_seg_len != DEV_DATA_SEG_LEN)
>>>
>>> + dev_warn(&hpb->sdev_ufs_lu->sdev_dev,
>>>
>>> + "%s: data seg length is not
>>> same.\n",
>>>
>>> + __func__);
>>>
>>> + 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;
>>
>> Hi Deajun,
>> This series looks good to me. Just here I have one question. You
>> didn't
>> handle HPB_RSP_DEV_RESET, just a warning. Based on your SS UFS, how
>> to
>> handle HPB_RSP_DEV_RESET from the host side? Do you think we shoud
>> reset host side HPB entry as well or what else?
>>
>>
>> Bean
>
> Same question here - I am still collecting feedbacks from flash vendors
> about
> what is recommanded host behavior on reception of HPB Op code 0x2,
> since it
> is not cleared defined in HPB2.0 specs.
>
> Can Guo.
I think the question should be asked in the HPB2.0 patch, since in
HPB1.0 device
control mode, a HPB reset in device side does not impact anything in
host side -
host is not writing back any HPB entries to device anyways and HPB Read
cmd with
invalid HPB entries shall be treated as normal Read(10) cmd without any
problems.
Please correct me if I am wrong.
Thanks,
Can Guo.
^ permalink raw reply [flat|nested] 26+ messages in thread* RE: Re: [PATCH v31 2/4] scsi: ufs: L2P map management for HPB read
2021-03-23 4:33 ` Can Guo
@ 2021-03-23 5:37 ` Daejun Park
2021-03-23 6:07 ` Can Guo
0 siblings, 1 reply; 26+ messages in thread
From: Daejun Park @ 2021-03-23 5:37 UTC (permalink / raw)
To: Can Guo, Bean Huo
Cc: Daejun Park, Greg KH, avri.altman@wdc.com, jejb@linux.ibm.com,
martin.petersen@oracle.com, asutoshd@codeaurora.org,
stanley.chu@mediatek.com, bvanassche@acm.org,
linux-scsi@vger.kernel.org, linux-kernel@vger.kernel.org,
ALIM AKHTAR, JinHwan Park, Javier Gonzalez, Sung-Jun Park,
Jinyoung CHOI, Dukhyun Kwon, Keoseong Park, Jaemyung Lee,
Jieon Seol
>On 2021-03-23 12:22, Can Guo wrote:
>> On 2021-03-22 17:11, Bean Huo wrote:
>>> On Mon, 2021-03-22 at 15:54 +0900, Daejun Park wrote:
>>>> + switch (rsp_field->hpb_op) {
>>>>
>>>> + case HPB_RSP_REQ_REGION_UPDATE:
>>>>
>>>> + if (data_seg_len != DEV_DATA_SEG_LEN)
>>>>
>>>> + dev_warn(&hpb->sdev_ufs_lu->sdev_dev,
>>>>
>>>> + "%s: data seg length is not
>>>> same.\n",
>>>>
>>>> + __func__);
>>>>
>>>> + 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;
>>>
>>> Hi Deajun,
>>> This series looks good to me. Just here I have one question. You
>>> didn't
>>> handle HPB_RSP_DEV_RESET, just a warning. Based on your SS UFS, how
>>> to
>>> handle HPB_RSP_DEV_RESET from the host side? Do you think we shoud
>>> reset host side HPB entry as well or what else?
>>>
>>>
>>> Bean
>>
>> Same question here - I am still collecting feedbacks from flash vendors
>> about
>> what is recommanded host behavior on reception of HPB Op code 0x2,
>> since it
>> is not cleared defined in HPB2.0 specs.
>>
>> Can Guo.
>
>I think the question should be asked in the HPB2.0 patch, since in
>HPB1.0 device
>control mode, a HPB reset in device side does not impact anything in
>host side -
>host is not writing back any HPB entries to device anyways and HPB Read
>cmd with
>invalid HPB entries shall be treated as normal Read(10) cmd without any
>problems.
Yes, UFS device will process read command even the HPB entries are valid or
not. So it is warning about read performance drop by dev reset.
Thanks,
Daejun
>Please correct me if I am wrong.
>Thanks,
>Can Guo.
>
>
>
^ permalink raw reply [flat|nested] 26+ messages in thread* Re: [PATCH v31 2/4] scsi: ufs: L2P map management for HPB read
2021-03-23 5:37 ` Daejun Park
@ 2021-03-23 6:07 ` Can Guo
2021-03-23 6:19 ` Daejun Park
0 siblings, 1 reply; 26+ messages in thread
From: Can Guo @ 2021-03-23 6:07 UTC (permalink / raw)
To: daejun7.park
Cc: Bean Huo, Greg KH, avri.altman, jejb, martin.petersen, asutoshd,
stanley.chu, bvanassche, linux-scsi, linux-kernel, ALIM AKHTAR,
JinHwan Park, Javier Gonzalez, Sung-Jun Park, Jinyoung CHOI,
Dukhyun Kwon, Keoseong Park, Jaemyung Lee, Jieon Seol
On 2021-03-23 13:37, Daejun Park wrote:
>> On 2021-03-23 12:22, Can Guo wrote:
>>> On 2021-03-22 17:11, Bean Huo wrote:
>>>> On Mon, 2021-03-22 at 15:54 +0900, Daejun Park wrote:
>>>>> + switch (rsp_field->hpb_op) {
>>>>>
>>>>> + case HPB_RSP_REQ_REGION_UPDATE:
>>>>>
>>>>> + if (data_seg_len != DEV_DATA_SEG_LEN)
>>>>>
>>>>> + dev_warn(&hpb->sdev_ufs_lu->sdev_dev,
>>>>>
>>>>> + "%s: data seg length is not
>>>>> same.\n",
>>>>>
>>>>> + __func__);
>>>>>
>>>>> + 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;
>>>>
>>>> Hi Deajun,
>>>> This series looks good to me. Just here I have one question. You
>>>> didn't
>>>> handle HPB_RSP_DEV_RESET, just a warning. Based on your SS UFS, how
>>>> to
>>>> handle HPB_RSP_DEV_RESET from the host side? Do you think we shoud
>>>> reset host side HPB entry as well or what else?
>>>>
>>>>
>>>> Bean
>>>
>>> Same question here - I am still collecting feedbacks from flash
>>> vendors
>>> about
>>> what is recommanded host behavior on reception of HPB Op code 0x2,
>>> since it
>>> is not cleared defined in HPB2.0 specs.
>>>
>>> Can Guo.
>>
>> I think the question should be asked in the HPB2.0 patch, since in
>> HPB1.0 device
>> control mode, a HPB reset in device side does not impact anything in
>> host side -
>> host is not writing back any HPB entries to device anyways and HPB
>> Read
>> cmd with
>> invalid HPB entries shall be treated as normal Read(10) cmd without
>> any
>> problems.
>
> Yes, UFS device will process read command even the HPB entries are
> valid or
> not. So it is warning about read performance drop by dev reset.
Yeah, but still I am 100% sure about what should host do in case of
HPB2.0
when it receives HPB Op code 0x2, I am waiting for feedbacks.
Thanks,
Can Guo.
>
> Thanks,
> Daejun
>
>> Please correct me if I am wrong.
>
>
>
>> Thanks,
>> Can Guo.
>>
>>
>>
^ permalink raw reply [flat|nested] 26+ messages in thread* RE: Re: [PATCH v31 2/4] scsi: ufs: L2P map management for HPB read
2021-03-23 6:07 ` Can Guo
@ 2021-03-23 6:19 ` Daejun Park
2021-03-23 6:26 ` Can Guo
0 siblings, 1 reply; 26+ messages in thread
From: Daejun Park @ 2021-03-23 6:19 UTC (permalink / raw)
To: Can Guo, Daejun Park
Cc: Bean Huo, Greg KH, avri.altman@wdc.com, jejb@linux.ibm.com,
martin.petersen@oracle.com, asutoshd@codeaurora.org,
stanley.chu@mediatek.com, bvanassche@acm.org,
linux-scsi@vger.kernel.org, linux-kernel@vger.kernel.org,
ALIM AKHTAR, JinHwan Park, Javier Gonzalez, Sung-Jun Park,
Jinyoung CHOI, Dukhyun Kwon, Keoseong Park, Jaemyung Lee,
Jieon Seol
>On 2021-03-23 13:37, Daejun Park wrote:
>>> On 2021-03-23 12:22, Can Guo wrote:
>>>> On 2021-03-22 17:11, Bean Huo wrote:
>>>>> On Mon, 2021-03-22 at 15:54 +0900, Daejun Park wrote:
>>>>>> + switch (rsp_field->hpb_op) {
>>>>>>
>>>>>> + case HPB_RSP_REQ_REGION_UPDATE:
>>>>>>
>>>>>> + if (data_seg_len != DEV_DATA_SEG_LEN)
>>>>>>
>>>>>> + dev_warn(&hpb->sdev_ufs_lu->sdev_dev,
>>>>>>
>>>>>> + "%s: data seg length is not
>>>>>> same.\n",
>>>>>>
>>>>>> + __func__);
>>>>>>
>>>>>> + 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;
>>>>>
>>>>> Hi Deajun,
>>>>> This series looks good to me. Just here I have one question. You
>>>>> didn't
>>>>> handle HPB_RSP_DEV_RESET, just a warning. Based on your SS UFS, how
>>>>> to
>>>>> handle HPB_RSP_DEV_RESET from the host side? Do you think we shoud
>>>>> reset host side HPB entry as well or what else?
>>>>>
>>>>>
>>>>> Bean
>>>>
>>>> Same question here - I am still collecting feedbacks from flash
>>>> vendors
>>>> about
>>>> what is recommanded host behavior on reception of HPB Op code 0x2,
>>>> since it
>>>> is not cleared defined in HPB2.0 specs.
>>>>
>>>> Can Guo.
>>>
>>> I think the question should be asked in the HPB2.0 patch, since in
>>> HPB1.0 device
>>> control mode, a HPB reset in device side does not impact anything in
>>> host side -
>>> host is not writing back any HPB entries to device anyways and HPB
>>> Read
>>> cmd with
>>> invalid HPB entries shall be treated as normal Read(10) cmd without
>>> any
>>> problems.
>>
>> Yes, UFS device will process read command even the HPB entries are
>> valid or
>> not. So it is warning about read performance drop by dev reset.
>
>Yeah, but still I am 100% sure about what should host do in case of
>HPB2.0
>when it receives HPB Op code 0x2, I am waiting for feedbacks.
I think the host has two choices when it receives 0x2.
One is nothing on host.
The other is discarding all HPB entries in the host.
In the JEDEC HPB spec, it as follows:
When the device is powered off by the host, the device may restore L2P map
data upon power up or build from the host’s HPB READ command.
If some UFS builds L2P map data from the host's HPB READ commands, we don't
have to discard HPB entries in the host.
So I thinks there is nothing to do when it receives 0x2.
Thanks,
Daejun
>Thanks,
>Can Guo.
>
>>
>> Thanks,
>> Daejun
>>
>>> Please correct me if I am wrong.
>>
>>
>>
>>> Thanks,
>>> Can Guo.
>>>
>>>
>>>
>
>
>
^ permalink raw reply [flat|nested] 26+ messages in thread* Re: [PATCH v31 2/4] scsi: ufs: L2P map management for HPB read
2021-03-23 6:19 ` Daejun Park
@ 2021-03-23 6:26 ` Can Guo
2021-03-23 6:37 ` Daejun Park
0 siblings, 1 reply; 26+ messages in thread
From: Can Guo @ 2021-03-23 6:26 UTC (permalink / raw)
To: daejun7.park
Cc: Bean Huo, Greg KH, avri.altman, jejb, martin.petersen, asutoshd,
stanley.chu, bvanassche, linux-scsi, linux-kernel, ALIM AKHTAR,
JinHwan Park, Javier Gonzalez, Sung-Jun Park, Jinyoung CHOI,
Dukhyun Kwon, Keoseong Park, Jaemyung Lee, Jieon Seol
On 2021-03-23 14:19, Daejun Park wrote:
>> On 2021-03-23 13:37, Daejun Park wrote:
>>>> On 2021-03-23 12:22, Can Guo wrote:
>>>>> On 2021-03-22 17:11, Bean Huo wrote:
>>>>>> On Mon, 2021-03-22 at 15:54 +0900, Daejun Park wrote:
>>>>>>> + switch (rsp_field->hpb_op) {
>>>>>>>
>>>>>>> + case HPB_RSP_REQ_REGION_UPDATE:
>>>>>>>
>>>>>>> + if (data_seg_len != DEV_DATA_SEG_LEN)
>>>>>>>
>>>>>>> + dev_warn(&hpb->sdev_ufs_lu->sdev_dev,
>>>>>>>
>>>>>>> + "%s: data seg length is not
>>>>>>> same.\n",
>>>>>>>
>>>>>>> + __func__);
>>>>>>>
>>>>>>> + 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;
>>>>>>
>>>>>> Hi Deajun,
>>>>>> This series looks good to me. Just here I have one question. You
>>>>>> didn't
>>>>>> handle HPB_RSP_DEV_RESET, just a warning. Based on your SS UFS,
>>>>>> how
>>>>>> to
>>>>>> handle HPB_RSP_DEV_RESET from the host side? Do you think we shoud
>>>>>> reset host side HPB entry as well or what else?
>>>>>>
>>>>>>
>>>>>> Bean
>>>>>
>>>>> Same question here - I am still collecting feedbacks from flash
>>>>> vendors
>>>>> about
>>>>> what is recommanded host behavior on reception of HPB Op code 0x2,
>>>>> since it
>>>>> is not cleared defined in HPB2.0 specs.
>>>>>
>>>>> Can Guo.
>>>>
>>>> I think the question should be asked in the HPB2.0 patch, since in
>>>> HPB1.0 device
>>>> control mode, a HPB reset in device side does not impact anything in
>>>> host side -
>>>> host is not writing back any HPB entries to device anyways and HPB
>>>> Read
>>>> cmd with
>>>> invalid HPB entries shall be treated as normal Read(10) cmd without
>>>> any
>>>> problems.
>>>
>>> Yes, UFS device will process read command even the HPB entries are
>>> valid or
>>> not. So it is warning about read performance drop by dev reset.
>>
>> Yeah, but still I am 100% sure about what should host do in case of
>> HPB2.0
>> when it receives HPB Op code 0x2, I am waiting for feedbacks.
>
> I think the host has two choices when it receives 0x2.
> One is nothing on host.
> The other is discarding all HPB entries in the host.
>
> In the JEDEC HPB spec, it as follows:
> When the device is powered off by the host, the device may restore L2P
> map
> data upon power up or build from the host’s HPB READ command.
>
> If some UFS builds L2P map data from the host's HPB READ commands, we
> don't
> have to discard HPB entries in the host.
>
> So I thinks there is nothing to do when it receives 0x2.
But in HPB2.0, if we do nothing to active regions in host side, host can
write
HPB entries (which host thinks valid, but actually invalid in device
side since
reset happened) back to device through HPB Write Buffer cmds (BUFFER ID
= 0x2).
My question is that are all UFSs OK with this?
Thanks,
Can Guo.
>
> Thanks,
> Daejun
>
>> Thanks,
>> Can Guo.
>>
>>>
>>> Thanks,
>>> Daejun
>>>
>>>> Please correct me if I am wrong.
>>>
>>>
>>>
>>>> Thanks,
>>>> Can Guo.
>>>>
>>>>
>>>>
>>
>>
>>
^ permalink raw reply [flat|nested] 26+ messages in thread* RE: Re: [PATCH v31 2/4] scsi: ufs: L2P map management for HPB read
2021-03-23 6:26 ` Can Guo
@ 2021-03-23 6:37 ` Daejun Park
2021-03-23 6:47 ` Can Guo
0 siblings, 1 reply; 26+ messages in thread
From: Daejun Park @ 2021-03-23 6:37 UTC (permalink / raw)
To: Can Guo, Daejun Park
Cc: Bean Huo, Greg KH, avri.altman@wdc.com, jejb@linux.ibm.com,
martin.petersen@oracle.com, asutoshd@codeaurora.org,
stanley.chu@mediatek.com, bvanassche@acm.org,
linux-scsi@vger.kernel.org, linux-kernel@vger.kernel.org,
ALIM AKHTAR, JinHwan Park, Javier Gonzalez, Sung-Jun Park,
Jinyoung CHOI, Dukhyun Kwon, Keoseong Park, Jaemyung Lee,
Jieon Seol
>On 2021-03-23 14:19, Daejun Park wrote:
>>> On 2021-03-23 13:37, Daejun Park wrote:
>>>>> On 2021-03-23 12:22, Can Guo wrote:
>>>>>> On 2021-03-22 17:11, Bean Huo wrote:
>>>>>>> On Mon, 2021-03-22 at 15:54 +0900, Daejun Park wrote:
>>>>>>>> + switch (rsp_field->hpb_op) {
>>>>>>>>
>>>>>>>> + case HPB_RSP_REQ_REGION_UPDATE:
>>>>>>>>
>>>>>>>> + if (data_seg_len != DEV_DATA_SEG_LEN)
>>>>>>>>
>>>>>>>> + dev_warn(&hpb->sdev_ufs_lu->sdev_dev,
>>>>>>>>
>>>>>>>> + "%s: data seg length is not
>>>>>>>> same.\n",
>>>>>>>>
>>>>>>>> + __func__);
>>>>>>>>
>>>>>>>> + 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;
>>>>>>>
>>>>>>> Hi Deajun,
>>>>>>> This series looks good to me. Just here I have one question. You
>>>>>>> didn't
>>>>>>> handle HPB_RSP_DEV_RESET, just a warning. Based on your SS UFS,
>>>>>>> how
>>>>>>> to
>>>>>>> handle HPB_RSP_DEV_RESET from the host side? Do you think we shoud
>>>>>>> reset host side HPB entry as well or what else?
>>>>>>>
>>>>>>>
>>>>>>> Bean
>>>>>>
>>>>>> Same question here - I am still collecting feedbacks from flash
>>>>>> vendors
>>>>>> about
>>>>>> what is recommanded host behavior on reception of HPB Op code 0x2,
>>>>>> since it
>>>>>> is not cleared defined in HPB2.0 specs.
>>>>>>
>>>>>> Can Guo.
>>>>>
>>>>> I think the question should be asked in the HPB2.0 patch, since in
>>>>> HPB1.0 device
>>>>> control mode, a HPB reset in device side does not impact anything in
>>>>> host side -
>>>>> host is not writing back any HPB entries to device anyways and HPB
>>>>> Read
>>>>> cmd with
>>>>> invalid HPB entries shall be treated as normal Read(10) cmd without
>>>>> any
>>>>> problems.
>>>>
>>>> Yes, UFS device will process read command even the HPB entries are
>>>> valid or
>>>> not. So it is warning about read performance drop by dev reset.
>>>
>>> Yeah, but still I am 100% sure about what should host do in case of
>>> HPB2.0
>>> when it receives HPB Op code 0x2, I am waiting for feedbacks.
>>
>> I think the host has two choices when it receives 0x2.
>> One is nothing on host.
>> The other is discarding all HPB entries in the host.
>>
>> In the JEDEC HPB spec, it as follows:
>> When the device is powered off by the host, the device may restore L2P
>> map
>> data upon power up or build from the host’s HPB READ command.
>>
>> If some UFS builds L2P map data from the host's HPB READ commands, we
>> don't
>> have to discard HPB entries in the host.
>>
>> So I thinks there is nothing to do when it receives 0x2.
>
>But in HPB2.0, if we do nothing to active regions in host side, host can
>write
>HPB entries (which host thinks valid, but actually invalid in device
>side since
>reset happened) back to device through HPB Write Buffer cmds (BUFFER ID
>= 0x2).
>My question is that are all UFSs OK with this?
Yes, it must be OK.
Please refer the following the HPB 2.0 spec:
If the HPB Entries sent by HPB WRITE BUFFER are removed by the device,
for example, because they are not consumed for a long enough period of time,
then the HPB READ command for the removed HPB entries shall be handled as a
normal READ command.
Thanks,
Daejun
>Thanks,
>Can Guo.
>
>>
>> Thanks,
>> Daejun
>>
>>> Thanks,
>>> Can Guo.
>>>
>>>>
>>>> Thanks,
>>>> Daejun
>>>>
>>>>> Please correct me if I am wrong.
>>>>
>>>>
>>>>
>>>>> Thanks,
>>>>> Can Guo.
>>>>>
>>>>>
>>>>>
>>>
>>>
>>>
>
>
>
^ permalink raw reply [flat|nested] 26+ messages in thread* Re: [PATCH v31 2/4] scsi: ufs: L2P map management for HPB read
2021-03-23 6:37 ` Daejun Park
@ 2021-03-23 6:47 ` Can Guo
2021-03-23 12:48 ` Avri Altman
0 siblings, 1 reply; 26+ messages in thread
From: Can Guo @ 2021-03-23 6:47 UTC (permalink / raw)
To: daejun7.park
Cc: Bean Huo, Greg KH, avri.altman, jejb, martin.petersen, asutoshd,
stanley.chu, bvanassche, linux-scsi, linux-kernel, ALIM AKHTAR,
JinHwan Park, Javier Gonzalez, Sung-Jun Park, Jinyoung CHOI,
Dukhyun Kwon, Keoseong Park, Jaemyung Lee, Jieon Seol
On 2021-03-23 14:37, Daejun Park wrote:
>> On 2021-03-23 14:19, Daejun Park wrote:
>>>> On 2021-03-23 13:37, Daejun Park wrote:
>>>>>> On 2021-03-23 12:22, Can Guo wrote:
>>>>>>> On 2021-03-22 17:11, Bean Huo wrote:
>>>>>>>> On Mon, 2021-03-22 at 15:54 +0900, Daejun Park wrote:
>>>>>>>>> + switch (rsp_field->hpb_op) {
>>>>>>>>>
>>>>>>>>> + case HPB_RSP_REQ_REGION_UPDATE:
>>>>>>>>>
>>>>>>>>> + if (data_seg_len != DEV_DATA_SEG_LEN)
>>>>>>>>>
>>>>>>>>> + dev_warn(&hpb->sdev_ufs_lu->sdev_dev,
>>>>>>>>>
>>>>>>>>> + "%s: data seg length is not
>>>>>>>>> same.\n",
>>>>>>>>>
>>>>>>>>> + __func__);
>>>>>>>>>
>>>>>>>>> + 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;
>>>>>>>>
>>>>>>>> Hi Deajun,
>>>>>>>> This series looks good to me. Just here I have one question. You
>>>>>>>> didn't
>>>>>>>> handle HPB_RSP_DEV_RESET, just a warning. Based on your SS UFS,
>>>>>>>> how
>>>>>>>> to
>>>>>>>> handle HPB_RSP_DEV_RESET from the host side? Do you think we
>>>>>>>> shoud
>>>>>>>> reset host side HPB entry as well or what else?
>>>>>>>>
>>>>>>>>
>>>>>>>> Bean
>>>>>>>
>>>>>>> Same question here - I am still collecting feedbacks from flash
>>>>>>> vendors
>>>>>>> about
>>>>>>> what is recommanded host behavior on reception of HPB Op code
>>>>>>> 0x2,
>>>>>>> since it
>>>>>>> is not cleared defined in HPB2.0 specs.
>>>>>>>
>>>>>>> Can Guo.
>>>>>>
>>>>>> I think the question should be asked in the HPB2.0 patch, since in
>>>>>> HPB1.0 device
>>>>>> control mode, a HPB reset in device side does not impact anything
>>>>>> in
>>>>>> host side -
>>>>>> host is not writing back any HPB entries to device anyways and HPB
>>>>>> Read
>>>>>> cmd with
>>>>>> invalid HPB entries shall be treated as normal Read(10) cmd
>>>>>> without
>>>>>> any
>>>>>> problems.
>>>>>
>>>>> Yes, UFS device will process read command even the HPB entries are
>>>>> valid or
>>>>> not. So it is warning about read performance drop by dev reset.
>>>>
>>>> Yeah, but still I am 100% sure about what should host do in case of
>>>> HPB2.0
>>>> when it receives HPB Op code 0x2, I am waiting for feedbacks.
>>>
>>> I think the host has two choices when it receives 0x2.
>>> One is nothing on host.
>>> The other is discarding all HPB entries in the host.
>>>
>>> In the JEDEC HPB spec, it as follows:
>>> When the device is powered off by the host, the device may restore
>>> L2P
>>> map
>>> data upon power up or build from the host’s HPB READ command.
>>>
>>> If some UFS builds L2P map data from the host's HPB READ commands, we
>>> don't
>>> have to discard HPB entries in the host.
>>>
>>> So I thinks there is nothing to do when it receives 0x2.
>>
>> But in HPB2.0, if we do nothing to active regions in host side, host
>> can
>> write
>> HPB entries (which host thinks valid, but actually invalid in device
>> side since
>> reset happened) back to device through HPB Write Buffer cmds (BUFFER
>> ID
>> = 0x2).
>> My question is that are all UFSs OK with this?
>
> Yes, it must be OK.
>
> Please refer the following the HPB 2.0 spec:
>
> If the HPB Entries sent by HPB WRITE BUFFER are removed by the device,
> for example, because they are not consumed for a long enough period of
> time,
> then the HPB READ command for the removed HPB entries shall be handled
> as a
> normal READ command.
>
No, it is talking about the subsequent HPB READ cmd sent after a HPB
WRITE BUFFER cmd,
but not the HPB WRITE BUFFER cmd itself...
Thanks,
Can Guo.
> Thanks,
> Daejun
>
>> Thanks,
>> Can Guo.
>>
>>>
>>> Thanks,
>>> Daejun
>>>
>>>> Thanks,
>>>> Can Guo.
>>>>
>>>>>
>>>>> Thanks,
>>>>> Daejun
>>>>>
>>>>>> Please correct me if I am wrong.
>>>>>
>>>>>
>>>>>
>>>>>> Thanks,
>>>>>> Can Guo.
>>>>>>
>>>>>>
>>>>>>
>>>>
>>>>
>>>>
>>
>>
>>
^ permalink raw reply [flat|nested] 26+ messages in thread* RE: [PATCH v31 2/4] scsi: ufs: L2P map management for HPB read
2021-03-23 6:47 ` Can Guo
@ 2021-03-23 12:48 ` Avri Altman
2021-03-24 1:45 ` Can Guo
0 siblings, 1 reply; 26+ messages in thread
From: Avri Altman @ 2021-03-23 12:48 UTC (permalink / raw)
To: Can Guo, daejun7.park@samsung.com
Cc: Bean Huo, Greg KH, jejb@linux.ibm.com, martin.petersen@oracle.com,
asutoshd@codeaurora.org, stanley.chu@mediatek.com,
bvanassche@acm.org, linux-scsi@vger.kernel.org,
linux-kernel@vger.kernel.org, ALIM AKHTAR, JinHwan Park,
Javier Gonzalez, Sung-Jun Park, Jinyoung CHOI, Dukhyun Kwon,
Keoseong Park, Jaemyung Lee, Jieon Seol
>
> On 2021-03-23 14:37, Daejun Park wrote:
> >> On 2021-03-23 14:19, Daejun Park wrote:
> >>>> On 2021-03-23 13:37, Daejun Park wrote:
> >>>>>> On 2021-03-23 12:22, Can Guo wrote:
> >>>>>>> On 2021-03-22 17:11, Bean Huo wrote:
> >>>>>>>> On Mon, 2021-03-22 at 15:54 +0900, Daejun Park wrote:
> >>>>>>>>> + switch (rsp_field->hpb_op) {
> >>>>>>>>>
> >>>>>>>>> + case HPB_RSP_REQ_REGION_UPDATE:
> >>>>>>>>>
> >>>>>>>>> + if (data_seg_len != DEV_DATA_SEG_LEN)
> >>>>>>>>>
> >>>>>>>>> + dev_warn(&hpb->sdev_ufs_lu->sdev_dev,
> >>>>>>>>>
> >>>>>>>>> + "%s: data seg length is not
> >>>>>>>>> same.\n",
> >>>>>>>>>
> >>>>>>>>> + __func__);
> >>>>>>>>>
> >>>>>>>>> + 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;
> >>>>>>>>
> >>>>>>>> Hi Deajun,
> >>>>>>>> This series looks good to me. Just here I have one question. You
> >>>>>>>> didn't
> >>>>>>>> handle HPB_RSP_DEV_RESET, just a warning. Based on your SS UFS,
> >>>>>>>> how
> >>>>>>>> to
> >>>>>>>> handle HPB_RSP_DEV_RESET from the host side? Do you think we
> >>>>>>>> shoud
> >>>>>>>> reset host side HPB entry as well or what else?
> >>>>>>>>
> >>>>>>>>
> >>>>>>>> Bean
> >>>>>>>
> >>>>>>> Same question here - I am still collecting feedbacks from flash
> >>>>>>> vendors
> >>>>>>> about
> >>>>>>> what is recommanded host behavior on reception of HPB Op code
> >>>>>>> 0x2,
> >>>>>>> since it
> >>>>>>> is not cleared defined in HPB2.0 specs.
> >>>>>>>
> >>>>>>> Can Guo.
> >>>>>>
> >>>>>> I think the question should be asked in the HPB2.0 patch, since in
> >>>>>> HPB1.0 device
> >>>>>> control mode, a HPB reset in device side does not impact anything
> >>>>>> in
> >>>>>> host side -
> >>>>>> host is not writing back any HPB entries to device anyways and HPB
> >>>>>> Read
> >>>>>> cmd with
> >>>>>> invalid HPB entries shall be treated as normal Read(10) cmd
> >>>>>> without
> >>>>>> any
> >>>>>> problems.
> >>>>>
> >>>>> Yes, UFS device will process read command even the HPB entries are
> >>>>> valid or
> >>>>> not. So it is warning about read performance drop by dev reset.
> >>>>
> >>>> Yeah, but still I am 100% sure about what should host do in case of
> >>>> HPB2.0
> >>>> when it receives HPB Op code 0x2, I am waiting for feedbacks.
> >>>
> >>> I think the host has two choices when it receives 0x2.
> >>> One is nothing on host.
> >>> The other is discarding all HPB entries in the host.
> >>>
> >>> In the JEDEC HPB spec, it as follows:
> >>> When the device is powered off by the host, the device may restore
> >>> L2P
> >>> map
> >>> data upon power up or build from the host’s HPB READ command.
> >>>
> >>> If some UFS builds L2P map data from the host's HPB READ commands, we
> >>> don't
> >>> have to discard HPB entries in the host.
> >>>
> >>> So I thinks there is nothing to do when it receives 0x2.
> >>
> >> But in HPB2.0, if we do nothing to active regions in host side, host
> >> can
> >> write
> >> HPB entries (which host thinks valid, but actually invalid in device
> >> side since
> >> reset happened) back to device through HPB Write Buffer cmds (BUFFER
> >> ID
> >> = 0x2).
> >> My question is that are all UFSs OK with this?
> >
> > Yes, it must be OK.
> >
> > Please refer the following the HPB 2.0 spec:
> >
> > If the HPB Entries sent by HPB WRITE BUFFER are removed by the device,
> > for example, because they are not consumed for a long enough period of
> > time,
> > then the HPB READ command for the removed HPB entries shall be handled
> > as a
> > normal READ command.
> >
>
> No, it is talking about the subsequent HPB READ cmd sent after a HPB
> WRITE BUFFER cmd,
> but not the HPB WRITE BUFFER cmd itself...
Looks like this discussion is going the same way as we had in host mode.
HPB-WRITE-BUFFER 0x2, if exist, is always a companion to HPB-READ.
You shouldn't consider them separately.
The device is expected to handle invalid ppn by itself, and specifically for this case,
As Daejun explained, Handle each HPB-READ (and its companion HPB-WRITE-BUFFER) like READ10.
For device mode, doing nothing in case of dev reset, seems to me like the right thing to do.
Thanks,
Avri
>
> Thanks,
> Can Guo.
>
> > Thanks,
> > Daejun
> >
> >> Thanks,
> >> Can Guo.
> >>
> >>>
> >>> Thanks,
> >>> Daejun
> >>>
> >>>> Thanks,
> >>>> Can Guo.
> >>>>
> >>>>>
> >>>>> Thanks,
> >>>>> Daejun
> >>>>>
> >>>>>> Please correct me if I am wrong.
> >>>>>
> >>>>>
> >>>>>
> >>>>>> Thanks,
> >>>>>> Can Guo.
> >>>>>>
> >>>>>>
> >>>>>>
> >>>>
> >>>>
> >>>>
> >>
> >>
> >>
^ permalink raw reply [flat|nested] 26+ messages in thread* Re: [PATCH v31 2/4] scsi: ufs: L2P map management for HPB read
2021-03-23 12:48 ` Avri Altman
@ 2021-03-24 1:45 ` Can Guo
2021-03-24 8:37 ` Bean Huo
0 siblings, 1 reply; 26+ messages in thread
From: Can Guo @ 2021-03-24 1:45 UTC (permalink / raw)
To: Avri Altman
Cc: daejun7.park, Bean Huo, Greg KH, jejb, martin.petersen, asutoshd,
stanley.chu, bvanassche, linux-scsi, linux-kernel, ALIM AKHTAR,
JinHwan Park, Javier Gonzalez, Sung-Jun Park, Jinyoung CHOI,
Dukhyun Kwon, Keoseong Park, Jaemyung Lee, Jieon Seol
On 2021-03-23 20:48, Avri Altman wrote:
>>
>> On 2021-03-23 14:37, Daejun Park wrote:
>> >> On 2021-03-23 14:19, Daejun Park wrote:
>> >>>> On 2021-03-23 13:37, Daejun Park wrote:
>> >>>>>> On 2021-03-23 12:22, Can Guo wrote:
>> >>>>>>> On 2021-03-22 17:11, Bean Huo wrote:
>> >>>>>>>> On Mon, 2021-03-22 at 15:54 +0900, Daejun Park wrote:
>> >>>>>>>>> + switch (rsp_field->hpb_op) {
>> >>>>>>>>>
>> >>>>>>>>> + case HPB_RSP_REQ_REGION_UPDATE:
>> >>>>>>>>>
>> >>>>>>>>> + if (data_seg_len != DEV_DATA_SEG_LEN)
>> >>>>>>>>>
>> >>>>>>>>> + dev_warn(&hpb->sdev_ufs_lu->sdev_dev,
>> >>>>>>>>>
>> >>>>>>>>> + "%s: data seg length is not
>> >>>>>>>>> same.\n",
>> >>>>>>>>>
>> >>>>>>>>> + __func__);
>> >>>>>>>>>
>> >>>>>>>>> + 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;
>> >>>>>>>>
>> >>>>>>>> Hi Deajun,
>> >>>>>>>> This series looks good to me. Just here I have one question. You
>> >>>>>>>> didn't
>> >>>>>>>> handle HPB_RSP_DEV_RESET, just a warning. Based on your SS UFS,
>> >>>>>>>> how
>> >>>>>>>> to
>> >>>>>>>> handle HPB_RSP_DEV_RESET from the host side? Do you think we
>> >>>>>>>> shoud
>> >>>>>>>> reset host side HPB entry as well or what else?
>> >>>>>>>>
>> >>>>>>>>
>> >>>>>>>> Bean
>> >>>>>>>
>> >>>>>>> Same question here - I am still collecting feedbacks from flash
>> >>>>>>> vendors
>> >>>>>>> about
>> >>>>>>> what is recommanded host behavior on reception of HPB Op code
>> >>>>>>> 0x2,
>> >>>>>>> since it
>> >>>>>>> is not cleared defined in HPB2.0 specs.
>> >>>>>>>
>> >>>>>>> Can Guo.
>> >>>>>>
>> >>>>>> I think the question should be asked in the HPB2.0 patch, since in
>> >>>>>> HPB1.0 device
>> >>>>>> control mode, a HPB reset in device side does not impact anything
>> >>>>>> in
>> >>>>>> host side -
>> >>>>>> host is not writing back any HPB entries to device anyways and HPB
>> >>>>>> Read
>> >>>>>> cmd with
>> >>>>>> invalid HPB entries shall be treated as normal Read(10) cmd
>> >>>>>> without
>> >>>>>> any
>> >>>>>> problems.
>> >>>>>
>> >>>>> Yes, UFS device will process read command even the HPB entries are
>> >>>>> valid or
>> >>>>> not. So it is warning about read performance drop by dev reset.
>> >>>>
>> >>>> Yeah, but still I am 100% sure about what should host do in case of
>> >>>> HPB2.0
>> >>>> when it receives HPB Op code 0x2, I am waiting for feedbacks.
>> >>>
>> >>> I think the host has two choices when it receives 0x2.
>> >>> One is nothing on host.
>> >>> The other is discarding all HPB entries in the host.
>> >>>
>> >>> In the JEDEC HPB spec, it as follows:
>> >>> When the device is powered off by the host, the device may restore
>> >>> L2P
>> >>> map
>> >>> data upon power up or build from the host’s HPB READ command.
>> >>>
>> >>> If some UFS builds L2P map data from the host's HPB READ commands, we
>> >>> don't
>> >>> have to discard HPB entries in the host.
>> >>>
>> >>> So I thinks there is nothing to do when it receives 0x2.
>> >>
>> >> But in HPB2.0, if we do nothing to active regions in host side, host
>> >> can
>> >> write
>> >> HPB entries (which host thinks valid, but actually invalid in device
>> >> side since
>> >> reset happened) back to device through HPB Write Buffer cmds (BUFFER
>> >> ID
>> >> = 0x2).
>> >> My question is that are all UFSs OK with this?
>> >
>> > Yes, it must be OK.
>> >
>> > Please refer the following the HPB 2.0 spec:
>> >
>> > If the HPB Entries sent by HPB WRITE BUFFER are removed by the device,
>> > for example, because they are not consumed for a long enough period of
>> > time,
>> > then the HPB READ command for the removed HPB entries shall be handled
>> > as a
>> > normal READ command.
>> >
>>
>> No, it is talking about the subsequent HPB READ cmd sent after a HPB
>> WRITE BUFFER cmd,
>> but not the HPB WRITE BUFFER cmd itself...
> Looks like this discussion is going the same way as we had in host
> mode.
> HPB-WRITE-BUFFER 0x2, if exist, is always a companion to HPB-READ.
> You shouldn't consider them separately.
>
> The device is expected to handle invalid ppn by itself, and
> specifically for this case,
> As Daejun explained, Handle each HPB-READ (and its companion
> HPB-WRITE-BUFFER) like READ10.
>
> For device mode, doing nothing in case of dev reset, seems to me like
> the right thing to do.
I just got some feedbacks from other flash vendors, they all commit that
their devices can work well in this scenario [1]. Some of them proposed
even complicated (maybe better) principles of handling the "HPB reset",
but since the device works well in [1], I am OK with current (simpler)
handling of "HPB reset" - in device mode doing nothing, in host mode
re-activate regions that host is trying to do a read to.
Thanks,
Can Guo.
>
> Thanks,
> Avri
>
>>
>> Thanks,
>> Can Guo.
>>
>> > Thanks,
>> > Daejun
>> >
>> >> Thanks,
>> >> Can Guo.
>> >>
>> >>>
>> >>> Thanks,
>> >>> Daejun
>> >>>
>> >>>> Thanks,
>> >>>> Can Guo.
>> >>>>
>> >>>>>
>> >>>>> Thanks,
>> >>>>> Daejun
>> >>>>>
>> >>>>>> Please correct me if I am wrong.
>> >>>>>
>> >>>>>
>> >>>>>
>> >>>>>> Thanks,
>> >>>>>> Can Guo.
>> >>>>>>
>> >>>>>>
>> >>>>>>
>> >>>>
>> >>>>
>> >>>>
>> >>
>> >>
>> >>
^ permalink raw reply [flat|nested] 26+ messages in thread* Re: [PATCH v31 2/4] scsi: ufs: L2P map management for HPB read
2021-03-24 1:45 ` Can Guo
@ 2021-03-24 8:37 ` Bean Huo
2021-03-24 9:24 ` Can Guo
0 siblings, 1 reply; 26+ messages in thread
From: Bean Huo @ 2021-03-24 8:37 UTC (permalink / raw)
To: Can Guo, Avri Altman
Cc: daejun7.park, Greg KH, jejb, martin.petersen, asutoshd,
stanley.chu, bvanassche, linux-scsi, linux-kernel, ALIM AKHTAR,
JinHwan Park, Javier Gonzalez, Sung-Jun Park, Jinyoung CHOI,
Dukhyun Kwon, Keoseong Park, Jaemyung Lee, Jieon Seol
On Wed, 2021-03-24 at 09:45 +0800, Can Guo wrote:
> On 2021-03-23 20:48, Avri Altman wrote:
>
> > > On 2021-03-23 14:37, Daejun Park wrote:
> > > > > On 2021-03-23 14:19, Daejun Park wrote:
> > > > > > > On 2021-03-23 13:37, Daejun Park wrote:
> > > > > > > > > On 2021-03-23 12:22, Can Guo wrote:
> > > > > > > > > > On 2021-03-22 17:11, Bean Huo wrote:
> > > > > > > > > > > On Mon, 2021-03-22 at 15:54 +0900, Daejun Park
> > > > > > > > > > > wrote:
> > > > > > > > > > > > + switch (rsp_field->hpb_op) {
> > > > > > > > > > > > + case HPB_RSP_REQ_REGION_UPDATE:
> > > > > > > > > > > > + if (data_seg_len !=
> > > > > > > > > > > > DEV_DATA_SEG_LEN)
> > > > > > > > > > > > + dev_warn(&hpb-
> > > > > > > > > > > > >sdev_ufs_lu->sdev_dev,
> > > > > > > > > > > > + "%s: data seg
> > > > > > > > > > > > length is not
> > > > > > > > > > > > same.\n",
> > > > > > > > > > > > + __func__);
> > > > > > > > > > > > +
> > > > > > > > > > > > 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;
> > > > > > > > > > > Hi Deajun,
> > > > > > > > > > > This series looks good to me. Just here I have
> > > > > > > > > > > one question. You
> > > > > > > > > > > didn't
> > > > > > > > > > > handle HPB_RSP_DEV_RESET, just a warning. Based
> > > > > > > > > > > on your SS UFS,
> > > > > > > > > > > how
> > > > > > > > > > > to
> > > > > > > > > > > handle HPB_RSP_DEV_RESET from the host side? Do
> > > > > > > > > > > you think we
> > > > > > > > > > > shoud
> > > > > > > > > > > reset host side HPB entry as well or what else?
> > > > > > > > > > > Bean
> > > > > > > > > > Same question here - I am still collecting
> > > > > > > > > > feedbacks from flash
> > > > > > > > > > vendors
> > > > > > > > > > about
> > > > > > > > > > what is recommanded host behavior on reception of
> > > > > > > > > > HPB Op code
> > > > > > > > > > 0x2,
> > > > > > > > > > since it
> > > > > > > > > > is not cleared defined in HPB2.0 specs.
> > > > > > > > > > Can Guo.
> > > > > > > > > I think the question should be asked in the HPB2.0
> > > > > > > > > patch, since in
> > > > > > > > > HPB1.0 device
> > > > > > > > > control mode, a HPB reset in device side does not
> > > > > > > > > impact anything
> > > > > > > > > in
> > > > > > > > > host side -
> > > > > > > > > host is not writing back any HPB entries to device
> > > > > > > > > anyways and HPB
> > > > > > > > > Read
> > > > > > > > > cmd with
> > > > > > > > > invalid HPB entries shall be treated as normal
> > > > > > > > > Read(10) cmd
> > > > > > > > > without
> > > > > > > > > any
> > > > > > > > > problems.
> > > > > > > > Yes, UFS device will process read command even the HPB
> > > > > > > > entries are
> > > > > > > > valid or
> > > > > > > > not. So it is warning about read performance drop by
> > > > > > > > dev reset.
> > > > > > > Yeah, but still I am 100% sure about what should host do
> > > > > > > in case of
> > > > > > > HPB2.0
> > > > > > > when it receives HPB Op code 0x2, I am waiting for
> > > > > > > feedbacks.
> > > > > > I think the host has two choices when it receives 0x2.
> > > > > > One is nothing on host.
> > > > > > The other is discarding all HPB entries in the host.
> > > > > > In the JEDEC HPB spec, it as follows:
> > > > > > When the device is powered off by the host, the device may
> > > > > > restore
> > > > > > L2P
> > > > > > map
> > > > > > data upon power up or build from the host’s HPB READ
> > > > > > command.
> > > > > > If some UFS builds L2P map data from the host's HPB READ
> > > > > > commands, we
> > > > > > don't
> > > > > > have to discard HPB entries in the host.
> > > > > > So I thinks there is nothing to do when it receives 0x2.
> > > > > But in HPB2.0, if we do nothing to active regions in host
> > > > > side, host
> > > > > can
> > > > > write
> > > > > HPB entries (which host thinks valid, but actually invalid in
> > > > > device
> > > > > side since
> > > > > reset happened) back to device through HPB Write Buffer cmds
> > > > > (BUFFER
> > > > > ID
> > > > > = 0x2).
> > > > > My question is that are all UFSs OK with this?
> > > > Yes, it must be OK.
> > > > Please refer the following the HPB 2.0 spec:
> > > > If the HPB Entries sent by HPB WRITE BUFFER are removed by the
> > > > device,
> > > > for example, because they are not consumed for a long enough
> > > > period of
> > > > time,
> > > > then the HPB READ command for the removed HPB entries shall be
> > > > handled
> > > > as a
> > > > normal READ command.
> > > No, it is talking about the subsequent HPB READ cmd sent after a
> > > HPB
> > > WRITE BUFFER cmd,
> > > but not the HPB WRITE BUFFER cmd itself...
> > Looks like this discussion is going the same way as we had in host
> > mode.
> > HPB-WRITE-BUFFER 0x2, if exist, is always a companion to HPB-READ.
> > You shouldn't consider them separately.
> > The device is expected to handle invalid ppn by itself, and
> > specifically for this case,
> > As Daejun explained, Handle each HPB-READ (and its companion
> > HPB-WRITE-BUFFER) like READ10.
> > For device mode, doing nothing in case of dev reset, seems to me
> > like
> > the right thing to do.
>
>
> I just got some feedbacks from other flash vendors, they all commit
> that
>
> their devices can work well in this scenario [1]. Some of them
> proposed
>
> even complicated (maybe better) principles of handling the "HPB
> reset",
>
> but since the device works well in [1], I am OK with current
> (simpler)
>
> handling of "HPB reset" - in device mode doing nothing, in host mode
>
> re-activate regions that host is trying to do a read to.
>
>
>
Our suggestion on this indication 0x2:
1. If current mode is device control mode, we suggest host just
deactivate all active regions and don't send HPB READ BUFFER command to
device unless device indicate host to activate certain region in later
response. In another way, it is a signal telling host to reset host
side L2P entry and to rebuild the L2P mapping entry in host memroy.
2. If current mode is host control mode, we suggest host send HPB READ
BUFFER command before it wants to send read command on this region,
rather than sending HPB READ BUFFER commands on all regions at the same
time.
Bean
> Thanks,
>
> Can Guo.
^ permalink raw reply [flat|nested] 26+ messages in thread* Re: [PATCH v31 2/4] scsi: ufs: L2P map management for HPB read
2021-03-24 8:37 ` Bean Huo
@ 2021-03-24 9:24 ` Can Guo
2021-03-24 9:33 ` Bean Huo
0 siblings, 1 reply; 26+ messages in thread
From: Can Guo @ 2021-03-24 9:24 UTC (permalink / raw)
To: Bean Huo
Cc: Avri Altman, daejun7.park, Greg KH, jejb, martin.petersen,
asutoshd, stanley.chu, bvanassche, linux-scsi, linux-kernel,
ALIM AKHTAR, JinHwan Park, Javier Gonzalez, Sung-Jun Park,
Jinyoung CHOI, Dukhyun Kwon, Keoseong Park, Jaemyung Lee,
Jieon Seol
On 2021-03-24 16:37, Bean Huo wrote:
> On Wed, 2021-03-24 at 09:45 +0800, Can Guo wrote:
>> On 2021-03-23 20:48, Avri Altman wrote:
>>
>> > > On 2021-03-23 14:37, Daejun Park wrote:
>> > > > > On 2021-03-23 14:19, Daejun Park wrote:
>> > > > > > > On 2021-03-23 13:37, Daejun Park wrote:
>> > > > > > > > > On 2021-03-23 12:22, Can Guo wrote:
>> > > > > > > > > > On 2021-03-22 17:11, Bean Huo wrote:
>> > > > > > > > > > > On Mon, 2021-03-22 at 15:54 +0900, Daejun Park
>> > > > > > > > > > > wrote:
>> > > > > > > > > > > > + switch (rsp_field->hpb_op) {
>> > > > > > > > > > > > + case HPB_RSP_REQ_REGION_UPDATE:
>> > > > > > > > > > > > + if (data_seg_len !=
>> > > > > > > > > > > > DEV_DATA_SEG_LEN)
>> > > > > > > > > > > > + dev_warn(&hpb-
>> > > > > > > > > > > > >sdev_ufs_lu->sdev_dev,
>> > > > > > > > > > > > + "%s: data seg
>> > > > > > > > > > > > length is not
>> > > > > > > > > > > > same.\n",
>> > > > > > > > > > > > + __func__);
>> > > > > > > > > > > > +
>> > > > > > > > > > > > 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;
>> > > > > > > > > > > Hi Deajun,
>> > > > > > > > > > > This series looks good to me. Just here I have
>> > > > > > > > > > > one question. You
>> > > > > > > > > > > didn't
>> > > > > > > > > > > handle HPB_RSP_DEV_RESET, just a warning. Based
>> > > > > > > > > > > on your SS UFS,
>> > > > > > > > > > > how
>> > > > > > > > > > > to
>> > > > > > > > > > > handle HPB_RSP_DEV_RESET from the host side? Do
>> > > > > > > > > > > you think we
>> > > > > > > > > > > shoud
>> > > > > > > > > > > reset host side HPB entry as well or what else?
>> > > > > > > > > > > Bean
>> > > > > > > > > > Same question here - I am still collecting
>> > > > > > > > > > feedbacks from flash
>> > > > > > > > > > vendors
>> > > > > > > > > > about
>> > > > > > > > > > what is recommanded host behavior on reception of
>> > > > > > > > > > HPB Op code
>> > > > > > > > > > 0x2,
>> > > > > > > > > > since it
>> > > > > > > > > > is not cleared defined in HPB2.0 specs.
>> > > > > > > > > > Can Guo.
>> > > > > > > > > I think the question should be asked in the HPB2.0
>> > > > > > > > > patch, since in
>> > > > > > > > > HPB1.0 device
>> > > > > > > > > control mode, a HPB reset in device side does not
>> > > > > > > > > impact anything
>> > > > > > > > > in
>> > > > > > > > > host side -
>> > > > > > > > > host is not writing back any HPB entries to device
>> > > > > > > > > anyways and HPB
>> > > > > > > > > Read
>> > > > > > > > > cmd with
>> > > > > > > > > invalid HPB entries shall be treated as normal
>> > > > > > > > > Read(10) cmd
>> > > > > > > > > without
>> > > > > > > > > any
>> > > > > > > > > problems.
>> > > > > > > > Yes, UFS device will process read command even the HPB
>> > > > > > > > entries are
>> > > > > > > > valid or
>> > > > > > > > not. So it is warning about read performance drop by
>> > > > > > > > dev reset.
>> > > > > > > Yeah, but still I am 100% sure about what should host do
>> > > > > > > in case of
>> > > > > > > HPB2.0
>> > > > > > > when it receives HPB Op code 0x2, I am waiting for
>> > > > > > > feedbacks.
>> > > > > > I think the host has two choices when it receives 0x2.
>> > > > > > One is nothing on host.
>> > > > > > The other is discarding all HPB entries in the host.
>> > > > > > In the JEDEC HPB spec, it as follows:
>> > > > > > When the device is powered off by the host, the device may
>> > > > > > restore
>> > > > > > L2P
>> > > > > > map
>> > > > > > data upon power up or build from the host’s HPB READ
>> > > > > > command.
>> > > > > > If some UFS builds L2P map data from the host's HPB READ
>> > > > > > commands, we
>> > > > > > don't
>> > > > > > have to discard HPB entries in the host.
>> > > > > > So I thinks there is nothing to do when it receives 0x2.
>> > > > > But in HPB2.0, if we do nothing to active regions in host
>> > > > > side, host
>> > > > > can
>> > > > > write
>> > > > > HPB entries (which host thinks valid, but actually invalid in
>> > > > > device
>> > > > > side since
>> > > > > reset happened) back to device through HPB Write Buffer cmds
>> > > > > (BUFFER
>> > > > > ID
>> > > > > = 0x2).
>> > > > > My question is that are all UFSs OK with this?
>> > > > Yes, it must be OK.
>> > > > Please refer the following the HPB 2.0 spec:
>> > > > If the HPB Entries sent by HPB WRITE BUFFER are removed by the
>> > > > device,
>> > > > for example, because they are not consumed for a long enough
>> > > > period of
>> > > > time,
>> > > > then the HPB READ command for the removed HPB entries shall be
>> > > > handled
>> > > > as a
>> > > > normal READ command.
>> > > No, it is talking about the subsequent HPB READ cmd sent after a
>> > > HPB
>> > > WRITE BUFFER cmd,
>> > > but not the HPB WRITE BUFFER cmd itself...
>> > Looks like this discussion is going the same way as we had in host
>> > mode.
>> > HPB-WRITE-BUFFER 0x2, if exist, is always a companion to HPB-READ.
>> > You shouldn't consider them separately.
>> > The device is expected to handle invalid ppn by itself, and
>> > specifically for this case,
>> > As Daejun explained, Handle each HPB-READ (and its companion
>> > HPB-WRITE-BUFFER) like READ10.
>> > For device mode, doing nothing in case of dev reset, seems to me
>> > like
>> > the right thing to do.
>>
>>
>> I just got some feedbacks from other flash vendors, they all commit
>> that
>>
>> their devices can work well in this scenario [1]. Some of them
>> proposed
>>
>> even complicated (maybe better) principles of handling the "HPB
>> reset",
>>
>> but since the device works well in [1], I am OK with current
>> (simpler)
>>
>> handling of "HPB reset" - in device mode doing nothing, in host mode
>>
>> re-activate regions that host is trying to do a read to.
>>
>>
>>
>
> Our suggestion on this indication 0x2:
>
> 1. If current mode is device control mode, we suggest host just
> deactivate all active regions and don't send HPB READ BUFFER command to
> device unless device indicate host to activate certain region in later
> response. In another way, it is a signal telling host to reset host
> side L2P entry and to rebuild the L2P mapping entry in host memroy.
>
> 2. If current mode is host control mode, we suggest host send HPB READ
> BUFFER command before it wants to send read command on this region,
> rather than sending HPB READ BUFFER commands on all regions at the same
> time.
>
>
> Bean
Hi Bean,
I got this proposal from your side too, after that I've checked with
Leon Ge from your side and he confirmed that it is fine that host just
ignores the "HPB reset" indication. We can leave it as it is as of now
and revisit it if any UFS needs extra care. What do you say?
Thanks,
Can Guo.
>
>> Thanks,
>>
>> Can Guo.
^ permalink raw reply [flat|nested] 26+ messages in thread* Re: [PATCH v31 2/4] scsi: ufs: L2P map management for HPB read
2021-03-24 9:24 ` Can Guo
@ 2021-03-24 9:33 ` Bean Huo
2021-03-24 9:37 ` Can Guo
0 siblings, 1 reply; 26+ messages in thread
From: Bean Huo @ 2021-03-24 9:33 UTC (permalink / raw)
To: Can Guo
Cc: Avri Altman, daejun7.park, Greg KH, jejb, martin.petersen,
asutoshd, stanley.chu, bvanassche, linux-scsi, linux-kernel,
ALIM AKHTAR, JinHwan Park, Javier Gonzalez, Sung-Jun Park,
Jinyoung CHOI, Dukhyun Kwon, Keoseong Park, Jaemyung Lee,
Jieon Seol
On Wed, 2021-03-24 at 17:24 +0800, Can Guo wrote:
> On 2021-03-24 16:37, Bean Huo wrote:
> > On Wed, 2021-03-24 at 09:45 +0800, Can Guo wrote:
> > > On 2021-03-23 20:48, Avri Altman wrote:
> > >
> > > > > On 2021-03-23 14:37, Daejun Park wrote:
> > > > > > > On 2021-03-23 14:19, Daejun Park wrote:
> > > > > > > > > On 2021-03-23 13:37, Daejun Park wrote:
> > > > > > > > > > > On 2021-03-23 12:22, Can Guo wrote:
> > > > > > > > > > > > On 2021-03-22 17:11, Bean Huo wrote:
> > > > > > > > > > > > > On Mon, 2021-03-22 at 15:54 +0900, Daejun
> > > > > > > > > > > > > Park
> > > > > > > > > > > > > wrote:
> > > > > > > > > > > > > > + switch (rsp_field->hpb_op) {
> > > > > > > > > > > > > > + case HPB_RSP_REQ_REGION_UPDATE:
> > > > > > > > > > > > > > + if (data_seg_len !=
> > > > > > > > > > > > > > DEV_DATA_SEG_LEN)
> > > > > > > > > > > > > > + dev_warn(&hpb-
> > > > > > > > > > > > > > > sdev_ufs_lu->sdev_dev,
> > > > > > > > > > > > > > + "%s: data
> > > > > > > > > > > > > > seg
> > > > > > > > > > > > > > length is not
> > > > > > > > > > > > > > same.\n",
> > > > > > > > > > > > > > + __func__);
> > > > > > > > > > > > > > +
> > > > > > > > > > > > > > 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;
> > > > > > > > > > > > > Hi Deajun,
> > > > > > > > > > > > > This series looks good to me. Just here I
> > > > > > > > > > > > > have
> > > > > > > > > > > > > one question. You
> > > > > > > > > > > > > didn't
> > > > > > > > > > > > > handle HPB_RSP_DEV_RESET, just a
> > > > > > > > > > > > > warning. Based
> > > > > > > > > > > > > on your SS UFS,
> > > > > > > > > > > > > how
> > > > > > > > > > > > > to
> > > > > > > > > > > > > handle HPB_RSP_DEV_RESET from the host side?
> > > > > > > > > > > > > Do
> > > > > > > > > > > > > you think we
> > > > > > > > > > > > > shoud
> > > > > > > > > > > > > reset host side HPB entry as well or what
> > > > > > > > > > > > > else?
> > > > > > > > > > > > > Bean
> > > > > > > > > > > > Same question here - I am still collecting
> > > > > > > > > > > > feedbacks from flash
> > > > > > > > > > > > vendors
> > > > > > > > > > > > about
> > > > > > > > > > > > what is recommanded host behavior on reception
> > > > > > > > > > > > of
> > > > > > > > > > > > HPB Op code
> > > > > > > > > > > > 0x2,
> > > > > > > > > > > > since it
> > > > > > > > > > > > is not cleared defined in HPB2.0 specs.
> > > > > > > > > > > > Can Guo.
> > > > > > > > > > > I think the question should be asked in the
> > > > > > > > > > > HPB2.0
> > > > > > > > > > > patch, since in
> > > > > > > > > > > HPB1.0 device
> > > > > > > > > > > control mode, a HPB reset in device side does not
> > > > > > > > > > > impact anything
> > > > > > > > > > > in
> > > > > > > > > > > host side -
> > > > > > > > > > > host is not writing back any HPB entries to
> > > > > > > > > > > device
> > > > > > > > > > > anyways and HPB
> > > > > > > > > > > Read
> > > > > > > > > > > cmd with
> > > > > > > > > > > invalid HPB entries shall be treated as normal
> > > > > > > > > > > Read(10) cmd
> > > > > > > > > > > without
> > > > > > > > > > > any
> > > > > > > > > > > problems.
> > > > > > > > > > Yes, UFS device will process read command even the
> > > > > > > > > > HPB
> > > > > > > > > > entries are
> > > > > > > > > > valid or
> > > > > > > > > > not. So it is warning about read performance drop
> > > > > > > > > > by
> > > > > > > > > > dev reset.
> > > > > > > > > Yeah, but still I am 100% sure about what should host
> > > > > > > > > do
> > > > > > > > > in case of
> > > > > > > > > HPB2.0
> > > > > > > > > when it receives HPB Op code 0x2, I am waiting for
> > > > > > > > > feedbacks.
> > > > > > > > I think the host has two choices when it receives 0x2.
> > > > > > > > One is nothing on host.
> > > > > > > > The other is discarding all HPB entries in the host.
> > > > > > > > In the JEDEC HPB spec, it as follows:
> > > > > > > > When the device is powered off by the host, the device
> > > > > > > > may
> > > > > > > > restore
> > > > > > > > L2P
> > > > > > > > map
> > > > > > > > data upon power up or build from the host’s HPB READ
> > > > > > > > command.
> > > > > > > > If some UFS builds L2P map data from the host's HPB
> > > > > > > > READ
> > > > > > > > commands, we
> > > > > > > > don't
> > > > > > > > have to discard HPB entries in the host.
> > > > > > > > So I thinks there is nothing to do when it receives
> > > > > > > > 0x2.
> > > > > > > But in HPB2.0, if we do nothing to active regions in host
> > > > > > > side, host
> > > > > > > can
> > > > > > > write
> > > > > > > HPB entries (which host thinks valid, but actually
> > > > > > > invalid in
> > > > > > > device
> > > > > > > side since
> > > > > > > reset happened) back to device through HPB Write Buffer
> > > > > > > cmds
> > > > > > > (BUFFER
> > > > > > > ID
> > > > > > > = 0x2).
> > > > > > > My question is that are all UFSs OK with this?
> > > > > > Yes, it must be OK.
> > > > > > Please refer the following the HPB 2.0 spec:
> > > > > > If the HPB Entries sent by HPB WRITE BUFFER are removed by
> > > > > > the
> > > > > > device,
> > > > > > for example, because they are not consumed for a long
> > > > > > enough
> > > > > > period of
> > > > > > time,
> > > > > > then the HPB READ command for the removed HPB entries shall
> > > > > > be
> > > > > > handled
> > > > > > as a
> > > > > > normal READ command.
> > > > > No, it is talking about the subsequent HPB READ cmd sent
> > > > > after a
> > > > > HPB
> > > > > WRITE BUFFER cmd,
> > > > > but not the HPB WRITE BUFFER cmd itself...
> > > > Looks like this discussion is going the same way as we had in
> > > > host
> > > > mode.
> > > > HPB-WRITE-BUFFER 0x2, if exist, is always a companion to HPB-
> > > > READ.
> > > > You shouldn't consider them separately.
> > > > The device is expected to handle invalid ppn by itself, and
> > > > specifically for this case,
> > > > As Daejun explained, Handle each HPB-READ (and its companion
> > > > HPB-WRITE-BUFFER) like READ10.
> > > > For device mode, doing nothing in case of dev reset, seems to
> > > > me
> > > > like
> > > > the right thing to do.
> > >
> > > I just got some feedbacks from other flash vendors, they all
> > > commit
> > > that
> > >
> > > their devices can work well in this scenario [1]. Some of them
> > > proposed
> > >
> > > even complicated (maybe better) principles of handling the "HPB
> > > reset",
> > >
> > > but since the device works well in [1], I am OK with current
> > > (simpler)
> > >
> > > handling of "HPB reset" - in device mode doing nothing, in host
> > > mode
> > >
> > > re-activate regions that host is trying to do a read to.
> > >
> > >
> > >
> >
> > Our suggestion on this indication 0x2:
> >
> > 1. If current mode is device control mode, we suggest host just
> > deactivate all active regions and don't send HPB READ BUFFER
> > command to
> > device unless device indicate host to activate certain region in
> > later
> > response. In another way, it is a signal telling host to reset host
> > side L2P entry and to rebuild the L2P mapping entry in host memroy.
> >
> > 2. If current mode is host control mode, we suggest host send HPB
> > READ
> > BUFFER command before it wants to send read command on this region,
> > rather than sending HPB READ BUFFER commands on all regions at the
> > same
> > time.
> >
> >
> > Bean
>
> Hi Bean,
>
> I got this proposal from your side too, after that I've checked with
> Leon Ge from your side and he confirmed that it is fine that host
> just
> ignores the "HPB reset" indication. We can leave it as it is as of
> now
> and revisit it if any UFS needs extra care. What do you say?
>
> Thanks,
> Can Guo.
Hi Can,
Agree. Current handling is ok to us, but if we want to change it, we
hope it is the same with the above suggestion. We can keep current
implementation, seeing if need changes in the near future based on the
feedback or new updates in the Spec.
Thanks,
Bean
>
> > > Thanks,
> > >
> > > Can Guo.
^ permalink raw reply [flat|nested] 26+ messages in thread* Re: [PATCH v31 2/4] scsi: ufs: L2P map management for HPB read
2021-03-24 9:33 ` Bean Huo
@ 2021-03-24 9:37 ` Can Guo
0 siblings, 0 replies; 26+ messages in thread
From: Can Guo @ 2021-03-24 9:37 UTC (permalink / raw)
To: Bean Huo
Cc: Avri Altman, daejun7.park, Greg KH, jejb, martin.petersen,
asutoshd, stanley.chu, bvanassche, linux-scsi, linux-kernel,
ALIM AKHTAR, JinHwan Park, Javier Gonzalez, Sung-Jun Park,
Jinyoung CHOI, Dukhyun Kwon, Keoseong Park, Jaemyung Lee,
Jieon Seol
On 2021-03-24 17:33, Bean Huo wrote:
> On Wed, 2021-03-24 at 17:24 +0800, Can Guo wrote:
>> On 2021-03-24 16:37, Bean Huo wrote:
>> > On Wed, 2021-03-24 at 09:45 +0800, Can Guo wrote:
>> > > On 2021-03-23 20:48, Avri Altman wrote:
>> > >
>> > > > > On 2021-03-23 14:37, Daejun Park wrote:
>> > > > > > > On 2021-03-23 14:19, Daejun Park wrote:
>> > > > > > > > > On 2021-03-23 13:37, Daejun Park wrote:
>> > > > > > > > > > > On 2021-03-23 12:22, Can Guo wrote:
>> > > > > > > > > > > > On 2021-03-22 17:11, Bean Huo wrote:
>> > > > > > > > > > > > > On Mon, 2021-03-22 at 15:54 +0900, Daejun
>> > > > > > > > > > > > > Park
>> > > > > > > > > > > > > wrote:
>> > > > > > > > > > > > > > + switch (rsp_field->hpb_op) {
>> > > > > > > > > > > > > > + case HPB_RSP_REQ_REGION_UPDATE:
>> > > > > > > > > > > > > > + if (data_seg_len !=
>> > > > > > > > > > > > > > DEV_DATA_SEG_LEN)
>> > > > > > > > > > > > > > + dev_warn(&hpb-
>> > > > > > > > > > > > > > > sdev_ufs_lu->sdev_dev,
>> > > > > > > > > > > > > > + "%s: data
>> > > > > > > > > > > > > > seg
>> > > > > > > > > > > > > > length is not
>> > > > > > > > > > > > > > same.\n",
>> > > > > > > > > > > > > > + __func__);
>> > > > > > > > > > > > > > +
>> > > > > > > > > > > > > > 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;
>> > > > > > > > > > > > > Hi Deajun,
>> > > > > > > > > > > > > This series looks good to me. Just here I
>> > > > > > > > > > > > > have
>> > > > > > > > > > > > > one question. You
>> > > > > > > > > > > > > didn't
>> > > > > > > > > > > > > handle HPB_RSP_DEV_RESET, just a
>> > > > > > > > > > > > > warning. Based
>> > > > > > > > > > > > > on your SS UFS,
>> > > > > > > > > > > > > how
>> > > > > > > > > > > > > to
>> > > > > > > > > > > > > handle HPB_RSP_DEV_RESET from the host side?
>> > > > > > > > > > > > > Do
>> > > > > > > > > > > > > you think we
>> > > > > > > > > > > > > shoud
>> > > > > > > > > > > > > reset host side HPB entry as well or what
>> > > > > > > > > > > > > else?
>> > > > > > > > > > > > > Bean
>> > > > > > > > > > > > Same question here - I am still collecting
>> > > > > > > > > > > > feedbacks from flash
>> > > > > > > > > > > > vendors
>> > > > > > > > > > > > about
>> > > > > > > > > > > > what is recommanded host behavior on reception
>> > > > > > > > > > > > of
>> > > > > > > > > > > > HPB Op code
>> > > > > > > > > > > > 0x2,
>> > > > > > > > > > > > since it
>> > > > > > > > > > > > is not cleared defined in HPB2.0 specs.
>> > > > > > > > > > > > Can Guo.
>> > > > > > > > > > > I think the question should be asked in the
>> > > > > > > > > > > HPB2.0
>> > > > > > > > > > > patch, since in
>> > > > > > > > > > > HPB1.0 device
>> > > > > > > > > > > control mode, a HPB reset in device side does not
>> > > > > > > > > > > impact anything
>> > > > > > > > > > > in
>> > > > > > > > > > > host side -
>> > > > > > > > > > > host is not writing back any HPB entries to
>> > > > > > > > > > > device
>> > > > > > > > > > > anyways and HPB
>> > > > > > > > > > > Read
>> > > > > > > > > > > cmd with
>> > > > > > > > > > > invalid HPB entries shall be treated as normal
>> > > > > > > > > > > Read(10) cmd
>> > > > > > > > > > > without
>> > > > > > > > > > > any
>> > > > > > > > > > > problems.
>> > > > > > > > > > Yes, UFS device will process read command even the
>> > > > > > > > > > HPB
>> > > > > > > > > > entries are
>> > > > > > > > > > valid or
>> > > > > > > > > > not. So it is warning about read performance drop
>> > > > > > > > > > by
>> > > > > > > > > > dev reset.
>> > > > > > > > > Yeah, but still I am 100% sure about what should host
>> > > > > > > > > do
>> > > > > > > > > in case of
>> > > > > > > > > HPB2.0
>> > > > > > > > > when it receives HPB Op code 0x2, I am waiting for
>> > > > > > > > > feedbacks.
>> > > > > > > > I think the host has two choices when it receives 0x2.
>> > > > > > > > One is nothing on host.
>> > > > > > > > The other is discarding all HPB entries in the host.
>> > > > > > > > In the JEDEC HPB spec, it as follows:
>> > > > > > > > When the device is powered off by the host, the device
>> > > > > > > > may
>> > > > > > > > restore
>> > > > > > > > L2P
>> > > > > > > > map
>> > > > > > > > data upon power up or build from the host’s HPB READ
>> > > > > > > > command.
>> > > > > > > > If some UFS builds L2P map data from the host's HPB
>> > > > > > > > READ
>> > > > > > > > commands, we
>> > > > > > > > don't
>> > > > > > > > have to discard HPB entries in the host.
>> > > > > > > > So I thinks there is nothing to do when it receives
>> > > > > > > > 0x2.
>> > > > > > > But in HPB2.0, if we do nothing to active regions in host
>> > > > > > > side, host
>> > > > > > > can
>> > > > > > > write
>> > > > > > > HPB entries (which host thinks valid, but actually
>> > > > > > > invalid in
>> > > > > > > device
>> > > > > > > side since
>> > > > > > > reset happened) back to device through HPB Write Buffer
>> > > > > > > cmds
>> > > > > > > (BUFFER
>> > > > > > > ID
>> > > > > > > = 0x2).
>> > > > > > > My question is that are all UFSs OK with this?
>> > > > > > Yes, it must be OK.
>> > > > > > Please refer the following the HPB 2.0 spec:
>> > > > > > If the HPB Entries sent by HPB WRITE BUFFER are removed by
>> > > > > > the
>> > > > > > device,
>> > > > > > for example, because they are not consumed for a long
>> > > > > > enough
>> > > > > > period of
>> > > > > > time,
>> > > > > > then the HPB READ command for the removed HPB entries shall
>> > > > > > be
>> > > > > > handled
>> > > > > > as a
>> > > > > > normal READ command.
>> > > > > No, it is talking about the subsequent HPB READ cmd sent
>> > > > > after a
>> > > > > HPB
>> > > > > WRITE BUFFER cmd,
>> > > > > but not the HPB WRITE BUFFER cmd itself...
>> > > > Looks like this discussion is going the same way as we had in
>> > > > host
>> > > > mode.
>> > > > HPB-WRITE-BUFFER 0x2, if exist, is always a companion to HPB-
>> > > > READ.
>> > > > You shouldn't consider them separately.
>> > > > The device is expected to handle invalid ppn by itself, and
>> > > > specifically for this case,
>> > > > As Daejun explained, Handle each HPB-READ (and its companion
>> > > > HPB-WRITE-BUFFER) like READ10.
>> > > > For device mode, doing nothing in case of dev reset, seems to
>> > > > me
>> > > > like
>> > > > the right thing to do.
>> > >
>> > > I just got some feedbacks from other flash vendors, they all
>> > > commit
>> > > that
>> > >
>> > > their devices can work well in this scenario [1]. Some of them
>> > > proposed
>> > >
>> > > even complicated (maybe better) principles of handling the "HPB
>> > > reset",
>> > >
>> > > but since the device works well in [1], I am OK with current
>> > > (simpler)
>> > >
>> > > handling of "HPB reset" - in device mode doing nothing, in host
>> > > mode
>> > >
>> > > re-activate regions that host is trying to do a read to.
>> > >
>> > >
>> > >
>> >
>> > Our suggestion on this indication 0x2:
>> >
>> > 1. If current mode is device control mode, we suggest host just
>> > deactivate all active regions and don't send HPB READ BUFFER
>> > command to
>> > device unless device indicate host to activate certain region in
>> > later
>> > response. In another way, it is a signal telling host to reset host
>> > side L2P entry and to rebuild the L2P mapping entry in host memroy.
>> >
>> > 2. If current mode is host control mode, we suggest host send HPB
>> > READ
>> > BUFFER command before it wants to send read command on this region,
>> > rather than sending HPB READ BUFFER commands on all regions at the
>> > same
>> > time.
>> >
>> >
>> > Bean
>>
>> Hi Bean,
>>
>> I got this proposal from your side too, after that I've checked with
>> Leon Ge from your side and he confirmed that it is fine that host
>> just
>> ignores the "HPB reset" indication. We can leave it as it is as of
>> now
>> and revisit it if any UFS needs extra care. What do you say?
>>
>> Thanks,
>> Can Guo.
>
> Hi Can,
>
> Agree. Current handling is ok to us, but if we want to change it, we
> hope it is the same with the above suggestion. We can keep current
> implementation, seeing if need changes in the near future based on the
> feedback or new updates in the Spec.
>
Sure.
BTW, do you have plans to make the proposal into JEDEC specs?
Thanks,
Can Guo.
> Thanks,
> Bean
>
>
>
>>
>> > > Thanks,
>> > >
>> > > Can Guo.
^ permalink raw reply [flat|nested] 26+ messages in thread
* [PATCH v31 3/4] scsi: ufs: Prepare HPB read for cached sub-region
2021-03-22 6:51 ` [PATCH v31 0/4] scsi: ufs: Add Host Performance Booster Support Daejun Park
2021-03-22 6:53 ` [PATCH v31 1/4] scsi: ufs: Introduce HPB feature Daejun Park
2021-03-22 6:54 ` [PATCH v31 2/4] scsi: ufs: L2P map management for HPB read Daejun Park
@ 2021-03-22 6:54 ` Daejun Park
2021-03-22 6:55 ` [PATCH v31 4/4] scsi: ufs: Add HPB 2.0 support Daejun Park
3 siblings, 0 replies; 26+ messages in thread
From: Daejun Park @ 2021-03-22 6:54 UTC (permalink / raw)
To: Daejun Park, Greg KH, avri.altman@wdc.com, jejb@linux.ibm.com,
martin.petersen@oracle.com, asutoshd@codeaurora.org,
stanley.chu@mediatek.com, cang@codeaurora.org, bvanassche@acm.org,
huobean@gmail.com, linux-scsi@vger.kernel.org,
linux-kernel@vger.kernel.org, ALIM AKHTAR, JinHwan Park,
Javier Gonzalez, Sung-Jun Park, Jinyoung CHOI, Dukhyun Kwon,
Keoseong Park, Jaemyung Lee, Jieon Seol
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 | 257 +++++++++++++++++++++++++++++++++++++-
drivers/scsi/ufs/ufshpb.h | 2 +
3 files changed, 258 insertions(+), 3 deletions(-)
diff --git a/drivers/scsi/ufs/ufshcd.c b/drivers/scsi/ufs/ufshcd.c
index 88280310bb64..a7cf9278965c 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 c67acfc8c6bf..f789339f68d9 100644
--- a/drivers/scsi/ufs/ufshpb.c
+++ b/drivers/scsi/ufs/ufshpb.c
@@ -46,6 +46,29 @@ static void ufshpb_set_state(struct ufshpb_lu *hpb, int state)
atomic_set(&hpb->hpb_state, state);
}
+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;
@@ -80,8 +103,8 @@ static void ufshpb_kick_map_work(struct ufshpb_lu *hpb)
}
static bool ufshpb_is_hpb_rsp_valid(struct ufs_hba *hba,
- struct ufshcd_lrb *lrbp,
- struct utp_hpb_rsp *rsp_field)
+ struct ufshcd_lrb *lrbp,
+ struct utp_hpb_rsp *rsp_field)
{
/* Check HPB_UPDATE_ALERT */
if (!(lrbp->ucd_rsp_ptr->header.dword_2 &
@@ -107,6 +130,234 @@ static bool ufshpb_is_hpb_rsp_valid(struct ufs_hba *hba,
return true;
}
+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;
+
+next_srgn:
+ rgn = hpb->rgn_tbl + rgn_idx;
+ srgn = rgn->srgn_tbl + srgn_idx;
+
+ if (likely(!srgn->is_last))
+ bitmap_len = hpb->entries_per_srgn;
+ else
+ bitmap_len = hpb->last_srgn_entries;
+
+ 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;
+}
+
+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;
+ int bit_len;
+
+next_srgn:
+ rgn = hpb->rgn_tbl + rgn_idx;
+ srgn = rgn->srgn_tbl + srgn_idx;
+
+ if (likely(!srgn->is_last))
+ bitmap_len = hpb->entries_per_srgn;
+ else
+ bitmap_len = hpb->last_srgn_entries;
+
+ 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.
+ */
+ if (unlikely(!srgn->mctx)) {
+ dev_err(&hpb->sdev_ufs_lu->sdev_dev,
+ "no mctx in region %d subregion %d.\n",
+ srgn->rgn_idx, srgn->srgn_idx);
+ return true;
+ }
+
+ 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 int ufshpb_fill_ppn_from_page(struct ufshpb_lu *hpb,
+ struct ufshpb_map_ctx *mctx, int pos,
+ int len, u64 *ppn_buf)
+{
+ struct page *page;
+ int index, offset;
+ int copied;
+
+ index = pos / (PAGE_SIZE / HPB_ENTRY_SIZE);
+ offset = pos % (PAGE_SIZE / HPB_ENTRY_SIZE);
+
+ if ((offset + len) <= (PAGE_SIZE / HPB_ENTRY_SIZE))
+ copied = len;
+ else
+ copied = (PAGE_SIZE / HPB_ENTRY_SIZE) - offset;
+
+ page = mctx->m_page[index];
+ if (unlikely(!page)) {
+ dev_err(&hpb->sdev_ufs_lu->sdev_dev,
+ "error. cannot find page in mctx\n");
+ return -ENOMEM;
+ }
+
+ memcpy(ppn_buf, page_address(page) + (offset * HPB_ENTRY_SIZE),
+ copied * HPB_ENTRY_SIZE);
+
+ return copied;
+}
+
+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;
+
+ /* ppn value is stored as big-endian in the host memory */
+ memcpy(&cdb[6], &ppn, sizeof(u64));
+ 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_INIT)
+ 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 (blk_rq_is_scsi(cmd->request) ||
+ (!ufshpb_is_write_or_discard_cmd(cmd) &&
+ !ufshpb_is_read_cmd(cmd)))
+ return 0;
+
+ 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;
+ }
+
+ err = ufshpb_fill_ppn_from_page(hpb, srgn->mctx, srgn_offset, 1, &ppn);
+ spin_unlock_irqrestore(&hpb->rgn_state_lock, flags);
+ if (unlikely(err < 0)) {
+ /*
+ * 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.
+ */
+ dev_err(hba->dev, "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)
{
@@ -153,7 +404,7 @@ static struct ufshpb_req *ufshpb_get_map_req(struct ufshpb_lu *hpb,
}
static void ufshpb_put_map_req(struct ufshpb_lu *hpb,
- struct ufshpb_req *map_req)
+ struct ufshpb_req *map_req)
{
bio_put(map_req->bio);
blk_put_request(map_req->req);
diff --git a/drivers/scsi/ufs/ufshpb.h b/drivers/scsi/ufs/ufshpb.h
index dcc0ca3b8158..6e6a0252dc15 100644
--- a/drivers/scsi/ufs/ufshpb.h
+++ b/drivers/scsi/ufs/ufshpb.h
@@ -201,6 +201,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) {}
@@ -214,6 +215,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
^ permalink raw reply related [flat|nested] 26+ messages in thread* [PATCH v31 4/4] scsi: ufs: Add HPB 2.0 support
2021-03-22 6:51 ` [PATCH v31 0/4] scsi: ufs: Add Host Performance Booster Support Daejun Park
` (2 preceding siblings ...)
2021-03-22 6:54 ` [PATCH v31 3/4] scsi: ufs: Prepare HPB read for cached sub-region Daejun Park
@ 2021-03-22 6:55 ` Daejun Park
2021-03-24 5:01 ` Can Guo
3 siblings, 1 reply; 26+ messages in thread
From: Daejun Park @ 2021-03-22 6:55 UTC (permalink / raw)
To: Daejun Park, Greg KH, avri.altman@wdc.com, jejb@linux.ibm.com,
martin.petersen@oracle.com, asutoshd@codeaurora.org,
stanley.chu@mediatek.com, cang@codeaurora.org, bvanassche@acm.org,
huobean@gmail.com, linux-scsi@vger.kernel.org,
linux-kernel@vger.kernel.org, ALIM AKHTAR, JinHwan Park,
Javier Gonzalez, Sung-Jun Park, Jinyoung CHOI, Dukhyun Kwon,
Keoseong Park, Jaemyung Lee, Jieon Seol
This patch supports the HPB 2.0.
The HPB 2.0 supports read of varying sizes from 4KB to 512KB.
In the case of Read (<= 32KB) is supported as single HPB read.
In the case of Read (36KB ~ 512KB) is supported by as a combination of
write buffer command and HPB read command to deliver more PPN.
The write buffer commands may not be issued immediately due to busy tags.
To use HPB read more aggressively, the driver can requeue the write buffer
command. The requeue threshold is implemented as timeout and can be
modified with requeue_timeout_ms entry in sysfs.
Signed-off-by: Daejun Park <daejun7.park@samsung.com>
---
Documentation/ABI/testing/sysfs-driver-ufs | 47 +-
drivers/scsi/ufs/ufs-sysfs.c | 4 +
drivers/scsi/ufs/ufs.h | 3 +-
drivers/scsi/ufs/ufshcd.c | 25 +-
drivers/scsi/ufs/ufshcd.h | 7 +
drivers/scsi/ufs/ufshpb.c | 626 +++++++++++++++++++--
drivers/scsi/ufs/ufshpb.h | 67 ++-
7 files changed, 698 insertions(+), 81 deletions(-)
diff --git a/Documentation/ABI/testing/sysfs-driver-ufs b/Documentation/ABI/testing/sysfs-driver-ufs
index 528bf89fc98b..419adf450b89 100644
--- a/Documentation/ABI/testing/sysfs-driver-ufs
+++ b/Documentation/ABI/testing/sysfs-driver-ufs
@@ -1253,14 +1253,14 @@ Description: This entry shows the number of HPB pinned regions assigned to
The file is read only.
-What: /sys/class/scsi_device/*/device/hpb_sysfs/hit_cnt
+What: /sys/class/scsi_device/*/device/hpb_stat_sysfs/hit_cnt
Date: March 2021
Contact: Daejun Park <daejun7.park@samsung.com>
Description: This entry shows the number of reads that changed to HPB read.
The file is read only.
-What: /sys/class/scsi_device/*/device/hpb_sysfs/miss_cnt
+What: /sys/class/scsi_device/*/device/hpb_stat_sysfs/miss_cnt
Date: March 2021
Contact: Daejun Park <daejun7.park@samsung.com>
Description: This entry shows the number of reads that cannot be changed to
@@ -1268,7 +1268,7 @@ Description: This entry shows the number of reads that cannot be changed to
The file is read only.
-What: /sys/class/scsi_device/*/device/hpb_sysfs/rb_noti_cnt
+What: /sys/class/scsi_device/*/device/hpb_stat_sysfs/rb_noti_cnt
Date: March 2021
Contact: Daejun Park <daejun7.park@samsung.com>
Description: This entry shows the number of response UPIUs that has
@@ -1276,7 +1276,7 @@ Description: This entry shows the number of response UPIUs that has
The file is read only.
-What: /sys/class/scsi_device/*/device/hpb_sysfs/rb_active_cnt
+What: /sys/class/scsi_device/*/device/hpb_stat_sysfs/rb_active_cnt
Date: March 2021
Contact: Daejun Park <daejun7.park@samsung.com>
Description: This entry shows the number of active sub-regions recommended by
@@ -1284,7 +1284,7 @@ Description: This entry shows the number of active sub-regions recommended by
The file is read only.
-What: /sys/class/scsi_device/*/device/hpb_sysfs/rb_inactive_cnt
+What: /sys/class/scsi_device/*/device/hpb_stat_sysfs/rb_inactive_cnt
Date: March 2021
Contact: Daejun Park <daejun7.park@samsung.com>
Description: This entry shows the number of inactive regions recommended by
@@ -1292,10 +1292,45 @@ Description: This entry shows the number of inactive regions recommended by
The file is read only.
-What: /sys/class/scsi_device/*/device/hpb_sysfs/map_req_cnt
+What: /sys/class/scsi_device/*/device/hpb_stat_sysfs/map_req_cnt
Date: March 2021
Contact: Daejun Park <daejun7.park@samsung.com>
Description: This entry shows the number of read buffer commands for
activating sub-regions recommended by response UPIUs.
The file is read only.
+
+What: /sys/class/scsi_device/*/device/hpb_param_sysfs/requeue_timeout_ms
+Date: March 2021
+Contact: Daejun Park <daejun7.park@samsung.com>
+Description: This entry shows the requeue timeout threshold for write buffer
+ command in ms. This value can be changed by writing proper integer to
+ this entry.
+
+What: /sys/bus/platform/drivers/ufshcd/*/attributes/max_data_size_hpb_single_cmd
+Date: March 2021
+Contact: Daejun Park <daejun7.park@samsung.com>
+Description: This entry shows the maximum HPB data size for using single HPB
+ command.
+
+ === ========
+ 00h 4KB
+ 01h 8KB
+ 02h 12KB
+ ...
+ FFh 1024KB
+ === ========
+
+ The file is read only.
+
+What: /sys/bus/platform/drivers/ufshcd/*/flags/wb_enable
+Date: March 2021
+Contact: Daejun Park <daejun7.park@samsung.com>
+Description: This entry shows the status of HPB.
+
+ == ============================
+ 0 HPB is not enabled.
+ 1 HPB is enabled
+ == ============================
+
+ The file is read only.
diff --git a/drivers/scsi/ufs/ufs-sysfs.c b/drivers/scsi/ufs/ufs-sysfs.c
index 2546e7a1ac4f..92a883866e12 100644
--- a/drivers/scsi/ufs/ufs-sysfs.c
+++ b/drivers/scsi/ufs/ufs-sysfs.c
@@ -782,6 +782,7 @@ UFS_FLAG(disable_fw_update, _PERMANENTLY_DISABLE_FW_UPDATE);
UFS_FLAG(wb_enable, _WB_EN);
UFS_FLAG(wb_flush_en, _WB_BUFF_FLUSH_EN);
UFS_FLAG(wb_flush_during_h8, _WB_BUFF_FLUSH_DURING_HIBERN8);
+UFS_FLAG(hpb_enable, _HPB_EN);
static struct attribute *ufs_sysfs_device_flags[] = {
&dev_attr_device_init.attr,
@@ -795,6 +796,7 @@ static struct attribute *ufs_sysfs_device_flags[] = {
&dev_attr_wb_enable.attr,
&dev_attr_wb_flush_en.attr,
&dev_attr_wb_flush_during_h8.attr,
+ &dev_attr_hpb_enable.attr,
NULL,
};
@@ -841,6 +843,7 @@ out: \
static DEVICE_ATTR_RO(_name)
UFS_ATTRIBUTE(boot_lun_enabled, _BOOT_LU_EN);
+UFS_ATTRIBUTE(max_data_size_hpb_single_cmd, _MAX_HPB_SINGLE_CMD);
UFS_ATTRIBUTE(current_power_mode, _POWER_MODE);
UFS_ATTRIBUTE(active_icc_level, _ACTIVE_ICC_LVL);
UFS_ATTRIBUTE(ooo_data_enabled, _OOO_DATA_EN);
@@ -864,6 +867,7 @@ UFS_ATTRIBUTE(wb_cur_buf, _CURR_WB_BUFF_SIZE);
static struct attribute *ufs_sysfs_attributes[] = {
&dev_attr_boot_lun_enabled.attr,
+ &dev_attr_max_data_size_hpb_single_cmd.attr,
&dev_attr_current_power_mode.attr,
&dev_attr_active_icc_level.attr,
&dev_attr_ooo_data_enabled.attr,
diff --git a/drivers/scsi/ufs/ufs.h b/drivers/scsi/ufs/ufs.h
index bfb84d2ba990..8c6b38b1b142 100644
--- a/drivers/scsi/ufs/ufs.h
+++ b/drivers/scsi/ufs/ufs.h
@@ -123,12 +123,13 @@ enum flag_idn {
QUERY_FLAG_IDN_WB_BUFF_FLUSH_EN = 0x0F,
QUERY_FLAG_IDN_WB_BUFF_FLUSH_DURING_HIBERN8 = 0x10,
QUERY_FLAG_IDN_HPB_RESET = 0x11,
+ QUERY_FLAG_IDN_HPB_EN = 0x12,
};
/* Attribute idn for Query requests */
enum attr_idn {
QUERY_ATTR_IDN_BOOT_LU_EN = 0x00,
- QUERY_ATTR_IDN_RESERVED = 0x01,
+ QUERY_ATTR_IDN_MAX_HPB_SINGLE_CMD = 0x01,
QUERY_ATTR_IDN_POWER_MODE = 0x02,
QUERY_ATTR_IDN_ACTIVE_ICC_LVL = 0x03,
QUERY_ATTR_IDN_OOO_DATA_EN = 0x04,
diff --git a/drivers/scsi/ufs/ufshcd.c b/drivers/scsi/ufs/ufshcd.c
index a7cf9278965c..1653c7a7b066 100644
--- a/drivers/scsi/ufs/ufshcd.c
+++ b/drivers/scsi/ufs/ufshcd.c
@@ -2653,7 +2653,12 @@ static int ufshcd_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *cmd)
lrbp->req_abort_skip = false;
- ufshpb_prep(hba, lrbp);
+ err = ufshpb_prep(hba, lrbp);
+ if (err == -EAGAIN) {
+ lrbp->cmd = NULL;
+ ufshcd_release(hba);
+ goto out;
+ }
ufshcd_comp_scsi_upiu(hba, lrbp);
@@ -3107,7 +3112,7 @@ int ufshcd_query_attr(struct ufs_hba *hba, enum query_opcode opcode,
*
* Returns 0 for success, non-zero in case of failure
*/
-static int ufshcd_query_attr_retry(struct ufs_hba *hba,
+int ufshcd_query_attr_retry(struct ufs_hba *hba,
enum query_opcode opcode, enum attr_idn idn, u8 index, u8 selector,
u32 *attr_val)
{
@@ -4862,7 +4867,8 @@ static int ufshcd_change_queue_depth(struct scsi_device *sdev, int 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))
+ if ((sdev->lun >= UFS_UPIU_MAX_UNIT_NUM_ID) ||
+ !(hba->dev_info.hpb_enabled) || !ufshpb_is_allowed(hba))
return;
ufshpb_destroy_lu(hba, sdev);
@@ -7454,8 +7460,18 @@ static int ufs_get_device_desc(struct ufs_hba *hba)
if (dev_info->wspecversion >= UFS_DEV_HPB_SUPPORT_VERSION &&
(b_ufs_feature_sup & UFS_DEV_HPB_SUPPORT)) {
- dev_info->hpb_enabled = true;
+ bool hpb_en = false;
+
ufshpb_get_dev_info(hba, desc_buf);
+
+ if (!ufshpb_is_legacy(hba))
+ err = ufshcd_query_flag_retry(hba,
+ UPIU_QUERY_OPCODE_READ_FLAG,
+ QUERY_FLAG_IDN_HPB_EN, 0,
+ &hpb_en);
+
+ if (ufshpb_is_legacy(hba) || (!err && hpb_en))
+ dev_info->hpb_enabled = true;
}
err = ufshcd_read_string_desc(hba, model_index,
@@ -8028,6 +8044,7 @@ static const struct attribute_group *ufshcd_driver_groups[] = {
&ufs_sysfs_lun_attributes_group,
#ifdef CONFIG_SCSI_UFS_HPB
&ufs_sysfs_hpb_stat_group,
+ &ufs_sysfs_hpb_param_group,
#endif
NULL,
};
diff --git a/drivers/scsi/ufs/ufshcd.h b/drivers/scsi/ufs/ufshcd.h
index 008a5f7146c0..8aca8f327981 100644
--- a/drivers/scsi/ufs/ufshcd.h
+++ b/drivers/scsi/ufs/ufshcd.h
@@ -654,6 +654,8 @@ struct ufs_hba_variant_params {
* @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
+ * @max_hpb_single_cmd: maximum size of single HPB command
+ * @is_legacy: flag to check HPB 1.0
*/
struct ufshpb_dev_info {
int num_lu;
@@ -661,6 +663,8 @@ struct ufshpb_dev_info {
int srgn_size;
atomic_t slave_conf_cnt;
bool hpb_disabled;
+ int max_hpb_single_cmd;
+ bool is_legacy;
};
#endif
@@ -1096,6 +1100,9 @@ int ufshcd_read_desc_param(struct ufs_hba *hba,
u8 param_offset,
u8 *param_read_buf,
u8 param_size);
+int ufshcd_query_attr_retry(struct ufs_hba *hba, enum query_opcode opcode,
+ enum attr_idn idn, u8 index, u8 selector,
+ u32 *attr_val);
int ufshcd_query_attr(struct ufs_hba *hba, enum query_opcode opcode,
enum attr_idn idn, u8 index, u8 selector, u32 *attr_val);
int ufshcd_query_flag(struct ufs_hba *hba, enum query_opcode opcode,
diff --git a/drivers/scsi/ufs/ufshpb.c b/drivers/scsi/ufs/ufshpb.c
index f789339f68d9..3ac8b0a9e8d3 100644
--- a/drivers/scsi/ufs/ufshpb.c
+++ b/drivers/scsi/ufs/ufshpb.c
@@ -31,6 +31,11 @@ bool ufshpb_is_allowed(struct ufs_hba *hba)
return !(hba->ufshpb_dev.hpb_disabled);
}
+bool ufshpb_is_legacy(struct ufs_hba *hba)
+{
+ return hba->ufshpb_dev.is_legacy;
+}
+
static struct ufshpb_lu *ufshpb_get_hpb_data(struct scsi_device *sdev)
{
return sdev->hostdata;
@@ -64,9 +69,19 @@ static bool ufshpb_is_write_or_discard_cmd(struct scsi_cmnd *cmd)
op_is_discard(req_op(cmd->request));
}
-static bool ufshpb_is_support_chunk(int transfer_len)
+static bool ufshpb_is_support_chunk(struct ufshpb_lu *hpb, int transfer_len)
{
- return transfer_len <= HPB_MULTI_CHUNK_HIGH;
+ return transfer_len <= hpb->pre_req_max_tr_len;
+}
+
+/*
+ * In this driver, WRITE_BUFFER CMD support 36KB (len=9) ~ 512KB (len=128) as
+ * default. It is possible to change range of transfer_len through sysfs.
+ */
+static inline bool ufshpb_is_required_wb(struct ufshpb_lu *hpb, int len)
+{
+ return (len > hpb->pre_req_min_tr_len &&
+ len <= hpb->pre_req_max_tr_len);
}
static bool ufshpb_is_general_lun(int lun)
@@ -74,8 +89,7 @@ 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)
+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 &&
@@ -264,7 +278,8 @@ ufshpb_get_pos_from_lpn(struct ufshpb_lu *hpb, unsigned long lpn, int *rgn_idx,
static void
ufshpb_set_hpb_read_to_upiu(struct ufshpb_lu *hpb, struct ufshcd_lrb *lrbp,
- u32 lpn, u64 ppn, unsigned int transfer_len)
+ u32 lpn, u64 ppn, unsigned int transfer_len,
+ int read_id)
{
unsigned char *cdb = lrbp->cmd->cmnd;
@@ -273,15 +288,261 @@ ufshpb_set_hpb_read_to_upiu(struct ufshpb_lu *hpb, struct ufshcd_lrb *lrbp,
/* ppn value is stored as big-endian in the host memory */
memcpy(&cdb[6], &ppn, sizeof(u64));
cdb[14] = transfer_len;
+ cdb[15] = read_id;
lrbp->cmd->cmd_len = UFS_CDB_SIZE;
}
+static inline void ufshpb_set_write_buf_cmd(unsigned char *cdb,
+ unsigned long lpn, unsigned int len,
+ int read_id)
+{
+ cdb[0] = UFSHPB_WRITE_BUFFER;
+ cdb[1] = UFSHPB_WRITE_BUFFER_PREFETCH_ID;
+
+ put_unaligned_be32(lpn, &cdb[2]);
+ cdb[6] = read_id;
+ put_unaligned_be16(len * HPB_ENTRY_SIZE, &cdb[7]);
+
+ cdb[9] = 0x00; /* Control = 0x00 */
+}
+
+static struct ufshpb_req *ufshpb_get_pre_req(struct ufshpb_lu *hpb)
+{
+ struct ufshpb_req *pre_req;
+
+ if (hpb->num_inflight_pre_req >= hpb->throttle_pre_req) {
+ dev_info(&hpb->sdev_ufs_lu->sdev_dev,
+ "pre_req throttle. inflight %d throttle %d",
+ hpb->num_inflight_pre_req, hpb->throttle_pre_req);
+ return NULL;
+ }
+
+ pre_req = list_first_entry_or_null(&hpb->lh_pre_req_free,
+ struct ufshpb_req, list_req);
+ if (!pre_req) {
+ dev_info(&hpb->sdev_ufs_lu->sdev_dev, "There is no pre_req");
+ return NULL;
+ }
+
+ list_del_init(&pre_req->list_req);
+ hpb->num_inflight_pre_req++;
+
+ return pre_req;
+}
+
+static inline void ufshpb_put_pre_req(struct ufshpb_lu *hpb,
+ struct ufshpb_req *pre_req)
+{
+ pre_req->req = NULL;
+ bio_reset(pre_req->bio);
+ list_add_tail(&pre_req->list_req, &hpb->lh_pre_req_free);
+ hpb->num_inflight_pre_req--;
+}
+
+static void ufshpb_pre_req_compl_fn(struct request *req, blk_status_t error)
+{
+ struct ufshpb_req *pre_req = (struct ufshpb_req *)req->end_io_data;
+ struct ufshpb_lu *hpb = pre_req->hpb;
+ unsigned long flags;
+
+ if (error) {
+ struct scsi_request *rq = scsi_req(req);
+ struct scsi_sense_hdr sshdr;
+
+ dev_err(&hpb->sdev_ufs_lu->sdev_dev, "block status %d", error);
+ scsi_normalize_sense(rq->sense, SCSI_SENSE_BUFFERSIZE,
+ &sshdr);
+ dev_err(&hpb->sdev_ufs_lu->sdev_dev,
+ "code %x sense_key %x asc %x ascq %x",
+ sshdr.response_code,
+ sshdr.sense_key, sshdr.asc, sshdr.ascq);
+ dev_err(&hpb->sdev_ufs_lu->sdev_dev,
+ "byte4 %x byte5 %x byte6 %x additional_len %x",
+ sshdr.byte4, sshdr.byte5,
+ sshdr.byte6, sshdr.additional_length);
+ }
+
+ blk_mq_free_request(req);
+ spin_lock_irqsave(&hpb->rgn_state_lock, flags);
+ ufshpb_put_pre_req(pre_req->hpb, pre_req);
+ spin_unlock_irqrestore(&hpb->rgn_state_lock, flags);
+}
+
+static int ufshpb_prep_entry(struct ufshpb_req *pre_req, struct page *page)
+{
+ struct ufshpb_lu *hpb = pre_req->hpb;
+ struct ufshpb_region *rgn;
+ struct ufshpb_subregion *srgn;
+ u64 *addr;
+ int offset = 0;
+ int copied;
+ unsigned long lpn = pre_req->wb.lpn;
+ int rgn_idx, srgn_idx, srgn_offset;
+ unsigned long flags;
+
+ addr = page_address(page);
+ ufshpb_get_pos_from_lpn(hpb, lpn, &rgn_idx, &srgn_idx, &srgn_offset);
+
+ spin_lock_irqsave(&hpb->rgn_state_lock, flags);
+
+next_offset:
+ rgn = hpb->rgn_tbl + rgn_idx;
+ srgn = rgn->srgn_tbl + srgn_idx;
+
+ if (!ufshpb_is_valid_srgn(rgn, srgn))
+ goto mctx_error;
+
+ if (!srgn->mctx)
+ goto mctx_error;
+
+ copied = ufshpb_fill_ppn_from_page(hpb, srgn->mctx, srgn_offset,
+ pre_req->wb.len - offset,
+ &addr[offset]);
+
+ if (copied < 0)
+ goto mctx_error;
+
+ offset += copied;
+ srgn_offset += copied;
+
+ if (srgn_offset == hpb->entries_per_srgn) {
+ srgn_offset = 0;
+
+ if (++srgn_idx == hpb->srgns_per_rgn) {
+ srgn_idx = 0;
+ rgn_idx++;
+ }
+ }
+
+ if (offset < pre_req->wb.len)
+ goto next_offset;
+
+ spin_unlock_irqrestore(&hpb->rgn_state_lock, flags);
+ return 0;
+mctx_error:
+ spin_unlock_irqrestore(&hpb->rgn_state_lock, flags);
+ return -ENOMEM;
+}
+
+static int ufshpb_pre_req_add_bio_page(struct ufshpb_lu *hpb,
+ struct request_queue *q,
+ struct ufshpb_req *pre_req)
+{
+ struct page *page = pre_req->wb.m_page;
+ struct bio *bio = pre_req->bio;
+ int entries_bytes, ret;
+
+ if (!page)
+ return -ENOMEM;
+
+ if (ufshpb_prep_entry(pre_req, page))
+ return -ENOMEM;
+
+ entries_bytes = pre_req->wb.len * sizeof(u64);
+
+ ret = bio_add_pc_page(q, bio, page, entries_bytes, 0);
+ if (ret != entries_bytes) {
+ dev_err(&hpb->sdev_ufs_lu->sdev_dev,
+ "bio_add_pc_page fail: %d", ret);
+ return -ENOMEM;
+ }
+ return 0;
+}
+
+static inline int ufshpb_get_read_id(struct ufshpb_lu *hpb)
+{
+ if (++hpb->cur_read_id >= MAX_HPB_READ_ID)
+ hpb->cur_read_id = 1;
+ return hpb->cur_read_id;
+}
+
+static int ufshpb_execute_pre_req(struct ufshpb_lu *hpb, struct scsi_cmnd *cmd,
+ struct ufshpb_req *pre_req, int read_id)
+{
+ struct scsi_device *sdev = cmd->device;
+ struct request_queue *q = sdev->request_queue;
+ struct request *req;
+ struct scsi_request *rq;
+ struct bio *bio = pre_req->bio;
+
+ pre_req->hpb = hpb;
+ pre_req->wb.lpn = sectors_to_logical(cmd->device,
+ blk_rq_pos(cmd->request));
+ pre_req->wb.len = sectors_to_logical(cmd->device,
+ blk_rq_sectors(cmd->request));
+ if (ufshpb_pre_req_add_bio_page(hpb, q, pre_req))
+ return -ENOMEM;
+
+ req = pre_req->req;
+
+ /* 1. request setup */
+ blk_rq_append_bio(req, &bio);
+ req->rq_disk = NULL;
+ req->end_io_data = (void *)pre_req;
+ req->end_io = ufshpb_pre_req_compl_fn;
+
+ /* 2. scsi_request setup */
+ rq = scsi_req(req);
+ rq->retries = 1;
+
+ ufshpb_set_write_buf_cmd(rq->cmd, pre_req->wb.lpn, pre_req->wb.len,
+ read_id);
+ rq->cmd_len = scsi_command_size(rq->cmd);
+
+ if (blk_insert_cloned_request(q, req) != BLK_STS_OK)
+ return -EAGAIN;
+
+ hpb->stats.pre_req_cnt++;
+
+ return 0;
+}
+
+static int ufshpb_issue_pre_req(struct ufshpb_lu *hpb, struct scsi_cmnd *cmd,
+ int *read_id)
+{
+ struct ufshpb_req *pre_req;
+ struct request *req = NULL;
+ unsigned long flags;
+ int _read_id;
+ int ret = 0;
+
+ req = blk_get_request(cmd->device->request_queue,
+ REQ_OP_SCSI_OUT | REQ_SYNC, BLK_MQ_REQ_NOWAIT);
+ if (IS_ERR(req))
+ return -EAGAIN;
+
+ spin_lock_irqsave(&hpb->rgn_state_lock, flags);
+ pre_req = ufshpb_get_pre_req(hpb);
+ if (!pre_req) {
+ ret = -EAGAIN;
+ goto unlock_out;
+ }
+ _read_id = ufshpb_get_read_id(hpb);
+ spin_unlock_irqrestore(&hpb->rgn_state_lock, flags);
+
+ pre_req->req = req;
+
+ ret = ufshpb_execute_pre_req(hpb, cmd, pre_req, _read_id);
+ if (ret)
+ goto free_pre_req;
+
+ *read_id = _read_id;
+
+ return ret;
+free_pre_req:
+ spin_lock_irqsave(&hpb->rgn_state_lock, flags);
+ ufshpb_put_pre_req(hpb, pre_req);
+unlock_out:
+ spin_unlock_irqrestore(&hpb->rgn_state_lock, flags);
+ blk_put_request(req);
+ return ret;
+}
+
/*
* 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)
+int ufshpb_prep(struct ufs_hba *hba, struct ufshcd_lrb *lrbp)
{
struct ufshpb_lu *hpb;
struct ufshpb_region *rgn;
@@ -291,19 +552,20 @@ void ufshpb_prep(struct ufs_hba *hba, struct ufshcd_lrb *lrbp)
u64 ppn;
unsigned long flags;
int transfer_len, rgn_idx, srgn_idx, srgn_offset;
+ int read_id = 0;
int err = 0;
hpb = ufshpb_get_hpb_data(cmd->device);
if (!hpb)
- return;
+ return -ENODEV;
if (ufshpb_get_state(hpb) == HPB_INIT)
- return;
+ return -ENODEV;
if (ufshpb_get_state(hpb) != HPB_PRESENT) {
dev_notice(&hpb->sdev_ufs_lu->sdev_dev,
"%s: ufshpb state is not PRESENT", __func__);
- return;
+ return -ENODEV;
}
if (blk_rq_is_scsi(cmd->request) ||
@@ -314,7 +576,7 @@ void ufshpb_prep(struct ufs_hba *hba, struct ufshcd_lrb *lrbp)
transfer_len = sectors_to_logical(cmd->device,
blk_rq_sectors(cmd->request));
if (unlikely(!transfer_len))
- return;
+ return 0;
lpn = sectors_to_logical(cmd->device, blk_rq_pos(cmd->request));
ufshpb_get_pos_from_lpn(hpb, lpn, &rgn_idx, &srgn_idx, &srgn_offset);
@@ -327,18 +589,18 @@ void ufshpb_prep(struct ufs_hba *hba, struct ufshcd_lrb *lrbp)
ufshpb_set_ppn_dirty(hpb, rgn_idx, srgn_idx, srgn_offset,
transfer_len);
spin_unlock_irqrestore(&hpb->rgn_state_lock, flags);
- return;
+ return 0;
}
- if (!ufshpb_is_support_chunk(transfer_len))
- return;
+ if (!ufshpb_is_support_chunk(hpb, transfer_len))
+ return 0;
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;
+ return 0;
}
err = ufshpb_fill_ppn_from_page(hpb, srgn->mctx, srgn_offset, 1, &ppn);
@@ -351,64 +613,101 @@ void ufshpb_prep(struct ufs_hba *hba, struct ufshcd_lrb *lrbp)
* active state.
*/
dev_err(hba->dev, "get ppn failed. err %d\n", err);
- return;
+ return err;
+ }
+ if (!ufshpb_is_legacy(hba) &&
+ ufshpb_is_required_wb(hpb, transfer_len)) {
+ err = ufshpb_issue_pre_req(hpb, cmd, &read_id);
+ if (err) {
+ unsigned long timeout;
+
+ timeout = cmd->jiffies_at_alloc + msecs_to_jiffies(
+ hpb->params.requeue_timeout_ms);
+
+ if (time_before(jiffies, timeout))
+ return -EAGAIN;
+
+ hpb->stats.miss_cnt++;
+ return 0;
+ }
}
- ufshpb_set_hpb_read_to_upiu(hpb, lrbp, lpn, ppn, transfer_len);
+ ufshpb_set_hpb_read_to_upiu(hpb, lrbp, lpn, ppn, transfer_len, read_id);
hpb->stats.hit_cnt++;
+ return 0;
}
-static struct ufshpb_req *ufshpb_get_map_req(struct ufshpb_lu *hpb,
- struct ufshpb_subregion *srgn)
+
+static struct ufshpb_req *ufshpb_get_req(struct ufshpb_lu *hpb,
+ int rgn_idx, enum req_opf dir,
+ bool atomic)
{
- struct ufshpb_req *map_req;
+ struct ufshpb_req *rq;
struct request *req;
- struct bio *bio;
int retries = HPB_MAP_REQ_RETRIES;
- map_req = kmem_cache_alloc(hpb->map_req_cache, GFP_KERNEL);
- if (!map_req)
+ rq = kmem_cache_alloc(hpb->map_req_cache, GFP_ATOMIC);
+ if (!rq)
return NULL;
retry:
- req = blk_get_request(hpb->sdev_ufs_lu->request_queue,
- REQ_OP_SCSI_IN, BLK_MQ_REQ_NOWAIT);
+ req = blk_get_request(hpb->sdev_ufs_lu->request_queue, dir,
+ BLK_MQ_REQ_NOWAIT);
- if ((PTR_ERR(req) == -EWOULDBLOCK) && (--retries > 0)) {
+ if (!atomic && (PTR_ERR(req) == -EWOULDBLOCK) && (--retries > 0)) {
usleep_range(3000, 3100);
goto retry;
}
if (IS_ERR(req))
- goto free_map_req;
+ goto free_rq;
+
+ rq->hpb = hpb;
+ rq->req = req;
+ rq->rb.rgn_idx = rgn_idx;
+
+ return rq;
+
+free_rq:
+ kmem_cache_free(hpb->map_req_cache, rq);
+ return NULL;
+}
+
+static void ufshpb_put_req(struct ufshpb_lu *hpb, struct ufshpb_req *rq)
+{
+ blk_put_request(rq->req);
+ kmem_cache_free(hpb->map_req_cache, rq);
+}
+
+static struct ufshpb_req *ufshpb_get_map_req(struct ufshpb_lu *hpb,
+ struct ufshpb_subregion *srgn)
+{
+ struct ufshpb_req *map_req;
+ struct bio *bio;
+
+ map_req = ufshpb_get_req(hpb, srgn->rgn_idx, REQ_OP_SCSI_IN, false);
+ if (!map_req)
+ return NULL;
bio = bio_alloc(GFP_KERNEL, hpb->pages_per_srgn);
if (!bio) {
- blk_put_request(req);
- goto free_map_req;
+ ufshpb_put_req(hpb, map_req);
+ return NULL;
}
- 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->rb.srgn_idx = srgn->srgn_idx;
+ map_req->rb.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);
+ ufshpb_put_req(hpb, map_req);
}
static int ufshpb_clear_dirty_bitmap(struct ufshpb_lu *hpb,
@@ -491,6 +790,13 @@ static void ufshpb_activate_subregion(struct ufshpb_lu *hpb,
srgn->srgn_state = HPB_SRGN_VALID;
}
+static void ufshpb_umap_req_compl_fn(struct request *req, blk_status_t error)
+{
+ struct ufshpb_req *umap_req = (struct ufshpb_req *)req->end_io_data;
+
+ ufshpb_put_req(umap_req->hpb, umap_req);
+}
+
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;
@@ -498,8 +804,8 @@ static void ufshpb_map_req_compl_fn(struct request *req, blk_status_t error)
struct ufshpb_subregion *srgn;
unsigned long flags;
- srgn = hpb->rgn_tbl[map_req->rgn_idx].srgn_tbl +
- map_req->srgn_idx;
+ srgn = hpb->rgn_tbl[map_req->rb.rgn_idx].srgn_tbl +
+ map_req->rb.srgn_idx;
ufshpb_clear_dirty_bitmap(hpb, srgn);
spin_lock_irqsave(&hpb->rgn_state_lock, flags);
@@ -509,6 +815,16 @@ static void ufshpb_map_req_compl_fn(struct request *req, blk_status_t error)
ufshpb_put_map_req(map_req->hpb, map_req);
}
+static void ufshpb_set_unmap_cmd(unsigned char *cdb, struct ufshpb_region *rgn)
+{
+ cdb[0] = UFSHPB_WRITE_BUFFER;
+ cdb[1] = rgn ? UFSHPB_WRITE_BUFFER_INACT_SINGLE_ID :
+ UFSHPB_WRITE_BUFFER_INACT_ALL_ID;
+ if (rgn)
+ put_unaligned_be16(rgn->rgn_idx, &cdb[2]);
+ cdb[9] = 0x00;
+}
+
static void ufshpb_set_read_buf_cmd(unsigned char *cdb, int rgn_idx,
int srgn_idx, int srgn_mem_size)
{
@@ -522,6 +838,25 @@ static void ufshpb_set_read_buf_cmd(unsigned char *cdb, int rgn_idx,
cdb[9] = 0x00;
}
+static int ufshpb_execute_umap_req(struct ufshpb_lu *hpb,
+ struct ufshpb_req *umap_req,
+ struct ufshpb_region *rgn)
+{
+ struct request *req;
+ struct scsi_request *rq;
+
+ req = umap_req->req;
+ req->timeout = 0;
+ req->end_io_data = (void *)umap_req;
+ rq = scsi_req(req);
+ ufshpb_set_unmap_cmd(rq->cmd, rgn);
+ rq->cmd_len = HPB_WRITE_BUFFER_CMD_LENGTH;
+
+ blk_execute_rq_nowait(NULL, req, 1, ufshpb_umap_req_compl_fn);
+
+ return 0;
+}
+
static int ufshpb_execute_map_req(struct ufshpb_lu *hpb,
struct ufshpb_req *map_req, bool last)
{
@@ -534,12 +869,12 @@ static int ufshpb_execute_map_req(struct ufshpb_lu *hpb,
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],
+ ret = bio_add_pc_page(q, map_req->bio, map_req->rb.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);
+ map_req->rb.rgn_idx, map_req->rb.srgn_idx);
return ret;
}
}
@@ -555,8 +890,8 @@ static int ufshpb_execute_map_req(struct ufshpb_lu *hpb,
if (unlikely(last))
mem_size = hpb->last_srgn_entries * HPB_ENTRY_SIZE;
- ufshpb_set_read_buf_cmd(rq->cmd, map_req->rgn_idx,
- map_req->srgn_idx, mem_size);
+ ufshpb_set_read_buf_cmd(rq->cmd, map_req->rb.rgn_idx,
+ map_req->rb.srgn_idx, mem_size);
rq->cmd_len = HPB_READ_BUFFER_CMD_LENGTH;
blk_execute_rq_nowait(NULL, req, 1, ufshpb_map_req_compl_fn);
@@ -688,6 +1023,31 @@ static void ufshpb_purge_active_subregion(struct ufshpb_lu *hpb,
}
}
+static int ufshpb_issue_umap_req(struct ufshpb_lu *hpb,
+ struct ufshpb_region *rgn, bool atomic)
+{
+ struct ufshpb_req *umap_req;
+ int rgn_idx = rgn ? rgn->rgn_idx : 0;
+
+ umap_req = ufshpb_get_req(hpb, rgn_idx, REQ_OP_SCSI_OUT, atomic);
+ if (!umap_req)
+ return -ENOMEM;
+
+ if (ufshpb_execute_umap_req(hpb, umap_req, rgn))
+ goto free_umap_req;
+
+ return 0;
+
+free_umap_req:
+ ufshpb_put_req(hpb, umap_req);
+ return -EAGAIN;
+}
+
+static int ufshpb_issue_umap_all_req(struct ufshpb_lu *hpb)
+{
+ return ufshpb_issue_umap_req(hpb, NULL, false);
+}
+
static void __ufshpb_evict_region(struct ufshpb_lu *hpb,
struct ufshpb_region *rgn)
{
@@ -1210,6 +1570,17 @@ static void ufshpb_lu_parameter_init(struct ufs_hba *hba,
u32 entries_per_rgn;
u64 rgn_mem_size, tmp;
+ /* for pre_req */
+ hpb->pre_req_min_tr_len = hpb_dev_info->max_hpb_single_cmd + 1;
+
+ if (ufshpb_is_legacy(hba))
+ hpb->pre_req_max_tr_len = HPB_LEGACY_CHUNK_HIGH;
+ else
+ hpb->pre_req_max_tr_len = max(HPB_MULTI_CHUNK_HIGH,
+ hpb->pre_req_min_tr_len);
+
+ hpb->cur_read_id = 0;
+
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)
@@ -1357,7 +1728,7 @@ 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[] = {
+static struct attribute *hpb_dev_stat_attrs[] = {
&dev_attr_hit_cnt.attr,
&dev_attr_miss_cnt.attr,
&dev_attr_rb_noti_cnt.attr,
@@ -1368,10 +1739,118 @@ static struct attribute *hpb_dev_attrs[] = {
};
struct attribute_group ufs_sysfs_hpb_stat_group = {
- .name = "hpb_sysfs",
- .attrs = hpb_dev_attrs,
+ .name = "hpb_stat_sysfs",
+ .attrs = hpb_dev_stat_attrs,
};
+/* SYSFS functions */
+#define ufshpb_sysfs_param_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, "%d\n", hpb->params.__name); \
+}
+
+ufshpb_sysfs_param_show_func(requeue_timeout_ms);
+static ssize_t
+requeue_timeout_ms_store(struct device *dev, struct device_attribute *attr,
+ const char *buf, size_t count)
+{
+ struct scsi_device *sdev = to_scsi_device(dev);
+ struct ufshpb_lu *hpb = ufshpb_get_hpb_data(sdev);
+ int val;
+
+ if (!hpb)
+ return -ENODEV;
+
+ if (kstrtouint(buf, 0, &val))
+ return -EINVAL;
+
+ if (val < 0)
+ return -EINVAL;
+
+ hpb->params.requeue_timeout_ms = val;
+
+ return count;
+}
+static DEVICE_ATTR_RW(requeue_timeout_ms);
+
+static struct attribute *hpb_dev_param_attrs[] = {
+ &dev_attr_requeue_timeout_ms.attr,
+ NULL,
+};
+
+struct attribute_group ufs_sysfs_hpb_param_group = {
+ .name = "hpb_param_sysfs",
+ .attrs = hpb_dev_param_attrs,
+};
+
+static int ufshpb_pre_req_mempool_init(struct ufshpb_lu *hpb)
+{
+ struct ufshpb_req *pre_req = NULL, *t;
+ int qd = hpb->sdev_ufs_lu->queue_depth / 2;
+ int i;
+
+ INIT_LIST_HEAD(&hpb->lh_pre_req_free);
+
+ hpb->pre_req = kcalloc(qd, sizeof(struct ufshpb_req), GFP_KERNEL);
+ hpb->throttle_pre_req = qd;
+ hpb->num_inflight_pre_req = 0;
+
+ if (!hpb->pre_req)
+ goto release_mem;
+
+ for (i = 0; i < qd; i++) {
+ pre_req = hpb->pre_req + i;
+ INIT_LIST_HEAD(&pre_req->list_req);
+ pre_req->req = NULL;
+
+ pre_req->bio = bio_alloc(GFP_KERNEL, 1);
+ if (!pre_req->bio)
+ goto release_mem;
+
+ pre_req->wb.m_page = alloc_page(GFP_KERNEL | __GFP_ZERO);
+ if (!pre_req->wb.m_page) {
+ bio_put(pre_req->bio);
+ goto release_mem;
+ }
+
+ list_add_tail(&pre_req->list_req, &hpb->lh_pre_req_free);
+ }
+
+ return 0;
+release_mem:
+ list_for_each_entry_safe(pre_req, t, &hpb->lh_pre_req_free, list_req) {
+ list_del_init(&pre_req->list_req);
+ bio_put(pre_req->bio);
+ __free_page(pre_req->wb.m_page);
+ }
+
+ kfree(hpb->pre_req);
+ return -ENOMEM;
+}
+
+static void ufshpb_pre_req_mempool_destroy(struct ufshpb_lu *hpb)
+{
+ struct ufshpb_req *pre_req = NULL;
+ int i;
+
+ for (i = 0; i < hpb->throttle_pre_req; i++) {
+ pre_req = hpb->pre_req + i;
+ bio_put(hpb->pre_req[i].bio);
+ if (!pre_req->wb.m_page)
+ __free_page(hpb->pre_req[i].wb.m_page);
+ list_del_init(&pre_req->list_req);
+ }
+
+ kfree(hpb->pre_req);
+}
+
static void ufshpb_stat_init(struct ufshpb_lu *hpb)
{
hpb->stats.hit_cnt = 0;
@@ -1382,6 +1861,11 @@ static void ufshpb_stat_init(struct ufshpb_lu *hpb)
hpb->stats.map_req_cnt = 0;
}
+static void ufshpb_param_init(struct ufshpb_lu *hpb)
+{
+ hpb->params.requeue_timeout_ms = HPB_REQUEUE_TIME_MS;
+}
+
static int ufshpb_lu_hpb_init(struct ufs_hba *hba, struct ufshpb_lu *hpb)
{
int ret;
@@ -1414,14 +1898,24 @@ static int ufshpb_lu_hpb_init(struct ufs_hba *hba, struct ufshpb_lu *hpb)
goto release_req_cache;
}
+ ret = ufshpb_pre_req_mempool_init(hpb);
+ if (ret) {
+ dev_err(hba->dev, "ufshpb(%d) pre_req_mempool init fail",
+ hpb->lun);
+ goto release_m_page_cache;
+ }
+
ret = ufshpb_alloc_region_tbl(hba, hpb);
if (ret)
- goto release_m_page_cache;
+ goto release_pre_req_mempool;
ufshpb_stat_init(hpb);
+ ufshpb_param_init(hpb);
return 0;
+release_pre_req_mempool:
+ ufshpb_pre_req_mempool_destroy(hpb);
release_m_page_cache:
kmem_cache_destroy(hpb->m_page_cache);
release_req_cache:
@@ -1430,7 +1924,7 @@ static int ufshpb_lu_hpb_init(struct ufs_hba *hba, struct ufshpb_lu *hpb)
}
static struct ufshpb_lu *
-ufshpb_alloc_hpb_lu(struct ufs_hba *hba, int lun,
+ufshpb_alloc_hpb_lu(struct ufs_hba *hba, struct scsi_device *sdev,
struct ufshpb_dev_info *hpb_dev_info,
struct ufshpb_lu_info *hpb_lu_info)
{
@@ -1441,7 +1935,8 @@ ufshpb_alloc_hpb_lu(struct ufs_hba *hba, int lun,
if (!hpb)
return NULL;
- hpb->lun = lun;
+ hpb->lun = sdev->lun;
+ hpb->sdev_ufs_lu = sdev;
ufshpb_lu_parameter_init(hba, hpb, hpb_dev_info, hpb_lu_info);
@@ -1451,6 +1946,7 @@ ufshpb_alloc_hpb_lu(struct ufs_hba *hba, int lun,
goto release_hpb;
}
+ sdev->hostdata = hpb;
return hpb;
release_hpb:
@@ -1653,6 +2149,7 @@ void ufshpb_destroy_lu(struct ufs_hba *hba, struct scsi_device *sdev)
ufshpb_cancel_jobs(hpb);
+ ufshpb_pre_req_mempool_destroy(hpb);
ufshpb_destroy_region_tbl(hpb);
kmem_cache_destroy(hpb->map_req_cache);
@@ -1692,6 +2189,7 @@ static void ufshpb_hpb_lu_prepared(struct ufs_hba *hba)
ufshpb_set_state(hpb, HPB_PRESENT);
if ((hpb->lu_pinned_end - hpb->lu_pinned_start) > 0)
queue_work(ufshpb_wq, &hpb->map_work);
+ ufshpb_issue_umap_all_req(hpb);
} else {
dev_err(hba->dev, "destroy HPB lu %d\n", hpb->lun);
ufshpb_destroy_lu(hba, sdev);
@@ -1716,7 +2214,7 @@ void ufshpb_init_hpb_lu(struct ufs_hba *hba, struct scsi_device *sdev)
if (ret)
goto out;
- hpb = ufshpb_alloc_hpb_lu(hba, lun, &hba->ufshpb_dev,
+ hpb = ufshpb_alloc_hpb_lu(hba, sdev, &hba->ufshpb_dev,
&hpb_lu_info);
if (!hpb)
goto out;
@@ -1724,9 +2222,6 @@ void ufshpb_init_hpb_lu(struct ufs_hba *hba, struct scsi_device *sdev)
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;
-
out:
/* All LUs are initialized */
if (atomic_dec_and_test(&hba->ufshpb_dev.slave_conf_cnt))
@@ -1813,8 +2308,9 @@ void ufshpb_get_geo_info(struct ufs_hba *hba, u8 *geo_buf)
void ufshpb_get_dev_info(struct ufs_hba *hba, u8 *desc_buf)
{
struct ufshpb_dev_info *hpb_dev_info = &hba->ufshpb_dev;
- int version;
+ int version, ret;
u8 hpb_mode;
+ u32 max_hpb_single_cmd = HPB_MULTI_CHUNK_LOW;
hpb_mode = desc_buf[DEVICE_DESC_PARAM_HPB_CONTROL];
if (hpb_mode == HPB_HOST_CONTROL) {
@@ -1825,13 +2321,27 @@ void ufshpb_get_dev_info(struct ufs_hba *hba, u8 *desc_buf)
}
version = get_unaligned_be16(desc_buf + DEVICE_DESC_PARAM_HPB_VER);
- if (version != HPB_SUPPORT_VERSION) {
+ if ((version != HPB_SUPPORT_VERSION) &&
+ (version != HPB_SUPPORT_LEGACY_VERSION)) {
dev_err(hba->dev, "%s: HPB %x version is not supported.\n",
__func__, version);
hpb_dev_info->hpb_disabled = true;
return;
}
+ if (version == HPB_SUPPORT_LEGACY_VERSION)
+ hpb_dev_info->is_legacy = true;
+
+ pm_runtime_get_sync(hba->dev);
+ ret = ufshcd_query_attr_retry(hba, UPIU_QUERY_OPCODE_READ_ATTR,
+ QUERY_ATTR_IDN_MAX_HPB_SINGLE_CMD, 0, 0, &max_hpb_single_cmd);
+ pm_runtime_put_sync(hba->dev);
+
+ if (ret)
+ dev_err(hba->dev, "%s: idn: read max size of single hpb cmd query request failed",
+ __func__);
+ hpb_dev_info->max_hpb_single_cmd = max_hpb_single_cmd;
+
/*
* Get the number of user logical unit to check whether all
* scsi_device finish initialization
diff --git a/drivers/scsi/ufs/ufshpb.h b/drivers/scsi/ufs/ufshpb.h
index 6e6a0252dc15..b1128b0ce486 100644
--- a/drivers/scsi/ufs/ufshpb.h
+++ b/drivers/scsi/ufs/ufshpb.h
@@ -30,19 +30,29 @@
#define PINNED_NOT_SET U32_MAX
/* hpb support chunk size */
-#define HPB_MULTI_CHUNK_HIGH 1
+#define HPB_LEGACY_CHUNK_HIGH 1
+#define HPB_MULTI_CHUNK_LOW 7
+#define HPB_MULTI_CHUNK_HIGH 128
/* hpb vender defined opcode */
#define UFSHPB_READ 0xF8
#define UFSHPB_READ_BUFFER 0xF9
#define UFSHPB_READ_BUFFER_ID 0x01
+#define UFSHPB_WRITE_BUFFER 0xFA
+#define UFSHPB_WRITE_BUFFER_INACT_SINGLE_ID 0x01
+#define UFSHPB_WRITE_BUFFER_PREFETCH_ID 0x02
+#define UFSHPB_WRITE_BUFFER_INACT_ALL_ID 0x03
+#define HPB_WRITE_BUFFER_CMD_LENGTH 10
+#define MAX_HPB_READ_ID 0x7F
#define HPB_READ_BUFFER_CMD_LENGTH 10
#define LU_ENABLED_HPB_FUNC 0x02
#define HPB_RESET_REQ_RETRIES 10
#define HPB_MAP_REQ_RETRIES 5
+#define HPB_REQUEUE_TIME_MS 0
-#define HPB_SUPPORT_VERSION 0x100
+#define HPB_SUPPORT_VERSION 0x200
+#define HPB_SUPPORT_LEGACY_VERSION 0x100
enum UFSHPB_MODE {
HPB_HOST_CONTROL,
@@ -119,23 +129,38 @@ struct ufshpb_region {
(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
+ * struct ufshpb_req - HPB related request structure (write/read buffer)
+ * @req: block layer request structure
+ * @bio: bio for this request
+ * @hpb: ufshpb_lu structure that related to
+ * @list_req: ufshpb_req mempool list
+ * @sense: store its sense data
* @mctx: L2P map information
* @rgn_idx: target region index
* @srgn_idx: target sub-region index
* @lun: target logical unit number
+ * @m_page: L2P map information data for pre-request
+ * @len: length of host-side cached L2P map in m_page
+ * @lpn: start LPN of L2P map in m_page
*/
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 list_head list_req;
+ union {
+ struct {
+ struct ufshpb_map_ctx *mctx;
+ unsigned int rgn_idx;
+ unsigned int srgn_idx;
+ unsigned int lun;
+ } rb;
+ struct {
+ struct page *m_page;
+ unsigned int len;
+ unsigned long lpn;
+ } wb;
+ };
};
struct victim_select_info {
@@ -144,6 +169,10 @@ struct victim_select_info {
atomic_t active_cnt;
};
+struct ufshpb_params {
+ unsigned int requeue_timeout_ms;
+};
+
struct ufshpb_stats {
u64 hit_cnt;
u64 miss_cnt;
@@ -151,6 +180,7 @@ struct ufshpb_stats {
u64 rb_active_cnt;
u64 rb_inactive_cnt;
u64 map_req_cnt;
+ u64 pre_req_cnt;
};
struct ufshpb_lu {
@@ -166,6 +196,15 @@ struct ufshpb_lu {
struct list_head lh_act_srgn; /* hold rsp_list_lock */
struct list_head lh_inact_rgn; /* hold rsp_list_lock */
+ /* pre request information */
+ struct ufshpb_req *pre_req;
+ int num_inflight_pre_req;
+ int throttle_pre_req;
+ struct list_head lh_pre_req_free;
+ int cur_read_id;
+ int pre_req_min_tr_len;
+ int pre_req_max_tr_len;
+
/* cached L2P map management worker */
struct work_struct map_work;
@@ -190,6 +229,7 @@ struct ufshpb_lu {
u32 pages_per_srgn;
struct ufshpb_stats stats;
+ struct ufshpb_params params;
struct kmem_cache *map_req_cache;
struct kmem_cache *m_page_cache;
@@ -201,7 +241,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 int ufshpb_prep(struct ufs_hba *hba, struct ufshcd_lrb *lrbp) { return 0; }
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) {}
@@ -214,8 +254,9 @@ 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) {}
+static bool ufshpb_is_legacy(struct ufs_hba *hba) { return false; }
#else
-void ufshpb_prep(struct ufs_hba *hba, struct ufshcd_lrb *lrbp);
+int 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);
@@ -228,7 +269,9 @@ 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);
+bool ufshpb_is_legacy(struct ufs_hba *hba);
extern struct attribute_group ufs_sysfs_hpb_stat_group;
+extern struct attribute_group ufs_sysfs_hpb_param_group;
#endif
#endif /* End of Header */
--
2.25.1
^ permalink raw reply related [flat|nested] 26+ messages in thread* Re: [PATCH v31 4/4] scsi: ufs: Add HPB 2.0 support
2021-03-22 6:55 ` [PATCH v31 4/4] scsi: ufs: Add HPB 2.0 support Daejun Park
@ 2021-03-24 5:01 ` Can Guo
2021-03-25 0:47 ` Daejun Park
0 siblings, 1 reply; 26+ messages in thread
From: Can Guo @ 2021-03-24 5:01 UTC (permalink / raw)
To: daejun7.park
Cc: Greg KH, avri.altman, jejb, martin.petersen, asutoshd,
stanley.chu, bvanassche, huobean, linux-scsi, linux-kernel,
ALIM AKHTAR, JinHwan Park, Javier Gonzalez, Sung-Jun Park,
Jinyoung CHOI, Dukhyun Kwon, Keoseong Park, Jaemyung Lee,
Jieon Seol
On 2021-03-22 14:55, Daejun Park wrote:
> This patch supports the HPB 2.0.
>
> The HPB 2.0 supports read of varying sizes from 4KB to 512KB.
> In the case of Read (<= 32KB) is supported as single HPB read.
> In the case of Read (36KB ~ 512KB) is supported by as a combination of
> write buffer command and HPB read command to deliver more PPN.
> The write buffer commands may not be issued immediately due to busy
> tags.
> To use HPB read more aggressively, the driver can requeue the write
> buffer
> command. The requeue threshold is implemented as timeout and can be
> modified with requeue_timeout_ms entry in sysfs.
>
> Signed-off-by: Daejun Park <daejun7.park@samsung.com>
> ---
> Documentation/ABI/testing/sysfs-driver-ufs | 47 +-
> drivers/scsi/ufs/ufs-sysfs.c | 4 +
> drivers/scsi/ufs/ufs.h | 3 +-
> drivers/scsi/ufs/ufshcd.c | 25 +-
> drivers/scsi/ufs/ufshcd.h | 7 +
> drivers/scsi/ufs/ufshpb.c | 626 +++++++++++++++++++--
> drivers/scsi/ufs/ufshpb.h | 67 ++-
> 7 files changed, 698 insertions(+), 81 deletions(-)
>
> diff --git a/Documentation/ABI/testing/sysfs-driver-ufs
> b/Documentation/ABI/testing/sysfs-driver-ufs
> index 528bf89fc98b..419adf450b89 100644
> --- a/Documentation/ABI/testing/sysfs-driver-ufs
> +++ b/Documentation/ABI/testing/sysfs-driver-ufs
> @@ -1253,14 +1253,14 @@ Description: This entry shows the number of
> HPB pinned regions assigned to
>
> The file is read only.
>
> -What: /sys/class/scsi_device/*/device/hpb_sysfs/hit_cnt
> +What: /sys/class/scsi_device/*/device/hpb_stat_sysfs/hit_cnt
> Date: March 2021
> Contact: Daejun Park <daejun7.park@samsung.com>
> Description: This entry shows the number of reads that changed to HPB
> read.
>
> The file is read only.
>
> -What: /sys/class/scsi_device/*/device/hpb_sysfs/miss_cnt
> +What: /sys/class/scsi_device/*/device/hpb_stat_sysfs/miss_cnt
> Date: March 2021
> Contact: Daejun Park <daejun7.park@samsung.com>
> Description: This entry shows the number of reads that cannot be
> changed to
> @@ -1268,7 +1268,7 @@ Description: This entry shows the number of
> reads that cannot be changed to
>
> The file is read only.
>
> -What: /sys/class/scsi_device/*/device/hpb_sysfs/rb_noti_cnt
> +What: /sys/class/scsi_device/*/device/hpb_stat_sysfs/rb_noti_cnt
> Date: March 2021
> Contact: Daejun Park <daejun7.park@samsung.com>
> Description: This entry shows the number of response UPIUs that has
> @@ -1276,7 +1276,7 @@ Description: This entry shows the number of
> response UPIUs that has
>
> The file is read only.
>
> -What: /sys/class/scsi_device/*/device/hpb_sysfs/rb_active_cnt
> +What: /sys/class/scsi_device/*/device/hpb_stat_sysfs/rb_active_cnt
> Date: March 2021
> Contact: Daejun Park <daejun7.park@samsung.com>
> Description: This entry shows the number of active sub-regions
> recommended by
> @@ -1284,7 +1284,7 @@ Description: This entry shows the number of
> active sub-regions recommended by
>
> The file is read only.
>
> -What: /sys/class/scsi_device/*/device/hpb_sysfs/rb_inactive_cnt
> +What: /sys/class/scsi_device/*/device/hpb_stat_sysfs/rb_inactive_cnt
> Date: March 2021
> Contact: Daejun Park <daejun7.park@samsung.com>
> Description: This entry shows the number of inactive regions
> recommended by
> @@ -1292,10 +1292,45 @@ Description: This entry shows the number of
> inactive regions recommended by
>
> The file is read only.
>
> -What: /sys/class/scsi_device/*/device/hpb_sysfs/map_req_cnt
> +What: /sys/class/scsi_device/*/device/hpb_stat_sysfs/map_req_cnt
> Date: March 2021
> Contact: Daejun Park <daejun7.park@samsung.com>
> Description: This entry shows the number of read buffer commands for
> activating sub-regions recommended by response UPIUs.
>
> The file is read only.
> +
> +What: /sys/class/scsi_device/*/device/hpb_param_sysfs/requeue_timeout_ms
> +Date: March 2021
> +Contact: Daejun Park <daejun7.park@samsung.com>
> +Description: This entry shows the requeue timeout threshold for write
> buffer
> + command in ms. This value can be changed by writing proper integer
> to
> + this entry.
> +
> +What: /sys/bus/platform/drivers/ufshcd/*/attributes/max_data_size_hpb_single_cmd
> +Date: March 2021
> +Contact: Daejun Park <daejun7.park@samsung.com>
> +Description: This entry shows the maximum HPB data size for using
> single HPB
> + command.
> +
> + === ========
> + 00h 4KB
> + 01h 8KB
> + 02h 12KB
> + ...
> + FFh 1024KB
> + === ========
> +
> + The file is read only.
> +
> +What: /sys/bus/platform/drivers/ufshcd/*/flags/wb_enable
> +Date: March 2021
> +Contact: Daejun Park <daejun7.park@samsung.com>
> +Description: This entry shows the status of HPB.
> +
> + == ============================
> + 0 HPB is not enabled.
> + 1 HPB is enabled
> + == ============================
> +
> + The file is read only.
> diff --git a/drivers/scsi/ufs/ufs-sysfs.c
> b/drivers/scsi/ufs/ufs-sysfs.c
> index 2546e7a1ac4f..92a883866e12 100644
> --- a/drivers/scsi/ufs/ufs-sysfs.c
> +++ b/drivers/scsi/ufs/ufs-sysfs.c
> @@ -782,6 +782,7 @@ UFS_FLAG(disable_fw_update,
> _PERMANENTLY_DISABLE_FW_UPDATE);
> UFS_FLAG(wb_enable, _WB_EN);
> UFS_FLAG(wb_flush_en, _WB_BUFF_FLUSH_EN);
> UFS_FLAG(wb_flush_during_h8, _WB_BUFF_FLUSH_DURING_HIBERN8);
> +UFS_FLAG(hpb_enable, _HPB_EN);
>
> static struct attribute *ufs_sysfs_device_flags[] = {
> &dev_attr_device_init.attr,
> @@ -795,6 +796,7 @@ static struct attribute *ufs_sysfs_device_flags[] =
> {
> &dev_attr_wb_enable.attr,
> &dev_attr_wb_flush_en.attr,
> &dev_attr_wb_flush_during_h8.attr,
> + &dev_attr_hpb_enable.attr,
> NULL,
> };
>
> @@ -841,6 +843,7 @@ out: \
> static DEVICE_ATTR_RO(_name)
>
> UFS_ATTRIBUTE(boot_lun_enabled, _BOOT_LU_EN);
> +UFS_ATTRIBUTE(max_data_size_hpb_single_cmd, _MAX_HPB_SINGLE_CMD);
> UFS_ATTRIBUTE(current_power_mode, _POWER_MODE);
> UFS_ATTRIBUTE(active_icc_level, _ACTIVE_ICC_LVL);
> UFS_ATTRIBUTE(ooo_data_enabled, _OOO_DATA_EN);
> @@ -864,6 +867,7 @@ UFS_ATTRIBUTE(wb_cur_buf, _CURR_WB_BUFF_SIZE);
>
> static struct attribute *ufs_sysfs_attributes[] = {
> &dev_attr_boot_lun_enabled.attr,
> + &dev_attr_max_data_size_hpb_single_cmd.attr,
> &dev_attr_current_power_mode.attr,
> &dev_attr_active_icc_level.attr,
> &dev_attr_ooo_data_enabled.attr,
> diff --git a/drivers/scsi/ufs/ufs.h b/drivers/scsi/ufs/ufs.h
> index bfb84d2ba990..8c6b38b1b142 100644
> --- a/drivers/scsi/ufs/ufs.h
> +++ b/drivers/scsi/ufs/ufs.h
> @@ -123,12 +123,13 @@ enum flag_idn {
> QUERY_FLAG_IDN_WB_BUFF_FLUSH_EN = 0x0F,
> QUERY_FLAG_IDN_WB_BUFF_FLUSH_DURING_HIBERN8 = 0x10,
> QUERY_FLAG_IDN_HPB_RESET = 0x11,
> + QUERY_FLAG_IDN_HPB_EN = 0x12,
> };
>
> /* Attribute idn for Query requests */
> enum attr_idn {
> QUERY_ATTR_IDN_BOOT_LU_EN = 0x00,
> - QUERY_ATTR_IDN_RESERVED = 0x01,
> + QUERY_ATTR_IDN_MAX_HPB_SINGLE_CMD = 0x01,
> QUERY_ATTR_IDN_POWER_MODE = 0x02,
> QUERY_ATTR_IDN_ACTIVE_ICC_LVL = 0x03,
> QUERY_ATTR_IDN_OOO_DATA_EN = 0x04,
> diff --git a/drivers/scsi/ufs/ufshcd.c b/drivers/scsi/ufs/ufshcd.c
> index a7cf9278965c..1653c7a7b066 100644
> --- a/drivers/scsi/ufs/ufshcd.c
> +++ b/drivers/scsi/ufs/ufshcd.c
> @@ -2653,7 +2653,12 @@ static int ufshcd_queuecommand(struct Scsi_Host
> *host, struct scsi_cmnd *cmd)
>
> lrbp->req_abort_skip = false;
>
> - ufshpb_prep(hba, lrbp);
> + err = ufshpb_prep(hba, lrbp);
> + if (err == -EAGAIN) {
> + lrbp->cmd = NULL;
> + ufshcd_release(hba);
> + goto out;
> + }
>
> ufshcd_comp_scsi_upiu(hba, lrbp);
>
> @@ -3107,7 +3112,7 @@ int ufshcd_query_attr(struct ufs_hba *hba, enum
> query_opcode opcode,
> *
> * Returns 0 for success, non-zero in case of failure
> */
> -static int ufshcd_query_attr_retry(struct ufs_hba *hba,
> +int ufshcd_query_attr_retry(struct ufs_hba *hba,
> enum query_opcode opcode, enum attr_idn idn, u8 index, u8 selector,
> u32 *attr_val)
> {
> @@ -4862,7 +4867,8 @@ static int ufshcd_change_queue_depth(struct
> scsi_device *sdev, int 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))
> + if ((sdev->lun >= UFS_UPIU_MAX_UNIT_NUM_ID) ||
> + !(hba->dev_info.hpb_enabled) || !ufshpb_is_allowed(hba))
> return;
>
> ufshpb_destroy_lu(hba, sdev);
> @@ -7454,8 +7460,18 @@ static int ufs_get_device_desc(struct ufs_hba
> *hba)
>
> if (dev_info->wspecversion >= UFS_DEV_HPB_SUPPORT_VERSION &&
> (b_ufs_feature_sup & UFS_DEV_HPB_SUPPORT)) {
> - dev_info->hpb_enabled = true;
> + bool hpb_en = false;
> +
> ufshpb_get_dev_info(hba, desc_buf);
> +
> + if (!ufshpb_is_legacy(hba))
> + err = ufshcd_query_flag_retry(hba,
> + UPIU_QUERY_OPCODE_READ_FLAG,
> + QUERY_FLAG_IDN_HPB_EN, 0,
> + &hpb_en);
> +
> + if (ufshpb_is_legacy(hba) || (!err && hpb_en))
> + dev_info->hpb_enabled = true;
> }
>
> err = ufshcd_read_string_desc(hba, model_index,
> @@ -8028,6 +8044,7 @@ static const struct attribute_group
> *ufshcd_driver_groups[] = {
> &ufs_sysfs_lun_attributes_group,
> #ifdef CONFIG_SCSI_UFS_HPB
> &ufs_sysfs_hpb_stat_group,
> + &ufs_sysfs_hpb_param_group,
> #endif
> NULL,
> };
> diff --git a/drivers/scsi/ufs/ufshcd.h b/drivers/scsi/ufs/ufshcd.h
> index 008a5f7146c0..8aca8f327981 100644
> --- a/drivers/scsi/ufs/ufshcd.h
> +++ b/drivers/scsi/ufs/ufshcd.h
> @@ -654,6 +654,8 @@ struct ufs_hba_variant_params {
> * @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
> + * @max_hpb_single_cmd: maximum size of single HPB command
> + * @is_legacy: flag to check HPB 1.0
> */
> struct ufshpb_dev_info {
> int num_lu;
> @@ -661,6 +663,8 @@ struct ufshpb_dev_info {
> int srgn_size;
> atomic_t slave_conf_cnt;
> bool hpb_disabled;
> + int max_hpb_single_cmd;
> + bool is_legacy;
> };
> #endif
>
> @@ -1096,6 +1100,9 @@ int ufshcd_read_desc_param(struct ufs_hba *hba,
> u8 param_offset,
> u8 *param_read_buf,
> u8 param_size);
> +int ufshcd_query_attr_retry(struct ufs_hba *hba, enum query_opcode
> opcode,
> + enum attr_idn idn, u8 index, u8 selector,
> + u32 *attr_val);
> int ufshcd_query_attr(struct ufs_hba *hba, enum query_opcode opcode,
> enum attr_idn idn, u8 index, u8 selector, u32 *attr_val);
> int ufshcd_query_flag(struct ufs_hba *hba, enum query_opcode opcode,
> diff --git a/drivers/scsi/ufs/ufshpb.c b/drivers/scsi/ufs/ufshpb.c
> index f789339f68d9..3ac8b0a9e8d3 100644
> --- a/drivers/scsi/ufs/ufshpb.c
> +++ b/drivers/scsi/ufs/ufshpb.c
> @@ -31,6 +31,11 @@ bool ufshpb_is_allowed(struct ufs_hba *hba)
> return !(hba->ufshpb_dev.hpb_disabled);
> }
>
> +bool ufshpb_is_legacy(struct ufs_hba *hba)
> +{
> + return hba->ufshpb_dev.is_legacy;
> +}
> +
> static struct ufshpb_lu *ufshpb_get_hpb_data(struct scsi_device *sdev)
> {
> return sdev->hostdata;
> @@ -64,9 +69,19 @@ static bool ufshpb_is_write_or_discard_cmd(struct
> scsi_cmnd *cmd)
> op_is_discard(req_op(cmd->request));
> }
>
> -static bool ufshpb_is_support_chunk(int transfer_len)
> +static bool ufshpb_is_support_chunk(struct ufshpb_lu *hpb, int
> transfer_len)
> {
> - return transfer_len <= HPB_MULTI_CHUNK_HIGH;
> + return transfer_len <= hpb->pre_req_max_tr_len;
> +}
> +
> +/*
> + * In this driver, WRITE_BUFFER CMD support 36KB (len=9) ~ 512KB
> (len=128) as
> + * default. It is possible to change range of transfer_len through
> sysfs.
> + */
> +static inline bool ufshpb_is_required_wb(struct ufshpb_lu *hpb, int
> len)
> +{
> + return (len > hpb->pre_req_min_tr_len &&
> + len <= hpb->pre_req_max_tr_len);
> }
>
> static bool ufshpb_is_general_lun(int lun)
> @@ -74,8 +89,7 @@ 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)
> +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 &&
> @@ -264,7 +278,8 @@ ufshpb_get_pos_from_lpn(struct ufshpb_lu *hpb,
> unsigned long lpn, int *rgn_idx,
>
> static void
> ufshpb_set_hpb_read_to_upiu(struct ufshpb_lu *hpb, struct ufshcd_lrb
> *lrbp,
> - u32 lpn, u64 ppn, unsigned int transfer_len)
> + u32 lpn, u64 ppn, unsigned int transfer_len,
> + int read_id)
> {
> unsigned char *cdb = lrbp->cmd->cmnd;
>
> @@ -273,15 +288,261 @@ ufshpb_set_hpb_read_to_upiu(struct ufshpb_lu
> *hpb, struct ufshcd_lrb *lrbp,
> /* ppn value is stored as big-endian in the host memory */
> memcpy(&cdb[6], &ppn, sizeof(u64));
> cdb[14] = transfer_len;
> + cdb[15] = read_id;
>
> lrbp->cmd->cmd_len = UFS_CDB_SIZE;
> }
>
> +static inline void ufshpb_set_write_buf_cmd(unsigned char *cdb,
> + unsigned long lpn, unsigned int len,
> + int read_id)
> +{
> + cdb[0] = UFSHPB_WRITE_BUFFER;
> + cdb[1] = UFSHPB_WRITE_BUFFER_PREFETCH_ID;
> +
> + put_unaligned_be32(lpn, &cdb[2]);
> + cdb[6] = read_id;
> + put_unaligned_be16(len * HPB_ENTRY_SIZE, &cdb[7]);
> +
> + cdb[9] = 0x00; /* Control = 0x00 */
> +}
> +
> +static struct ufshpb_req *ufshpb_get_pre_req(struct ufshpb_lu *hpb)
> +{
> + struct ufshpb_req *pre_req;
> +
> + if (hpb->num_inflight_pre_req >= hpb->throttle_pre_req) {
> + dev_info(&hpb->sdev_ufs_lu->sdev_dev,
> + "pre_req throttle. inflight %d throttle %d",
> + hpb->num_inflight_pre_req, hpb->throttle_pre_req);
> + return NULL;
> + }
> +
> + pre_req = list_first_entry_or_null(&hpb->lh_pre_req_free,
> + struct ufshpb_req, list_req);
> + if (!pre_req) {
> + dev_info(&hpb->sdev_ufs_lu->sdev_dev, "There is no pre_req");
> + return NULL;
> + }
> +
> + list_del_init(&pre_req->list_req);
> + hpb->num_inflight_pre_req++;
> +
> + return pre_req;
> +}
> +
> +static inline void ufshpb_put_pre_req(struct ufshpb_lu *hpb,
> + struct ufshpb_req *pre_req)
> +{
> + pre_req->req = NULL;
> + bio_reset(pre_req->bio);
> + list_add_tail(&pre_req->list_req, &hpb->lh_pre_req_free);
> + hpb->num_inflight_pre_req--;
> +}
> +
> +static void ufshpb_pre_req_compl_fn(struct request *req, blk_status_t
> error)
> +{
> + struct ufshpb_req *pre_req = (struct ufshpb_req *)req->end_io_data;
> + struct ufshpb_lu *hpb = pre_req->hpb;
> + unsigned long flags;
> +
> + if (error) {
> + struct scsi_request *rq = scsi_req(req);
> + struct scsi_sense_hdr sshdr;
> +
> + dev_err(&hpb->sdev_ufs_lu->sdev_dev, "block status %d", error);
> + scsi_normalize_sense(rq->sense, SCSI_SENSE_BUFFERSIZE,
> + &sshdr);
> + dev_err(&hpb->sdev_ufs_lu->sdev_dev,
> + "code %x sense_key %x asc %x ascq %x",
> + sshdr.response_code,
> + sshdr.sense_key, sshdr.asc, sshdr.ascq);
> + dev_err(&hpb->sdev_ufs_lu->sdev_dev,
> + "byte4 %x byte5 %x byte6 %x additional_len %x",
> + sshdr.byte4, sshdr.byte5,
> + sshdr.byte6, sshdr.additional_length);
> + }
> +
> + blk_mq_free_request(req);
> + spin_lock_irqsave(&hpb->rgn_state_lock, flags);
> + ufshpb_put_pre_req(pre_req->hpb, pre_req);
> + spin_unlock_irqrestore(&hpb->rgn_state_lock, flags);
> +}
> +
> +static int ufshpb_prep_entry(struct ufshpb_req *pre_req, struct page
> *page)
> +{
> + struct ufshpb_lu *hpb = pre_req->hpb;
> + struct ufshpb_region *rgn;
> + struct ufshpb_subregion *srgn;
> + u64 *addr;
> + int offset = 0;
> + int copied;
> + unsigned long lpn = pre_req->wb.lpn;
> + int rgn_idx, srgn_idx, srgn_offset;
> + unsigned long flags;
> +
> + addr = page_address(page);
> + ufshpb_get_pos_from_lpn(hpb, lpn, &rgn_idx, &srgn_idx, &srgn_offset);
> +
> + spin_lock_irqsave(&hpb->rgn_state_lock, flags);
> +
> +next_offset:
> + rgn = hpb->rgn_tbl + rgn_idx;
> + srgn = rgn->srgn_tbl + srgn_idx;
> +
> + if (!ufshpb_is_valid_srgn(rgn, srgn))
> + goto mctx_error;
> +
> + if (!srgn->mctx)
> + goto mctx_error;
> +
> + copied = ufshpb_fill_ppn_from_page(hpb, srgn->mctx, srgn_offset,
> + pre_req->wb.len - offset,
> + &addr[offset]);
> +
> + if (copied < 0)
> + goto mctx_error;
> +
> + offset += copied;
> + srgn_offset += copied;
> +
> + if (srgn_offset == hpb->entries_per_srgn) {
> + srgn_offset = 0;
> +
> + if (++srgn_idx == hpb->srgns_per_rgn) {
> + srgn_idx = 0;
> + rgn_idx++;
> + }
> + }
> +
> + if (offset < pre_req->wb.len)
> + goto next_offset;
> +
> + spin_unlock_irqrestore(&hpb->rgn_state_lock, flags);
> + return 0;
> +mctx_error:
> + spin_unlock_irqrestore(&hpb->rgn_state_lock, flags);
> + return -ENOMEM;
> +}
> +
> +static int ufshpb_pre_req_add_bio_page(struct ufshpb_lu *hpb,
> + struct request_queue *q,
> + struct ufshpb_req *pre_req)
> +{
> + struct page *page = pre_req->wb.m_page;
> + struct bio *bio = pre_req->bio;
> + int entries_bytes, ret;
> +
> + if (!page)
> + return -ENOMEM;
> +
> + if (ufshpb_prep_entry(pre_req, page))
> + return -ENOMEM;
> +
> + entries_bytes = pre_req->wb.len * sizeof(u64);
> +
> + ret = bio_add_pc_page(q, bio, page, entries_bytes, 0);
> + if (ret != entries_bytes) {
> + dev_err(&hpb->sdev_ufs_lu->sdev_dev,
> + "bio_add_pc_page fail: %d", ret);
> + return -ENOMEM;
> + }
> + return 0;
> +}
> +
> +static inline int ufshpb_get_read_id(struct ufshpb_lu *hpb)
> +{
> + if (++hpb->cur_read_id >= MAX_HPB_READ_ID)
> + hpb->cur_read_id = 1;
> + return hpb->cur_read_id;
> +}
> +
> +static int ufshpb_execute_pre_req(struct ufshpb_lu *hpb, struct
> scsi_cmnd *cmd,
> + struct ufshpb_req *pre_req, int read_id)
> +{
> + struct scsi_device *sdev = cmd->device;
> + struct request_queue *q = sdev->request_queue;
> + struct request *req;
> + struct scsi_request *rq;
> + struct bio *bio = pre_req->bio;
> +
> + pre_req->hpb = hpb;
> + pre_req->wb.lpn = sectors_to_logical(cmd->device,
> + blk_rq_pos(cmd->request));
> + pre_req->wb.len = sectors_to_logical(cmd->device,
> + blk_rq_sectors(cmd->request));
> + if (ufshpb_pre_req_add_bio_page(hpb, q, pre_req))
> + return -ENOMEM;
> +
> + req = pre_req->req;
> +
> + /* 1. request setup */
> + blk_rq_append_bio(req, &bio);
> + req->rq_disk = NULL;
> + req->end_io_data = (void *)pre_req;
> + req->end_io = ufshpb_pre_req_compl_fn;
> +
> + /* 2. scsi_request setup */
> + rq = scsi_req(req);
> + rq->retries = 1;
> +
> + ufshpb_set_write_buf_cmd(rq->cmd, pre_req->wb.lpn, pre_req->wb.len,
> + read_id);
> + rq->cmd_len = scsi_command_size(rq->cmd);
> +
> + if (blk_insert_cloned_request(q, req) != BLK_STS_OK)
> + return -EAGAIN;
> +
> + hpb->stats.pre_req_cnt++;
> +
> + return 0;
> +}
> +
> +static int ufshpb_issue_pre_req(struct ufshpb_lu *hpb, struct
> scsi_cmnd *cmd,
> + int *read_id)
> +{
> + struct ufshpb_req *pre_req;
> + struct request *req = NULL;
> + unsigned long flags;
> + int _read_id;
> + int ret = 0;
> +
> + req = blk_get_request(cmd->device->request_queue,
> + REQ_OP_SCSI_OUT | REQ_SYNC, BLK_MQ_REQ_NOWAIT);
> + if (IS_ERR(req))
> + return -EAGAIN;
> +
> + spin_lock_irqsave(&hpb->rgn_state_lock, flags);
> + pre_req = ufshpb_get_pre_req(hpb);
> + if (!pre_req) {
> + ret = -EAGAIN;
> + goto unlock_out;
> + }
> + _read_id = ufshpb_get_read_id(hpb);
> + spin_unlock_irqrestore(&hpb->rgn_state_lock, flags);
> +
> + pre_req->req = req;
> +
> + ret = ufshpb_execute_pre_req(hpb, cmd, pre_req, _read_id);
> + if (ret)
> + goto free_pre_req;
> +
> + *read_id = _read_id;
> +
> + return ret;
> +free_pre_req:
> + spin_lock_irqsave(&hpb->rgn_state_lock, flags);
> + ufshpb_put_pre_req(hpb, pre_req);
> +unlock_out:
> + spin_unlock_irqrestore(&hpb->rgn_state_lock, flags);
> + blk_put_request(req);
> + return ret;
> +}
> +
> /*
> * 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)
> +int ufshpb_prep(struct ufs_hba *hba, struct ufshcd_lrb *lrbp)
> {
> struct ufshpb_lu *hpb;
> struct ufshpb_region *rgn;
> @@ -291,19 +552,20 @@ void ufshpb_prep(struct ufs_hba *hba, struct
> ufshcd_lrb *lrbp)
> u64 ppn;
> unsigned long flags;
> int transfer_len, rgn_idx, srgn_idx, srgn_offset;
> + int read_id = 0;
> int err = 0;
>
> hpb = ufshpb_get_hpb_data(cmd->device);
> if (!hpb)
> - return;
> + return -ENODEV;
>
> if (ufshpb_get_state(hpb) == HPB_INIT)
> - return;
> + return -ENODEV;
>
> if (ufshpb_get_state(hpb) != HPB_PRESENT) {
> dev_notice(&hpb->sdev_ufs_lu->sdev_dev,
> "%s: ufshpb state is not PRESENT", __func__);
> - return;
> + return -ENODEV;
> }
>
> if (blk_rq_is_scsi(cmd->request) ||
> @@ -314,7 +576,7 @@ void ufshpb_prep(struct ufs_hba *hba, struct
> ufshcd_lrb *lrbp)
> transfer_len = sectors_to_logical(cmd->device,
> blk_rq_sectors(cmd->request));
> if (unlikely(!transfer_len))
> - return;
> + return 0;
>
> lpn = sectors_to_logical(cmd->device, blk_rq_pos(cmd->request));
> ufshpb_get_pos_from_lpn(hpb, lpn, &rgn_idx, &srgn_idx, &srgn_offset);
> @@ -327,18 +589,18 @@ void ufshpb_prep(struct ufs_hba *hba, struct
> ufshcd_lrb *lrbp)
> ufshpb_set_ppn_dirty(hpb, rgn_idx, srgn_idx, srgn_offset,
> transfer_len);
> spin_unlock_irqrestore(&hpb->rgn_state_lock, flags);
> - return;
> + return 0;
> }
>
> - if (!ufshpb_is_support_chunk(transfer_len))
> - return;
> + if (!ufshpb_is_support_chunk(hpb, transfer_len))
> + return 0;
>
> 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;
> + return 0;
> }
>
> err = ufshpb_fill_ppn_from_page(hpb, srgn->mctx, srgn_offset, 1,
> &ppn);
> @@ -351,64 +613,101 @@ void ufshpb_prep(struct ufs_hba *hba, struct
> ufshcd_lrb *lrbp)
> * active state.
> */
> dev_err(hba->dev, "get ppn failed. err %d\n", err);
> - return;
> + return err;
> + }
> + if (!ufshpb_is_legacy(hba) &&
> + ufshpb_is_required_wb(hpb, transfer_len)) {
> + err = ufshpb_issue_pre_req(hpb, cmd, &read_id);
> + if (err) {
> + unsigned long timeout;
> +
> + timeout = cmd->jiffies_at_alloc + msecs_to_jiffies(
> + hpb->params.requeue_timeout_ms);
> +
> + if (time_before(jiffies, timeout))
> + return -EAGAIN;
> +
> + hpb->stats.miss_cnt++;
> + return 0;
> + }
> }
>
> - ufshpb_set_hpb_read_to_upiu(hpb, lrbp, lpn, ppn, transfer_len);
> + ufshpb_set_hpb_read_to_upiu(hpb, lrbp, lpn, ppn, transfer_len,
> read_id);
>
> hpb->stats.hit_cnt++;
> + return 0;
> }
> -static struct ufshpb_req *ufshpb_get_map_req(struct ufshpb_lu *hpb,
> - struct ufshpb_subregion *srgn)
> +
> +static struct ufshpb_req *ufshpb_get_req(struct ufshpb_lu *hpb,
> + int rgn_idx, enum req_opf dir,
> + bool atomic)
You didn't mention this change in cover letter. And I don't see anyone
is passing "atomic" as true, neither in your patches nor Avri's V6
series
(from ufshpb_issue_umap_single_req()). If no one is using the flag, then
this is dead code. If Avri needs this flag, he can add it in host
control
mode patches. Do I miss anything?
Thanks,
Can Guo.
> {
> - struct ufshpb_req *map_req;
> + struct ufshpb_req *rq;
> struct request *req;
> - struct bio *bio;
> int retries = HPB_MAP_REQ_RETRIES;
>
> - map_req = kmem_cache_alloc(hpb->map_req_cache, GFP_KERNEL);
> - if (!map_req)
> + rq = kmem_cache_alloc(hpb->map_req_cache, GFP_ATOMIC);
> + if (!rq)
> return NULL;
>
> retry:
> - req = blk_get_request(hpb->sdev_ufs_lu->request_queue,
> - REQ_OP_SCSI_IN, BLK_MQ_REQ_NOWAIT);
> + req = blk_get_request(hpb->sdev_ufs_lu->request_queue, dir,
> + BLK_MQ_REQ_NOWAIT);
>
> - if ((PTR_ERR(req) == -EWOULDBLOCK) && (--retries > 0)) {
> + if (!atomic && (PTR_ERR(req) == -EWOULDBLOCK) && (--retries > 0)) {
> usleep_range(3000, 3100);
> goto retry;
> }
>
> if (IS_ERR(req))
> - goto free_map_req;
> + goto free_rq;
> +
> + rq->hpb = hpb;
> + rq->req = req;
> + rq->rb.rgn_idx = rgn_idx;
> +
> + return rq;
> +
> +free_rq:
> + kmem_cache_free(hpb->map_req_cache, rq);
> + return NULL;
> +}
> +
> +static void ufshpb_put_req(struct ufshpb_lu *hpb, struct ufshpb_req
> *rq)
> +{
> + blk_put_request(rq->req);
> + kmem_cache_free(hpb->map_req_cache, rq);
> +}
> +
> +static struct ufshpb_req *ufshpb_get_map_req(struct ufshpb_lu *hpb,
> + struct ufshpb_subregion *srgn)
> +{
> + struct ufshpb_req *map_req;
> + struct bio *bio;
> +
> + map_req = ufshpb_get_req(hpb, srgn->rgn_idx, REQ_OP_SCSI_IN, false);
> + if (!map_req)
> + return NULL;
>
> bio = bio_alloc(GFP_KERNEL, hpb->pages_per_srgn);
> if (!bio) {
> - blk_put_request(req);
> - goto free_map_req;
> + ufshpb_put_req(hpb, map_req);
> + return NULL;
> }
>
> - 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->rb.srgn_idx = srgn->srgn_idx;
> + map_req->rb.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);
> + ufshpb_put_req(hpb, map_req);
> }
>
> static int ufshpb_clear_dirty_bitmap(struct ufshpb_lu *hpb,
> @@ -491,6 +790,13 @@ static void ufshpb_activate_subregion(struct
> ufshpb_lu *hpb,
> srgn->srgn_state = HPB_SRGN_VALID;
> }
>
> +static void ufshpb_umap_req_compl_fn(struct request *req, blk_status_t
> error)
> +{
> + struct ufshpb_req *umap_req = (struct ufshpb_req *)req->end_io_data;
> +
> + ufshpb_put_req(umap_req->hpb, umap_req);
> +}
> +
> 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;
> @@ -498,8 +804,8 @@ static void ufshpb_map_req_compl_fn(struct request
> *req, blk_status_t error)
> struct ufshpb_subregion *srgn;
> unsigned long flags;
>
> - srgn = hpb->rgn_tbl[map_req->rgn_idx].srgn_tbl +
> - map_req->srgn_idx;
> + srgn = hpb->rgn_tbl[map_req->rb.rgn_idx].srgn_tbl +
> + map_req->rb.srgn_idx;
>
> ufshpb_clear_dirty_bitmap(hpb, srgn);
> spin_lock_irqsave(&hpb->rgn_state_lock, flags);
> @@ -509,6 +815,16 @@ static void ufshpb_map_req_compl_fn(struct
> request *req, blk_status_t error)
> ufshpb_put_map_req(map_req->hpb, map_req);
> }
>
> +static void ufshpb_set_unmap_cmd(unsigned char *cdb, struct
> ufshpb_region *rgn)
> +{
> + cdb[0] = UFSHPB_WRITE_BUFFER;
> + cdb[1] = rgn ? UFSHPB_WRITE_BUFFER_INACT_SINGLE_ID :
> + UFSHPB_WRITE_BUFFER_INACT_ALL_ID;
> + if (rgn)
> + put_unaligned_be16(rgn->rgn_idx, &cdb[2]);
> + cdb[9] = 0x00;
> +}
> +
> static void ufshpb_set_read_buf_cmd(unsigned char *cdb, int rgn_idx,
> int srgn_idx, int srgn_mem_size)
> {
> @@ -522,6 +838,25 @@ static void ufshpb_set_read_buf_cmd(unsigned char
> *cdb, int rgn_idx,
> cdb[9] = 0x00;
> }
>
> +static int ufshpb_execute_umap_req(struct ufshpb_lu *hpb,
> + struct ufshpb_req *umap_req,
> + struct ufshpb_region *rgn)
> +{
> + struct request *req;
> + struct scsi_request *rq;
> +
> + req = umap_req->req;
> + req->timeout = 0;
> + req->end_io_data = (void *)umap_req;
> + rq = scsi_req(req);
> + ufshpb_set_unmap_cmd(rq->cmd, rgn);
> + rq->cmd_len = HPB_WRITE_BUFFER_CMD_LENGTH;
> +
> + blk_execute_rq_nowait(NULL, req, 1, ufshpb_umap_req_compl_fn);
> +
> + return 0;
> +}
> +
> static int ufshpb_execute_map_req(struct ufshpb_lu *hpb,
> struct ufshpb_req *map_req, bool last)
> {
> @@ -534,12 +869,12 @@ static int ufshpb_execute_map_req(struct
> ufshpb_lu *hpb,
>
> 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],
> + ret = bio_add_pc_page(q, map_req->bio, map_req->rb.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);
> + map_req->rb.rgn_idx, map_req->rb.srgn_idx);
> return ret;
> }
> }
> @@ -555,8 +890,8 @@ static int ufshpb_execute_map_req(struct ufshpb_lu
> *hpb,
> if (unlikely(last))
> mem_size = hpb->last_srgn_entries * HPB_ENTRY_SIZE;
>
> - ufshpb_set_read_buf_cmd(rq->cmd, map_req->rgn_idx,
> - map_req->srgn_idx, mem_size);
> + ufshpb_set_read_buf_cmd(rq->cmd, map_req->rb.rgn_idx,
> + map_req->rb.srgn_idx, mem_size);
> rq->cmd_len = HPB_READ_BUFFER_CMD_LENGTH;
>
> blk_execute_rq_nowait(NULL, req, 1, ufshpb_map_req_compl_fn);
> @@ -688,6 +1023,31 @@ static void ufshpb_purge_active_subregion(struct
> ufshpb_lu *hpb,
> }
> }
>
> +static int ufshpb_issue_umap_req(struct ufshpb_lu *hpb,
> + struct ufshpb_region *rgn, bool atomic)
> +{
> + struct ufshpb_req *umap_req;
> + int rgn_idx = rgn ? rgn->rgn_idx : 0;
> +
> + umap_req = ufshpb_get_req(hpb, rgn_idx, REQ_OP_SCSI_OUT, atomic);
> + if (!umap_req)
> + return -ENOMEM;
> +
> + if (ufshpb_execute_umap_req(hpb, umap_req, rgn))
> + goto free_umap_req;
> +
> + return 0;
> +
> +free_umap_req:
> + ufshpb_put_req(hpb, umap_req);
> + return -EAGAIN;
> +}
> +
> +static int ufshpb_issue_umap_all_req(struct ufshpb_lu *hpb)
> +{
> + return ufshpb_issue_umap_req(hpb, NULL, false);
> +}
> +
> static void __ufshpb_evict_region(struct ufshpb_lu *hpb,
> struct ufshpb_region *rgn)
> {
> @@ -1210,6 +1570,17 @@ static void ufshpb_lu_parameter_init(struct
> ufs_hba *hba,
> u32 entries_per_rgn;
> u64 rgn_mem_size, tmp;
>
> + /* for pre_req */
> + hpb->pre_req_min_tr_len = hpb_dev_info->max_hpb_single_cmd + 1;
> +
> + if (ufshpb_is_legacy(hba))
> + hpb->pre_req_max_tr_len = HPB_LEGACY_CHUNK_HIGH;
> + else
> + hpb->pre_req_max_tr_len = max(HPB_MULTI_CHUNK_HIGH,
> + hpb->pre_req_min_tr_len);
> +
> + hpb->cur_read_id = 0;
> +
> 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)
> @@ -1357,7 +1728,7 @@ 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[] = {
> +static struct attribute *hpb_dev_stat_attrs[] = {
> &dev_attr_hit_cnt.attr,
> &dev_attr_miss_cnt.attr,
> &dev_attr_rb_noti_cnt.attr,
> @@ -1368,10 +1739,118 @@ static struct attribute *hpb_dev_attrs[] = {
> };
>
> struct attribute_group ufs_sysfs_hpb_stat_group = {
> - .name = "hpb_sysfs",
> - .attrs = hpb_dev_attrs,
> + .name = "hpb_stat_sysfs",
> + .attrs = hpb_dev_stat_attrs,
> };
>
> +/* SYSFS functions */
> +#define ufshpb_sysfs_param_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, "%d\n", hpb->params.__name); \
> +}
> +
> +ufshpb_sysfs_param_show_func(requeue_timeout_ms);
> +static ssize_t
> +requeue_timeout_ms_store(struct device *dev, struct device_attribute
> *attr,
> + const char *buf, size_t count)
> +{
> + struct scsi_device *sdev = to_scsi_device(dev);
> + struct ufshpb_lu *hpb = ufshpb_get_hpb_data(sdev);
> + int val;
> +
> + if (!hpb)
> + return -ENODEV;
> +
> + if (kstrtouint(buf, 0, &val))
> + return -EINVAL;
> +
> + if (val < 0)
> + return -EINVAL;
> +
> + hpb->params.requeue_timeout_ms = val;
> +
> + return count;
> +}
> +static DEVICE_ATTR_RW(requeue_timeout_ms);
> +
> +static struct attribute *hpb_dev_param_attrs[] = {
> + &dev_attr_requeue_timeout_ms.attr,
> + NULL,
> +};
> +
> +struct attribute_group ufs_sysfs_hpb_param_group = {
> + .name = "hpb_param_sysfs",
> + .attrs = hpb_dev_param_attrs,
> +};
> +
> +static int ufshpb_pre_req_mempool_init(struct ufshpb_lu *hpb)
> +{
> + struct ufshpb_req *pre_req = NULL, *t;
> + int qd = hpb->sdev_ufs_lu->queue_depth / 2;
> + int i;
> +
> + INIT_LIST_HEAD(&hpb->lh_pre_req_free);
> +
> + hpb->pre_req = kcalloc(qd, sizeof(struct ufshpb_req), GFP_KERNEL);
> + hpb->throttle_pre_req = qd;
> + hpb->num_inflight_pre_req = 0;
> +
> + if (!hpb->pre_req)
> + goto release_mem;
> +
> + for (i = 0; i < qd; i++) {
> + pre_req = hpb->pre_req + i;
> + INIT_LIST_HEAD(&pre_req->list_req);
> + pre_req->req = NULL;
> +
> + pre_req->bio = bio_alloc(GFP_KERNEL, 1);
> + if (!pre_req->bio)
> + goto release_mem;
> +
> + pre_req->wb.m_page = alloc_page(GFP_KERNEL | __GFP_ZERO);
> + if (!pre_req->wb.m_page) {
> + bio_put(pre_req->bio);
> + goto release_mem;
> + }
> +
> + list_add_tail(&pre_req->list_req, &hpb->lh_pre_req_free);
> + }
> +
> + return 0;
> +release_mem:
> + list_for_each_entry_safe(pre_req, t, &hpb->lh_pre_req_free, list_req)
> {
> + list_del_init(&pre_req->list_req);
> + bio_put(pre_req->bio);
> + __free_page(pre_req->wb.m_page);
> + }
> +
> + kfree(hpb->pre_req);
> + return -ENOMEM;
> +}
> +
> +static void ufshpb_pre_req_mempool_destroy(struct ufshpb_lu *hpb)
> +{
> + struct ufshpb_req *pre_req = NULL;
> + int i;
> +
> + for (i = 0; i < hpb->throttle_pre_req; i++) {
> + pre_req = hpb->pre_req + i;
> + bio_put(hpb->pre_req[i].bio);
> + if (!pre_req->wb.m_page)
> + __free_page(hpb->pre_req[i].wb.m_page);
> + list_del_init(&pre_req->list_req);
> + }
> +
> + kfree(hpb->pre_req);
> +}
> +
> static void ufshpb_stat_init(struct ufshpb_lu *hpb)
> {
> hpb->stats.hit_cnt = 0;
> @@ -1382,6 +1861,11 @@ static void ufshpb_stat_init(struct ufshpb_lu
> *hpb)
> hpb->stats.map_req_cnt = 0;
> }
>
> +static void ufshpb_param_init(struct ufshpb_lu *hpb)
> +{
> + hpb->params.requeue_timeout_ms = HPB_REQUEUE_TIME_MS;
> +}
> +
> static int ufshpb_lu_hpb_init(struct ufs_hba *hba, struct ufshpb_lu
> *hpb)
> {
> int ret;
> @@ -1414,14 +1898,24 @@ static int ufshpb_lu_hpb_init(struct ufs_hba
> *hba, struct ufshpb_lu *hpb)
> goto release_req_cache;
> }
>
> + ret = ufshpb_pre_req_mempool_init(hpb);
> + if (ret) {
> + dev_err(hba->dev, "ufshpb(%d) pre_req_mempool init fail",
> + hpb->lun);
> + goto release_m_page_cache;
> + }
> +
> ret = ufshpb_alloc_region_tbl(hba, hpb);
> if (ret)
> - goto release_m_page_cache;
> + goto release_pre_req_mempool;
>
> ufshpb_stat_init(hpb);
> + ufshpb_param_init(hpb);
>
> return 0;
>
> +release_pre_req_mempool:
> + ufshpb_pre_req_mempool_destroy(hpb);
> release_m_page_cache:
> kmem_cache_destroy(hpb->m_page_cache);
> release_req_cache:
> @@ -1430,7 +1924,7 @@ static int ufshpb_lu_hpb_init(struct ufs_hba
> *hba, struct ufshpb_lu *hpb)
> }
>
> static struct ufshpb_lu *
> -ufshpb_alloc_hpb_lu(struct ufs_hba *hba, int lun,
> +ufshpb_alloc_hpb_lu(struct ufs_hba *hba, struct scsi_device *sdev,
> struct ufshpb_dev_info *hpb_dev_info,
> struct ufshpb_lu_info *hpb_lu_info)
> {
> @@ -1441,7 +1935,8 @@ ufshpb_alloc_hpb_lu(struct ufs_hba *hba, int lun,
> if (!hpb)
> return NULL;
>
> - hpb->lun = lun;
> + hpb->lun = sdev->lun;
> + hpb->sdev_ufs_lu = sdev;
>
> ufshpb_lu_parameter_init(hba, hpb, hpb_dev_info, hpb_lu_info);
>
> @@ -1451,6 +1946,7 @@ ufshpb_alloc_hpb_lu(struct ufs_hba *hba, int lun,
> goto release_hpb;
> }
>
> + sdev->hostdata = hpb;
> return hpb;
>
> release_hpb:
> @@ -1653,6 +2149,7 @@ void ufshpb_destroy_lu(struct ufs_hba *hba,
> struct scsi_device *sdev)
>
> ufshpb_cancel_jobs(hpb);
>
> + ufshpb_pre_req_mempool_destroy(hpb);
> ufshpb_destroy_region_tbl(hpb);
>
> kmem_cache_destroy(hpb->map_req_cache);
> @@ -1692,6 +2189,7 @@ static void ufshpb_hpb_lu_prepared(struct ufs_hba
> *hba)
> ufshpb_set_state(hpb, HPB_PRESENT);
> if ((hpb->lu_pinned_end - hpb->lu_pinned_start) > 0)
> queue_work(ufshpb_wq, &hpb->map_work);
> + ufshpb_issue_umap_all_req(hpb);
> } else {
> dev_err(hba->dev, "destroy HPB lu %d\n", hpb->lun);
> ufshpb_destroy_lu(hba, sdev);
> @@ -1716,7 +2214,7 @@ void ufshpb_init_hpb_lu(struct ufs_hba *hba,
> struct scsi_device *sdev)
> if (ret)
> goto out;
>
> - hpb = ufshpb_alloc_hpb_lu(hba, lun, &hba->ufshpb_dev,
> + hpb = ufshpb_alloc_hpb_lu(hba, sdev, &hba->ufshpb_dev,
> &hpb_lu_info);
> if (!hpb)
> goto out;
> @@ -1724,9 +2222,6 @@ void ufshpb_init_hpb_lu(struct ufs_hba *hba,
> struct scsi_device *sdev)
> 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;
> -
> out:
> /* All LUs are initialized */
> if (atomic_dec_and_test(&hba->ufshpb_dev.slave_conf_cnt))
> @@ -1813,8 +2308,9 @@ void ufshpb_get_geo_info(struct ufs_hba *hba, u8
> *geo_buf)
> void ufshpb_get_dev_info(struct ufs_hba *hba, u8 *desc_buf)
> {
> struct ufshpb_dev_info *hpb_dev_info = &hba->ufshpb_dev;
> - int version;
> + int version, ret;
> u8 hpb_mode;
> + u32 max_hpb_single_cmd = HPB_MULTI_CHUNK_LOW;
>
> hpb_mode = desc_buf[DEVICE_DESC_PARAM_HPB_CONTROL];
> if (hpb_mode == HPB_HOST_CONTROL) {
> @@ -1825,13 +2321,27 @@ void ufshpb_get_dev_info(struct ufs_hba *hba,
> u8 *desc_buf)
> }
>
> version = get_unaligned_be16(desc_buf + DEVICE_DESC_PARAM_HPB_VER);
> - if (version != HPB_SUPPORT_VERSION) {
> + if ((version != HPB_SUPPORT_VERSION) &&
> + (version != HPB_SUPPORT_LEGACY_VERSION)) {
> dev_err(hba->dev, "%s: HPB %x version is not supported.\n",
> __func__, version);
> hpb_dev_info->hpb_disabled = true;
> return;
> }
>
> + if (version == HPB_SUPPORT_LEGACY_VERSION)
> + hpb_dev_info->is_legacy = true;
> +
> + pm_runtime_get_sync(hba->dev);
> + ret = ufshcd_query_attr_retry(hba, UPIU_QUERY_OPCODE_READ_ATTR,
> + QUERY_ATTR_IDN_MAX_HPB_SINGLE_CMD, 0, 0, &max_hpb_single_cmd);
> + pm_runtime_put_sync(hba->dev);
> +
> + if (ret)
> + dev_err(hba->dev, "%s: idn: read max size of single hpb cmd query
> request failed",
> + __func__);
> + hpb_dev_info->max_hpb_single_cmd = max_hpb_single_cmd;
> +
> /*
> * Get the number of user logical unit to check whether all
> * scsi_device finish initialization
> diff --git a/drivers/scsi/ufs/ufshpb.h b/drivers/scsi/ufs/ufshpb.h
> index 6e6a0252dc15..b1128b0ce486 100644
> --- a/drivers/scsi/ufs/ufshpb.h
> +++ b/drivers/scsi/ufs/ufshpb.h
> @@ -30,19 +30,29 @@
> #define PINNED_NOT_SET U32_MAX
>
> /* hpb support chunk size */
> -#define HPB_MULTI_CHUNK_HIGH 1
> +#define HPB_LEGACY_CHUNK_HIGH 1
> +#define HPB_MULTI_CHUNK_LOW 7
> +#define HPB_MULTI_CHUNK_HIGH 128
>
> /* hpb vender defined opcode */
> #define UFSHPB_READ 0xF8
> #define UFSHPB_READ_BUFFER 0xF9
> #define UFSHPB_READ_BUFFER_ID 0x01
> +#define UFSHPB_WRITE_BUFFER 0xFA
> +#define UFSHPB_WRITE_BUFFER_INACT_SINGLE_ID 0x01
> +#define UFSHPB_WRITE_BUFFER_PREFETCH_ID 0x02
> +#define UFSHPB_WRITE_BUFFER_INACT_ALL_ID 0x03
> +#define HPB_WRITE_BUFFER_CMD_LENGTH 10
> +#define MAX_HPB_READ_ID 0x7F
> #define HPB_READ_BUFFER_CMD_LENGTH 10
> #define LU_ENABLED_HPB_FUNC 0x02
>
> #define HPB_RESET_REQ_RETRIES 10
> #define HPB_MAP_REQ_RETRIES 5
> +#define HPB_REQUEUE_TIME_MS 0
>
> -#define HPB_SUPPORT_VERSION 0x100
> +#define HPB_SUPPORT_VERSION 0x200
> +#define HPB_SUPPORT_LEGACY_VERSION 0x100
>
> enum UFSHPB_MODE {
> HPB_HOST_CONTROL,
> @@ -119,23 +129,38 @@ struct ufshpb_region {
> (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
> + * struct ufshpb_req - HPB related request structure (write/read
> buffer)
> + * @req: block layer request structure
> + * @bio: bio for this request
> + * @hpb: ufshpb_lu structure that related to
> + * @list_req: ufshpb_req mempool list
> + * @sense: store its sense data
> * @mctx: L2P map information
> * @rgn_idx: target region index
> * @srgn_idx: target sub-region index
> * @lun: target logical unit number
> + * @m_page: L2P map information data for pre-request
> + * @len: length of host-side cached L2P map in m_page
> + * @lpn: start LPN of L2P map in m_page
> */
> 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 list_head list_req;
> + union {
> + struct {
> + struct ufshpb_map_ctx *mctx;
> + unsigned int rgn_idx;
> + unsigned int srgn_idx;
> + unsigned int lun;
> + } rb;
> + struct {
> + struct page *m_page;
> + unsigned int len;
> + unsigned long lpn;
> + } wb;
> + };
> };
>
> struct victim_select_info {
> @@ -144,6 +169,10 @@ struct victim_select_info {
> atomic_t active_cnt;
> };
>
> +struct ufshpb_params {
> + unsigned int requeue_timeout_ms;
> +};
> +
> struct ufshpb_stats {
> u64 hit_cnt;
> u64 miss_cnt;
> @@ -151,6 +180,7 @@ struct ufshpb_stats {
> u64 rb_active_cnt;
> u64 rb_inactive_cnt;
> u64 map_req_cnt;
> + u64 pre_req_cnt;
> };
>
> struct ufshpb_lu {
> @@ -166,6 +196,15 @@ struct ufshpb_lu {
> struct list_head lh_act_srgn; /* hold rsp_list_lock */
> struct list_head lh_inact_rgn; /* hold rsp_list_lock */
>
> + /* pre request information */
> + struct ufshpb_req *pre_req;
> + int num_inflight_pre_req;
> + int throttle_pre_req;
> + struct list_head lh_pre_req_free;
> + int cur_read_id;
> + int pre_req_min_tr_len;
> + int pre_req_max_tr_len;
> +
> /* cached L2P map management worker */
> struct work_struct map_work;
>
> @@ -190,6 +229,7 @@ struct ufshpb_lu {
> u32 pages_per_srgn;
>
> struct ufshpb_stats stats;
> + struct ufshpb_params params;
>
> struct kmem_cache *map_req_cache;
> struct kmem_cache *m_page_cache;
> @@ -201,7 +241,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 int ufshpb_prep(struct ufs_hba *hba, struct ufshcd_lrb *lrbp)
> { return 0; }
> 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) {}
> @@ -214,8 +254,9 @@ 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) {}
> +static bool ufshpb_is_legacy(struct ufs_hba *hba) { return false; }
> #else
> -void ufshpb_prep(struct ufs_hba *hba, struct ufshcd_lrb *lrbp);
> +int 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);
> @@ -228,7 +269,9 @@ 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);
> +bool ufshpb_is_legacy(struct ufs_hba *hba);
> extern struct attribute_group ufs_sysfs_hpb_stat_group;
> +extern struct attribute_group ufs_sysfs_hpb_param_group;
> #endif
>
> #endif /* End of Header */
^ permalink raw reply [flat|nested] 26+ messages in thread* RE: Re: [PATCH v31 4/4] scsi: ufs: Add HPB 2.0 support
2021-03-24 5:01 ` Can Guo
@ 2021-03-25 0:47 ` Daejun Park
2021-03-25 8:12 ` Can Guo
0 siblings, 1 reply; 26+ messages in thread
From: Daejun Park @ 2021-03-25 0:47 UTC (permalink / raw)
To: Can Guo, Daejun Park
Cc: Greg KH, avri.altman@wdc.com, jejb@linux.ibm.com,
martin.petersen@oracle.com, asutoshd@codeaurora.org,
stanley.chu@mediatek.com, bvanassche@acm.org, huobean@gmail.com,
linux-scsi@vger.kernel.org, linux-kernel@vger.kernel.org,
ALIM AKHTAR, JinHwan Park, Javier Gonzalez, Sung-Jun Park,
Jinyoung CHOI, Dukhyun Kwon, Keoseong Park, Jaemyung Lee,
Jieon Seol
> On 2021-03-22 14:55, Daejun Park wrote:
> > This patch supports the HPB 2.0.
> >
> > The HPB 2.0 supports read of varying sizes from 4KB to 512KB.
> > In the case of Read (<= 32KB) is supported as single HPB read.
> > In the case of Read (36KB ~ 512KB) is supported by as a combination of
> > write buffer command and HPB read command to deliver more PPN.
> > The write buffer commands may not be issued immediately due to busy
> > tags.
> > To use HPB read more aggressively, the driver can requeue the write
> > buffer
> > command. The requeue threshold is implemented as timeout and can be
> > modified with requeue_timeout_ms entry in sysfs.
> >
> > Signed-off-by: Daejun Park <daejun7.park@samsung.com>
> > ---
> > Documentation/ABI/testing/sysfs-driver-ufs | 47 +-
> > drivers/scsi/ufs/ufs-sysfs.c | 4 +
> > drivers/scsi/ufs/ufs.h | 3 +-
> > drivers/scsi/ufs/ufshcd.c | 25 +-
> > drivers/scsi/ufs/ufshcd.h | 7 +
> > drivers/scsi/ufs/ufshpb.c | 626 +++++++++++++++++++--
> > drivers/scsi/ufs/ufshpb.h | 67 ++-
> > 7 files changed, 698 insertions(+), 81 deletions(-)
> >
> > diff --git a/Documentation/ABI/testing/sysfs-driver-ufs
> > b/Documentation/ABI/testing/sysfs-driver-ufs
> > index 528bf89fc98b..419adf450b89 100644
> > --- a/Documentation/ABI/testing/sysfs-driver-ufs
> > +++ b/Documentation/ABI/testing/sysfs-driver-ufs
> > @@ -1253,14 +1253,14 @@ Description: This entry shows the number of
> > HPB pinned regions assigned to
> >
> > The file is read only.
> >
> > -What: /sys/class/scsi_device/*/device/hpb_sysfs/hit_cnt
> > +What: /sys/class/scsi_device/*/device/hpb_stat_sysfs/hit_cnt
> > Date: March 2021
> > Contact: Daejun Park <daejun7.park@samsung.com>
> > Description: This entry shows the number of reads that changed to HPB
> > read.
> >
> > The file is read only.
> >
> > -What: /sys/class/scsi_device/*/device/hpb_sysfs/miss_cnt
> > +What: /sys/class/scsi_device/*/device/hpb_stat_sysfs/miss_cnt
> > Date: March 2021
> > Contact: Daejun Park <daejun7.park@samsung.com>
> > Description: This entry shows the number of reads that cannot be
> > changed to
> > @@ -1268,7 +1268,7 @@ Description: This entry shows the number of
> > reads that cannot be changed to
> >
> > The file is read only.
> >
> > -What: /sys/class/scsi_device/*/device/hpb_sysfs/rb_noti_cnt
> > +What: /sys/class/scsi_device/*/device/hpb_stat_sysfs/rb_noti_cnt
> > Date: March 2021
> > Contact: Daejun Park <daejun7.park@samsung.com>
> > Description: This entry shows the number of response UPIUs that has
> > @@ -1276,7 +1276,7 @@ Description: This entry shows the number of
> > response UPIUs that has
> >
> > The file is read only.
> >
> > -What: /sys/class/scsi_device/*/device/hpb_sysfs/rb_active_cnt
> > +What: /sys/class/scsi_device/*/device/hpb_stat_sysfs/rb_active_cnt
> > Date: March 2021
> > Contact: Daejun Park <daejun7.park@samsung.com>
> > Description: This entry shows the number of active sub-regions
> > recommended by
> > @@ -1284,7 +1284,7 @@ Description: This entry shows the number of
> > active sub-regions recommended by
> >
> > The file is read only.
> >
> > -What: /sys/class/scsi_device/*/device/hpb_sysfs/rb_inactive_cnt
> > +What: /sys/class/scsi_device/*/device/hpb_stat_sysfs/rb_inactive_cnt
> > Date: March 2021
> > Contact: Daejun Park <daejun7.park@samsung.com>
> > Description: This entry shows the number of inactive regions
> > recommended by
> > @@ -1292,10 +1292,45 @@ Description: This entry shows the number of
> > inactive regions recommended by
> >
> > The file is read only.
> >
> > -What: /sys/class/scsi_device/*/device/hpb_sysfs/map_req_cnt
> > +What: /sys/class/scsi_device/*/device/hpb_stat_sysfs/map_req_cnt
> > Date: March 2021
> > Contact: Daejun Park <daejun7.park@samsung.com>
> > Description: This entry shows the number of read buffer commands for
> > activating sub-regions recommended by response UPIUs.
> >
> > The file is read only.
> > +
> > +What: /sys/class/scsi_device/*/device/hpb_param_sysfs/requeue_timeout_ms
> > +Date: March 2021
> > +Contact: Daejun Park <daejun7.park@samsung.com>
> > +Description: This entry shows the requeue timeout threshold for write
> > buffer
> > + command in ms. This value can be changed by writing proper integer
> > to
> > + this entry.
> > +
> > +What: /sys/bus/platform/drivers/ufshcd/*/attributes/max_data_size_hpb_single_cmd
> > +Date: March 2021
> > +Contact: Daejun Park <daejun7.park@samsung.com>
> > +Description: This entry shows the maximum HPB data size for using
> > single HPB
> > + command.
> > +
> > + === ========
> > + 00h 4KB
> > + 01h 8KB
> > + 02h 12KB
> > + ...
> > + FFh 1024KB
> > + === ========
> > +
> > + The file is read only.
> > +
> > +What: /sys/bus/platform/drivers/ufshcd/*/flags/wb_enable
> > +Date: March 2021
> > +Contact: Daejun Park <daejun7.park@samsung.com>
> > +Description: This entry shows the status of HPB.
> > +
> > + == ============================
> > + 0 HPB is not enabled.
> > + 1 HPB is enabled
> > + == ============================
> > +
> > + The file is read only.
> > diff --git a/drivers/scsi/ufs/ufs-sysfs.c
> > b/drivers/scsi/ufs/ufs-sysfs.c
> > index 2546e7a1ac4f..92a883866e12 100644
> > --- a/drivers/scsi/ufs/ufs-sysfs.c
> > +++ b/drivers/scsi/ufs/ufs-sysfs.c
> > @@ -782,6 +782,7 @@ UFS_FLAG(disable_fw_update,
> > _PERMANENTLY_DISABLE_FW_UPDATE);
> > UFS_FLAG(wb_enable, _WB_EN);
> > UFS_FLAG(wb_flush_en, _WB_BUFF_FLUSH_EN);
> > UFS_FLAG(wb_flush_during_h8, _WB_BUFF_FLUSH_DURING_HIBERN8);
> > +UFS_FLAG(hpb_enable, _HPB_EN);
> >
> > static struct attribute *ufs_sysfs_device_flags[] = {
> > &dev_attr_device_init.attr,
> > @@ -795,6 +796,7 @@ static struct attribute *ufs_sysfs_device_flags[] =
> > {
> > &dev_attr_wb_enable.attr,
> > &dev_attr_wb_flush_en.attr,
> > &dev_attr_wb_flush_during_h8.attr,
> > + &dev_attr_hpb_enable.attr,
> > NULL,
> > };
> >
> > @@ -841,6 +843,7 @@ out: \
> > static DEVICE_ATTR_RO(_name)
> >
> > UFS_ATTRIBUTE(boot_lun_enabled, _BOOT_LU_EN);
> > +UFS_ATTRIBUTE(max_data_size_hpb_single_cmd, _MAX_HPB_SINGLE_CMD);
> > UFS_ATTRIBUTE(current_power_mode, _POWER_MODE);
> > UFS_ATTRIBUTE(active_icc_level, _ACTIVE_ICC_LVL);
> > UFS_ATTRIBUTE(ooo_data_enabled, _OOO_DATA_EN);
> > @@ -864,6 +867,7 @@ UFS_ATTRIBUTE(wb_cur_buf, _CURR_WB_BUFF_SIZE);
> >
> > static struct attribute *ufs_sysfs_attributes[] = {
> > &dev_attr_boot_lun_enabled.attr,
> > + &dev_attr_max_data_size_hpb_single_cmd.attr,
> > &dev_attr_current_power_mode.attr,
> > &dev_attr_active_icc_level.attr,
> > &dev_attr_ooo_data_enabled.attr,
> > diff --git a/drivers/scsi/ufs/ufs.h b/drivers/scsi/ufs/ufs.h
> > index bfb84d2ba990..8c6b38b1b142 100644
> > --- a/drivers/scsi/ufs/ufs.h
> > +++ b/drivers/scsi/ufs/ufs.h
> > @@ -123,12 +123,13 @@ enum flag_idn {
> > QUERY_FLAG_IDN_WB_BUFF_FLUSH_EN = 0x0F,
> > QUERY_FLAG_IDN_WB_BUFF_FLUSH_DURING_HIBERN8 = 0x10,
> > QUERY_FLAG_IDN_HPB_RESET = 0x11,
> > + QUERY_FLAG_IDN_HPB_EN = 0x12,
> > };
> >
> > /* Attribute idn for Query requests */
> > enum attr_idn {
> > QUERY_ATTR_IDN_BOOT_LU_EN = 0x00,
> > - QUERY_ATTR_IDN_RESERVED = 0x01,
> > + QUERY_ATTR_IDN_MAX_HPB_SINGLE_CMD = 0x01,
> > QUERY_ATTR_IDN_POWER_MODE = 0x02,
> > QUERY_ATTR_IDN_ACTIVE_ICC_LVL = 0x03,
> > QUERY_ATTR_IDN_OOO_DATA_EN = 0x04,
> > diff --git a/drivers/scsi/ufs/ufshcd.c b/drivers/scsi/ufs/ufshcd.c
> > index a7cf9278965c..1653c7a7b066 100644
> > --- a/drivers/scsi/ufs/ufshcd.c
> > +++ b/drivers/scsi/ufs/ufshcd.c
> > @@ -2653,7 +2653,12 @@ static int ufshcd_queuecommand(struct Scsi_Host
> > *host, struct scsi_cmnd *cmd)
> >
> > lrbp->req_abort_skip = false;
> >
> > - ufshpb_prep(hba, lrbp);
> > + err = ufshpb_prep(hba, lrbp);
> > + if (err == -EAGAIN) {
> > + lrbp->cmd = NULL;
> > + ufshcd_release(hba);
> > + goto out;
> > + }
> >
> > ufshcd_comp_scsi_upiu(hba, lrbp);
> >
> > @@ -3107,7 +3112,7 @@ int ufshcd_query_attr(struct ufs_hba *hba, enum
> > query_opcode opcode,
> > *
> > * Returns 0 for success, non-zero in case of failure
> > */
> > -static int ufshcd_query_attr_retry(struct ufs_hba *hba,
> > +int ufshcd_query_attr_retry(struct ufs_hba *hba,
> > enum query_opcode opcode, enum attr_idn idn, u8 index, u8 selector,
> > u32 *attr_val)
> > {
> > @@ -4862,7 +4867,8 @@ static int ufshcd_change_queue_depth(struct
> > scsi_device *sdev, int 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))
> > + if ((sdev->lun >= UFS_UPIU_MAX_UNIT_NUM_ID) ||
> > + !(hba->dev_info.hpb_enabled) || !ufshpb_is_allowed(hba))
> > return;
> >
> > ufshpb_destroy_lu(hba, sdev);
> > @@ -7454,8 +7460,18 @@ static int ufs_get_device_desc(struct ufs_hba
> > *hba)
> >
> > if (dev_info->wspecversion >= UFS_DEV_HPB_SUPPORT_VERSION &&
> > (b_ufs_feature_sup & UFS_DEV_HPB_SUPPORT)) {
> > - dev_info->hpb_enabled = true;
> > + bool hpb_en = false;
> > +
> > ufshpb_get_dev_info(hba, desc_buf);
> > +
> > + if (!ufshpb_is_legacy(hba))
> > + err = ufshcd_query_flag_retry(hba,
> > + UPIU_QUERY_OPCODE_READ_FLAG,
> > + QUERY_FLAG_IDN_HPB_EN, 0,
> > + &hpb_en);
> > +
> > + if (ufshpb_is_legacy(hba) || (!err && hpb_en))
> > + dev_info->hpb_enabled = true;
> > }
> >
> > err = ufshcd_read_string_desc(hba, model_index,
> > @@ -8028,6 +8044,7 @@ static const struct attribute_group
> > *ufshcd_driver_groups[] = {
> > &ufs_sysfs_lun_attributes_group,
> > #ifdef CONFIG_SCSI_UFS_HPB
> > &ufs_sysfs_hpb_stat_group,
> > + &ufs_sysfs_hpb_param_group,
> > #endif
> > NULL,
> > };
> > diff --git a/drivers/scsi/ufs/ufshcd.h b/drivers/scsi/ufs/ufshcd.h
> > index 008a5f7146c0..8aca8f327981 100644
> > --- a/drivers/scsi/ufs/ufshcd.h
> > +++ b/drivers/scsi/ufs/ufshcd.h
> > @@ -654,6 +654,8 @@ struct ufs_hba_variant_params {
> > * @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
> > + * @max_hpb_single_cmd: maximum size of single HPB command
> > + * @is_legacy: flag to check HPB 1.0
> > */
> > struct ufshpb_dev_info {
> > int num_lu;
> > @@ -661,6 +663,8 @@ struct ufshpb_dev_info {
> > int srgn_size;
> > atomic_t slave_conf_cnt;
> > bool hpb_disabled;
> > + int max_hpb_single_cmd;
> > + bool is_legacy;
> > };
> > #endif
> >
> > @@ -1096,6 +1100,9 @@ int ufshcd_read_desc_param(struct ufs_hba *hba,
> > u8 param_offset,
> > u8 *param_read_buf,
> > u8 param_size);
> > +int ufshcd_query_attr_retry(struct ufs_hba *hba, enum query_opcode
> > opcode,
> > + enum attr_idn idn, u8 index, u8 selector,
> > + u32 *attr_val);
> > int ufshcd_query_attr(struct ufs_hba *hba, enum query_opcode opcode,
> > enum attr_idn idn, u8 index, u8 selector, u32 *attr_val);
> > int ufshcd_query_flag(struct ufs_hba *hba, enum query_opcode opcode,
> > diff --git a/drivers/scsi/ufs/ufshpb.c b/drivers/scsi/ufs/ufshpb.c
> > index f789339f68d9..3ac8b0a9e8d3 100644
> > --- a/drivers/scsi/ufs/ufshpb.c
> > +++ b/drivers/scsi/ufs/ufshpb.c
> > @@ -31,6 +31,11 @@ bool ufshpb_is_allowed(struct ufs_hba *hba)
> > return !(hba->ufshpb_dev.hpb_disabled);
> > }
> >
> > +bool ufshpb_is_legacy(struct ufs_hba *hba)
> > +{
> > + return hba->ufshpb_dev.is_legacy;
> > +}
> > +
> > static struct ufshpb_lu *ufshpb_get_hpb_data(struct scsi_device *sdev)
> > {
> > return sdev->hostdata;
> > @@ -64,9 +69,19 @@ static bool ufshpb_is_write_or_discard_cmd(struct
> > scsi_cmnd *cmd)
> > op_is_discard(req_op(cmd->request));
> > }
> >
> > -static bool ufshpb_is_support_chunk(int transfer_len)
> > +static bool ufshpb_is_support_chunk(struct ufshpb_lu *hpb, int
> > transfer_len)
> > {
> > - return transfer_len <= HPB_MULTI_CHUNK_HIGH;
> > + return transfer_len <= hpb->pre_req_max_tr_len;
> > +}
> > +
> > +/*
> > + * In this driver, WRITE_BUFFER CMD support 36KB (len=9) ~ 512KB
> > (len=128) as
> > + * default. It is possible to change range of transfer_len through
> > sysfs.
> > + */
> > +static inline bool ufshpb_is_required_wb(struct ufshpb_lu *hpb, int
> > len)
> > +{
> > + return (len > hpb->pre_req_min_tr_len &&
> > + len <= hpb->pre_req_max_tr_len);
> > }
> >
> > static bool ufshpb_is_general_lun(int lun)
> > @@ -74,8 +89,7 @@ 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)
> > +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 &&
> > @@ -264,7 +278,8 @@ ufshpb_get_pos_from_lpn(struct ufshpb_lu *hpb,
> > unsigned long lpn, int *rgn_idx,
> >
> > static void
> > ufshpb_set_hpb_read_to_upiu(struct ufshpb_lu *hpb, struct ufshcd_lrb
> > *lrbp,
> > - u32 lpn, u64 ppn, unsigned int transfer_len)
> > + u32 lpn, u64 ppn, unsigned int transfer_len,
> > + int read_id)
> > {
> > unsigned char *cdb = lrbp->cmd->cmnd;
> >
> > @@ -273,15 +288,261 @@ ufshpb_set_hpb_read_to_upiu(struct ufshpb_lu
> > *hpb, struct ufshcd_lrb *lrbp,
> > /* ppn value is stored as big-endian in the host memory */
> > memcpy(&cdb[6], &ppn, sizeof(u64));
> > cdb[14] = transfer_len;
> > + cdb[15] = read_id;
> >
> > lrbp->cmd->cmd_len = UFS_CDB_SIZE;
> > }
> >
> > +static inline void ufshpb_set_write_buf_cmd(unsigned char *cdb,
> > + unsigned long lpn, unsigned int len,
> > + int read_id)
> > +{
> > + cdb[0] = UFSHPB_WRITE_BUFFER;
> > + cdb[1] = UFSHPB_WRITE_BUFFER_PREFETCH_ID;
> > +
> > + put_unaligned_be32(lpn, &cdb[2]);
> > + cdb[6] = read_id;
> > + put_unaligned_be16(len * HPB_ENTRY_SIZE, &cdb[7]);
> > +
> > + cdb[9] = 0x00; /* Control = 0x00 */
> > +}
> > +
> > +static struct ufshpb_req *ufshpb_get_pre_req(struct ufshpb_lu *hpb)
> > +{
> > + struct ufshpb_req *pre_req;
> > +
> > + if (hpb->num_inflight_pre_req >= hpb->throttle_pre_req) {
> > + dev_info(&hpb->sdev_ufs_lu->sdev_dev,
> > + "pre_req throttle. inflight %d throttle %d",
> > + hpb->num_inflight_pre_req, hpb->throttle_pre_req);
> > + return NULL;
> > + }
> > +
> > + pre_req = list_first_entry_or_null(&hpb->lh_pre_req_free,
> > + struct ufshpb_req, list_req);
> > + if (!pre_req) {
> > + dev_info(&hpb->sdev_ufs_lu->sdev_dev, "There is no pre_req");
> > + return NULL;
> > + }
> > +
> > + list_del_init(&pre_req->list_req);
> > + hpb->num_inflight_pre_req++;
> > +
> > + return pre_req;
> > +}
> > +
> > +static inline void ufshpb_put_pre_req(struct ufshpb_lu *hpb,
> > + struct ufshpb_req *pre_req)
> > +{
> > + pre_req->req = NULL;
> > + bio_reset(pre_req->bio);
> > + list_add_tail(&pre_req->list_req, &hpb->lh_pre_req_free);
> > + hpb->num_inflight_pre_req--;
> > +}
> > +
> > +static void ufshpb_pre_req_compl_fn(struct request *req, blk_status_t
> > error)
> > +{
> > + struct ufshpb_req *pre_req = (struct ufshpb_req *)req->end_io_data;
> > + struct ufshpb_lu *hpb = pre_req->hpb;
> > + unsigned long flags;
> > +
> > + if (error) {
> > + struct scsi_request *rq = scsi_req(req);
> > + struct scsi_sense_hdr sshdr;
> > +
> > + dev_err(&hpb->sdev_ufs_lu->sdev_dev, "block status %d", error);
> > + scsi_normalize_sense(rq->sense, SCSI_SENSE_BUFFERSIZE,
> > + &sshdr);
> > + dev_err(&hpb->sdev_ufs_lu->sdev_dev,
> > + "code %x sense_key %x asc %x ascq %x",
> > + sshdr.response_code,
> > + sshdr.sense_key, sshdr.asc, sshdr.ascq);
> > + dev_err(&hpb->sdev_ufs_lu->sdev_dev,
> > + "byte4 %x byte5 %x byte6 %x additional_len %x",
> > + sshdr.byte4, sshdr.byte5,
> > + sshdr.byte6, sshdr.additional_length);
> > + }
> > +
> > + blk_mq_free_request(req);
> > + spin_lock_irqsave(&hpb->rgn_state_lock, flags);
> > + ufshpb_put_pre_req(pre_req->hpb, pre_req);
> > + spin_unlock_irqrestore(&hpb->rgn_state_lock, flags);
> > +}
> > +
> > +static int ufshpb_prep_entry(struct ufshpb_req *pre_req, struct page
> > *page)
> > +{
> > + struct ufshpb_lu *hpb = pre_req->hpb;
> > + struct ufshpb_region *rgn;
> > + struct ufshpb_subregion *srgn;
> > + u64 *addr;
> > + int offset = 0;
> > + int copied;
> > + unsigned long lpn = pre_req->wb.lpn;
> > + int rgn_idx, srgn_idx, srgn_offset;
> > + unsigned long flags;
> > +
> > + addr = page_address(page);
> > + ufshpb_get_pos_from_lpn(hpb, lpn, &rgn_idx, &srgn_idx, &srgn_offset);
> > +
> > + spin_lock_irqsave(&hpb->rgn_state_lock, flags);
> > +
> > +next_offset:
> > + rgn = hpb->rgn_tbl + rgn_idx;
> > + srgn = rgn->srgn_tbl + srgn_idx;
> > +
> > + if (!ufshpb_is_valid_srgn(rgn, srgn))
> > + goto mctx_error;
> > +
> > + if (!srgn->mctx)
> > + goto mctx_error;
> > +
> > + copied = ufshpb_fill_ppn_from_page(hpb, srgn->mctx, srgn_offset,
> > + pre_req->wb.len - offset,
> > + &addr[offset]);
> > +
> > + if (copied < 0)
> > + goto mctx_error;
> > +
> > + offset += copied;
> > + srgn_offset += copied;
> > +
> > + if (srgn_offset == hpb->entries_per_srgn) {
> > + srgn_offset = 0;
> > +
> > + if (++srgn_idx == hpb->srgns_per_rgn) {
> > + srgn_idx = 0;
> > + rgn_idx++;
> > + }
> > + }
> > +
> > + if (offset < pre_req->wb.len)
> > + goto next_offset;
> > +
> > + spin_unlock_irqrestore(&hpb->rgn_state_lock, flags);
> > + return 0;
> > +mctx_error:
> > + spin_unlock_irqrestore(&hpb->rgn_state_lock, flags);
> > + return -ENOMEM;
> > +}
> > +
> > +static int ufshpb_pre_req_add_bio_page(struct ufshpb_lu *hpb,
> > + struct request_queue *q,
> > + struct ufshpb_req *pre_req)
> > +{
> > + struct page *page = pre_req->wb.m_page;
> > + struct bio *bio = pre_req->bio;
> > + int entries_bytes, ret;
> > +
> > + if (!page)
> > + return -ENOMEM;
> > +
> > + if (ufshpb_prep_entry(pre_req, page))
> > + return -ENOMEM;
> > +
> > + entries_bytes = pre_req->wb.len * sizeof(u64);
> > +
> > + ret = bio_add_pc_page(q, bio, page, entries_bytes, 0);
> > + if (ret != entries_bytes) {
> > + dev_err(&hpb->sdev_ufs_lu->sdev_dev,
> > + "bio_add_pc_page fail: %d", ret);
> > + return -ENOMEM;
> > + }
> > + return 0;
> > +}
> > +
> > +static inline int ufshpb_get_read_id(struct ufshpb_lu *hpb)
> > +{
> > + if (++hpb->cur_read_id >= MAX_HPB_READ_ID)
> > + hpb->cur_read_id = 1;
> > + return hpb->cur_read_id;
> > +}
> > +
> > +static int ufshpb_execute_pre_req(struct ufshpb_lu *hpb, struct
> > scsi_cmnd *cmd,
> > + struct ufshpb_req *pre_req, int read_id)
> > +{
> > + struct scsi_device *sdev = cmd->device;
> > + struct request_queue *q = sdev->request_queue;
> > + struct request *req;
> > + struct scsi_request *rq;
> > + struct bio *bio = pre_req->bio;
> > +
> > + pre_req->hpb = hpb;
> > + pre_req->wb.lpn = sectors_to_logical(cmd->device,
> > + blk_rq_pos(cmd->request));
> > + pre_req->wb.len = sectors_to_logical(cmd->device,
> > + blk_rq_sectors(cmd->request));
> > + if (ufshpb_pre_req_add_bio_page(hpb, q, pre_req))
> > + return -ENOMEM;
> > +
> > + req = pre_req->req;
> > +
> > + /* 1. request setup */
> > + blk_rq_append_bio(req, &bio);
> > + req->rq_disk = NULL;
> > + req->end_io_data = (void *)pre_req;
> > + req->end_io = ufshpb_pre_req_compl_fn;
> > +
> > + /* 2. scsi_request setup */
> > + rq = scsi_req(req);
> > + rq->retries = 1;
> > +
> > + ufshpb_set_write_buf_cmd(rq->cmd, pre_req->wb.lpn, pre_req->wb.len,
> > + read_id);
> > + rq->cmd_len = scsi_command_size(rq->cmd);
> > +
> > + if (blk_insert_cloned_request(q, req) != BLK_STS_OK)
> > + return -EAGAIN;
> > +
> > + hpb->stats.pre_req_cnt++;
> > +
> > + return 0;
> > +}
> > +
> > +static int ufshpb_issue_pre_req(struct ufshpb_lu *hpb, struct
> > scsi_cmnd *cmd,
> > + int *read_id)
> > +{
> > + struct ufshpb_req *pre_req;
> > + struct request *req = NULL;
> > + unsigned long flags;
> > + int _read_id;
> > + int ret = 0;
> > +
> > + req = blk_get_request(cmd->device->request_queue,
> > + REQ_OP_SCSI_OUT | REQ_SYNC, BLK_MQ_REQ_NOWAIT);
> > + if (IS_ERR(req))
> > + return -EAGAIN;
> > +
> > + spin_lock_irqsave(&hpb->rgn_state_lock, flags);
> > + pre_req = ufshpb_get_pre_req(hpb);
> > + if (!pre_req) {
> > + ret = -EAGAIN;
> > + goto unlock_out;
> > + }
> > + _read_id = ufshpb_get_read_id(hpb);
> > + spin_unlock_irqrestore(&hpb->rgn_state_lock, flags);
> > +
> > + pre_req->req = req;
> > +
> > + ret = ufshpb_execute_pre_req(hpb, cmd, pre_req, _read_id);
> > + if (ret)
> > + goto free_pre_req;
> > +
> > + *read_id = _read_id;
> > +
> > + return ret;
> > +free_pre_req:
> > + spin_lock_irqsave(&hpb->rgn_state_lock, flags);
> > + ufshpb_put_pre_req(hpb, pre_req);
> > +unlock_out:
> > + spin_unlock_irqrestore(&hpb->rgn_state_lock, flags);
> > + blk_put_request(req);
> > + return ret;
> > +}
> > +
> > /*
> > * 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)
> > +int ufshpb_prep(struct ufs_hba *hba, struct ufshcd_lrb *lrbp)
> > {
> > struct ufshpb_lu *hpb;
> > struct ufshpb_region *rgn;
> > @@ -291,19 +552,20 @@ void ufshpb_prep(struct ufs_hba *hba, struct
> > ufshcd_lrb *lrbp)
> > u64 ppn;
> > unsigned long flags;
> > int transfer_len, rgn_idx, srgn_idx, srgn_offset;
> > + int read_id = 0;
> > int err = 0;
> >
> > hpb = ufshpb_get_hpb_data(cmd->device);
> > if (!hpb)
> > - return;
> > + return -ENODEV;
> >
> > if (ufshpb_get_state(hpb) == HPB_INIT)
> > - return;
> > + return -ENODEV;
> >
> > if (ufshpb_get_state(hpb) != HPB_PRESENT) {
> > dev_notice(&hpb->sdev_ufs_lu->sdev_dev,
> > "%s: ufshpb state is not PRESENT", __func__);
> > - return;
> > + return -ENODEV;
> > }
> >
> > if (blk_rq_is_scsi(cmd->request) ||
> > @@ -314,7 +576,7 @@ void ufshpb_prep(struct ufs_hba *hba, struct
> > ufshcd_lrb *lrbp)
> > transfer_len = sectors_to_logical(cmd->device,
> > blk_rq_sectors(cmd->request));
> > if (unlikely(!transfer_len))
> > - return;
> > + return 0;
> >
> > lpn = sectors_to_logical(cmd->device, blk_rq_pos(cmd->request));
> > ufshpb_get_pos_from_lpn(hpb, lpn, &rgn_idx, &srgn_idx, &srgn_offset);
> > @@ -327,18 +589,18 @@ void ufshpb_prep(struct ufs_hba *hba, struct
> > ufshcd_lrb *lrbp)
> > ufshpb_set_ppn_dirty(hpb, rgn_idx, srgn_idx, srgn_offset,
> > transfer_len);
> > spin_unlock_irqrestore(&hpb->rgn_state_lock, flags);
> > - return;
> > + return 0;
> > }
> >
> > - if (!ufshpb_is_support_chunk(transfer_len))
> > - return;
> > + if (!ufshpb_is_support_chunk(hpb, transfer_len))
> > + return 0;
> >
> > 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;
> > + return 0;
> > }
> >
> > err = ufshpb_fill_ppn_from_page(hpb, srgn->mctx, srgn_offset, 1,
> > &ppn);
> > @@ -351,64 +613,101 @@ void ufshpb_prep(struct ufs_hba *hba, struct
> > ufshcd_lrb *lrbp)
> > * active state.
> > */
> > dev_err(hba->dev, "get ppn failed. err %d\n", err);
> > - return;
> > + return err;
> > + }
> > + if (!ufshpb_is_legacy(hba) &&
> > + ufshpb_is_required_wb(hpb, transfer_len)) {
> > + err = ufshpb_issue_pre_req(hpb, cmd, &read_id);
> > + if (err) {
> > + unsigned long timeout;
> > +
> > + timeout = cmd->jiffies_at_alloc + msecs_to_jiffies(
> > + hpb->params.requeue_timeout_ms);
> > +
> > + if (time_before(jiffies, timeout))
> > + return -EAGAIN;
> > +
> > + hpb->stats.miss_cnt++;
> > + return 0;
> > + }
> > }
> >
> > - ufshpb_set_hpb_read_to_upiu(hpb, lrbp, lpn, ppn, transfer_len);
> > + ufshpb_set_hpb_read_to_upiu(hpb, lrbp, lpn, ppn, transfer_len,
> > read_id);
> >
> > hpb->stats.hit_cnt++;
> > + return 0;
> > }
> > -static struct ufshpb_req *ufshpb_get_map_req(struct ufshpb_lu *hpb,
> > - struct ufshpb_subregion *srgn)
> > +
> > +static struct ufshpb_req *ufshpb_get_req(struct ufshpb_lu *hpb,
> > + int rgn_idx, enum req_opf dir,
> > + bool atomic)
>
> You didn't mention this change in cover letter. And I don't see anyone
> is passing "atomic" as true, neither in your patches nor Avri's V6
> series
> (from ufshpb_issue_umap_single_req()). If no one is using the flag, then
> this is dead code. If Avri needs this flag, he can add it in host
> control
> mode patches. Do I miss anything?
I thought Avri will use this flag under atomic section. There is no
spin_lock on ufshpb_issue_umap_single_req in the Avri's V6 series, so I
will delete it.
Thanks,
Daejun
>
> Thanks,
> Can Guo.
>
> > {
> > - struct ufshpb_req *map_req;
> > + struct ufshpb_req *rq;
> > struct request *req;
> > - struct bio *bio;
> > int retries = HPB_MAP_REQ_RETRIES;
> >
> > - map_req = kmem_cache_alloc(hpb->map_req_cache, GFP_KERNEL);
> > - if (!map_req)
> > + rq = kmem_cache_alloc(hpb->map_req_cache, GFP_ATOMIC);
> > + if (!rq)
> > return NULL;
> >
> > retry:
> > - req = blk_get_request(hpb->sdev_ufs_lu->request_queue,
> > - REQ_OP_SCSI_IN, BLK_MQ_REQ_NOWAIT);
> > + req = blk_get_request(hpb->sdev_ufs_lu->request_queue, dir,
> > + BLK_MQ_REQ_NOWAIT);
> >
> > - if ((PTR_ERR(req) == -EWOULDBLOCK) && (--retries > 0)) {
> > + if (!atomic && (PTR_ERR(req) == -EWOULDBLOCK) && (--retries > 0)) {
> > usleep_range(3000, 3100);
> > goto retry;
> > }
> >
> > if (IS_ERR(req))
> > - goto free_map_req;
> > + goto free_rq;
> > +
> > + rq->hpb = hpb;
> > + rq->req = req;
> > + rq->rb.rgn_idx = rgn_idx;
> > +
> > + return rq;
> > +
> > +free_rq:
> > + kmem_cache_free(hpb->map_req_cache, rq);
> > + return NULL;
> > +}
> > +
> > +static void ufshpb_put_req(struct ufshpb_lu *hpb, struct ufshpb_req
> > *rq)
> > +{
> > + blk_put_request(rq->req);
> > + kmem_cache_free(hpb->map_req_cache, rq);
> > +}
> > +
> > +static struct ufshpb_req *ufshpb_get_map_req(struct ufshpb_lu *hpb,
> > + struct ufshpb_subregion *srgn)
> > +{
> > + struct ufshpb_req *map_req;
> > + struct bio *bio;
> > +
> > + map_req = ufshpb_get_req(hpb, srgn->rgn_idx, REQ_OP_SCSI_IN, false);
> > + if (!map_req)
> > + return NULL;
> >
> > bio = bio_alloc(GFP_KERNEL, hpb->pages_per_srgn);
> > if (!bio) {
> > - blk_put_request(req);
> > - goto free_map_req;
> > + ufshpb_put_req(hpb, map_req);
> > + return NULL;
> > }
> >
> > - 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->rb.srgn_idx = srgn->srgn_idx;
> > + map_req->rb.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);
> > + ufshpb_put_req(hpb, map_req);
> > }
> >
> > static int ufshpb_clear_dirty_bitmap(struct ufshpb_lu *hpb,
> > @@ -491,6 +790,13 @@ static void ufshpb_activate_subregion(struct
> > ufshpb_lu *hpb,
> > srgn->srgn_state = HPB_SRGN_VALID;
> > }
> >
> > +static void ufshpb_umap_req_compl_fn(struct request *req, blk_status_t
> > error)
> > +{
> > + struct ufshpb_req *umap_req = (struct ufshpb_req *)req->end_io_data;
> > +
> > + ufshpb_put_req(umap_req->hpb, umap_req);
> > +}
> > +
> > 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;
> > @@ -498,8 +804,8 @@ static void ufshpb_map_req_compl_fn(struct request
> > *req, blk_status_t error)
> > struct ufshpb_subregion *srgn;
> > unsigned long flags;
> >
> > - srgn = hpb->rgn_tbl[map_req->rgn_idx].srgn_tbl +
> > - map_req->srgn_idx;
> > + srgn = hpb->rgn_tbl[map_req->rb.rgn_idx].srgn_tbl +
> > + map_req->rb.srgn_idx;
> >
> > ufshpb_clear_dirty_bitmap(hpb, srgn);
> > spin_lock_irqsave(&hpb->rgn_state_lock, flags);
> > @@ -509,6 +815,16 @@ static void ufshpb_map_req_compl_fn(struct
> > request *req, blk_status_t error)
> > ufshpb_put_map_req(map_req->hpb, map_req);
> > }
> >
> > +static void ufshpb_set_unmap_cmd(unsigned char *cdb, struct
> > ufshpb_region *rgn)
> > +{
> > + cdb[0] = UFSHPB_WRITE_BUFFER;
> > + cdb[1] = rgn ? UFSHPB_WRITE_BUFFER_INACT_SINGLE_ID :
> > + UFSHPB_WRITE_BUFFER_INACT_ALL_ID;
> > + if (rgn)
> > + put_unaligned_be16(rgn->rgn_idx, &cdb[2]);
> > + cdb[9] = 0x00;
> > +}
> > +
> > static void ufshpb_set_read_buf_cmd(unsigned char *cdb, int rgn_idx,
> > int srgn_idx, int srgn_mem_size)
> > {
> > @@ -522,6 +838,25 @@ static void ufshpb_set_read_buf_cmd(unsigned char
> > *cdb, int rgn_idx,
> > cdb[9] = 0x00;
> > }
> >
> > +static int ufshpb_execute_umap_req(struct ufshpb_lu *hpb,
> > + struct ufshpb_req *umap_req,
> > + struct ufshpb_region *rgn)
> > +{
> > + struct request *req;
> > + struct scsi_request *rq;
> > +
> > + req = umap_req->req;
> > + req->timeout = 0;
> > + req->end_io_data = (void *)umap_req;
> > + rq = scsi_req(req);
> > + ufshpb_set_unmap_cmd(rq->cmd, rgn);
> > + rq->cmd_len = HPB_WRITE_BUFFER_CMD_LENGTH;
> > +
> > + blk_execute_rq_nowait(NULL, req, 1, ufshpb_umap_req_compl_fn);
> > +
> > + return 0;
> > +}
> > +
> > static int ufshpb_execute_map_req(struct ufshpb_lu *hpb,
> > struct ufshpb_req *map_req, bool last)
> > {
> > @@ -534,12 +869,12 @@ static int ufshpb_execute_map_req(struct
> > ufshpb_lu *hpb,
> >
> > 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],
> > + ret = bio_add_pc_page(q, map_req->bio, map_req->rb.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);
> > + map_req->rb.rgn_idx, map_req->rb.srgn_idx);
> > return ret;
> > }
> > }
> > @@ -555,8 +890,8 @@ static int ufshpb_execute_map_req(struct ufshpb_lu
> > *hpb,
> > if (unlikely(last))
> > mem_size = hpb->last_srgn_entries * HPB_ENTRY_SIZE;
> >
> > - ufshpb_set_read_buf_cmd(rq->cmd, map_req->rgn_idx,
> > - map_req->srgn_idx, mem_size);
> > + ufshpb_set_read_buf_cmd(rq->cmd, map_req->rb.rgn_idx,
> > + map_req->rb.srgn_idx, mem_size);
> > rq->cmd_len = HPB_READ_BUFFER_CMD_LENGTH;
> >
> > blk_execute_rq_nowait(NULL, req, 1, ufshpb_map_req_compl_fn);
> > @@ -688,6 +1023,31 @@ static void ufshpb_purge_active_subregion(struct
> > ufshpb_lu *hpb,
> > }
> > }
> >
> > +static int ufshpb_issue_umap_req(struct ufshpb_lu *hpb,
> > + struct ufshpb_region *rgn, bool atomic)
> > +{
> > + struct ufshpb_req *umap_req;
> > + int rgn_idx = rgn ? rgn->rgn_idx : 0;
> > +
> > + umap_req = ufshpb_get_req(hpb, rgn_idx, REQ_OP_SCSI_OUT, atomic);
> > + if (!umap_req)
> > + return -ENOMEM;
> > +
> > + if (ufshpb_execute_umap_req(hpb, umap_req, rgn))
> > + goto free_umap_req;
> > +
> > + return 0;
> > +
> > +free_umap_req:
> > + ufshpb_put_req(hpb, umap_req);
> > + return -EAGAIN;
> > +}
> > +
> > +static int ufshpb_issue_umap_all_req(struct ufshpb_lu *hpb)
> > +{
> > + return ufshpb_issue_umap_req(hpb, NULL, false);
> > +}
> > +
> > static void __ufshpb_evict_region(struct ufshpb_lu *hpb,
> > struct ufshpb_region *rgn)
> > {
> > @@ -1210,6 +1570,17 @@ static void ufshpb_lu_parameter_init(struct
> > ufs_hba *hba,
> > u32 entries_per_rgn;
> > u64 rgn_mem_size, tmp;
> >
> > + /* for pre_req */
> > + hpb->pre_req_min_tr_len = hpb_dev_info->max_hpb_single_cmd + 1;
> > +
> > + if (ufshpb_is_legacy(hba))
> > + hpb->pre_req_max_tr_len = HPB_LEGACY_CHUNK_HIGH;
> > + else
> > + hpb->pre_req_max_tr_len = max(HPB_MULTI_CHUNK_HIGH,
> > + hpb->pre_req_min_tr_len);
> > +
> > + hpb->cur_read_id = 0;
> > +
> > 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)
> > @@ -1357,7 +1728,7 @@ 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[] = {
> > +static struct attribute *hpb_dev_stat_attrs[] = {
> > &dev_attr_hit_cnt.attr,
> > &dev_attr_miss_cnt.attr,
> > &dev_attr_rb_noti_cnt.attr,
> > @@ -1368,10 +1739,118 @@ static struct attribute *hpb_dev_attrs[] = {
> > };
> >
> > struct attribute_group ufs_sysfs_hpb_stat_group = {
> > - .name = "hpb_sysfs",
> > - .attrs = hpb_dev_attrs,
> > + .name = "hpb_stat_sysfs",
> > + .attrs = hpb_dev_stat_attrs,
> > };
> >
> > +/* SYSFS functions */
> > +#define ufshpb_sysfs_param_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, "%d\n", hpb->params.__name); \
> > +}
> > +
> > +ufshpb_sysfs_param_show_func(requeue_timeout_ms);
> > +static ssize_t
> > +requeue_timeout_ms_store(struct device *dev, struct device_attribute
> > *attr,
> > + const char *buf, size_t count)
> > +{
> > + struct scsi_device *sdev = to_scsi_device(dev);
> > + struct ufshpb_lu *hpb = ufshpb_get_hpb_data(sdev);
> > + int val;
> > +
> > + if (!hpb)
> > + return -ENODEV;
> > +
> > + if (kstrtouint(buf, 0, &val))
> > + return -EINVAL;
> > +
> > + if (val < 0)
> > + return -EINVAL;
> > +
> > + hpb->params.requeue_timeout_ms = val;
> > +
> > + return count;
> > +}
> > +static DEVICE_ATTR_RW(requeue_timeout_ms);
> > +
> > +static struct attribute *hpb_dev_param_attrs[] = {
> > + &dev_attr_requeue_timeout_ms.attr,
> > + NULL,
> > +};
> > +
> > +struct attribute_group ufs_sysfs_hpb_param_group = {
> > + .name = "hpb_param_sysfs",
> > + .attrs = hpb_dev_param_attrs,
> > +};
> > +
> > +static int ufshpb_pre_req_mempool_init(struct ufshpb_lu *hpb)
> > +{
> > + struct ufshpb_req *pre_req = NULL, *t;
> > + int qd = hpb->sdev_ufs_lu->queue_depth / 2;
> > + int i;
> > +
> > + INIT_LIST_HEAD(&hpb->lh_pre_req_free);
> > +
> > + hpb->pre_req = kcalloc(qd, sizeof(struct ufshpb_req), GFP_KERNEL);
> > + hpb->throttle_pre_req = qd;
> > + hpb->num_inflight_pre_req = 0;
> > +
> > + if (!hpb->pre_req)
> > + goto release_mem;
> > +
> > + for (i = 0; i < qd; i++) {
> > + pre_req = hpb->pre_req + i;
> > + INIT_LIST_HEAD(&pre_req->list_req);
> > + pre_req->req = NULL;
> > +
> > + pre_req->bio = bio_alloc(GFP_KERNEL, 1);
> > + if (!pre_req->bio)
> > + goto release_mem;
> > +
> > + pre_req->wb.m_page = alloc_page(GFP_KERNEL | __GFP_ZERO);
> > + if (!pre_req->wb.m_page) {
> > + bio_put(pre_req->bio);
> > + goto release_mem;
> > + }
> > +
> > + list_add_tail(&pre_req->list_req, &hpb->lh_pre_req_free);
> > + }
> > +
> > + return 0;
> > +release_mem:
> > + list_for_each_entry_safe(pre_req, t, &hpb->lh_pre_req_free, list_req)
> > {
> > + list_del_init(&pre_req->list_req);
> > + bio_put(pre_req->bio);
> > + __free_page(pre_req->wb.m_page);
> > + }
> > +
> > + kfree(hpb->pre_req);
> > + return -ENOMEM;
> > +}
> > +
> > +static void ufshpb_pre_req_mempool_destroy(struct ufshpb_lu *hpb)
> > +{
> > + struct ufshpb_req *pre_req = NULL;
> > + int i;
> > +
> > + for (i = 0; i < hpb->throttle_pre_req; i++) {
> > + pre_req = hpb->pre_req + i;
> > + bio_put(hpb->pre_req[i].bio);
> > + if (!pre_req->wb.m_page)
> > + __free_page(hpb->pre_req[i].wb.m_page);
> > + list_del_init(&pre_req->list_req);
> > + }
> > +
> > + kfree(hpb->pre_req);
> > +}
> > +
> > static void ufshpb_stat_init(struct ufshpb_lu *hpb)
> > {
> > hpb->stats.hit_cnt = 0;
> > @@ -1382,6 +1861,11 @@ static void ufshpb_stat_init(struct ufshpb_lu
> > *hpb)
> > hpb->stats.map_req_cnt = 0;
> > }
> >
> > +static void ufshpb_param_init(struct ufshpb_lu *hpb)
> > +{
> > + hpb->params.requeue_timeout_ms = HPB_REQUEUE_TIME_MS;
> > +}
> > +
> > static int ufshpb_lu_hpb_init(struct ufs_hba *hba, struct ufshpb_lu
> > *hpb)
> > {
> > int ret;
> > @@ -1414,14 +1898,24 @@ static int ufshpb_lu_hpb_init(struct ufs_hba
> > *hba, struct ufshpb_lu *hpb)
> > goto release_req_cache;
> > }
> >
> > + ret = ufshpb_pre_req_mempool_init(hpb);
> > + if (ret) {
> > + dev_err(hba->dev, "ufshpb(%d) pre_req_mempool init fail",
> > + hpb->lun);
> > + goto release_m_page_cache;
> > + }
> > +
> > ret = ufshpb_alloc_region_tbl(hba, hpb);
> > if (ret)
> > - goto release_m_page_cache;
> > + goto release_pre_req_mempool;
> >
> > ufshpb_stat_init(hpb);
> > + ufshpb_param_init(hpb);
> >
> > return 0;
> >
> > +release_pre_req_mempool:
> > + ufshpb_pre_req_mempool_destroy(hpb);
> > release_m_page_cache:
> > kmem_cache_destroy(hpb->m_page_cache);
> > release_req_cache:
> > @@ -1430,7 +1924,7 @@ static int ufshpb_lu_hpb_init(struct ufs_hba
> > *hba, struct ufshpb_lu *hpb)
> > }
> >
> > static struct ufshpb_lu *
> > -ufshpb_alloc_hpb_lu(struct ufs_hba *hba, int lun,
> > +ufshpb_alloc_hpb_lu(struct ufs_hba *hba, struct scsi_device *sdev,
> > struct ufshpb_dev_info *hpb_dev_info,
> > struct ufshpb_lu_info *hpb_lu_info)
> > {
> > @@ -1441,7 +1935,8 @@ ufshpb_alloc_hpb_lu(struct ufs_hba *hba, int lun,
> > if (!hpb)
> > return NULL;
> >
> > - hpb->lun = lun;
> > + hpb->lun = sdev->lun;
> > + hpb->sdev_ufs_lu = sdev;
> >
> > ufshpb_lu_parameter_init(hba, hpb, hpb_dev_info, hpb_lu_info);
> >
> > @@ -1451,6 +1946,7 @@ ufshpb_alloc_hpb_lu(struct ufs_hba *hba, int lun,
> > goto release_hpb;
> > }
> >
> > + sdev->hostdata = hpb;
> > return hpb;
> >
> > release_hpb:
> > @@ -1653,6 +2149,7 @@ void ufshpb_destroy_lu(struct ufs_hba *hba,
> > struct scsi_device *sdev)
> >
> > ufshpb_cancel_jobs(hpb);
> >
> > + ufshpb_pre_req_mempool_destroy(hpb);
> > ufshpb_destroy_region_tbl(hpb);
> >
> > kmem_cache_destroy(hpb->map_req_cache);
> > @@ -1692,6 +2189,7 @@ static void ufshpb_hpb_lu_prepared(struct ufs_hba
> > *hba)
> > ufshpb_set_state(hpb, HPB_PRESENT);
> > if ((hpb->lu_pinned_end - hpb->lu_pinned_start) > 0)
> > queue_work(ufshpb_wq, &hpb->map_work);
> > + ufshpb_issue_umap_all_req(hpb);
> > } else {
> > dev_err(hba->dev, "destroy HPB lu %d\n", hpb->lun);
> > ufshpb_destroy_lu(hba, sdev);
> > @@ -1716,7 +2214,7 @@ void ufshpb_init_hpb_lu(struct ufs_hba *hba,
> > struct scsi_device *sdev)
> > if (ret)
> > goto out;
> >
> > - hpb = ufshpb_alloc_hpb_lu(hba, lun, &hba->ufshpb_dev,
> > + hpb = ufshpb_alloc_hpb_lu(hba, sdev, &hba->ufshpb_dev,
> > &hpb_lu_info);
> > if (!hpb)
> > goto out;
> > @@ -1724,9 +2222,6 @@ void ufshpb_init_hpb_lu(struct ufs_hba *hba,
> > struct scsi_device *sdev)
> > 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;
> > -
> > out:
> > /* All LUs are initialized */
> > if (atomic_dec_and_test(&hba->ufshpb_dev.slave_conf_cnt))
> > @@ -1813,8 +2308,9 @@ void ufshpb_get_geo_info(struct ufs_hba *hba, u8
> > *geo_buf)
> > void ufshpb_get_dev_info(struct ufs_hba *hba, u8 *desc_buf)
> > {
> > struct ufshpb_dev_info *hpb_dev_info = &hba->ufshpb_dev;
> > - int version;
> > + int version, ret;
> > u8 hpb_mode;
> > + u32 max_hpb_single_cmd = HPB_MULTI_CHUNK_LOW;
> >
> > hpb_mode = desc_buf[DEVICE_DESC_PARAM_HPB_CONTROL];
> > if (hpb_mode == HPB_HOST_CONTROL) {
> > @@ -1825,13 +2321,27 @@ void ufshpb_get_dev_info(struct ufs_hba *hba,
> > u8 *desc_buf)
> > }
> >
> > version = get_unaligned_be16(desc_buf + DEVICE_DESC_PARAM_HPB_VER);
> > - if (version != HPB_SUPPORT_VERSION) {
> > + if ((version != HPB_SUPPORT_VERSION) &&
> > + (version != HPB_SUPPORT_LEGACY_VERSION)) {
> > dev_err(hba->dev, "%s: HPB %x version is not supported.\n",
> > __func__, version);
> > hpb_dev_info->hpb_disabled = true;
> > return;
> > }
> >
> > + if (version == HPB_SUPPORT_LEGACY_VERSION)
> > + hpb_dev_info->is_legacy = true;
> > +
> > + pm_runtime_get_sync(hba->dev);
> > + ret = ufshcd_query_attr_retry(hba, UPIU_QUERY_OPCODE_READ_ATTR,
> > + QUERY_ATTR_IDN_MAX_HPB_SINGLE_CMD, 0, 0, &max_hpb_single_cmd);
> > + pm_runtime_put_sync(hba->dev);
> > +
> > + if (ret)
> > + dev_err(hba->dev, "%s: idn: read max size of single hpb cmd query
> > request failed",
> > + __func__);
> > + hpb_dev_info->max_hpb_single_cmd = max_hpb_single_cmd;
> > +
> > /*
> > * Get the number of user logical unit to check whether all
> > * scsi_device finish initialization
> > diff --git a/drivers/scsi/ufs/ufshpb.h b/drivers/scsi/ufs/ufshpb.h
> > index 6e6a0252dc15..b1128b0ce486 100644
> > --- a/drivers/scsi/ufs/ufshpb.h
> > +++ b/drivers/scsi/ufs/ufshpb.h
> > @@ -30,19 +30,29 @@
> > #define PINNED_NOT_SET U32_MAX
> >
> > /* hpb support chunk size */
> > -#define HPB_MULTI_CHUNK_HIGH 1
> > +#define HPB_LEGACY_CHUNK_HIGH 1
> > +#define HPB_MULTI_CHUNK_LOW 7
> > +#define HPB_MULTI_CHUNK_HIGH 128
> >
> > /* hpb vender defined opcode */
> > #define UFSHPB_READ 0xF8
> > #define UFSHPB_READ_BUFFER 0xF9
> > #define UFSHPB_READ_BUFFER_ID 0x01
> > +#define UFSHPB_WRITE_BUFFER 0xFA
> > +#define UFSHPB_WRITE_BUFFER_INACT_SINGLE_ID 0x01
> > +#define UFSHPB_WRITE_BUFFER_PREFETCH_ID 0x02
> > +#define UFSHPB_WRITE_BUFFER_INACT_ALL_ID 0x03
> > +#define HPB_WRITE_BUFFER_CMD_LENGTH 10
> > +#define MAX_HPB_READ_ID 0x7F
> > #define HPB_READ_BUFFER_CMD_LENGTH 10
> > #define LU_ENABLED_HPB_FUNC 0x02
> >
> > #define HPB_RESET_REQ_RETRIES 10
> > #define HPB_MAP_REQ_RETRIES 5
> > +#define HPB_REQUEUE_TIME_MS 0
> >
> > -#define HPB_SUPPORT_VERSION 0x100
> > +#define HPB_SUPPORT_VERSION 0x200
> > +#define HPB_SUPPORT_LEGACY_VERSION 0x100
> >
> > enum UFSHPB_MODE {
> > HPB_HOST_CONTROL,
> > @@ -119,23 +129,38 @@ struct ufshpb_region {
> > (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
> > + * struct ufshpb_req - HPB related request structure (write/read
> > buffer)
> > + * @req: block layer request structure
> > + * @bio: bio for this request
> > + * @hpb: ufshpb_lu structure that related to
> > + * @list_req: ufshpb_req mempool list
> > + * @sense: store its sense data
> > * @mctx: L2P map information
> > * @rgn_idx: target region index
> > * @srgn_idx: target sub-region index
> > * @lun: target logical unit number
> > + * @m_page: L2P map information data for pre-request
> > + * @len: length of host-side cached L2P map in m_page
> > + * @lpn: start LPN of L2P map in m_page
> > */
> > 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 list_head list_req;
> > + union {
> > + struct {
> > + struct ufshpb_map_ctx *mctx;
> > + unsigned int rgn_idx;
> > + unsigned int srgn_idx;
> > + unsigned int lun;
> > + } rb;
> > + struct {
> > + struct page *m_page;
> > + unsigned int len;
> > + unsigned long lpn;
> > + } wb;
> > + };
> > };
> >
> > struct victim_select_info {
> > @@ -144,6 +169,10 @@ struct victim_select_info {
> > atomic_t active_cnt;
> > };
> >
> > +struct ufshpb_params {
> > + unsigned int requeue_timeout_ms;
> > +};
> > +
> > struct ufshpb_stats {
> > u64 hit_cnt;
> > u64 miss_cnt;
> > @@ -151,6 +180,7 @@ struct ufshpb_stats {
> > u64 rb_active_cnt;
> > u64 rb_inactive_cnt;
> > u64 map_req_cnt;
> > + u64 pre_req_cnt;
> > };
> >
> > struct ufshpb_lu {
> > @@ -166,6 +196,15 @@ struct ufshpb_lu {
> > struct list_head lh_act_srgn; /* hold rsp_list_lock */
> > struct list_head lh_inact_rgn; /* hold rsp_list_lock */
> >
> > + /* pre request information */
> > + struct ufshpb_req *pre_req;
> > + int num_inflight_pre_req;
> > + int throttle_pre_req;
> > + struct list_head lh_pre_req_free;
> > + int cur_read_id;
> > + int pre_req_min_tr_len;
> > + int pre_req_max_tr_len;
> > +
> > /* cached L2P map management worker */
> > struct work_struct map_work;
> >
> > @@ -190,6 +229,7 @@ struct ufshpb_lu {
> > u32 pages_per_srgn;
> >
> > struct ufshpb_stats stats;
> > + struct ufshpb_params params;
> >
> > struct kmem_cache *map_req_cache;
> > struct kmem_cache *m_page_cache;
> > @@ -201,7 +241,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 int ufshpb_prep(struct ufs_hba *hba, struct ufshcd_lrb *lrbp)
> > { return 0; }
> > 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) {}
> > @@ -214,8 +254,9 @@ 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) {}
> > +static bool ufshpb_is_legacy(struct ufs_hba *hba) { return false; }
> > #else
> > -void ufshpb_prep(struct ufs_hba *hba, struct ufshcd_lrb *lrbp);
> > +int 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);
> > @@ -228,7 +269,9 @@ 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);
> > +bool ufshpb_is_legacy(struct ufs_hba *hba);
> > extern struct attribute_group ufs_sysfs_hpb_stat_group;
> > +extern struct attribute_group ufs_sysfs_hpb_param_group;
> > #endif
> >
> > #endif /* End of Header */
>
>
>
^ permalink raw reply [flat|nested] 26+ messages in thread* Re: [PATCH v31 4/4] scsi: ufs: Add HPB 2.0 support
2021-03-25 0:47 ` Daejun Park
@ 2021-03-25 8:12 ` Can Guo
2021-03-26 2:55 ` Daejun Park
0 siblings, 1 reply; 26+ messages in thread
From: Can Guo @ 2021-03-25 8:12 UTC (permalink / raw)
To: daejun7.park
Cc: Greg KH, avri.altman, jejb, martin.petersen, asutoshd,
stanley.chu, bvanassche, huobean, linux-scsi, linux-kernel,
ALIM AKHTAR, JinHwan Park, Javier Gonzalez, Sung-Jun Park,
Jinyoung CHOI, Dukhyun Kwon, Keoseong Park, Jaemyung Lee,
Jieon Seol
On 2021-03-25 08:47, Daejun Park wrote:
>> On 2021-03-22 14:55, Daejun Park wrote:
>> > This patch supports the HPB 2.0.
>> >
>> > The HPB 2.0 supports read of varying sizes from 4KB to 512KB.
>> > In the case of Read (<= 32KB) is supported as single HPB read.
>> > In the case of Read (36KB ~ 512KB) is supported by as a combination of
>> > write buffer command and HPB read command to deliver more PPN.
>> > The write buffer commands may not be issued immediately due to busy
>> > tags.
>> > To use HPB read more aggressively, the driver can requeue the write
>> > buffer
>> > command. The requeue threshold is implemented as timeout and can be
>> > modified with requeue_timeout_ms entry in sysfs.
>> >
>> > Signed-off-by: Daejun Park <daejun7.park@samsung.com>
>> > ---
>> > Documentation/ABI/testing/sysfs-driver-ufs | 47 +-
>> > drivers/scsi/ufs/ufs-sysfs.c | 4 +
>> > drivers/scsi/ufs/ufs.h | 3 +-
>> > drivers/scsi/ufs/ufshcd.c | 25 +-
>> > drivers/scsi/ufs/ufshcd.h | 7 +
>> > drivers/scsi/ufs/ufshpb.c | 626 +++++++++++++++++++--
>> > drivers/scsi/ufs/ufshpb.h | 67 ++-
>> > 7 files changed, 698 insertions(+), 81 deletions(-)
>> >
>> > diff --git a/Documentation/ABI/testing/sysfs-driver-ufs
>> > b/Documentation/ABI/testing/sysfs-driver-ufs
>> > index 528bf89fc98b..419adf450b89 100644
>> > --- a/Documentation/ABI/testing/sysfs-driver-ufs
>> > +++ b/Documentation/ABI/testing/sysfs-driver-ufs
>> > @@ -1253,14 +1253,14 @@ Description: This entry shows the number of
>> > HPB pinned regions assigned to
>> >
>> > The file is read only.
>> >
>> > -What: /sys/class/scsi_device/*/device/hpb_sysfs/hit_cnt
>> > +What: /sys/class/scsi_device/*/device/hpb_stat_sysfs/hit_cnt
>> > Date: March 2021
>> > Contact: Daejun Park <daejun7.park@samsung.com>
>> > Description: This entry shows the number of reads that changed to HPB
>> > read.
>> >
>> > The file is read only.
>> >
>> > -What: /sys/class/scsi_device/*/device/hpb_sysfs/miss_cnt
>> > +What: /sys/class/scsi_device/*/device/hpb_stat_sysfs/miss_cnt
>> > Date: March 2021
>> > Contact: Daejun Park <daejun7.park@samsung.com>
>> > Description: This entry shows the number of reads that cannot be
>> > changed to
>> > @@ -1268,7 +1268,7 @@ Description: This entry shows the number of
>> > reads that cannot be changed to
>> >
>> > The file is read only.
>> >
>> > -What: /sys/class/scsi_device/*/device/hpb_sysfs/rb_noti_cnt
>> > +What: /sys/class/scsi_device/*/device/hpb_stat_sysfs/rb_noti_cnt
>> > Date: March 2021
>> > Contact: Daejun Park <daejun7.park@samsung.com>
>> > Description: This entry shows the number of response UPIUs that has
>> > @@ -1276,7 +1276,7 @@ Description: This entry shows the number of
>> > response UPIUs that has
>> >
>> > The file is read only.
>> >
>> > -What: /sys/class/scsi_device/*/device/hpb_sysfs/rb_active_cnt
>> > +What: /sys/class/scsi_device/*/device/hpb_stat_sysfs/rb_active_cnt
>> > Date: March 2021
>> > Contact: Daejun Park <daejun7.park@samsung.com>
>> > Description: This entry shows the number of active sub-regions
>> > recommended by
>> > @@ -1284,7 +1284,7 @@ Description: This entry shows the number of
>> > active sub-regions recommended by
>> >
>> > The file is read only.
>> >
>> > -What: /sys/class/scsi_device/*/device/hpb_sysfs/rb_inactive_cnt
>> > +What: /sys/class/scsi_device/*/device/hpb_stat_sysfs/rb_inactive_cnt
>> > Date: March 2021
>> > Contact: Daejun Park <daejun7.park@samsung.com>
>> > Description: This entry shows the number of inactive regions
>> > recommended by
>> > @@ -1292,10 +1292,45 @@ Description: This entry shows the number of
>> > inactive regions recommended by
>> >
>> > The file is read only.
>> >
>> > -What: /sys/class/scsi_device/*/device/hpb_sysfs/map_req_cnt
>> > +What: /sys/class/scsi_device/*/device/hpb_stat_sysfs/map_req_cnt
>> > Date: March 2021
>> > Contact: Daejun Park <daejun7.park@samsung.com>
>> > Description: This entry shows the number of read buffer commands for
>> > activating sub-regions recommended by response UPIUs.
>> >
>> > The file is read only.
>> > +
>> > +What: /sys/class/scsi_device/*/device/hpb_param_sysfs/requeue_timeout_ms
>> > +Date: March 2021
>> > +Contact: Daejun Park <daejun7.park@samsung.com>
>> > +Description: This entry shows the requeue timeout threshold for write
>> > buffer
>> > + command in ms. This value can be changed by writing proper integer
>> > to
>> > + this entry.
>> > +
>> > +What: /sys/bus/platform/drivers/ufshcd/*/attributes/max_data_size_hpb_single_cmd
>> > +Date: March 2021
>> > +Contact: Daejun Park <daejun7.park@samsung.com>
>> > +Description: This entry shows the maximum HPB data size for using
>> > single HPB
>> > + command.
>> > +
>> > + === ========
>> > + 00h 4KB
>> > + 01h 8KB
>> > + 02h 12KB
>> > + ...
>> > + FFh 1024KB
>> > + === ========
>> > +
>> > + The file is read only.
>> > +
>> > +What: /sys/bus/platform/drivers/ufshcd/*/flags/wb_enable
>> > +Date: March 2021
>> > +Contact: Daejun Park <daejun7.park@samsung.com>
>> > +Description: This entry shows the status of HPB.
>> > +
>> > + == ============================
>> > + 0 HPB is not enabled.
>> > + 1 HPB is enabled
>> > + == ============================
>> > +
>> > + The file is read only.
>> > diff --git a/drivers/scsi/ufs/ufs-sysfs.c
>> > b/drivers/scsi/ufs/ufs-sysfs.c
>> > index 2546e7a1ac4f..92a883866e12 100644
>> > --- a/drivers/scsi/ufs/ufs-sysfs.c
>> > +++ b/drivers/scsi/ufs/ufs-sysfs.c
>> > @@ -782,6 +782,7 @@ UFS_FLAG(disable_fw_update,
>> > _PERMANENTLY_DISABLE_FW_UPDATE);
>> > UFS_FLAG(wb_enable, _WB_EN);
>> > UFS_FLAG(wb_flush_en, _WB_BUFF_FLUSH_EN);
>> > UFS_FLAG(wb_flush_during_h8, _WB_BUFF_FLUSH_DURING_HIBERN8);
>> > +UFS_FLAG(hpb_enable, _HPB_EN);
>> >
>> > static struct attribute *ufs_sysfs_device_flags[] = {
>> > &dev_attr_device_init.attr,
>> > @@ -795,6 +796,7 @@ static struct attribute *ufs_sysfs_device_flags[] =
>> > {
>> > &dev_attr_wb_enable.attr,
>> > &dev_attr_wb_flush_en.attr,
>> > &dev_attr_wb_flush_during_h8.attr,
>> > + &dev_attr_hpb_enable.attr,
>> > NULL,
>> > };
>> >
>> > @@ -841,6 +843,7 @@ out: \
>> > static DEVICE_ATTR_RO(_name)
>> >
>> > UFS_ATTRIBUTE(boot_lun_enabled, _BOOT_LU_EN);
>> > +UFS_ATTRIBUTE(max_data_size_hpb_single_cmd, _MAX_HPB_SINGLE_CMD);
>> > UFS_ATTRIBUTE(current_power_mode, _POWER_MODE);
>> > UFS_ATTRIBUTE(active_icc_level, _ACTIVE_ICC_LVL);
>> > UFS_ATTRIBUTE(ooo_data_enabled, _OOO_DATA_EN);
>> > @@ -864,6 +867,7 @@ UFS_ATTRIBUTE(wb_cur_buf, _CURR_WB_BUFF_SIZE);
>> >
>> > static struct attribute *ufs_sysfs_attributes[] = {
>> > &dev_attr_boot_lun_enabled.attr,
>> > + &dev_attr_max_data_size_hpb_single_cmd.attr,
>> > &dev_attr_current_power_mode.attr,
>> > &dev_attr_active_icc_level.attr,
>> > &dev_attr_ooo_data_enabled.attr,
>> > diff --git a/drivers/scsi/ufs/ufs.h b/drivers/scsi/ufs/ufs.h
>> > index bfb84d2ba990..8c6b38b1b142 100644
>> > --- a/drivers/scsi/ufs/ufs.h
>> > +++ b/drivers/scsi/ufs/ufs.h
>> > @@ -123,12 +123,13 @@ enum flag_idn {
>> > QUERY_FLAG_IDN_WB_BUFF_FLUSH_EN = 0x0F,
>> > QUERY_FLAG_IDN_WB_BUFF_FLUSH_DURING_HIBERN8 = 0x10,
>> > QUERY_FLAG_IDN_HPB_RESET = 0x11,
>> > + QUERY_FLAG_IDN_HPB_EN = 0x12,
>> > };
>> >
>> > /* Attribute idn for Query requests */
>> > enum attr_idn {
>> > QUERY_ATTR_IDN_BOOT_LU_EN = 0x00,
>> > - QUERY_ATTR_IDN_RESERVED = 0x01,
>> > + QUERY_ATTR_IDN_MAX_HPB_SINGLE_CMD = 0x01,
>> > QUERY_ATTR_IDN_POWER_MODE = 0x02,
>> > QUERY_ATTR_IDN_ACTIVE_ICC_LVL = 0x03,
>> > QUERY_ATTR_IDN_OOO_DATA_EN = 0x04,
>> > diff --git a/drivers/scsi/ufs/ufshcd.c b/drivers/scsi/ufs/ufshcd.c
>> > index a7cf9278965c..1653c7a7b066 100644
>> > --- a/drivers/scsi/ufs/ufshcd.c
>> > +++ b/drivers/scsi/ufs/ufshcd.c
>> > @@ -2653,7 +2653,12 @@ static int ufshcd_queuecommand(struct Scsi_Host
>> > *host, struct scsi_cmnd *cmd)
>> >
>> > lrbp->req_abort_skip = false;
>> >
>> > - ufshpb_prep(hba, lrbp);
>> > + err = ufshpb_prep(hba, lrbp);
>> > + if (err == -EAGAIN) {
>> > + lrbp->cmd = NULL;
>> > + ufshcd_release(hba);
>> > + goto out;
>> > + }
>> >
>> > ufshcd_comp_scsi_upiu(hba, lrbp);
>> >
>> > @@ -3107,7 +3112,7 @@ int ufshcd_query_attr(struct ufs_hba *hba, enum
>> > query_opcode opcode,
>> > *
>> > * Returns 0 for success, non-zero in case of failure
>> > */
>> > -static int ufshcd_query_attr_retry(struct ufs_hba *hba,
>> > +int ufshcd_query_attr_retry(struct ufs_hba *hba,
>> > enum query_opcode opcode, enum attr_idn idn, u8 index, u8 selector,
>> > u32 *attr_val)
>> > {
>> > @@ -4862,7 +4867,8 @@ static int ufshcd_change_queue_depth(struct
>> > scsi_device *sdev, int 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))
>> > + if ((sdev->lun >= UFS_UPIU_MAX_UNIT_NUM_ID) ||
>> > + !(hba->dev_info.hpb_enabled) || !ufshpb_is_allowed(hba))
>> > return;
>> >
>> > ufshpb_destroy_lu(hba, sdev);
>> > @@ -7454,8 +7460,18 @@ static int ufs_get_device_desc(struct ufs_hba
>> > *hba)
>> >
>> > if (dev_info->wspecversion >= UFS_DEV_HPB_SUPPORT_VERSION &&
>> > (b_ufs_feature_sup & UFS_DEV_HPB_SUPPORT)) {
>> > - dev_info->hpb_enabled = true;
>> > + bool hpb_en = false;
>> > +
>> > ufshpb_get_dev_info(hba, desc_buf);
>> > +
>> > + if (!ufshpb_is_legacy(hba))
>> > + err = ufshcd_query_flag_retry(hba,
>> > + UPIU_QUERY_OPCODE_READ_FLAG,
>> > + QUERY_FLAG_IDN_HPB_EN, 0,
>> > + &hpb_en);
>> > +
>> > + if (ufshpb_is_legacy(hba) || (!err && hpb_en))
>> > + dev_info->hpb_enabled = true;
>> > }
>> >
>> > err = ufshcd_read_string_desc(hba, model_index,
>> > @@ -8028,6 +8044,7 @@ static const struct attribute_group
>> > *ufshcd_driver_groups[] = {
>> > &ufs_sysfs_lun_attributes_group,
>> > #ifdef CONFIG_SCSI_UFS_HPB
>> > &ufs_sysfs_hpb_stat_group,
>> > + &ufs_sysfs_hpb_param_group,
>> > #endif
>> > NULL,
>> > };
>> > diff --git a/drivers/scsi/ufs/ufshcd.h b/drivers/scsi/ufs/ufshcd.h
>> > index 008a5f7146c0..8aca8f327981 100644
>> > --- a/drivers/scsi/ufs/ufshcd.h
>> > +++ b/drivers/scsi/ufs/ufshcd.h
>> > @@ -654,6 +654,8 @@ struct ufs_hba_variant_params {
>> > * @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
>> > + * @max_hpb_single_cmd: maximum size of single HPB command
>> > + * @is_legacy: flag to check HPB 1.0
>> > */
>> > struct ufshpb_dev_info {
>> > int num_lu;
>> > @@ -661,6 +663,8 @@ struct ufshpb_dev_info {
>> > int srgn_size;
>> > atomic_t slave_conf_cnt;
>> > bool hpb_disabled;
>> > + int max_hpb_single_cmd;
>> > + bool is_legacy;
>> > };
>> > #endif
>> >
>> > @@ -1096,6 +1100,9 @@ int ufshcd_read_desc_param(struct ufs_hba *hba,
>> > u8 param_offset,
>> > u8 *param_read_buf,
>> > u8 param_size);
>> > +int ufshcd_query_attr_retry(struct ufs_hba *hba, enum query_opcode
>> > opcode,
>> > + enum attr_idn idn, u8 index, u8 selector,
>> > + u32 *attr_val);
>> > int ufshcd_query_attr(struct ufs_hba *hba, enum query_opcode opcode,
>> > enum attr_idn idn, u8 index, u8 selector, u32 *attr_val);
>> > int ufshcd_query_flag(struct ufs_hba *hba, enum query_opcode opcode,
>> > diff --git a/drivers/scsi/ufs/ufshpb.c b/drivers/scsi/ufs/ufshpb.c
>> > index f789339f68d9..3ac8b0a9e8d3 100644
>> > --- a/drivers/scsi/ufs/ufshpb.c
>> > +++ b/drivers/scsi/ufs/ufshpb.c
>> > @@ -31,6 +31,11 @@ bool ufshpb_is_allowed(struct ufs_hba *hba)
>> > return !(hba->ufshpb_dev.hpb_disabled);
>> > }
>> >
>> > +bool ufshpb_is_legacy(struct ufs_hba *hba)
>> > +{
>> > + return hba->ufshpb_dev.is_legacy;
>> > +}
>> > +
>> > static struct ufshpb_lu *ufshpb_get_hpb_data(struct scsi_device *sdev)
>> > {
>> > return sdev->hostdata;
>> > @@ -64,9 +69,19 @@ static bool ufshpb_is_write_or_discard_cmd(struct
>> > scsi_cmnd *cmd)
>> > op_is_discard(req_op(cmd->request));
>> > }
>> >
>> > -static bool ufshpb_is_support_chunk(int transfer_len)
>> > +static bool ufshpb_is_support_chunk(struct ufshpb_lu *hpb, int
>> > transfer_len)
>> > {
>> > - return transfer_len <= HPB_MULTI_CHUNK_HIGH;
>> > + return transfer_len <= hpb->pre_req_max_tr_len;
>> > +}
>> > +
>> > +/*
>> > + * In this driver, WRITE_BUFFER CMD support 36KB (len=9) ~ 512KB
>> > (len=128) as
>> > + * default. It is possible to change range of transfer_len through
>> > sysfs.
>> > + */
>> > +static inline bool ufshpb_is_required_wb(struct ufshpb_lu *hpb, int
>> > len)
>> > +{
>> > + return (len > hpb->pre_req_min_tr_len &&
>> > + len <= hpb->pre_req_max_tr_len);
>> > }
>> >
>> > static bool ufshpb_is_general_lun(int lun)
>> > @@ -74,8 +89,7 @@ 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)
>> > +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 &&
>> > @@ -264,7 +278,8 @@ ufshpb_get_pos_from_lpn(struct ufshpb_lu *hpb,
>> > unsigned long lpn, int *rgn_idx,
>> >
>> > static void
>> > ufshpb_set_hpb_read_to_upiu(struct ufshpb_lu *hpb, struct ufshcd_lrb
>> > *lrbp,
>> > - u32 lpn, u64 ppn, unsigned int transfer_len)
>> > + u32 lpn, u64 ppn, unsigned int transfer_len,
>> > + int read_id)
>> > {
>> > unsigned char *cdb = lrbp->cmd->cmnd;
>> >
>> > @@ -273,15 +288,261 @@ ufshpb_set_hpb_read_to_upiu(struct ufshpb_lu
>> > *hpb, struct ufshcd_lrb *lrbp,
>> > /* ppn value is stored as big-endian in the host memory */
>> > memcpy(&cdb[6], &ppn, sizeof(u64));
>> > cdb[14] = transfer_len;
>> > + cdb[15] = read_id;
>> >
>> > lrbp->cmd->cmd_len = UFS_CDB_SIZE;
>> > }
>> >
>> > +static inline void ufshpb_set_write_buf_cmd(unsigned char *cdb,
>> > + unsigned long lpn, unsigned int len,
>> > + int read_id)
>> > +{
>> > + cdb[0] = UFSHPB_WRITE_BUFFER;
>> > + cdb[1] = UFSHPB_WRITE_BUFFER_PREFETCH_ID;
>> > +
>> > + put_unaligned_be32(lpn, &cdb[2]);
>> > + cdb[6] = read_id;
>> > + put_unaligned_be16(len * HPB_ENTRY_SIZE, &cdb[7]);
>> > +
>> > + cdb[9] = 0x00; /* Control = 0x00 */
>> > +}
>> > +
>> > +static struct ufshpb_req *ufshpb_get_pre_req(struct ufshpb_lu *hpb)
>> > +{
>> > + struct ufshpb_req *pre_req;
>> > +
>> > + if (hpb->num_inflight_pre_req >= hpb->throttle_pre_req) {
>> > + dev_info(&hpb->sdev_ufs_lu->sdev_dev,
>> > + "pre_req throttle. inflight %d throttle %d",
>> > + hpb->num_inflight_pre_req, hpb->throttle_pre_req);
>> > + return NULL;
>> > + }
>> > +
>> > + pre_req = list_first_entry_or_null(&hpb->lh_pre_req_free,
>> > + struct ufshpb_req, list_req);
>> > + if (!pre_req) {
>> > + dev_info(&hpb->sdev_ufs_lu->sdev_dev, "There is no pre_req");
>> > + return NULL;
>> > + }
>> > +
>> > + list_del_init(&pre_req->list_req);
>> > + hpb->num_inflight_pre_req++;
>> > +
>> > + return pre_req;
>> > +}
>> > +
>> > +static inline void ufshpb_put_pre_req(struct ufshpb_lu *hpb,
>> > + struct ufshpb_req *pre_req)
>> > +{
>> > + pre_req->req = NULL;
>> > + bio_reset(pre_req->bio);
>> > + list_add_tail(&pre_req->list_req, &hpb->lh_pre_req_free);
>> > + hpb->num_inflight_pre_req--;
>> > +}
>> > +
>> > +static void ufshpb_pre_req_compl_fn(struct request *req, blk_status_t
>> > error)
>> > +{
>> > + struct ufshpb_req *pre_req = (struct ufshpb_req *)req->end_io_data;
>> > + struct ufshpb_lu *hpb = pre_req->hpb;
>> > + unsigned long flags;
>> > +
>> > + if (error) {
>> > + struct scsi_request *rq = scsi_req(req);
>> > + struct scsi_sense_hdr sshdr;
>> > +
>> > + dev_err(&hpb->sdev_ufs_lu->sdev_dev, "block status %d", error);
>> > + scsi_normalize_sense(rq->sense, SCSI_SENSE_BUFFERSIZE,
>> > + &sshdr);
>> > + dev_err(&hpb->sdev_ufs_lu->sdev_dev,
>> > + "code %x sense_key %x asc %x ascq %x",
>> > + sshdr.response_code,
>> > + sshdr.sense_key, sshdr.asc, sshdr.ascq);
>> > + dev_err(&hpb->sdev_ufs_lu->sdev_dev,
>> > + "byte4 %x byte5 %x byte6 %x additional_len %x",
>> > + sshdr.byte4, sshdr.byte5,
>> > + sshdr.byte6, sshdr.additional_length);
>> > + }
>> > +
>> > + blk_mq_free_request(req);
>> > + spin_lock_irqsave(&hpb->rgn_state_lock, flags);
>> > + ufshpb_put_pre_req(pre_req->hpb, pre_req);
>> > + spin_unlock_irqrestore(&hpb->rgn_state_lock, flags);
>> > +}
>> > +
>> > +static int ufshpb_prep_entry(struct ufshpb_req *pre_req, struct page
>> > *page)
>> > +{
>> > + struct ufshpb_lu *hpb = pre_req->hpb;
>> > + struct ufshpb_region *rgn;
>> > + struct ufshpb_subregion *srgn;
>> > + u64 *addr;
>> > + int offset = 0;
>> > + int copied;
>> > + unsigned long lpn = pre_req->wb.lpn;
>> > + int rgn_idx, srgn_idx, srgn_offset;
>> > + unsigned long flags;
>> > +
>> > + addr = page_address(page);
>> > + ufshpb_get_pos_from_lpn(hpb, lpn, &rgn_idx, &srgn_idx, &srgn_offset);
>> > +
>> > + spin_lock_irqsave(&hpb->rgn_state_lock, flags);
>> > +
>> > +next_offset:
>> > + rgn = hpb->rgn_tbl + rgn_idx;
>> > + srgn = rgn->srgn_tbl + srgn_idx;
>> > +
>> > + if (!ufshpb_is_valid_srgn(rgn, srgn))
>> > + goto mctx_error;
>> > +
>> > + if (!srgn->mctx)
>> > + goto mctx_error;
>> > +
>> > + copied = ufshpb_fill_ppn_from_page(hpb, srgn->mctx, srgn_offset,
>> > + pre_req->wb.len - offset,
>> > + &addr[offset]);
>> > +
>> > + if (copied < 0)
>> > + goto mctx_error;
>> > +
>> > + offset += copied;
>> > + srgn_offset += copied;
>> > +
>> > + if (srgn_offset == hpb->entries_per_srgn) {
>> > + srgn_offset = 0;
>> > +
>> > + if (++srgn_idx == hpb->srgns_per_rgn) {
>> > + srgn_idx = 0;
>> > + rgn_idx++;
>> > + }
>> > + }
>> > +
>> > + if (offset < pre_req->wb.len)
>> > + goto next_offset;
>> > +
>> > + spin_unlock_irqrestore(&hpb->rgn_state_lock, flags);
>> > + return 0;
>> > +mctx_error:
>> > + spin_unlock_irqrestore(&hpb->rgn_state_lock, flags);
>> > + return -ENOMEM;
>> > +}
>> > +
>> > +static int ufshpb_pre_req_add_bio_page(struct ufshpb_lu *hpb,
>> > + struct request_queue *q,
>> > + struct ufshpb_req *pre_req)
>> > +{
>> > + struct page *page = pre_req->wb.m_page;
>> > + struct bio *bio = pre_req->bio;
>> > + int entries_bytes, ret;
>> > +
>> > + if (!page)
>> > + return -ENOMEM;
>> > +
>> > + if (ufshpb_prep_entry(pre_req, page))
>> > + return -ENOMEM;
>> > +
>> > + entries_bytes = pre_req->wb.len * sizeof(u64);
>> > +
>> > + ret = bio_add_pc_page(q, bio, page, entries_bytes, 0);
>> > + if (ret != entries_bytes) {
>> > + dev_err(&hpb->sdev_ufs_lu->sdev_dev,
>> > + "bio_add_pc_page fail: %d", ret);
>> > + return -ENOMEM;
>> > + }
>> > + return 0;
>> > +}
>> > +
>> > +static inline int ufshpb_get_read_id(struct ufshpb_lu *hpb)
>> > +{
>> > + if (++hpb->cur_read_id >= MAX_HPB_READ_ID)
>> > + hpb->cur_read_id = 1;
>> > + return hpb->cur_read_id;
>> > +}
>> > +
>> > +static int ufshpb_execute_pre_req(struct ufshpb_lu *hpb, struct
>> > scsi_cmnd *cmd,
>> > + struct ufshpb_req *pre_req, int read_id)
>> > +{
>> > + struct scsi_device *sdev = cmd->device;
>> > + struct request_queue *q = sdev->request_queue;
>> > + struct request *req;
>> > + struct scsi_request *rq;
>> > + struct bio *bio = pre_req->bio;
>> > +
>> > + pre_req->hpb = hpb;
>> > + pre_req->wb.lpn = sectors_to_logical(cmd->device,
>> > + blk_rq_pos(cmd->request));
>> > + pre_req->wb.len = sectors_to_logical(cmd->device,
>> > + blk_rq_sectors(cmd->request));
>> > + if (ufshpb_pre_req_add_bio_page(hpb, q, pre_req))
>> > + return -ENOMEM;
>> > +
>> > + req = pre_req->req;
>> > +
>> > + /* 1. request setup */
>> > + blk_rq_append_bio(req, &bio);
>> > + req->rq_disk = NULL;
>> > + req->end_io_data = (void *)pre_req;
>> > + req->end_io = ufshpb_pre_req_compl_fn;
>> > +
>> > + /* 2. scsi_request setup */
>> > + rq = scsi_req(req);
>> > + rq->retries = 1;
>> > +
>> > + ufshpb_set_write_buf_cmd(rq->cmd, pre_req->wb.lpn, pre_req->wb.len,
>> > + read_id);
>> > + rq->cmd_len = scsi_command_size(rq->cmd);
>> > +
>> > + if (blk_insert_cloned_request(q, req) != BLK_STS_OK)
>> > + return -EAGAIN;
>> > +
>> > + hpb->stats.pre_req_cnt++;
>> > +
>> > + return 0;
>> > +}
>> > +
>> > +static int ufshpb_issue_pre_req(struct ufshpb_lu *hpb, struct
>> > scsi_cmnd *cmd,
>> > + int *read_id)
>> > +{
>> > + struct ufshpb_req *pre_req;
>> > + struct request *req = NULL;
>> > + unsigned long flags;
>> > + int _read_id;
>> > + int ret = 0;
>> > +
>> > + req = blk_get_request(cmd->device->request_queue,
>> > + REQ_OP_SCSI_OUT | REQ_SYNC, BLK_MQ_REQ_NOWAIT);
>> > + if (IS_ERR(req))
>> > + return -EAGAIN;
>> > +
>> > + spin_lock_irqsave(&hpb->rgn_state_lock, flags);
>> > + pre_req = ufshpb_get_pre_req(hpb);
>> > + if (!pre_req) {
>> > + ret = -EAGAIN;
>> > + goto unlock_out;
>> > + }
>> > + _read_id = ufshpb_get_read_id(hpb);
>> > + spin_unlock_irqrestore(&hpb->rgn_state_lock, flags);
>> > +
>> > + pre_req->req = req;
>> > +
>> > + ret = ufshpb_execute_pre_req(hpb, cmd, pre_req, _read_id);
>> > + if (ret)
>> > + goto free_pre_req;
>> > +
>> > + *read_id = _read_id;
>> > +
>> > + return ret;
>> > +free_pre_req:
>> > + spin_lock_irqsave(&hpb->rgn_state_lock, flags);
>> > + ufshpb_put_pre_req(hpb, pre_req);
>> > +unlock_out:
>> > + spin_unlock_irqrestore(&hpb->rgn_state_lock, flags);
>> > + blk_put_request(req);
>> > + return ret;
>> > +}
>> > +
>> > /*
>> > * 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)
>> > +int ufshpb_prep(struct ufs_hba *hba, struct ufshcd_lrb *lrbp)
>> > {
>> > struct ufshpb_lu *hpb;
>> > struct ufshpb_region *rgn;
>> > @@ -291,19 +552,20 @@ void ufshpb_prep(struct ufs_hba *hba, struct
>> > ufshcd_lrb *lrbp)
>> > u64 ppn;
>> > unsigned long flags;
>> > int transfer_len, rgn_idx, srgn_idx, srgn_offset;
>> > + int read_id = 0;
>> > int err = 0;
>> >
>> > hpb = ufshpb_get_hpb_data(cmd->device);
>> > if (!hpb)
>> > - return;
>> > + return -ENODEV;
>> >
>> > if (ufshpb_get_state(hpb) == HPB_INIT)
>> > - return;
>> > + return -ENODEV;
>> >
>> > if (ufshpb_get_state(hpb) != HPB_PRESENT) {
>> > dev_notice(&hpb->sdev_ufs_lu->sdev_dev,
>> > "%s: ufshpb state is not PRESENT", __func__);
>> > - return;
>> > + return -ENODEV;
>> > }
>> >
>> > if (blk_rq_is_scsi(cmd->request) ||
>> > @@ -314,7 +576,7 @@ void ufshpb_prep(struct ufs_hba *hba, struct
>> > ufshcd_lrb *lrbp)
>> > transfer_len = sectors_to_logical(cmd->device,
>> > blk_rq_sectors(cmd->request));
>> > if (unlikely(!transfer_len))
>> > - return;
>> > + return 0;
>> >
>> > lpn = sectors_to_logical(cmd->device, blk_rq_pos(cmd->request));
>> > ufshpb_get_pos_from_lpn(hpb, lpn, &rgn_idx, &srgn_idx, &srgn_offset);
>> > @@ -327,18 +589,18 @@ void ufshpb_prep(struct ufs_hba *hba, struct
>> > ufshcd_lrb *lrbp)
>> > ufshpb_set_ppn_dirty(hpb, rgn_idx, srgn_idx, srgn_offset,
>> > transfer_len);
>> > spin_unlock_irqrestore(&hpb->rgn_state_lock, flags);
>> > - return;
>> > + return 0;
>> > }
>> >
>> > - if (!ufshpb_is_support_chunk(transfer_len))
>> > - return;
>> > + if (!ufshpb_is_support_chunk(hpb, transfer_len))
>> > + return 0;
>> >
>> > 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;
>> > + return 0;
>> > }
>> >
>> > err = ufshpb_fill_ppn_from_page(hpb, srgn->mctx, srgn_offset, 1,
>> > &ppn);
>> > @@ -351,64 +613,101 @@ void ufshpb_prep(struct ufs_hba *hba, struct
>> > ufshcd_lrb *lrbp)
>> > * active state.
>> > */
>> > dev_err(hba->dev, "get ppn failed. err %d\n", err);
>> > - return;
>> > + return err;
>> > + }
>> > + if (!ufshpb_is_legacy(hba) &&
>> > + ufshpb_is_required_wb(hpb, transfer_len)) {
>> > + err = ufshpb_issue_pre_req(hpb, cmd, &read_id);
>> > + if (err) {
>> > + unsigned long timeout;
>> > +
>> > + timeout = cmd->jiffies_at_alloc + msecs_to_jiffies(
>> > + hpb->params.requeue_timeout_ms);
>> > +
>> > + if (time_before(jiffies, timeout))
>> > + return -EAGAIN;
>> > +
>> > + hpb->stats.miss_cnt++;
>> > + return 0;
>> > + }
>> > }
>> >
>> > - ufshpb_set_hpb_read_to_upiu(hpb, lrbp, lpn, ppn, transfer_len);
>> > + ufshpb_set_hpb_read_to_upiu(hpb, lrbp, lpn, ppn, transfer_len,
>> > read_id);
>> >
>> > hpb->stats.hit_cnt++;
>> > + return 0;
>> > }
>> > -static struct ufshpb_req *ufshpb_get_map_req(struct ufshpb_lu *hpb,
>> > - struct ufshpb_subregion *srgn)
>> > +
>> > +static struct ufshpb_req *ufshpb_get_req(struct ufshpb_lu *hpb,
>> > + int rgn_idx, enum req_opf dir,
>> > + bool atomic)
>>
>> You didn't mention this change in cover letter. And I don't see anyone
>> is passing "atomic" as true, neither in your patches nor Avri's V6
>> series
>> (from ufshpb_issue_umap_single_req()). If no one is using the flag,
>> then
>> this is dead code. If Avri needs this flag, he can add it in host
>> control
>> mode patches. Do I miss anything?
>
> I thought Avri will use this flag under atomic section. There is no
> spin_lock on ufshpb_issue_umap_single_req in the Avri's V6 series, so I
> will delete it.
>
> Thanks,
> Daejun
>
Please address it in next version. After that, I will give my
reviewed-by tag.
Thanks,
Can Guo.
>>
>> Thanks,
>> Can Guo.
>>
>> > {
>> > - struct ufshpb_req *map_req;
>> > + struct ufshpb_req *rq;
>> > struct request *req;
>> > - struct bio *bio;
>> > int retries = HPB_MAP_REQ_RETRIES;
>> >
>> > - map_req = kmem_cache_alloc(hpb->map_req_cache, GFP_KERNEL);
>> > - if (!map_req)
>> > + rq = kmem_cache_alloc(hpb->map_req_cache, GFP_ATOMIC);
>> > + if (!rq)
>> > return NULL;
>> >
>> > retry:
>> > - req = blk_get_request(hpb->sdev_ufs_lu->request_queue,
>> > - REQ_OP_SCSI_IN, BLK_MQ_REQ_NOWAIT);
>> > + req = blk_get_request(hpb->sdev_ufs_lu->request_queue, dir,
>> > + BLK_MQ_REQ_NOWAIT);
>> >
>> > - if ((PTR_ERR(req) == -EWOULDBLOCK) && (--retries > 0)) {
>> > + if (!atomic && (PTR_ERR(req) == -EWOULDBLOCK) && (--retries > 0)) {
>> > usleep_range(3000, 3100);
>> > goto retry;
>> > }
>> >
>> > if (IS_ERR(req))
>> > - goto free_map_req;
>> > + goto free_rq;
>> > +
>> > + rq->hpb = hpb;
>> > + rq->req = req;
>> > + rq->rb.rgn_idx = rgn_idx;
>> > +
>> > + return rq;
>> > +
>> > +free_rq:
>> > + kmem_cache_free(hpb->map_req_cache, rq);
>> > + return NULL;
>> > +}
>> > +
>> > +static void ufshpb_put_req(struct ufshpb_lu *hpb, struct ufshpb_req
>> > *rq)
>> > +{
>> > + blk_put_request(rq->req);
>> > + kmem_cache_free(hpb->map_req_cache, rq);
>> > +}
>> > +
>> > +static struct ufshpb_req *ufshpb_get_map_req(struct ufshpb_lu *hpb,
>> > + struct ufshpb_subregion *srgn)
>> > +{
>> > + struct ufshpb_req *map_req;
>> > + struct bio *bio;
>> > +
>> > + map_req = ufshpb_get_req(hpb, srgn->rgn_idx, REQ_OP_SCSI_IN, false);
>> > + if (!map_req)
>> > + return NULL;
>> >
>> > bio = bio_alloc(GFP_KERNEL, hpb->pages_per_srgn);
>> > if (!bio) {
>> > - blk_put_request(req);
>> > - goto free_map_req;
>> > + ufshpb_put_req(hpb, map_req);
>> > + return NULL;
>> > }
>> >
>> > - 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->rb.srgn_idx = srgn->srgn_idx;
>> > + map_req->rb.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);
>> > + ufshpb_put_req(hpb, map_req);
>> > }
>> >
>> > static int ufshpb_clear_dirty_bitmap(struct ufshpb_lu *hpb,
>> > @@ -491,6 +790,13 @@ static void ufshpb_activate_subregion(struct
>> > ufshpb_lu *hpb,
>> > srgn->srgn_state = HPB_SRGN_VALID;
>> > }
>> >
>> > +static void ufshpb_umap_req_compl_fn(struct request *req, blk_status_t
>> > error)
>> > +{
>> > + struct ufshpb_req *umap_req = (struct ufshpb_req *)req->end_io_data;
>> > +
>> > + ufshpb_put_req(umap_req->hpb, umap_req);
>> > +}
>> > +
>> > 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;
>> > @@ -498,8 +804,8 @@ static void ufshpb_map_req_compl_fn(struct request
>> > *req, blk_status_t error)
>> > struct ufshpb_subregion *srgn;
>> > unsigned long flags;
>> >
>> > - srgn = hpb->rgn_tbl[map_req->rgn_idx].srgn_tbl +
>> > - map_req->srgn_idx;
>> > + srgn = hpb->rgn_tbl[map_req->rb.rgn_idx].srgn_tbl +
>> > + map_req->rb.srgn_idx;
>> >
>> > ufshpb_clear_dirty_bitmap(hpb, srgn);
>> > spin_lock_irqsave(&hpb->rgn_state_lock, flags);
>> > @@ -509,6 +815,16 @@ static void ufshpb_map_req_compl_fn(struct
>> > request *req, blk_status_t error)
>> > ufshpb_put_map_req(map_req->hpb, map_req);
>> > }
>> >
>> > +static void ufshpb_set_unmap_cmd(unsigned char *cdb, struct
>> > ufshpb_region *rgn)
>> > +{
>> > + cdb[0] = UFSHPB_WRITE_BUFFER;
>> > + cdb[1] = rgn ? UFSHPB_WRITE_BUFFER_INACT_SINGLE_ID :
>> > + UFSHPB_WRITE_BUFFER_INACT_ALL_ID;
>> > + if (rgn)
>> > + put_unaligned_be16(rgn->rgn_idx, &cdb[2]);
>> > + cdb[9] = 0x00;
>> > +}
>> > +
>> > static void ufshpb_set_read_buf_cmd(unsigned char *cdb, int rgn_idx,
>> > int srgn_idx, int srgn_mem_size)
>> > {
>> > @@ -522,6 +838,25 @@ static void ufshpb_set_read_buf_cmd(unsigned char
>> > *cdb, int rgn_idx,
>> > cdb[9] = 0x00;
>> > }
>> >
>> > +static int ufshpb_execute_umap_req(struct ufshpb_lu *hpb,
>> > + struct ufshpb_req *umap_req,
>> > + struct ufshpb_region *rgn)
>> > +{
>> > + struct request *req;
>> > + struct scsi_request *rq;
>> > +
>> > + req = umap_req->req;
>> > + req->timeout = 0;
>> > + req->end_io_data = (void *)umap_req;
>> > + rq = scsi_req(req);
>> > + ufshpb_set_unmap_cmd(rq->cmd, rgn);
>> > + rq->cmd_len = HPB_WRITE_BUFFER_CMD_LENGTH;
>> > +
>> > + blk_execute_rq_nowait(NULL, req, 1, ufshpb_umap_req_compl_fn);
>> > +
>> > + return 0;
>> > +}
>> > +
>> > static int ufshpb_execute_map_req(struct ufshpb_lu *hpb,
>> > struct ufshpb_req *map_req, bool last)
>> > {
>> > @@ -534,12 +869,12 @@ static int ufshpb_execute_map_req(struct
>> > ufshpb_lu *hpb,
>> >
>> > 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],
>> > + ret = bio_add_pc_page(q, map_req->bio, map_req->rb.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);
>> > + map_req->rb.rgn_idx, map_req->rb.srgn_idx);
>> > return ret;
>> > }
>> > }
>> > @@ -555,8 +890,8 @@ static int ufshpb_execute_map_req(struct ufshpb_lu
>> > *hpb,
>> > if (unlikely(last))
>> > mem_size = hpb->last_srgn_entries * HPB_ENTRY_SIZE;
>> >
>> > - ufshpb_set_read_buf_cmd(rq->cmd, map_req->rgn_idx,
>> > - map_req->srgn_idx, mem_size);
>> > + ufshpb_set_read_buf_cmd(rq->cmd, map_req->rb.rgn_idx,
>> > + map_req->rb.srgn_idx, mem_size);
>> > rq->cmd_len = HPB_READ_BUFFER_CMD_LENGTH;
>> >
>> > blk_execute_rq_nowait(NULL, req, 1, ufshpb_map_req_compl_fn);
>> > @@ -688,6 +1023,31 @@ static void ufshpb_purge_active_subregion(struct
>> > ufshpb_lu *hpb,
>> > }
>> > }
>> >
>> > +static int ufshpb_issue_umap_req(struct ufshpb_lu *hpb,
>> > + struct ufshpb_region *rgn, bool atomic)
>> > +{
>> > + struct ufshpb_req *umap_req;
>> > + int rgn_idx = rgn ? rgn->rgn_idx : 0;
>> > +
>> > + umap_req = ufshpb_get_req(hpb, rgn_idx, REQ_OP_SCSI_OUT, atomic);
>> > + if (!umap_req)
>> > + return -ENOMEM;
>> > +
>> > + if (ufshpb_execute_umap_req(hpb, umap_req, rgn))
>> > + goto free_umap_req;
>> > +
>> > + return 0;
>> > +
>> > +free_umap_req:
>> > + ufshpb_put_req(hpb, umap_req);
>> > + return -EAGAIN;
>> > +}
>> > +
>> > +static int ufshpb_issue_umap_all_req(struct ufshpb_lu *hpb)
>> > +{
>> > + return ufshpb_issue_umap_req(hpb, NULL, false);
>> > +}
>> > +
>> > static void __ufshpb_evict_region(struct ufshpb_lu *hpb,
>> > struct ufshpb_region *rgn)
>> > {
>> > @@ -1210,6 +1570,17 @@ static void ufshpb_lu_parameter_init(struct
>> > ufs_hba *hba,
>> > u32 entries_per_rgn;
>> > u64 rgn_mem_size, tmp;
>> >
>> > + /* for pre_req */
>> > + hpb->pre_req_min_tr_len = hpb_dev_info->max_hpb_single_cmd + 1;
>> > +
>> > + if (ufshpb_is_legacy(hba))
>> > + hpb->pre_req_max_tr_len = HPB_LEGACY_CHUNK_HIGH;
>> > + else
>> > + hpb->pre_req_max_tr_len = max(HPB_MULTI_CHUNK_HIGH,
>> > + hpb->pre_req_min_tr_len);
>> > +
>> > + hpb->cur_read_id = 0;
>> > +
>> > 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)
>> > @@ -1357,7 +1728,7 @@ 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[] = {
>> > +static struct attribute *hpb_dev_stat_attrs[] = {
>> > &dev_attr_hit_cnt.attr,
>> > &dev_attr_miss_cnt.attr,
>> > &dev_attr_rb_noti_cnt.attr,
>> > @@ -1368,10 +1739,118 @@ static struct attribute *hpb_dev_attrs[] = {
>> > };
>> >
>> > struct attribute_group ufs_sysfs_hpb_stat_group = {
>> > - .name = "hpb_sysfs",
>> > - .attrs = hpb_dev_attrs,
>> > + .name = "hpb_stat_sysfs",
>> > + .attrs = hpb_dev_stat_attrs,
>> > };
>> >
>> > +/* SYSFS functions */
>> > +#define ufshpb_sysfs_param_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, "%d\n", hpb->params.__name); \
>> > +}
>> > +
>> > +ufshpb_sysfs_param_show_func(requeue_timeout_ms);
>> > +static ssize_t
>> > +requeue_timeout_ms_store(struct device *dev, struct device_attribute
>> > *attr,
>> > + const char *buf, size_t count)
>> > +{
>> > + struct scsi_device *sdev = to_scsi_device(dev);
>> > + struct ufshpb_lu *hpb = ufshpb_get_hpb_data(sdev);
>> > + int val;
>> > +
>> > + if (!hpb)
>> > + return -ENODEV;
>> > +
>> > + if (kstrtouint(buf, 0, &val))
>> > + return -EINVAL;
>> > +
>> > + if (val < 0)
>> > + return -EINVAL;
>> > +
>> > + hpb->params.requeue_timeout_ms = val;
>> > +
>> > + return count;
>> > +}
>> > +static DEVICE_ATTR_RW(requeue_timeout_ms);
>> > +
>> > +static struct attribute *hpb_dev_param_attrs[] = {
>> > + &dev_attr_requeue_timeout_ms.attr,
>> > + NULL,
>> > +};
>> > +
>> > +struct attribute_group ufs_sysfs_hpb_param_group = {
>> > + .name = "hpb_param_sysfs",
>> > + .attrs = hpb_dev_param_attrs,
>> > +};
>> > +
>> > +static int ufshpb_pre_req_mempool_init(struct ufshpb_lu *hpb)
>> > +{
>> > + struct ufshpb_req *pre_req = NULL, *t;
>> > + int qd = hpb->sdev_ufs_lu->queue_depth / 2;
>> > + int i;
>> > +
>> > + INIT_LIST_HEAD(&hpb->lh_pre_req_free);
>> > +
>> > + hpb->pre_req = kcalloc(qd, sizeof(struct ufshpb_req), GFP_KERNEL);
>> > + hpb->throttle_pre_req = qd;
>> > + hpb->num_inflight_pre_req = 0;
>> > +
>> > + if (!hpb->pre_req)
>> > + goto release_mem;
>> > +
>> > + for (i = 0; i < qd; i++) {
>> > + pre_req = hpb->pre_req + i;
>> > + INIT_LIST_HEAD(&pre_req->list_req);
>> > + pre_req->req = NULL;
>> > +
>> > + pre_req->bio = bio_alloc(GFP_KERNEL, 1);
>> > + if (!pre_req->bio)
>> > + goto release_mem;
>> > +
>> > + pre_req->wb.m_page = alloc_page(GFP_KERNEL | __GFP_ZERO);
>> > + if (!pre_req->wb.m_page) {
>> > + bio_put(pre_req->bio);
>> > + goto release_mem;
>> > + }
>> > +
>> > + list_add_tail(&pre_req->list_req, &hpb->lh_pre_req_free);
>> > + }
>> > +
>> > + return 0;
>> > +release_mem:
>> > + list_for_each_entry_safe(pre_req, t, &hpb->lh_pre_req_free, list_req)
>> > {
>> > + list_del_init(&pre_req->list_req);
>> > + bio_put(pre_req->bio);
>> > + __free_page(pre_req->wb.m_page);
>> > + }
>> > +
>> > + kfree(hpb->pre_req);
>> > + return -ENOMEM;
>> > +}
>> > +
>> > +static void ufshpb_pre_req_mempool_destroy(struct ufshpb_lu *hpb)
>> > +{
>> > + struct ufshpb_req *pre_req = NULL;
>> > + int i;
>> > +
>> > + for (i = 0; i < hpb->throttle_pre_req; i++) {
>> > + pre_req = hpb->pre_req + i;
>> > + bio_put(hpb->pre_req[i].bio);
>> > + if (!pre_req->wb.m_page)
>> > + __free_page(hpb->pre_req[i].wb.m_page);
>> > + list_del_init(&pre_req->list_req);
>> > + }
>> > +
>> > + kfree(hpb->pre_req);
>> > +}
>> > +
>> > static void ufshpb_stat_init(struct ufshpb_lu *hpb)
>> > {
>> > hpb->stats.hit_cnt = 0;
>> > @@ -1382,6 +1861,11 @@ static void ufshpb_stat_init(struct ufshpb_lu
>> > *hpb)
>> > hpb->stats.map_req_cnt = 0;
>> > }
>> >
>> > +static void ufshpb_param_init(struct ufshpb_lu *hpb)
>> > +{
>> > + hpb->params.requeue_timeout_ms = HPB_REQUEUE_TIME_MS;
>> > +}
>> > +
>> > static int ufshpb_lu_hpb_init(struct ufs_hba *hba, struct ufshpb_lu
>> > *hpb)
>> > {
>> > int ret;
>> > @@ -1414,14 +1898,24 @@ static int ufshpb_lu_hpb_init(struct ufs_hba
>> > *hba, struct ufshpb_lu *hpb)
>> > goto release_req_cache;
>> > }
>> >
>> > + ret = ufshpb_pre_req_mempool_init(hpb);
>> > + if (ret) {
>> > + dev_err(hba->dev, "ufshpb(%d) pre_req_mempool init fail",
>> > + hpb->lun);
>> > + goto release_m_page_cache;
>> > + }
>> > +
>> > ret = ufshpb_alloc_region_tbl(hba, hpb);
>> > if (ret)
>> > - goto release_m_page_cache;
>> > + goto release_pre_req_mempool;
>> >
>> > ufshpb_stat_init(hpb);
>> > + ufshpb_param_init(hpb);
>> >
>> > return 0;
>> >
>> > +release_pre_req_mempool:
>> > + ufshpb_pre_req_mempool_destroy(hpb);
>> > release_m_page_cache:
>> > kmem_cache_destroy(hpb->m_page_cache);
>> > release_req_cache:
>> > @@ -1430,7 +1924,7 @@ static int ufshpb_lu_hpb_init(struct ufs_hba
>> > *hba, struct ufshpb_lu *hpb)
>> > }
>> >
>> > static struct ufshpb_lu *
>> > -ufshpb_alloc_hpb_lu(struct ufs_hba *hba, int lun,
>> > +ufshpb_alloc_hpb_lu(struct ufs_hba *hba, struct scsi_device *sdev,
>> > struct ufshpb_dev_info *hpb_dev_info,
>> > struct ufshpb_lu_info *hpb_lu_info)
>> > {
>> > @@ -1441,7 +1935,8 @@ ufshpb_alloc_hpb_lu(struct ufs_hba *hba, int lun,
>> > if (!hpb)
>> > return NULL;
>> >
>> > - hpb->lun = lun;
>> > + hpb->lun = sdev->lun;
>> > + hpb->sdev_ufs_lu = sdev;
>> >
>> > ufshpb_lu_parameter_init(hba, hpb, hpb_dev_info, hpb_lu_info);
>> >
>> > @@ -1451,6 +1946,7 @@ ufshpb_alloc_hpb_lu(struct ufs_hba *hba, int lun,
>> > goto release_hpb;
>> > }
>> >
>> > + sdev->hostdata = hpb;
>> > return hpb;
>> >
>> > release_hpb:
>> > @@ -1653,6 +2149,7 @@ void ufshpb_destroy_lu(struct ufs_hba *hba,
>> > struct scsi_device *sdev)
>> >
>> > ufshpb_cancel_jobs(hpb);
>> >
>> > + ufshpb_pre_req_mempool_destroy(hpb);
>> > ufshpb_destroy_region_tbl(hpb);
>> >
>> > kmem_cache_destroy(hpb->map_req_cache);
>> > @@ -1692,6 +2189,7 @@ static void ufshpb_hpb_lu_prepared(struct ufs_hba
>> > *hba)
>> > ufshpb_set_state(hpb, HPB_PRESENT);
>> > if ((hpb->lu_pinned_end - hpb->lu_pinned_start) > 0)
>> > queue_work(ufshpb_wq, &hpb->map_work);
>> > + ufshpb_issue_umap_all_req(hpb);
>> > } else {
>> > dev_err(hba->dev, "destroy HPB lu %d\n", hpb->lun);
>> > ufshpb_destroy_lu(hba, sdev);
>> > @@ -1716,7 +2214,7 @@ void ufshpb_init_hpb_lu(struct ufs_hba *hba,
>> > struct scsi_device *sdev)
>> > if (ret)
>> > goto out;
>> >
>> > - hpb = ufshpb_alloc_hpb_lu(hba, lun, &hba->ufshpb_dev,
>> > + hpb = ufshpb_alloc_hpb_lu(hba, sdev, &hba->ufshpb_dev,
>> > &hpb_lu_info);
>> > if (!hpb)
>> > goto out;
>> > @@ -1724,9 +2222,6 @@ void ufshpb_init_hpb_lu(struct ufs_hba *hba,
>> > struct scsi_device *sdev)
>> > 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;
>> > -
>> > out:
>> > /* All LUs are initialized */
>> > if (atomic_dec_and_test(&hba->ufshpb_dev.slave_conf_cnt))
>> > @@ -1813,8 +2308,9 @@ void ufshpb_get_geo_info(struct ufs_hba *hba, u8
>> > *geo_buf)
>> > void ufshpb_get_dev_info(struct ufs_hba *hba, u8 *desc_buf)
>> > {
>> > struct ufshpb_dev_info *hpb_dev_info = &hba->ufshpb_dev;
>> > - int version;
>> > + int version, ret;
>> > u8 hpb_mode;
>> > + u32 max_hpb_single_cmd = HPB_MULTI_CHUNK_LOW;
>> >
>> > hpb_mode = desc_buf[DEVICE_DESC_PARAM_HPB_CONTROL];
>> > if (hpb_mode == HPB_HOST_CONTROL) {
>> > @@ -1825,13 +2321,27 @@ void ufshpb_get_dev_info(struct ufs_hba *hba,
>> > u8 *desc_buf)
>> > }
>> >
>> > version = get_unaligned_be16(desc_buf + DEVICE_DESC_PARAM_HPB_VER);
>> > - if (version != HPB_SUPPORT_VERSION) {
>> > + if ((version != HPB_SUPPORT_VERSION) &&
>> > + (version != HPB_SUPPORT_LEGACY_VERSION)) {
>> > dev_err(hba->dev, "%s: HPB %x version is not supported.\n",
>> > __func__, version);
>> > hpb_dev_info->hpb_disabled = true;
>> > return;
>> > }
>> >
>> > + if (version == HPB_SUPPORT_LEGACY_VERSION)
>> > + hpb_dev_info->is_legacy = true;
>> > +
>> > + pm_runtime_get_sync(hba->dev);
>> > + ret = ufshcd_query_attr_retry(hba, UPIU_QUERY_OPCODE_READ_ATTR,
>> > + QUERY_ATTR_IDN_MAX_HPB_SINGLE_CMD, 0, 0, &max_hpb_single_cmd);
>> > + pm_runtime_put_sync(hba->dev);
>> > +
>> > + if (ret)
>> > + dev_err(hba->dev, "%s: idn: read max size of single hpb cmd query
>> > request failed",
>> > + __func__);
>> > + hpb_dev_info->max_hpb_single_cmd = max_hpb_single_cmd;
>> > +
>> > /*
>> > * Get the number of user logical unit to check whether all
>> > * scsi_device finish initialization
>> > diff --git a/drivers/scsi/ufs/ufshpb.h b/drivers/scsi/ufs/ufshpb.h
>> > index 6e6a0252dc15..b1128b0ce486 100644
>> > --- a/drivers/scsi/ufs/ufshpb.h
>> > +++ b/drivers/scsi/ufs/ufshpb.h
>> > @@ -30,19 +30,29 @@
>> > #define PINNED_NOT_SET U32_MAX
>> >
>> > /* hpb support chunk size */
>> > -#define HPB_MULTI_CHUNK_HIGH 1
>> > +#define HPB_LEGACY_CHUNK_HIGH 1
>> > +#define HPB_MULTI_CHUNK_LOW 7
>> > +#define HPB_MULTI_CHUNK_HIGH 128
>> >
>> > /* hpb vender defined opcode */
>> > #define UFSHPB_READ 0xF8
>> > #define UFSHPB_READ_BUFFER 0xF9
>> > #define UFSHPB_READ_BUFFER_ID 0x01
>> > +#define UFSHPB_WRITE_BUFFER 0xFA
>> > +#define UFSHPB_WRITE_BUFFER_INACT_SINGLE_ID 0x01
>> > +#define UFSHPB_WRITE_BUFFER_PREFETCH_ID 0x02
>> > +#define UFSHPB_WRITE_BUFFER_INACT_ALL_ID 0x03
>> > +#define HPB_WRITE_BUFFER_CMD_LENGTH 10
>> > +#define MAX_HPB_READ_ID 0x7F
>> > #define HPB_READ_BUFFER_CMD_LENGTH 10
>> > #define LU_ENABLED_HPB_FUNC 0x02
>> >
>> > #define HPB_RESET_REQ_RETRIES 10
>> > #define HPB_MAP_REQ_RETRIES 5
>> > +#define HPB_REQUEUE_TIME_MS 0
>> >
>> > -#define HPB_SUPPORT_VERSION 0x100
>> > +#define HPB_SUPPORT_VERSION 0x200
>> > +#define HPB_SUPPORT_LEGACY_VERSION 0x100
>> >
>> > enum UFSHPB_MODE {
>> > HPB_HOST_CONTROL,
>> > @@ -119,23 +129,38 @@ struct ufshpb_region {
>> > (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
>> > + * struct ufshpb_req - HPB related request structure (write/read
>> > buffer)
>> > + * @req: block layer request structure
>> > + * @bio: bio for this request
>> > + * @hpb: ufshpb_lu structure that related to
>> > + * @list_req: ufshpb_req mempool list
>> > + * @sense: store its sense data
>> > * @mctx: L2P map information
>> > * @rgn_idx: target region index
>> > * @srgn_idx: target sub-region index
>> > * @lun: target logical unit number
>> > + * @m_page: L2P map information data for pre-request
>> > + * @len: length of host-side cached L2P map in m_page
>> > + * @lpn: start LPN of L2P map in m_page
>> > */
>> > 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 list_head list_req;
>> > + union {
>> > + struct {
>> > + struct ufshpb_map_ctx *mctx;
>> > + unsigned int rgn_idx;
>> > + unsigned int srgn_idx;
>> > + unsigned int lun;
>> > + } rb;
>> > + struct {
>> > + struct page *m_page;
>> > + unsigned int len;
>> > + unsigned long lpn;
>> > + } wb;
>> > + };
>> > };
>> >
>> > struct victim_select_info {
>> > @@ -144,6 +169,10 @@ struct victim_select_info {
>> > atomic_t active_cnt;
>> > };
>> >
>> > +struct ufshpb_params {
>> > + unsigned int requeue_timeout_ms;
>> > +};
>> > +
>> > struct ufshpb_stats {
>> > u64 hit_cnt;
>> > u64 miss_cnt;
>> > @@ -151,6 +180,7 @@ struct ufshpb_stats {
>> > u64 rb_active_cnt;
>> > u64 rb_inactive_cnt;
>> > u64 map_req_cnt;
>> > + u64 pre_req_cnt;
>> > };
>> >
>> > struct ufshpb_lu {
>> > @@ -166,6 +196,15 @@ struct ufshpb_lu {
>> > struct list_head lh_act_srgn; /* hold rsp_list_lock */
>> > struct list_head lh_inact_rgn; /* hold rsp_list_lock */
>> >
>> > + /* pre request information */
>> > + struct ufshpb_req *pre_req;
>> > + int num_inflight_pre_req;
>> > + int throttle_pre_req;
>> > + struct list_head lh_pre_req_free;
>> > + int cur_read_id;
>> > + int pre_req_min_tr_len;
>> > + int pre_req_max_tr_len;
>> > +
>> > /* cached L2P map management worker */
>> > struct work_struct map_work;
>> >
>> > @@ -190,6 +229,7 @@ struct ufshpb_lu {
>> > u32 pages_per_srgn;
>> >
>> > struct ufshpb_stats stats;
>> > + struct ufshpb_params params;
>> >
>> > struct kmem_cache *map_req_cache;
>> > struct kmem_cache *m_page_cache;
>> > @@ -201,7 +241,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 int ufshpb_prep(struct ufs_hba *hba, struct ufshcd_lrb *lrbp)
>> > { return 0; }
>> > 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) {}
>> > @@ -214,8 +254,9 @@ 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) {}
>> > +static bool ufshpb_is_legacy(struct ufs_hba *hba) { return false; }
>> > #else
>> > -void ufshpb_prep(struct ufs_hba *hba, struct ufshcd_lrb *lrbp);
>> > +int 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);
>> > @@ -228,7 +269,9 @@ 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);
>> > +bool ufshpb_is_legacy(struct ufs_hba *hba);
>> > extern struct attribute_group ufs_sysfs_hpb_stat_group;
>> > +extern struct attribute_group ufs_sysfs_hpb_param_group;
>> > #endif
>> >
>> > #endif /* End of Header */
>>
>>
>>
^ permalink raw reply [flat|nested] 26+ messages in thread* RE: Re: [PATCH v31 4/4] scsi: ufs: Add HPB 2.0 support
2021-03-25 8:12 ` Can Guo
@ 2021-03-26 2:55 ` Daejun Park
2021-03-26 3:15 ` Bart Van Assche
0 siblings, 1 reply; 26+ messages in thread
From: Daejun Park @ 2021-03-26 2:55 UTC (permalink / raw)
To: Can Guo, Daejun Park
Cc: Greg KH, avri.altman@wdc.com, jejb@linux.ibm.com,
martin.petersen@oracle.com, asutoshd@codeaurora.org,
stanley.chu@mediatek.com, bvanassche@acm.org, huobean@gmail.com,
linux-scsi@vger.kernel.org, linux-kernel@vger.kernel.org,
ALIM AKHTAR, JinHwan Park, Javier Gonzalez, Sung-Jun Park,
Jinyoung CHOI, Dukhyun Kwon, Keoseong Park, Jaemyung Lee,
Jieon Seol
> On 2021-03-25 08:47, Daejun Park wrote:
> >> On 2021-03-22 14:55, Daejun Park wrote:
> >> > This patch supports the HPB 2.0.
> >> >
> >> > The HPB 2.0 supports read of varying sizes from 4KB to 512KB.
> >> > In the case of Read (<= 32KB) is supported as single HPB read.
> >> > In the case of Read (36KB ~ 512KB) is supported by as a combination of
> >> > write buffer command and HPB read command to deliver more PPN.
> >> > The write buffer commands may not be issued immediately due to busy
> >> > tags.
> >> > To use HPB read more aggressively, the driver can requeue the write
> >> > buffer
> >> > command. The requeue threshold is implemented as timeout and can be
> >> > modified with requeue_timeout_ms entry in sysfs.
> >> >
> >> > Signed-off-by: Daejun Park <daejun7.park@samsung.com>
> >> > ---
> >> > Documentation/ABI/testing/sysfs-driver-ufs | 47 +-
> >> > drivers/scsi/ufs/ufs-sysfs.c | 4 +
> >> > drivers/scsi/ufs/ufs.h | 3 +-
> >> > drivers/scsi/ufs/ufshcd.c | 25 +-
> >> > drivers/scsi/ufs/ufshcd.h | 7 +
> >> > drivers/scsi/ufs/ufshpb.c | 626 +++++++++++++++++++--
> >> > drivers/scsi/ufs/ufshpb.h | 67 ++-
> >> > 7 files changed, 698 insertions(+), 81 deletions(-)
> >> >
> >> > diff --git a/Documentation/ABI/testing/sysfs-driver-ufs
> >> > b/Documentation/ABI/testing/sysfs-driver-ufs
> >> > index 528bf89fc98b..419adf450b89 100644
> >> > --- a/Documentation/ABI/testing/sysfs-driver-ufs
> >> > +++ b/Documentation/ABI/testing/sysfs-driver-ufs
> >> > @@ -1253,14 +1253,14 @@ Description: This entry shows the number of
> >> > HPB pinned regions assigned to
> >> >
> >> > The file is read only.
> >> >
> >> > -What: /sys/class/scsi_device/*/device/hpb_sysfs/hit_cnt
> >> > +What: /sys/class/scsi_device/*/device/hpb_stat_sysfs/hit_cnt
> >> > Date: March 2021
> >> > Contact: Daejun Park <daejun7.park@samsung.com>
> >> > Description: This entry shows the number of reads that changed to HPB
> >> > read.
> >> >
> >> > The file is read only.
> >> >
> >> > -What: /sys/class/scsi_device/*/device/hpb_sysfs/miss_cnt
> >> > +What: /sys/class/scsi_device/*/device/hpb_stat_sysfs/miss_cnt
> >> > Date: March 2021
> >> > Contact: Daejun Park <daejun7.park@samsung.com>
> >> > Description: This entry shows the number of reads that cannot be
> >> > changed to
> >> > @@ -1268,7 +1268,7 @@ Description: This entry shows the number of
> >> > reads that cannot be changed to
> >> >
> >> > The file is read only.
> >> >
> >> > -What: /sys/class/scsi_device/*/device/hpb_sysfs/rb_noti_cnt
> >> > +What: /sys/class/scsi_device/*/device/hpb_stat_sysfs/rb_noti_cnt
> >> > Date: March 2021
> >> > Contact: Daejun Park <daejun7.park@samsung.com>
> >> > Description: This entry shows the number of response UPIUs that has
> >> > @@ -1276,7 +1276,7 @@ Description: This entry shows the number of
> >> > response UPIUs that has
> >> >
> >> > The file is read only.
> >> >
> >> > -What: /sys/class/scsi_device/*/device/hpb_sysfs/rb_active_cnt
> >> > +What: /sys/class/scsi_device/*/device/hpb_stat_sysfs/rb_active_cnt
> >> > Date: March 2021
> >> > Contact: Daejun Park <daejun7.park@samsung.com>
> >> > Description: This entry shows the number of active sub-regions
> >> > recommended by
> >> > @@ -1284,7 +1284,7 @@ Description: This entry shows the number of
> >> > active sub-regions recommended by
> >> >
> >> > The file is read only.
> >> >
> >> > -What: /sys/class/scsi_device/*/device/hpb_sysfs/rb_inactive_cnt
> >> > +What: /sys/class/scsi_device/*/device/hpb_stat_sysfs/rb_inactive_cnt
> >> > Date: March 2021
> >> > Contact: Daejun Park <daejun7.park@samsung.com>
> >> > Description: This entry shows the number of inactive regions
> >> > recommended by
> >> > @@ -1292,10 +1292,45 @@ Description: This entry shows the number of
> >> > inactive regions recommended by
> >> >
> >> > The file is read only.
> >> >
> >> > -What: /sys/class/scsi_device/*/device/hpb_sysfs/map_req_cnt
> >> > +What: /sys/class/scsi_device/*/device/hpb_stat_sysfs/map_req_cnt
> >> > Date: March 2021
> >> > Contact: Daejun Park <daejun7.park@samsung.com>
> >> > Description: This entry shows the number of read buffer commands for
> >> > activating sub-regions recommended by response UPIUs.
> >> >
> >> > The file is read only.
> >> > +
> >> > +What: /sys/class/scsi_device/*/device/hpb_param_sysfs/requeue_timeout_ms
> >> > +Date: March 2021
> >> > +Contact: Daejun Park <daejun7.park@samsung.com>
> >> > +Description: This entry shows the requeue timeout threshold for write
> >> > buffer
> >> > + command in ms. This value can be changed by writing proper integer
> >> > to
> >> > + this entry.
> >> > +
> >> > +What: /sys/bus/platform/drivers/ufshcd/*/attributes/max_data_size_hpb_single_cmd
> >> > +Date: March 2021
> >> > +Contact: Daejun Park <daejun7.park@samsung.com>
> >> > +Description: This entry shows the maximum HPB data size for using
> >> > single HPB
> >> > + command.
> >> > +
> >> > + === ========
> >> > + 00h 4KB
> >> > + 01h 8KB
> >> > + 02h 12KB
> >> > + ...
> >> > + FFh 1024KB
> >> > + === ========
> >> > +
> >> > + The file is read only.
> >> > +
> >> > +What: /sys/bus/platform/drivers/ufshcd/*/flags/wb_enable
> >> > +Date: March 2021
> >> > +Contact: Daejun Park <daejun7.park@samsung.com>
> >> > +Description: This entry shows the status of HPB.
> >> > +
> >> > + == ============================
> >> > + 0 HPB is not enabled.
> >> > + 1 HPB is enabled
> >> > + == ============================
> >> > +
> >> > + The file is read only.
> >> > diff --git a/drivers/scsi/ufs/ufs-sysfs.c
> >> > b/drivers/scsi/ufs/ufs-sysfs.c
> >> > index 2546e7a1ac4f..92a883866e12 100644
> >> > --- a/drivers/scsi/ufs/ufs-sysfs.c
> >> > +++ b/drivers/scsi/ufs/ufs-sysfs.c
> >> > @@ -782,6 +782,7 @@ UFS_FLAG(disable_fw_update,
> >> > _PERMANENTLY_DISABLE_FW_UPDATE);
> >> > UFS_FLAG(wb_enable, _WB_EN);
> >> > UFS_FLAG(wb_flush_en, _WB_BUFF_FLUSH_EN);
> >> > UFS_FLAG(wb_flush_during_h8, _WB_BUFF_FLUSH_DURING_HIBERN8);
> >> > +UFS_FLAG(hpb_enable, _HPB_EN);
> >> >
> >> > static struct attribute *ufs_sysfs_device_flags[] = {
> >> > &dev_attr_device_init.attr,
> >> > @@ -795,6 +796,7 @@ static struct attribute *ufs_sysfs_device_flags[] =
> >> > {
> >> > &dev_attr_wb_enable.attr,
> >> > &dev_attr_wb_flush_en.attr,
> >> > &dev_attr_wb_flush_during_h8.attr,
> >> > + &dev_attr_hpb_enable.attr,
> >> > NULL,
> >> > };
> >> >
> >> > @@ -841,6 +843,7 @@ out: \
> >> > static DEVICE_ATTR_RO(_name)
> >> >
> >> > UFS_ATTRIBUTE(boot_lun_enabled, _BOOT_LU_EN);
> >> > +UFS_ATTRIBUTE(max_data_size_hpb_single_cmd, _MAX_HPB_SINGLE_CMD);
> >> > UFS_ATTRIBUTE(current_power_mode, _POWER_MODE);
> >> > UFS_ATTRIBUTE(active_icc_level, _ACTIVE_ICC_LVL);
> >> > UFS_ATTRIBUTE(ooo_data_enabled, _OOO_DATA_EN);
> >> > @@ -864,6 +867,7 @@ UFS_ATTRIBUTE(wb_cur_buf, _CURR_WB_BUFF_SIZE);
> >> >
> >> > static struct attribute *ufs_sysfs_attributes[] = {
> >> > &dev_attr_boot_lun_enabled.attr,
> >> > + &dev_attr_max_data_size_hpb_single_cmd.attr,
> >> > &dev_attr_current_power_mode.attr,
> >> > &dev_attr_active_icc_level.attr,
> >> > &dev_attr_ooo_data_enabled.attr,
> >> > diff --git a/drivers/scsi/ufs/ufs.h b/drivers/scsi/ufs/ufs.h
> >> > index bfb84d2ba990..8c6b38b1b142 100644
> >> > --- a/drivers/scsi/ufs/ufs.h
> >> > +++ b/drivers/scsi/ufs/ufs.h
> >> > @@ -123,12 +123,13 @@ enum flag_idn {
> >> > QUERY_FLAG_IDN_WB_BUFF_FLUSH_EN = 0x0F,
> >> > QUERY_FLAG_IDN_WB_BUFF_FLUSH_DURING_HIBERN8 = 0x10,
> >> > QUERY_FLAG_IDN_HPB_RESET = 0x11,
> >> > + QUERY_FLAG_IDN_HPB_EN = 0x12,
> >> > };
> >> >
> >> > /* Attribute idn for Query requests */
> >> > enum attr_idn {
> >> > QUERY_ATTR_IDN_BOOT_LU_EN = 0x00,
> >> > - QUERY_ATTR_IDN_RESERVED = 0x01,
> >> > + QUERY_ATTR_IDN_MAX_HPB_SINGLE_CMD = 0x01,
> >> > QUERY_ATTR_IDN_POWER_MODE = 0x02,
> >> > QUERY_ATTR_IDN_ACTIVE_ICC_LVL = 0x03,
> >> > QUERY_ATTR_IDN_OOO_DATA_EN = 0x04,
> >> > diff --git a/drivers/scsi/ufs/ufshcd.c b/drivers/scsi/ufs/ufshcd.c
> >> > index a7cf9278965c..1653c7a7b066 100644
> >> > --- a/drivers/scsi/ufs/ufshcd.c
> >> > +++ b/drivers/scsi/ufs/ufshcd.c
> >> > @@ -2653,7 +2653,12 @@ static int ufshcd_queuecommand(struct Scsi_Host
> >> > *host, struct scsi_cmnd *cmd)
> >> >
> >> > lrbp->req_abort_skip = false;
> >> >
> >> > - ufshpb_prep(hba, lrbp);
> >> > + err = ufshpb_prep(hba, lrbp);
> >> > + if (err == -EAGAIN) {
> >> > + lrbp->cmd = NULL;
> >> > + ufshcd_release(hba);
> >> > + goto out;
> >> > + }
> >> >
> >> > ufshcd_comp_scsi_upiu(hba, lrbp);
> >> >
> >> > @@ -3107,7 +3112,7 @@ int ufshcd_query_attr(struct ufs_hba *hba, enum
> >> > query_opcode opcode,
> >> > *
> >> > * Returns 0 for success, non-zero in case of failure
> >> > */
> >> > -static int ufshcd_query_attr_retry(struct ufs_hba *hba,
> >> > +int ufshcd_query_attr_retry(struct ufs_hba *hba,
> >> > enum query_opcode opcode, enum attr_idn idn, u8 index, u8 selector,
> >> > u32 *attr_val)
> >> > {
> >> > @@ -4862,7 +4867,8 @@ static int ufshcd_change_queue_depth(struct
> >> > scsi_device *sdev, int 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))
> >> > + if ((sdev->lun >= UFS_UPIU_MAX_UNIT_NUM_ID) ||
> >> > + !(hba->dev_info.hpb_enabled) || !ufshpb_is_allowed(hba))
> >> > return;
> >> >
> >> > ufshpb_destroy_lu(hba, sdev);
> >> > @@ -7454,8 +7460,18 @@ static int ufs_get_device_desc(struct ufs_hba
> >> > *hba)
> >> >
> >> > if (dev_info->wspecversion >= UFS_DEV_HPB_SUPPORT_VERSION &&
> >> > (b_ufs_feature_sup & UFS_DEV_HPB_SUPPORT)) {
> >> > - dev_info->hpb_enabled = true;
> >> > + bool hpb_en = false;
> >> > +
> >> > ufshpb_get_dev_info(hba, desc_buf);
> >> > +
> >> > + if (!ufshpb_is_legacy(hba))
> >> > + err = ufshcd_query_flag_retry(hba,
> >> > + UPIU_QUERY_OPCODE_READ_FLAG,
> >> > + QUERY_FLAG_IDN_HPB_EN, 0,
> >> > + &hpb_en);
> >> > +
> >> > + if (ufshpb_is_legacy(hba) || (!err && hpb_en))
> >> > + dev_info->hpb_enabled = true;
> >> > }
> >> >
> >> > err = ufshcd_read_string_desc(hba, model_index,
> >> > @@ -8028,6 +8044,7 @@ static const struct attribute_group
> >> > *ufshcd_driver_groups[] = {
> >> > &ufs_sysfs_lun_attributes_group,
> >> > #ifdef CONFIG_SCSI_UFS_HPB
> >> > &ufs_sysfs_hpb_stat_group,
> >> > + &ufs_sysfs_hpb_param_group,
> >> > #endif
> >> > NULL,
> >> > };
> >> > diff --git a/drivers/scsi/ufs/ufshcd.h b/drivers/scsi/ufs/ufshcd.h
> >> > index 008a5f7146c0..8aca8f327981 100644
> >> > --- a/drivers/scsi/ufs/ufshcd.h
> >> > +++ b/drivers/scsi/ufs/ufshcd.h
> >> > @@ -654,6 +654,8 @@ struct ufs_hba_variant_params {
> >> > * @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
> >> > + * @max_hpb_single_cmd: maximum size of single HPB command
> >> > + * @is_legacy: flag to check HPB 1.0
> >> > */
> >> > struct ufshpb_dev_info {
> >> > int num_lu;
> >> > @@ -661,6 +663,8 @@ struct ufshpb_dev_info {
> >> > int srgn_size;
> >> > atomic_t slave_conf_cnt;
> >> > bool hpb_disabled;
> >> > + int max_hpb_single_cmd;
> >> > + bool is_legacy;
> >> > };
> >> > #endif
> >> >
> >> > @@ -1096,6 +1100,9 @@ int ufshcd_read_desc_param(struct ufs_hba *hba,
> >> > u8 param_offset,
> >> > u8 *param_read_buf,
> >> > u8 param_size);
> >> > +int ufshcd_query_attr_retry(struct ufs_hba *hba, enum query_opcode
> >> > opcode,
> >> > + enum attr_idn idn, u8 index, u8 selector,
> >> > + u32 *attr_val);
> >> > int ufshcd_query_attr(struct ufs_hba *hba, enum query_opcode opcode,
> >> > enum attr_idn idn, u8 index, u8 selector, u32 *attr_val);
> >> > int ufshcd_query_flag(struct ufs_hba *hba, enum query_opcode opcode,
> >> > diff --git a/drivers/scsi/ufs/ufshpb.c b/drivers/scsi/ufs/ufshpb.c
> >> > index f789339f68d9..3ac8b0a9e8d3 100644
> >> > --- a/drivers/scsi/ufs/ufshpb.c
> >> > +++ b/drivers/scsi/ufs/ufshpb.c
> >> > @@ -31,6 +31,11 @@ bool ufshpb_is_allowed(struct ufs_hba *hba)
> >> > return !(hba->ufshpb_dev.hpb_disabled);
> >> > }
> >> >
> >> > +bool ufshpb_is_legacy(struct ufs_hba *hba)
> >> > +{
> >> > + return hba->ufshpb_dev.is_legacy;
> >> > +}
> >> > +
> >> > static struct ufshpb_lu *ufshpb_get_hpb_data(struct scsi_device *sdev)
> >> > {
> >> > return sdev->hostdata;
> >> > @@ -64,9 +69,19 @@ static bool ufshpb_is_write_or_discard_cmd(struct
> >> > scsi_cmnd *cmd)
> >> > op_is_discard(req_op(cmd->request));
> >> > }
> >> >
> >> > -static bool ufshpb_is_support_chunk(int transfer_len)
> >> > +static bool ufshpb_is_support_chunk(struct ufshpb_lu *hpb, int
> >> > transfer_len)
> >> > {
> >> > - return transfer_len <= HPB_MULTI_CHUNK_HIGH;
> >> > + return transfer_len <= hpb->pre_req_max_tr_len;
> >> > +}
> >> > +
> >> > +/*
> >> > + * In this driver, WRITE_BUFFER CMD support 36KB (len=9) ~ 512KB
> >> > (len=128) as
> >> > + * default. It is possible to change range of transfer_len through
> >> > sysfs.
> >> > + */
> >> > +static inline bool ufshpb_is_required_wb(struct ufshpb_lu *hpb, int
> >> > len)
> >> > +{
> >> > + return (len > hpb->pre_req_min_tr_len &&
> >> > + len <= hpb->pre_req_max_tr_len);
> >> > }
> >> >
> >> > static bool ufshpb_is_general_lun(int lun)
> >> > @@ -74,8 +89,7 @@ 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)
> >> > +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 &&
> >> > @@ -264,7 +278,8 @@ ufshpb_get_pos_from_lpn(struct ufshpb_lu *hpb,
> >> > unsigned long lpn, int *rgn_idx,
> >> >
> >> > static void
> >> > ufshpb_set_hpb_read_to_upiu(struct ufshpb_lu *hpb, struct ufshcd_lrb
> >> > *lrbp,
> >> > - u32 lpn, u64 ppn, unsigned int transfer_len)
> >> > + u32 lpn, u64 ppn, unsigned int transfer_len,
> >> > + int read_id)
> >> > {
> >> > unsigned char *cdb = lrbp->cmd->cmnd;
> >> >
> >> > @@ -273,15 +288,261 @@ ufshpb_set_hpb_read_to_upiu(struct ufshpb_lu
> >> > *hpb, struct ufshcd_lrb *lrbp,
> >> > /* ppn value is stored as big-endian in the host memory */
> >> > memcpy(&cdb[6], &ppn, sizeof(u64));
> >> > cdb[14] = transfer_len;
> >> > + cdb[15] = read_id;
> >> >
> >> > lrbp->cmd->cmd_len = UFS_CDB_SIZE;
> >> > }
> >> >
> >> > +static inline void ufshpb_set_write_buf_cmd(unsigned char *cdb,
> >> > + unsigned long lpn, unsigned int len,
> >> > + int read_id)
> >> > +{
> >> > + cdb[0] = UFSHPB_WRITE_BUFFER;
> >> > + cdb[1] = UFSHPB_WRITE_BUFFER_PREFETCH_ID;
> >> > +
> >> > + put_unaligned_be32(lpn, &cdb[2]);
> >> > + cdb[6] = read_id;
> >> > + put_unaligned_be16(len * HPB_ENTRY_SIZE, &cdb[7]);
> >> > +
> >> > + cdb[9] = 0x00; /* Control = 0x00 */
> >> > +}
> >> > +
> >> > +static struct ufshpb_req *ufshpb_get_pre_req(struct ufshpb_lu *hpb)
> >> > +{
> >> > + struct ufshpb_req *pre_req;
> >> > +
> >> > + if (hpb->num_inflight_pre_req >= hpb->throttle_pre_req) {
> >> > + dev_info(&hpb->sdev_ufs_lu->sdev_dev,
> >> > + "pre_req throttle. inflight %d throttle %d",
> >> > + hpb->num_inflight_pre_req, hpb->throttle_pre_req);
> >> > + return NULL;
> >> > + }
> >> > +
> >> > + pre_req = list_first_entry_or_null(&hpb->lh_pre_req_free,
> >> > + struct ufshpb_req, list_req);
> >> > + if (!pre_req) {
> >> > + dev_info(&hpb->sdev_ufs_lu->sdev_dev, "There is no pre_req");
> >> > + return NULL;
> >> > + }
> >> > +
> >> > + list_del_init(&pre_req->list_req);
> >> > + hpb->num_inflight_pre_req++;
> >> > +
> >> > + return pre_req;
> >> > +}
> >> > +
> >> > +static inline void ufshpb_put_pre_req(struct ufshpb_lu *hpb,
> >> > + struct ufshpb_req *pre_req)
> >> > +{
> >> > + pre_req->req = NULL;
> >> > + bio_reset(pre_req->bio);
> >> > + list_add_tail(&pre_req->list_req, &hpb->lh_pre_req_free);
> >> > + hpb->num_inflight_pre_req--;
> >> > +}
> >> > +
> >> > +static void ufshpb_pre_req_compl_fn(struct request *req, blk_status_t
> >> > error)
> >> > +{
> >> > + struct ufshpb_req *pre_req = (struct ufshpb_req *)req->end_io_data;
> >> > + struct ufshpb_lu *hpb = pre_req->hpb;
> >> > + unsigned long flags;
> >> > +
> >> > + if (error) {
> >> > + struct scsi_request *rq = scsi_req(req);
> >> > + struct scsi_sense_hdr sshdr;
> >> > +
> >> > + dev_err(&hpb->sdev_ufs_lu->sdev_dev, "block status %d", error);
> >> > + scsi_normalize_sense(rq->sense, SCSI_SENSE_BUFFERSIZE,
> >> > + &sshdr);
> >> > + dev_err(&hpb->sdev_ufs_lu->sdev_dev,
> >> > + "code %x sense_key %x asc %x ascq %x",
> >> > + sshdr.response_code,
> >> > + sshdr.sense_key, sshdr.asc, sshdr.ascq);
> >> > + dev_err(&hpb->sdev_ufs_lu->sdev_dev,
> >> > + "byte4 %x byte5 %x byte6 %x additional_len %x",
> >> > + sshdr.byte4, sshdr.byte5,
> >> > + sshdr.byte6, sshdr.additional_length);
> >> > + }
> >> > +
> >> > + blk_mq_free_request(req);
> >> > + spin_lock_irqsave(&hpb->rgn_state_lock, flags);
> >> > + ufshpb_put_pre_req(pre_req->hpb, pre_req);
> >> > + spin_unlock_irqrestore(&hpb->rgn_state_lock, flags);
> >> > +}
> >> > +
> >> > +static int ufshpb_prep_entry(struct ufshpb_req *pre_req, struct page
> >> > *page)
> >> > +{
> >> > + struct ufshpb_lu *hpb = pre_req->hpb;
> >> > + struct ufshpb_region *rgn;
> >> > + struct ufshpb_subregion *srgn;
> >> > + u64 *addr;
> >> > + int offset = 0;
> >> > + int copied;
> >> > + unsigned long lpn = pre_req->wb.lpn;
> >> > + int rgn_idx, srgn_idx, srgn_offset;
> >> > + unsigned long flags;
> >> > +
> >> > + addr = page_address(page);
> >> > + ufshpb_get_pos_from_lpn(hpb, lpn, &rgn_idx, &srgn_idx, &srgn_offset);
> >> > +
> >> > + spin_lock_irqsave(&hpb->rgn_state_lock, flags);
> >> > +
> >> > +next_offset:
> >> > + rgn = hpb->rgn_tbl + rgn_idx;
> >> > + srgn = rgn->srgn_tbl + srgn_idx;
> >> > +
> >> > + if (!ufshpb_is_valid_srgn(rgn, srgn))
> >> > + goto mctx_error;
> >> > +
> >> > + if (!srgn->mctx)
> >> > + goto mctx_error;
> >> > +
> >> > + copied = ufshpb_fill_ppn_from_page(hpb, srgn->mctx, srgn_offset,
> >> > + pre_req->wb.len - offset,
> >> > + &addr[offset]);
> >> > +
> >> > + if (copied < 0)
> >> > + goto mctx_error;
> >> > +
> >> > + offset += copied;
> >> > + srgn_offset += copied;
> >> > +
> >> > + if (srgn_offset == hpb->entries_per_srgn) {
> >> > + srgn_offset = 0;
> >> > +
> >> > + if (++srgn_idx == hpb->srgns_per_rgn) {
> >> > + srgn_idx = 0;
> >> > + rgn_idx++;
> >> > + }
> >> > + }
> >> > +
> >> > + if (offset < pre_req->wb.len)
> >> > + goto next_offset;
> >> > +
> >> > + spin_unlock_irqrestore(&hpb->rgn_state_lock, flags);
> >> > + return 0;
> >> > +mctx_error:
> >> > + spin_unlock_irqrestore(&hpb->rgn_state_lock, flags);
> >> > + return -ENOMEM;
> >> > +}
> >> > +
> >> > +static int ufshpb_pre_req_add_bio_page(struct ufshpb_lu *hpb,
> >> > + struct request_queue *q,
> >> > + struct ufshpb_req *pre_req)
> >> > +{
> >> > + struct page *page = pre_req->wb.m_page;
> >> > + struct bio *bio = pre_req->bio;
> >> > + int entries_bytes, ret;
> >> > +
> >> > + if (!page)
> >> > + return -ENOMEM;
> >> > +
> >> > + if (ufshpb_prep_entry(pre_req, page))
> >> > + return -ENOMEM;
> >> > +
> >> > + entries_bytes = pre_req->wb.len * sizeof(u64);
> >> > +
> >> > + ret = bio_add_pc_page(q, bio, page, entries_bytes, 0);
> >> > + if (ret != entries_bytes) {
> >> > + dev_err(&hpb->sdev_ufs_lu->sdev_dev,
> >> > + "bio_add_pc_page fail: %d", ret);
> >> > + return -ENOMEM;
> >> > + }
> >> > + return 0;
> >> > +}
> >> > +
> >> > +static inline int ufshpb_get_read_id(struct ufshpb_lu *hpb)
> >> > +{
> >> > + if (++hpb->cur_read_id >= MAX_HPB_READ_ID)
> >> > + hpb->cur_read_id = 1;
> >> > + return hpb->cur_read_id;
> >> > +}
> >> > +
> >> > +static int ufshpb_execute_pre_req(struct ufshpb_lu *hpb, struct
> >> > scsi_cmnd *cmd,
> >> > + struct ufshpb_req *pre_req, int read_id)
> >> > +{
> >> > + struct scsi_device *sdev = cmd->device;
> >> > + struct request_queue *q = sdev->request_queue;
> >> > + struct request *req;
> >> > + struct scsi_request *rq;
> >> > + struct bio *bio = pre_req->bio;
> >> > +
> >> > + pre_req->hpb = hpb;
> >> > + pre_req->wb.lpn = sectors_to_logical(cmd->device,
> >> > + blk_rq_pos(cmd->request));
> >> > + pre_req->wb.len = sectors_to_logical(cmd->device,
> >> > + blk_rq_sectors(cmd->request));
> >> > + if (ufshpb_pre_req_add_bio_page(hpb, q, pre_req))
> >> > + return -ENOMEM;
> >> > +
> >> > + req = pre_req->req;
> >> > +
> >> > + /* 1. request setup */
> >> > + blk_rq_append_bio(req, &bio);
> >> > + req->rq_disk = NULL;
> >> > + req->end_io_data = (void *)pre_req;
> >> > + req->end_io = ufshpb_pre_req_compl_fn;
> >> > +
> >> > + /* 2. scsi_request setup */
> >> > + rq = scsi_req(req);
> >> > + rq->retries = 1;
> >> > +
> >> > + ufshpb_set_write_buf_cmd(rq->cmd, pre_req->wb.lpn, pre_req->wb.len,
> >> > + read_id);
> >> > + rq->cmd_len = scsi_command_size(rq->cmd);
> >> > +
> >> > + if (blk_insert_cloned_request(q, req) != BLK_STS_OK)
> >> > + return -EAGAIN;
> >> > +
> >> > + hpb->stats.pre_req_cnt++;
> >> > +
> >> > + return 0;
> >> > +}
> >> > +
> >> > +static int ufshpb_issue_pre_req(struct ufshpb_lu *hpb, struct
> >> > scsi_cmnd *cmd,
> >> > + int *read_id)
> >> > +{
> >> > + struct ufshpb_req *pre_req;
> >> > + struct request *req = NULL;
> >> > + unsigned long flags;
> >> > + int _read_id;
> >> > + int ret = 0;
> >> > +
> >> > + req = blk_get_request(cmd->device->request_queue,
> >> > + REQ_OP_SCSI_OUT | REQ_SYNC, BLK_MQ_REQ_NOWAIT);
> >> > + if (IS_ERR(req))
> >> > + return -EAGAIN;
> >> > +
> >> > + spin_lock_irqsave(&hpb->rgn_state_lock, flags);
> >> > + pre_req = ufshpb_get_pre_req(hpb);
> >> > + if (!pre_req) {
> >> > + ret = -EAGAIN;
> >> > + goto unlock_out;
> >> > + }
> >> > + _read_id = ufshpb_get_read_id(hpb);
> >> > + spin_unlock_irqrestore(&hpb->rgn_state_lock, flags);
> >> > +
> >> > + pre_req->req = req;
> >> > +
> >> > + ret = ufshpb_execute_pre_req(hpb, cmd, pre_req, _read_id);
> >> > + if (ret)
> >> > + goto free_pre_req;
> >> > +
> >> > + *read_id = _read_id;
> >> > +
> >> > + return ret;
> >> > +free_pre_req:
> >> > + spin_lock_irqsave(&hpb->rgn_state_lock, flags);
> >> > + ufshpb_put_pre_req(hpb, pre_req);
> >> > +unlock_out:
> >> > + spin_unlock_irqrestore(&hpb->rgn_state_lock, flags);
> >> > + blk_put_request(req);
> >> > + return ret;
> >> > +}
> >> > +
> >> > /*
> >> > * 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)
> >> > +int ufshpb_prep(struct ufs_hba *hba, struct ufshcd_lrb *lrbp)
> >> > {
> >> > struct ufshpb_lu *hpb;
> >> > struct ufshpb_region *rgn;
> >> > @@ -291,19 +552,20 @@ void ufshpb_prep(struct ufs_hba *hba, struct
> >> > ufshcd_lrb *lrbp)
> >> > u64 ppn;
> >> > unsigned long flags;
> >> > int transfer_len, rgn_idx, srgn_idx, srgn_offset;
> >> > + int read_id = 0;
> >> > int err = 0;
> >> >
> >> > hpb = ufshpb_get_hpb_data(cmd->device);
> >> > if (!hpb)
> >> > - return;
> >> > + return -ENODEV;
> >> >
> >> > if (ufshpb_get_state(hpb) == HPB_INIT)
> >> > - return;
> >> > + return -ENODEV;
> >> >
> >> > if (ufshpb_get_state(hpb) != HPB_PRESENT) {
> >> > dev_notice(&hpb->sdev_ufs_lu->sdev_dev,
> >> > "%s: ufshpb state is not PRESENT", __func__);
> >> > - return;
> >> > + return -ENODEV;
> >> > }
> >> >
> >> > if (blk_rq_is_scsi(cmd->request) ||
> >> > @@ -314,7 +576,7 @@ void ufshpb_prep(struct ufs_hba *hba, struct
> >> > ufshcd_lrb *lrbp)
> >> > transfer_len = sectors_to_logical(cmd->device,
> >> > blk_rq_sectors(cmd->request));
> >> > if (unlikely(!transfer_len))
> >> > - return;
> >> > + return 0;
> >> >
> >> > lpn = sectors_to_logical(cmd->device, blk_rq_pos(cmd->request));
> >> > ufshpb_get_pos_from_lpn(hpb, lpn, &rgn_idx, &srgn_idx, &srgn_offset);
> >> > @@ -327,18 +589,18 @@ void ufshpb_prep(struct ufs_hba *hba, struct
> >> > ufshcd_lrb *lrbp)
> >> > ufshpb_set_ppn_dirty(hpb, rgn_idx, srgn_idx, srgn_offset,
> >> > transfer_len);
> >> > spin_unlock_irqrestore(&hpb->rgn_state_lock, flags);
> >> > - return;
> >> > + return 0;
> >> > }
> >> >
> >> > - if (!ufshpb_is_support_chunk(transfer_len))
> >> > - return;
> >> > + if (!ufshpb_is_support_chunk(hpb, transfer_len))
> >> > + return 0;
> >> >
> >> > 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;
> >> > + return 0;
> >> > }
> >> >
> >> > err = ufshpb_fill_ppn_from_page(hpb, srgn->mctx, srgn_offset, 1,
> >> > &ppn);
> >> > @@ -351,64 +613,101 @@ void ufshpb_prep(struct ufs_hba *hba, struct
> >> > ufshcd_lrb *lrbp)
> >> > * active state.
> >> > */
> >> > dev_err(hba->dev, "get ppn failed. err %d\n", err);
> >> > - return;
> >> > + return err;
> >> > + }
> >> > + if (!ufshpb_is_legacy(hba) &&
> >> > + ufshpb_is_required_wb(hpb, transfer_len)) {
> >> > + err = ufshpb_issue_pre_req(hpb, cmd, &read_id);
> >> > + if (err) {
> >> > + unsigned long timeout;
> >> > +
> >> > + timeout = cmd->jiffies_at_alloc + msecs_to_jiffies(
> >> > + hpb->params.requeue_timeout_ms);
> >> > +
> >> > + if (time_before(jiffies, timeout))
> >> > + return -EAGAIN;
> >> > +
> >> > + hpb->stats.miss_cnt++;
> >> > + return 0;
> >> > + }
> >> > }
> >> >
> >> > - ufshpb_set_hpb_read_to_upiu(hpb, lrbp, lpn, ppn, transfer_len);
> >> > + ufshpb_set_hpb_read_to_upiu(hpb, lrbp, lpn, ppn, transfer_len,
> >> > read_id);
> >> >
> >> > hpb->stats.hit_cnt++;
> >> > + return 0;
> >> > }
> >> > -static struct ufshpb_req *ufshpb_get_map_req(struct ufshpb_lu *hpb,
> >> > - struct ufshpb_subregion *srgn)
> >> > +
> >> > +static struct ufshpb_req *ufshpb_get_req(struct ufshpb_lu *hpb,
> >> > + int rgn_idx, enum req_opf dir,
> >> > + bool atomic)
> >>
> >> You didn't mention this change in cover letter. And I don't see anyone
> >> is passing "atomic" as true, neither in your patches nor Avri's V6
> >> series
> >> (from ufshpb_issue_umap_single_req()). If no one is using the flag,
> >> then
> >> this is dead code. If Avri needs this flag, he can add it in host
> >> control
> >> mode patches. Do I miss anything?
> >
> > I thought Avri will use this flag under atomic section. There is no
> > spin_lock on ufshpb_issue_umap_single_req in the Avri's V6 series, so I
> > will delete it.
> >
> > Thanks,
> > Daejun
> >
>
> Please address it in next version. After that, I will give my
> reviewed-by tag.
OK, I will do.
Thanks,
Daejun
>
> Thanks,
> Can Guo.
>
> >>
> >> Thanks,
> >> Can Guo.
> >>
> >> > {
> >> > - struct ufshpb_req *map_req;
> >> > + struct ufshpb_req *rq;
> >> > struct request *req;
> >> > - struct bio *bio;
> >> > int retries = HPB_MAP_REQ_RETRIES;
> >> >
> >> > - map_req = kmem_cache_alloc(hpb->map_req_cache, GFP_KERNEL);
> >> > - if (!map_req)
> >> > + rq = kmem_cache_alloc(hpb->map_req_cache, GFP_ATOMIC);
> >> > + if (!rq)
> >> > return NULL;
> >> >
> >> > retry:
> >> > - req = blk_get_request(hpb->sdev_ufs_lu->request_queue,
> >> > - REQ_OP_SCSI_IN, BLK_MQ_REQ_NOWAIT);
> >> > + req = blk_get_request(hpb->sdev_ufs_lu->request_queue, dir,
> >> > + BLK_MQ_REQ_NOWAIT);
> >> >
> >> > - if ((PTR_ERR(req) == -EWOULDBLOCK) && (--retries > 0)) {
> >> > + if (!atomic && (PTR_ERR(req) == -EWOULDBLOCK) && (--retries > 0)) {
> >> > usleep_range(3000, 3100);
> >> > goto retry;
> >> > }
> >> >
> >> > if (IS_ERR(req))
> >> > - goto free_map_req;
> >> > + goto free_rq;
> >> > +
> >> > + rq->hpb = hpb;
> >> > + rq->req = req;
> >> > + rq->rb.rgn_idx = rgn_idx;
> >> > +
> >> > + return rq;
> >> > +
> >> > +free_rq:
> >> > + kmem_cache_free(hpb->map_req_cache, rq);
> >> > + return NULL;
> >> > +}
> >> > +
> >> > +static void ufshpb_put_req(struct ufshpb_lu *hpb, struct ufshpb_req
> >> > *rq)
> >> > +{
> >> > + blk_put_request(rq->req);
> >> > + kmem_cache_free(hpb->map_req_cache, rq);
> >> > +}
> >> > +
> >> > +static struct ufshpb_req *ufshpb_get_map_req(struct ufshpb_lu *hpb,
> >> > + struct ufshpb_subregion *srgn)
> >> > +{
> >> > + struct ufshpb_req *map_req;
> >> > + struct bio *bio;
> >> > +
> >> > + map_req = ufshpb_get_req(hpb, srgn->rgn_idx, REQ_OP_SCSI_IN, false);
> >> > + if (!map_req)
> >> > + return NULL;
> >> >
> >> > bio = bio_alloc(GFP_KERNEL, hpb->pages_per_srgn);
> >> > if (!bio) {
> >> > - blk_put_request(req);
> >> > - goto free_map_req;
> >> > + ufshpb_put_req(hpb, map_req);
> >> > + return NULL;
> >> > }
> >> >
> >> > - 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->rb.srgn_idx = srgn->srgn_idx;
> >> > + map_req->rb.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);
> >> > + ufshpb_put_req(hpb, map_req);
> >> > }
> >> >
> >> > static int ufshpb_clear_dirty_bitmap(struct ufshpb_lu *hpb,
> >> > @@ -491,6 +790,13 @@ static void ufshpb_activate_subregion(struct
> >> > ufshpb_lu *hpb,
> >> > srgn->srgn_state = HPB_SRGN_VALID;
> >> > }
> >> >
> >> > +static void ufshpb_umap_req_compl_fn(struct request *req, blk_status_t
> >> > error)
> >> > +{
> >> > + struct ufshpb_req *umap_req = (struct ufshpb_req *)req->end_io_data;
> >> > +
> >> > + ufshpb_put_req(umap_req->hpb, umap_req);
> >> > +}
> >> > +
> >> > 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;
> >> > @@ -498,8 +804,8 @@ static void ufshpb_map_req_compl_fn(struct request
> >> > *req, blk_status_t error)
> >> > struct ufshpb_subregion *srgn;
> >> > unsigned long flags;
> >> >
> >> > - srgn = hpb->rgn_tbl[map_req->rgn_idx].srgn_tbl +
> >> > - map_req->srgn_idx;
> >> > + srgn = hpb->rgn_tbl[map_req->rb.rgn_idx].srgn_tbl +
> >> > + map_req->rb.srgn_idx;
> >> >
> >> > ufshpb_clear_dirty_bitmap(hpb, srgn);
> >> > spin_lock_irqsave(&hpb->rgn_state_lock, flags);
> >> > @@ -509,6 +815,16 @@ static void ufshpb_map_req_compl_fn(struct
> >> > request *req, blk_status_t error)
> >> > ufshpb_put_map_req(map_req->hpb, map_req);
> >> > }
> >> >
> >> > +static void ufshpb_set_unmap_cmd(unsigned char *cdb, struct
> >> > ufshpb_region *rgn)
> >> > +{
> >> > + cdb[0] = UFSHPB_WRITE_BUFFER;
> >> > + cdb[1] = rgn ? UFSHPB_WRITE_BUFFER_INACT_SINGLE_ID :
> >> > + UFSHPB_WRITE_BUFFER_INACT_ALL_ID;
> >> > + if (rgn)
> >> > + put_unaligned_be16(rgn->rgn_idx, &cdb[2]);
> >> > + cdb[9] = 0x00;
> >> > +}
> >> > +
> >> > static void ufshpb_set_read_buf_cmd(unsigned char *cdb, int rgn_idx,
> >> > int srgn_idx, int srgn_mem_size)
> >> > {
> >> > @@ -522,6 +838,25 @@ static void ufshpb_set_read_buf_cmd(unsigned char
> >> > *cdb, int rgn_idx,
> >> > cdb[9] = 0x00;
> >> > }
> >> >
> >> > +static int ufshpb_execute_umap_req(struct ufshpb_lu *hpb,
> >> > + struct ufshpb_req *umap_req,
> >> > + struct ufshpb_region *rgn)
> >> > +{
> >> > + struct request *req;
> >> > + struct scsi_request *rq;
> >> > +
> >> > + req = umap_req->req;
> >> > + req->timeout = 0;
> >> > + req->end_io_data = (void *)umap_req;
> >> > + rq = scsi_req(req);
> >> > + ufshpb_set_unmap_cmd(rq->cmd, rgn);
> >> > + rq->cmd_len = HPB_WRITE_BUFFER_CMD_LENGTH;
> >> > +
> >> > + blk_execute_rq_nowait(NULL, req, 1, ufshpb_umap_req_compl_fn);
> >> > +
> >> > + return 0;
> >> > +}
> >> > +
> >> > static int ufshpb_execute_map_req(struct ufshpb_lu *hpb,
> >> > struct ufshpb_req *map_req, bool last)
> >> > {
> >> > @@ -534,12 +869,12 @@ static int ufshpb_execute_map_req(struct
> >> > ufshpb_lu *hpb,
> >> >
> >> > 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],
> >> > + ret = bio_add_pc_page(q, map_req->bio, map_req->rb.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);
> >> > + map_req->rb.rgn_idx, map_req->rb.srgn_idx);
> >> > return ret;
> >> > }
> >> > }
> >> > @@ -555,8 +890,8 @@ static int ufshpb_execute_map_req(struct ufshpb_lu
> >> > *hpb,
> >> > if (unlikely(last))
> >> > mem_size = hpb->last_srgn_entries * HPB_ENTRY_SIZE;
> >> >
> >> > - ufshpb_set_read_buf_cmd(rq->cmd, map_req->rgn_idx,
> >> > - map_req->srgn_idx, mem_size);
> >> > + ufshpb_set_read_buf_cmd(rq->cmd, map_req->rb.rgn_idx,
> >> > + map_req->rb.srgn_idx, mem_size);
> >> > rq->cmd_len = HPB_READ_BUFFER_CMD_LENGTH;
> >> >
> >> > blk_execute_rq_nowait(NULL, req, 1, ufshpb_map_req_compl_fn);
> >> > @@ -688,6 +1023,31 @@ static void ufshpb_purge_active_subregion(struct
> >> > ufshpb_lu *hpb,
> >> > }
> >> > }
> >> >
> >> > +static int ufshpb_issue_umap_req(struct ufshpb_lu *hpb,
> >> > + struct ufshpb_region *rgn, bool atomic)
> >> > +{
> >> > + struct ufshpb_req *umap_req;
> >> > + int rgn_idx = rgn ? rgn->rgn_idx : 0;
> >> > +
> >> > + umap_req = ufshpb_get_req(hpb, rgn_idx, REQ_OP_SCSI_OUT, atomic);
> >> > + if (!umap_req)
> >> > + return -ENOMEM;
> >> > +
> >> > + if (ufshpb_execute_umap_req(hpb, umap_req, rgn))
> >> > + goto free_umap_req;
> >> > +
> >> > + return 0;
> >> > +
> >> > +free_umap_req:
> >> > + ufshpb_put_req(hpb, umap_req);
> >> > + return -EAGAIN;
> >> > +}
> >> > +
> >> > +static int ufshpb_issue_umap_all_req(struct ufshpb_lu *hpb)
> >> > +{
> >> > + return ufshpb_issue_umap_req(hpb, NULL, false);
> >> > +}
> >> > +
> >> > static void __ufshpb_evict_region(struct ufshpb_lu *hpb,
> >> > struct ufshpb_region *rgn)
> >> > {
> >> > @@ -1210,6 +1570,17 @@ static void ufshpb_lu_parameter_init(struct
> >> > ufs_hba *hba,
> >> > u32 entries_per_rgn;
> >> > u64 rgn_mem_size, tmp;
> >> >
> >> > + /* for pre_req */
> >> > + hpb->pre_req_min_tr_len = hpb_dev_info->max_hpb_single_cmd + 1;
> >> > +
> >> > + if (ufshpb_is_legacy(hba))
> >> > + hpb->pre_req_max_tr_len = HPB_LEGACY_CHUNK_HIGH;
> >> > + else
> >> > + hpb->pre_req_max_tr_len = max(HPB_MULTI_CHUNK_HIGH,
> >> > + hpb->pre_req_min_tr_len);
> >> > +
> >> > + hpb->cur_read_id = 0;
> >> > +
> >> > 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)
> >> > @@ -1357,7 +1728,7 @@ 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[] = {
> >> > +static struct attribute *hpb_dev_stat_attrs[] = {
> >> > &dev_attr_hit_cnt.attr,
> >> > &dev_attr_miss_cnt.attr,
> >> > &dev_attr_rb_noti_cnt.attr,
> >> > @@ -1368,10 +1739,118 @@ static struct attribute *hpb_dev_attrs[] = {
> >> > };
> >> >
> >> > struct attribute_group ufs_sysfs_hpb_stat_group = {
> >> > - .name = "hpb_sysfs",
> >> > - .attrs = hpb_dev_attrs,
> >> > + .name = "hpb_stat_sysfs",
> >> > + .attrs = hpb_dev_stat_attrs,
> >> > };
> >> >
> >> > +/* SYSFS functions */
> >> > +#define ufshpb_sysfs_param_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, "%d\n", hpb->params.__name); \
> >> > +}
> >> > +
> >> > +ufshpb_sysfs_param_show_func(requeue_timeout_ms);
> >> > +static ssize_t
> >> > +requeue_timeout_ms_store(struct device *dev, struct device_attribute
> >> > *attr,
> >> > + const char *buf, size_t count)
> >> > +{
> >> > + struct scsi_device *sdev = to_scsi_device(dev);
> >> > + struct ufshpb_lu *hpb = ufshpb_get_hpb_data(sdev);
> >> > + int val;
> >> > +
> >> > + if (!hpb)
> >> > + return -ENODEV;
> >> > +
> >> > + if (kstrtouint(buf, 0, &val))
> >> > + return -EINVAL;
> >> > +
> >> > + if (val < 0)
> >> > + return -EINVAL;
> >> > +
> >> > + hpb->params.requeue_timeout_ms = val;
> >> > +
> >> > + return count;
> >> > +}
> >> > +static DEVICE_ATTR_RW(requeue_timeout_ms);
> >> > +
> >> > +static struct attribute *hpb_dev_param_attrs[] = {
> >> > + &dev_attr_requeue_timeout_ms.attr,
> >> > + NULL,
> >> > +};
> >> > +
> >> > +struct attribute_group ufs_sysfs_hpb_param_group = {
> >> > + .name = "hpb_param_sysfs",
> >> > + .attrs = hpb_dev_param_attrs,
> >> > +};
> >> > +
> >> > +static int ufshpb_pre_req_mempool_init(struct ufshpb_lu *hpb)
> >> > +{
> >> > + struct ufshpb_req *pre_req = NULL, *t;
> >> > + int qd = hpb->sdev_ufs_lu->queue_depth / 2;
> >> > + int i;
> >> > +
> >> > + INIT_LIST_HEAD(&hpb->lh_pre_req_free);
> >> > +
> >> > + hpb->pre_req = kcalloc(qd, sizeof(struct ufshpb_req), GFP_KERNEL);
> >> > + hpb->throttle_pre_req = qd;
> >> > + hpb->num_inflight_pre_req = 0;
> >> > +
> >> > + if (!hpb->pre_req)
> >> > + goto release_mem;
> >> > +
> >> > + for (i = 0; i < qd; i++) {
> >> > + pre_req = hpb->pre_req + i;
> >> > + INIT_LIST_HEAD(&pre_req->list_req);
> >> > + pre_req->req = NULL;
> >> > +
> >> > + pre_req->bio = bio_alloc(GFP_KERNEL, 1);
> >> > + if (!pre_req->bio)
> >> > + goto release_mem;
> >> > +
> >> > + pre_req->wb.m_page = alloc_page(GFP_KERNEL | __GFP_ZERO);
> >> > + if (!pre_req->wb.m_page) {
> >> > + bio_put(pre_req->bio);
> >> > + goto release_mem;
> >> > + }
> >> > +
> >> > + list_add_tail(&pre_req->list_req, &hpb->lh_pre_req_free);
> >> > + }
> >> > +
> >> > + return 0;
> >> > +release_mem:
> >> > + list_for_each_entry_safe(pre_req, t, &hpb->lh_pre_req_free, list_req)
> >> > {
> >> > + list_del_init(&pre_req->list_req);
> >> > + bio_put(pre_req->bio);
> >> > + __free_page(pre_req->wb.m_page);
> >> > + }
> >> > +
> >> > + kfree(hpb->pre_req);
> >> > + return -ENOMEM;
> >> > +}
> >> > +
> >> > +static void ufshpb_pre_req_mempool_destroy(struct ufshpb_lu *hpb)
> >> > +{
> >> > + struct ufshpb_req *pre_req = NULL;
> >> > + int i;
> >> > +
> >> > + for (i = 0; i < hpb->throttle_pre_req; i++) {
> >> > + pre_req = hpb->pre_req + i;
> >> > + bio_put(hpb->pre_req[i].bio);
> >> > + if (!pre_req->wb.m_page)
> >> > + __free_page(hpb->pre_req[i].wb.m_page);
> >> > + list_del_init(&pre_req->list_req);
> >> > + }
> >> > +
> >> > + kfree(hpb->pre_req);
> >> > +}
> >> > +
> >> > static void ufshpb_stat_init(struct ufshpb_lu *hpb)
> >> > {
> >> > hpb->stats.hit_cnt = 0;
> >> > @@ -1382,6 +1861,11 @@ static void ufshpb_stat_init(struct ufshpb_lu
> >> > *hpb)
> >> > hpb->stats.map_req_cnt = 0;
> >> > }
> >> >
> >> > +static void ufshpb_param_init(struct ufshpb_lu *hpb)
> >> > +{
> >> > + hpb->params.requeue_timeout_ms = HPB_REQUEUE_TIME_MS;
> >> > +}
> >> > +
> >> > static int ufshpb_lu_hpb_init(struct ufs_hba *hba, struct ufshpb_lu
> >> > *hpb)
> >> > {
> >> > int ret;
> >> > @@ -1414,14 +1898,24 @@ static int ufshpb_lu_hpb_init(struct ufs_hba
> >> > *hba, struct ufshpb_lu *hpb)
> >> > goto release_req_cache;
> >> > }
> >> >
> >> > + ret = ufshpb_pre_req_mempool_init(hpb);
> >> > + if (ret) {
> >> > + dev_err(hba->dev, "ufshpb(%d) pre_req_mempool init fail",
> >> > + hpb->lun);
> >> > + goto release_m_page_cache;
> >> > + }
> >> > +
> >> > ret = ufshpb_alloc_region_tbl(hba, hpb);
> >> > if (ret)
> >> > - goto release_m_page_cache;
> >> > + goto release_pre_req_mempool;
> >> >
> >> > ufshpb_stat_init(hpb);
> >> > + ufshpb_param_init(hpb);
> >> >
> >> > return 0;
> >> >
> >> > +release_pre_req_mempool:
> >> > + ufshpb_pre_req_mempool_destroy(hpb);
> >> > release_m_page_cache:
> >> > kmem_cache_destroy(hpb->m_page_cache);
> >> > release_req_cache:
> >> > @@ -1430,7 +1924,7 @@ static int ufshpb_lu_hpb_init(struct ufs_hba
> >> > *hba, struct ufshpb_lu *hpb)
> >> > }
> >> >
> >> > static struct ufshpb_lu *
> >> > -ufshpb_alloc_hpb_lu(struct ufs_hba *hba, int lun,
> >> > +ufshpb_alloc_hpb_lu(struct ufs_hba *hba, struct scsi_device *sdev,
> >> > struct ufshpb_dev_info *hpb_dev_info,
> >> > struct ufshpb_lu_info *hpb_lu_info)
> >> > {
> >> > @@ -1441,7 +1935,8 @@ ufshpb_alloc_hpb_lu(struct ufs_hba *hba, int lun,
> >> > if (!hpb)
> >> > return NULL;
> >> >
> >> > - hpb->lun = lun;
> >> > + hpb->lun = sdev->lun;
> >> > + hpb->sdev_ufs_lu = sdev;
> >> >
> >> > ufshpb_lu_parameter_init(hba, hpb, hpb_dev_info, hpb_lu_info);
> >> >
> >> > @@ -1451,6 +1946,7 @@ ufshpb_alloc_hpb_lu(struct ufs_hba *hba, int lun,
> >> > goto release_hpb;
> >> > }
> >> >
> >> > + sdev->hostdata = hpb;
> >> > return hpb;
> >> >
> >> > release_hpb:
> >> > @@ -1653,6 +2149,7 @@ void ufshpb_destroy_lu(struct ufs_hba *hba,
> >> > struct scsi_device *sdev)
> >> >
> >> > ufshpb_cancel_jobs(hpb);
> >> >
> >> > + ufshpb_pre_req_mempool_destroy(hpb);
> >> > ufshpb_destroy_region_tbl(hpb);
> >> >
> >> > kmem_cache_destroy(hpb->map_req_cache);
> >> > @@ -1692,6 +2189,7 @@ static void ufshpb_hpb_lu_prepared(struct ufs_hba
> >> > *hba)
> >> > ufshpb_set_state(hpb, HPB_PRESENT);
> >> > if ((hpb->lu_pinned_end - hpb->lu_pinned_start) > 0)
> >> > queue_work(ufshpb_wq, &hpb->map_work);
> >> > + ufshpb_issue_umap_all_req(hpb);
> >> > } else {
> >> > dev_err(hba->dev, "destroy HPB lu %d\n", hpb->lun);
> >> > ufshpb_destroy_lu(hba, sdev);
> >> > @@ -1716,7 +2214,7 @@ void ufshpb_init_hpb_lu(struct ufs_hba *hba,
> >> > struct scsi_device *sdev)
> >> > if (ret)
> >> > goto out;
> >> >
> >> > - hpb = ufshpb_alloc_hpb_lu(hba, lun, &hba->ufshpb_dev,
> >> > + hpb = ufshpb_alloc_hpb_lu(hba, sdev, &hba->ufshpb_dev,
> >> > &hpb_lu_info);
> >> > if (!hpb)
> >> > goto out;
> >> > @@ -1724,9 +2222,6 @@ void ufshpb_init_hpb_lu(struct ufs_hba *hba,
> >> > struct scsi_device *sdev)
> >> > 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;
> >> > -
> >> > out:
> >> > /* All LUs are initialized */
> >> > if (atomic_dec_and_test(&hba->ufshpb_dev.slave_conf_cnt))
> >> > @@ -1813,8 +2308,9 @@ void ufshpb_get_geo_info(struct ufs_hba *hba, u8
> >> > *geo_buf)
> >> > void ufshpb_get_dev_info(struct ufs_hba *hba, u8 *desc_buf)
> >> > {
> >> > struct ufshpb_dev_info *hpb_dev_info = &hba->ufshpb_dev;
> >> > - int version;
> >> > + int version, ret;
> >> > u8 hpb_mode;
> >> > + u32 max_hpb_single_cmd = HPB_MULTI_CHUNK_LOW;
> >> >
> >> > hpb_mode = desc_buf[DEVICE_DESC_PARAM_HPB_CONTROL];
> >> > if (hpb_mode == HPB_HOST_CONTROL) {
> >> > @@ -1825,13 +2321,27 @@ void ufshpb_get_dev_info(struct ufs_hba *hba,
> >> > u8 *desc_buf)
> >> > }
> >> >
> >> > version = get_unaligned_be16(desc_buf + DEVICE_DESC_PARAM_HPB_VER);
> >> > - if (version != HPB_SUPPORT_VERSION) {
> >> > + if ((version != HPB_SUPPORT_VERSION) &&
> >> > + (version != HPB_SUPPORT_LEGACY_VERSION)) {
> >> > dev_err(hba->dev, "%s: HPB %x version is not supported.\n",
> >> > __func__, version);
> >> > hpb_dev_info->hpb_disabled = true;
> >> > return;
> >> > }
> >> >
> >> > + if (version == HPB_SUPPORT_LEGACY_VERSION)
> >> > + hpb_dev_info->is_legacy = true;
> >> > +
> >> > + pm_runtime_get_sync(hba->dev);
> >> > + ret = ufshcd_query_attr_retry(hba, UPIU_QUERY_OPCODE_READ_ATTR,
> >> > + QUERY_ATTR_IDN_MAX_HPB_SINGLE_CMD, 0, 0, &max_hpb_single_cmd);
> >> > + pm_runtime_put_sync(hba->dev);
> >> > +
> >> > + if (ret)
> >> > + dev_err(hba->dev, "%s: idn: read max size of single hpb cmd query
> >> > request failed",
> >> > + __func__);
> >> > + hpb_dev_info->max_hpb_single_cmd = max_hpb_single_cmd;
> >> > +
> >> > /*
> >> > * Get the number of user logical unit to check whether all
> >> > * scsi_device finish initialization
> >> > diff --git a/drivers/scsi/ufs/ufshpb.h b/drivers/scsi/ufs/ufshpb.h
> >> > index 6e6a0252dc15..b1128b0ce486 100644
> >> > --- a/drivers/scsi/ufs/ufshpb.h
> >> > +++ b/drivers/scsi/ufs/ufshpb.h
> >> > @@ -30,19 +30,29 @@
> >> > #define PINNED_NOT_SET U32_MAX
> >> >
> >> > /* hpb support chunk size */
> >> > -#define HPB_MULTI_CHUNK_HIGH 1
> >> > +#define HPB_LEGACY_CHUNK_HIGH 1
> >> > +#define HPB_MULTI_CHUNK_LOW 7
> >> > +#define HPB_MULTI_CHUNK_HIGH 128
> >> >
> >> > /* hpb vender defined opcode */
> >> > #define UFSHPB_READ 0xF8
> >> > #define UFSHPB_READ_BUFFER 0xF9
> >> > #define UFSHPB_READ_BUFFER_ID 0x01
> >> > +#define UFSHPB_WRITE_BUFFER 0xFA
> >> > +#define UFSHPB_WRITE_BUFFER_INACT_SINGLE_ID 0x01
> >> > +#define UFSHPB_WRITE_BUFFER_PREFETCH_ID 0x02
> >> > +#define UFSHPB_WRITE_BUFFER_INACT_ALL_ID 0x03
> >> > +#define HPB_WRITE_BUFFER_CMD_LENGTH 10
> >> > +#define MAX_HPB_READ_ID 0x7F
> >> > #define HPB_READ_BUFFER_CMD_LENGTH 10
> >> > #define LU_ENABLED_HPB_FUNC 0x02
> >> >
> >> > #define HPB_RESET_REQ_RETRIES 10
> >> > #define HPB_MAP_REQ_RETRIES 5
> >> > +#define HPB_REQUEUE_TIME_MS 0
> >> >
> >> > -#define HPB_SUPPORT_VERSION 0x100
> >> > +#define HPB_SUPPORT_VERSION 0x200
> >> > +#define HPB_SUPPORT_LEGACY_VERSION 0x100
> >> >
> >> > enum UFSHPB_MODE {
> >> > HPB_HOST_CONTROL,
> >> > @@ -119,23 +129,38 @@ struct ufshpb_region {
> >> > (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
> >> > + * struct ufshpb_req - HPB related request structure (write/read
> >> > buffer)
> >> > + * @req: block layer request structure
> >> > + * @bio: bio for this request
> >> > + * @hpb: ufshpb_lu structure that related to
> >> > + * @list_req: ufshpb_req mempool list
> >> > + * @sense: store its sense data
> >> > * @mctx: L2P map information
> >> > * @rgn_idx: target region index
> >> > * @srgn_idx: target sub-region index
> >> > * @lun: target logical unit number
> >> > + * @m_page: L2P map information data for pre-request
> >> > + * @len: length of host-side cached L2P map in m_page
> >> > + * @lpn: start LPN of L2P map in m_page
> >> > */
> >> > 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 list_head list_req;
> >> > + union {
> >> > + struct {
> >> > + struct ufshpb_map_ctx *mctx;
> >> > + unsigned int rgn_idx;
> >> > + unsigned int srgn_idx;
> >> > + unsigned int lun;
> >> > + } rb;
> >> > + struct {
> >> > + struct page *m_page;
> >> > + unsigned int len;
> >> > + unsigned long lpn;
> >> > + } wb;
> >> > + };
> >> > };
> >> >
> >> > struct victim_select_info {
> >> > @@ -144,6 +169,10 @@ struct victim_select_info {
> >> > atomic_t active_cnt;
> >> > };
> >> >
> >> > +struct ufshpb_params {
> >> > + unsigned int requeue_timeout_ms;
> >> > +};
> >> > +
> >> > struct ufshpb_stats {
> >> > u64 hit_cnt;
> >> > u64 miss_cnt;
> >> > @@ -151,6 +180,7 @@ struct ufshpb_stats {
> >> > u64 rb_active_cnt;
> >> > u64 rb_inactive_cnt;
> >> > u64 map_req_cnt;
> >> > + u64 pre_req_cnt;
> >> > };
> >> >
> >> > struct ufshpb_lu {
> >> > @@ -166,6 +196,15 @@ struct ufshpb_lu {
> >> > struct list_head lh_act_srgn; /* hold rsp_list_lock */
> >> > struct list_head lh_inact_rgn; /* hold rsp_list_lock */
> >> >
> >> > + /* pre request information */
> >> > + struct ufshpb_req *pre_req;
> >> > + int num_inflight_pre_req;
> >> > + int throttle_pre_req;
> >> > + struct list_head lh_pre_req_free;
> >> > + int cur_read_id;
> >> > + int pre_req_min_tr_len;
> >> > + int pre_req_max_tr_len;
> >> > +
> >> > /* cached L2P map management worker */
> >> > struct work_struct map_work;
> >> >
> >> > @@ -190,6 +229,7 @@ struct ufshpb_lu {
> >> > u32 pages_per_srgn;
> >> >
> >> > struct ufshpb_stats stats;
> >> > + struct ufshpb_params params;
> >> >
> >> > struct kmem_cache *map_req_cache;
> >> > struct kmem_cache *m_page_cache;
> >> > @@ -201,7 +241,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 int ufshpb_prep(struct ufs_hba *hba, struct ufshcd_lrb *lrbp)
> >> > { return 0; }
> >> > 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) {}
> >> > @@ -214,8 +254,9 @@ 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) {}
> >> > +static bool ufshpb_is_legacy(struct ufs_hba *hba) { return false; }
> >> > #else
> >> > -void ufshpb_prep(struct ufs_hba *hba, struct ufshcd_lrb *lrbp);
> >> > +int 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);
> >> > @@ -228,7 +269,9 @@ 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);
> >> > +bool ufshpb_is_legacy(struct ufs_hba *hba);
> >> > extern struct attribute_group ufs_sysfs_hpb_stat_group;
> >> > +extern struct attribute_group ufs_sysfs_hpb_param_group;
> >> > #endif
> >> >
> >> > #endif /* End of Header */
> >>
> >>
> >>
>
>
>
^ permalink raw reply [flat|nested] 26+ messages in thread* Re: [PATCH v31 4/4] scsi: ufs: Add HPB 2.0 support
2021-03-26 2:55 ` Daejun Park
@ 2021-03-26 3:15 ` Bart Van Assche
0 siblings, 0 replies; 26+ messages in thread
From: Bart Van Assche @ 2021-03-26 3:15 UTC (permalink / raw)
To: daejun7.park, Can Guo
Cc: Greg KH, avri.altman@wdc.com, jejb@linux.ibm.com,
martin.petersen@oracle.com, asutoshd@codeaurora.org,
stanley.chu@mediatek.com, huobean@gmail.com,
linux-scsi@vger.kernel.org, linux-kernel@vger.kernel.org,
ALIM AKHTAR, JinHwan Park, Javier Gonzalez, Sung-Jun Park,
Jinyoung CHOI, Dukhyun Kwon, Keoseong Park, Jaemyung Lee,
Jieon Seol
On 3/25/21 7:55 PM, Daejun Park wrote:
>> Please address it in next version. After that, I will give my
>> reviewed-by tag.
>
> OK, I will do.
Hi,
Please trim emails when replying. Otherwise it is very hard to follow a
conversation. It took me plenty of scrolling to find the above reply.
Thanks,
Bart.
^ permalink raw reply [flat|nested] 26+ messages in thread