net/ethtool/cabletest.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2
   3 #include <linux/phy.h>
   4 #include <linux/ethtool_netlink.h>
   5 #include "netlink.h"
   6 #include "common.h"
   7
   8 /* 802.3 standard allows 100 meters for BaseT cables. However longer
   9  * cables might work, depending on the quality of the cables and the
  10  * PHY. So allow testing for up to 150 meters.
  11  */
  12 #define MAX_CABLE_LENGTH_CM (150 * 100)
  13
  14 const struct nla_policy ethnl_cable_test_act_policy[] = {
  15         [ETHTOOL_A_CABLE_TEST_HEADER]           =
  16                 NLA_POLICY_NESTED(ethnl_header_policy),
  17 };
  18
  19 static int ethnl_cable_test_started(struct phy_device *phydev, u8 cmd)
  20 {
  21         struct sk_buff *skb;
  22         int err = -ENOMEM;
  23         void *ehdr;
  24
  25         skb = genlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
  26         if (!skb)
  27                 goto out;
  28
  29         ehdr = ethnl_bcastmsg_put(skb, cmd);
  30         if (!ehdr) {
  31                 err = -EMSGSIZE;
  32                 goto out;
  33         }
  34
  35         err = ethnl_fill_reply_header(skb, phydev->attached_dev,
  36                                       ETHTOOL_A_CABLE_TEST_NTF_HEADER);
  37         if (err)
  38                 goto out;
  39
  40         err = nla_put_u8(skb, ETHTOOL_A_CABLE_TEST_NTF_STATUS,
  41                          ETHTOOL_A_CABLE_TEST_NTF_STATUS_STARTED);
  42         if (err)
  43                 goto out;
  44
  45         genlmsg_end(skb, ehdr);
  46
  47         return ethnl_multicast(skb, phydev->attached_dev);
  48
  49 out:
  50         nlmsg_free(skb);
  51         phydev_err(phydev, "%s: Error %pe\n", __func__, ERR_PTR(err));
  52
  53         return err;
  54 }
  55
  56 int ethnl_act_cable_test(struct sk_buff *skb, struct genl_info *info)
  57 {
  58         struct ethnl_req_info req_info = {};
  59         const struct ethtool_phy_ops *ops;
  60         struct nlattr **tb = info->attrs;
  61         struct net_device *dev;
  62         int ret;
  63
  64         ret = ethnl_parse_header_dev_get(&req_info,
  65                                          tb[ETHTOOL_A_CABLE_TEST_HEADER],
  66                                          genl_info_net(info), info->extack,
  67                                          true);
  68         if (ret < 0)
  69                 return ret;
  70
  71         dev = req_info.dev;
  72         if (!dev->phydev) {
  73                 ret = -EOPNOTSUPP;
  74                 goto out_dev_put;
  75         }
  76
  77         rtnl_lock();
  78         ops = ethtool_phy_ops;
  79         if (!ops || !ops->start_cable_test) {
  80                 ret = -EOPNOTSUPP;
  81                 goto out_rtnl;
  82         }
  83
  84         ret = ethnl_ops_begin(dev);
  85         if (ret < 0)
  86                 goto out_rtnl;
  87
  88         ret = ops->start_cable_test(dev->phydev, info->extack);
  89
  90         ethnl_ops_complete(dev);
  91
  92         if (!ret)
  93                 ethnl_cable_test_started(dev->phydev,
  94                                          ETHTOOL_MSG_CABLE_TEST_NTF);
  95
  96 out_rtnl:
  97         rtnl_unlock();
  98 out_dev_put:
  99         ethnl_parse_header_dev_put(&req_info);
 100         return ret;
 101 }
 102
 103 int ethnl_cable_test_alloc(struct phy_device *phydev, u8 cmd)
 104 {
 105         int err = -ENOMEM;
 106
 107         /* One TDR sample occupies 20 bytes. For a 150 meter cable,
 108          * with four pairs, around 12K is needed.
 109          */
 110         phydev->skb = genlmsg_new(SZ_16K, GFP_KERNEL);
 111         if (!phydev->skb)
 112                 goto out;
 113
 114         phydev->ehdr = ethnl_bcastmsg_put(phydev->skb, cmd);
 115         if (!phydev->ehdr) {
 116                 err = -EMSGSIZE;
 117                 goto out;
 118         }
 119
 120         err = ethnl_fill_reply_header(phydev->skb, phydev->attached_dev,
 121                                       ETHTOOL_A_CABLE_TEST_NTF_HEADER);
 122         if (err)
 123                 goto out;
 124
 125         err = nla_put_u8(phydev->skb, ETHTOOL_A_CABLE_TEST_NTF_STATUS,
 126                          ETHTOOL_A_CABLE_TEST_NTF_STATUS_COMPLETED);
 127         if (err)
 128                 goto out;
 129
 130         phydev->nest = nla_nest_start(phydev->skb,
 131                                       ETHTOOL_A_CABLE_TEST_NTF_NEST);
 132         if (!phydev->nest) {
 133                 err = -EMSGSIZE;
 134                 goto out;
 135         }
 136
 137         return 0;
 138
 139 out:
 140         nlmsg_free(phydev->skb);
 141         phydev->skb = NULL;
 142         return err;
 143 }
 144 EXPORT_SYMBOL_GPL(ethnl_cable_test_alloc);
 145
 146 void ethnl_cable_test_free(struct phy_device *phydev)
 147 {
 148         nlmsg_free(phydev->skb);
 149         phydev->skb = NULL;
 150 }
 151 EXPORT_SYMBOL_GPL(ethnl_cable_test_free);
 152
 153 void ethnl_cable_test_finished(struct phy_device *phydev)
 154 {
 155         nla_nest_end(phydev->skb, phydev->nest);
 156
 157         genlmsg_end(phydev->skb, phydev->ehdr);
 158
 159         ethnl_multicast(phydev->skb, phydev->attached_dev);
 160 }
 161 EXPORT_SYMBOL_GPL(ethnl_cable_test_finished);
 162
 163 int ethnl_cable_test_result(struct phy_device *phydev, u8 pair, u8 result)
 164 {
 165         struct nlattr *nest;
 166         int ret = -EMSGSIZE;
 167
 168         nest = nla_nest_start(phydev->skb, ETHTOOL_A_CABLE_NEST_RESULT);
 169         if (!nest)
 170                 return -EMSGSIZE;
 171
 172         if (nla_put_u8(phydev->skb, ETHTOOL_A_CABLE_RESULT_PAIR, pair))
 173                 goto err;
 174         if (nla_put_u8(phydev->skb, ETHTOOL_A_CABLE_RESULT_CODE, result))
 175                 goto err;
 176
 177         nla_nest_end(phydev->skb, nest);
 178         return 0;
 179
 180 err:
 181         nla_nest_cancel(phydev->skb, nest);
 182         return ret;
 183 }
 184 EXPORT_SYMBOL_GPL(ethnl_cable_test_result);
 185
 186 int ethnl_cable_test_fault_length(struct phy_device *phydev, u8 pair, u32 cm)
 187 {
 188         struct nlattr *nest;
 189         int ret = -EMSGSIZE;
 190
 191         nest = nla_nest_start(phydev->skb,
 192                               ETHTOOL_A_CABLE_NEST_FAULT_LENGTH);
 193         if (!nest)
 194                 return -EMSGSIZE;
 195
 196         if (nla_put_u8(phydev->skb, ETHTOOL_A_CABLE_FAULT_LENGTH_PAIR, pair))
 197                 goto err;
 198         if (nla_put_u32(phydev->skb, ETHTOOL_A_CABLE_FAULT_LENGTH_CM, cm))
 199                 goto err;
 200
 201         nla_nest_end(phydev->skb, nest);
 202         return 0;
 203
 204 err:
 205         nla_nest_cancel(phydev->skb, nest);
 206         return ret;
 207 }
 208 EXPORT_SYMBOL_GPL(ethnl_cable_test_fault_length);
 209
 210 struct cable_test_tdr_req_info {
 211         struct ethnl_req_info           base;
 212 };
 213
 214 static const struct nla_policy cable_test_tdr_act_cfg_policy[] = {
 215         [ETHTOOL_A_CABLE_TEST_TDR_CFG_FIRST]    = { .type = NLA_U32 },
 216         [ETHTOOL_A_CABLE_TEST_TDR_CFG_LAST]     = { .type = NLA_U32 },
 217         [ETHTOOL_A_CABLE_TEST_TDR_CFG_STEP]     = { .type = NLA_U32 },
 218         [ETHTOOL_A_CABLE_TEST_TDR_CFG_PAIR]     = { .type = NLA_U8 },
 219 };
 220
 221 const struct nla_policy ethnl_cable_test_tdr_act_policy[] = {
 222         [ETHTOOL_A_CABLE_TEST_TDR_HEADER]       =
 223                 NLA_POLICY_NESTED(ethnl_header_policy),
 224         [ETHTOOL_A_CABLE_TEST_TDR_CFG]          = { .type = NLA_NESTED },
 225 };
 226
 227 /* CABLE_TEST_TDR_ACT */
 228 static int ethnl_act_cable_test_tdr_cfg(const struct nlattr *nest,
 229                                         struct genl_info *info,
 230                                         struct phy_tdr_config *cfg)
 231 {
 232         struct nlattr *tb[ARRAY_SIZE(cable_test_tdr_act_cfg_policy)];
 233         int ret;
 234
 235         cfg->first = 100;
 236         cfg->step = 100;
 237         cfg->last = MAX_CABLE_LENGTH_CM;
 238         cfg->pair = PHY_PAIR_ALL;
 239
 240         if (!nest)
 241                 return 0;
 242
 243         ret = nla_parse_nested(tb,
 244                                ARRAY_SIZE(cable_test_tdr_act_cfg_policy) - 1,
 245                                nest, cable_test_tdr_act_cfg_policy,
 246                                info->extack);
 247         if (ret < 0)
 248                 return ret;
 249
 250         if (tb[ETHTOOL_A_CABLE_TEST_TDR_CFG_FIRST])
 251                 cfg->first = nla_get_u32(
 252                         tb[ETHTOOL_A_CABLE_TEST_TDR_CFG_FIRST]);
 253
 254         if (tb[ETHTOOL_A_CABLE_TEST_TDR_CFG_LAST])
 255                 cfg->last = nla_get_u32(tb[ETHTOOL_A_CABLE_TEST_TDR_CFG_LAST]);
 256
 257         if (tb[ETHTOOL_A_CABLE_TEST_TDR_CFG_STEP])
 258                 cfg->step = nla_get_u32(tb[ETHTOOL_A_CABLE_TEST_TDR_CFG_STEP]);
 259
 260         if (tb[ETHTOOL_A_CABLE_TEST_TDR_CFG_PAIR]) {
 261                 cfg->pair = nla_get_u8(tb[ETHTOOL_A_CABLE_TEST_TDR_CFG_PAIR]);
 262                 if (cfg->pair > ETHTOOL_A_CABLE_PAIR_D) {
 263                         NL_SET_ERR_MSG_ATTR(
 264                                 info->extack,
 265                                 tb[ETHTOOL_A_CABLE_TEST_TDR_CFG_PAIR],
 266                                 "invalid pair parameter");
 267                         return -EINVAL;
 268                 }
 269         }
 270
 271         if (cfg->first > MAX_CABLE_LENGTH_CM) {
 272                 NL_SET_ERR_MSG_ATTR(info->extack,
 273                                     tb[ETHTOOL_A_CABLE_TEST_TDR_CFG_FIRST],
 274                                     "invalid first parameter");
 275                 return -EINVAL;
 276         }
 277
 278         if (cfg->last > MAX_CABLE_LENGTH_CM) {
 279                 NL_SET_ERR_MSG_ATTR(info->extack,
 280                                     tb[ETHTOOL_A_CABLE_TEST_TDR_CFG_LAST],
 281                                     "invalid last parameter");
 282                 return -EINVAL;
 283         }
 284
 285         if (cfg->first > cfg->last) {
 286                 NL_SET_ERR_MSG(info->extack, "invalid first/last parameter");
 287                 return -EINVAL;
 288         }
 289
 290         if (!cfg->step) {
 291                 NL_SET_ERR_MSG_ATTR(info->extack,
 292                                     tb[ETHTOOL_A_CABLE_TEST_TDR_CFG_STEP],
 293                                     "invalid step parameter");
 294                 return -EINVAL;
 295         }
 296
 297         if (cfg->step > (cfg->last - cfg->first)) {
 298                 NL_SET_ERR_MSG_ATTR(info->extack,
 299                                     tb[ETHTOOL_A_CABLE_TEST_TDR_CFG_STEP],
 300                                     "step parameter too big");
 301                 return -EINVAL;
 302         }
 303
 304         return 0;
 305 }
 306
 307 int ethnl_act_cable_test_tdr(struct sk_buff *skb, struct genl_info *info)
 308 {
 309         struct ethnl_req_info req_info = {};
 310         const struct ethtool_phy_ops *ops;
 311         struct nlattr **tb = info->attrs;
 312         struct phy_tdr_config cfg;
 313         struct net_device *dev;
 314         int ret;
 315
 316         ret = ethnl_parse_header_dev_get(&req_info,
 317                                          tb[ETHTOOL_A_CABLE_TEST_TDR_HEADER],
 318                                          genl_info_net(info), info->extack,
 319                                          true);
 320         if (ret < 0)
 321                 return ret;
 322
 323         dev = req_info.dev;
 324         if (!dev->phydev) {
 325                 ret = -EOPNOTSUPP;
 326                 goto out_dev_put;
 327         }
 328
 329         ret = ethnl_act_cable_test_tdr_cfg(tb[ETHTOOL_A_CABLE_TEST_TDR_CFG],
 330                                            info, &cfg);
 331         if (ret)
 332                 goto out_dev_put;
 333
 334         rtnl_lock();
 335         ops = ethtool_phy_ops;
 336         if (!ops || !ops->start_cable_test_tdr) {
 337                 ret = -EOPNOTSUPP;
 338                 goto out_rtnl;
 339         }
 340
 341         ret = ethnl_ops_begin(dev);
 342         if (ret < 0)
 343                 goto out_rtnl;
 344
 345         ret = ops->start_cable_test_tdr(dev->phydev, info->extack, &cfg);
 346
 347         ethnl_ops_complete(dev);
 348
 349         if (!ret)
 350                 ethnl_cable_test_started(dev->phydev,
 351                                          ETHTOOL_MSG_CABLE_TEST_TDR_NTF);
 352
 353 out_rtnl:
 354         rtnl_unlock();
 355 out_dev_put:
 356         ethnl_parse_header_dev_put(&req_info);
 357         return ret;
 358 }
 359
 360 int ethnl_cable_test_amplitude(struct phy_device *phydev,
 361                                u8 pair, s16 mV)
 362 {
 363         struct nlattr *nest;
 364         int ret = -EMSGSIZE;
 365
 366         nest = nla_nest_start(phydev->skb,
 367                               ETHTOOL_A_CABLE_TDR_NEST_AMPLITUDE);
 368         if (!nest)
 369                 return -EMSGSIZE;
 370
 371         if (nla_put_u8(phydev->skb, ETHTOOL_A_CABLE_AMPLITUDE_PAIR, pair))
 372                 goto err;
 373         if (nla_put_u16(phydev->skb, ETHTOOL_A_CABLE_AMPLITUDE_mV, mV))
 374                 goto err;
 375
 376         nla_nest_end(phydev->skb, nest);
 377         return 0;
 378
 379 err:
 380         nla_nest_cancel(phydev->skb, nest);
 381         return ret;
 382 }
 383 EXPORT_SYMBOL_GPL(ethnl_cable_test_amplitude);
 384
 385 int ethnl_cable_test_pulse(struct phy_device *phydev, u16 mV)
 386 {
 387         struct nlattr *nest;
 388         int ret = -EMSGSIZE;
 389
 390         nest = nla_nest_start(phydev->skb, ETHTOOL_A_CABLE_TDR_NEST_PULSE);
 391         if (!nest)
 392                 return -EMSGSIZE;
 393
 394         if (nla_put_u16(phydev->skb, ETHTOOL_A_CABLE_PULSE_mV, mV))
 395                 goto err;
 396
 397         nla_nest_end(phydev->skb, nest);
 398         return 0;
 399
 400 err:
 401         nla_nest_cancel(phydev->skb, nest);
 402         return ret;
 403 }
 404 EXPORT_SYMBOL_GPL(ethnl_cable_test_pulse);
 405
 406 int ethnl_cable_test_step(struct phy_device *phydev, u32 first, u32 last,
 407                           u32 step)
 408 {
 409         struct nlattr *nest;
 410         int ret = -EMSGSIZE;
 411
 412         nest = nla_nest_start(phydev->skb, ETHTOOL_A_CABLE_TDR_NEST_STEP);
 413         if (!nest)
 414                 return -EMSGSIZE;
 415
 416         if (nla_put_u32(phydev->skb, ETHTOOL_A_CABLE_STEP_FIRST_DISTANCE,
 417                         first))
 418                 goto err;
 419
 420         if (nla_put_u32(phydev->skb, ETHTOOL_A_CABLE_STEP_LAST_DISTANCE, last))
 421                 goto err;
 422
 423         if (nla_put_u32(phydev->skb, ETHTOOL_A_CABLE_STEP_STEP_DISTANCE, step))
 424                 goto err;
 425
 426         nla_nest_end(phydev->skb, nest);
 427         return 0;
 428
 429 err:
 430         nla_nest_cancel(phydev->skb, nest);
 431         return ret;
 432 }
 433 EXPORT_SYMBOL_GPL(ethnl_cable_test_step);