xref: /openbmc/linux/net/dsa/slave.c (revision d198b34f3855eee2571dda03eea75a09c7c31480)
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 ***************************************************/
26 static 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 
36 static 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 
46 void 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 ****************************************************/
60 static int dsa_slave_get_iflink(const struct net_device *dev)
61 {
62 	return dsa_slave_to_master(dev)->ifindex;
63 }
64 
65 static 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 
97 clear_promisc:
98 	if (dev->flags & IFF_PROMISC)
99 		dev_set_promiscuity(master, -1);
100 clear_allmulti:
101 	if (dev->flags & IFF_ALLMULTI)
102 		dev_set_allmulti(master, -1);
103 del_unicast:
104 	if (!ether_addr_equal(dev->dev_addr, master->dev_addr))
105 		dev_uc_del(master, dev->dev_addr);
106 out:
107 	return err;
108 }
109 
110 static 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 
130 static 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 
143 static 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 
151 static 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 
172 out:
173 	ether_addr_copy(dev->dev_addr, addr->sa_data);
174 
175 	return 0;
176 }
177 
178 struct dsa_slave_dump_ctx {
179 	struct net_device *dev;
180 	struct sk_buff *skb;
181 	struct netlink_callback *cb;
182 	int idx;
183 };
184 
185 static int
186 dsa_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 
220 skip:
221 	dump->idx++;
222 	return 0;
223 
224 nla_put_failure:
225 	nlmsg_cancel(dump->skb, nlh);
226 	return -EMSGSIZE;
227 }
228 
229 static int
230 dsa_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 
249 static 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 
270 static 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 
306 static 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 
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)
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 
376 static 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 
393 static 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 
422 static 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 
442 static 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 
456 static 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 
482 netdev_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 }
498 EXPORT_SYMBOL_GPL(dsa_enqueue_skb);
499 
500 static 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 
533 static 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 
541 static 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 
552 static void
553 dsa_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 
562 static 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 
569 static 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 
583 static 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 
595 static 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 
607 static 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 
626 static 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 
657 static 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 
675 static 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 
686 static 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 
700 static 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 
720 static 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 
740 static 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 
748 static 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 
756 static 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 
764 static 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
773 static 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;
792 out:
793 	return err;
794 }
795 
796 static 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 
809 static void dsa_slave_poll_controller(struct net_device *dev)
810 {
811 }
812 #endif
813 
814 static 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 
832 static struct dsa_mall_tc_entry *
833 dsa_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 
845 static 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 
900 static 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 
927 static 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 
945 static 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 
961 static 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 
967 static 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 
973 static LIST_HEAD(dsa_slave_block_cb_list);
974 
975 static 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 
1015 static 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 
1030 static 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 
1058 static 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 
1070 static 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 
1082 static 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 
1094 static 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 
1128 static 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 
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,
1180 };
1181 
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,
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 
1194 int 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 
1203 static 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 
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,
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 
1236 static struct device_type dsa_type = {
1237 	.name	= "dsa",
1238 };
1239 
1240 void 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 }
1246 EXPORT_SYMBOL_GPL(dsa_port_phylink_mac_change);
1247 
1248 static 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 *******************************************************/
1261 static 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 
1275 static 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 
1327 int 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 
1343 int 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 
1359 static 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 
1373 int 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 
1441 out_phy:
1442 	rtnl_lock();
1443 	phylink_disconnect_phy(p->dp->pl);
1444 	rtnl_unlock();
1445 	phylink_destroy(p->dp->pl);
1446 out_free:
1447 	free_percpu(p->stats64);
1448 	free_netdev(slave_dev);
1449 	port->slave = NULL;
1450 	return ret;
1451 }
1452 
1453 void 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 
1470 bool dsa_slave_dev_check(const struct net_device *dev)
1471 {
1472 	return dev->netdev_ops == &dsa_slave_netdev_ops;
1473 }
1474 
1475 static 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 
1494 static 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 
1526 static 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 
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;
1546 };
1547 
1548 static 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 
1593 static int
1594 dsa_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() */
1610 static 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 
1651 err_fdb_work_init:
1652 	kfree(switchdev_work);
1653 	return NOTIFY_BAD;
1654 }
1655 
1656 static 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 
1683 static struct notifier_block dsa_slave_nb __read_mostly = {
1684 	.notifier_call  = dsa_slave_netdevice_event,
1685 };
1686 
1687 static struct notifier_block dsa_slave_switchdev_notifier = {
1688 	.notifier_call = dsa_slave_switchdev_event,
1689 };
1690 
1691 static struct notifier_block dsa_slave_switchdev_blocking_notifier = {
1692 	.notifier_call = dsa_slave_switchdev_blocking_event,
1693 };
1694 
1695 int 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 
1715 err_switchdev_blocking_nb:
1716 	unregister_switchdev_notifier(&dsa_slave_switchdev_notifier);
1717 err_switchdev_nb:
1718 	unregister_netdevice_notifier(&dsa_slave_nb);
1719 	return err;
1720 }
1721 
1722 void 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 }
1740