]> git.proxmox.com Git - mirror_ubuntu-hirsute-kernel.git/blame_incremental - net/dsa/slave.c
projects / mirror_ubuntu-hirsute-kernel.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
Merge tag 'asoc-v5.7' of https://git.kernel.org/pub/scm/linux/kernel/git/broonie...
[mirror_ubuntu-hirsute-kernel.git] / net / dsa / slave.c
... / ...
CommitLineData
1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 * net/dsa/slave.c - Slave device handling
4 * Copyright (c) 2008-2009 Marvell Semiconductor
5 */
6
7#include <linux/list.h>
8#include <linux/etherdevice.h>
9#include <linux/netdevice.h>
10#include <linux/phy.h>
11#include <linux/phy_fixed.h>
12#include <linux/phylink.h>
13#include <linux/of_net.h>
14#include <linux/of_mdio.h>
15#include <linux/mdio.h>
16#include <net/rtnetlink.h>
17#include <net/pkt_cls.h>
18#include <net/tc_act/tc_mirred.h>
19#include <linux/if_bridge.h>
20#include <linux/netpoll.h>
21#include <linux/ptp_classify.h>
22
23#include "dsa_priv.h"
24
25/* slave mii_bus handling ***************************************************/
26static int dsa_slave_phy_read(struct mii_bus *bus, int addr, int reg)
27{
28 struct dsa_switch *ds = bus->priv;
29
30 if (ds->phys_mii_mask & (1 << addr))
31 return ds->ops->phy_read(ds, addr, reg);
32
33 return 0xffff;
34}
35
36static int dsa_slave_phy_write(struct mii_bus *bus, int addr, int reg, u16 val)
37{
38 struct dsa_switch *ds = bus->priv;
39
40 if (ds->phys_mii_mask & (1 << addr))
41 return ds->ops->phy_write(ds, addr, reg, val);
42
43 return 0;
44}
45
46void dsa_slave_mii_bus_init(struct dsa_switch *ds)
47{
48 ds->slave_mii_bus->priv = (void *)ds;
49 ds->slave_mii_bus->name = "dsa slave smi";
50 ds->slave_mii_bus->read = dsa_slave_phy_read;
51 ds->slave_mii_bus->write = dsa_slave_phy_write;
52 snprintf(ds->slave_mii_bus->id, MII_BUS_ID_SIZE, "dsa-%d.%d",
53 ds->dst->index, ds->index);
54 ds->slave_mii_bus->parent = ds->dev;
55 ds->slave_mii_bus->phy_mask = ~ds->phys_mii_mask;
56}
57
58
59/* slave device handling ****************************************************/
60static int dsa_slave_get_iflink(const struct net_device *dev)
61{
62 return dsa_slave_to_master(dev)->ifindex;
63}
64
65static int dsa_slave_open(struct net_device *dev)
66{
67 struct net_device *master = dsa_slave_to_master(dev);
68 struct dsa_port *dp = dsa_slave_to_port(dev);
69 int err;
70
71 if (!(master->flags & IFF_UP))
72 return -ENETDOWN;
73
74 if (!ether_addr_equal(dev->dev_addr, master->dev_addr)) {
75 err = dev_uc_add(master, dev->dev_addr);
76 if (err < 0)
77 goto out;
78 }
79
80 if (dev->flags & IFF_ALLMULTI) {
81 err = dev_set_allmulti(master, 1);
82 if (err < 0)
83 goto del_unicast;
84 }
85 if (dev->flags & IFF_PROMISC) {
86 err = dev_set_promiscuity(master, 1);
87 if (err < 0)
88 goto clear_allmulti;
89 }
90
91 err = dsa_port_enable_rt(dp, dev->phydev);
92 if (err)
93 goto clear_promisc;
94
95 return 0;
96
97clear_promisc:
98 if (dev->flags & IFF_PROMISC)
99 dev_set_promiscuity(master, -1);
100clear_allmulti:
101 if (dev->flags & IFF_ALLMULTI)
102 dev_set_allmulti(master, -1);
103del_unicast:
104 if (!ether_addr_equal(dev->dev_addr, master->dev_addr))
105 dev_uc_del(master, dev->dev_addr);
106out:
107 return err;
108}
109
110static int dsa_slave_close(struct net_device *dev)
111{
112 struct net_device *master = dsa_slave_to_master(dev);
113 struct dsa_port *dp = dsa_slave_to_port(dev);
114
115 dsa_port_disable_rt(dp);
116
117 dev_mc_unsync(master, dev);
118 dev_uc_unsync(master, dev);
119 if (dev->flags & IFF_ALLMULTI)
120 dev_set_allmulti(master, -1);
121 if (dev->flags & IFF_PROMISC)
122 dev_set_promiscuity(master, -1);
123
124 if (!ether_addr_equal(dev->dev_addr, master->dev_addr))
125 dev_uc_del(master, dev->dev_addr);
126
127 return 0;
128}
129
130static void dsa_slave_change_rx_flags(struct net_device *dev, int change)
131{
132 struct net_device *master = dsa_slave_to_master(dev);
133 if (dev->flags & IFF_UP) {
134 if (change & IFF_ALLMULTI)
135 dev_set_allmulti(master,
136 dev->flags & IFF_ALLMULTI ? 1 : -1);
137 if (change & IFF_PROMISC)
138 dev_set_promiscuity(master,
139 dev->flags & IFF_PROMISC ? 1 : -1);
140 }
141}
142
143static void dsa_slave_set_rx_mode(struct net_device *dev)
144{
145 struct net_device *master = dsa_slave_to_master(dev);
146
147 dev_mc_sync(master, dev);
148 dev_uc_sync(master, dev);
149}
150
151static int dsa_slave_set_mac_address(struct net_device *dev, void *a)
152{
153 struct net_device *master = dsa_slave_to_master(dev);
154 struct sockaddr *addr = a;
155 int err;
156
157 if (!is_valid_ether_addr(addr->sa_data))
158 return -EADDRNOTAVAIL;
159
160 if (!(dev->flags & IFF_UP))
161 goto out;
162
163 if (!ether_addr_equal(addr->sa_data, master->dev_addr)) {
164 err = dev_uc_add(master, addr->sa_data);
165 if (err < 0)
166 return err;
167 }
168
169 if (!ether_addr_equal(dev->dev_addr, master->dev_addr))
170 dev_uc_del(master, dev->dev_addr);
171
172out:
173 ether_addr_copy(dev->dev_addr, addr->sa_data);
174
175 return 0;
176}
177
178struct dsa_slave_dump_ctx {
179 struct net_device *dev;
180 struct sk_buff *skb;
181 struct netlink_callback *cb;
182 int idx;
183};
184
185static int
186dsa_slave_port_fdb_do_dump(const unsigned char *addr, u16 vid,
187 bool is_static, void *data)
188{
189 struct dsa_slave_dump_ctx *dump = data;
190 u32 portid = NETLINK_CB(dump->cb->skb).portid;
191 u32 seq = dump->cb->nlh->nlmsg_seq;
192 struct nlmsghdr *nlh;
193 struct ndmsg *ndm;
194
195 if (dump->idx < dump->cb->args[2])
196 goto skip;
197
198 nlh = nlmsg_put(dump->skb, portid, seq, RTM_NEWNEIGH,
199 sizeof(*ndm), NLM_F_MULTI);
200 if (!nlh)
201 return -EMSGSIZE;
202
203 ndm = nlmsg_data(nlh);
204 ndm->ndm_family = AF_BRIDGE;
205 ndm->ndm_pad1 = 0;
206 ndm->ndm_pad2 = 0;
207 ndm->ndm_flags = NTF_SELF;
208 ndm->ndm_type = 0;
209 ndm->ndm_ifindex = dump->dev->ifindex;
210 ndm->ndm_state = is_static ? NUD_NOARP : NUD_REACHABLE;
211
212 if (nla_put(dump->skb, NDA_LLADDR, ETH_ALEN, addr))
213 goto nla_put_failure;
214
215 if (vid && nla_put_u16(dump->skb, NDA_VLAN, vid))
216 goto nla_put_failure;
217
218 nlmsg_end(dump->skb, nlh);
219
220skip:
221 dump->idx++;
222 return 0;
223
224nla_put_failure:
225 nlmsg_cancel(dump->skb, nlh);
226 return -EMSGSIZE;
227}
228
229static int
230dsa_slave_fdb_dump(struct sk_buff *skb, struct netlink_callback *cb,
231 struct net_device *dev, struct net_device *filter_dev,
232 int *idx)
233{
234 struct dsa_port *dp = dsa_slave_to_port(dev);
235 struct dsa_slave_dump_ctx dump = {
236 .dev = dev,
237 .skb = skb,
238 .cb = cb,
239 .idx = *idx,
240 };
241 int err;
242
243 err = dsa_port_fdb_dump(dp, dsa_slave_port_fdb_do_dump, &dump);
244 *idx = dump.idx;
245
246 return err;
247}
248
249static int dsa_slave_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
250{
251 struct dsa_slave_priv *p = netdev_priv(dev);
252 struct dsa_switch *ds = p->dp->ds;
253 int port = p->dp->index;
254
255 /* Pass through to switch driver if it supports timestamping */
256 switch (cmd) {
257 case SIOCGHWTSTAMP:
258 if (ds->ops->port_hwtstamp_get)
259 return ds->ops->port_hwtstamp_get(ds, port, ifr);
260 break;
261 case SIOCSHWTSTAMP:
262 if (ds->ops->port_hwtstamp_set)
263 return ds->ops->port_hwtstamp_set(ds, port, ifr);
264 break;
265 }
266
267 return phylink_mii_ioctl(p->dp->pl, ifr, cmd);
268}
269
270static int dsa_slave_port_attr_set(struct net_device *dev,
271 const struct switchdev_attr *attr,
272 struct switchdev_trans *trans)
273{
274 struct dsa_port *dp = dsa_slave_to_port(dev);
275 int ret;
276
277 switch (attr->id) {
278 case SWITCHDEV_ATTR_ID_PORT_STP_STATE:
279 ret = dsa_port_set_state(dp, attr->u.stp_state, trans);
280 break;
281 case SWITCHDEV_ATTR_ID_BRIDGE_VLAN_FILTERING:
282 ret = dsa_port_vlan_filtering(dp, attr->u.vlan_filtering,
283 trans);
284 break;
285 case SWITCHDEV_ATTR_ID_BRIDGE_AGEING_TIME:
286 ret = dsa_port_ageing_time(dp, attr->u.ageing_time, trans);
287 break;
288 case SWITCHDEV_ATTR_ID_PORT_PRE_BRIDGE_FLAGS:
289 ret = dsa_port_pre_bridge_flags(dp, attr->u.brport_flags,
290 trans);
291 break;
292 case SWITCHDEV_ATTR_ID_PORT_BRIDGE_FLAGS:
293 ret = dsa_port_bridge_flags(dp, attr->u.brport_flags, trans);
294 break;
295 case SWITCHDEV_ATTR_ID_BRIDGE_MROUTER:
296 ret = dsa_port_mrouter(dp->cpu_dp, attr->u.mrouter, trans);
297 break;
298 default:
299 ret = -EOPNOTSUPP;
300 break;
301 }
302
303 return ret;
304}
305
306static int dsa_slave_vlan_add(struct net_device *dev,
307 const struct switchdev_obj *obj,
308 struct switchdev_trans *trans)
309{
310 struct dsa_port *dp = dsa_slave_to_port(dev);
311 struct switchdev_obj_port_vlan vlan;
312 int err;
313
314 if (obj->orig_dev != dev)
315 return -EOPNOTSUPP;
316
317 if (dp->bridge_dev && !br_vlan_enabled(dp->bridge_dev))
318 return 0;
319
320 vlan = *SWITCHDEV_OBJ_PORT_VLAN(obj);
321
322 err = dsa_port_vlan_add(dp, &vlan, trans);
323 if (err)
324 return err;
325
326 /* We need the dedicated CPU port to be a member of the VLAN as well.
327 * Even though drivers often handle CPU membership in special ways,
328 * it doesn't make sense to program a PVID, so clear this flag.
329 */
330 vlan.flags &= ~BRIDGE_VLAN_INFO_PVID;
331
332 err = dsa_port_vlan_add(dp->cpu_dp, &vlan, trans);
333 if (err)
334 return err;
335
336 return 0;
337}
338
339static int dsa_slave_port_obj_add(struct net_device *dev,
340 const struct switchdev_obj *obj,
341 struct switchdev_trans *trans,
342 struct netlink_ext_ack *extack)
343{
344 struct dsa_port *dp = dsa_slave_to_port(dev);
345 int err;
346
347 /* For the prepare phase, ensure the full set of changes is feasable in
348 * one go in order to signal a failure properly. If an operation is not
349 * supported, return -EOPNOTSUPP.
350 */
351
352 switch (obj->id) {
353 case SWITCHDEV_OBJ_ID_PORT_MDB:
354 if (obj->orig_dev != dev)
355 return -EOPNOTSUPP;
356 err = dsa_port_mdb_add(dp, SWITCHDEV_OBJ_PORT_MDB(obj), trans);
357 break;
358 case SWITCHDEV_OBJ_ID_HOST_MDB:
359 /* DSA can directly translate this to a normal MDB add,
360 * but on the CPU port.
361 */
362 err = dsa_port_mdb_add(dp->cpu_dp, SWITCHDEV_OBJ_PORT_MDB(obj),
363 trans);
364 break;
365 case SWITCHDEV_OBJ_ID_PORT_VLAN:
366 err = dsa_slave_vlan_add(dev, obj, trans);
367 break;
368 default:
369 err = -EOPNOTSUPP;
370 break;
371 }
372
373 return err;
374}
375
376static int dsa_slave_vlan_del(struct net_device *dev,
377 const struct switchdev_obj *obj)
378{
379 struct dsa_port *dp = dsa_slave_to_port(dev);
380
381 if (obj->orig_dev != dev)
382 return -EOPNOTSUPP;
383
384 if (dp->bridge_dev && !br_vlan_enabled(dp->bridge_dev))
385 return 0;
386
387 /* Do not deprogram the CPU port as it may be shared with other user
388 * ports which can be members of this VLAN as well.
389 */
390 return dsa_port_vlan_del(dp, SWITCHDEV_OBJ_PORT_VLAN(obj));
391}
392
393static int dsa_slave_port_obj_del(struct net_device *dev,
394 const struct switchdev_obj *obj)
395{
396 struct dsa_port *dp = dsa_slave_to_port(dev);
397 int err;
398
399 switch (obj->id) {
400 case SWITCHDEV_OBJ_ID_PORT_MDB:
401 if (obj->orig_dev != dev)
402 return -EOPNOTSUPP;
403 err = dsa_port_mdb_del(dp, SWITCHDEV_OBJ_PORT_MDB(obj));
404 break;
405 case SWITCHDEV_OBJ_ID_HOST_MDB:
406 /* DSA can directly translate this to a normal MDB add,
407 * but on the CPU port.
408 */
409 err = dsa_port_mdb_del(dp->cpu_dp, SWITCHDEV_OBJ_PORT_MDB(obj));
410 break;
411 case SWITCHDEV_OBJ_ID_PORT_VLAN:
412 err = dsa_slave_vlan_del(dev, obj);
413 break;
414 default:
415 err = -EOPNOTSUPP;
416 break;
417 }
418
419 return err;
420}
421
422static int dsa_slave_get_port_parent_id(struct net_device *dev,
423 struct netdev_phys_item_id *ppid)
424{
425 struct dsa_port *dp = dsa_slave_to_port(dev);
426 struct dsa_switch *ds = dp->ds;
427 struct dsa_switch_tree *dst = ds->dst;
428
429 /* For non-legacy ports, devlink is used and it takes
430 * care of the name generation. This ndo implementation
431 * should be removed with legacy support.
432 */
433 if (dp->ds->devlink)
434 return -EOPNOTSUPP;
435
436 ppid->id_len = sizeof(dst->index);
437 memcpy(&ppid->id, &dst->index, ppid->id_len);
438
439 return 0;
440}
441
442static inline netdev_tx_t dsa_slave_netpoll_send_skb(struct net_device *dev,
443 struct sk_buff *skb)
444{
445#ifdef CONFIG_NET_POLL_CONTROLLER
446 struct dsa_slave_priv *p = netdev_priv(dev);
447
448 if (p->netpoll)
449 netpoll_send_skb(p->netpoll, skb);
450#else
451 BUG();
452#endif
453 return NETDEV_TX_OK;
454}
455
456static void dsa_skb_tx_timestamp(struct dsa_slave_priv *p,
457 struct sk_buff *skb)
458{
459 struct dsa_switch *ds = p->dp->ds;
460 struct sk_buff *clone;
461 unsigned int type;
462
463 type = ptp_classify_raw(skb);
464 if (type == PTP_CLASS_NONE)
465 return;
466
467 if (!ds->ops->port_txtstamp)
468 return;
469
470 clone = skb_clone_sk(skb);
471 if (!clone)
472 return;
473
474 DSA_SKB_CB(skb)->clone = clone;
475
476 if (ds->ops->port_txtstamp(ds, p->dp->index, clone, type))
477 return;
478
479 kfree_skb(clone);
480}
481
482netdev_tx_t dsa_enqueue_skb(struct sk_buff *skb, struct net_device *dev)
483{
484 /* SKB for netpoll still need to be mangled with the protocol-specific
485 * tag to be successfully transmitted
486 */
487 if (unlikely(netpoll_tx_running(dev)))
488 return dsa_slave_netpoll_send_skb(dev, skb);
489
490 /* Queue the SKB for transmission on the parent interface, but
491 * do not modify its EtherType
492 */
493 skb->dev = dsa_slave_to_master(dev);
494 dev_queue_xmit(skb);
495
496 return NETDEV_TX_OK;
497}
498EXPORT_SYMBOL_GPL(dsa_enqueue_skb);
499
500static netdev_tx_t dsa_slave_xmit(struct sk_buff *skb, struct net_device *dev)
501{
502 struct dsa_slave_priv *p = netdev_priv(dev);
503 struct pcpu_sw_netstats *s;
504 struct sk_buff *nskb;
505
506 s = this_cpu_ptr(p->stats64);
507 u64_stats_update_begin(&s->syncp);
508 s->tx_packets++;
509 s->tx_bytes += skb->len;
510 u64_stats_update_end(&s->syncp);
511
512 DSA_SKB_CB(skb)->clone = NULL;
513
514 /* Identify PTP protocol packets, clone them, and pass them to the
515 * switch driver
516 */
517 dsa_skb_tx_timestamp(p, skb);
518
519 /* Transmit function may have to reallocate the original SKB,
520 * in which case it must have freed it. Only free it here on error.
521 */
522 nskb = p->xmit(skb, dev);
523 if (!nskb) {
524 kfree_skb(skb);
525 return NETDEV_TX_OK;
526 }
527
528 return dsa_enqueue_skb(nskb, dev);
529}
530
531/* ethtool operations *******************************************************/
532
533static void dsa_slave_get_drvinfo(struct net_device *dev,
534 struct ethtool_drvinfo *drvinfo)
535{
536 strlcpy(drvinfo->driver, "dsa", sizeof(drvinfo->driver));
537 strlcpy(drvinfo->fw_version, "N/A", sizeof(drvinfo->fw_version));
538 strlcpy(drvinfo->bus_info, "platform", sizeof(drvinfo->bus_info));
539}
540
541static int dsa_slave_get_regs_len(struct net_device *dev)
542{
543 struct dsa_port *dp = dsa_slave_to_port(dev);
544 struct dsa_switch *ds = dp->ds;
545
546 if (ds->ops->get_regs_len)
547 return ds->ops->get_regs_len(ds, dp->index);
548
549 return -EOPNOTSUPP;
550}
551
552static void
553dsa_slave_get_regs(struct net_device *dev, struct ethtool_regs *regs, void *_p)
554{
555 struct dsa_port *dp = dsa_slave_to_port(dev);
556 struct dsa_switch *ds = dp->ds;
557
558 if (ds->ops->get_regs)
559 ds->ops->get_regs(ds, dp->index, regs, _p);
560}
561
562static int dsa_slave_nway_reset(struct net_device *dev)
563{
564 struct dsa_port *dp = dsa_slave_to_port(dev);
565
566 return phylink_ethtool_nway_reset(dp->pl);
567}
568
569static int dsa_slave_get_eeprom_len(struct net_device *dev)
570{
571 struct dsa_port *dp = dsa_slave_to_port(dev);
572 struct dsa_switch *ds = dp->ds;
573
574 if (ds->cd && ds->cd->eeprom_len)
575 return ds->cd->eeprom_len;
576
577 if (ds->ops->get_eeprom_len)
578 return ds->ops->get_eeprom_len(ds);
579
580 return 0;
581}
582
583static int dsa_slave_get_eeprom(struct net_device *dev,
584 struct ethtool_eeprom *eeprom, u8 *data)
585{
586 struct dsa_port *dp = dsa_slave_to_port(dev);
587 struct dsa_switch *ds = dp->ds;
588
589 if (ds->ops->get_eeprom)
590 return ds->ops->get_eeprom(ds, eeprom, data);
591
592 return -EOPNOTSUPP;
593}
594
595static int dsa_slave_set_eeprom(struct net_device *dev,
596 struct ethtool_eeprom *eeprom, u8 *data)
597{
598 struct dsa_port *dp = dsa_slave_to_port(dev);
599 struct dsa_switch *ds = dp->ds;
600
601 if (ds->ops->set_eeprom)
602 return ds->ops->set_eeprom(ds, eeprom, data);
603
604 return -EOPNOTSUPP;
605}
606
607static void dsa_slave_get_strings(struct net_device *dev,
608 uint32_t stringset, uint8_t *data)
609{
610 struct dsa_port *dp = dsa_slave_to_port(dev);
611 struct dsa_switch *ds = dp->ds;
612
613 if (stringset == ETH_SS_STATS) {
614 int len = ETH_GSTRING_LEN;
615
616 strncpy(data, "tx_packets", len);
617 strncpy(data + len, "tx_bytes", len);
618 strncpy(data + 2 * len, "rx_packets", len);
619 strncpy(data + 3 * len, "rx_bytes", len);
620 if (ds->ops->get_strings)
621 ds->ops->get_strings(ds, dp->index, stringset,
622 data + 4 * len);
623 }
624}
625
626static void dsa_slave_get_ethtool_stats(struct net_device *dev,
627 struct ethtool_stats *stats,
628 uint64_t *data)
629{
630 struct dsa_port *dp = dsa_slave_to_port(dev);
631 struct dsa_slave_priv *p = netdev_priv(dev);
632 struct dsa_switch *ds = dp->ds;
633 struct pcpu_sw_netstats *s;
634 unsigned int start;
635 int i;
636
637 for_each_possible_cpu(i) {
638 u64 tx_packets, tx_bytes, rx_packets, rx_bytes;
639
640 s = per_cpu_ptr(p->stats64, i);
641 do {
642 start = u64_stats_fetch_begin_irq(&s->syncp);
643 tx_packets = s->tx_packets;
644 tx_bytes = s->tx_bytes;
645 rx_packets = s->rx_packets;
646 rx_bytes = s->rx_bytes;
647 } while (u64_stats_fetch_retry_irq(&s->syncp, start));
648 data[0] += tx_packets;
649 data[1] += tx_bytes;
650 data[2] += rx_packets;
651 data[3] += rx_bytes;
652 }
653 if (ds->ops->get_ethtool_stats)
654 ds->ops->get_ethtool_stats(ds, dp->index, data + 4);
655}
656
657static int dsa_slave_get_sset_count(struct net_device *dev, int sset)
658{
659 struct dsa_port *dp = dsa_slave_to_port(dev);
660 struct dsa_switch *ds = dp->ds;
661
662 if (sset == ETH_SS_STATS) {
663 int count;
664
665 count = 4;
666 if (ds->ops->get_sset_count)
667 count += ds->ops->get_sset_count(ds, dp->index, sset);
668
669 return count;
670 }
671
672 return -EOPNOTSUPP;
673}
674
675static void dsa_slave_get_wol(struct net_device *dev, struct ethtool_wolinfo *w)
676{
677 struct dsa_port *dp = dsa_slave_to_port(dev);
678 struct dsa_switch *ds = dp->ds;
679
680 phylink_ethtool_get_wol(dp->pl, w);
681
682 if (ds->ops->get_wol)
683 ds->ops->get_wol(ds, dp->index, w);
684}
685
686static int dsa_slave_set_wol(struct net_device *dev, struct ethtool_wolinfo *w)
687{
688 struct dsa_port *dp = dsa_slave_to_port(dev);
689 struct dsa_switch *ds = dp->ds;
690 int ret = -EOPNOTSUPP;
691
692 phylink_ethtool_set_wol(dp->pl, w);
693
694 if (ds->ops->set_wol)
695 ret = ds->ops->set_wol(ds, dp->index, w);
696
697 return ret;
698}
699
700static int dsa_slave_set_eee(struct net_device *dev, struct ethtool_eee *e)
701{
702 struct dsa_port *dp = dsa_slave_to_port(dev);
703 struct dsa_switch *ds = dp->ds;
704 int ret;
705
706 /* Port's PHY and MAC both need to be EEE capable */
707 if (!dev->phydev || !dp->pl)
708 return -ENODEV;
709
710 if (!ds->ops->set_mac_eee)
711 return -EOPNOTSUPP;
712
713 ret = ds->ops->set_mac_eee(ds, dp->index, e);
714 if (ret)
715 return ret;
716
717 return phylink_ethtool_set_eee(dp->pl, e);
718}
719
720static int dsa_slave_get_eee(struct net_device *dev, struct ethtool_eee *e)
721{
722 struct dsa_port *dp = dsa_slave_to_port(dev);
723 struct dsa_switch *ds = dp->ds;
724 int ret;
725
726 /* Port's PHY and MAC both need to be EEE capable */
727 if (!dev->phydev || !dp->pl)
728 return -ENODEV;
729
730 if (!ds->ops->get_mac_eee)
731 return -EOPNOTSUPP;
732
733 ret = ds->ops->get_mac_eee(ds, dp->index, e);
734 if (ret)
735 return ret;
736
737 return phylink_ethtool_get_eee(dp->pl, e);
738}
739
740static int dsa_slave_get_link_ksettings(struct net_device *dev,
741 struct ethtool_link_ksettings *cmd)
742{
743 struct dsa_port *dp = dsa_slave_to_port(dev);
744
745 return phylink_ethtool_ksettings_get(dp->pl, cmd);
746}
747
748static int dsa_slave_set_link_ksettings(struct net_device *dev,
749 const struct ethtool_link_ksettings *cmd)
750{
751 struct dsa_port *dp = dsa_slave_to_port(dev);
752
753 return phylink_ethtool_ksettings_set(dp->pl, cmd);
754}
755
756static void dsa_slave_get_pauseparam(struct net_device *dev,
757 struct ethtool_pauseparam *pause)
758{
759 struct dsa_port *dp = dsa_slave_to_port(dev);
760
761 phylink_ethtool_get_pauseparam(dp->pl, pause);
762}
763
764static int dsa_slave_set_pauseparam(struct net_device *dev,
765 struct ethtool_pauseparam *pause)
766{
767 struct dsa_port *dp = dsa_slave_to_port(dev);
768
769 return phylink_ethtool_set_pauseparam(dp->pl, pause);
770}
771
772#ifdef CONFIG_NET_POLL_CONTROLLER
773static int dsa_slave_netpoll_setup(struct net_device *dev,
774 struct netpoll_info *ni)
775{
776 struct net_device *master = dsa_slave_to_master(dev);
777 struct dsa_slave_priv *p = netdev_priv(dev);
778 struct netpoll *netpoll;
779 int err = 0;
780
781 netpoll = kzalloc(sizeof(*netpoll), GFP_KERNEL);
782 if (!netpoll)
783 return -ENOMEM;
784
785 err = __netpoll_setup(netpoll, master);
786 if (err) {
787 kfree(netpoll);
788 goto out;
789 }
790
791 p->netpoll = netpoll;
792out:
793 return err;
794}
795
796static void dsa_slave_netpoll_cleanup(struct net_device *dev)
797{
798 struct dsa_slave_priv *p = netdev_priv(dev);
799 struct netpoll *netpoll = p->netpoll;
800
801 if (!netpoll)
802 return;
803
804 p->netpoll = NULL;
805
806 __netpoll_free(netpoll);
807}
808
809static void dsa_slave_poll_controller(struct net_device *dev)
810{
811}
812#endif
813
814static int dsa_slave_get_phys_port_name(struct net_device *dev,
815 char *name, size_t len)
816{
817 struct dsa_port *dp = dsa_slave_to_port(dev);
818
819 /* For non-legacy ports, devlink is used and it takes
820 * care of the name generation. This ndo implementation
821 * should be removed with legacy support.
822 */
823 if (dp->ds->devlink)
824 return -EOPNOTSUPP;
825
826 if (snprintf(name, len, "p%d", dp->index) >= len)
827 return -EINVAL;
828
829 return 0;
830}
831
832static struct dsa_mall_tc_entry *
833dsa_slave_mall_tc_entry_find(struct net_device *dev, unsigned long cookie)
834{
835 struct dsa_slave_priv *p = netdev_priv(dev);
836 struct dsa_mall_tc_entry *mall_tc_entry;
837
838 list_for_each_entry(mall_tc_entry, &p->mall_tc_list, list)
839 if (mall_tc_entry->cookie == cookie)
840 return mall_tc_entry;
841
842 return NULL;
843}
844
845static int dsa_slave_add_cls_matchall(struct net_device *dev,
846 struct tc_cls_matchall_offload *cls,
847 bool ingress)
848{
849 struct dsa_port *dp = dsa_slave_to_port(dev);
850 struct dsa_slave_priv *p = netdev_priv(dev);
851 struct dsa_mall_tc_entry *mall_tc_entry;
852 __be16 protocol = cls->common.protocol;
853 struct dsa_switch *ds = dp->ds;
854 struct flow_action_entry *act;
855 struct dsa_port *to_dp;
856 int err = -EOPNOTSUPP;
857
858 if (!ds->ops->port_mirror_add)
859 return err;
860
861 if (!flow_offload_has_one_action(&cls->rule->action))
862 return err;
863
864 act = &cls->rule->action.entries[0];
865
866 if (act->id == FLOW_ACTION_MIRRED && protocol == htons(ETH_P_ALL)) {
867 struct dsa_mall_mirror_tc_entry *mirror;
868
869 if (!act->dev)
870 return -EINVAL;
871
872 if (!dsa_slave_dev_check(act->dev))
873 return -EOPNOTSUPP;
874
875 mall_tc_entry = kzalloc(sizeof(*mall_tc_entry), GFP_KERNEL);
876 if (!mall_tc_entry)
877 return -ENOMEM;
878
879 mall_tc_entry->cookie = cls->cookie;
880 mall_tc_entry->type = DSA_PORT_MALL_MIRROR;
881 mirror = &mall_tc_entry->mirror;
882
883 to_dp = dsa_slave_to_port(act->dev);
884
885 mirror->to_local_port = to_dp->index;
886 mirror->ingress = ingress;
887
888 err = ds->ops->port_mirror_add(ds, dp->index, mirror, ingress);
889 if (err) {
890 kfree(mall_tc_entry);
891 return err;
892 }
893
894 list_add_tail(&mall_tc_entry->list, &p->mall_tc_list);
895 }
896
897 return 0;
898}
899
900static void dsa_slave_del_cls_matchall(struct net_device *dev,
901 struct tc_cls_matchall_offload *cls)
902{
903 struct dsa_port *dp = dsa_slave_to_port(dev);
904 struct dsa_mall_tc_entry *mall_tc_entry;
905 struct dsa_switch *ds = dp->ds;
906
907 if (!ds->ops->port_mirror_del)
908 return;
909
910 mall_tc_entry = dsa_slave_mall_tc_entry_find(dev, cls->cookie);
911 if (!mall_tc_entry)
912 return;
913
914 list_del(&mall_tc_entry->list);
915
916 switch (mall_tc_entry->type) {
917 case DSA_PORT_MALL_MIRROR:
918 ds->ops->port_mirror_del(ds, dp->index, &mall_tc_entry->mirror);
919 break;
920 default:
921 WARN_ON(1);
922 }
923
924 kfree(mall_tc_entry);
925}
926
927static int dsa_slave_setup_tc_cls_matchall(struct net_device *dev,
928 struct tc_cls_matchall_offload *cls,
929 bool ingress)
930{
931 if (cls->common.chain_index)
932 return -EOPNOTSUPP;
933
934 switch (cls->command) {
935 case TC_CLSMATCHALL_REPLACE:
936 return dsa_slave_add_cls_matchall(dev, cls, ingress);
937 case TC_CLSMATCHALL_DESTROY:
938 dsa_slave_del_cls_matchall(dev, cls);
939 return 0;
940 default:
941 return -EOPNOTSUPP;
942 }
943}
944
945static int dsa_slave_setup_tc_block_cb(enum tc_setup_type type, void *type_data,
946 void *cb_priv, bool ingress)
947{
948 struct net_device *dev = cb_priv;
949
950 if (!tc_can_offload(dev))
951 return -EOPNOTSUPP;
952
953 switch (type) {
954 case TC_SETUP_CLSMATCHALL:
955 return dsa_slave_setup_tc_cls_matchall(dev, type_data, ingress);
956 default:
957 return -EOPNOTSUPP;
958 }
959}
960
961static int dsa_slave_setup_tc_block_cb_ig(enum tc_setup_type type,
962 void *type_data, void *cb_priv)
963{
964 return dsa_slave_setup_tc_block_cb(type, type_data, cb_priv, true);
965}
966
967static int dsa_slave_setup_tc_block_cb_eg(enum tc_setup_type type,
968 void *type_data, void *cb_priv)
969{
970 return dsa_slave_setup_tc_block_cb(type, type_data, cb_priv, false);
971}
972
973static LIST_HEAD(dsa_slave_block_cb_list);
974
975static int dsa_slave_setup_tc_block(struct net_device *dev,
976 struct flow_block_offload *f)
977{
978 struct flow_block_cb *block_cb;
979 flow_setup_cb_t *cb;
980
981 if (f->binder_type == FLOW_BLOCK_BINDER_TYPE_CLSACT_INGRESS)
982 cb = dsa_slave_setup_tc_block_cb_ig;
983 else if (f->binder_type == FLOW_BLOCK_BINDER_TYPE_CLSACT_EGRESS)
984 cb = dsa_slave_setup_tc_block_cb_eg;
985 else
986 return -EOPNOTSUPP;
987
988 f->driver_block_list = &dsa_slave_block_cb_list;
989
990 switch (f->command) {
991 case FLOW_BLOCK_BIND:
992 if (flow_block_cb_is_busy(cb, dev, &dsa_slave_block_cb_list))
993 return -EBUSY;
994
995 block_cb = flow_block_cb_alloc(cb, dev, dev, NULL);
996 if (IS_ERR(block_cb))
997 return PTR_ERR(block_cb);
998
999 flow_block_cb_add(block_cb, f);
1000 list_add_tail(&block_cb->driver_list, &dsa_slave_block_cb_list);
1001 return 0;
1002 case FLOW_BLOCK_UNBIND:
1003 block_cb = flow_block_cb_lookup(f->block, cb, dev);
1004 if (!block_cb)
1005 return -ENOENT;
1006
1007 flow_block_cb_remove(block_cb, f);
1008 list_del(&block_cb->driver_list);
1009 return 0;
1010 default:
1011 return -EOPNOTSUPP;
1012 }
1013}
1014
1015static int dsa_slave_setup_tc(struct net_device *dev, enum tc_setup_type type,
1016 void *type_data)
1017{
1018 struct dsa_port *dp = dsa_slave_to_port(dev);
1019 struct dsa_switch *ds = dp->ds;
1020
1021 if (type == TC_SETUP_BLOCK)
1022 return dsa_slave_setup_tc_block(dev, type_data);
1023
1024 if (!ds->ops->port_setup_tc)
1025 return -EOPNOTSUPP;
1026
1027 return ds->ops->port_setup_tc(ds, dp->index, type, type_data);
1028}
1029
1030static void dsa_slave_get_stats64(struct net_device *dev,
1031 struct rtnl_link_stats64 *stats)
1032{
1033 struct dsa_slave_priv *p = netdev_priv(dev);
1034 struct pcpu_sw_netstats *s;
1035 unsigned int start;
1036 int i;
1037
1038 netdev_stats_to_stats64(stats, &dev->stats);
1039 for_each_possible_cpu(i) {
1040 u64 tx_packets, tx_bytes, rx_packets, rx_bytes;
1041
1042 s = per_cpu_ptr(p->stats64, i);
1043 do {
1044 start = u64_stats_fetch_begin_irq(&s->syncp);
1045 tx_packets = s->tx_packets;
1046 tx_bytes = s->tx_bytes;
1047 rx_packets = s->rx_packets;
1048 rx_bytes = s->rx_bytes;
1049 } while (u64_stats_fetch_retry_irq(&s->syncp, start));
1050
1051 stats->tx_packets += tx_packets;
1052 stats->tx_bytes += tx_bytes;
1053 stats->rx_packets += rx_packets;
1054 stats->rx_bytes += rx_bytes;
1055 }
1056}
1057
1058static int dsa_slave_get_rxnfc(struct net_device *dev,
1059 struct ethtool_rxnfc *nfc, u32 *rule_locs)
1060{
1061 struct dsa_port *dp = dsa_slave_to_port(dev);
1062 struct dsa_switch *ds = dp->ds;
1063
1064 if (!ds->ops->get_rxnfc)
1065 return -EOPNOTSUPP;
1066
1067 return ds->ops->get_rxnfc(ds, dp->index, nfc, rule_locs);
1068}
1069
1070static int dsa_slave_set_rxnfc(struct net_device *dev,
1071 struct ethtool_rxnfc *nfc)
1072{
1073 struct dsa_port *dp = dsa_slave_to_port(dev);
1074 struct dsa_switch *ds = dp->ds;
1075
1076 if (!ds->ops->set_rxnfc)
1077 return -EOPNOTSUPP;
1078
1079 return ds->ops->set_rxnfc(ds, dp->index, nfc);
1080}
1081
1082static int dsa_slave_get_ts_info(struct net_device *dev,
1083 struct ethtool_ts_info *ts)
1084{
1085 struct dsa_slave_priv *p = netdev_priv(dev);
1086 struct dsa_switch *ds = p->dp->ds;
1087
1088 if (!ds->ops->get_ts_info)
1089 return -EOPNOTSUPP;
1090
1091 return ds->ops->get_ts_info(ds, p->dp->index, ts);
1092}
1093
1094static int dsa_slave_vlan_rx_add_vid(struct net_device *dev, __be16 proto,
1095 u16 vid)
1096{
1097 struct dsa_port *dp = dsa_slave_to_port(dev);
1098 struct bridge_vlan_info info;
1099 int ret;
1100
1101 /* Check for a possible bridge VLAN entry now since there is no
1102 * need to emulate the switchdev prepare + commit phase.
1103 */
1104 if (dp->bridge_dev) {
1105 if (!br_vlan_enabled(dp->bridge_dev))
1106 return 0;
1107
1108 /* br_vlan_get_info() returns -EINVAL or -ENOENT if the
1109 * device, respectively the VID is not found, returning
1110 * 0 means success, which is a failure for us here.
1111 */
1112 ret = br_vlan_get_info(dp->bridge_dev, vid, &info);
1113 if (ret == 0)
1114 return -EBUSY;
1115 }
1116
1117 ret = dsa_port_vid_add(dp, vid, 0);
1118 if (ret)
1119 return ret;
1120
1121 ret = dsa_port_vid_add(dp->cpu_dp, vid, 0);
1122 if (ret)
1123 return ret;
1124
1125 return 0;
1126}
1127
1128static int dsa_slave_vlan_rx_kill_vid(struct net_device *dev, __be16 proto,
1129 u16 vid)
1130{
1131 struct dsa_port *dp = dsa_slave_to_port(dev);
1132 struct bridge_vlan_info info;
1133 int ret;
1134
1135 /* Check for a possible bridge VLAN entry now since there is no
1136 * need to emulate the switchdev prepare + commit phase.
1137 */
1138 if (dp->bridge_dev) {
1139 if (!br_vlan_enabled(dp->bridge_dev))
1140 return 0;
1141
1142 /* br_vlan_get_info() returns -EINVAL or -ENOENT if the
1143 * device, respectively the VID is not found, returning
1144 * 0 means success, which is a failure for us here.
1145 */
1146 ret = br_vlan_get_info(dp->bridge_dev, vid, &info);
1147 if (ret == 0)
1148 return -EBUSY;
1149 }
1150
1151 /* Do not deprogram the CPU port as it may be shared with other user
1152 * ports which can be members of this VLAN as well.
1153 */
1154 return dsa_port_vid_del(dp, vid);
1155}
1156
1157static const struct ethtool_ops dsa_slave_ethtool_ops = {
1158 .get_drvinfo = dsa_slave_get_drvinfo,
1159 .get_regs_len = dsa_slave_get_regs_len,
1160 .get_regs = dsa_slave_get_regs,
1161 .nway_reset = dsa_slave_nway_reset,
1162 .get_link = ethtool_op_get_link,
1163 .get_eeprom_len = dsa_slave_get_eeprom_len,
1164 .get_eeprom = dsa_slave_get_eeprom,
1165 .set_eeprom = dsa_slave_set_eeprom,
1166 .get_strings = dsa_slave_get_strings,
1167 .get_ethtool_stats = dsa_slave_get_ethtool_stats,
1168 .get_sset_count = dsa_slave_get_sset_count,
1169 .set_wol = dsa_slave_set_wol,
1170 .get_wol = dsa_slave_get_wol,
1171 .set_eee = dsa_slave_set_eee,
1172 .get_eee = dsa_slave_get_eee,
1173 .get_link_ksettings = dsa_slave_get_link_ksettings,
1174 .set_link_ksettings = dsa_slave_set_link_ksettings,
1175 .get_pauseparam = dsa_slave_get_pauseparam,
1176 .set_pauseparam = dsa_slave_set_pauseparam,
1177 .get_rxnfc = dsa_slave_get_rxnfc,
1178 .set_rxnfc = dsa_slave_set_rxnfc,
1179 .get_ts_info = dsa_slave_get_ts_info,
1180};
1181
1182/* legacy way, bypassing the bridge *****************************************/
1183int dsa_legacy_fdb_add(struct ndmsg *ndm, struct nlattr *tb[],
1184 struct net_device *dev,
1185 const unsigned char *addr, u16 vid,
1186 u16 flags,
1187 struct netlink_ext_ack *extack)
1188{
1189 struct dsa_port *dp = dsa_slave_to_port(dev);
1190
1191 return dsa_port_fdb_add(dp, addr, vid);
1192}
1193
1194int dsa_legacy_fdb_del(struct ndmsg *ndm, struct nlattr *tb[],
1195 struct net_device *dev,
1196 const unsigned char *addr, u16 vid)
1197{
1198 struct dsa_port *dp = dsa_slave_to_port(dev);
1199
1200 return dsa_port_fdb_del(dp, addr, vid);
1201}
1202
1203static struct devlink_port *dsa_slave_get_devlink_port(struct net_device *dev)
1204{
1205 struct dsa_port *dp = dsa_slave_to_port(dev);
1206
1207 return dp->ds->devlink ? &dp->devlink_port : NULL;
1208}
1209
1210static const struct net_device_ops dsa_slave_netdev_ops = {
1211 .ndo_open = dsa_slave_open,
1212 .ndo_stop = dsa_slave_close,
1213 .ndo_start_xmit = dsa_slave_xmit,
1214 .ndo_change_rx_flags = dsa_slave_change_rx_flags,
1215 .ndo_set_rx_mode = dsa_slave_set_rx_mode,
1216 .ndo_set_mac_address = dsa_slave_set_mac_address,
1217 .ndo_fdb_add = dsa_legacy_fdb_add,
1218 .ndo_fdb_del = dsa_legacy_fdb_del,
1219 .ndo_fdb_dump = dsa_slave_fdb_dump,
1220 .ndo_do_ioctl = dsa_slave_ioctl,
1221 .ndo_get_iflink = dsa_slave_get_iflink,
1222#ifdef CONFIG_NET_POLL_CONTROLLER
1223 .ndo_netpoll_setup = dsa_slave_netpoll_setup,
1224 .ndo_netpoll_cleanup = dsa_slave_netpoll_cleanup,
1225 .ndo_poll_controller = dsa_slave_poll_controller,
1226#endif
1227 .ndo_get_phys_port_name = dsa_slave_get_phys_port_name,
1228 .ndo_setup_tc = dsa_slave_setup_tc,
1229 .ndo_get_stats64 = dsa_slave_get_stats64,
1230 .ndo_get_port_parent_id = dsa_slave_get_port_parent_id,
1231 .ndo_vlan_rx_add_vid = dsa_slave_vlan_rx_add_vid,
1232 .ndo_vlan_rx_kill_vid = dsa_slave_vlan_rx_kill_vid,
1233 .ndo_get_devlink_port = dsa_slave_get_devlink_port,
1234};
1235
1236static struct device_type dsa_type = {
1237 .name = "dsa",
1238};
1239
1240void dsa_port_phylink_mac_change(struct dsa_switch *ds, int port, bool up)
1241{
1242 const struct dsa_port *dp = dsa_to_port(ds, port);
1243
1244 phylink_mac_change(dp->pl, up);
1245}
1246EXPORT_SYMBOL_GPL(dsa_port_phylink_mac_change);
1247
1248static void dsa_slave_phylink_fixed_state(struct net_device *dev,
1249 struct phylink_link_state *state)
1250{
1251 struct dsa_port *dp = dsa_slave_to_port(dev);
1252 struct dsa_switch *ds = dp->ds;
1253
1254 /* No need to check that this operation is valid, the callback would
1255 * not be called if it was not.
1256 */
1257 ds->ops->phylink_fixed_state(ds, dp->index, state);
1258}
1259
1260/* slave device setup *******************************************************/
1261static int dsa_slave_phy_connect(struct net_device *slave_dev, int addr)
1262{
1263 struct dsa_port *dp = dsa_slave_to_port(slave_dev);
1264 struct dsa_switch *ds = dp->ds;
1265
1266 slave_dev->phydev = mdiobus_get_phy(ds->slave_mii_bus, addr);
1267 if (!slave_dev->phydev) {
1268 netdev_err(slave_dev, "no phy at %d\n", addr);
1269 return -ENODEV;
1270 }
1271
1272 return phylink_connect_phy(dp->pl, slave_dev->phydev);
1273}
1274
1275static int dsa_slave_phy_setup(struct net_device *slave_dev)
1276{
1277 struct dsa_port *dp = dsa_slave_to_port(slave_dev);
1278 struct device_node *port_dn = dp->dn;
1279 struct dsa_switch *ds = dp->ds;
1280 phy_interface_t mode;
1281 u32 phy_flags = 0;
1282 int ret;
1283
1284 ret = of_get_phy_mode(port_dn, &mode);
1285 if (ret)
1286 mode = PHY_INTERFACE_MODE_NA;
1287
1288 dp->pl_config.dev = &slave_dev->dev;
1289 dp->pl_config.type = PHYLINK_NETDEV;
1290
1291 dp->pl = phylink_create(&dp->pl_config, of_fwnode_handle(port_dn), mode,
1292 &dsa_port_phylink_mac_ops);
1293 if (IS_ERR(dp->pl)) {
1294 netdev_err(slave_dev,
1295 "error creating PHYLINK: %ld\n", PTR_ERR(dp->pl));
1296 return PTR_ERR(dp->pl);
1297 }
1298
1299 /* Register only if the switch provides such a callback, since this
1300 * callback takes precedence over polling the link GPIO in PHYLINK
1301 * (see phylink_get_fixed_state).
1302 */
1303 if (ds->ops->phylink_fixed_state)
1304 phylink_fixed_state_cb(dp->pl, dsa_slave_phylink_fixed_state);
1305
1306 if (ds->ops->get_phy_flags)
1307 phy_flags = ds->ops->get_phy_flags(ds, dp->index);
1308
1309 ret = phylink_of_phy_connect(dp->pl, port_dn, phy_flags);
1310 if (ret == -ENODEV && ds->slave_mii_bus) {
1311 /* We could not connect to a designated PHY or SFP, so try to
1312 * use the switch internal MDIO bus instead
1313 */
1314 ret = dsa_slave_phy_connect(slave_dev, dp->index);
1315 if (ret) {
1316 netdev_err(slave_dev,
1317 "failed to connect to port %d: %d\n",
1318 dp->index, ret);
1319 phylink_destroy(dp->pl);
1320 return ret;
1321 }
1322 }
1323
1324 return ret;
1325}
1326
1327int dsa_slave_suspend(struct net_device *slave_dev)
1328{
1329 struct dsa_port *dp = dsa_slave_to_port(slave_dev);
1330
1331 if (!netif_running(slave_dev))
1332 return 0;
1333
1334 netif_device_detach(slave_dev);
1335
1336 rtnl_lock();
1337 phylink_stop(dp->pl);
1338 rtnl_unlock();
1339
1340 return 0;
1341}
1342
1343int dsa_slave_resume(struct net_device *slave_dev)
1344{
1345 struct dsa_port *dp = dsa_slave_to_port(slave_dev);
1346
1347 if (!netif_running(slave_dev))
1348 return 0;
1349
1350 netif_device_attach(slave_dev);
1351
1352 rtnl_lock();
1353 phylink_start(dp->pl);
1354 rtnl_unlock();
1355
1356 return 0;
1357}
1358
1359static void dsa_slave_notify(struct net_device *dev, unsigned long val)
1360{
1361 struct net_device *master = dsa_slave_to_master(dev);
1362 struct dsa_port *dp = dsa_slave_to_port(dev);
1363 struct dsa_notifier_register_info rinfo = {
1364 .switch_number = dp->ds->index,
1365 .port_number = dp->index,
1366 .master = master,
1367 .info.dev = dev,
1368 };
1369
1370 call_dsa_notifiers(val, dev, &rinfo.info);
1371}
1372
1373int dsa_slave_create(struct dsa_port *port)
1374{
1375 const struct dsa_port *cpu_dp = port->cpu_dp;
1376 struct net_device *master = cpu_dp->master;
1377 struct dsa_switch *ds = port->ds;
1378 const char *name = port->name;
1379 struct net_device *slave_dev;
1380 struct dsa_slave_priv *p;
1381 int ret;
1382
1383 if (!ds->num_tx_queues)
1384 ds->num_tx_queues = 1;
1385
1386 slave_dev = alloc_netdev_mqs(sizeof(struct dsa_slave_priv), name,
1387 NET_NAME_UNKNOWN, ether_setup,
1388 ds->num_tx_queues, 1);
1389 if (slave_dev == NULL)
1390 return -ENOMEM;
1391
1392 slave_dev->features = master->vlan_features | NETIF_F_HW_TC;
1393 if (ds->ops->port_vlan_add && ds->ops->port_vlan_del)
1394 slave_dev->features |= NETIF_F_HW_VLAN_CTAG_FILTER;
1395 slave_dev->hw_features |= NETIF_F_HW_TC;
1396 slave_dev->ethtool_ops = &dsa_slave_ethtool_ops;
1397 if (!IS_ERR_OR_NULL(port->mac))
1398 ether_addr_copy(slave_dev->dev_addr, port->mac);
1399 else
1400 eth_hw_addr_inherit(slave_dev, master);
1401 slave_dev->priv_flags |= IFF_NO_QUEUE;
1402 slave_dev->netdev_ops = &dsa_slave_netdev_ops;
1403 slave_dev->min_mtu = 0;
1404 slave_dev->max_mtu = ETH_MAX_MTU;
1405 SET_NETDEV_DEVTYPE(slave_dev, &dsa_type);
1406
1407 SET_NETDEV_DEV(slave_dev, port->ds->dev);
1408 slave_dev->dev.of_node = port->dn;
1409 slave_dev->vlan_features = master->vlan_features;
1410
1411 p = netdev_priv(slave_dev);
1412 p->stats64 = netdev_alloc_pcpu_stats(struct pcpu_sw_netstats);
1413 if (!p->stats64) {
1414 free_netdev(slave_dev);
1415 return -ENOMEM;
1416 }
1417 p->dp = port;
1418 INIT_LIST_HEAD(&p->mall_tc_list);
1419 p->xmit = cpu_dp->tag_ops->xmit;
1420 port->slave = slave_dev;
1421
1422 netif_carrier_off(slave_dev);
1423
1424 ret = dsa_slave_phy_setup(slave_dev);
1425 if (ret) {
1426 netdev_err(master, "error %d setting up slave phy\n", ret);
1427 goto out_free;
1428 }
1429
1430 dsa_slave_notify(slave_dev, DSA_PORT_REGISTER);
1431
1432 ret = register_netdev(slave_dev);
1433 if (ret) {
1434 netdev_err(master, "error %d registering interface %s\n",
1435 ret, slave_dev->name);
1436 goto out_phy;
1437 }
1438
1439 return 0;
1440
1441out_phy:
1442 rtnl_lock();
1443 phylink_disconnect_phy(p->dp->pl);
1444 rtnl_unlock();
1445 phylink_destroy(p->dp->pl);
1446out_free:
1447 free_percpu(p->stats64);
1448 free_netdev(slave_dev);
1449 port->slave = NULL;
1450 return ret;
1451}
1452
1453void dsa_slave_destroy(struct net_device *slave_dev)
1454{
1455 struct dsa_port *dp = dsa_slave_to_port(slave_dev);
1456 struct dsa_slave_priv *p = netdev_priv(slave_dev);
1457
1458 netif_carrier_off(slave_dev);
1459 rtnl_lock();
1460 phylink_disconnect_phy(dp->pl);
1461 rtnl_unlock();
1462
1463 dsa_slave_notify(slave_dev, DSA_PORT_UNREGISTER);
1464 unregister_netdev(slave_dev);
1465 phylink_destroy(dp->pl);
1466 free_percpu(p->stats64);
1467 free_netdev(slave_dev);
1468}
1469
1470bool dsa_slave_dev_check(const struct net_device *dev)
1471{
1472 return dev->netdev_ops == &dsa_slave_netdev_ops;
1473}
1474
1475static int dsa_slave_changeupper(struct net_device *dev,
1476 struct netdev_notifier_changeupper_info *info)
1477{
1478 struct dsa_port *dp = dsa_slave_to_port(dev);
1479 int err = NOTIFY_DONE;
1480
1481 if (netif_is_bridge_master(info->upper_dev)) {
1482 if (info->linking) {
1483 err = dsa_port_bridge_join(dp, info->upper_dev);
1484 err = notifier_from_errno(err);
1485 } else {
1486 dsa_port_bridge_leave(dp, info->upper_dev);
1487 err = NOTIFY_OK;
1488 }
1489 }
1490
1491 return err;
1492}
1493
1494static int dsa_slave_upper_vlan_check(struct net_device *dev,
1495 struct netdev_notifier_changeupper_info *
1496 info)
1497{
1498 struct netlink_ext_ack *ext_ack;
1499 struct net_device *slave;
1500 struct dsa_port *dp;
1501
1502 ext_ack = netdev_notifier_info_to_extack(&info->info);
1503
1504 if (!is_vlan_dev(dev))
1505 return NOTIFY_DONE;
1506
1507 slave = vlan_dev_real_dev(dev);
1508 if (!dsa_slave_dev_check(slave))
1509 return NOTIFY_DONE;
1510
1511 dp = dsa_slave_to_port(slave);
1512 if (!dp->bridge_dev)
1513 return NOTIFY_DONE;
1514
1515 /* Deny enslaving a VLAN device into a VLAN-aware bridge */
1516 if (br_vlan_enabled(dp->bridge_dev) &&
1517 netif_is_bridge_master(info->upper_dev) && info->linking) {
1518 NL_SET_ERR_MSG_MOD(ext_ack,
1519 "Cannot enslave VLAN device into VLAN aware bridge");
1520 return notifier_from_errno(-EINVAL);
1521 }
1522
1523 return NOTIFY_DONE;
1524}
1525
1526static int dsa_slave_netdevice_event(struct notifier_block *nb,
1527 unsigned long event, void *ptr)
1528{
1529 struct net_device *dev = netdev_notifier_info_to_dev(ptr);
1530
1531 if (event == NETDEV_CHANGEUPPER) {
1532 if (!dsa_slave_dev_check(dev))
1533 return dsa_slave_upper_vlan_check(dev, ptr);
1534
1535 return dsa_slave_changeupper(dev, ptr);
1536 }
1537
1538 return NOTIFY_DONE;
1539}
1540
1541struct dsa_switchdev_event_work {
1542 struct work_struct work;
1543 struct switchdev_notifier_fdb_info fdb_info;
1544 struct net_device *dev;
1545 unsigned long event;
1546};
1547
1548static void dsa_slave_switchdev_event_work(struct work_struct *work)
1549{
1550 struct dsa_switchdev_event_work *switchdev_work =
1551 container_of(work, struct dsa_switchdev_event_work, work);
1552 struct net_device *dev = switchdev_work->dev;
1553 struct switchdev_notifier_fdb_info *fdb_info;
1554 struct dsa_port *dp = dsa_slave_to_port(dev);
1555 int err;
1556
1557 rtnl_lock();
1558 switch (switchdev_work->event) {
1559 case SWITCHDEV_FDB_ADD_TO_DEVICE:
1560 fdb_info = &switchdev_work->fdb_info;
1561 if (!fdb_info->added_by_user)
1562 break;
1563
1564 err = dsa_port_fdb_add(dp, fdb_info->addr, fdb_info->vid);
1565 if (err) {
1566 netdev_dbg(dev, "fdb add failed err=%d\n", err);
1567 break;
1568 }
1569 fdb_info->offloaded = true;
1570 call_switchdev_notifiers(SWITCHDEV_FDB_OFFLOADED, dev,
1571 &fdb_info->info, NULL);
1572 break;
1573
1574 case SWITCHDEV_FDB_DEL_TO_DEVICE:
1575 fdb_info = &switchdev_work->fdb_info;
1576 if (!fdb_info->added_by_user)
1577 break;
1578
1579 err = dsa_port_fdb_del(dp, fdb_info->addr, fdb_info->vid);
1580 if (err) {
1581 netdev_dbg(dev, "fdb del failed err=%d\n", err);
1582 dev_close(dev);
1583 }
1584 break;
1585 }
1586 rtnl_unlock();
1587
1588 kfree(switchdev_work->fdb_info.addr);
1589 kfree(switchdev_work);
1590 dev_put(dev);
1591}
1592
1593static int
1594dsa_slave_switchdev_fdb_work_init(struct dsa_switchdev_event_work *
1595 switchdev_work,
1596 const struct switchdev_notifier_fdb_info *
1597 fdb_info)
1598{
1599 memcpy(&switchdev_work->fdb_info, fdb_info,
1600 sizeof(switchdev_work->fdb_info));
1601 switchdev_work->fdb_info.addr = kzalloc(ETH_ALEN, GFP_ATOMIC);
1602 if (!switchdev_work->fdb_info.addr)
1603 return -ENOMEM;
1604 ether_addr_copy((u8 *)switchdev_work->fdb_info.addr,
1605 fdb_info->addr);
1606 return 0;
1607}
1608
1609/* Called under rcu_read_lock() */
1610static int dsa_slave_switchdev_event(struct notifier_block *unused,
1611 unsigned long event, void *ptr)
1612{
1613 struct net_device *dev = switchdev_notifier_info_to_dev(ptr);
1614 struct dsa_switchdev_event_work *switchdev_work;
1615 int err;
1616
1617 if (event == SWITCHDEV_PORT_ATTR_SET) {
1618 err = switchdev_handle_port_attr_set(dev, ptr,
1619 dsa_slave_dev_check,
1620 dsa_slave_port_attr_set);
1621 return notifier_from_errno(err);
1622 }
1623
1624 if (!dsa_slave_dev_check(dev))
1625 return NOTIFY_DONE;
1626
1627 switchdev_work = kzalloc(sizeof(*switchdev_work), GFP_ATOMIC);
1628 if (!switchdev_work)
1629 return NOTIFY_BAD;
1630
1631 INIT_WORK(&switchdev_work->work,
1632 dsa_slave_switchdev_event_work);
1633 switchdev_work->dev = dev;
1634 switchdev_work->event = event;
1635
1636 switch (event) {
1637 case SWITCHDEV_FDB_ADD_TO_DEVICE: /* fall through */
1638 case SWITCHDEV_FDB_DEL_TO_DEVICE:
1639 if (dsa_slave_switchdev_fdb_work_init(switchdev_work, ptr))
1640 goto err_fdb_work_init;
1641 dev_hold(dev);
1642 break;
1643 default:
1644 kfree(switchdev_work);
1645 return NOTIFY_DONE;
1646 }
1647
1648 dsa_schedule_work(&switchdev_work->work);
1649 return NOTIFY_OK;
1650
1651err_fdb_work_init:
1652 kfree(switchdev_work);
1653 return NOTIFY_BAD;
1654}
1655
1656static int dsa_slave_switchdev_blocking_event(struct notifier_block *unused,
1657 unsigned long event, void *ptr)
1658{
1659 struct net_device *dev = switchdev_notifier_info_to_dev(ptr);
1660 int err;
1661
1662 switch (event) {
1663 case SWITCHDEV_PORT_OBJ_ADD:
1664 err = switchdev_handle_port_obj_add(dev, ptr,
1665 dsa_slave_dev_check,
1666 dsa_slave_port_obj_add);
1667 return notifier_from_errno(err);
1668 case SWITCHDEV_PORT_OBJ_DEL:
1669 err = switchdev_handle_port_obj_del(dev, ptr,
1670 dsa_slave_dev_check,
1671 dsa_slave_port_obj_del);
1672 return notifier_from_errno(err);
1673 case SWITCHDEV_PORT_ATTR_SET:
1674 err = switchdev_handle_port_attr_set(dev, ptr,
1675 dsa_slave_dev_check,
1676 dsa_slave_port_attr_set);
1677 return notifier_from_errno(err);
1678 }
1679
1680 return NOTIFY_DONE;
1681}
1682
1683static struct notifier_block dsa_slave_nb __read_mostly = {
1684 .notifier_call = dsa_slave_netdevice_event,
1685};
1686
1687static struct notifier_block dsa_slave_switchdev_notifier = {
1688 .notifier_call = dsa_slave_switchdev_event,
1689};
1690
1691static struct notifier_block dsa_slave_switchdev_blocking_notifier = {
1692 .notifier_call = dsa_slave_switchdev_blocking_event,
1693};
1694
1695int dsa_slave_register_notifier(void)
1696{
1697 struct notifier_block *nb;
1698 int err;
1699
1700 err = register_netdevice_notifier(&dsa_slave_nb);
1701 if (err)
1702 return err;
1703
1704 err = register_switchdev_notifier(&dsa_slave_switchdev_notifier);
1705 if (err)
1706 goto err_switchdev_nb;
1707
1708 nb = &dsa_slave_switchdev_blocking_notifier;
1709 err = register_switchdev_blocking_notifier(nb);
1710 if (err)
1711 goto err_switchdev_blocking_nb;
1712
1713 return 0;
1714
1715err_switchdev_blocking_nb:
1716 unregister_switchdev_notifier(&dsa_slave_switchdev_notifier);
1717err_switchdev_nb:
1718 unregister_netdevice_notifier(&dsa_slave_nb);
1719 return err;
1720}
1721
1722void dsa_slave_unregister_notifier(void)
1723{
1724 struct notifier_block *nb;
1725 int err;
1726
1727 nb = &dsa_slave_switchdev_blocking_notifier;
1728 err = unregister_switchdev_blocking_notifier(nb);
1729 if (err)
1730 pr_err("DSA: failed to unregister switchdev blocking notifier (%d)\n", err);
1731
1732 err = unregister_switchdev_notifier(&dsa_slave_switchdev_notifier);
1733 if (err)
1734 pr_err("DSA: failed to unregister switchdev notifier (%d)\n", err);
1735
1736 err = unregister_netdevice_notifier(&dsa_slave_nb);
1737 if (err)
1738 pr_err("DSA: failed to unregister slave notifier (%d)\n", err);
1739}
Ubuntu Hirsute Linux kernel mirror