mirror of
https://mirrors.bfsu.edu.cn/git/linux.git
synced 2024-11-15 00:04:15 +08:00
fe1eb24bd5
This reverts commit32bb4515e3. This reverts commitd078d48063. This reverts commitfcc4b105ca. This reverts commit345237dbc1. This reverts commit7db69ec9cf. This reverts commit95132a018f. This reverts commit63d5eaf35a. This reverts commitc29451aefc. This reverts commit2ab0edb505. This reverts commitdedd702a35. This reverts commit034fcc2103. This reverts commit9c5625f559. This reverts commit02018c544e. Looks like we need more time for reviews, and incremental changes will be hard to make sense of. So revert. Link: https://lore.kernel.org/all/ZZP6FV5sXEf+xd58@shell.armlinux.org.uk/ Signed-off-by: Jakub Kicinski <kuba@kernel.org>
434 lines
9.6 KiB
C
434 lines
9.6 KiB
C
// SPDX-License-Identifier: GPL-2.0-only
|
|
|
|
#include <linux/phy.h>
|
|
#include <linux/ethtool_netlink.h>
|
|
#include "netlink.h"
|
|
#include "common.h"
|
|
|
|
/* 802.3 standard allows 100 meters for BaseT cables. However longer
|
|
* cables might work, depending on the quality of the cables and the
|
|
* PHY. So allow testing for up to 150 meters.
|
|
*/
|
|
#define MAX_CABLE_LENGTH_CM (150 * 100)
|
|
|
|
const struct nla_policy ethnl_cable_test_act_policy[] = {
|
|
[ETHTOOL_A_CABLE_TEST_HEADER] =
|
|
NLA_POLICY_NESTED(ethnl_header_policy),
|
|
};
|
|
|
|
static int ethnl_cable_test_started(struct phy_device *phydev, u8 cmd)
|
|
{
|
|
struct sk_buff *skb;
|
|
int err = -ENOMEM;
|
|
void *ehdr;
|
|
|
|
skb = genlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
|
|
if (!skb)
|
|
goto out;
|
|
|
|
ehdr = ethnl_bcastmsg_put(skb, cmd);
|
|
if (!ehdr) {
|
|
err = -EMSGSIZE;
|
|
goto out;
|
|
}
|
|
|
|
err = ethnl_fill_reply_header(skb, phydev->attached_dev,
|
|
ETHTOOL_A_CABLE_TEST_NTF_HEADER);
|
|
if (err)
|
|
goto out;
|
|
|
|
err = nla_put_u8(skb, ETHTOOL_A_CABLE_TEST_NTF_STATUS,
|
|
ETHTOOL_A_CABLE_TEST_NTF_STATUS_STARTED);
|
|
if (err)
|
|
goto out;
|
|
|
|
genlmsg_end(skb, ehdr);
|
|
|
|
return ethnl_multicast(skb, phydev->attached_dev);
|
|
|
|
out:
|
|
nlmsg_free(skb);
|
|
phydev_err(phydev, "%s: Error %pe\n", __func__, ERR_PTR(err));
|
|
|
|
return err;
|
|
}
|
|
|
|
int ethnl_act_cable_test(struct sk_buff *skb, struct genl_info *info)
|
|
{
|
|
struct ethnl_req_info req_info = {};
|
|
const struct ethtool_phy_ops *ops;
|
|
struct nlattr **tb = info->attrs;
|
|
struct net_device *dev;
|
|
int ret;
|
|
|
|
ret = ethnl_parse_header_dev_get(&req_info,
|
|
tb[ETHTOOL_A_CABLE_TEST_HEADER],
|
|
genl_info_net(info), info->extack,
|
|
true);
|
|
if (ret < 0)
|
|
return ret;
|
|
|
|
dev = req_info.dev;
|
|
if (!dev->phydev) {
|
|
ret = -EOPNOTSUPP;
|
|
goto out_dev_put;
|
|
}
|
|
|
|
rtnl_lock();
|
|
ops = ethtool_phy_ops;
|
|
if (!ops || !ops->start_cable_test) {
|
|
ret = -EOPNOTSUPP;
|
|
goto out_rtnl;
|
|
}
|
|
|
|
ret = ethnl_ops_begin(dev);
|
|
if (ret < 0)
|
|
goto out_rtnl;
|
|
|
|
ret = ops->start_cable_test(dev->phydev, info->extack);
|
|
|
|
ethnl_ops_complete(dev);
|
|
|
|
if (!ret)
|
|
ethnl_cable_test_started(dev->phydev,
|
|
ETHTOOL_MSG_CABLE_TEST_NTF);
|
|
|
|
out_rtnl:
|
|
rtnl_unlock();
|
|
out_dev_put:
|
|
ethnl_parse_header_dev_put(&req_info);
|
|
return ret;
|
|
}
|
|
|
|
int ethnl_cable_test_alloc(struct phy_device *phydev, u8 cmd)
|
|
{
|
|
int err = -ENOMEM;
|
|
|
|
/* One TDR sample occupies 20 bytes. For a 150 meter cable,
|
|
* with four pairs, around 12K is needed.
|
|
*/
|
|
phydev->skb = genlmsg_new(SZ_16K, GFP_KERNEL);
|
|
if (!phydev->skb)
|
|
goto out;
|
|
|
|
phydev->ehdr = ethnl_bcastmsg_put(phydev->skb, cmd);
|
|
if (!phydev->ehdr) {
|
|
err = -EMSGSIZE;
|
|
goto out;
|
|
}
|
|
|
|
err = ethnl_fill_reply_header(phydev->skb, phydev->attached_dev,
|
|
ETHTOOL_A_CABLE_TEST_NTF_HEADER);
|
|
if (err)
|
|
goto out;
|
|
|
|
err = nla_put_u8(phydev->skb, ETHTOOL_A_CABLE_TEST_NTF_STATUS,
|
|
ETHTOOL_A_CABLE_TEST_NTF_STATUS_COMPLETED);
|
|
if (err)
|
|
goto out;
|
|
|
|
phydev->nest = nla_nest_start(phydev->skb,
|
|
ETHTOOL_A_CABLE_TEST_NTF_NEST);
|
|
if (!phydev->nest) {
|
|
err = -EMSGSIZE;
|
|
goto out;
|
|
}
|
|
|
|
return 0;
|
|
|
|
out:
|
|
nlmsg_free(phydev->skb);
|
|
phydev->skb = NULL;
|
|
return err;
|
|
}
|
|
EXPORT_SYMBOL_GPL(ethnl_cable_test_alloc);
|
|
|
|
void ethnl_cable_test_free(struct phy_device *phydev)
|
|
{
|
|
nlmsg_free(phydev->skb);
|
|
phydev->skb = NULL;
|
|
}
|
|
EXPORT_SYMBOL_GPL(ethnl_cable_test_free);
|
|
|
|
void ethnl_cable_test_finished(struct phy_device *phydev)
|
|
{
|
|
nla_nest_end(phydev->skb, phydev->nest);
|
|
|
|
genlmsg_end(phydev->skb, phydev->ehdr);
|
|
|
|
ethnl_multicast(phydev->skb, phydev->attached_dev);
|
|
}
|
|
EXPORT_SYMBOL_GPL(ethnl_cable_test_finished);
|
|
|
|
int ethnl_cable_test_result(struct phy_device *phydev, u8 pair, u8 result)
|
|
{
|
|
struct nlattr *nest;
|
|
int ret = -EMSGSIZE;
|
|
|
|
nest = nla_nest_start(phydev->skb, ETHTOOL_A_CABLE_NEST_RESULT);
|
|
if (!nest)
|
|
return -EMSGSIZE;
|
|
|
|
if (nla_put_u8(phydev->skb, ETHTOOL_A_CABLE_RESULT_PAIR, pair))
|
|
goto err;
|
|
if (nla_put_u8(phydev->skb, ETHTOOL_A_CABLE_RESULT_CODE, result))
|
|
goto err;
|
|
|
|
nla_nest_end(phydev->skb, nest);
|
|
return 0;
|
|
|
|
err:
|
|
nla_nest_cancel(phydev->skb, nest);
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL_GPL(ethnl_cable_test_result);
|
|
|
|
int ethnl_cable_test_fault_length(struct phy_device *phydev, u8 pair, u32 cm)
|
|
{
|
|
struct nlattr *nest;
|
|
int ret = -EMSGSIZE;
|
|
|
|
nest = nla_nest_start(phydev->skb,
|
|
ETHTOOL_A_CABLE_NEST_FAULT_LENGTH);
|
|
if (!nest)
|
|
return -EMSGSIZE;
|
|
|
|
if (nla_put_u8(phydev->skb, ETHTOOL_A_CABLE_FAULT_LENGTH_PAIR, pair))
|
|
goto err;
|
|
if (nla_put_u32(phydev->skb, ETHTOOL_A_CABLE_FAULT_LENGTH_CM, cm))
|
|
goto err;
|
|
|
|
nla_nest_end(phydev->skb, nest);
|
|
return 0;
|
|
|
|
err:
|
|
nla_nest_cancel(phydev->skb, nest);
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL_GPL(ethnl_cable_test_fault_length);
|
|
|
|
struct cable_test_tdr_req_info {
|
|
struct ethnl_req_info base;
|
|
};
|
|
|
|
static const struct nla_policy cable_test_tdr_act_cfg_policy[] = {
|
|
[ETHTOOL_A_CABLE_TEST_TDR_CFG_FIRST] = { .type = NLA_U32 },
|
|
[ETHTOOL_A_CABLE_TEST_TDR_CFG_LAST] = { .type = NLA_U32 },
|
|
[ETHTOOL_A_CABLE_TEST_TDR_CFG_STEP] = { .type = NLA_U32 },
|
|
[ETHTOOL_A_CABLE_TEST_TDR_CFG_PAIR] = { .type = NLA_U8 },
|
|
};
|
|
|
|
const struct nla_policy ethnl_cable_test_tdr_act_policy[] = {
|
|
[ETHTOOL_A_CABLE_TEST_TDR_HEADER] =
|
|
NLA_POLICY_NESTED(ethnl_header_policy),
|
|
[ETHTOOL_A_CABLE_TEST_TDR_CFG] = { .type = NLA_NESTED },
|
|
};
|
|
|
|
/* CABLE_TEST_TDR_ACT */
|
|
static int ethnl_act_cable_test_tdr_cfg(const struct nlattr *nest,
|
|
struct genl_info *info,
|
|
struct phy_tdr_config *cfg)
|
|
{
|
|
struct nlattr *tb[ARRAY_SIZE(cable_test_tdr_act_cfg_policy)];
|
|
int ret;
|
|
|
|
cfg->first = 100;
|
|
cfg->step = 100;
|
|
cfg->last = MAX_CABLE_LENGTH_CM;
|
|
cfg->pair = PHY_PAIR_ALL;
|
|
|
|
if (!nest)
|
|
return 0;
|
|
|
|
ret = nla_parse_nested(tb,
|
|
ARRAY_SIZE(cable_test_tdr_act_cfg_policy) - 1,
|
|
nest, cable_test_tdr_act_cfg_policy,
|
|
info->extack);
|
|
if (ret < 0)
|
|
return ret;
|
|
|
|
if (tb[ETHTOOL_A_CABLE_TEST_TDR_CFG_FIRST])
|
|
cfg->first = nla_get_u32(
|
|
tb[ETHTOOL_A_CABLE_TEST_TDR_CFG_FIRST]);
|
|
|
|
if (tb[ETHTOOL_A_CABLE_TEST_TDR_CFG_LAST])
|
|
cfg->last = nla_get_u32(tb[ETHTOOL_A_CABLE_TEST_TDR_CFG_LAST]);
|
|
|
|
if (tb[ETHTOOL_A_CABLE_TEST_TDR_CFG_STEP])
|
|
cfg->step = nla_get_u32(tb[ETHTOOL_A_CABLE_TEST_TDR_CFG_STEP]);
|
|
|
|
if (tb[ETHTOOL_A_CABLE_TEST_TDR_CFG_PAIR]) {
|
|
cfg->pair = nla_get_u8(tb[ETHTOOL_A_CABLE_TEST_TDR_CFG_PAIR]);
|
|
if (cfg->pair > ETHTOOL_A_CABLE_PAIR_D) {
|
|
NL_SET_ERR_MSG_ATTR(
|
|
info->extack,
|
|
tb[ETHTOOL_A_CABLE_TEST_TDR_CFG_PAIR],
|
|
"invalid pair parameter");
|
|
return -EINVAL;
|
|
}
|
|
}
|
|
|
|
if (cfg->first > MAX_CABLE_LENGTH_CM) {
|
|
NL_SET_ERR_MSG_ATTR(info->extack,
|
|
tb[ETHTOOL_A_CABLE_TEST_TDR_CFG_FIRST],
|
|
"invalid first parameter");
|
|
return -EINVAL;
|
|
}
|
|
|
|
if (cfg->last > MAX_CABLE_LENGTH_CM) {
|
|
NL_SET_ERR_MSG_ATTR(info->extack,
|
|
tb[ETHTOOL_A_CABLE_TEST_TDR_CFG_LAST],
|
|
"invalid last parameter");
|
|
return -EINVAL;
|
|
}
|
|
|
|
if (cfg->first > cfg->last) {
|
|
NL_SET_ERR_MSG(info->extack, "invalid first/last parameter");
|
|
return -EINVAL;
|
|
}
|
|
|
|
if (!cfg->step) {
|
|
NL_SET_ERR_MSG_ATTR(info->extack,
|
|
tb[ETHTOOL_A_CABLE_TEST_TDR_CFG_STEP],
|
|
"invalid step parameter");
|
|
return -EINVAL;
|
|
}
|
|
|
|
if (cfg->step > (cfg->last - cfg->first)) {
|
|
NL_SET_ERR_MSG_ATTR(info->extack,
|
|
tb[ETHTOOL_A_CABLE_TEST_TDR_CFG_STEP],
|
|
"step parameter too big");
|
|
return -EINVAL;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int ethnl_act_cable_test_tdr(struct sk_buff *skb, struct genl_info *info)
|
|
{
|
|
struct ethnl_req_info req_info = {};
|
|
const struct ethtool_phy_ops *ops;
|
|
struct nlattr **tb = info->attrs;
|
|
struct phy_tdr_config cfg;
|
|
struct net_device *dev;
|
|
int ret;
|
|
|
|
ret = ethnl_parse_header_dev_get(&req_info,
|
|
tb[ETHTOOL_A_CABLE_TEST_TDR_HEADER],
|
|
genl_info_net(info), info->extack,
|
|
true);
|
|
if (ret < 0)
|
|
return ret;
|
|
|
|
dev = req_info.dev;
|
|
if (!dev->phydev) {
|
|
ret = -EOPNOTSUPP;
|
|
goto out_dev_put;
|
|
}
|
|
|
|
ret = ethnl_act_cable_test_tdr_cfg(tb[ETHTOOL_A_CABLE_TEST_TDR_CFG],
|
|
info, &cfg);
|
|
if (ret)
|
|
goto out_dev_put;
|
|
|
|
rtnl_lock();
|
|
ops = ethtool_phy_ops;
|
|
if (!ops || !ops->start_cable_test_tdr) {
|
|
ret = -EOPNOTSUPP;
|
|
goto out_rtnl;
|
|
}
|
|
|
|
ret = ethnl_ops_begin(dev);
|
|
if (ret < 0)
|
|
goto out_rtnl;
|
|
|
|
ret = ops->start_cable_test_tdr(dev->phydev, info->extack, &cfg);
|
|
|
|
ethnl_ops_complete(dev);
|
|
|
|
if (!ret)
|
|
ethnl_cable_test_started(dev->phydev,
|
|
ETHTOOL_MSG_CABLE_TEST_TDR_NTF);
|
|
|
|
out_rtnl:
|
|
rtnl_unlock();
|
|
out_dev_put:
|
|
ethnl_parse_header_dev_put(&req_info);
|
|
return ret;
|
|
}
|
|
|
|
int ethnl_cable_test_amplitude(struct phy_device *phydev,
|
|
u8 pair, s16 mV)
|
|
{
|
|
struct nlattr *nest;
|
|
int ret = -EMSGSIZE;
|
|
|
|
nest = nla_nest_start(phydev->skb,
|
|
ETHTOOL_A_CABLE_TDR_NEST_AMPLITUDE);
|
|
if (!nest)
|
|
return -EMSGSIZE;
|
|
|
|
if (nla_put_u8(phydev->skb, ETHTOOL_A_CABLE_AMPLITUDE_PAIR, pair))
|
|
goto err;
|
|
if (nla_put_u16(phydev->skb, ETHTOOL_A_CABLE_AMPLITUDE_mV, mV))
|
|
goto err;
|
|
|
|
nla_nest_end(phydev->skb, nest);
|
|
return 0;
|
|
|
|
err:
|
|
nla_nest_cancel(phydev->skb, nest);
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL_GPL(ethnl_cable_test_amplitude);
|
|
|
|
int ethnl_cable_test_pulse(struct phy_device *phydev, u16 mV)
|
|
{
|
|
struct nlattr *nest;
|
|
int ret = -EMSGSIZE;
|
|
|
|
nest = nla_nest_start(phydev->skb, ETHTOOL_A_CABLE_TDR_NEST_PULSE);
|
|
if (!nest)
|
|
return -EMSGSIZE;
|
|
|
|
if (nla_put_u16(phydev->skb, ETHTOOL_A_CABLE_PULSE_mV, mV))
|
|
goto err;
|
|
|
|
nla_nest_end(phydev->skb, nest);
|
|
return 0;
|
|
|
|
err:
|
|
nla_nest_cancel(phydev->skb, nest);
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL_GPL(ethnl_cable_test_pulse);
|
|
|
|
int ethnl_cable_test_step(struct phy_device *phydev, u32 first, u32 last,
|
|
u32 step)
|
|
{
|
|
struct nlattr *nest;
|
|
int ret = -EMSGSIZE;
|
|
|
|
nest = nla_nest_start(phydev->skb, ETHTOOL_A_CABLE_TDR_NEST_STEP);
|
|
if (!nest)
|
|
return -EMSGSIZE;
|
|
|
|
if (nla_put_u32(phydev->skb, ETHTOOL_A_CABLE_STEP_FIRST_DISTANCE,
|
|
first))
|
|
goto err;
|
|
|
|
if (nla_put_u32(phydev->skb, ETHTOOL_A_CABLE_STEP_LAST_DISTANCE, last))
|
|
goto err;
|
|
|
|
if (nla_put_u32(phydev->skb, ETHTOOL_A_CABLE_STEP_STEP_DISTANCE, step))
|
|
goto err;
|
|
|
|
nla_nest_end(phydev->skb, nest);
|
|
return 0;
|
|
|
|
err:
|
|
nla_nest_cancel(phydev->skb, nest);
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL_GPL(ethnl_cable_test_step);
|