Skip to content

Commit e0a5e2b

Browse files
kmaincentPaolo Abeni
kmaincent
authored and
Paolo Abeni
committed
net: pse-pd: Use power limit at driver side instead of current limit
The regulator framework uses current limits, but the PSE standard and known PSE controllers rely on power limits. Instead of converting current to power within each driver, perform the conversion in the PSE core. This avoids redundancy in driver implementation and aligns better with the standard, simplifying driver development. Remove at the same time the _pse_ethtool_get_status() function which is not needed anymore. Acked-by: Oleksij Rempel <o.rempel@pengutronix.de> Signed-off-by: Kory Maincent <kory.maincent@bootlin.com> Signed-off-by: Paolo Abeni <pabeni@redhat.com>
1 parent f3cb3c7 commit e0a5e2b

3 files changed

Lines changed: 57 additions & 95 deletions

File tree

‎drivers/net/pse-pd/pd692x0.c‎

Lines changed: 10 additions & 35 deletions
Original file line numberDiff line numberDiff line change
@@ -999,62 +999,37 @@ static int pd692x0_pi_get_voltage(struct pse_controller_dev *pcdev, int id)
999999
return (buf.sub[0] << 8 | buf.sub[1]) * 100000;
10001000
}
10011001

1002-
static int pd692x0_pi_get_current_limit(struct pse_controller_dev *pcdev,
1003-
int id)
1002+
static int pd692x0_pi_get_pw_limit(struct pse_controller_dev *pcdev,
1003+
int id)
10041004
{
10051005
struct pd692x0_priv *priv = to_pd692x0_priv(pcdev);
10061006
struct pd692x0_msg msg, buf = {0};
1007-
int mW, uV, uA, ret;
1008-
s64 tmp_64;
1007+
int ret;
10091008

10101009
msg = pd692x0_msg_template_list[PD692X0_MSG_GET_PORT_PARAM];
10111010
msg.sub[2] = id;
10121011
ret = pd692x0_sendrecv_msg(priv, &msg, &buf);
10131012
if (ret < 0)
10141013
return ret;
10151014

1016-
ret = pd692x0_pi_get_pw_from_table(buf.data[2], buf.data[3]);
1017-
if (ret < 0)
1018-
return ret;
1019-
mW = ret;
1020-
1021-
ret = pd692x0_pi_get_voltage(pcdev, id);
1022-
if (ret < 0)
1023-
return ret;
1024-
uV = ret;
1025-
1026-
tmp_64 = mW;
1027-
tmp_64 *= 1000000000ull;
1028-
/* uA = mW * 1000000000 / uV */
1029-
uA = DIV_ROUND_CLOSEST_ULL(tmp_64, uV);
1030-
return uA;
1015+
return pd692x0_pi_get_pw_from_table(buf.data[2], buf.data[3]);
10311016
}
10321017

1033-
static int pd692x0_pi_set_current_limit(struct pse_controller_dev *pcdev,
1034-
int id, int max_uA)
1018+
static int pd692x0_pi_set_pw_limit(struct pse_controller_dev *pcdev,
1019+
int id, int max_mW)
10351020
{
10361021
struct pd692x0_priv *priv = to_pd692x0_priv(pcdev);
10371022
struct device *dev = &priv->client->dev;
10381023
struct pd692x0_msg msg, buf = {0};
1039-
int uV, ret, mW;
1040-
s64 tmp_64;
1024+
int ret;
10411025

10421026
ret = pd692x0_fw_unavailable(priv);
10431027
if (ret)
10441028
return ret;
10451029

1046-
ret = pd692x0_pi_get_voltage(pcdev, id);
1047-
if (ret < 0)
1048-
return ret;
1049-
uV = ret;
1050-
10511030
msg = pd692x0_msg_template_list[PD692X0_MSG_SET_PORT_PARAM];
10521031
msg.sub[2] = id;
1053-
tmp_64 = uV;
1054-
tmp_64 *= max_uA;
1055-
/* mW = uV * uA / 1000000000 */
1056-
mW = DIV_ROUND_CLOSEST_ULL(tmp_64, 1000000000);
1057-
ret = pd692x0_pi_set_pw_from_table(dev, &msg, mW);
1032+
ret = pd692x0_pi_set_pw_from_table(dev, &msg, max_mW);
10581033
if (ret)
10591034
return ret;
10601035

@@ -1068,8 +1043,8 @@ static const struct pse_controller_ops pd692x0_ops = {
10681043
.pi_disable = pd692x0_pi_disable,
10691044
.pi_is_enabled = pd692x0_pi_is_enabled,
10701045
.pi_get_voltage = pd692x0_pi_get_voltage,
1071-
.pi_get_current_limit = pd692x0_pi_get_current_limit,
1072-
.pi_set_current_limit = pd692x0_pi_set_current_limit,
1046+
.pi_get_pw_limit = pd692x0_pi_get_pw_limit,
1047+
.pi_set_pw_limit = pd692x0_pi_set_pw_limit,
10731048
};
10741049

10751050
#define PD692X0_FW_LINE_MAX_SZ 0xff

‎drivers/net/pse-pd/pse_core.c‎

Lines changed: 41 additions & 50 deletions
Original file line numberDiff line numberDiff line change
@@ -291,33 +291,25 @@ static int pse_pi_get_voltage(struct regulator_dev *rdev)
291291
return ret;
292292
}
293293

294-
static int _pse_ethtool_get_status(struct pse_controller_dev *pcdev,
295-
int id,
296-
struct netlink_ext_ack *extack,
297-
struct pse_control_status *status);
298-
299294
static int pse_pi_get_current_limit(struct regulator_dev *rdev)
300295
{
301296
struct pse_controller_dev *pcdev = rdev_get_drvdata(rdev);
302297
const struct pse_controller_ops *ops;
303-
struct netlink_ext_ack extack = {};
304-
struct pse_control_status st = {};
305-
int id, uV, ret;
298+
int id, uV, mW, ret;
306299
s64 tmp_64;
307300

308301
ops = pcdev->ops;
309302
id = rdev_get_id(rdev);
303+
if (!ops->pi_get_pw_limit || !ops->pi_get_voltage)
304+
return -EOPNOTSUPP;
305+
310306
mutex_lock(&pcdev->lock);
311-
if (ops->pi_get_current_limit) {
312-
ret = ops->pi_get_current_limit(pcdev, id);
307+
ret = ops->pi_get_pw_limit(pcdev, id);
308+
if (ret < 0)
313309
goto out;
314-
}
310+
mW = ret;
315311

316-
/* If pi_get_current_limit() callback not populated get voltage
317-
* from pi_get_voltage() and power limit from ethtool_get_status()
318-
* to calculate current limit.
319-
*/
320-
ret = _pse_pi_get_voltage(rdev);
312+
ret = pse_pi_get_voltage(rdev);
321313
if (!ret) {
322314
dev_err(pcdev->dev, "Voltage null\n");
323315
ret = -ERANGE;
@@ -327,16 +319,7 @@ static int pse_pi_get_current_limit(struct regulator_dev *rdev)
327319
goto out;
328320
uV = ret;
329321

330-
ret = _pse_ethtool_get_status(pcdev, id, &extack, &st);
331-
if (ret)
332-
goto out;
333-
334-
if (!st.c33_avail_pw_limit) {
335-
ret = -ENODATA;
336-
goto out;
337-
}
338-
339-
tmp_64 = st.c33_avail_pw_limit;
322+
tmp_64 = mW;
340323
tmp_64 *= 1000000000ull;
341324
/* uA = mW * 1000000000 / uV */
342325
ret = DIV_ROUND_CLOSEST_ULL(tmp_64, uV);
@@ -351,18 +334,33 @@ static int pse_pi_set_current_limit(struct regulator_dev *rdev, int min_uA,
351334
{
352335
struct pse_controller_dev *pcdev = rdev_get_drvdata(rdev);
353336
const struct pse_controller_ops *ops;
354-
int id, ret;
337+
int id, mW, ret;
338+
s64 tmp_64;
355339

356340
ops = pcdev->ops;
357-
if (!ops->pi_set_current_limit)
341+
if (!ops->pi_set_pw_limit || !ops->pi_get_voltage)
358342
return -EOPNOTSUPP;
359343

360344
if (max_uA > MAX_PI_CURRENT)
361345
return -ERANGE;
362346

363347
id = rdev_get_id(rdev);
364348
mutex_lock(&pcdev->lock);
365-
ret = ops->pi_set_current_limit(pcdev, id, max_uA);
349+
ret = pse_pi_get_voltage(rdev);
350+
if (!ret) {
351+
dev_err(pcdev->dev, "Voltage null\n");
352+
ret = -ERANGE;
353+
goto out;
354+
}
355+
if (ret < 0)
356+
goto out;
357+
358+
tmp_64 = ret;
359+
tmp_64 *= max_uA;
360+
/* mW = uA * uV / 1000000000 */
361+
mW = DIV_ROUND_CLOSEST_ULL(tmp_64, 1000000000);
362+
ret = ops->pi_set_pw_limit(pcdev, id, mW);
363+
out:
366364
mutex_unlock(&pcdev->lock);
367365

368366
return ret;
@@ -406,7 +404,7 @@ devm_pse_pi_regulator_register(struct pse_controller_dev *pcdev,
406404

407405
rinit_data->constraints.valid_ops_mask = REGULATOR_CHANGE_STATUS;
408406

409-
if (pcdev->ops->pi_set_current_limit)
407+
if (pcdev->ops->pi_set_pw_limit)
410408
rinit_data->constraints.valid_ops_mask |=
411409
REGULATOR_CHANGE_CURRENT;
412410

@@ -737,23 +735,6 @@ struct pse_control *of_pse_control_get(struct device_node *node)
737735
}
738736
EXPORT_SYMBOL_GPL(of_pse_control_get);
739737

740-
static int _pse_ethtool_get_status(struct pse_controller_dev *pcdev,
741-
int id,
742-
struct netlink_ext_ack *extack,
743-
struct pse_control_status *status)
744-
{
745-
const struct pse_controller_ops *ops;
746-
747-
ops = pcdev->ops;
748-
if (!ops->ethtool_get_status) {
749-
NL_SET_ERR_MSG(extack,
750-
"PSE driver does not support status report");
751-
return -EOPNOTSUPP;
752-
}
753-
754-
return ops->ethtool_get_status(pcdev, id, extack, status);
755-
}
756-
757738
/**
758739
* pse_ethtool_get_status - get status of PSE control
759740
* @psec: PSE control pointer
@@ -766,11 +747,21 @@ int pse_ethtool_get_status(struct pse_control *psec,
766747
struct netlink_ext_ack *extack,
767748
struct pse_control_status *status)
768749
{
750+
const struct pse_controller_ops *ops;
751+
struct pse_controller_dev *pcdev;
769752
int err;
770753

771-
mutex_lock(&psec->pcdev->lock);
772-
err = _pse_ethtool_get_status(psec->pcdev, psec->id, extack, status);
773-
mutex_unlock(&psec->pcdev->lock);
754+
pcdev = psec->pcdev;
755+
ops = pcdev->ops;
756+
if (!ops->ethtool_get_status) {
757+
NL_SET_ERR_MSG(extack,
758+
"PSE driver does not support status report");
759+
return -EOPNOTSUPP;
760+
}
761+
762+
mutex_lock(&pcdev->lock);
763+
err = ops->ethtool_get_status(pcdev, psec->id, extack, status);
764+
mutex_unlock(&pcdev->lock);
774765

775766
return err;
776767
}

‎include/linux/pse-pd/pse.h‎

Lines changed: 6 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -77,12 +77,8 @@ struct pse_control_status {
7777
* @pi_disable: Configure the PSE PI as disabled.
7878
* @pi_get_voltage: Return voltage similarly to get_voltage regulator
7979
* callback.
80-
* @pi_get_current_limit: Get the configured current limit similarly to
81-
* get_current_limit regulator callback.
82-
* @pi_set_current_limit: Configure the current limit similarly to
83-
* set_current_limit regulator callback.
84-
* Should not return an error in case of MAX_PI_CURRENT
85-
* current value set.
80+
* @pi_get_pw_limit: Get the configured power limit of the PSE PI.
81+
* @pi_set_pw_limit: Configure the power limit of the PSE PI.
8682
*/
8783
struct pse_controller_ops {
8884
int (*ethtool_get_status)(struct pse_controller_dev *pcdev,
@@ -93,10 +89,10 @@ struct pse_controller_ops {
9389
int (*pi_enable)(struct pse_controller_dev *pcdev, int id);
9490
int (*pi_disable)(struct pse_controller_dev *pcdev, int id);
9591
int (*pi_get_voltage)(struct pse_controller_dev *pcdev, int id);
96-
int (*pi_get_current_limit)(struct pse_controller_dev *pcdev,
97-
int id);
98-
int (*pi_set_current_limit)(struct pse_controller_dev *pcdev,
99-
int id, int max_uA);
92+
int (*pi_get_pw_limit)(struct pse_controller_dev *pcdev,
93+
int id);
94+
int (*pi_set_pw_limit)(struct pse_controller_dev *pcdev,
95+
int id, int max_mW);
10096
};
10197

10298
struct module;

0 commit comments

Comments
 (0)