Commit | Line | Data |
---|---|---|
11ca3c42 AL |
1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | ||
3 | #include <linux/phy.h> | |
1dd3f212 | 4 | #include <linux/ethtool_netlink.h> |
11ca3c42 AL |
5 | #include "netlink.h" |
6 | #include "common.h" | |
7 | ||
f2bc8ad3 AL |
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) | |
11ca3c42 | 13 | |
ff419afa | 14 | const struct nla_policy ethnl_cable_test_act_policy[] = { |
329d9c33 JK |
15 | [ETHTOOL_A_CABLE_TEST_HEADER] = |
16 | NLA_POLICY_NESTED(ethnl_header_policy), | |
11ca3c42 AL |
17 | }; |
18 | ||
1a644de2 | 19 | static int ethnl_cable_test_started(struct phy_device *phydev, u8 cmd) |
9896a457 AL |
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 | ||
1a644de2 | 29 | ehdr = ethnl_bcastmsg_put(skb, cmd); |
9896a457 AL |
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 | ||
11ca3c42 AL |
56 | int ethnl_act_cable_test(struct sk_buff *skb, struct genl_info *info) |
57 | { | |
11ca3c42 | 58 | struct ethnl_req_info req_info = {}; |
f3631ab0 | 59 | const struct ethtool_phy_ops *ops; |
5028588b | 60 | struct nlattr **tb = info->attrs; |
11ca3c42 AL |
61 | struct net_device *dev; |
62 | int ret; | |
63 | ||
11ca3c42 AL |
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(); | |
f3631ab0 FF |
78 | ops = ethtool_phy_ops; |
79 | if (!ops || !ops->start_cable_test) { | |
80 | ret = -EOPNOTSUPP; | |
81 | goto out_rtnl; | |
82 | } | |
83 | ||
11ca3c42 AL |
84 | ret = ethnl_ops_begin(dev); |
85 | if (ret < 0) | |
86 | goto out_rtnl; | |
87 | ||
f3631ab0 | 88 | ret = ops->start_cable_test(dev->phydev, info->extack); |
11ca3c42 AL |
89 | |
90 | ethnl_ops_complete(dev); | |
9896a457 AL |
91 | |
92 | if (!ret) | |
1a644de2 AL |
93 | ethnl_cable_test_started(dev->phydev, |
94 | ETHTOOL_MSG_CABLE_TEST_NTF); | |
9896a457 | 95 | |
11ca3c42 AL |
96 | out_rtnl: |
97 | rtnl_unlock(); | |
98 | out_dev_put: | |
34ac17ec | 99 | ethnl_parse_header_dev_put(&req_info); |
11ca3c42 AL |
100 | return ret; |
101 | } | |
1dd3f212 | 102 | |
1a644de2 | 103 | int ethnl_cable_test_alloc(struct phy_device *phydev, u8 cmd) |
1dd3f212 AL |
104 | { |
105 | int err = -ENOMEM; | |
106 | ||
6b4a0fc1 AL |
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); | |
1dd3f212 AL |
111 | if (!phydev->skb) |
112 | goto out; | |
113 | ||
1a644de2 | 114 | phydev->ehdr = ethnl_bcastmsg_put(phydev->skb, cmd); |
1dd3f212 AL |
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); | |
1e2dc145 AL |
132 | if (!phydev->nest) { |
133 | err = -EMSGSIZE; | |
1dd3f212 | 134 | goto out; |
1e2dc145 | 135 | } |
1dd3f212 AL |
136 | |
137 | return 0; | |
138 | ||
139 | out: | |
140 | nlmsg_free(phydev->skb); | |
1e2dc145 | 141 | phydev->skb = NULL; |
1dd3f212 AL |
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); | |
1e2dc145 | 149 | phydev->skb = NULL; |
1dd3f212 AL |
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); | |
1e2dc145 AL |
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); | |
1a644de2 | 209 | |
f2bc8ad3 AL |
210 | struct cable_test_tdr_req_info { |
211 | struct ethnl_req_info base; | |
212 | }; | |
213 | ||
ff419afa | 214 | static const struct nla_policy cable_test_tdr_act_cfg_policy[] = { |
f2bc8ad3 AL |
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 | ||
ff419afa | 221 | const struct nla_policy ethnl_cable_test_tdr_act_policy[] = { |
329d9c33 JK |
222 | [ETHTOOL_A_CABLE_TEST_TDR_HEADER] = |
223 | NLA_POLICY_NESTED(ethnl_header_policy), | |
f2bc8ad3 | 224 | [ETHTOOL_A_CABLE_TEST_TDR_CFG] = { .type = NLA_NESTED }, |
1a644de2 AL |
225 | }; |
226 | ||
f2bc8ad3 | 227 | /* CABLE_TEST_TDR_ACT */ |
fd55199d AL |
228 | static int ethnl_act_cable_test_tdr_cfg(const struct nlattr *nest, |
229 | struct genl_info *info, | |
230 | struct phy_tdr_config *cfg) | |
f2bc8ad3 | 231 | { |
ff419afa | 232 | struct nlattr *tb[ARRAY_SIZE(cable_test_tdr_act_cfg_policy)]; |
f2bc8ad3 AL |
233 | int ret; |
234 | ||
4b973f49 AL |
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 | ||
ff419afa JK |
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); | |
f2bc8ad3 AL |
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]); | |
4b973f49 | 253 | |
f2bc8ad3 AL |
254 | if (tb[ETHTOOL_A_CABLE_TEST_TDR_CFG_LAST]) |
255 | cfg->last = nla_get_u32(tb[ETHTOOL_A_CABLE_TEST_TDR_CFG_LAST]); | |
f2bc8ad3 AL |
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]); | |
f2bc8ad3 AL |
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 | } | |
f2bc8ad3 AL |
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 | ||
1a644de2 AL |
307 | int ethnl_act_cable_test_tdr(struct sk_buff *skb, struct genl_info *info) |
308 | { | |
1a644de2 | 309 | struct ethnl_req_info req_info = {}; |
f3631ab0 | 310 | const struct ethtool_phy_ops *ops; |
5028588b | 311 | struct nlattr **tb = info->attrs; |
f2bc8ad3 | 312 | struct phy_tdr_config cfg; |
1a644de2 AL |
313 | struct net_device *dev; |
314 | int ret; | |
315 | ||
1a644de2 AL |
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 | ||
f2bc8ad3 AL |
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 | ||
1a644de2 | 334 | rtnl_lock(); |
f3631ab0 FF |
335 | ops = ethtool_phy_ops; |
336 | if (!ops || !ops->start_cable_test_tdr) { | |
337 | ret = -EOPNOTSUPP; | |
338 | goto out_rtnl; | |
339 | } | |
340 | ||
1a644de2 AL |
341 | ret = ethnl_ops_begin(dev); |
342 | if (ret < 0) | |
343 | goto out_rtnl; | |
344 | ||
f3631ab0 | 345 | ret = ops->start_cable_test_tdr(dev->phydev, info->extack, &cfg); |
1a644de2 AL |
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: | |
34ac17ec | 356 | ethnl_parse_header_dev_put(&req_info); |
1a644de2 AL |
357 | return ret; |
358 | } | |
6b4a0fc1 AL |
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); |