2 * net/dsa/slave.c - Slave device handling
3 * Copyright (c) 2008-2009 Marvell Semiconductor
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
11 #include <linux/list.h>
12 #include <linux/etherdevice.h>
13 #include <linux/netdevice.h>
14 #include <linux/phy.h>
15 #include <linux/phy_fixed.h>
16 #include <linux/of_net.h>
17 #include <linux/of_mdio.h>
18 #include <linux/mdio.h>
19 #include <linux/list.h>
21 #include <net/rtnetlink.h>
22 #include <net/switchdev.h>
23 #include <net/pkt_cls.h>
24 #include <net/tc_act/tc_mirred.h>
25 #include <linux/if_bridge.h>
26 #include <linux/netpoll.h>
29 static bool dsa_slave_dev_check(struct net_device *dev);
31 static int dsa_slave_notify(struct net_device *dev, unsigned long e, void *v)
33 struct dsa_slave_priv *p = netdev_priv(dev);
34 struct raw_notifier_head *nh = &p->dp->ds->dst->nh;
37 err = raw_notifier_call_chain(nh, e, v);
39 return notifier_to_errno(err);
42 /* slave mii_bus handling ***************************************************/
43 static int dsa_slave_phy_read(struct mii_bus *bus, int addr, int reg)
45 struct dsa_switch *ds = bus->priv;
47 if (ds->phys_mii_mask & (1 << addr))
48 return ds->ops->phy_read(ds, addr, reg);
53 static int dsa_slave_phy_write(struct mii_bus *bus, int addr, int reg, u16 val)
55 struct dsa_switch *ds = bus->priv;
57 if (ds->phys_mii_mask & (1 << addr))
58 return ds->ops->phy_write(ds, addr, reg, val);
63 void dsa_slave_mii_bus_init(struct dsa_switch *ds)
65 ds->slave_mii_bus->priv = (void *)ds;
66 ds->slave_mii_bus->name = "dsa slave smi";
67 ds->slave_mii_bus->read = dsa_slave_phy_read;
68 ds->slave_mii_bus->write = dsa_slave_phy_write;
69 snprintf(ds->slave_mii_bus->id, MII_BUS_ID_SIZE, "dsa-%d.%d",
70 ds->dst->tree, ds->index);
71 ds->slave_mii_bus->parent = ds->dev;
72 ds->slave_mii_bus->phy_mask = ~ds->phys_mii_mask;
76 /* slave device handling ****************************************************/
77 static int dsa_slave_get_iflink(const struct net_device *dev)
79 struct dsa_slave_priv *p = netdev_priv(dev);
81 return p->dp->ds->dst->master_netdev->ifindex;
84 static inline bool dsa_port_is_bridged(struct dsa_port *dp)
86 return !!dp->bridge_dev;
89 static void dsa_slave_set_state(struct net_device *dev, u8 state)
91 struct dsa_slave_priv *p = netdev_priv(dev);
92 struct dsa_port *dp = p->dp;
93 struct dsa_switch *ds = dp->ds;
96 if (ds->ops->port_stp_state_set)
97 ds->ops->port_stp_state_set(ds, port, state);
99 if (ds->ops->port_fast_age) {
100 /* Fast age FDB entries or flush appropriate forwarding database
101 * for the given port, if we are moving it from Learning or
102 * Forwarding state, to Disabled or Blocking or Listening state.
105 if ((dp->stp_state == BR_STATE_LEARNING ||
106 dp->stp_state == BR_STATE_FORWARDING) &&
107 (state == BR_STATE_DISABLED ||
108 state == BR_STATE_BLOCKING ||
109 state == BR_STATE_LISTENING))
110 ds->ops->port_fast_age(ds, port);
113 dp->stp_state = state;
116 static int dsa_slave_open(struct net_device *dev)
118 struct dsa_slave_priv *p = netdev_priv(dev);
119 struct net_device *master = p->dp->ds->dst->master_netdev;
120 struct dsa_switch *ds = p->dp->ds;
121 u8 stp_state = dsa_port_is_bridged(p->dp) ?
122 BR_STATE_BLOCKING : BR_STATE_FORWARDING;
125 if (!(master->flags & IFF_UP))
128 if (!ether_addr_equal(dev->dev_addr, master->dev_addr)) {
129 err = dev_uc_add(master, dev->dev_addr);
134 if (dev->flags & IFF_ALLMULTI) {
135 err = dev_set_allmulti(master, 1);
139 if (dev->flags & IFF_PROMISC) {
140 err = dev_set_promiscuity(master, 1);
145 if (ds->ops->port_enable) {
146 err = ds->ops->port_enable(ds, p->dp->index, p->phy);
151 dsa_slave_set_state(dev, stp_state);
159 if (dev->flags & IFF_PROMISC)
160 dev_set_promiscuity(master, -1);
162 if (dev->flags & IFF_ALLMULTI)
163 dev_set_allmulti(master, -1);
165 if (!ether_addr_equal(dev->dev_addr, master->dev_addr))
166 dev_uc_del(master, dev->dev_addr);
171 static int dsa_slave_close(struct net_device *dev)
173 struct dsa_slave_priv *p = netdev_priv(dev);
174 struct net_device *master = p->dp->ds->dst->master_netdev;
175 struct dsa_switch *ds = p->dp->ds;
180 dev_mc_unsync(master, dev);
181 dev_uc_unsync(master, dev);
182 if (dev->flags & IFF_ALLMULTI)
183 dev_set_allmulti(master, -1);
184 if (dev->flags & IFF_PROMISC)
185 dev_set_promiscuity(master, -1);
187 if (!ether_addr_equal(dev->dev_addr, master->dev_addr))
188 dev_uc_del(master, dev->dev_addr);
190 if (ds->ops->port_disable)
191 ds->ops->port_disable(ds, p->dp->index, p->phy);
193 dsa_slave_set_state(dev, BR_STATE_DISABLED);
198 static void dsa_slave_change_rx_flags(struct net_device *dev, int change)
200 struct dsa_slave_priv *p = netdev_priv(dev);
201 struct net_device *master = p->dp->ds->dst->master_netdev;
203 if (change & IFF_ALLMULTI)
204 dev_set_allmulti(master, dev->flags & IFF_ALLMULTI ? 1 : -1);
205 if (change & IFF_PROMISC)
206 dev_set_promiscuity(master, dev->flags & IFF_PROMISC ? 1 : -1);
209 static void dsa_slave_set_rx_mode(struct net_device *dev)
211 struct dsa_slave_priv *p = netdev_priv(dev);
212 struct net_device *master = p->dp->ds->dst->master_netdev;
214 dev_mc_sync(master, dev);
215 dev_uc_sync(master, dev);
218 static int dsa_slave_set_mac_address(struct net_device *dev, void *a)
220 struct dsa_slave_priv *p = netdev_priv(dev);
221 struct net_device *master = p->dp->ds->dst->master_netdev;
222 struct sockaddr *addr = a;
225 if (!is_valid_ether_addr(addr->sa_data))
226 return -EADDRNOTAVAIL;
228 if (!(dev->flags & IFF_UP))
231 if (!ether_addr_equal(addr->sa_data, master->dev_addr)) {
232 err = dev_uc_add(master, addr->sa_data);
237 if (!ether_addr_equal(dev->dev_addr, master->dev_addr))
238 dev_uc_del(master, dev->dev_addr);
241 ether_addr_copy(dev->dev_addr, addr->sa_data);
246 static int dsa_slave_port_vlan_add(struct net_device *dev,
247 const struct switchdev_obj_port_vlan *vlan,
248 struct switchdev_trans *trans)
250 struct dsa_slave_priv *p = netdev_priv(dev);
251 struct dsa_port *dp = p->dp;
252 struct dsa_switch *ds = dp->ds;
254 if (switchdev_trans_ph_prepare(trans)) {
255 if (!ds->ops->port_vlan_prepare || !ds->ops->port_vlan_add)
258 return ds->ops->port_vlan_prepare(ds, dp->index, vlan, trans);
261 ds->ops->port_vlan_add(ds, dp->index, vlan, trans);
266 static int dsa_slave_port_vlan_del(struct net_device *dev,
267 const struct switchdev_obj_port_vlan *vlan)
269 struct dsa_slave_priv *p = netdev_priv(dev);
270 struct dsa_switch *ds = p->dp->ds;
272 if (!ds->ops->port_vlan_del)
275 return ds->ops->port_vlan_del(ds, p->dp->index, vlan);
278 static int dsa_slave_port_vlan_dump(struct net_device *dev,
279 struct switchdev_obj_port_vlan *vlan,
280 switchdev_obj_dump_cb_t *cb)
282 struct dsa_slave_priv *p = netdev_priv(dev);
283 struct dsa_switch *ds = p->dp->ds;
285 if (ds->ops->port_vlan_dump)
286 return ds->ops->port_vlan_dump(ds, p->dp->index, vlan, cb);
291 static int dsa_slave_port_fdb_add(struct net_device *dev,
292 const struct switchdev_obj_port_fdb *fdb,
293 struct switchdev_trans *trans)
295 struct dsa_slave_priv *p = netdev_priv(dev);
296 struct dsa_switch *ds = p->dp->ds;
298 if (switchdev_trans_ph_prepare(trans)) {
299 if (!ds->ops->port_fdb_prepare || !ds->ops->port_fdb_add)
302 return ds->ops->port_fdb_prepare(ds, p->dp->index, fdb, trans);
305 ds->ops->port_fdb_add(ds, p->dp->index, fdb, trans);
310 static int dsa_slave_port_fdb_del(struct net_device *dev,
311 const struct switchdev_obj_port_fdb *fdb)
313 struct dsa_slave_priv *p = netdev_priv(dev);
314 struct dsa_switch *ds = p->dp->ds;
315 int ret = -EOPNOTSUPP;
317 if (ds->ops->port_fdb_del)
318 ret = ds->ops->port_fdb_del(ds, p->dp->index, fdb);
323 static int dsa_slave_port_fdb_dump(struct net_device *dev,
324 struct switchdev_obj_port_fdb *fdb,
325 switchdev_obj_dump_cb_t *cb)
327 struct dsa_slave_priv *p = netdev_priv(dev);
328 struct dsa_switch *ds = p->dp->ds;
330 if (ds->ops->port_fdb_dump)
331 return ds->ops->port_fdb_dump(ds, p->dp->index, fdb, cb);
336 static int dsa_slave_port_mdb_add(struct net_device *dev,
337 const struct switchdev_obj_port_mdb *mdb,
338 struct switchdev_trans *trans)
340 struct dsa_slave_priv *p = netdev_priv(dev);
341 struct dsa_switch *ds = p->dp->ds;
343 if (switchdev_trans_ph_prepare(trans)) {
344 if (!ds->ops->port_mdb_prepare || !ds->ops->port_mdb_add)
347 return ds->ops->port_mdb_prepare(ds, p->dp->index, mdb, trans);
350 ds->ops->port_mdb_add(ds, p->dp->index, mdb, trans);
355 static int dsa_slave_port_mdb_del(struct net_device *dev,
356 const struct switchdev_obj_port_mdb *mdb)
358 struct dsa_slave_priv *p = netdev_priv(dev);
359 struct dsa_switch *ds = p->dp->ds;
361 if (ds->ops->port_mdb_del)
362 return ds->ops->port_mdb_del(ds, p->dp->index, mdb);
367 static int dsa_slave_port_mdb_dump(struct net_device *dev,
368 struct switchdev_obj_port_mdb *mdb,
369 switchdev_obj_dump_cb_t *cb)
371 struct dsa_slave_priv *p = netdev_priv(dev);
372 struct dsa_switch *ds = p->dp->ds;
374 if (ds->ops->port_mdb_dump)
375 return ds->ops->port_mdb_dump(ds, p->dp->index, mdb, cb);
380 static int dsa_slave_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
382 struct dsa_slave_priv *p = netdev_priv(dev);
385 return phy_mii_ioctl(p->phy, ifr, cmd);
390 static int dsa_slave_stp_state_set(struct net_device *dev,
391 const struct switchdev_attr *attr,
392 struct switchdev_trans *trans)
394 struct dsa_slave_priv *p = netdev_priv(dev);
395 struct dsa_switch *ds = p->dp->ds;
397 if (switchdev_trans_ph_prepare(trans))
398 return ds->ops->port_stp_state_set ? 0 : -EOPNOTSUPP;
400 dsa_slave_set_state(dev, attr->u.stp_state);
405 static int dsa_slave_vlan_filtering(struct net_device *dev,
406 const struct switchdev_attr *attr,
407 struct switchdev_trans *trans)
409 struct dsa_slave_priv *p = netdev_priv(dev);
410 struct dsa_switch *ds = p->dp->ds;
412 /* bridge skips -EOPNOTSUPP, so skip the prepare phase */
413 if (switchdev_trans_ph_prepare(trans))
416 if (ds->ops->port_vlan_filtering)
417 return ds->ops->port_vlan_filtering(ds, p->dp->index,
418 attr->u.vlan_filtering);
423 static unsigned int dsa_fastest_ageing_time(struct dsa_switch *ds,
424 unsigned int ageing_time)
428 for (i = 0; i < ds->num_ports; ++i) {
429 struct dsa_port *dp = &ds->ports[i];
431 if (dp && dp->ageing_time && dp->ageing_time < ageing_time)
432 ageing_time = dp->ageing_time;
438 static int dsa_slave_ageing_time(struct net_device *dev,
439 const struct switchdev_attr *attr,
440 struct switchdev_trans *trans)
442 struct dsa_slave_priv *p = netdev_priv(dev);
443 struct dsa_switch *ds = p->dp->ds;
444 unsigned long ageing_jiffies = clock_t_to_jiffies(attr->u.ageing_time);
445 unsigned int ageing_time = jiffies_to_msecs(ageing_jiffies);
447 if (switchdev_trans_ph_prepare(trans)) {
448 if (ds->ageing_time_min && ageing_time < ds->ageing_time_min)
450 if (ds->ageing_time_max && ageing_time > ds->ageing_time_max)
455 /* Keep the fastest ageing time in case of multiple bridges */
456 p->dp->ageing_time = ageing_time;
457 ageing_time = dsa_fastest_ageing_time(ds, ageing_time);
459 if (ds->ops->set_ageing_time)
460 return ds->ops->set_ageing_time(ds, ageing_time);
465 static int dsa_slave_port_attr_set(struct net_device *dev,
466 const struct switchdev_attr *attr,
467 struct switchdev_trans *trans)
472 case SWITCHDEV_ATTR_ID_PORT_STP_STATE:
473 ret = dsa_slave_stp_state_set(dev, attr, trans);
475 case SWITCHDEV_ATTR_ID_BRIDGE_VLAN_FILTERING:
476 ret = dsa_slave_vlan_filtering(dev, attr, trans);
478 case SWITCHDEV_ATTR_ID_BRIDGE_AGEING_TIME:
479 ret = dsa_slave_ageing_time(dev, attr, trans);
489 static int dsa_slave_port_obj_add(struct net_device *dev,
490 const struct switchdev_obj *obj,
491 struct switchdev_trans *trans)
495 /* For the prepare phase, ensure the full set of changes is feasable in
496 * one go in order to signal a failure properly. If an operation is not
497 * supported, return -EOPNOTSUPP.
501 case SWITCHDEV_OBJ_ID_PORT_FDB:
502 err = dsa_slave_port_fdb_add(dev,
503 SWITCHDEV_OBJ_PORT_FDB(obj),
506 case SWITCHDEV_OBJ_ID_PORT_MDB:
507 err = dsa_slave_port_mdb_add(dev, SWITCHDEV_OBJ_PORT_MDB(obj),
510 case SWITCHDEV_OBJ_ID_PORT_VLAN:
511 err = dsa_slave_port_vlan_add(dev,
512 SWITCHDEV_OBJ_PORT_VLAN(obj),
523 static int dsa_slave_port_obj_del(struct net_device *dev,
524 const struct switchdev_obj *obj)
529 case SWITCHDEV_OBJ_ID_PORT_FDB:
530 err = dsa_slave_port_fdb_del(dev,
531 SWITCHDEV_OBJ_PORT_FDB(obj));
533 case SWITCHDEV_OBJ_ID_PORT_MDB:
534 err = dsa_slave_port_mdb_del(dev, SWITCHDEV_OBJ_PORT_MDB(obj));
536 case SWITCHDEV_OBJ_ID_PORT_VLAN:
537 err = dsa_slave_port_vlan_del(dev,
538 SWITCHDEV_OBJ_PORT_VLAN(obj));
548 static int dsa_slave_port_obj_dump(struct net_device *dev,
549 struct switchdev_obj *obj,
550 switchdev_obj_dump_cb_t *cb)
555 case SWITCHDEV_OBJ_ID_PORT_FDB:
556 err = dsa_slave_port_fdb_dump(dev,
557 SWITCHDEV_OBJ_PORT_FDB(obj),
560 case SWITCHDEV_OBJ_ID_PORT_MDB:
561 err = dsa_slave_port_mdb_dump(dev, SWITCHDEV_OBJ_PORT_MDB(obj),
564 case SWITCHDEV_OBJ_ID_PORT_VLAN:
565 err = dsa_slave_port_vlan_dump(dev,
566 SWITCHDEV_OBJ_PORT_VLAN(obj),
577 static int dsa_slave_bridge_port_join(struct net_device *dev,
578 struct net_device *br)
580 struct dsa_slave_priv *p = netdev_priv(dev);
581 struct dsa_notifier_bridge_info info = {
582 .sw_index = p->dp->ds->index,
583 .port = p->dp->index,
588 /* Here the port is already bridged. Reflect the current configuration
589 * so that drivers can program their chips accordingly.
591 p->dp->bridge_dev = br;
593 err = dsa_slave_notify(dev, DSA_NOTIFIER_BRIDGE_JOIN, &info);
595 /* The bridging is rolled back on error */
597 p->dp->bridge_dev = NULL;
602 static void dsa_slave_bridge_port_leave(struct net_device *dev,
603 struct net_device *br)
605 struct dsa_slave_priv *p = netdev_priv(dev);
606 struct dsa_notifier_bridge_info info = {
607 .sw_index = p->dp->ds->index,
608 .port = p->dp->index,
613 /* Here the port is already unbridged. Reflect the current configuration
614 * so that drivers can program their chips accordingly.
616 p->dp->bridge_dev = NULL;
618 err = dsa_slave_notify(dev, DSA_NOTIFIER_BRIDGE_LEAVE, &info);
620 netdev_err(dev, "failed to notify DSA_NOTIFIER_BRIDGE_LEAVE\n");
622 /* Port left the bridge, put in BR_STATE_DISABLED by the bridge layer,
623 * so allow it to be in BR_STATE_FORWARDING to be kept functional
625 dsa_slave_set_state(dev, BR_STATE_FORWARDING);
628 static int dsa_slave_port_attr_get(struct net_device *dev,
629 struct switchdev_attr *attr)
631 struct dsa_slave_priv *p = netdev_priv(dev);
632 struct dsa_switch *ds = p->dp->ds;
635 case SWITCHDEV_ATTR_ID_PORT_PARENT_ID:
636 attr->u.ppid.id_len = sizeof(ds->index);
637 memcpy(&attr->u.ppid.id, &ds->index, attr->u.ppid.id_len);
646 static inline netdev_tx_t dsa_netpoll_send_skb(struct dsa_slave_priv *p,
649 #ifdef CONFIG_NET_POLL_CONTROLLER
651 netpoll_send_skb(p->netpoll, skb);
658 static netdev_tx_t dsa_slave_xmit(struct sk_buff *skb, struct net_device *dev)
660 struct dsa_slave_priv *p = netdev_priv(dev);
661 struct sk_buff *nskb;
663 dev->stats.tx_packets++;
664 dev->stats.tx_bytes += skb->len;
666 /* Transmit function may have to reallocate the original SKB */
667 nskb = p->xmit(skb, dev);
671 /* SKB for netpoll still need to be mangled with the protocol-specific
672 * tag to be successfully transmitted
674 if (unlikely(netpoll_tx_running(dev)))
675 return dsa_netpoll_send_skb(p, nskb);
677 /* Queue the SKB for transmission on the parent interface, but
678 * do not modify its EtherType
680 nskb->dev = p->dp->ds->dst->master_netdev;
681 dev_queue_xmit(nskb);
686 /* ethtool operations *******************************************************/
688 dsa_slave_get_link_ksettings(struct net_device *dev,
689 struct ethtool_link_ksettings *cmd)
691 struct dsa_slave_priv *p = netdev_priv(dev);
692 int err = -EOPNOTSUPP;
695 err = phy_ethtool_ksettings_get(p->phy, cmd);
701 dsa_slave_set_link_ksettings(struct net_device *dev,
702 const struct ethtool_link_ksettings *cmd)
704 struct dsa_slave_priv *p = netdev_priv(dev);
707 return phy_ethtool_ksettings_set(p->phy, cmd);
712 static void dsa_slave_get_drvinfo(struct net_device *dev,
713 struct ethtool_drvinfo *drvinfo)
715 strlcpy(drvinfo->driver, "dsa", sizeof(drvinfo->driver));
716 strlcpy(drvinfo->fw_version, "N/A", sizeof(drvinfo->fw_version));
717 strlcpy(drvinfo->bus_info, "platform", sizeof(drvinfo->bus_info));
720 static int dsa_slave_get_regs_len(struct net_device *dev)
722 struct dsa_slave_priv *p = netdev_priv(dev);
723 struct dsa_switch *ds = p->dp->ds;
725 if (ds->ops->get_regs_len)
726 return ds->ops->get_regs_len(ds, p->dp->index);
732 dsa_slave_get_regs(struct net_device *dev, struct ethtool_regs *regs, void *_p)
734 struct dsa_slave_priv *p = netdev_priv(dev);
735 struct dsa_switch *ds = p->dp->ds;
737 if (ds->ops->get_regs)
738 ds->ops->get_regs(ds, p->dp->index, regs, _p);
741 static int dsa_slave_nway_reset(struct net_device *dev)
743 struct dsa_slave_priv *p = netdev_priv(dev);
746 return genphy_restart_aneg(p->phy);
751 static u32 dsa_slave_get_link(struct net_device *dev)
753 struct dsa_slave_priv *p = netdev_priv(dev);
755 if (p->phy != NULL) {
756 genphy_update_link(p->phy);
763 static int dsa_slave_get_eeprom_len(struct net_device *dev)
765 struct dsa_slave_priv *p = netdev_priv(dev);
766 struct dsa_switch *ds = p->dp->ds;
768 if (ds->cd && ds->cd->eeprom_len)
769 return ds->cd->eeprom_len;
771 if (ds->ops->get_eeprom_len)
772 return ds->ops->get_eeprom_len(ds);
777 static int dsa_slave_get_eeprom(struct net_device *dev,
778 struct ethtool_eeprom *eeprom, u8 *data)
780 struct dsa_slave_priv *p = netdev_priv(dev);
781 struct dsa_switch *ds = p->dp->ds;
783 if (ds->ops->get_eeprom)
784 return ds->ops->get_eeprom(ds, eeprom, data);
789 static int dsa_slave_set_eeprom(struct net_device *dev,
790 struct ethtool_eeprom *eeprom, u8 *data)
792 struct dsa_slave_priv *p = netdev_priv(dev);
793 struct dsa_switch *ds = p->dp->ds;
795 if (ds->ops->set_eeprom)
796 return ds->ops->set_eeprom(ds, eeprom, data);
801 static void dsa_slave_get_strings(struct net_device *dev,
802 uint32_t stringset, uint8_t *data)
804 struct dsa_slave_priv *p = netdev_priv(dev);
805 struct dsa_switch *ds = p->dp->ds;
807 if (stringset == ETH_SS_STATS) {
808 int len = ETH_GSTRING_LEN;
810 strncpy(data, "tx_packets", len);
811 strncpy(data + len, "tx_bytes", len);
812 strncpy(data + 2 * len, "rx_packets", len);
813 strncpy(data + 3 * len, "rx_bytes", len);
814 if (ds->ops->get_strings)
815 ds->ops->get_strings(ds, p->dp->index, data + 4 * len);
819 static void dsa_cpu_port_get_ethtool_stats(struct net_device *dev,
820 struct ethtool_stats *stats,
823 struct dsa_switch_tree *dst = dev->dsa_ptr;
824 struct dsa_switch *ds = dst->cpu_switch;
825 s8 cpu_port = dst->cpu_port;
828 if (dst->master_ethtool_ops.get_sset_count) {
829 count = dst->master_ethtool_ops.get_sset_count(dev,
831 dst->master_ethtool_ops.get_ethtool_stats(dev, stats, data);
834 if (ds->ops->get_ethtool_stats)
835 ds->ops->get_ethtool_stats(ds, cpu_port, data + count);
838 static int dsa_cpu_port_get_sset_count(struct net_device *dev, int sset)
840 struct dsa_switch_tree *dst = dev->dsa_ptr;
841 struct dsa_switch *ds = dst->cpu_switch;
844 if (dst->master_ethtool_ops.get_sset_count)
845 count += dst->master_ethtool_ops.get_sset_count(dev, sset);
847 if (sset == ETH_SS_STATS && ds->ops->get_sset_count)
848 count += ds->ops->get_sset_count(ds);
853 static void dsa_cpu_port_get_strings(struct net_device *dev,
854 uint32_t stringset, uint8_t *data)
856 struct dsa_switch_tree *dst = dev->dsa_ptr;
857 struct dsa_switch *ds = dst->cpu_switch;
858 s8 cpu_port = dst->cpu_port;
859 int len = ETH_GSTRING_LEN;
860 int mcount = 0, count;
865 snprintf(pfx, sizeof(pfx), "p%.2d", cpu_port);
866 /* We do not want to be NULL-terminated, since this is a prefix */
867 pfx[sizeof(pfx) - 1] = '_';
869 if (dst->master_ethtool_ops.get_sset_count) {
870 mcount = dst->master_ethtool_ops.get_sset_count(dev,
872 dst->master_ethtool_ops.get_strings(dev, stringset, data);
875 if (stringset == ETH_SS_STATS && ds->ops->get_strings) {
876 ndata = data + mcount * len;
877 /* This function copies ETH_GSTRINGS_LEN bytes, we will mangle
878 * the output after to prepend our CPU port prefix we
879 * constructed earlier
881 ds->ops->get_strings(ds, cpu_port, ndata);
882 count = ds->ops->get_sset_count(ds);
883 for (i = 0; i < count; i++) {
884 memmove(ndata + (i * len + sizeof(pfx)),
885 ndata + i * len, len - sizeof(pfx));
886 memcpy(ndata + i * len, pfx, sizeof(pfx));
891 static void dsa_slave_get_ethtool_stats(struct net_device *dev,
892 struct ethtool_stats *stats,
895 struct dsa_slave_priv *p = netdev_priv(dev);
896 struct dsa_switch *ds = p->dp->ds;
898 data[0] = dev->stats.tx_packets;
899 data[1] = dev->stats.tx_bytes;
900 data[2] = dev->stats.rx_packets;
901 data[3] = dev->stats.rx_bytes;
902 if (ds->ops->get_ethtool_stats)
903 ds->ops->get_ethtool_stats(ds, p->dp->index, data + 4);
906 static int dsa_slave_get_sset_count(struct net_device *dev, int sset)
908 struct dsa_slave_priv *p = netdev_priv(dev);
909 struct dsa_switch *ds = p->dp->ds;
911 if (sset == ETH_SS_STATS) {
915 if (ds->ops->get_sset_count)
916 count += ds->ops->get_sset_count(ds);
924 static void dsa_slave_get_wol(struct net_device *dev, struct ethtool_wolinfo *w)
926 struct dsa_slave_priv *p = netdev_priv(dev);
927 struct dsa_switch *ds = p->dp->ds;
929 if (ds->ops->get_wol)
930 ds->ops->get_wol(ds, p->dp->index, w);
933 static int dsa_slave_set_wol(struct net_device *dev, struct ethtool_wolinfo *w)
935 struct dsa_slave_priv *p = netdev_priv(dev);
936 struct dsa_switch *ds = p->dp->ds;
937 int ret = -EOPNOTSUPP;
939 if (ds->ops->set_wol)
940 ret = ds->ops->set_wol(ds, p->dp->index, w);
945 static int dsa_slave_set_eee(struct net_device *dev, struct ethtool_eee *e)
947 struct dsa_slave_priv *p = netdev_priv(dev);
948 struct dsa_switch *ds = p->dp->ds;
951 if (!ds->ops->set_eee)
954 ret = ds->ops->set_eee(ds, p->dp->index, p->phy, e);
959 ret = phy_ethtool_set_eee(p->phy, e);
964 static int dsa_slave_get_eee(struct net_device *dev, struct ethtool_eee *e)
966 struct dsa_slave_priv *p = netdev_priv(dev);
967 struct dsa_switch *ds = p->dp->ds;
970 if (!ds->ops->get_eee)
973 ret = ds->ops->get_eee(ds, p->dp->index, e);
978 ret = phy_ethtool_get_eee(p->phy, e);
983 #ifdef CONFIG_NET_POLL_CONTROLLER
984 static int dsa_slave_netpoll_setup(struct net_device *dev,
985 struct netpoll_info *ni)
987 struct dsa_slave_priv *p = netdev_priv(dev);
988 struct dsa_switch *ds = p->dp->ds;
989 struct net_device *master = ds->dst->master_netdev;
990 struct netpoll *netpoll;
993 netpoll = kzalloc(sizeof(*netpoll), GFP_KERNEL);
997 err = __netpoll_setup(netpoll, master);
1003 p->netpoll = netpoll;
1008 static void dsa_slave_netpoll_cleanup(struct net_device *dev)
1010 struct dsa_slave_priv *p = netdev_priv(dev);
1011 struct netpoll *netpoll = p->netpoll;
1018 __netpoll_free_async(netpoll);
1021 static void dsa_slave_poll_controller(struct net_device *dev)
1026 static int dsa_slave_get_phys_port_name(struct net_device *dev,
1027 char *name, size_t len)
1029 struct dsa_slave_priv *p = netdev_priv(dev);
1031 if (snprintf(name, len, "p%d", p->dp->index) >= len)
1037 static struct dsa_mall_tc_entry *
1038 dsa_slave_mall_tc_entry_find(struct dsa_slave_priv *p,
1039 unsigned long cookie)
1041 struct dsa_mall_tc_entry *mall_tc_entry;
1043 list_for_each_entry(mall_tc_entry, &p->mall_tc_list, list)
1044 if (mall_tc_entry->cookie == cookie)
1045 return mall_tc_entry;
1050 static int dsa_slave_add_cls_matchall(struct net_device *dev,
1052 struct tc_cls_matchall_offload *cls,
1055 struct dsa_slave_priv *p = netdev_priv(dev);
1056 struct dsa_mall_tc_entry *mall_tc_entry;
1057 struct dsa_switch *ds = p->dp->ds;
1058 struct net *net = dev_net(dev);
1059 struct dsa_slave_priv *to_p;
1060 struct net_device *to_dev;
1061 const struct tc_action *a;
1062 int err = -EOPNOTSUPP;
1066 if (!ds->ops->port_mirror_add)
1069 if (!tc_single_action(cls->exts))
1072 tcf_exts_to_list(cls->exts, &actions);
1073 a = list_first_entry(&actions, struct tc_action, list);
1075 if (is_tcf_mirred_egress_mirror(a) && protocol == htons(ETH_P_ALL)) {
1076 struct dsa_mall_mirror_tc_entry *mirror;
1078 ifindex = tcf_mirred_ifindex(a);
1079 to_dev = __dev_get_by_index(net, ifindex);
1083 if (!dsa_slave_dev_check(to_dev))
1086 mall_tc_entry = kzalloc(sizeof(*mall_tc_entry), GFP_KERNEL);
1090 mall_tc_entry->cookie = cls->cookie;
1091 mall_tc_entry->type = DSA_PORT_MALL_MIRROR;
1092 mirror = &mall_tc_entry->mirror;
1094 to_p = netdev_priv(to_dev);
1096 mirror->to_local_port = to_p->dp->index;
1097 mirror->ingress = ingress;
1099 err = ds->ops->port_mirror_add(ds, p->dp->index, mirror,
1102 kfree(mall_tc_entry);
1106 list_add_tail(&mall_tc_entry->list, &p->mall_tc_list);
1112 static void dsa_slave_del_cls_matchall(struct net_device *dev,
1113 struct tc_cls_matchall_offload *cls)
1115 struct dsa_slave_priv *p = netdev_priv(dev);
1116 struct dsa_mall_tc_entry *mall_tc_entry;
1117 struct dsa_switch *ds = p->dp->ds;
1119 if (!ds->ops->port_mirror_del)
1122 mall_tc_entry = dsa_slave_mall_tc_entry_find(p, cls->cookie);
1126 list_del(&mall_tc_entry->list);
1128 switch (mall_tc_entry->type) {
1129 case DSA_PORT_MALL_MIRROR:
1130 ds->ops->port_mirror_del(ds, p->dp->index,
1131 &mall_tc_entry->mirror);
1137 kfree(mall_tc_entry);
1140 static int dsa_slave_setup_tc(struct net_device *dev, u32 handle,
1141 __be16 protocol, struct tc_to_netdev *tc)
1143 bool ingress = TC_H_MAJ(handle) == TC_H_MAJ(TC_H_INGRESS);
1144 int ret = -EOPNOTSUPP;
1147 case TC_SETUP_MATCHALL:
1148 switch (tc->cls_mall->command) {
1149 case TC_CLSMATCHALL_REPLACE:
1150 return dsa_slave_add_cls_matchall(dev, protocol,
1153 case TC_CLSMATCHALL_DESTROY:
1154 dsa_slave_del_cls_matchall(dev, tc->cls_mall);
1164 void dsa_cpu_port_ethtool_init(struct ethtool_ops *ops)
1166 ops->get_sset_count = dsa_cpu_port_get_sset_count;
1167 ops->get_ethtool_stats = dsa_cpu_port_get_ethtool_stats;
1168 ops->get_strings = dsa_cpu_port_get_strings;
1171 static int dsa_slave_get_rxnfc(struct net_device *dev,
1172 struct ethtool_rxnfc *nfc, u32 *rule_locs)
1174 struct dsa_slave_priv *p = netdev_priv(dev);
1175 struct dsa_switch *ds = p->dp->ds;
1177 if (!ds->ops->get_rxnfc)
1180 return ds->ops->get_rxnfc(ds, p->dp->index, nfc, rule_locs);
1183 static int dsa_slave_set_rxnfc(struct net_device *dev,
1184 struct ethtool_rxnfc *nfc)
1186 struct dsa_slave_priv *p = netdev_priv(dev);
1187 struct dsa_switch *ds = p->dp->ds;
1189 if (!ds->ops->set_rxnfc)
1192 return ds->ops->set_rxnfc(ds, p->dp->index, nfc);
1195 static const struct ethtool_ops dsa_slave_ethtool_ops = {
1196 .get_drvinfo = dsa_slave_get_drvinfo,
1197 .get_regs_len = dsa_slave_get_regs_len,
1198 .get_regs = dsa_slave_get_regs,
1199 .nway_reset = dsa_slave_nway_reset,
1200 .get_link = dsa_slave_get_link,
1201 .get_eeprom_len = dsa_slave_get_eeprom_len,
1202 .get_eeprom = dsa_slave_get_eeprom,
1203 .set_eeprom = dsa_slave_set_eeprom,
1204 .get_strings = dsa_slave_get_strings,
1205 .get_ethtool_stats = dsa_slave_get_ethtool_stats,
1206 .get_sset_count = dsa_slave_get_sset_count,
1207 .set_wol = dsa_slave_set_wol,
1208 .get_wol = dsa_slave_get_wol,
1209 .set_eee = dsa_slave_set_eee,
1210 .get_eee = dsa_slave_get_eee,
1211 .get_link_ksettings = dsa_slave_get_link_ksettings,
1212 .set_link_ksettings = dsa_slave_set_link_ksettings,
1213 .get_rxnfc = dsa_slave_get_rxnfc,
1214 .set_rxnfc = dsa_slave_set_rxnfc,
1217 static const struct net_device_ops dsa_slave_netdev_ops = {
1218 .ndo_open = dsa_slave_open,
1219 .ndo_stop = dsa_slave_close,
1220 .ndo_start_xmit = dsa_slave_xmit,
1221 .ndo_change_rx_flags = dsa_slave_change_rx_flags,
1222 .ndo_set_rx_mode = dsa_slave_set_rx_mode,
1223 .ndo_set_mac_address = dsa_slave_set_mac_address,
1224 .ndo_fdb_add = switchdev_port_fdb_add,
1225 .ndo_fdb_del = switchdev_port_fdb_del,
1226 .ndo_fdb_dump = switchdev_port_fdb_dump,
1227 .ndo_do_ioctl = dsa_slave_ioctl,
1228 .ndo_get_iflink = dsa_slave_get_iflink,
1229 #ifdef CONFIG_NET_POLL_CONTROLLER
1230 .ndo_netpoll_setup = dsa_slave_netpoll_setup,
1231 .ndo_netpoll_cleanup = dsa_slave_netpoll_cleanup,
1232 .ndo_poll_controller = dsa_slave_poll_controller,
1234 .ndo_bridge_getlink = switchdev_port_bridge_getlink,
1235 .ndo_bridge_setlink = switchdev_port_bridge_setlink,
1236 .ndo_bridge_dellink = switchdev_port_bridge_dellink,
1237 .ndo_get_phys_port_name = dsa_slave_get_phys_port_name,
1238 .ndo_setup_tc = dsa_slave_setup_tc,
1241 static const struct switchdev_ops dsa_slave_switchdev_ops = {
1242 .switchdev_port_attr_get = dsa_slave_port_attr_get,
1243 .switchdev_port_attr_set = dsa_slave_port_attr_set,
1244 .switchdev_port_obj_add = dsa_slave_port_obj_add,
1245 .switchdev_port_obj_del = dsa_slave_port_obj_del,
1246 .switchdev_port_obj_dump = dsa_slave_port_obj_dump,
1249 static struct device_type dsa_type = {
1253 static void dsa_slave_adjust_link(struct net_device *dev)
1255 struct dsa_slave_priv *p = netdev_priv(dev);
1256 struct dsa_switch *ds = p->dp->ds;
1257 unsigned int status_changed = 0;
1259 if (p->old_link != p->phy->link) {
1261 p->old_link = p->phy->link;
1264 if (p->old_duplex != p->phy->duplex) {
1266 p->old_duplex = p->phy->duplex;
1269 if (p->old_pause != p->phy->pause) {
1271 p->old_pause = p->phy->pause;
1274 if (ds->ops->adjust_link && status_changed)
1275 ds->ops->adjust_link(ds, p->dp->index, p->phy);
1278 phy_print_status(p->phy);
1281 static int dsa_slave_fixed_link_update(struct net_device *dev,
1282 struct fixed_phy_status *status)
1284 struct dsa_slave_priv *p;
1285 struct dsa_switch *ds;
1288 p = netdev_priv(dev);
1290 if (ds->ops->fixed_link_update)
1291 ds->ops->fixed_link_update(ds, p->dp->index, status);
1297 /* slave device setup *******************************************************/
1298 static int dsa_slave_phy_connect(struct dsa_slave_priv *p,
1299 struct net_device *slave_dev,
1302 struct dsa_switch *ds = p->dp->ds;
1304 p->phy = mdiobus_get_phy(ds->slave_mii_bus, addr);
1306 netdev_err(slave_dev, "no phy at %d\n", addr);
1310 /* Use already configured phy mode */
1311 if (p->phy_interface == PHY_INTERFACE_MODE_NA)
1312 p->phy_interface = p->phy->interface;
1313 return phy_connect_direct(slave_dev, p->phy, dsa_slave_adjust_link,
1317 static int dsa_slave_phy_setup(struct dsa_slave_priv *p,
1318 struct net_device *slave_dev)
1320 struct dsa_switch *ds = p->dp->ds;
1321 struct device_node *phy_dn, *port_dn;
1322 bool phy_is_fixed = false;
1326 port_dn = p->dp->dn;
1327 mode = of_get_phy_mode(port_dn);
1329 mode = PHY_INTERFACE_MODE_NA;
1330 p->phy_interface = mode;
1332 phy_dn = of_parse_phandle(port_dn, "phy-handle", 0);
1333 if (!phy_dn && of_phy_is_fixed_link(port_dn)) {
1334 /* In the case of a fixed PHY, the DT node associated
1335 * to the fixed PHY is the Port DT node
1337 ret = of_phy_register_fixed_link(port_dn);
1339 netdev_err(slave_dev, "failed to register fixed PHY: %d\n", ret);
1342 phy_is_fixed = true;
1343 phy_dn = of_node_get(port_dn);
1346 if (ds->ops->get_phy_flags)
1347 phy_flags = ds->ops->get_phy_flags(ds, p->dp->index);
1350 int phy_id = of_mdio_parse_addr(&slave_dev->dev, phy_dn);
1352 /* If this PHY address is part of phys_mii_mask, which means
1353 * that we need to divert reads and writes to/from it, then we
1354 * want to bind this device using the slave MII bus created by
1355 * DSA to make that happen.
1357 if (!phy_is_fixed && phy_id >= 0 &&
1358 (ds->phys_mii_mask & (1 << phy_id))) {
1359 ret = dsa_slave_phy_connect(p, slave_dev, phy_id);
1361 netdev_err(slave_dev, "failed to connect to phy%d: %d\n", phy_id, ret);
1362 of_node_put(phy_dn);
1366 p->phy = of_phy_connect(slave_dev, phy_dn,
1367 dsa_slave_adjust_link,
1372 of_node_put(phy_dn);
1375 if (p->phy && phy_is_fixed)
1376 fixed_phy_set_link_update(p->phy, dsa_slave_fixed_link_update);
1378 /* We could not connect to a designated PHY, so use the switch internal
1382 ret = dsa_slave_phy_connect(p, slave_dev, p->dp->index);
1384 netdev_err(slave_dev, "failed to connect to port %d: %d\n",
1387 of_phy_deregister_fixed_link(port_dn);
1392 phy_attached_info(p->phy);
1397 static struct lock_class_key dsa_slave_netdev_xmit_lock_key;
1398 static void dsa_slave_set_lockdep_class_one(struct net_device *dev,
1399 struct netdev_queue *txq,
1402 lockdep_set_class(&txq->_xmit_lock,
1403 &dsa_slave_netdev_xmit_lock_key);
1406 int dsa_slave_suspend(struct net_device *slave_dev)
1408 struct dsa_slave_priv *p = netdev_priv(slave_dev);
1410 netif_device_detach(slave_dev);
1417 phy_suspend(p->phy);
1423 int dsa_slave_resume(struct net_device *slave_dev)
1425 struct dsa_slave_priv *p = netdev_priv(slave_dev);
1427 netif_device_attach(slave_dev);
1437 int dsa_slave_create(struct dsa_switch *ds, struct device *parent,
1438 int port, const char *name)
1440 struct dsa_switch_tree *dst = ds->dst;
1441 struct net_device *master;
1442 struct net_device *slave_dev;
1443 struct dsa_slave_priv *p;
1446 master = ds->dst->master_netdev;
1447 if (ds->master_netdev)
1448 master = ds->master_netdev;
1450 slave_dev = alloc_netdev(sizeof(struct dsa_slave_priv), name,
1451 NET_NAME_UNKNOWN, ether_setup);
1452 if (slave_dev == NULL)
1455 slave_dev->features = master->vlan_features | NETIF_F_HW_TC;
1456 slave_dev->hw_features |= NETIF_F_HW_TC;
1457 slave_dev->ethtool_ops = &dsa_slave_ethtool_ops;
1458 eth_hw_addr_inherit(slave_dev, master);
1459 slave_dev->priv_flags |= IFF_NO_QUEUE;
1460 slave_dev->netdev_ops = &dsa_slave_netdev_ops;
1461 slave_dev->switchdev_ops = &dsa_slave_switchdev_ops;
1462 slave_dev->min_mtu = 0;
1463 slave_dev->max_mtu = ETH_MAX_MTU;
1464 SET_NETDEV_DEVTYPE(slave_dev, &dsa_type);
1466 netdev_for_each_tx_queue(slave_dev, dsa_slave_set_lockdep_class_one,
1469 SET_NETDEV_DEV(slave_dev, parent);
1470 slave_dev->dev.of_node = ds->ports[port].dn;
1471 slave_dev->vlan_features = master->vlan_features;
1473 p = netdev_priv(slave_dev);
1474 p->dp = &ds->ports[port];
1475 INIT_LIST_HEAD(&p->mall_tc_list);
1476 p->xmit = dst->tag_ops->xmit;
1482 ds->ports[port].netdev = slave_dev;
1483 ret = register_netdev(slave_dev);
1485 netdev_err(master, "error %d registering interface %s\n",
1486 ret, slave_dev->name);
1487 ds->ports[port].netdev = NULL;
1488 free_netdev(slave_dev);
1492 netif_carrier_off(slave_dev);
1494 ret = dsa_slave_phy_setup(p, slave_dev);
1496 netdev_err(master, "error %d setting up slave phy\n", ret);
1497 unregister_netdev(slave_dev);
1498 free_netdev(slave_dev);
1505 void dsa_slave_destroy(struct net_device *slave_dev)
1507 struct dsa_slave_priv *p = netdev_priv(slave_dev);
1508 struct device_node *port_dn;
1510 port_dn = p->dp->dn;
1512 netif_carrier_off(slave_dev);
1514 phy_disconnect(p->phy);
1516 if (of_phy_is_fixed_link(port_dn))
1517 of_phy_deregister_fixed_link(port_dn);
1519 unregister_netdev(slave_dev);
1520 free_netdev(slave_dev);
1523 static bool dsa_slave_dev_check(struct net_device *dev)
1525 return dev->netdev_ops == &dsa_slave_netdev_ops;
1528 static int dsa_slave_changeupper(struct net_device *dev,
1529 struct netdev_notifier_changeupper_info *info)
1531 int err = NOTIFY_DONE;
1533 if (netif_is_bridge_master(info->upper_dev)) {
1534 if (info->linking) {
1535 err = dsa_slave_bridge_port_join(dev, info->upper_dev);
1536 err = notifier_from_errno(err);
1538 dsa_slave_bridge_port_leave(dev, info->upper_dev);
1546 static int dsa_slave_netdevice_event(struct notifier_block *nb,
1547 unsigned long event, void *ptr)
1549 struct net_device *dev = netdev_notifier_info_to_dev(ptr);
1551 if (dev->netdev_ops != &dsa_slave_netdev_ops)
1554 if (event == NETDEV_CHANGEUPPER)
1555 return dsa_slave_changeupper(dev, ptr);
1560 static struct notifier_block dsa_slave_nb __read_mostly = {
1561 .notifier_call = dsa_slave_netdevice_event,
1564 int dsa_slave_register_notifier(void)
1566 return register_netdevice_notifier(&dsa_slave_nb);
1569 void dsa_slave_unregister_notifier(void)
1573 err = unregister_netdevice_notifier(&dsa_slave_nb);
1575 pr_err("DSA: failed to unregister slave notifier (%d)\n", err);