1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * net/dsa/slave.c - Slave device handling
4 * Copyright (c) 2008-2009 Marvell Semiconductor
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>
25 /* slave mii_bus handling ***************************************************/
26 static int dsa_slave_phy_read(struct mii_bus
*bus
, int addr
, int reg
)
28 struct dsa_switch
*ds
= bus
->priv
;
30 if (ds
->phys_mii_mask
& (1 << addr
))
31 return ds
->ops
->phy_read(ds
, addr
, reg
);
36 static int dsa_slave_phy_write(struct mii_bus
*bus
, int addr
, int reg
, u16 val
)
38 struct dsa_switch
*ds
= bus
->priv
;
40 if (ds
->phys_mii_mask
& (1 << addr
))
41 return ds
->ops
->phy_write(ds
, addr
, reg
, val
);
46 void dsa_slave_mii_bus_init(struct dsa_switch
*ds
)
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
;
59 /* slave device handling ****************************************************/
60 static int dsa_slave_get_iflink(const struct net_device
*dev
)
62 return dsa_slave_to_master(dev
)->ifindex
;
65 static int dsa_slave_open(struct net_device
*dev
)
67 struct net_device
*master
= dsa_slave_to_master(dev
);
68 struct dsa_port
*dp
= dsa_slave_to_port(dev
);
71 if (!(master
->flags
& IFF_UP
))
74 if (!ether_addr_equal(dev
->dev_addr
, master
->dev_addr
)) {
75 err
= dev_uc_add(master
, dev
->dev_addr
);
80 if (dev
->flags
& IFF_ALLMULTI
) {
81 err
= dev_set_allmulti(master
, 1);
85 if (dev
->flags
& IFF_PROMISC
) {
86 err
= dev_set_promiscuity(master
, 1);
91 err
= dsa_port_enable_rt(dp
, dev
->phydev
);
98 if (dev
->flags
& IFF_PROMISC
)
99 dev_set_promiscuity(master
, -1);
101 if (dev
->flags
& IFF_ALLMULTI
)
102 dev_set_allmulti(master
, -1);
104 if (!ether_addr_equal(dev
->dev_addr
, master
->dev_addr
))
105 dev_uc_del(master
, dev
->dev_addr
);
110 static int dsa_slave_close(struct net_device
*dev
)
112 struct net_device
*master
= dsa_slave_to_master(dev
);
113 struct dsa_port
*dp
= dsa_slave_to_port(dev
);
115 dsa_port_disable_rt(dp
);
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);
124 if (!ether_addr_equal(dev
->dev_addr
, master
->dev_addr
))
125 dev_uc_del(master
, dev
->dev_addr
);
130 static void dsa_slave_change_rx_flags(struct net_device
*dev
, int change
)
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);
143 static void dsa_slave_set_rx_mode(struct net_device
*dev
)
145 struct net_device
*master
= dsa_slave_to_master(dev
);
147 dev_mc_sync(master
, dev
);
148 dev_uc_sync(master
, dev
);
151 static int dsa_slave_set_mac_address(struct net_device
*dev
, void *a
)
153 struct net_device
*master
= dsa_slave_to_master(dev
);
154 struct sockaddr
*addr
= a
;
157 if (!is_valid_ether_addr(addr
->sa_data
))
158 return -EADDRNOTAVAIL
;
160 if (!(dev
->flags
& IFF_UP
))
163 if (!ether_addr_equal(addr
->sa_data
, master
->dev_addr
)) {
164 err
= dev_uc_add(master
, addr
->sa_data
);
169 if (!ether_addr_equal(dev
->dev_addr
, master
->dev_addr
))
170 dev_uc_del(master
, dev
->dev_addr
);
173 ether_addr_copy(dev
->dev_addr
, addr
->sa_data
);
178 struct dsa_slave_dump_ctx
{
179 struct net_device
*dev
;
181 struct netlink_callback
*cb
;
186 dsa_slave_port_fdb_do_dump(const unsigned char *addr
, u16 vid
,
187 bool is_static
, void *data
)
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
;
195 if (dump
->idx
< dump
->cb
->args
[2])
198 nlh
= nlmsg_put(dump
->skb
, portid
, seq
, RTM_NEWNEIGH
,
199 sizeof(*ndm
), NLM_F_MULTI
);
203 ndm
= nlmsg_data(nlh
);
204 ndm
->ndm_family
= AF_BRIDGE
;
207 ndm
->ndm_flags
= NTF_SELF
;
209 ndm
->ndm_ifindex
= dump
->dev
->ifindex
;
210 ndm
->ndm_state
= is_static
? NUD_NOARP
: NUD_REACHABLE
;
212 if (nla_put(dump
->skb
, NDA_LLADDR
, ETH_ALEN
, addr
))
213 goto nla_put_failure
;
215 if (vid
&& nla_put_u16(dump
->skb
, NDA_VLAN
, vid
))
216 goto nla_put_failure
;
218 nlmsg_end(dump
->skb
, nlh
);
225 nlmsg_cancel(dump
->skb
, nlh
);
230 dsa_slave_fdb_dump(struct sk_buff
*skb
, struct netlink_callback
*cb
,
231 struct net_device
*dev
, struct net_device
*filter_dev
,
234 struct dsa_port
*dp
= dsa_slave_to_port(dev
);
235 struct dsa_slave_dump_ctx dump
= {
243 err
= dsa_port_fdb_dump(dp
, dsa_slave_port_fdb_do_dump
, &dump
);
249 static int dsa_slave_ioctl(struct net_device
*dev
, struct ifreq
*ifr
, int cmd
)
251 struct dsa_slave_priv
*p
= netdev_priv(dev
);
252 struct dsa_switch
*ds
= p
->dp
->ds
;
253 int port
= p
->dp
->index
;
255 /* Pass through to switch driver if it supports timestamping */
258 if (ds
->ops
->port_hwtstamp_get
)
259 return ds
->ops
->port_hwtstamp_get(ds
, port
, ifr
);
262 if (ds
->ops
->port_hwtstamp_set
)
263 return ds
->ops
->port_hwtstamp_set(ds
, port
, ifr
);
267 return phylink_mii_ioctl(p
->dp
->pl
, ifr
, cmd
);
270 static int dsa_slave_port_attr_set(struct net_device
*dev
,
271 const struct switchdev_attr
*attr
,
272 struct switchdev_trans
*trans
)
274 struct dsa_port
*dp
= dsa_slave_to_port(dev
);
278 case SWITCHDEV_ATTR_ID_PORT_STP_STATE
:
279 ret
= dsa_port_set_state(dp
, attr
->u
.stp_state
, trans
);
281 case SWITCHDEV_ATTR_ID_BRIDGE_VLAN_FILTERING
:
282 ret
= dsa_port_vlan_filtering(dp
, attr
->u
.vlan_filtering
,
285 case SWITCHDEV_ATTR_ID_BRIDGE_AGEING_TIME
:
286 ret
= dsa_port_ageing_time(dp
, attr
->u
.ageing_time
, trans
);
288 case SWITCHDEV_ATTR_ID_PORT_PRE_BRIDGE_FLAGS
:
289 ret
= dsa_port_pre_bridge_flags(dp
, attr
->u
.brport_flags
,
292 case SWITCHDEV_ATTR_ID_PORT_BRIDGE_FLAGS
:
293 ret
= dsa_port_bridge_flags(dp
, attr
->u
.brport_flags
, trans
);
295 case SWITCHDEV_ATTR_ID_BRIDGE_MROUTER
:
296 ret
= dsa_port_mrouter(dp
->cpu_dp
, attr
->u
.mrouter
, trans
);
306 static int dsa_slave_vlan_add(struct net_device
*dev
,
307 const struct switchdev_obj
*obj
,
308 struct switchdev_trans
*trans
)
310 struct dsa_port
*dp
= dsa_slave_to_port(dev
);
311 struct switchdev_obj_port_vlan vlan
;
314 if (obj
->orig_dev
!= dev
)
317 if (dp
->bridge_dev
&& !br_vlan_enabled(dp
->bridge_dev
))
320 vlan
= *SWITCHDEV_OBJ_PORT_VLAN(obj
);
322 err
= dsa_port_vlan_add(dp
, &vlan
, trans
);
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.
330 vlan
.flags
&= ~BRIDGE_VLAN_INFO_PVID
;
332 err
= dsa_port_vlan_add(dp
->cpu_dp
, &vlan
, trans
);
339 static 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
)
344 struct dsa_port
*dp
= dsa_slave_to_port(dev
);
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.
353 case SWITCHDEV_OBJ_ID_PORT_MDB
:
354 if (obj
->orig_dev
!= dev
)
356 err
= dsa_port_mdb_add(dp
, SWITCHDEV_OBJ_PORT_MDB(obj
), trans
);
358 case SWITCHDEV_OBJ_ID_HOST_MDB
:
359 /* DSA can directly translate this to a normal MDB add,
360 * but on the CPU port.
362 err
= dsa_port_mdb_add(dp
->cpu_dp
, SWITCHDEV_OBJ_PORT_MDB(obj
),
365 case SWITCHDEV_OBJ_ID_PORT_VLAN
:
366 err
= dsa_slave_vlan_add(dev
, obj
, trans
);
376 static int dsa_slave_vlan_del(struct net_device
*dev
,
377 const struct switchdev_obj
*obj
)
379 struct dsa_port
*dp
= dsa_slave_to_port(dev
);
381 if (obj
->orig_dev
!= dev
)
384 if (dp
->bridge_dev
&& !br_vlan_enabled(dp
->bridge_dev
))
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.
390 return dsa_port_vlan_del(dp
, SWITCHDEV_OBJ_PORT_VLAN(obj
));
393 static int dsa_slave_port_obj_del(struct net_device
*dev
,
394 const struct switchdev_obj
*obj
)
396 struct dsa_port
*dp
= dsa_slave_to_port(dev
);
400 case SWITCHDEV_OBJ_ID_PORT_MDB
:
401 if (obj
->orig_dev
!= dev
)
403 err
= dsa_port_mdb_del(dp
, SWITCHDEV_OBJ_PORT_MDB(obj
));
405 case SWITCHDEV_OBJ_ID_HOST_MDB
:
406 /* DSA can directly translate this to a normal MDB add,
407 * but on the CPU port.
409 err
= dsa_port_mdb_del(dp
->cpu_dp
, SWITCHDEV_OBJ_PORT_MDB(obj
));
411 case SWITCHDEV_OBJ_ID_PORT_VLAN
:
412 err
= dsa_slave_vlan_del(dev
, obj
);
422 static int dsa_slave_get_port_parent_id(struct net_device
*dev
,
423 struct netdev_phys_item_id
*ppid
)
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
;
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.
436 ppid
->id_len
= sizeof(dst
->index
);
437 memcpy(&ppid
->id
, &dst
->index
, ppid
->id_len
);
442 static inline netdev_tx_t
dsa_slave_netpoll_send_skb(struct net_device
*dev
,
445 #ifdef CONFIG_NET_POLL_CONTROLLER
446 struct dsa_slave_priv
*p
= netdev_priv(dev
);
449 netpoll_send_skb(p
->netpoll
, skb
);
456 static void dsa_skb_tx_timestamp(struct dsa_slave_priv
*p
,
459 struct dsa_switch
*ds
= p
->dp
->ds
;
460 struct sk_buff
*clone
;
463 type
= ptp_classify_raw(skb
);
464 if (type
== PTP_CLASS_NONE
)
467 if (!ds
->ops
->port_txtstamp
)
470 clone
= skb_clone_sk(skb
);
474 DSA_SKB_CB(skb
)->clone
= clone
;
476 if (ds
->ops
->port_txtstamp(ds
, p
->dp
->index
, clone
, type
))
482 netdev_tx_t
dsa_enqueue_skb(struct sk_buff
*skb
, struct net_device
*dev
)
484 /* SKB for netpoll still need to be mangled with the protocol-specific
485 * tag to be successfully transmitted
487 if (unlikely(netpoll_tx_running(dev
)))
488 return dsa_slave_netpoll_send_skb(dev
, skb
);
490 /* Queue the SKB for transmission on the parent interface, but
491 * do not modify its EtherType
493 skb
->dev
= dsa_slave_to_master(dev
);
498 EXPORT_SYMBOL_GPL(dsa_enqueue_skb
);
500 static netdev_tx_t
dsa_slave_xmit(struct sk_buff
*skb
, struct net_device
*dev
)
502 struct dsa_slave_priv
*p
= netdev_priv(dev
);
503 struct pcpu_sw_netstats
*s
;
504 struct sk_buff
*nskb
;
506 s
= this_cpu_ptr(p
->stats64
);
507 u64_stats_update_begin(&s
->syncp
);
509 s
->tx_bytes
+= skb
->len
;
510 u64_stats_update_end(&s
->syncp
);
512 DSA_SKB_CB(skb
)->clone
= NULL
;
514 /* Identify PTP protocol packets, clone them, and pass them to the
517 dsa_skb_tx_timestamp(p
, skb
);
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.
522 nskb
= p
->xmit(skb
, dev
);
528 return dsa_enqueue_skb(nskb
, dev
);
531 /* ethtool operations *******************************************************/
533 static void dsa_slave_get_drvinfo(struct net_device
*dev
,
534 struct ethtool_drvinfo
*drvinfo
)
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
));
541 static int dsa_slave_get_regs_len(struct net_device
*dev
)
543 struct dsa_port
*dp
= dsa_slave_to_port(dev
);
544 struct dsa_switch
*ds
= dp
->ds
;
546 if (ds
->ops
->get_regs_len
)
547 return ds
->ops
->get_regs_len(ds
, dp
->index
);
553 dsa_slave_get_regs(struct net_device
*dev
, struct ethtool_regs
*regs
, void *_p
)
555 struct dsa_port
*dp
= dsa_slave_to_port(dev
);
556 struct dsa_switch
*ds
= dp
->ds
;
558 if (ds
->ops
->get_regs
)
559 ds
->ops
->get_regs(ds
, dp
->index
, regs
, _p
);
562 static int dsa_slave_nway_reset(struct net_device
*dev
)
564 struct dsa_port
*dp
= dsa_slave_to_port(dev
);
566 return phylink_ethtool_nway_reset(dp
->pl
);
569 static int dsa_slave_get_eeprom_len(struct net_device
*dev
)
571 struct dsa_port
*dp
= dsa_slave_to_port(dev
);
572 struct dsa_switch
*ds
= dp
->ds
;
574 if (ds
->cd
&& ds
->cd
->eeprom_len
)
575 return ds
->cd
->eeprom_len
;
577 if (ds
->ops
->get_eeprom_len
)
578 return ds
->ops
->get_eeprom_len(ds
);
583 static int dsa_slave_get_eeprom(struct net_device
*dev
,
584 struct ethtool_eeprom
*eeprom
, u8
*data
)
586 struct dsa_port
*dp
= dsa_slave_to_port(dev
);
587 struct dsa_switch
*ds
= dp
->ds
;
589 if (ds
->ops
->get_eeprom
)
590 return ds
->ops
->get_eeprom(ds
, eeprom
, data
);
595 static int dsa_slave_set_eeprom(struct net_device
*dev
,
596 struct ethtool_eeprom
*eeprom
, u8
*data
)
598 struct dsa_port
*dp
= dsa_slave_to_port(dev
);
599 struct dsa_switch
*ds
= dp
->ds
;
601 if (ds
->ops
->set_eeprom
)
602 return ds
->ops
->set_eeprom(ds
, eeprom
, data
);
607 static void dsa_slave_get_strings(struct net_device
*dev
,
608 uint32_t stringset
, uint8_t *data
)
610 struct dsa_port
*dp
= dsa_slave_to_port(dev
);
611 struct dsa_switch
*ds
= dp
->ds
;
613 if (stringset
== ETH_SS_STATS
) {
614 int len
= ETH_GSTRING_LEN
;
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
,
626 static void dsa_slave_get_ethtool_stats(struct net_device
*dev
,
627 struct ethtool_stats
*stats
,
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
;
637 for_each_possible_cpu(i
) {
638 u64 tx_packets
, tx_bytes
, rx_packets
, rx_bytes
;
640 s
= per_cpu_ptr(p
->stats64
, i
);
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
;
650 data
[2] += rx_packets
;
653 if (ds
->ops
->get_ethtool_stats
)
654 ds
->ops
->get_ethtool_stats(ds
, dp
->index
, data
+ 4);
657 static int dsa_slave_get_sset_count(struct net_device
*dev
, int sset
)
659 struct dsa_port
*dp
= dsa_slave_to_port(dev
);
660 struct dsa_switch
*ds
= dp
->ds
;
662 if (sset
== ETH_SS_STATS
) {
666 if (ds
->ops
->get_sset_count
)
667 count
+= ds
->ops
->get_sset_count(ds
, dp
->index
, sset
);
675 static void dsa_slave_get_wol(struct net_device
*dev
, struct ethtool_wolinfo
*w
)
677 struct dsa_port
*dp
= dsa_slave_to_port(dev
);
678 struct dsa_switch
*ds
= dp
->ds
;
680 phylink_ethtool_get_wol(dp
->pl
, w
);
682 if (ds
->ops
->get_wol
)
683 ds
->ops
->get_wol(ds
, dp
->index
, w
);
686 static int dsa_slave_set_wol(struct net_device
*dev
, struct ethtool_wolinfo
*w
)
688 struct dsa_port
*dp
= dsa_slave_to_port(dev
);
689 struct dsa_switch
*ds
= dp
->ds
;
690 int ret
= -EOPNOTSUPP
;
692 phylink_ethtool_set_wol(dp
->pl
, w
);
694 if (ds
->ops
->set_wol
)
695 ret
= ds
->ops
->set_wol(ds
, dp
->index
, w
);
700 static int dsa_slave_set_eee(struct net_device
*dev
, struct ethtool_eee
*e
)
702 struct dsa_port
*dp
= dsa_slave_to_port(dev
);
703 struct dsa_switch
*ds
= dp
->ds
;
706 /* Port's PHY and MAC both need to be EEE capable */
707 if (!dev
->phydev
|| !dp
->pl
)
710 if (!ds
->ops
->set_mac_eee
)
713 ret
= ds
->ops
->set_mac_eee(ds
, dp
->index
, e
);
717 return phylink_ethtool_set_eee(dp
->pl
, e
);
720 static int dsa_slave_get_eee(struct net_device
*dev
, struct ethtool_eee
*e
)
722 struct dsa_port
*dp
= dsa_slave_to_port(dev
);
723 struct dsa_switch
*ds
= dp
->ds
;
726 /* Port's PHY and MAC both need to be EEE capable */
727 if (!dev
->phydev
|| !dp
->pl
)
730 if (!ds
->ops
->get_mac_eee
)
733 ret
= ds
->ops
->get_mac_eee(ds
, dp
->index
, e
);
737 return phylink_ethtool_get_eee(dp
->pl
, e
);
740 static int dsa_slave_get_link_ksettings(struct net_device
*dev
,
741 struct ethtool_link_ksettings
*cmd
)
743 struct dsa_port
*dp
= dsa_slave_to_port(dev
);
745 return phylink_ethtool_ksettings_get(dp
->pl
, cmd
);
748 static int dsa_slave_set_link_ksettings(struct net_device
*dev
,
749 const struct ethtool_link_ksettings
*cmd
)
751 struct dsa_port
*dp
= dsa_slave_to_port(dev
);
753 return phylink_ethtool_ksettings_set(dp
->pl
, cmd
);
756 static void dsa_slave_get_pauseparam(struct net_device
*dev
,
757 struct ethtool_pauseparam
*pause
)
759 struct dsa_port
*dp
= dsa_slave_to_port(dev
);
761 phylink_ethtool_get_pauseparam(dp
->pl
, pause
);
764 static int dsa_slave_set_pauseparam(struct net_device
*dev
,
765 struct ethtool_pauseparam
*pause
)
767 struct dsa_port
*dp
= dsa_slave_to_port(dev
);
769 return phylink_ethtool_set_pauseparam(dp
->pl
, pause
);
772 #ifdef CONFIG_NET_POLL_CONTROLLER
773 static int dsa_slave_netpoll_setup(struct net_device
*dev
,
774 struct netpoll_info
*ni
)
776 struct net_device
*master
= dsa_slave_to_master(dev
);
777 struct dsa_slave_priv
*p
= netdev_priv(dev
);
778 struct netpoll
*netpoll
;
781 netpoll
= kzalloc(sizeof(*netpoll
), GFP_KERNEL
);
785 err
= __netpoll_setup(netpoll
, master
);
791 p
->netpoll
= netpoll
;
796 static void dsa_slave_netpoll_cleanup(struct net_device
*dev
)
798 struct dsa_slave_priv
*p
= netdev_priv(dev
);
799 struct netpoll
*netpoll
= p
->netpoll
;
806 __netpoll_free(netpoll
);
809 static void dsa_slave_poll_controller(struct net_device
*dev
)
814 static int dsa_slave_get_phys_port_name(struct net_device
*dev
,
815 char *name
, size_t len
)
817 struct dsa_port
*dp
= dsa_slave_to_port(dev
);
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.
826 if (snprintf(name
, len
, "p%d", dp
->index
) >= len
)
832 static struct dsa_mall_tc_entry
*
833 dsa_slave_mall_tc_entry_find(struct net_device
*dev
, unsigned long cookie
)
835 struct dsa_slave_priv
*p
= netdev_priv(dev
);
836 struct dsa_mall_tc_entry
*mall_tc_entry
;
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
;
845 static int dsa_slave_add_cls_matchall(struct net_device
*dev
,
846 struct tc_cls_matchall_offload
*cls
,
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
;
858 if (!ds
->ops
->port_mirror_add
)
861 if (!flow_offload_has_one_action(&cls
->rule
->action
))
864 act
= &cls
->rule
->action
.entries
[0];
866 if (act
->id
== FLOW_ACTION_MIRRED
&& protocol
== htons(ETH_P_ALL
)) {
867 struct dsa_mall_mirror_tc_entry
*mirror
;
872 if (!dsa_slave_dev_check(act
->dev
))
875 mall_tc_entry
= kzalloc(sizeof(*mall_tc_entry
), GFP_KERNEL
);
879 mall_tc_entry
->cookie
= cls
->cookie
;
880 mall_tc_entry
->type
= DSA_PORT_MALL_MIRROR
;
881 mirror
= &mall_tc_entry
->mirror
;
883 to_dp
= dsa_slave_to_port(act
->dev
);
885 mirror
->to_local_port
= to_dp
->index
;
886 mirror
->ingress
= ingress
;
888 err
= ds
->ops
->port_mirror_add(ds
, dp
->index
, mirror
, ingress
);
890 kfree(mall_tc_entry
);
894 list_add_tail(&mall_tc_entry
->list
, &p
->mall_tc_list
);
900 static void dsa_slave_del_cls_matchall(struct net_device
*dev
,
901 struct tc_cls_matchall_offload
*cls
)
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
;
907 if (!ds
->ops
->port_mirror_del
)
910 mall_tc_entry
= dsa_slave_mall_tc_entry_find(dev
, cls
->cookie
);
914 list_del(&mall_tc_entry
->list
);
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
);
924 kfree(mall_tc_entry
);
927 static int dsa_slave_setup_tc_cls_matchall(struct net_device
*dev
,
928 struct tc_cls_matchall_offload
*cls
,
931 if (cls
->common
.chain_index
)
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
);
945 static int dsa_slave_setup_tc_block_cb(enum tc_setup_type type
, void *type_data
,
946 void *cb_priv
, bool ingress
)
948 struct net_device
*dev
= cb_priv
;
950 if (!tc_can_offload(dev
))
954 case TC_SETUP_CLSMATCHALL
:
955 return dsa_slave_setup_tc_cls_matchall(dev
, type_data
, ingress
);
961 static int dsa_slave_setup_tc_block_cb_ig(enum tc_setup_type type
,
962 void *type_data
, void *cb_priv
)
964 return dsa_slave_setup_tc_block_cb(type
, type_data
, cb_priv
, true);
967 static int dsa_slave_setup_tc_block_cb_eg(enum tc_setup_type type
,
968 void *type_data
, void *cb_priv
)
970 return dsa_slave_setup_tc_block_cb(type
, type_data
, cb_priv
, false);
973 static LIST_HEAD(dsa_slave_block_cb_list
);
975 static int dsa_slave_setup_tc_block(struct net_device
*dev
,
976 struct flow_block_offload
*f
)
978 struct flow_block_cb
*block_cb
;
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
;
988 f
->driver_block_list
= &dsa_slave_block_cb_list
;
990 switch (f
->command
) {
991 case FLOW_BLOCK_BIND
:
992 if (flow_block_cb_is_busy(cb
, dev
, &dsa_slave_block_cb_list
))
995 block_cb
= flow_block_cb_alloc(cb
, dev
, dev
, NULL
);
996 if (IS_ERR(block_cb
))
997 return PTR_ERR(block_cb
);
999 flow_block_cb_add(block_cb
, f
);
1000 list_add_tail(&block_cb
->driver_list
, &dsa_slave_block_cb_list
);
1002 case FLOW_BLOCK_UNBIND
:
1003 block_cb
= flow_block_cb_lookup(f
->block
, cb
, dev
);
1007 flow_block_cb_remove(block_cb
, f
);
1008 list_del(&block_cb
->driver_list
);
1015 static int dsa_slave_setup_tc(struct net_device
*dev
, enum tc_setup_type type
,
1018 struct dsa_port
*dp
= dsa_slave_to_port(dev
);
1019 struct dsa_switch
*ds
= dp
->ds
;
1021 if (type
== TC_SETUP_BLOCK
)
1022 return dsa_slave_setup_tc_block(dev
, type_data
);
1024 if (!ds
->ops
->port_setup_tc
)
1027 return ds
->ops
->port_setup_tc(ds
, dp
->index
, type
, type_data
);
1030 static void dsa_slave_get_stats64(struct net_device
*dev
,
1031 struct rtnl_link_stats64
*stats
)
1033 struct dsa_slave_priv
*p
= netdev_priv(dev
);
1034 struct pcpu_sw_netstats
*s
;
1038 netdev_stats_to_stats64(stats
, &dev
->stats
);
1039 for_each_possible_cpu(i
) {
1040 u64 tx_packets
, tx_bytes
, rx_packets
, rx_bytes
;
1042 s
= per_cpu_ptr(p
->stats64
, i
);
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
));
1051 stats
->tx_packets
+= tx_packets
;
1052 stats
->tx_bytes
+= tx_bytes
;
1053 stats
->rx_packets
+= rx_packets
;
1054 stats
->rx_bytes
+= rx_bytes
;
1058 static int dsa_slave_get_rxnfc(struct net_device
*dev
,
1059 struct ethtool_rxnfc
*nfc
, u32
*rule_locs
)
1061 struct dsa_port
*dp
= dsa_slave_to_port(dev
);
1062 struct dsa_switch
*ds
= dp
->ds
;
1064 if (!ds
->ops
->get_rxnfc
)
1067 return ds
->ops
->get_rxnfc(ds
, dp
->index
, nfc
, rule_locs
);
1070 static int dsa_slave_set_rxnfc(struct net_device
*dev
,
1071 struct ethtool_rxnfc
*nfc
)
1073 struct dsa_port
*dp
= dsa_slave_to_port(dev
);
1074 struct dsa_switch
*ds
= dp
->ds
;
1076 if (!ds
->ops
->set_rxnfc
)
1079 return ds
->ops
->set_rxnfc(ds
, dp
->index
, nfc
);
1082 static int dsa_slave_get_ts_info(struct net_device
*dev
,
1083 struct ethtool_ts_info
*ts
)
1085 struct dsa_slave_priv
*p
= netdev_priv(dev
);
1086 struct dsa_switch
*ds
= p
->dp
->ds
;
1088 if (!ds
->ops
->get_ts_info
)
1091 return ds
->ops
->get_ts_info(ds
, p
->dp
->index
, ts
);
1094 static int dsa_slave_vlan_rx_add_vid(struct net_device
*dev
, __be16 proto
,
1097 struct dsa_port
*dp
= dsa_slave_to_port(dev
);
1098 struct bridge_vlan_info info
;
1101 /* Check for a possible bridge VLAN entry now since there is no
1102 * need to emulate the switchdev prepare + commit phase.
1104 if (dp
->bridge_dev
) {
1105 if (!br_vlan_enabled(dp
->bridge_dev
))
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.
1112 ret
= br_vlan_get_info(dp
->bridge_dev
, vid
, &info
);
1117 ret
= dsa_port_vid_add(dp
, vid
, 0);
1121 ret
= dsa_port_vid_add(dp
->cpu_dp
, vid
, 0);
1128 static int dsa_slave_vlan_rx_kill_vid(struct net_device
*dev
, __be16 proto
,
1131 struct dsa_port
*dp
= dsa_slave_to_port(dev
);
1132 struct bridge_vlan_info info
;
1135 /* Check for a possible bridge VLAN entry now since there is no
1136 * need to emulate the switchdev prepare + commit phase.
1138 if (dp
->bridge_dev
) {
1139 if (!br_vlan_enabled(dp
->bridge_dev
))
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.
1146 ret
= br_vlan_get_info(dp
->bridge_dev
, vid
, &info
);
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.
1154 return dsa_port_vid_del(dp
, vid
);
1157 static 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
,
1182 /* legacy way, bypassing the bridge *****************************************/
1183 int dsa_legacy_fdb_add(struct ndmsg
*ndm
, struct nlattr
*tb
[],
1184 struct net_device
*dev
,
1185 const unsigned char *addr
, u16 vid
,
1187 struct netlink_ext_ack
*extack
)
1189 struct dsa_port
*dp
= dsa_slave_to_port(dev
);
1191 return dsa_port_fdb_add(dp
, addr
, vid
);
1194 int dsa_legacy_fdb_del(struct ndmsg
*ndm
, struct nlattr
*tb
[],
1195 struct net_device
*dev
,
1196 const unsigned char *addr
, u16 vid
)
1198 struct dsa_port
*dp
= dsa_slave_to_port(dev
);
1200 return dsa_port_fdb_del(dp
, addr
, vid
);
1203 static struct devlink_port
*dsa_slave_get_devlink_port(struct net_device
*dev
)
1205 struct dsa_port
*dp
= dsa_slave_to_port(dev
);
1207 return dp
->ds
->devlink
? &dp
->devlink_port
: NULL
;
1210 static 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
,
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
,
1236 static struct device_type dsa_type
= {
1240 void dsa_port_phylink_mac_change(struct dsa_switch
*ds
, int port
, bool up
)
1242 const struct dsa_port
*dp
= dsa_to_port(ds
, port
);
1244 phylink_mac_change(dp
->pl
, up
);
1246 EXPORT_SYMBOL_GPL(dsa_port_phylink_mac_change
);
1248 static void dsa_slave_phylink_fixed_state(struct net_device
*dev
,
1249 struct phylink_link_state
*state
)
1251 struct dsa_port
*dp
= dsa_slave_to_port(dev
);
1252 struct dsa_switch
*ds
= dp
->ds
;
1254 /* No need to check that this operation is valid, the callback would
1255 * not be called if it was not.
1257 ds
->ops
->phylink_fixed_state(ds
, dp
->index
, state
);
1260 /* slave device setup *******************************************************/
1261 static int dsa_slave_phy_connect(struct net_device
*slave_dev
, int addr
)
1263 struct dsa_port
*dp
= dsa_slave_to_port(slave_dev
);
1264 struct dsa_switch
*ds
= dp
->ds
;
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
);
1272 return phylink_connect_phy(dp
->pl
, slave_dev
->phydev
);
1275 static int dsa_slave_phy_setup(struct net_device
*slave_dev
)
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
;
1284 ret
= of_get_phy_mode(port_dn
, &mode
);
1286 mode
= PHY_INTERFACE_MODE_NA
;
1288 dp
->pl_config
.dev
= &slave_dev
->dev
;
1289 dp
->pl_config
.type
= PHYLINK_NETDEV
;
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
);
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).
1303 if (ds
->ops
->phylink_fixed_state
)
1304 phylink_fixed_state_cb(dp
->pl
, dsa_slave_phylink_fixed_state
);
1306 if (ds
->ops
->get_phy_flags
)
1307 phy_flags
= ds
->ops
->get_phy_flags(ds
, dp
->index
);
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
1314 ret
= dsa_slave_phy_connect(slave_dev
, dp
->index
);
1316 netdev_err(slave_dev
,
1317 "failed to connect to port %d: %d\n",
1319 phylink_destroy(dp
->pl
);
1327 int dsa_slave_suspend(struct net_device
*slave_dev
)
1329 struct dsa_port
*dp
= dsa_slave_to_port(slave_dev
);
1331 if (!netif_running(slave_dev
))
1334 netif_device_detach(slave_dev
);
1337 phylink_stop(dp
->pl
);
1343 int dsa_slave_resume(struct net_device
*slave_dev
)
1345 struct dsa_port
*dp
= dsa_slave_to_port(slave_dev
);
1347 if (!netif_running(slave_dev
))
1350 netif_device_attach(slave_dev
);
1353 phylink_start(dp
->pl
);
1359 static void dsa_slave_notify(struct net_device
*dev
, unsigned long val
)
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
,
1370 call_dsa_notifiers(val
, dev
, &rinfo
.info
);
1373 int dsa_slave_create(struct dsa_port
*port
)
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
;
1383 if (!ds
->num_tx_queues
)
1384 ds
->num_tx_queues
= 1;
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
)
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
);
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
);
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
;
1411 p
= netdev_priv(slave_dev
);
1412 p
->stats64
= netdev_alloc_pcpu_stats(struct pcpu_sw_netstats
);
1414 free_netdev(slave_dev
);
1418 INIT_LIST_HEAD(&p
->mall_tc_list
);
1419 p
->xmit
= cpu_dp
->tag_ops
->xmit
;
1420 port
->slave
= slave_dev
;
1422 netif_carrier_off(slave_dev
);
1424 ret
= dsa_slave_phy_setup(slave_dev
);
1426 netdev_err(master
, "error %d setting up slave phy\n", ret
);
1430 dsa_slave_notify(slave_dev
, DSA_PORT_REGISTER
);
1432 ret
= register_netdev(slave_dev
);
1434 netdev_err(master
, "error %d registering interface %s\n",
1435 ret
, slave_dev
->name
);
1443 phylink_disconnect_phy(p
->dp
->pl
);
1445 phylink_destroy(p
->dp
->pl
);
1447 free_percpu(p
->stats64
);
1448 free_netdev(slave_dev
);
1453 void dsa_slave_destroy(struct net_device
*slave_dev
)
1455 struct dsa_port
*dp
= dsa_slave_to_port(slave_dev
);
1456 struct dsa_slave_priv
*p
= netdev_priv(slave_dev
);
1458 netif_carrier_off(slave_dev
);
1460 phylink_disconnect_phy(dp
->pl
);
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
);
1470 bool dsa_slave_dev_check(const struct net_device
*dev
)
1472 return dev
->netdev_ops
== &dsa_slave_netdev_ops
;
1475 static int dsa_slave_changeupper(struct net_device
*dev
,
1476 struct netdev_notifier_changeupper_info
*info
)
1478 struct dsa_port
*dp
= dsa_slave_to_port(dev
);
1479 int err
= NOTIFY_DONE
;
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
);
1486 dsa_port_bridge_leave(dp
, info
->upper_dev
);
1494 static int dsa_slave_upper_vlan_check(struct net_device
*dev
,
1495 struct netdev_notifier_changeupper_info
*
1498 struct netlink_ext_ack
*ext_ack
;
1499 struct net_device
*slave
;
1500 struct dsa_port
*dp
;
1502 ext_ack
= netdev_notifier_info_to_extack(&info
->info
);
1504 if (!is_vlan_dev(dev
))
1507 slave
= vlan_dev_real_dev(dev
);
1508 if (!dsa_slave_dev_check(slave
))
1511 dp
= dsa_slave_to_port(slave
);
1512 if (!dp
->bridge_dev
)
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
);
1526 static int dsa_slave_netdevice_event(struct notifier_block
*nb
,
1527 unsigned long event
, void *ptr
)
1529 struct net_device
*dev
= netdev_notifier_info_to_dev(ptr
);
1531 if (event
== NETDEV_CHANGEUPPER
) {
1532 if (!dsa_slave_dev_check(dev
))
1533 return dsa_slave_upper_vlan_check(dev
, ptr
);
1535 return dsa_slave_changeupper(dev
, ptr
);
1541 struct 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
;
1548 static void dsa_slave_switchdev_event_work(struct work_struct
*work
)
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
);
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
)
1564 err
= dsa_port_fdb_add(dp
, fdb_info
->addr
, fdb_info
->vid
);
1566 netdev_dbg(dev
, "fdb add failed err=%d\n", err
);
1569 fdb_info
->offloaded
= true;
1570 call_switchdev_notifiers(SWITCHDEV_FDB_OFFLOADED
, dev
,
1571 &fdb_info
->info
, NULL
);
1574 case SWITCHDEV_FDB_DEL_TO_DEVICE
:
1575 fdb_info
= &switchdev_work
->fdb_info
;
1576 if (!fdb_info
->added_by_user
)
1579 err
= dsa_port_fdb_del(dp
, fdb_info
->addr
, fdb_info
->vid
);
1581 netdev_dbg(dev
, "fdb del failed err=%d\n", err
);
1588 kfree(switchdev_work
->fdb_info
.addr
);
1589 kfree(switchdev_work
);
1594 dsa_slave_switchdev_fdb_work_init(struct dsa_switchdev_event_work
*
1596 const struct switchdev_notifier_fdb_info
*
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
)
1604 ether_addr_copy((u8
*)switchdev_work
->fdb_info
.addr
,
1609 /* Called under rcu_read_lock() */
1610 static int dsa_slave_switchdev_event(struct notifier_block
*unused
,
1611 unsigned long event
, void *ptr
)
1613 struct net_device
*dev
= switchdev_notifier_info_to_dev(ptr
);
1614 struct dsa_switchdev_event_work
*switchdev_work
;
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
);
1624 if (!dsa_slave_dev_check(dev
))
1627 switchdev_work
= kzalloc(sizeof(*switchdev_work
), GFP_ATOMIC
);
1628 if (!switchdev_work
)
1631 INIT_WORK(&switchdev_work
->work
,
1632 dsa_slave_switchdev_event_work
);
1633 switchdev_work
->dev
= dev
;
1634 switchdev_work
->event
= 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
;
1644 kfree(switchdev_work
);
1648 dsa_schedule_work(&switchdev_work
->work
);
1652 kfree(switchdev_work
);
1656 static int dsa_slave_switchdev_blocking_event(struct notifier_block
*unused
,
1657 unsigned long event
, void *ptr
)
1659 struct net_device
*dev
= switchdev_notifier_info_to_dev(ptr
);
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
);
1683 static struct notifier_block dsa_slave_nb __read_mostly
= {
1684 .notifier_call
= dsa_slave_netdevice_event
,
1687 static struct notifier_block dsa_slave_switchdev_notifier
= {
1688 .notifier_call
= dsa_slave_switchdev_event
,
1691 static struct notifier_block dsa_slave_switchdev_blocking_notifier
= {
1692 .notifier_call
= dsa_slave_switchdev_blocking_event
,
1695 int dsa_slave_register_notifier(void)
1697 struct notifier_block
*nb
;
1700 err
= register_netdevice_notifier(&dsa_slave_nb
);
1704 err
= register_switchdev_notifier(&dsa_slave_switchdev_notifier
);
1706 goto err_switchdev_nb
;
1708 nb
= &dsa_slave_switchdev_blocking_notifier
;
1709 err
= register_switchdev_blocking_notifier(nb
);
1711 goto err_switchdev_blocking_nb
;
1715 err_switchdev_blocking_nb
:
1716 unregister_switchdev_notifier(&dsa_slave_switchdev_notifier
);
1718 unregister_netdevice_notifier(&dsa_slave_nb
);
1722 void dsa_slave_unregister_notifier(void)
1724 struct notifier_block
*nb
;
1727 nb
= &dsa_slave_switchdev_blocking_notifier
;
1728 err
= unregister_switchdev_blocking_notifier(nb
);
1730 pr_err("DSA: failed to unregister switchdev blocking notifier (%d)\n", err
);
1732 err
= unregister_switchdev_notifier(&dsa_slave_switchdev_notifier
);
1734 pr_err("DSA: failed to unregister switchdev notifier (%d)\n", err
);
1736 err
= unregister_netdevice_notifier(&dsa_slave_nb
);
1738 pr_err("DSA: failed to unregister slave notifier (%d)\n", err
);