iv/linux
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

scsi: ufs: host: Rename structure ufs_dev_params to ufs_host_params

Browse Source 
Structure ufs_dev_params is actually used in UFS host drivers to declare
host specific power mode parameters, like ufs_<vendor>_params or host_cap,
which makes the code not very straightforward to read. Rename the structure
ufs_dev_params to ufs_host_params and unify the declarations in all drivers
to host_params.

In addition, rename the two functions ufshcd_init_pwr_dev_param() and
ufshcd_get_pwr_dev_param() which work based on the ufs_host_params to
ufshcd_init_host_params() and ufshcd_negotiate_pwr_params() respectively to
avoid confusions.

This change does not change any functionalities or logic.

Acked-by: Andrew Halaney <ahalaney@redhat.com>
Reviewed-by: Nitin Rawat <quic_nitirawa@quicinc.com>
Reviewed-by: Manivannan Sadhasivam <manivannan.sadhasivam@linaro.org>
Reviewed-by: Bart Van Assche <bvanassche@acm.org>
Signed-off-by: Can Guo <quic_cang@quicinc.com>
Link: https://lore.kernel.org/r/1701520577-31163-2-git-send-email-quic_cang@quicinc.com
Reviewed-by: Peter Wang <peter.wang@mediatek.com>
Tested-by: Neil Armstrong <neil.armstrong@linaro.org> # on SM8550-QRD
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
This commit is contained in:
Can Guo 2023-12-02 04:36:07 -08:00 committed by Martin K. Petersen
parent b85ea95d08
commit fa3dca8251
6 changed files with 57 additions and 64 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
drivers/ufs/host/ufs-exynos.c
View File

@ -765,7 +765,7 @@ static int exynos_ufs_pre_pwr_mode(struct ufs_hba *hba,
{ {
struct exynos_ufs *ufs = ufshcd_get_variant(hba); struct exynos_ufs *ufs = ufshcd_get_variant(hba);
struct phy *generic_phy = ufs->phy; struct phy *generic_phy = ufs->phy;
struct ufs_dev_params ufs_exynos_cap; struct ufs_host_params host_params;
int ret; int ret;
if (!dev_req_params) { if (!dev_req_params) {
@ -774,10 +774,9 @@ static int exynos_ufs_pre_pwr_mode(struct ufs_hba *hba,
goto out; goto out;
} }
ufshcd_init_pwr_dev_param(&ufs_exynos_cap); ufshcd_init_host_params(&host_params);
ret = ufshcd_get_pwr_dev_param(&ufs_exynos_cap, ret = ufshcd_negotiate_pwr_params(&host_params, dev_max_params, dev_req_params);
dev_max_params, dev_req_params);
if (ret) { if (ret) {
pr_err("%s: failed to determine capabilities\n", __func__); pr_err("%s: failed to determine capabilities\n", __func__);
goto out; goto out;

11
drivers/ufs/host/ufs-hisi.c
View File

@ -293,9 +293,9 @@ static int ufs_hisi_link_startup_notify(struct ufs_hba *hba,
return err; return err;
} }
static void ufs_hisi_set_dev_cap(struct ufs_dev_params *hisi_param) static void ufs_hisi_set_dev_cap(struct ufs_host_params *host_params)
{ {
ufshcd_init_pwr_dev_param(hisi_param); ufshcd_init_host_params(host_params);
} }
static void ufs_hisi_pwr_change_pre_change(struct ufs_hba *hba) static void ufs_hisi_pwr_change_pre_change(struct ufs_hba *hba)
@ -365,7 +365,7 @@ static int ufs_hisi_pwr_change_notify(struct ufs_hba *hba,
struct ufs_pa_layer_attr *dev_max_params, struct ufs_pa_layer_attr *dev_max_params,
struct ufs_pa_layer_attr *dev_req_params) struct ufs_pa_layer_attr *dev_req_params)
{ {
struct ufs_dev_params ufs_hisi_cap; struct ufs_host_params host_params;
int ret = 0; int ret = 0;
if (!dev_req_params) { if (!dev_req_params) {
@ -377,9 +377,8 @@ static int ufs_hisi_pwr_change_notify(struct ufs_hba *hba,
switch (status) { switch (status) {
case PRE_CHANGE: case PRE_CHANGE:
ufs_hisi_set_dev_cap(&ufs_hisi_cap); ufs_hisi_set_dev_cap(&host_params);
ret = ufshcd_get_pwr_dev_param(&ufs_hisi_cap, ret = ufshcd_negotiate_pwr_params(&host_params, dev_max_params, dev_req_params);
dev_max_params, dev_req_params);
if (ret) { if (ret) {
dev_err(hba->dev, dev_err(hba->dev,
"%s: failed to determine capabilities\n", __func__); "%s: failed to determine capabilities\n", __func__);

12
drivers/ufs/host/ufs-mediatek.c
View File

@ -996,16 +996,14 @@ static int ufs_mtk_pre_pwr_change(struct ufs_hba *hba,
struct ufs_pa_layer_attr *dev_req_params) struct ufs_pa_layer_attr *dev_req_params)
{ {
struct ufs_mtk_host *host = ufshcd_get_variant(hba); struct ufs_mtk_host *host = ufshcd_get_variant(hba);
struct ufs_dev_params host_cap; struct ufs_host_params host_params;
int ret; int ret;
ufshcd_init_pwr_dev_param(&host_cap); ufshcd_init_host_params(&host_params);
host_cap.hs_rx_gear = UFS_HS_G5; host_params.hs_rx_gear = UFS_HS_G5;
host_cap.hs_tx_gear = UFS_HS_G5; host_params.hs_tx_gear = UFS_HS_G5;
ret = ufshcd_get_pwr_dev_param(&host_cap, ret = ufshcd_negotiate_pwr_params(&host_params, dev_max_params, dev_req_params);
dev_max_params,
dev_req_params);
if (ret) { if (ret) {
pr_info("%s: failed to determine capabilities\n", pr_info("%s: failed to determine capabilities\n",
__func__); __func__);

12
drivers/ufs/host/ufs-qcom.c
View File

@ -898,7 +898,7 @@ static int ufs_qcom_pwr_change_notify(struct ufs_hba *hba,
struct ufs_pa_layer_attr *dev_req_params) struct ufs_pa_layer_attr *dev_req_params)
{ {
struct ufs_qcom_host *host = ufshcd_get_variant(hba); struct ufs_qcom_host *host = ufshcd_get_variant(hba);
struct ufs_dev_params ufs_qcom_cap; struct ufs_host_params host_params;
int ret = 0; int ret = 0;
if (!dev_req_params) { if (!dev_req_params) {
@ -908,15 +908,13 @@ static int ufs_qcom_pwr_change_notify(struct ufs_hba *hba,
switch (status) { switch (status) {
case PRE_CHANGE: case PRE_CHANGE:
ufshcd_init_pwr_dev_param(&ufs_qcom_cap); ufshcd_init_host_params(&host_params);
ufs_qcom_cap.hs_rate = UFS_QCOM_LIMIT_HS_RATE; host_params.hs_rate = UFS_QCOM_LIMIT_HS_RATE;
/* This driver only supports symmetic gear setting i.e., hs_tx_gear == hs_rx_gear */ /* This driver only supports symmetic gear setting i.e., hs_tx_gear == hs_rx_gear */
ufs_qcom_cap.hs_tx_gear = ufs_qcom_cap.hs_rx_gear = ufs_qcom_get_hs_gear(hba); host_params.hs_tx_gear = host_params.hs_rx_gear = ufs_qcom_get_hs_gear(hba);
ret = ufshcd_get_pwr_dev_param(&ufs_qcom_cap, ret = ufshcd_negotiate_pwr_params(&host_params, dev_max_params, dev_req_params);
dev_max_params,
dev_req_params);
if (ret) { if (ret) {
dev_err(hba->dev, "%s: failed to determine capabilities\n", dev_err(hba->dev, "%s: failed to determine capabilities\n",
__func__); __func__);

69
drivers/ufs/host/ufshcd-pltfrm.c
View File

@ -285,61 +285,60 @@ static int ufshcd_parse_operating_points(struct ufs_hba *hba)
} }
/** /**
* ufshcd_get_pwr_dev_param - get finally agreed attributes for * ufshcd_negotiate_pwr_params - find power mode settings that are supported by
* power mode change both the controller and the device
* @pltfrm_param: pointer to platform parameters * @host_params: pointer to host parameters
* @dev_max: pointer to device attributes * @dev_max: pointer to device attributes
* @agreed_pwr: returned agreed attributes * @agreed_pwr: returned agreed attributes
* *
* Return: 0 on success, non-zero value on failure. * Return: 0 on success, non-zero value on failure.
*/ */
int ufshcd_get_pwr_dev_param(const struct ufs_dev_params *pltfrm_param, int ufshcd_negotiate_pwr_params(const struct ufs_host_params *host_params,
const struct ufs_pa_layer_attr *dev_max, const struct ufs_pa_layer_attr *dev_max,
struct ufs_pa_layer_attr *agreed_pwr) struct ufs_pa_layer_attr *agreed_pwr)
{ {
int min_pltfrm_gear; int min_host_gear;
int min_dev_gear; int min_dev_gear;
bool is_dev_sup_hs = false; bool is_dev_sup_hs = false;
bool is_pltfrm_max_hs = false; bool is_host_max_hs = false;
if (dev_max->pwr_rx == FAST_MODE) if (dev_max->pwr_rx == FAST_MODE)
is_dev_sup_hs = true; is_dev_sup_hs = true;
if (pltfrm_param->desired_working_mode == UFS_HS_MODE) { if (host_params->desired_working_mode == UFS_HS_MODE) {
is_pltfrm_max_hs = true; is_host_max_hs = true;
min_pltfrm_gear = min_t(u32, pltfrm_param->hs_rx_gear, min_host_gear = min_t(u32, host_params->hs_rx_gear,
pltfrm_param->hs_tx_gear); host_params->hs_tx_gear);
} else { } else {
min_pltfrm_gear = min_t(u32, pltfrm_param->pwm_rx_gear, min_host_gear = min_t(u32, host_params->pwm_rx_gear,
pltfrm_param->pwm_tx_gear); host_params->pwm_tx_gear);
} }
/* /*
* device doesn't support HS but * device doesn't support HS but host_params->desired_working_mode is HS,
* pltfrm_param->desired_working_mode is HS, * thus device and host_params don't agree
* thus device and pltfrm_param don't agree
*/ */
if (!is_dev_sup_hs && is_pltfrm_max_hs) { if (!is_dev_sup_hs && is_host_max_hs) {
pr_info("%s: device doesn't support HS\n", pr_info("%s: device doesn't support HS\n",
__func__); __func__);
return -ENOTSUPP; return -ENOTSUPP;
} else if (is_dev_sup_hs && is_pltfrm_max_hs) { } else if (is_dev_sup_hs && is_host_max_hs) {
/* /*
* since device supports HS, it supports FAST_MODE. * since device supports HS, it supports FAST_MODE.
* since pltfrm_param->desired_working_mode is also HS * since host_params->desired_working_mode is also HS
* then final decision (FAST/FASTAUTO) is done according * then final decision (FAST/FASTAUTO) is done according
* to pltfrm_params as it is the restricting factor * to pltfrm_params as it is the restricting factor
*/ */
agreed_pwr->pwr_rx = pltfrm_param->rx_pwr_hs; agreed_pwr->pwr_rx = host_params->rx_pwr_hs;
agreed_pwr->pwr_tx = agreed_pwr->pwr_rx; agreed_pwr->pwr_tx = agreed_pwr->pwr_rx;
} else { } else {
/* /*
* here pltfrm_param->desired_working_mode is PWM. * here host_params->desired_working_mode is PWM.
* it doesn't matter whether device supports HS or PWM, * it doesn't matter whether device supports HS or PWM,
* in both cases pltfrm_param->desired_working_mode will * in both cases host_params->desired_working_mode will
* determine the mode * determine the mode
*/ */
agreed_pwr->pwr_rx = pltfrm_param->rx_pwr_pwm; agreed_pwr->pwr_rx = host_params->rx_pwr_pwm;
agreed_pwr->pwr_tx = agreed_pwr->pwr_rx; agreed_pwr->pwr_tx = agreed_pwr->pwr_rx;
} }
@ -349,9 +348,9 @@ int ufshcd_get_pwr_dev_param(const struct ufs_dev_params *pltfrm_param,
* the same decision will be made for rx * the same decision will be made for rx
*/ */
agreed_pwr->lane_tx = min_t(u32, dev_max->lane_tx, agreed_pwr->lane_tx = min_t(u32, dev_max->lane_tx,
pltfrm_param->tx_lanes); host_params->tx_lanes);
agreed_pwr->lane_rx = min_t(u32, dev_max->lane_rx, agreed_pwr->lane_rx = min_t(u32, dev_max->lane_rx,
pltfrm_param->rx_lanes); host_params->rx_lanes);
/* device maximum gear is the minimum between device rx and tx gears */ /* device maximum gear is the minimum between device rx and tx gears */
min_dev_gear = min_t(u32, dev_max->gear_rx, dev_max->gear_tx); min_dev_gear = min_t(u32, dev_max->gear_rx, dev_max->gear_tx);
@ -364,26 +363,26 @@ int ufshcd_get_pwr_dev_param(const struct ufs_dev_params *pltfrm_param,
* what is the gear, as it is the one that also decided previously what * what is the gear, as it is the one that also decided previously what
* pwr the device will be configured to. * pwr the device will be configured to.
*/ */
if ((is_dev_sup_hs && is_pltfrm_max_hs) || if ((is_dev_sup_hs && is_host_max_hs) ||
(!is_dev_sup_hs && !is_pltfrm_max_hs)) { (!is_dev_sup_hs && !is_host_max_hs)) {
agreed_pwr->gear_rx = agreed_pwr->gear_rx =
min_t(u32, min_dev_gear, min_pltfrm_gear); min_t(u32, min_dev_gear, min_host_gear);
} else if (!is_dev_sup_hs) { } else if (!is_dev_sup_hs) {
agreed_pwr->gear_rx = min_dev_gear; agreed_pwr->gear_rx = min_dev_gear;
} else { } else {
agreed_pwr->gear_rx = min_pltfrm_gear; agreed_pwr->gear_rx = min_host_gear;
} }
agreed_pwr->gear_tx = agreed_pwr->gear_rx; agreed_pwr->gear_tx = agreed_pwr->gear_rx;
agreed_pwr->hs_rate = pltfrm_param->hs_rate; agreed_pwr->hs_rate = host_params->hs_rate;
return 0; return 0;
} }
EXPORT_SYMBOL_GPL(ufshcd_get_pwr_dev_param); EXPORT_SYMBOL_GPL(ufshcd_negotiate_pwr_params);
void ufshcd_init_pwr_dev_param(struct ufs_dev_params *dev_param) void ufshcd_init_host_params(struct ufs_host_params *host_params)
{ {
*dev_param = (struct ufs_dev_params){ *host_params = (struct ufs_host_params){
.tx_lanes = UFS_LANE_2, .tx_lanes = UFS_LANE_2,
.rx_lanes = UFS_LANE_2, .rx_lanes = UFS_LANE_2,
.hs_rx_gear = UFS_HS_G3, .hs_rx_gear = UFS_HS_G3,
@ -398,7 +397,7 @@ void ufshcd_init_pwr_dev_param(struct ufs_dev_params *dev_param)
.desired_working_mode = UFS_HS_MODE, .desired_working_mode = UFS_HS_MODE,
}; };
} }
EXPORT_SYMBOL_GPL(ufshcd_init_pwr_dev_param); EXPORT_SYMBOL_GPL(ufshcd_init_host_params);
/** /**
* ufshcd_pltfrm_init - probe routine of the driver * ufshcd_pltfrm_init - probe routine of the driver

10
drivers/ufs/host/ufshcd-pltfrm.h
View File

@ -10,7 +10,7 @@
#define UFS_PWM_MODE 1 #define UFS_PWM_MODE 1
#define UFS_HS_MODE 2 #define UFS_HS_MODE 2
struct ufs_dev_params { struct ufs_host_params {
u32 pwm_rx_gear; /* pwm rx gear to work in */ u32 pwm_rx_gear; /* pwm rx gear to work in */
u32 pwm_tx_gear; /* pwm tx gear to work in */ u32 pwm_tx_gear; /* pwm tx gear to work in */
u32 hs_rx_gear; /* hs rx gear to work in */ u32 hs_rx_gear; /* hs rx gear to work in */
@ -25,10 +25,10 @@ struct ufs_dev_params {
u32 desired_working_mode; u32 desired_working_mode;
}; };
int ufshcd_get_pwr_dev_param(const struct ufs_dev_params *dev_param, int ufshcd_negotiate_pwr_params(const struct ufs_host_params *host_params,
const struct ufs_pa_layer_attr *dev_max, const struct ufs_pa_layer_attr *dev_max,
struct ufs_pa_layer_attr *agreed_pwr); struct ufs_pa_layer_attr *agreed_pwr);
void ufshcd_init_pwr_dev_param(struct ufs_dev_params *dev_param); void ufshcd_init_host_params(struct ufs_host_params *host_params);
int ufshcd_pltfrm_init(struct platform_device *pdev, int ufshcd_pltfrm_init(struct platform_device *pdev,
const struct ufs_hba_variant_ops *vops); const struct ufs_hba_variant_ops *vops);
int ufshcd_populate_vreg(struct device *dev, const char *name, int ufshcd_populate_vreg(struct device *dev, const char *name,