1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 * Handling of a conduit device, switching frames via its switch fabric CPU port
4 *
5 * Copyright (c) 2017 Savoir-faire Linux Inc.
6 * Vivien Didelot <vivien.didelot@savoirfairelinux.com>
7 */
8
9#include <linux/ethtool.h>
10#include <linux/netdevice.h>
11#include <linux/netlink.h>
12#include <net/dsa.h>
13#include <net/netdev_lock.h>
14
15#include "conduit.h"
16#include "dsa.h"
17#include "port.h"
18#include "tag.h"
19
20static int dsa_conduit_get_regs_len(struct net_device *dev)
21{
22 struct dsa_port *cpu_dp = dev->dsa_ptr;
23 const struct ethtool_ops *ops = cpu_dp->orig_ethtool_ops;
24 struct dsa_switch *ds = cpu_dp->ds;
25 int port = cpu_dp->index;
26 int ret = 0;
27 int len;
28
29 if (ops && ops->get_regs_len) {
30 netdev_lock_ops(dev);
31 len = ops->get_regs_len(dev);
32 netdev_unlock_ops(dev);
33 if (len < 0)
34 return len;
35 ret += len;
36 }
37
38 ret += sizeof(struct ethtool_drvinfo);
39 ret += sizeof(struct ethtool_regs);
40
41 if (ds->ops->get_regs_len) {
42 len = ds->ops->get_regs_len(ds, port);
43 if (len < 0)
44 return len;
45 ret += len;
46 }
47
48 return ret;
49}
50
51static void dsa_conduit_get_regs(struct net_device *dev,
52 struct ethtool_regs *regs, void *data)
53{
54 struct dsa_port *cpu_dp = dev->dsa_ptr;
55 const struct ethtool_ops *ops = cpu_dp->orig_ethtool_ops;
56 struct dsa_switch *ds = cpu_dp->ds;
57 struct ethtool_drvinfo *cpu_info;
58 struct ethtool_regs *cpu_regs;
59 int port = cpu_dp->index;
60 int len;
61
62 if (ops && ops->get_regs_len && ops->get_regs) {
63 netdev_lock_ops(dev);
64 len = ops->get_regs_len(dev);
65 if (len < 0) {
66 netdev_unlock_ops(dev);
67 return;
68 }
69 regs->len = len;
70 ops->get_regs(dev, regs, data);
71 netdev_unlock_ops(dev);
72 data += regs->len;
73 }
74
75 cpu_info = (struct ethtool_drvinfo *)data;
76 strscpy(cpu_info->driver, "dsa", sizeof(cpu_info->driver));
77 data += sizeof(*cpu_info);
78 cpu_regs = (struct ethtool_regs *)data;
79 data += sizeof(*cpu_regs);
80
81 if (ds->ops->get_regs_len && ds->ops->get_regs) {
82 len = ds->ops->get_regs_len(ds, port);
83 if (len < 0)
84 return;
85 cpu_regs->len = len;
86 ds->ops->get_regs(ds, port, cpu_regs, data);
87 }
88}
89
90static ssize_t dsa_conduit_append_port_stats(struct dsa_switch *ds, int port,
91 u64 *data, size_t start)
92{
93 int count;
94
95 if (!ds->ops->get_sset_count)
96 return 0;
97
98 count = ds->ops->get_sset_count(ds, port, ETH_SS_STATS);
99 if (count < 0)
100 return count;
101
102 if (ds->ops->get_ethtool_stats)
103 ds->ops->get_ethtool_stats(ds, port, data + start);
104
105 return count;
106}
107
108static void dsa_conduit_get_ethtool_stats(struct net_device *dev,
109 struct ethtool_stats *stats,
110 u64 *data)
111{
112 struct dsa_port *dp, *cpu_dp = dev->dsa_ptr;
113 const struct ethtool_ops *ops = cpu_dp->orig_ethtool_ops;
114 struct dsa_switch_tree *dst = cpu_dp->dst;
115 int count, mcount = 0;
116
117 if (ops && ops->get_sset_count && ops->get_ethtool_stats) {
118 netdev_lock_ops(dev);
119 mcount = ops->get_sset_count(dev, ETH_SS_STATS);
120 ops->get_ethtool_stats(dev, stats, data);
121 netdev_unlock_ops(dev);
122 }
123
124 list_for_each_entry(dp, &dst->ports, list) {
125 if (!dsa_port_is_dsa(port: dp) && !dsa_port_is_cpu(port: dp))
126 continue;
127
128 count = dsa_conduit_append_port_stats(ds: dp->ds, port: dp->index,
129 data, start: mcount);
130 if (count < 0)
131 return;
132
133 mcount += count;
134 }
135}
136
137static void dsa_conduit_get_ethtool_phy_stats(struct net_device *dev,
138 struct ethtool_stats *stats,
139 u64 *data)
140{
141 struct dsa_port *cpu_dp = dev->dsa_ptr;
142 const struct ethtool_ops *ops = cpu_dp->orig_ethtool_ops;
143 struct dsa_switch *ds = cpu_dp->ds;
144 int port = cpu_dp->index;
145 int count = 0;
146
147 if (dev->phydev && (!ops || !ops->get_ethtool_phy_stats)) {
148 count = phy_ethtool_get_sset_count(phydev: dev->phydev);
149 if (count >= 0)
150 phy_ethtool_get_stats(phydev: dev->phydev, stats, data);
151 } else if (ops && ops->get_sset_count && ops->get_ethtool_phy_stats) {
152 netdev_lock_ops(dev);
153 count = ops->get_sset_count(dev, ETH_SS_PHY_STATS);
154 ops->get_ethtool_phy_stats(dev, stats, data);
155 netdev_unlock_ops(dev);
156 }
157
158 if (count < 0)
159 count = 0;
160
161 if (ds->ops->get_ethtool_phy_stats)
162 ds->ops->get_ethtool_phy_stats(ds, port, data + count);
163}
164
165static void dsa_conduit_append_port_sset_count(struct dsa_switch *ds, int port,
166 int sset, int *count)
167{
168 if (ds->ops->get_sset_count)
169 *count += ds->ops->get_sset_count(ds, port, sset);
170}
171
172static int dsa_conduit_get_sset_count(struct net_device *dev, int sset)
173{
174 struct dsa_port *dp, *cpu_dp = dev->dsa_ptr;
175 const struct ethtool_ops *ops = cpu_dp->orig_ethtool_ops;
176 struct dsa_switch_tree *dst = cpu_dp->dst;
177 int count = 0;
178
179 netdev_lock_ops(dev);
180 if (sset == ETH_SS_PHY_STATS && dev->phydev &&
181 (!ops || !ops->get_ethtool_phy_stats))
182 count = phy_ethtool_get_sset_count(phydev: dev->phydev);
183 else if (ops && ops->get_sset_count)
184 count = ops->get_sset_count(dev, sset);
185 netdev_unlock_ops(dev);
186
187 if (count < 0)
188 count = 0;
189
190 list_for_each_entry(dp, &dst->ports, list) {
191 if (!dsa_port_is_dsa(port: dp) && !dsa_port_is_cpu(port: dp))
192 continue;
193
194 dsa_conduit_append_port_sset_count(ds: dp->ds, port: dp->index, sset,
195 count: &count);
196 }
197
198 return count;
199}
200
201static ssize_t dsa_conduit_append_port_strings(struct dsa_switch *ds, int port,
202 u32 stringset, u8 *data,
203 size_t start)
204{
205 int len = ETH_GSTRING_LEN;
206 u8 pfx[8], *ndata;
207 int count, i;
208
209 if (!ds->ops->get_strings)
210 return 0;
211
212 snprintf(buf: pfx, size: sizeof(pfx), fmt: "s%.2d_p%.2d", ds->index, port);
213 /* We do not want to be NULL-terminated, since this is a prefix */
214 pfx[sizeof(pfx) - 1] = '_';
215 ndata = data + start * len;
216 /* This function copies ETH_GSTRINGS_LEN bytes, we will mangle
217 * the output after to prepend our CPU port prefix we
218 * constructed earlier
219 */
220 ds->ops->get_strings(ds, port, stringset, ndata);
221 count = ds->ops->get_sset_count(ds, port, stringset);
222 if (count < 0)
223 return count;
224
225 for (i = 0; i < count; i++) {
226 memmove(ndata + (i * len + sizeof(pfx)),
227 ndata + i * len, len - sizeof(pfx));
228 memcpy(ndata + i * len, pfx, sizeof(pfx));
229 }
230
231 return count;
232}
233
234static void dsa_conduit_get_strings(struct net_device *dev, u32 stringset,
235 u8 *data)
236{
237 struct dsa_port *dp, *cpu_dp = dev->dsa_ptr;
238 const struct ethtool_ops *ops = cpu_dp->orig_ethtool_ops;
239 struct dsa_switch_tree *dst = cpu_dp->dst;
240 int count, mcount = 0;
241
242 netdev_lock_ops(dev);
243 if (stringset == ETH_SS_PHY_STATS && dev->phydev &&
244 !ops->get_ethtool_phy_stats) {
245 mcount = phy_ethtool_get_sset_count(phydev: dev->phydev);
246 if (mcount < 0)
247 mcount = 0;
248 else
249 phy_ethtool_get_strings(phydev: dev->phydev, data);
250 } else if (ops->get_sset_count && ops->get_strings) {
251 mcount = ops->get_sset_count(dev, stringset);
252 if (mcount < 0)
253 mcount = 0;
254 ops->get_strings(dev, stringset, data);
255 }
256 netdev_unlock_ops(dev);
257
258 list_for_each_entry(dp, &dst->ports, list) {
259 if (!dsa_port_is_dsa(port: dp) && !dsa_port_is_cpu(port: dp))
260 continue;
261
262 count = dsa_conduit_append_port_strings(ds: dp->ds, port: dp->index,
263 stringset, data,
264 start: mcount);
265 if (count < 0)
266 return;
267
268 mcount += count;
269 }
270}
271
272/* Deny PTP operations on conduit if there is at least one switch in the tree
273 * that is PTP capable.
274 */
275int __dsa_conduit_hwtstamp_validate(struct net_device *dev,
276 const struct kernel_hwtstamp_config *config,
277 struct netlink_ext_ack *extack)
278{
279 struct dsa_port *cpu_dp = dev->dsa_ptr;
280 struct dsa_switch *ds = cpu_dp->ds;
281 struct dsa_switch_tree *dst;
282 struct dsa_port *dp;
283
284 dst = ds->dst;
285
286 list_for_each_entry(dp, &dst->ports, list) {
287 if (dsa_port_supports_hwtstamp(dp)) {
288 NL_SET_ERR_MSG(extack,
289 "HW timestamping not allowed on DSA conduit when switch supports the operation");
290 return -EBUSY;
291 }
292 }
293
294 return 0;
295}
296
297static int dsa_conduit_ethtool_setup(struct net_device *dev)
298{
299 struct dsa_port *cpu_dp = dev->dsa_ptr;
300 struct dsa_switch *ds = cpu_dp->ds;
301 struct ethtool_ops *ops;
302
303 if (netif_is_lag_master(dev))
304 return 0;
305
306 ops = devm_kzalloc(dev: ds->dev, size: sizeof(*ops), GFP_KERNEL);
307 if (!ops)
308 return -ENOMEM;
309
310 cpu_dp->orig_ethtool_ops = dev->ethtool_ops;
311 if (cpu_dp->orig_ethtool_ops)
312 memcpy(ops, cpu_dp->orig_ethtool_ops, sizeof(*ops));
313
314 ops->get_regs_len = dsa_conduit_get_regs_len;
315 ops->get_regs = dsa_conduit_get_regs;
316 ops->get_sset_count = dsa_conduit_get_sset_count;
317 ops->get_ethtool_stats = dsa_conduit_get_ethtool_stats;
318 ops->get_strings = dsa_conduit_get_strings;
319 ops->get_ethtool_phy_stats = dsa_conduit_get_ethtool_phy_stats;
320
321 dev->ethtool_ops = ops;
322
323 return 0;
324}
325
326static void dsa_conduit_ethtool_teardown(struct net_device *dev)
327{
328 struct dsa_port *cpu_dp = dev->dsa_ptr;
329
330 if (netif_is_lag_master(dev))
331 return;
332
333 dev->ethtool_ops = cpu_dp->orig_ethtool_ops;
334 cpu_dp->orig_ethtool_ops = NULL;
335}
336
337/* Keep the conduit always promiscuous if the tagging protocol requires that
338 * (garbles MAC DA) or if it doesn't support unicast filtering, case in which
339 * it would revert to promiscuous mode as soon as we call dev_uc_add() on it
340 * anyway.
341 */
342static void dsa_conduit_set_promiscuity(struct net_device *dev, int inc)
343{
344 const struct dsa_device_ops *ops = dev->dsa_ptr->tag_ops;
345
346 if ((dev->priv_flags & IFF_UNICAST_FLT) && !ops->promisc_on_conduit)
347 return;
348
349 ASSERT_RTNL();
350
351 dev_set_promiscuity(dev, inc);
352}
353
354static ssize_t tagging_show(struct device *d, struct device_attribute *attr,
355 char *buf)
356{
357 struct net_device *dev = to_net_dev(d);
358 struct dsa_port *cpu_dp = dev->dsa_ptr;
359
360 return sysfs_emit(buf, fmt: "%s\n",
361 dsa_tag_protocol_to_str(ops: cpu_dp->tag_ops));
362}
363
364static ssize_t tagging_store(struct device *d, struct device_attribute *attr,
365 const char *buf, size_t count)
366{
367 const struct dsa_device_ops *new_tag_ops, *old_tag_ops;
368 const char *end = strchrnul(buf, '\n'), *name;
369 struct net_device *dev = to_net_dev(d);
370 struct dsa_port *cpu_dp = dev->dsa_ptr;
371 size_t len = end - buf;
372 int err;
373
374 /* Empty string passed */
375 if (!len)
376 return -ENOPROTOOPT;
377
378 name = kstrndup(s: buf, len, GFP_KERNEL);
379 if (!name)
380 return -ENOMEM;
381
382 old_tag_ops = cpu_dp->tag_ops;
383 new_tag_ops = dsa_tag_driver_get_by_name(name);
384 kfree(objp: name);
385 /* Bad tagger name? */
386 if (IS_ERR(ptr: new_tag_ops))
387 return PTR_ERR(ptr: new_tag_ops);
388
389 if (new_tag_ops == old_tag_ops)
390 /* Drop the temporarily held duplicate reference, since
391 * the DSA switch tree uses this tagger.
392 */
393 goto out;
394
395 err = dsa_tree_change_tag_proto(dst: cpu_dp->ds->dst, tag_ops: new_tag_ops,
396 old_tag_ops);
397 if (err) {
398 /* On failure the old tagger is restored, so we don't need the
399 * driver for the new one.
400 */
401 dsa_tag_driver_put(ops: new_tag_ops);
402 return err;
403 }
404
405 /* On success we no longer need the module for the old tagging protocol
406 */
407out:
408 dsa_tag_driver_put(ops: old_tag_ops);
409 return count;
410}
411static DEVICE_ATTR_RW(tagging);
412
413static struct attribute *dsa_user_attrs[] = {
414 &dev_attr_tagging.attr,
415 NULL
416};
417
418static const struct attribute_group dsa_group = {
419 .name = "dsa",
420 .attrs = dsa_user_attrs,
421};
422
423static void dsa_conduit_reset_mtu(struct net_device *dev)
424{
425 int err;
426
427 err = dev_set_mtu(dev, ETH_DATA_LEN);
428 if (err)
429 netdev_dbg(dev,
430 "Unable to reset MTU to exclude DSA overheads\n");
431}
432
433int dsa_conduit_setup(struct net_device *dev, struct dsa_port *cpu_dp)
434{
435 const struct dsa_device_ops *tag_ops = cpu_dp->tag_ops;
436 struct dsa_switch *ds = cpu_dp->ds;
437 struct device_link *consumer_link;
438 int mtu, ret;
439
440 mtu = ETH_DATA_LEN + dsa_tag_protocol_overhead(ops: tag_ops);
441
442 /* The DSA conduit must use SET_NETDEV_DEV for this to work. */
443 if (!netif_is_lag_master(dev)) {
444 consumer_link = device_link_add(consumer: ds->dev, supplier: dev->dev.parent,
445 DL_FLAG_AUTOREMOVE_CONSUMER);
446 if (!consumer_link)
447 netdev_err(dev,
448 format: "Failed to create a device link to DSA switch %s\n",
449 dev_name(dev: ds->dev));
450 }
451
452 /* The switch driver may not implement ->port_change_mtu(), case in
453 * which dsa_user_change_mtu() will not update the conduit MTU either,
454 * so we need to do that here.
455 */
456 ret = dev_set_mtu(dev, mtu);
457 if (ret)
458 netdev_warn(dev, format: "error %d setting MTU to %d to include DSA overhead\n",
459 ret, mtu);
460
461 /* If we use a tagging format that doesn't have an ethertype
462 * field, make sure that all packets from this point on get
463 * sent to the tag format's receive function.
464 */
465 wmb();
466
467 dev->dsa_ptr = cpu_dp;
468
469 dsa_conduit_set_promiscuity(dev, inc: 1);
470
471 ret = dsa_conduit_ethtool_setup(dev);
472 if (ret)
473 goto out_err_reset_promisc;
474
475 ret = sysfs_create_group(kobj: &dev->dev.kobj, grp: &dsa_group);
476 if (ret)
477 goto out_err_ethtool_teardown;
478
479 return ret;
480
481out_err_ethtool_teardown:
482 dsa_conduit_ethtool_teardown(dev);
483out_err_reset_promisc:
484 dsa_conduit_set_promiscuity(dev, inc: -1);
485 return ret;
486}
487
488void dsa_conduit_teardown(struct net_device *dev)
489{
490 sysfs_remove_group(kobj: &dev->dev.kobj, grp: &dsa_group);
491 dsa_conduit_ethtool_teardown(dev);
492 dsa_conduit_reset_mtu(dev);
493 dsa_conduit_set_promiscuity(dev, inc: -1);
494
495 dev->dsa_ptr = NULL;
496
497 /* If we used a tagging format that doesn't have an ethertype
498 * field, make sure that all packets from this point get sent
499 * without the tag and go through the regular receive path.
500 */
501 wmb();
502}
503
504int dsa_conduit_lag_setup(struct net_device *lag_dev, struct dsa_port *cpu_dp,
505 struct netdev_lag_upper_info *uinfo,
506 struct netlink_ext_ack *extack)
507{
508 bool conduit_setup = false;
509 int err;
510
511 if (!netdev_uses_dsa(dev: lag_dev)) {
512 err = dsa_conduit_setup(dev: lag_dev, cpu_dp);
513 if (err)
514 return err;
515
516 conduit_setup = true;
517 }
518
519 err = dsa_port_lag_join(dp: cpu_dp, lag_dev, uinfo, extack);
520 if (err) {
521 NL_SET_ERR_MSG_WEAK_MOD(extack, "CPU port failed to join LAG");
522 goto out_conduit_teardown;
523 }
524
525 return 0;
526
527out_conduit_teardown:
528 if (conduit_setup)
529 dsa_conduit_teardown(dev: lag_dev);
530 return err;
531}
532
533/* Tear down a conduit if there isn't any other user port on it,
534 * optionally also destroying LAG information.
535 */
536void dsa_conduit_lag_teardown(struct net_device *lag_dev,
537 struct dsa_port *cpu_dp)
538{
539 struct net_device *upper;
540 struct list_head *iter;
541
542 dsa_port_lag_leave(dp: cpu_dp, lag_dev);
543
544 netdev_for_each_upper_dev_rcu(lag_dev, upper, iter)
545 if (dsa_user_dev_check(dev: upper))
546 return;
547
548 dsa_conduit_teardown(dev: lag_dev);
549}
550

source code of linux/net/dsa/conduit.c