xref: /openbmc/linux/net/dsa/slave.c (revision fa5d824ce5dd8306c66f45c34fd78536e6ce2488)
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/selftests.h>
19 #include <net/tc_act/tc_mirred.h>
20 #include <linux/if_bridge.h>
21 #include <linux/if_hsr.h>
22 #include <linux/netpoll.h>
23 
24 #include "dsa_priv.h"
25 
26 /* slave mii_bus handling ***************************************************/
27 static int dsa_slave_phy_read(struct mii_bus *bus, int addr, int reg)
28 {
29 	struct dsa_switch *ds = bus->priv;
30 
31 	if (ds->phys_mii_mask & (1 << addr))
32 		return ds->ops->phy_read(ds, addr, reg);
33 
34 	return 0xffff;
35 }
36 
37 static int dsa_slave_phy_write(struct mii_bus *bus, int addr, int reg, u16 val)
38 {
39 	struct dsa_switch *ds = bus->priv;
40 
41 	if (ds->phys_mii_mask & (1 << addr))
42 		return ds->ops->phy_write(ds, addr, reg, val);
43 
44 	return 0;
45 }
46 
47 void dsa_slave_mii_bus_init(struct dsa_switch *ds)
48 {
49 	ds->slave_mii_bus->priv = (void *)ds;
50 	ds->slave_mii_bus->name = "dsa slave smi";
51 	ds->slave_mii_bus->read = dsa_slave_phy_read;
52 	ds->slave_mii_bus->write = dsa_slave_phy_write;
53 	snprintf(ds->slave_mii_bus->id, MII_BUS_ID_SIZE, "dsa-%d.%d",
54 		 ds->dst->index, ds->index);
55 	ds->slave_mii_bus->parent = ds->dev;
56 	ds->slave_mii_bus->phy_mask = ~ds->phys_mii_mask;
57 }
58 
59 
60 /* slave device handling ****************************************************/
61 static int dsa_slave_get_iflink(const struct net_device *dev)
62 {
63 	return dsa_slave_to_master(dev)->ifindex;
64 }
65 
66 static int dsa_slave_open(struct net_device *dev)
67 {
68 	struct net_device *master = dsa_slave_to_master(dev);
69 	struct dsa_port *dp = dsa_slave_to_port(dev);
70 	int err;
71 
72 	err = dev_open(master, NULL);
73 	if (err < 0) {
74 		netdev_err(dev, "failed to open master %s\n", master->name);
75 		goto out;
76 	}
77 
78 	if (!ether_addr_equal(dev->dev_addr, master->dev_addr)) {
79 		err = dev_uc_add(master, dev->dev_addr);
80 		if (err < 0)
81 			goto out;
82 	}
83 
84 	if (dev->flags & IFF_ALLMULTI) {
85 		err = dev_set_allmulti(master, 1);
86 		if (err < 0)
87 			goto del_unicast;
88 	}
89 	if (dev->flags & IFF_PROMISC) {
90 		err = dev_set_promiscuity(master, 1);
91 		if (err < 0)
92 			goto clear_allmulti;
93 	}
94 
95 	err = dsa_port_enable_rt(dp, dev->phydev);
96 	if (err)
97 		goto clear_promisc;
98 
99 	return 0;
100 
101 clear_promisc:
102 	if (dev->flags & IFF_PROMISC)
103 		dev_set_promiscuity(master, -1);
104 clear_allmulti:
105 	if (dev->flags & IFF_ALLMULTI)
106 		dev_set_allmulti(master, -1);
107 del_unicast:
108 	if (!ether_addr_equal(dev->dev_addr, master->dev_addr))
109 		dev_uc_del(master, dev->dev_addr);
110 out:
111 	return err;
112 }
113 
114 static int dsa_slave_close(struct net_device *dev)
115 {
116 	struct net_device *master = dsa_slave_to_master(dev);
117 	struct dsa_port *dp = dsa_slave_to_port(dev);
118 
119 	dsa_port_disable_rt(dp);
120 
121 	dev_mc_unsync(master, dev);
122 	dev_uc_unsync(master, dev);
123 	if (dev->flags & IFF_ALLMULTI)
124 		dev_set_allmulti(master, -1);
125 	if (dev->flags & IFF_PROMISC)
126 		dev_set_promiscuity(master, -1);
127 
128 	if (!ether_addr_equal(dev->dev_addr, master->dev_addr))
129 		dev_uc_del(master, dev->dev_addr);
130 
131 	return 0;
132 }
133 
134 static void dsa_slave_change_rx_flags(struct net_device *dev, int change)
135 {
136 	struct net_device *master = dsa_slave_to_master(dev);
137 	if (dev->flags & IFF_UP) {
138 		if (change & IFF_ALLMULTI)
139 			dev_set_allmulti(master,
140 					 dev->flags & IFF_ALLMULTI ? 1 : -1);
141 		if (change & IFF_PROMISC)
142 			dev_set_promiscuity(master,
143 					    dev->flags & IFF_PROMISC ? 1 : -1);
144 	}
145 }
146 
147 static void dsa_slave_set_rx_mode(struct net_device *dev)
148 {
149 	struct net_device *master = dsa_slave_to_master(dev);
150 
151 	dev_mc_sync(master, dev);
152 	dev_uc_sync(master, dev);
153 }
154 
155 static int dsa_slave_set_mac_address(struct net_device *dev, void *a)
156 {
157 	struct net_device *master = dsa_slave_to_master(dev);
158 	struct sockaddr *addr = a;
159 	int err;
160 
161 	if (!is_valid_ether_addr(addr->sa_data))
162 		return -EADDRNOTAVAIL;
163 
164 	if (!(dev->flags & IFF_UP))
165 		goto out;
166 
167 	if (!ether_addr_equal(addr->sa_data, master->dev_addr)) {
168 		err = dev_uc_add(master, addr->sa_data);
169 		if (err < 0)
170 			return err;
171 	}
172 
173 	if (!ether_addr_equal(dev->dev_addr, master->dev_addr))
174 		dev_uc_del(master, dev->dev_addr);
175 
176 out:
177 	eth_hw_addr_set(dev, addr->sa_data);
178 
179 	return 0;
180 }
181 
182 struct dsa_slave_dump_ctx {
183 	struct net_device *dev;
184 	struct sk_buff *skb;
185 	struct netlink_callback *cb;
186 	int idx;
187 };
188 
189 static int
190 dsa_slave_port_fdb_do_dump(const unsigned char *addr, u16 vid,
191 			   bool is_static, void *data)
192 {
193 	struct dsa_slave_dump_ctx *dump = data;
194 	u32 portid = NETLINK_CB(dump->cb->skb).portid;
195 	u32 seq = dump->cb->nlh->nlmsg_seq;
196 	struct nlmsghdr *nlh;
197 	struct ndmsg *ndm;
198 
199 	if (dump->idx < dump->cb->args[2])
200 		goto skip;
201 
202 	nlh = nlmsg_put(dump->skb, portid, seq, RTM_NEWNEIGH,
203 			sizeof(*ndm), NLM_F_MULTI);
204 	if (!nlh)
205 		return -EMSGSIZE;
206 
207 	ndm = nlmsg_data(nlh);
208 	ndm->ndm_family  = AF_BRIDGE;
209 	ndm->ndm_pad1    = 0;
210 	ndm->ndm_pad2    = 0;
211 	ndm->ndm_flags   = NTF_SELF;
212 	ndm->ndm_type    = 0;
213 	ndm->ndm_ifindex = dump->dev->ifindex;
214 	ndm->ndm_state   = is_static ? NUD_NOARP : NUD_REACHABLE;
215 
216 	if (nla_put(dump->skb, NDA_LLADDR, ETH_ALEN, addr))
217 		goto nla_put_failure;
218 
219 	if (vid && nla_put_u16(dump->skb, NDA_VLAN, vid))
220 		goto nla_put_failure;
221 
222 	nlmsg_end(dump->skb, nlh);
223 
224 skip:
225 	dump->idx++;
226 	return 0;
227 
228 nla_put_failure:
229 	nlmsg_cancel(dump->skb, nlh);
230 	return -EMSGSIZE;
231 }
232 
233 static int
234 dsa_slave_fdb_dump(struct sk_buff *skb, struct netlink_callback *cb,
235 		   struct net_device *dev, struct net_device *filter_dev,
236 		   int *idx)
237 {
238 	struct dsa_port *dp = dsa_slave_to_port(dev);
239 	struct dsa_slave_dump_ctx dump = {
240 		.dev = dev,
241 		.skb = skb,
242 		.cb = cb,
243 		.idx = *idx,
244 	};
245 	int err;
246 
247 	err = dsa_port_fdb_dump(dp, dsa_slave_port_fdb_do_dump, &dump);
248 	*idx = dump.idx;
249 
250 	return err;
251 }
252 
253 static int dsa_slave_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
254 {
255 	struct dsa_slave_priv *p = netdev_priv(dev);
256 	struct dsa_switch *ds = p->dp->ds;
257 	int port = p->dp->index;
258 
259 	/* Pass through to switch driver if it supports timestamping */
260 	switch (cmd) {
261 	case SIOCGHWTSTAMP:
262 		if (ds->ops->port_hwtstamp_get)
263 			return ds->ops->port_hwtstamp_get(ds, port, ifr);
264 		break;
265 	case SIOCSHWTSTAMP:
266 		if (ds->ops->port_hwtstamp_set)
267 			return ds->ops->port_hwtstamp_set(ds, port, ifr);
268 		break;
269 	}
270 
271 	return phylink_mii_ioctl(p->dp->pl, ifr, cmd);
272 }
273 
274 static int dsa_slave_port_attr_set(struct net_device *dev, const void *ctx,
275 				   const struct switchdev_attr *attr,
276 				   struct netlink_ext_ack *extack)
277 {
278 	struct dsa_port *dp = dsa_slave_to_port(dev);
279 	int ret;
280 
281 	if (ctx && ctx != dp)
282 		return 0;
283 
284 	switch (attr->id) {
285 	case SWITCHDEV_ATTR_ID_PORT_STP_STATE:
286 		if (!dsa_port_offloads_bridge_port(dp, attr->orig_dev))
287 			return -EOPNOTSUPP;
288 
289 		ret = dsa_port_set_state(dp, attr->u.stp_state, true);
290 		break;
291 	case SWITCHDEV_ATTR_ID_BRIDGE_VLAN_FILTERING:
292 		if (!dsa_port_offloads_bridge_dev(dp, attr->orig_dev))
293 			return -EOPNOTSUPP;
294 
295 		ret = dsa_port_vlan_filtering(dp, attr->u.vlan_filtering,
296 					      extack);
297 		break;
298 	case SWITCHDEV_ATTR_ID_BRIDGE_AGEING_TIME:
299 		if (!dsa_port_offloads_bridge_dev(dp, attr->orig_dev))
300 			return -EOPNOTSUPP;
301 
302 		ret = dsa_port_ageing_time(dp, attr->u.ageing_time);
303 		break;
304 	case SWITCHDEV_ATTR_ID_PORT_PRE_BRIDGE_FLAGS:
305 		if (!dsa_port_offloads_bridge_port(dp, attr->orig_dev))
306 			return -EOPNOTSUPP;
307 
308 		ret = dsa_port_pre_bridge_flags(dp, attr->u.brport_flags,
309 						extack);
310 		break;
311 	case SWITCHDEV_ATTR_ID_PORT_BRIDGE_FLAGS:
312 		if (!dsa_port_offloads_bridge_port(dp, attr->orig_dev))
313 			return -EOPNOTSUPP;
314 
315 		ret = dsa_port_bridge_flags(dp, attr->u.brport_flags, extack);
316 		break;
317 	default:
318 		ret = -EOPNOTSUPP;
319 		break;
320 	}
321 
322 	return ret;
323 }
324 
325 /* Must be called under rcu_read_lock() */
326 static int
327 dsa_slave_vlan_check_for_8021q_uppers(struct net_device *slave,
328 				      const struct switchdev_obj_port_vlan *vlan)
329 {
330 	struct net_device *upper_dev;
331 	struct list_head *iter;
332 
333 	netdev_for_each_upper_dev_rcu(slave, upper_dev, iter) {
334 		u16 vid;
335 
336 		if (!is_vlan_dev(upper_dev))
337 			continue;
338 
339 		vid = vlan_dev_vlan_id(upper_dev);
340 		if (vid == vlan->vid)
341 			return -EBUSY;
342 	}
343 
344 	return 0;
345 }
346 
347 static int dsa_slave_vlan_add(struct net_device *dev,
348 			      const struct switchdev_obj *obj,
349 			      struct netlink_ext_ack *extack)
350 {
351 	struct net_device *master = dsa_slave_to_master(dev);
352 	struct dsa_port *dp = dsa_slave_to_port(dev);
353 	struct switchdev_obj_port_vlan vlan;
354 	int err;
355 
356 	if (dsa_port_skip_vlan_configuration(dp)) {
357 		NL_SET_ERR_MSG_MOD(extack, "skipping configuration of VLAN");
358 		return 0;
359 	}
360 
361 	vlan = *SWITCHDEV_OBJ_PORT_VLAN(obj);
362 
363 	/* Deny adding a bridge VLAN when there is already an 802.1Q upper with
364 	 * the same VID.
365 	 */
366 	if (br_vlan_enabled(dsa_port_bridge_dev_get(dp))) {
367 		rcu_read_lock();
368 		err = dsa_slave_vlan_check_for_8021q_uppers(dev, &vlan);
369 		rcu_read_unlock();
370 		if (err) {
371 			NL_SET_ERR_MSG_MOD(extack,
372 					   "Port already has a VLAN upper with this VID");
373 			return err;
374 		}
375 	}
376 
377 	err = dsa_port_vlan_add(dp, &vlan, extack);
378 	if (err)
379 		return err;
380 
381 	/* We need the dedicated CPU port to be a member of the VLAN as well.
382 	 * Even though drivers often handle CPU membership in special ways,
383 	 * it doesn't make sense to program a PVID, so clear this flag.
384 	 */
385 	vlan.flags &= ~BRIDGE_VLAN_INFO_PVID;
386 
387 	err = dsa_port_vlan_add(dp->cpu_dp, &vlan, extack);
388 	if (err)
389 		return err;
390 
391 	return vlan_vid_add(master, htons(ETH_P_8021Q), vlan.vid);
392 }
393 
394 static int dsa_slave_port_obj_add(struct net_device *dev, const void *ctx,
395 				  const struct switchdev_obj *obj,
396 				  struct netlink_ext_ack *extack)
397 {
398 	struct dsa_port *dp = dsa_slave_to_port(dev);
399 	int err;
400 
401 	if (ctx && ctx != dp)
402 		return 0;
403 
404 	switch (obj->id) {
405 	case SWITCHDEV_OBJ_ID_PORT_MDB:
406 		if (!dsa_port_offloads_bridge_port(dp, obj->orig_dev))
407 			return -EOPNOTSUPP;
408 
409 		err = dsa_port_mdb_add(dp, SWITCHDEV_OBJ_PORT_MDB(obj));
410 		break;
411 	case SWITCHDEV_OBJ_ID_HOST_MDB:
412 		if (!dsa_port_offloads_bridge_dev(dp, obj->orig_dev))
413 			return -EOPNOTSUPP;
414 
415 		err = dsa_port_host_mdb_add(dp, SWITCHDEV_OBJ_PORT_MDB(obj));
416 		break;
417 	case SWITCHDEV_OBJ_ID_PORT_VLAN:
418 		if (!dsa_port_offloads_bridge_port(dp, obj->orig_dev))
419 			return -EOPNOTSUPP;
420 
421 		err = dsa_slave_vlan_add(dev, obj, extack);
422 		break;
423 	case SWITCHDEV_OBJ_ID_MRP:
424 		if (!dsa_port_offloads_bridge_dev(dp, obj->orig_dev))
425 			return -EOPNOTSUPP;
426 
427 		err = dsa_port_mrp_add(dp, SWITCHDEV_OBJ_MRP(obj));
428 		break;
429 	case SWITCHDEV_OBJ_ID_RING_ROLE_MRP:
430 		if (!dsa_port_offloads_bridge_dev(dp, obj->orig_dev))
431 			return -EOPNOTSUPP;
432 
433 		err = dsa_port_mrp_add_ring_role(dp,
434 						 SWITCHDEV_OBJ_RING_ROLE_MRP(obj));
435 		break;
436 	default:
437 		err = -EOPNOTSUPP;
438 		break;
439 	}
440 
441 	return err;
442 }
443 
444 static int dsa_slave_vlan_del(struct net_device *dev,
445 			      const struct switchdev_obj *obj)
446 {
447 	struct net_device *master = dsa_slave_to_master(dev);
448 	struct dsa_port *dp = dsa_slave_to_port(dev);
449 	struct switchdev_obj_port_vlan *vlan;
450 	int err;
451 
452 	if (dsa_port_skip_vlan_configuration(dp))
453 		return 0;
454 
455 	vlan = SWITCHDEV_OBJ_PORT_VLAN(obj);
456 
457 	/* Do not deprogram the CPU port as it may be shared with other user
458 	 * ports which can be members of this VLAN as well.
459 	 */
460 	err = dsa_port_vlan_del(dp, vlan);
461 	if (err)
462 		return err;
463 
464 	vlan_vid_del(master, htons(ETH_P_8021Q), vlan->vid);
465 
466 	return 0;
467 }
468 
469 static int dsa_slave_port_obj_del(struct net_device *dev, const void *ctx,
470 				  const struct switchdev_obj *obj)
471 {
472 	struct dsa_port *dp = dsa_slave_to_port(dev);
473 	int err;
474 
475 	if (ctx && ctx != dp)
476 		return 0;
477 
478 	switch (obj->id) {
479 	case SWITCHDEV_OBJ_ID_PORT_MDB:
480 		if (!dsa_port_offloads_bridge_port(dp, obj->orig_dev))
481 			return -EOPNOTSUPP;
482 
483 		err = dsa_port_mdb_del(dp, SWITCHDEV_OBJ_PORT_MDB(obj));
484 		break;
485 	case SWITCHDEV_OBJ_ID_HOST_MDB:
486 		if (!dsa_port_offloads_bridge_dev(dp, obj->orig_dev))
487 			return -EOPNOTSUPP;
488 
489 		err = dsa_port_host_mdb_del(dp, SWITCHDEV_OBJ_PORT_MDB(obj));
490 		break;
491 	case SWITCHDEV_OBJ_ID_PORT_VLAN:
492 		if (!dsa_port_offloads_bridge_port(dp, obj->orig_dev))
493 			return -EOPNOTSUPP;
494 
495 		err = dsa_slave_vlan_del(dev, obj);
496 		break;
497 	case SWITCHDEV_OBJ_ID_MRP:
498 		if (!dsa_port_offloads_bridge_dev(dp, obj->orig_dev))
499 			return -EOPNOTSUPP;
500 
501 		err = dsa_port_mrp_del(dp, SWITCHDEV_OBJ_MRP(obj));
502 		break;
503 	case SWITCHDEV_OBJ_ID_RING_ROLE_MRP:
504 		if (!dsa_port_offloads_bridge_dev(dp, obj->orig_dev))
505 			return -EOPNOTSUPP;
506 
507 		err = dsa_port_mrp_del_ring_role(dp,
508 						 SWITCHDEV_OBJ_RING_ROLE_MRP(obj));
509 		break;
510 	default:
511 		err = -EOPNOTSUPP;
512 		break;
513 	}
514 
515 	return err;
516 }
517 
518 static inline netdev_tx_t dsa_slave_netpoll_send_skb(struct net_device *dev,
519 						     struct sk_buff *skb)
520 {
521 #ifdef CONFIG_NET_POLL_CONTROLLER
522 	struct dsa_slave_priv *p = netdev_priv(dev);
523 
524 	return netpoll_send_skb(p->netpoll, skb);
525 #else
526 	BUG();
527 	return NETDEV_TX_OK;
528 #endif
529 }
530 
531 static void dsa_skb_tx_timestamp(struct dsa_slave_priv *p,
532 				 struct sk_buff *skb)
533 {
534 	struct dsa_switch *ds = p->dp->ds;
535 
536 	if (!(skb_shinfo(skb)->tx_flags & SKBTX_HW_TSTAMP))
537 		return;
538 
539 	if (!ds->ops->port_txtstamp)
540 		return;
541 
542 	ds->ops->port_txtstamp(ds, p->dp->index, skb);
543 }
544 
545 netdev_tx_t dsa_enqueue_skb(struct sk_buff *skb, struct net_device *dev)
546 {
547 	/* SKB for netpoll still need to be mangled with the protocol-specific
548 	 * tag to be successfully transmitted
549 	 */
550 	if (unlikely(netpoll_tx_running(dev)))
551 		return dsa_slave_netpoll_send_skb(dev, skb);
552 
553 	/* Queue the SKB for transmission on the parent interface, but
554 	 * do not modify its EtherType
555 	 */
556 	skb->dev = dsa_slave_to_master(dev);
557 	dev_queue_xmit(skb);
558 
559 	return NETDEV_TX_OK;
560 }
561 EXPORT_SYMBOL_GPL(dsa_enqueue_skb);
562 
563 static int dsa_realloc_skb(struct sk_buff *skb, struct net_device *dev)
564 {
565 	int needed_headroom = dev->needed_headroom;
566 	int needed_tailroom = dev->needed_tailroom;
567 
568 	/* For tail taggers, we need to pad short frames ourselves, to ensure
569 	 * that the tail tag does not fail at its role of being at the end of
570 	 * the packet, once the master interface pads the frame. Account for
571 	 * that pad length here, and pad later.
572 	 */
573 	if (unlikely(needed_tailroom && skb->len < ETH_ZLEN))
574 		needed_tailroom += ETH_ZLEN - skb->len;
575 	/* skb_headroom() returns unsigned int... */
576 	needed_headroom = max_t(int, needed_headroom - skb_headroom(skb), 0);
577 	needed_tailroom = max_t(int, needed_tailroom - skb_tailroom(skb), 0);
578 
579 	if (likely(!needed_headroom && !needed_tailroom && !skb_cloned(skb)))
580 		/* No reallocation needed, yay! */
581 		return 0;
582 
583 	return pskb_expand_head(skb, needed_headroom, needed_tailroom,
584 				GFP_ATOMIC);
585 }
586 
587 static netdev_tx_t dsa_slave_xmit(struct sk_buff *skb, struct net_device *dev)
588 {
589 	struct dsa_slave_priv *p = netdev_priv(dev);
590 	struct sk_buff *nskb;
591 
592 	dev_sw_netstats_tx_add(dev, 1, skb->len);
593 
594 	memset(skb->cb, 0, sizeof(skb->cb));
595 
596 	/* Handle tx timestamp if any */
597 	dsa_skb_tx_timestamp(p, skb);
598 
599 	if (dsa_realloc_skb(skb, dev)) {
600 		dev_kfree_skb_any(skb);
601 		return NETDEV_TX_OK;
602 	}
603 
604 	/* needed_tailroom should still be 'warm' in the cache line from
605 	 * dsa_realloc_skb(), which has also ensured that padding is safe.
606 	 */
607 	if (dev->needed_tailroom)
608 		eth_skb_pad(skb);
609 
610 	/* Transmit function may have to reallocate the original SKB,
611 	 * in which case it must have freed it. Only free it here on error.
612 	 */
613 	nskb = p->xmit(skb, dev);
614 	if (!nskb) {
615 		kfree_skb(skb);
616 		return NETDEV_TX_OK;
617 	}
618 
619 	return dsa_enqueue_skb(nskb, dev);
620 }
621 
622 /* ethtool operations *******************************************************/
623 
624 static void dsa_slave_get_drvinfo(struct net_device *dev,
625 				  struct ethtool_drvinfo *drvinfo)
626 {
627 	strlcpy(drvinfo->driver, "dsa", sizeof(drvinfo->driver));
628 	strlcpy(drvinfo->fw_version, "N/A", sizeof(drvinfo->fw_version));
629 	strlcpy(drvinfo->bus_info, "platform", sizeof(drvinfo->bus_info));
630 }
631 
632 static int dsa_slave_get_regs_len(struct net_device *dev)
633 {
634 	struct dsa_port *dp = dsa_slave_to_port(dev);
635 	struct dsa_switch *ds = dp->ds;
636 
637 	if (ds->ops->get_regs_len)
638 		return ds->ops->get_regs_len(ds, dp->index);
639 
640 	return -EOPNOTSUPP;
641 }
642 
643 static void
644 dsa_slave_get_regs(struct net_device *dev, struct ethtool_regs *regs, void *_p)
645 {
646 	struct dsa_port *dp = dsa_slave_to_port(dev);
647 	struct dsa_switch *ds = dp->ds;
648 
649 	if (ds->ops->get_regs)
650 		ds->ops->get_regs(ds, dp->index, regs, _p);
651 }
652 
653 static int dsa_slave_nway_reset(struct net_device *dev)
654 {
655 	struct dsa_port *dp = dsa_slave_to_port(dev);
656 
657 	return phylink_ethtool_nway_reset(dp->pl);
658 }
659 
660 static int dsa_slave_get_eeprom_len(struct net_device *dev)
661 {
662 	struct dsa_port *dp = dsa_slave_to_port(dev);
663 	struct dsa_switch *ds = dp->ds;
664 
665 	if (ds->cd && ds->cd->eeprom_len)
666 		return ds->cd->eeprom_len;
667 
668 	if (ds->ops->get_eeprom_len)
669 		return ds->ops->get_eeprom_len(ds);
670 
671 	return 0;
672 }
673 
674 static int dsa_slave_get_eeprom(struct net_device *dev,
675 				struct ethtool_eeprom *eeprom, u8 *data)
676 {
677 	struct dsa_port *dp = dsa_slave_to_port(dev);
678 	struct dsa_switch *ds = dp->ds;
679 
680 	if (ds->ops->get_eeprom)
681 		return ds->ops->get_eeprom(ds, eeprom, data);
682 
683 	return -EOPNOTSUPP;
684 }
685 
686 static int dsa_slave_set_eeprom(struct net_device *dev,
687 				struct ethtool_eeprom *eeprom, u8 *data)
688 {
689 	struct dsa_port *dp = dsa_slave_to_port(dev);
690 	struct dsa_switch *ds = dp->ds;
691 
692 	if (ds->ops->set_eeprom)
693 		return ds->ops->set_eeprom(ds, eeprom, data);
694 
695 	return -EOPNOTSUPP;
696 }
697 
698 static void dsa_slave_get_strings(struct net_device *dev,
699 				  uint32_t stringset, uint8_t *data)
700 {
701 	struct dsa_port *dp = dsa_slave_to_port(dev);
702 	struct dsa_switch *ds = dp->ds;
703 
704 	if (stringset == ETH_SS_STATS) {
705 		int len = ETH_GSTRING_LEN;
706 
707 		strncpy(data, "tx_packets", len);
708 		strncpy(data + len, "tx_bytes", len);
709 		strncpy(data + 2 * len, "rx_packets", len);
710 		strncpy(data + 3 * len, "rx_bytes", len);
711 		if (ds->ops->get_strings)
712 			ds->ops->get_strings(ds, dp->index, stringset,
713 					     data + 4 * len);
714 	} else if (stringset ==  ETH_SS_TEST) {
715 		net_selftest_get_strings(data);
716 	}
717 
718 }
719 
720 static void dsa_slave_get_ethtool_stats(struct net_device *dev,
721 					struct ethtool_stats *stats,
722 					uint64_t *data)
723 {
724 	struct dsa_port *dp = dsa_slave_to_port(dev);
725 	struct dsa_switch *ds = dp->ds;
726 	struct pcpu_sw_netstats *s;
727 	unsigned int start;
728 	int i;
729 
730 	for_each_possible_cpu(i) {
731 		u64 tx_packets, tx_bytes, rx_packets, rx_bytes;
732 
733 		s = per_cpu_ptr(dev->tstats, i);
734 		do {
735 			start = u64_stats_fetch_begin_irq(&s->syncp);
736 			tx_packets = s->tx_packets;
737 			tx_bytes = s->tx_bytes;
738 			rx_packets = s->rx_packets;
739 			rx_bytes = s->rx_bytes;
740 		} while (u64_stats_fetch_retry_irq(&s->syncp, start));
741 		data[0] += tx_packets;
742 		data[1] += tx_bytes;
743 		data[2] += rx_packets;
744 		data[3] += rx_bytes;
745 	}
746 	if (ds->ops->get_ethtool_stats)
747 		ds->ops->get_ethtool_stats(ds, dp->index, data + 4);
748 }
749 
750 static int dsa_slave_get_sset_count(struct net_device *dev, int sset)
751 {
752 	struct dsa_port *dp = dsa_slave_to_port(dev);
753 	struct dsa_switch *ds = dp->ds;
754 
755 	if (sset == ETH_SS_STATS) {
756 		int count = 0;
757 
758 		if (ds->ops->get_sset_count) {
759 			count = ds->ops->get_sset_count(ds, dp->index, sset);
760 			if (count < 0)
761 				return count;
762 		}
763 
764 		return count + 4;
765 	} else if (sset ==  ETH_SS_TEST) {
766 		return net_selftest_get_count();
767 	}
768 
769 	return -EOPNOTSUPP;
770 }
771 
772 static void dsa_slave_get_eth_phy_stats(struct net_device *dev,
773 					struct ethtool_eth_phy_stats *phy_stats)
774 {
775 	struct dsa_port *dp = dsa_slave_to_port(dev);
776 	struct dsa_switch *ds = dp->ds;
777 
778 	if (ds->ops->get_eth_phy_stats)
779 		ds->ops->get_eth_phy_stats(ds, dp->index, phy_stats);
780 }
781 
782 static void dsa_slave_get_eth_mac_stats(struct net_device *dev,
783 					struct ethtool_eth_mac_stats *mac_stats)
784 {
785 	struct dsa_port *dp = dsa_slave_to_port(dev);
786 	struct dsa_switch *ds = dp->ds;
787 
788 	if (ds->ops->get_eth_mac_stats)
789 		ds->ops->get_eth_mac_stats(ds, dp->index, mac_stats);
790 }
791 
792 static void
793 dsa_slave_get_eth_ctrl_stats(struct net_device *dev,
794 			     struct ethtool_eth_ctrl_stats *ctrl_stats)
795 {
796 	struct dsa_port *dp = dsa_slave_to_port(dev);
797 	struct dsa_switch *ds = dp->ds;
798 
799 	if (ds->ops->get_eth_ctrl_stats)
800 		ds->ops->get_eth_ctrl_stats(ds, dp->index, ctrl_stats);
801 }
802 
803 static void dsa_slave_net_selftest(struct net_device *ndev,
804 				   struct ethtool_test *etest, u64 *buf)
805 {
806 	struct dsa_port *dp = dsa_slave_to_port(ndev);
807 	struct dsa_switch *ds = dp->ds;
808 
809 	if (ds->ops->self_test) {
810 		ds->ops->self_test(ds, dp->index, etest, buf);
811 		return;
812 	}
813 
814 	net_selftest(ndev, etest, buf);
815 }
816 
817 static void dsa_slave_get_wol(struct net_device *dev, struct ethtool_wolinfo *w)
818 {
819 	struct dsa_port *dp = dsa_slave_to_port(dev);
820 	struct dsa_switch *ds = dp->ds;
821 
822 	phylink_ethtool_get_wol(dp->pl, w);
823 
824 	if (ds->ops->get_wol)
825 		ds->ops->get_wol(ds, dp->index, w);
826 }
827 
828 static int dsa_slave_set_wol(struct net_device *dev, struct ethtool_wolinfo *w)
829 {
830 	struct dsa_port *dp = dsa_slave_to_port(dev);
831 	struct dsa_switch *ds = dp->ds;
832 	int ret = -EOPNOTSUPP;
833 
834 	phylink_ethtool_set_wol(dp->pl, w);
835 
836 	if (ds->ops->set_wol)
837 		ret = ds->ops->set_wol(ds, dp->index, w);
838 
839 	return ret;
840 }
841 
842 static int dsa_slave_set_eee(struct net_device *dev, struct ethtool_eee *e)
843 {
844 	struct dsa_port *dp = dsa_slave_to_port(dev);
845 	struct dsa_switch *ds = dp->ds;
846 	int ret;
847 
848 	/* Port's PHY and MAC both need to be EEE capable */
849 	if (!dev->phydev || !dp->pl)
850 		return -ENODEV;
851 
852 	if (!ds->ops->set_mac_eee)
853 		return -EOPNOTSUPP;
854 
855 	ret = ds->ops->set_mac_eee(ds, dp->index, e);
856 	if (ret)
857 		return ret;
858 
859 	return phylink_ethtool_set_eee(dp->pl, e);
860 }
861 
862 static int dsa_slave_get_eee(struct net_device *dev, struct ethtool_eee *e)
863 {
864 	struct dsa_port *dp = dsa_slave_to_port(dev);
865 	struct dsa_switch *ds = dp->ds;
866 	int ret;
867 
868 	/* Port's PHY and MAC both need to be EEE capable */
869 	if (!dev->phydev || !dp->pl)
870 		return -ENODEV;
871 
872 	if (!ds->ops->get_mac_eee)
873 		return -EOPNOTSUPP;
874 
875 	ret = ds->ops->get_mac_eee(ds, dp->index, e);
876 	if (ret)
877 		return ret;
878 
879 	return phylink_ethtool_get_eee(dp->pl, e);
880 }
881 
882 static int dsa_slave_get_link_ksettings(struct net_device *dev,
883 					struct ethtool_link_ksettings *cmd)
884 {
885 	struct dsa_port *dp = dsa_slave_to_port(dev);
886 
887 	return phylink_ethtool_ksettings_get(dp->pl, cmd);
888 }
889 
890 static int dsa_slave_set_link_ksettings(struct net_device *dev,
891 					const struct ethtool_link_ksettings *cmd)
892 {
893 	struct dsa_port *dp = dsa_slave_to_port(dev);
894 
895 	return phylink_ethtool_ksettings_set(dp->pl, cmd);
896 }
897 
898 static void dsa_slave_get_pauseparam(struct net_device *dev,
899 				     struct ethtool_pauseparam *pause)
900 {
901 	struct dsa_port *dp = dsa_slave_to_port(dev);
902 
903 	phylink_ethtool_get_pauseparam(dp->pl, pause);
904 }
905 
906 static int dsa_slave_set_pauseparam(struct net_device *dev,
907 				    struct ethtool_pauseparam *pause)
908 {
909 	struct dsa_port *dp = dsa_slave_to_port(dev);
910 
911 	return phylink_ethtool_set_pauseparam(dp->pl, pause);
912 }
913 
914 #ifdef CONFIG_NET_POLL_CONTROLLER
915 static int dsa_slave_netpoll_setup(struct net_device *dev,
916 				   struct netpoll_info *ni)
917 {
918 	struct net_device *master = dsa_slave_to_master(dev);
919 	struct dsa_slave_priv *p = netdev_priv(dev);
920 	struct netpoll *netpoll;
921 	int err = 0;
922 
923 	netpoll = kzalloc(sizeof(*netpoll), GFP_KERNEL);
924 	if (!netpoll)
925 		return -ENOMEM;
926 
927 	err = __netpoll_setup(netpoll, master);
928 	if (err) {
929 		kfree(netpoll);
930 		goto out;
931 	}
932 
933 	p->netpoll = netpoll;
934 out:
935 	return err;
936 }
937 
938 static void dsa_slave_netpoll_cleanup(struct net_device *dev)
939 {
940 	struct dsa_slave_priv *p = netdev_priv(dev);
941 	struct netpoll *netpoll = p->netpoll;
942 
943 	if (!netpoll)
944 		return;
945 
946 	p->netpoll = NULL;
947 
948 	__netpoll_free(netpoll);
949 }
950 
951 static void dsa_slave_poll_controller(struct net_device *dev)
952 {
953 }
954 #endif
955 
956 static struct dsa_mall_tc_entry *
957 dsa_slave_mall_tc_entry_find(struct net_device *dev, unsigned long cookie)
958 {
959 	struct dsa_slave_priv *p = netdev_priv(dev);
960 	struct dsa_mall_tc_entry *mall_tc_entry;
961 
962 	list_for_each_entry(mall_tc_entry, &p->mall_tc_list, list)
963 		if (mall_tc_entry->cookie == cookie)
964 			return mall_tc_entry;
965 
966 	return NULL;
967 }
968 
969 static int
970 dsa_slave_add_cls_matchall_mirred(struct net_device *dev,
971 				  struct tc_cls_matchall_offload *cls,
972 				  bool ingress)
973 {
974 	struct dsa_port *dp = dsa_slave_to_port(dev);
975 	struct dsa_slave_priv *p = netdev_priv(dev);
976 	struct dsa_mall_mirror_tc_entry *mirror;
977 	struct dsa_mall_tc_entry *mall_tc_entry;
978 	struct dsa_switch *ds = dp->ds;
979 	struct flow_action_entry *act;
980 	struct dsa_port *to_dp;
981 	int err;
982 
983 	if (!ds->ops->port_mirror_add)
984 		return -EOPNOTSUPP;
985 
986 	if (!flow_action_basic_hw_stats_check(&cls->rule->action,
987 					      cls->common.extack))
988 		return -EOPNOTSUPP;
989 
990 	act = &cls->rule->action.entries[0];
991 
992 	if (!act->dev)
993 		return -EINVAL;
994 
995 	if (!dsa_slave_dev_check(act->dev))
996 		return -EOPNOTSUPP;
997 
998 	mall_tc_entry = kzalloc(sizeof(*mall_tc_entry), GFP_KERNEL);
999 	if (!mall_tc_entry)
1000 		return -ENOMEM;
1001 
1002 	mall_tc_entry->cookie = cls->cookie;
1003 	mall_tc_entry->type = DSA_PORT_MALL_MIRROR;
1004 	mirror = &mall_tc_entry->mirror;
1005 
1006 	to_dp = dsa_slave_to_port(act->dev);
1007 
1008 	mirror->to_local_port = to_dp->index;
1009 	mirror->ingress = ingress;
1010 
1011 	err = ds->ops->port_mirror_add(ds, dp->index, mirror, ingress);
1012 	if (err) {
1013 		kfree(mall_tc_entry);
1014 		return err;
1015 	}
1016 
1017 	list_add_tail(&mall_tc_entry->list, &p->mall_tc_list);
1018 
1019 	return err;
1020 }
1021 
1022 static int
1023 dsa_slave_add_cls_matchall_police(struct net_device *dev,
1024 				  struct tc_cls_matchall_offload *cls,
1025 				  bool ingress)
1026 {
1027 	struct netlink_ext_ack *extack = cls->common.extack;
1028 	struct dsa_port *dp = dsa_slave_to_port(dev);
1029 	struct dsa_slave_priv *p = netdev_priv(dev);
1030 	struct dsa_mall_policer_tc_entry *policer;
1031 	struct dsa_mall_tc_entry *mall_tc_entry;
1032 	struct dsa_switch *ds = dp->ds;
1033 	struct flow_action_entry *act;
1034 	int err;
1035 
1036 	if (!ds->ops->port_policer_add) {
1037 		NL_SET_ERR_MSG_MOD(extack,
1038 				   "Policing offload not implemented");
1039 		return -EOPNOTSUPP;
1040 	}
1041 
1042 	if (!ingress) {
1043 		NL_SET_ERR_MSG_MOD(extack,
1044 				   "Only supported on ingress qdisc");
1045 		return -EOPNOTSUPP;
1046 	}
1047 
1048 	if (!flow_action_basic_hw_stats_check(&cls->rule->action,
1049 					      cls->common.extack))
1050 		return -EOPNOTSUPP;
1051 
1052 	list_for_each_entry(mall_tc_entry, &p->mall_tc_list, list) {
1053 		if (mall_tc_entry->type == DSA_PORT_MALL_POLICER) {
1054 			NL_SET_ERR_MSG_MOD(extack,
1055 					   "Only one port policer allowed");
1056 			return -EEXIST;
1057 		}
1058 	}
1059 
1060 	act = &cls->rule->action.entries[0];
1061 
1062 	mall_tc_entry = kzalloc(sizeof(*mall_tc_entry), GFP_KERNEL);
1063 	if (!mall_tc_entry)
1064 		return -ENOMEM;
1065 
1066 	mall_tc_entry->cookie = cls->cookie;
1067 	mall_tc_entry->type = DSA_PORT_MALL_POLICER;
1068 	policer = &mall_tc_entry->policer;
1069 	policer->rate_bytes_per_sec = act->police.rate_bytes_ps;
1070 	policer->burst = act->police.burst;
1071 
1072 	err = ds->ops->port_policer_add(ds, dp->index, policer);
1073 	if (err) {
1074 		kfree(mall_tc_entry);
1075 		return err;
1076 	}
1077 
1078 	list_add_tail(&mall_tc_entry->list, &p->mall_tc_list);
1079 
1080 	return err;
1081 }
1082 
1083 static int dsa_slave_add_cls_matchall(struct net_device *dev,
1084 				      struct tc_cls_matchall_offload *cls,
1085 				      bool ingress)
1086 {
1087 	int err = -EOPNOTSUPP;
1088 
1089 	if (cls->common.protocol == htons(ETH_P_ALL) &&
1090 	    flow_offload_has_one_action(&cls->rule->action) &&
1091 	    cls->rule->action.entries[0].id == FLOW_ACTION_MIRRED)
1092 		err = dsa_slave_add_cls_matchall_mirred(dev, cls, ingress);
1093 	else if (flow_offload_has_one_action(&cls->rule->action) &&
1094 		 cls->rule->action.entries[0].id == FLOW_ACTION_POLICE)
1095 		err = dsa_slave_add_cls_matchall_police(dev, cls, ingress);
1096 
1097 	return err;
1098 }
1099 
1100 static void dsa_slave_del_cls_matchall(struct net_device *dev,
1101 				       struct tc_cls_matchall_offload *cls)
1102 {
1103 	struct dsa_port *dp = dsa_slave_to_port(dev);
1104 	struct dsa_mall_tc_entry *mall_tc_entry;
1105 	struct dsa_switch *ds = dp->ds;
1106 
1107 	mall_tc_entry = dsa_slave_mall_tc_entry_find(dev, cls->cookie);
1108 	if (!mall_tc_entry)
1109 		return;
1110 
1111 	list_del(&mall_tc_entry->list);
1112 
1113 	switch (mall_tc_entry->type) {
1114 	case DSA_PORT_MALL_MIRROR:
1115 		if (ds->ops->port_mirror_del)
1116 			ds->ops->port_mirror_del(ds, dp->index,
1117 						 &mall_tc_entry->mirror);
1118 		break;
1119 	case DSA_PORT_MALL_POLICER:
1120 		if (ds->ops->port_policer_del)
1121 			ds->ops->port_policer_del(ds, dp->index);
1122 		break;
1123 	default:
1124 		WARN_ON(1);
1125 	}
1126 
1127 	kfree(mall_tc_entry);
1128 }
1129 
1130 static int dsa_slave_setup_tc_cls_matchall(struct net_device *dev,
1131 					   struct tc_cls_matchall_offload *cls,
1132 					   bool ingress)
1133 {
1134 	if (cls->common.chain_index)
1135 		return -EOPNOTSUPP;
1136 
1137 	switch (cls->command) {
1138 	case TC_CLSMATCHALL_REPLACE:
1139 		return dsa_slave_add_cls_matchall(dev, cls, ingress);
1140 	case TC_CLSMATCHALL_DESTROY:
1141 		dsa_slave_del_cls_matchall(dev, cls);
1142 		return 0;
1143 	default:
1144 		return -EOPNOTSUPP;
1145 	}
1146 }
1147 
1148 static int dsa_slave_add_cls_flower(struct net_device *dev,
1149 				    struct flow_cls_offload *cls,
1150 				    bool ingress)
1151 {
1152 	struct dsa_port *dp = dsa_slave_to_port(dev);
1153 	struct dsa_switch *ds = dp->ds;
1154 	int port = dp->index;
1155 
1156 	if (!ds->ops->cls_flower_add)
1157 		return -EOPNOTSUPP;
1158 
1159 	return ds->ops->cls_flower_add(ds, port, cls, ingress);
1160 }
1161 
1162 static int dsa_slave_del_cls_flower(struct net_device *dev,
1163 				    struct flow_cls_offload *cls,
1164 				    bool ingress)
1165 {
1166 	struct dsa_port *dp = dsa_slave_to_port(dev);
1167 	struct dsa_switch *ds = dp->ds;
1168 	int port = dp->index;
1169 
1170 	if (!ds->ops->cls_flower_del)
1171 		return -EOPNOTSUPP;
1172 
1173 	return ds->ops->cls_flower_del(ds, port, cls, ingress);
1174 }
1175 
1176 static int dsa_slave_stats_cls_flower(struct net_device *dev,
1177 				      struct flow_cls_offload *cls,
1178 				      bool ingress)
1179 {
1180 	struct dsa_port *dp = dsa_slave_to_port(dev);
1181 	struct dsa_switch *ds = dp->ds;
1182 	int port = dp->index;
1183 
1184 	if (!ds->ops->cls_flower_stats)
1185 		return -EOPNOTSUPP;
1186 
1187 	return ds->ops->cls_flower_stats(ds, port, cls, ingress);
1188 }
1189 
1190 static int dsa_slave_setup_tc_cls_flower(struct net_device *dev,
1191 					 struct flow_cls_offload *cls,
1192 					 bool ingress)
1193 {
1194 	switch (cls->command) {
1195 	case FLOW_CLS_REPLACE:
1196 		return dsa_slave_add_cls_flower(dev, cls, ingress);
1197 	case FLOW_CLS_DESTROY:
1198 		return dsa_slave_del_cls_flower(dev, cls, ingress);
1199 	case FLOW_CLS_STATS:
1200 		return dsa_slave_stats_cls_flower(dev, cls, ingress);
1201 	default:
1202 		return -EOPNOTSUPP;
1203 	}
1204 }
1205 
1206 static int dsa_slave_setup_tc_block_cb(enum tc_setup_type type, void *type_data,
1207 				       void *cb_priv, bool ingress)
1208 {
1209 	struct net_device *dev = cb_priv;
1210 
1211 	if (!tc_can_offload(dev))
1212 		return -EOPNOTSUPP;
1213 
1214 	switch (type) {
1215 	case TC_SETUP_CLSMATCHALL:
1216 		return dsa_slave_setup_tc_cls_matchall(dev, type_data, ingress);
1217 	case TC_SETUP_CLSFLOWER:
1218 		return dsa_slave_setup_tc_cls_flower(dev, type_data, ingress);
1219 	default:
1220 		return -EOPNOTSUPP;
1221 	}
1222 }
1223 
1224 static int dsa_slave_setup_tc_block_cb_ig(enum tc_setup_type type,
1225 					  void *type_data, void *cb_priv)
1226 {
1227 	return dsa_slave_setup_tc_block_cb(type, type_data, cb_priv, true);
1228 }
1229 
1230 static int dsa_slave_setup_tc_block_cb_eg(enum tc_setup_type type,
1231 					  void *type_data, void *cb_priv)
1232 {
1233 	return dsa_slave_setup_tc_block_cb(type, type_data, cb_priv, false);
1234 }
1235 
1236 static LIST_HEAD(dsa_slave_block_cb_list);
1237 
1238 static int dsa_slave_setup_tc_block(struct net_device *dev,
1239 				    struct flow_block_offload *f)
1240 {
1241 	struct flow_block_cb *block_cb;
1242 	flow_setup_cb_t *cb;
1243 
1244 	if (f->binder_type == FLOW_BLOCK_BINDER_TYPE_CLSACT_INGRESS)
1245 		cb = dsa_slave_setup_tc_block_cb_ig;
1246 	else if (f->binder_type == FLOW_BLOCK_BINDER_TYPE_CLSACT_EGRESS)
1247 		cb = dsa_slave_setup_tc_block_cb_eg;
1248 	else
1249 		return -EOPNOTSUPP;
1250 
1251 	f->driver_block_list = &dsa_slave_block_cb_list;
1252 
1253 	switch (f->command) {
1254 	case FLOW_BLOCK_BIND:
1255 		if (flow_block_cb_is_busy(cb, dev, &dsa_slave_block_cb_list))
1256 			return -EBUSY;
1257 
1258 		block_cb = flow_block_cb_alloc(cb, dev, dev, NULL);
1259 		if (IS_ERR(block_cb))
1260 			return PTR_ERR(block_cb);
1261 
1262 		flow_block_cb_add(block_cb, f);
1263 		list_add_tail(&block_cb->driver_list, &dsa_slave_block_cb_list);
1264 		return 0;
1265 	case FLOW_BLOCK_UNBIND:
1266 		block_cb = flow_block_cb_lookup(f->block, cb, dev);
1267 		if (!block_cb)
1268 			return -ENOENT;
1269 
1270 		flow_block_cb_remove(block_cb, f);
1271 		list_del(&block_cb->driver_list);
1272 		return 0;
1273 	default:
1274 		return -EOPNOTSUPP;
1275 	}
1276 }
1277 
1278 static int dsa_slave_setup_ft_block(struct dsa_switch *ds, int port,
1279 				    void *type_data)
1280 {
1281 	struct dsa_port *cpu_dp = dsa_to_port(ds, port)->cpu_dp;
1282 	struct net_device *master = cpu_dp->master;
1283 
1284 	if (!master->netdev_ops->ndo_setup_tc)
1285 		return -EOPNOTSUPP;
1286 
1287 	return master->netdev_ops->ndo_setup_tc(master, TC_SETUP_FT, type_data);
1288 }
1289 
1290 static int dsa_slave_setup_tc(struct net_device *dev, enum tc_setup_type type,
1291 			      void *type_data)
1292 {
1293 	struct dsa_port *dp = dsa_slave_to_port(dev);
1294 	struct dsa_switch *ds = dp->ds;
1295 
1296 	switch (type) {
1297 	case TC_SETUP_BLOCK:
1298 		return dsa_slave_setup_tc_block(dev, type_data);
1299 	case TC_SETUP_FT:
1300 		return dsa_slave_setup_ft_block(ds, dp->index, type_data);
1301 	default:
1302 		break;
1303 	}
1304 
1305 	if (!ds->ops->port_setup_tc)
1306 		return -EOPNOTSUPP;
1307 
1308 	return ds->ops->port_setup_tc(ds, dp->index, type, type_data);
1309 }
1310 
1311 static int dsa_slave_get_rxnfc(struct net_device *dev,
1312 			       struct ethtool_rxnfc *nfc, u32 *rule_locs)
1313 {
1314 	struct dsa_port *dp = dsa_slave_to_port(dev);
1315 	struct dsa_switch *ds = dp->ds;
1316 
1317 	if (!ds->ops->get_rxnfc)
1318 		return -EOPNOTSUPP;
1319 
1320 	return ds->ops->get_rxnfc(ds, dp->index, nfc, rule_locs);
1321 }
1322 
1323 static int dsa_slave_set_rxnfc(struct net_device *dev,
1324 			       struct ethtool_rxnfc *nfc)
1325 {
1326 	struct dsa_port *dp = dsa_slave_to_port(dev);
1327 	struct dsa_switch *ds = dp->ds;
1328 
1329 	if (!ds->ops->set_rxnfc)
1330 		return -EOPNOTSUPP;
1331 
1332 	return ds->ops->set_rxnfc(ds, dp->index, nfc);
1333 }
1334 
1335 static int dsa_slave_get_ts_info(struct net_device *dev,
1336 				 struct ethtool_ts_info *ts)
1337 {
1338 	struct dsa_slave_priv *p = netdev_priv(dev);
1339 	struct dsa_switch *ds = p->dp->ds;
1340 
1341 	if (!ds->ops->get_ts_info)
1342 		return -EOPNOTSUPP;
1343 
1344 	return ds->ops->get_ts_info(ds, p->dp->index, ts);
1345 }
1346 
1347 static int dsa_slave_vlan_rx_add_vid(struct net_device *dev, __be16 proto,
1348 				     u16 vid)
1349 {
1350 	struct net_device *master = dsa_slave_to_master(dev);
1351 	struct dsa_port *dp = dsa_slave_to_port(dev);
1352 	struct switchdev_obj_port_vlan vlan = {
1353 		.obj.id = SWITCHDEV_OBJ_ID_PORT_VLAN,
1354 		.vid = vid,
1355 		/* This API only allows programming tagged, non-PVID VIDs */
1356 		.flags = 0,
1357 	};
1358 	struct netlink_ext_ack extack = {0};
1359 	int ret;
1360 
1361 	/* User port... */
1362 	ret = dsa_port_vlan_add(dp, &vlan, &extack);
1363 	if (ret) {
1364 		if (extack._msg)
1365 			netdev_err(dev, "%s\n", extack._msg);
1366 		return ret;
1367 	}
1368 
1369 	/* And CPU port... */
1370 	ret = dsa_port_vlan_add(dp->cpu_dp, &vlan, &extack);
1371 	if (ret) {
1372 		if (extack._msg)
1373 			netdev_err(dev, "CPU port %d: %s\n", dp->cpu_dp->index,
1374 				   extack._msg);
1375 		return ret;
1376 	}
1377 
1378 	return vlan_vid_add(master, proto, vid);
1379 }
1380 
1381 static int dsa_slave_vlan_rx_kill_vid(struct net_device *dev, __be16 proto,
1382 				      u16 vid)
1383 {
1384 	struct net_device *master = dsa_slave_to_master(dev);
1385 	struct dsa_port *dp = dsa_slave_to_port(dev);
1386 	struct switchdev_obj_port_vlan vlan = {
1387 		.vid = vid,
1388 		/* This API only allows programming tagged, non-PVID VIDs */
1389 		.flags = 0,
1390 	};
1391 	int err;
1392 
1393 	/* Do not deprogram the CPU port as it may be shared with other user
1394 	 * ports which can be members of this VLAN as well.
1395 	 */
1396 	err = dsa_port_vlan_del(dp, &vlan);
1397 	if (err)
1398 		return err;
1399 
1400 	vlan_vid_del(master, proto, vid);
1401 
1402 	return 0;
1403 }
1404 
1405 static int dsa_slave_restore_vlan(struct net_device *vdev, int vid, void *arg)
1406 {
1407 	__be16 proto = vdev ? vlan_dev_vlan_proto(vdev) : htons(ETH_P_8021Q);
1408 
1409 	return dsa_slave_vlan_rx_add_vid(arg, proto, vid);
1410 }
1411 
1412 static int dsa_slave_clear_vlan(struct net_device *vdev, int vid, void *arg)
1413 {
1414 	__be16 proto = vdev ? vlan_dev_vlan_proto(vdev) : htons(ETH_P_8021Q);
1415 
1416 	return dsa_slave_vlan_rx_kill_vid(arg, proto, vid);
1417 }
1418 
1419 /* Keep the VLAN RX filtering list in sync with the hardware only if VLAN
1420  * filtering is enabled. The baseline is that only ports that offload a
1421  * VLAN-aware bridge are VLAN-aware, and standalone ports are VLAN-unaware,
1422  * but there are exceptions for quirky hardware.
1423  *
1424  * If ds->vlan_filtering_is_global = true, then standalone ports which share
1425  * the same switch with other ports that offload a VLAN-aware bridge are also
1426  * inevitably VLAN-aware.
1427  *
1428  * To summarize, a DSA switch port offloads:
1429  *
1430  * - If standalone (this includes software bridge, software LAG):
1431  *     - if ds->needs_standalone_vlan_filtering = true, OR if
1432  *       (ds->vlan_filtering_is_global = true AND there are bridges spanning
1433  *       this switch chip which have vlan_filtering=1)
1434  *         - the 8021q upper VLANs
1435  *     - else (standalone VLAN filtering is not needed, VLAN filtering is not
1436  *       global, or it is, but no port is under a VLAN-aware bridge):
1437  *         - no VLAN (any 8021q upper is a software VLAN)
1438  *
1439  * - If under a vlan_filtering=0 bridge which it offload:
1440  *     - if ds->configure_vlan_while_not_filtering = true (default):
1441  *         - the bridge VLANs. These VLANs are committed to hardware but inactive.
1442  *     - else (deprecated):
1443  *         - no VLAN. The bridge VLANs are not restored when VLAN awareness is
1444  *           enabled, so this behavior is broken and discouraged.
1445  *
1446  * - If under a vlan_filtering=1 bridge which it offload:
1447  *     - the bridge VLANs
1448  *     - the 8021q upper VLANs
1449  */
1450 int dsa_slave_manage_vlan_filtering(struct net_device *slave,
1451 				    bool vlan_filtering)
1452 {
1453 	int err;
1454 
1455 	if (vlan_filtering) {
1456 		slave->features |= NETIF_F_HW_VLAN_CTAG_FILTER;
1457 
1458 		err = vlan_for_each(slave, dsa_slave_restore_vlan, slave);
1459 		if (err) {
1460 			vlan_for_each(slave, dsa_slave_clear_vlan, slave);
1461 			slave->features &= ~NETIF_F_HW_VLAN_CTAG_FILTER;
1462 			return err;
1463 		}
1464 	} else {
1465 		err = vlan_for_each(slave, dsa_slave_clear_vlan, slave);
1466 		if (err)
1467 			return err;
1468 
1469 		slave->features &= ~NETIF_F_HW_VLAN_CTAG_FILTER;
1470 	}
1471 
1472 	return 0;
1473 }
1474 
1475 struct dsa_hw_port {
1476 	struct list_head list;
1477 	struct net_device *dev;
1478 	int old_mtu;
1479 };
1480 
1481 static int dsa_hw_port_list_set_mtu(struct list_head *hw_port_list, int mtu)
1482 {
1483 	const struct dsa_hw_port *p;
1484 	int err;
1485 
1486 	list_for_each_entry(p, hw_port_list, list) {
1487 		if (p->dev->mtu == mtu)
1488 			continue;
1489 
1490 		err = dev_set_mtu(p->dev, mtu);
1491 		if (err)
1492 			goto rollback;
1493 	}
1494 
1495 	return 0;
1496 
1497 rollback:
1498 	list_for_each_entry_continue_reverse(p, hw_port_list, list) {
1499 		if (p->dev->mtu == p->old_mtu)
1500 			continue;
1501 
1502 		if (dev_set_mtu(p->dev, p->old_mtu))
1503 			netdev_err(p->dev, "Failed to restore MTU\n");
1504 	}
1505 
1506 	return err;
1507 }
1508 
1509 static void dsa_hw_port_list_free(struct list_head *hw_port_list)
1510 {
1511 	struct dsa_hw_port *p, *n;
1512 
1513 	list_for_each_entry_safe(p, n, hw_port_list, list)
1514 		kfree(p);
1515 }
1516 
1517 /* Make the hardware datapath to/from @dev limited to a common MTU */
1518 static void dsa_bridge_mtu_normalization(struct dsa_port *dp)
1519 {
1520 	struct list_head hw_port_list;
1521 	struct dsa_switch_tree *dst;
1522 	int min_mtu = ETH_MAX_MTU;
1523 	struct dsa_port *other_dp;
1524 	int err;
1525 
1526 	if (!dp->ds->mtu_enforcement_ingress)
1527 		return;
1528 
1529 	if (!dp->bridge)
1530 		return;
1531 
1532 	INIT_LIST_HEAD(&hw_port_list);
1533 
1534 	/* Populate the list of ports that are part of the same bridge
1535 	 * as the newly added/modified port
1536 	 */
1537 	list_for_each_entry(dst, &dsa_tree_list, list) {
1538 		list_for_each_entry(other_dp, &dst->ports, list) {
1539 			struct dsa_hw_port *hw_port;
1540 			struct net_device *slave;
1541 
1542 			if (other_dp->type != DSA_PORT_TYPE_USER)
1543 				continue;
1544 
1545 			if (!dsa_port_bridge_same(dp, other_dp))
1546 				continue;
1547 
1548 			if (!other_dp->ds->mtu_enforcement_ingress)
1549 				continue;
1550 
1551 			slave = other_dp->slave;
1552 
1553 			if (min_mtu > slave->mtu)
1554 				min_mtu = slave->mtu;
1555 
1556 			hw_port = kzalloc(sizeof(*hw_port), GFP_KERNEL);
1557 			if (!hw_port)
1558 				goto out;
1559 
1560 			hw_port->dev = slave;
1561 			hw_port->old_mtu = slave->mtu;
1562 
1563 			list_add(&hw_port->list, &hw_port_list);
1564 		}
1565 	}
1566 
1567 	/* Attempt to configure the entire hardware bridge to the newly added
1568 	 * interface's MTU first, regardless of whether the intention of the
1569 	 * user was to raise or lower it.
1570 	 */
1571 	err = dsa_hw_port_list_set_mtu(&hw_port_list, dp->slave->mtu);
1572 	if (!err)
1573 		goto out;
1574 
1575 	/* Clearly that didn't work out so well, so just set the minimum MTU on
1576 	 * all hardware bridge ports now. If this fails too, then all ports will
1577 	 * still have their old MTU rolled back anyway.
1578 	 */
1579 	dsa_hw_port_list_set_mtu(&hw_port_list, min_mtu);
1580 
1581 out:
1582 	dsa_hw_port_list_free(&hw_port_list);
1583 }
1584 
1585 int dsa_slave_change_mtu(struct net_device *dev, int new_mtu)
1586 {
1587 	struct net_device *master = dsa_slave_to_master(dev);
1588 	struct dsa_port *dp = dsa_slave_to_port(dev);
1589 	struct dsa_slave_priv *p = netdev_priv(dev);
1590 	struct dsa_switch *ds = p->dp->ds;
1591 	struct dsa_port *dp_iter;
1592 	struct dsa_port *cpu_dp;
1593 	int port = p->dp->index;
1594 	int largest_mtu = 0;
1595 	int new_master_mtu;
1596 	int old_master_mtu;
1597 	int mtu_limit;
1598 	int cpu_mtu;
1599 	int err;
1600 
1601 	if (!ds->ops->port_change_mtu)
1602 		return -EOPNOTSUPP;
1603 
1604 	list_for_each_entry(dp_iter, &ds->dst->ports, list) {
1605 		int slave_mtu;
1606 
1607 		if (!dsa_port_is_user(dp_iter))
1608 			continue;
1609 
1610 		/* During probe, this function will be called for each slave
1611 		 * device, while not all of them have been allocated. That's
1612 		 * ok, it doesn't change what the maximum is, so ignore it.
1613 		 */
1614 		if (!dp_iter->slave)
1615 			continue;
1616 
1617 		/* Pretend that we already applied the setting, which we
1618 		 * actually haven't (still haven't done all integrity checks)
1619 		 */
1620 		if (dp_iter == dp)
1621 			slave_mtu = new_mtu;
1622 		else
1623 			slave_mtu = dp_iter->slave->mtu;
1624 
1625 		if (largest_mtu < slave_mtu)
1626 			largest_mtu = slave_mtu;
1627 	}
1628 
1629 	cpu_dp = dsa_to_port(ds, port)->cpu_dp;
1630 
1631 	mtu_limit = min_t(int, master->max_mtu, dev->max_mtu);
1632 	old_master_mtu = master->mtu;
1633 	new_master_mtu = largest_mtu + dsa_tag_protocol_overhead(cpu_dp->tag_ops);
1634 	if (new_master_mtu > mtu_limit)
1635 		return -ERANGE;
1636 
1637 	/* If the master MTU isn't over limit, there's no need to check the CPU
1638 	 * MTU, since that surely isn't either.
1639 	 */
1640 	cpu_mtu = largest_mtu;
1641 
1642 	/* Start applying stuff */
1643 	if (new_master_mtu != old_master_mtu) {
1644 		err = dev_set_mtu(master, new_master_mtu);
1645 		if (err < 0)
1646 			goto out_master_failed;
1647 
1648 		/* We only need to propagate the MTU of the CPU port to
1649 		 * upstream switches, so create a non-targeted notifier which
1650 		 * updates all switches.
1651 		 */
1652 		err = dsa_port_mtu_change(cpu_dp, cpu_mtu, false);
1653 		if (err)
1654 			goto out_cpu_failed;
1655 	}
1656 
1657 	err = dsa_port_mtu_change(dp, new_mtu, true);
1658 	if (err)
1659 		goto out_port_failed;
1660 
1661 	dev->mtu = new_mtu;
1662 
1663 	dsa_bridge_mtu_normalization(dp);
1664 
1665 	return 0;
1666 
1667 out_port_failed:
1668 	if (new_master_mtu != old_master_mtu)
1669 		dsa_port_mtu_change(cpu_dp, old_master_mtu -
1670 				    dsa_tag_protocol_overhead(cpu_dp->tag_ops),
1671 				    false);
1672 out_cpu_failed:
1673 	if (new_master_mtu != old_master_mtu)
1674 		dev_set_mtu(master, old_master_mtu);
1675 out_master_failed:
1676 	return err;
1677 }
1678 
1679 static const struct ethtool_ops dsa_slave_ethtool_ops = {
1680 	.get_drvinfo		= dsa_slave_get_drvinfo,
1681 	.get_regs_len		= dsa_slave_get_regs_len,
1682 	.get_regs		= dsa_slave_get_regs,
1683 	.nway_reset		= dsa_slave_nway_reset,
1684 	.get_link		= ethtool_op_get_link,
1685 	.get_eeprom_len		= dsa_slave_get_eeprom_len,
1686 	.get_eeprom		= dsa_slave_get_eeprom,
1687 	.set_eeprom		= dsa_slave_set_eeprom,
1688 	.get_strings		= dsa_slave_get_strings,
1689 	.get_ethtool_stats	= dsa_slave_get_ethtool_stats,
1690 	.get_sset_count		= dsa_slave_get_sset_count,
1691 	.get_eth_phy_stats	= dsa_slave_get_eth_phy_stats,
1692 	.get_eth_mac_stats	= dsa_slave_get_eth_mac_stats,
1693 	.get_eth_ctrl_stats	= dsa_slave_get_eth_ctrl_stats,
1694 	.set_wol		= dsa_slave_set_wol,
1695 	.get_wol		= dsa_slave_get_wol,
1696 	.set_eee		= dsa_slave_set_eee,
1697 	.get_eee		= dsa_slave_get_eee,
1698 	.get_link_ksettings	= dsa_slave_get_link_ksettings,
1699 	.set_link_ksettings	= dsa_slave_set_link_ksettings,
1700 	.get_pauseparam		= dsa_slave_get_pauseparam,
1701 	.set_pauseparam		= dsa_slave_set_pauseparam,
1702 	.get_rxnfc		= dsa_slave_get_rxnfc,
1703 	.set_rxnfc		= dsa_slave_set_rxnfc,
1704 	.get_ts_info		= dsa_slave_get_ts_info,
1705 	.self_test		= dsa_slave_net_selftest,
1706 };
1707 
1708 static struct devlink_port *dsa_slave_get_devlink_port(struct net_device *dev)
1709 {
1710 	struct dsa_port *dp = dsa_slave_to_port(dev);
1711 
1712 	return &dp->devlink_port;
1713 }
1714 
1715 static void dsa_slave_get_stats64(struct net_device *dev,
1716 				  struct rtnl_link_stats64 *s)
1717 {
1718 	struct dsa_port *dp = dsa_slave_to_port(dev);
1719 	struct dsa_switch *ds = dp->ds;
1720 
1721 	if (ds->ops->get_stats64)
1722 		ds->ops->get_stats64(ds, dp->index, s);
1723 	else
1724 		dev_get_tstats64(dev, s);
1725 }
1726 
1727 static int dsa_slave_fill_forward_path(struct net_device_path_ctx *ctx,
1728 				       struct net_device_path *path)
1729 {
1730 	struct dsa_port *dp = dsa_slave_to_port(ctx->dev);
1731 	struct dsa_port *cpu_dp = dp->cpu_dp;
1732 
1733 	path->dev = ctx->dev;
1734 	path->type = DEV_PATH_DSA;
1735 	path->dsa.proto = cpu_dp->tag_ops->proto;
1736 	path->dsa.port = dp->index;
1737 	ctx->dev = cpu_dp->master;
1738 
1739 	return 0;
1740 }
1741 
1742 static const struct net_device_ops dsa_slave_netdev_ops = {
1743 	.ndo_open	 	= dsa_slave_open,
1744 	.ndo_stop		= dsa_slave_close,
1745 	.ndo_start_xmit		= dsa_slave_xmit,
1746 	.ndo_change_rx_flags	= dsa_slave_change_rx_flags,
1747 	.ndo_set_rx_mode	= dsa_slave_set_rx_mode,
1748 	.ndo_set_mac_address	= dsa_slave_set_mac_address,
1749 	.ndo_fdb_dump		= dsa_slave_fdb_dump,
1750 	.ndo_eth_ioctl		= dsa_slave_ioctl,
1751 	.ndo_get_iflink		= dsa_slave_get_iflink,
1752 #ifdef CONFIG_NET_POLL_CONTROLLER
1753 	.ndo_netpoll_setup	= dsa_slave_netpoll_setup,
1754 	.ndo_netpoll_cleanup	= dsa_slave_netpoll_cleanup,
1755 	.ndo_poll_controller	= dsa_slave_poll_controller,
1756 #endif
1757 	.ndo_setup_tc		= dsa_slave_setup_tc,
1758 	.ndo_get_stats64	= dsa_slave_get_stats64,
1759 	.ndo_vlan_rx_add_vid	= dsa_slave_vlan_rx_add_vid,
1760 	.ndo_vlan_rx_kill_vid	= dsa_slave_vlan_rx_kill_vid,
1761 	.ndo_get_devlink_port	= dsa_slave_get_devlink_port,
1762 	.ndo_change_mtu		= dsa_slave_change_mtu,
1763 	.ndo_fill_forward_path	= dsa_slave_fill_forward_path,
1764 };
1765 
1766 static struct device_type dsa_type = {
1767 	.name	= "dsa",
1768 };
1769 
1770 void dsa_port_phylink_mac_change(struct dsa_switch *ds, int port, bool up)
1771 {
1772 	const struct dsa_port *dp = dsa_to_port(ds, port);
1773 
1774 	if (dp->pl)
1775 		phylink_mac_change(dp->pl, up);
1776 }
1777 EXPORT_SYMBOL_GPL(dsa_port_phylink_mac_change);
1778 
1779 static void dsa_slave_phylink_fixed_state(struct phylink_config *config,
1780 					  struct phylink_link_state *state)
1781 {
1782 	struct dsa_port *dp = container_of(config, struct dsa_port, pl_config);
1783 	struct dsa_switch *ds = dp->ds;
1784 
1785 	/* No need to check that this operation is valid, the callback would
1786 	 * not be called if it was not.
1787 	 */
1788 	ds->ops->phylink_fixed_state(ds, dp->index, state);
1789 }
1790 
1791 /* slave device setup *******************************************************/
1792 static int dsa_slave_phy_connect(struct net_device *slave_dev, int addr,
1793 				 u32 flags)
1794 {
1795 	struct dsa_port *dp = dsa_slave_to_port(slave_dev);
1796 	struct dsa_switch *ds = dp->ds;
1797 
1798 	slave_dev->phydev = mdiobus_get_phy(ds->slave_mii_bus, addr);
1799 	if (!slave_dev->phydev) {
1800 		netdev_err(slave_dev, "no phy at %d\n", addr);
1801 		return -ENODEV;
1802 	}
1803 
1804 	slave_dev->phydev->dev_flags |= flags;
1805 
1806 	return phylink_connect_phy(dp->pl, slave_dev->phydev);
1807 }
1808 
1809 static int dsa_slave_phy_setup(struct net_device *slave_dev)
1810 {
1811 	struct dsa_port *dp = dsa_slave_to_port(slave_dev);
1812 	struct device_node *port_dn = dp->dn;
1813 	struct dsa_switch *ds = dp->ds;
1814 	u32 phy_flags = 0;
1815 	int ret;
1816 
1817 	dp->pl_config.dev = &slave_dev->dev;
1818 	dp->pl_config.type = PHYLINK_NETDEV;
1819 
1820 	/* The get_fixed_state callback takes precedence over polling the
1821 	 * link GPIO in PHYLINK (see phylink_get_fixed_state).  Only set
1822 	 * this if the switch provides such a callback.
1823 	 */
1824 	if (ds->ops->phylink_fixed_state) {
1825 		dp->pl_config.get_fixed_state = dsa_slave_phylink_fixed_state;
1826 		dp->pl_config.poll_fixed_state = true;
1827 	}
1828 
1829 	ret = dsa_port_phylink_create(dp);
1830 	if (ret)
1831 		return ret;
1832 
1833 	if (ds->ops->get_phy_flags)
1834 		phy_flags = ds->ops->get_phy_flags(ds, dp->index);
1835 
1836 	ret = phylink_of_phy_connect(dp->pl, port_dn, phy_flags);
1837 	if (ret == -ENODEV && ds->slave_mii_bus) {
1838 		/* We could not connect to a designated PHY or SFP, so try to
1839 		 * use the switch internal MDIO bus instead
1840 		 */
1841 		ret = dsa_slave_phy_connect(slave_dev, dp->index, phy_flags);
1842 	}
1843 	if (ret) {
1844 		netdev_err(slave_dev, "failed to connect to PHY: %pe\n",
1845 			   ERR_PTR(ret));
1846 		phylink_destroy(dp->pl);
1847 	}
1848 
1849 	return ret;
1850 }
1851 
1852 void dsa_slave_setup_tagger(struct net_device *slave)
1853 {
1854 	struct dsa_port *dp = dsa_slave_to_port(slave);
1855 	struct dsa_slave_priv *p = netdev_priv(slave);
1856 	const struct dsa_port *cpu_dp = dp->cpu_dp;
1857 	struct net_device *master = cpu_dp->master;
1858 	const struct dsa_switch *ds = dp->ds;
1859 
1860 	slave->needed_headroom = cpu_dp->tag_ops->needed_headroom;
1861 	slave->needed_tailroom = cpu_dp->tag_ops->needed_tailroom;
1862 	/* Try to save one extra realloc later in the TX path (in the master)
1863 	 * by also inheriting the master's needed headroom and tailroom.
1864 	 * The 8021q driver also does this.
1865 	 */
1866 	slave->needed_headroom += master->needed_headroom;
1867 	slave->needed_tailroom += master->needed_tailroom;
1868 
1869 	p->xmit = cpu_dp->tag_ops->xmit;
1870 
1871 	slave->features = master->vlan_features | NETIF_F_HW_TC;
1872 	slave->hw_features |= NETIF_F_HW_TC;
1873 	slave->features |= NETIF_F_LLTX;
1874 	if (slave->needed_tailroom)
1875 		slave->features &= ~(NETIF_F_SG | NETIF_F_FRAGLIST);
1876 	if (ds->needs_standalone_vlan_filtering)
1877 		slave->features |= NETIF_F_HW_VLAN_CTAG_FILTER;
1878 }
1879 
1880 int dsa_slave_suspend(struct net_device *slave_dev)
1881 {
1882 	struct dsa_port *dp = dsa_slave_to_port(slave_dev);
1883 
1884 	if (!netif_running(slave_dev))
1885 		return 0;
1886 
1887 	netif_device_detach(slave_dev);
1888 
1889 	rtnl_lock();
1890 	phylink_stop(dp->pl);
1891 	rtnl_unlock();
1892 
1893 	return 0;
1894 }
1895 
1896 int dsa_slave_resume(struct net_device *slave_dev)
1897 {
1898 	struct dsa_port *dp = dsa_slave_to_port(slave_dev);
1899 
1900 	if (!netif_running(slave_dev))
1901 		return 0;
1902 
1903 	netif_device_attach(slave_dev);
1904 
1905 	rtnl_lock();
1906 	phylink_start(dp->pl);
1907 	rtnl_unlock();
1908 
1909 	return 0;
1910 }
1911 
1912 int dsa_slave_create(struct dsa_port *port)
1913 {
1914 	const struct dsa_port *cpu_dp = port->cpu_dp;
1915 	struct net_device *master = cpu_dp->master;
1916 	struct dsa_switch *ds = port->ds;
1917 	const char *name = port->name;
1918 	struct net_device *slave_dev;
1919 	struct dsa_slave_priv *p;
1920 	int ret;
1921 
1922 	if (!ds->num_tx_queues)
1923 		ds->num_tx_queues = 1;
1924 
1925 	slave_dev = alloc_netdev_mqs(sizeof(struct dsa_slave_priv), name,
1926 				     NET_NAME_UNKNOWN, ether_setup,
1927 				     ds->num_tx_queues, 1);
1928 	if (slave_dev == NULL)
1929 		return -ENOMEM;
1930 
1931 	slave_dev->ethtool_ops = &dsa_slave_ethtool_ops;
1932 	if (!is_zero_ether_addr(port->mac))
1933 		eth_hw_addr_set(slave_dev, port->mac);
1934 	else
1935 		eth_hw_addr_inherit(slave_dev, master);
1936 	slave_dev->priv_flags |= IFF_NO_QUEUE;
1937 	slave_dev->netdev_ops = &dsa_slave_netdev_ops;
1938 	if (ds->ops->port_max_mtu)
1939 		slave_dev->max_mtu = ds->ops->port_max_mtu(ds, port->index);
1940 	SET_NETDEV_DEVTYPE(slave_dev, &dsa_type);
1941 
1942 	SET_NETDEV_DEV(slave_dev, port->ds->dev);
1943 	slave_dev->dev.of_node = port->dn;
1944 	slave_dev->vlan_features = master->vlan_features;
1945 
1946 	p = netdev_priv(slave_dev);
1947 	slave_dev->tstats = netdev_alloc_pcpu_stats(struct pcpu_sw_netstats);
1948 	if (!slave_dev->tstats) {
1949 		free_netdev(slave_dev);
1950 		return -ENOMEM;
1951 	}
1952 
1953 	ret = gro_cells_init(&p->gcells, slave_dev);
1954 	if (ret)
1955 		goto out_free;
1956 
1957 	p->dp = port;
1958 	INIT_LIST_HEAD(&p->mall_tc_list);
1959 	port->slave = slave_dev;
1960 	dsa_slave_setup_tagger(slave_dev);
1961 
1962 	netif_carrier_off(slave_dev);
1963 
1964 	ret = dsa_slave_phy_setup(slave_dev);
1965 	if (ret) {
1966 		netdev_err(slave_dev,
1967 			   "error %d setting up PHY for tree %d, switch %d, port %d\n",
1968 			   ret, ds->dst->index, ds->index, port->index);
1969 		goto out_gcells;
1970 	}
1971 
1972 	rtnl_lock();
1973 
1974 	ret = dsa_slave_change_mtu(slave_dev, ETH_DATA_LEN);
1975 	if (ret && ret != -EOPNOTSUPP)
1976 		dev_warn(ds->dev, "nonfatal error %d setting MTU to %d on port %d\n",
1977 			 ret, ETH_DATA_LEN, port->index);
1978 
1979 	ret = register_netdevice(slave_dev);
1980 	if (ret) {
1981 		netdev_err(master, "error %d registering interface %s\n",
1982 			   ret, slave_dev->name);
1983 		rtnl_unlock();
1984 		goto out_phy;
1985 	}
1986 
1987 	ret = netdev_upper_dev_link(master, slave_dev, NULL);
1988 
1989 	rtnl_unlock();
1990 
1991 	if (ret)
1992 		goto out_unregister;
1993 
1994 	return 0;
1995 
1996 out_unregister:
1997 	unregister_netdev(slave_dev);
1998 out_phy:
1999 	rtnl_lock();
2000 	phylink_disconnect_phy(p->dp->pl);
2001 	rtnl_unlock();
2002 	phylink_destroy(p->dp->pl);
2003 out_gcells:
2004 	gro_cells_destroy(&p->gcells);
2005 out_free:
2006 	free_percpu(slave_dev->tstats);
2007 	free_netdev(slave_dev);
2008 	port->slave = NULL;
2009 	return ret;
2010 }
2011 
2012 void dsa_slave_destroy(struct net_device *slave_dev)
2013 {
2014 	struct net_device *master = dsa_slave_to_master(slave_dev);
2015 	struct dsa_port *dp = dsa_slave_to_port(slave_dev);
2016 	struct dsa_slave_priv *p = netdev_priv(slave_dev);
2017 
2018 	netif_carrier_off(slave_dev);
2019 	rtnl_lock();
2020 	netdev_upper_dev_unlink(master, slave_dev);
2021 	unregister_netdevice(slave_dev);
2022 	phylink_disconnect_phy(dp->pl);
2023 	rtnl_unlock();
2024 
2025 	phylink_destroy(dp->pl);
2026 	gro_cells_destroy(&p->gcells);
2027 	free_percpu(slave_dev->tstats);
2028 	free_netdev(slave_dev);
2029 }
2030 
2031 bool dsa_slave_dev_check(const struct net_device *dev)
2032 {
2033 	return dev->netdev_ops == &dsa_slave_netdev_ops;
2034 }
2035 EXPORT_SYMBOL_GPL(dsa_slave_dev_check);
2036 
2037 static int dsa_slave_changeupper(struct net_device *dev,
2038 				 struct netdev_notifier_changeupper_info *info)
2039 {
2040 	struct dsa_port *dp = dsa_slave_to_port(dev);
2041 	struct netlink_ext_ack *extack;
2042 	int err = NOTIFY_DONE;
2043 
2044 	extack = netdev_notifier_info_to_extack(&info->info);
2045 
2046 	if (netif_is_bridge_master(info->upper_dev)) {
2047 		if (info->linking) {
2048 			err = dsa_port_bridge_join(dp, info->upper_dev, extack);
2049 			if (!err)
2050 				dsa_bridge_mtu_normalization(dp);
2051 			if (err == -EOPNOTSUPP) {
2052 				NL_SET_ERR_MSG_MOD(extack,
2053 						   "Offloading not supported");
2054 				err = 0;
2055 			}
2056 			err = notifier_from_errno(err);
2057 		} else {
2058 			dsa_port_bridge_leave(dp, info->upper_dev);
2059 			err = NOTIFY_OK;
2060 		}
2061 	} else if (netif_is_lag_master(info->upper_dev)) {
2062 		if (info->linking) {
2063 			err = dsa_port_lag_join(dp, info->upper_dev,
2064 						info->upper_info, extack);
2065 			if (err == -EOPNOTSUPP) {
2066 				NL_SET_ERR_MSG_MOD(info->info.extack,
2067 						   "Offloading not supported");
2068 				err = 0;
2069 			}
2070 			err = notifier_from_errno(err);
2071 		} else {
2072 			dsa_port_lag_leave(dp, info->upper_dev);
2073 			err = NOTIFY_OK;
2074 		}
2075 	} else if (is_hsr_master(info->upper_dev)) {
2076 		if (info->linking) {
2077 			err = dsa_port_hsr_join(dp, info->upper_dev);
2078 			if (err == -EOPNOTSUPP) {
2079 				NL_SET_ERR_MSG_MOD(info->info.extack,
2080 						   "Offloading not supported");
2081 				err = 0;
2082 			}
2083 			err = notifier_from_errno(err);
2084 		} else {
2085 			dsa_port_hsr_leave(dp, info->upper_dev);
2086 			err = NOTIFY_OK;
2087 		}
2088 	}
2089 
2090 	return err;
2091 }
2092 
2093 static int dsa_slave_prechangeupper(struct net_device *dev,
2094 				    struct netdev_notifier_changeupper_info *info)
2095 {
2096 	struct dsa_port *dp = dsa_slave_to_port(dev);
2097 
2098 	if (netif_is_bridge_master(info->upper_dev) && !info->linking)
2099 		dsa_port_pre_bridge_leave(dp, info->upper_dev);
2100 	else if (netif_is_lag_master(info->upper_dev) && !info->linking)
2101 		dsa_port_pre_lag_leave(dp, info->upper_dev);
2102 	/* dsa_port_pre_hsr_leave is not yet necessary since hsr cannot be
2103 	 * meaningfully enslaved to a bridge yet
2104 	 */
2105 
2106 	return NOTIFY_DONE;
2107 }
2108 
2109 static int
2110 dsa_slave_lag_changeupper(struct net_device *dev,
2111 			  struct netdev_notifier_changeupper_info *info)
2112 {
2113 	struct net_device *lower;
2114 	struct list_head *iter;
2115 	int err = NOTIFY_DONE;
2116 	struct dsa_port *dp;
2117 
2118 	netdev_for_each_lower_dev(dev, lower, iter) {
2119 		if (!dsa_slave_dev_check(lower))
2120 			continue;
2121 
2122 		dp = dsa_slave_to_port(lower);
2123 		if (!dp->lag_dev)
2124 			/* Software LAG */
2125 			continue;
2126 
2127 		err = dsa_slave_changeupper(lower, info);
2128 		if (notifier_to_errno(err))
2129 			break;
2130 	}
2131 
2132 	return err;
2133 }
2134 
2135 /* Same as dsa_slave_lag_changeupper() except that it calls
2136  * dsa_slave_prechangeupper()
2137  */
2138 static int
2139 dsa_slave_lag_prechangeupper(struct net_device *dev,
2140 			     struct netdev_notifier_changeupper_info *info)
2141 {
2142 	struct net_device *lower;
2143 	struct list_head *iter;
2144 	int err = NOTIFY_DONE;
2145 	struct dsa_port *dp;
2146 
2147 	netdev_for_each_lower_dev(dev, lower, iter) {
2148 		if (!dsa_slave_dev_check(lower))
2149 			continue;
2150 
2151 		dp = dsa_slave_to_port(lower);
2152 		if (!dp->lag_dev)
2153 			/* Software LAG */
2154 			continue;
2155 
2156 		err = dsa_slave_prechangeupper(lower, info);
2157 		if (notifier_to_errno(err))
2158 			break;
2159 	}
2160 
2161 	return err;
2162 }
2163 
2164 static int
2165 dsa_prevent_bridging_8021q_upper(struct net_device *dev,
2166 				 struct netdev_notifier_changeupper_info *info)
2167 {
2168 	struct netlink_ext_ack *ext_ack;
2169 	struct net_device *slave, *br;
2170 	struct dsa_port *dp;
2171 
2172 	ext_ack = netdev_notifier_info_to_extack(&info->info);
2173 
2174 	if (!is_vlan_dev(dev))
2175 		return NOTIFY_DONE;
2176 
2177 	slave = vlan_dev_real_dev(dev);
2178 	if (!dsa_slave_dev_check(slave))
2179 		return NOTIFY_DONE;
2180 
2181 	dp = dsa_slave_to_port(slave);
2182 	br = dsa_port_bridge_dev_get(dp);
2183 	if (!br)
2184 		return NOTIFY_DONE;
2185 
2186 	/* Deny enslaving a VLAN device into a VLAN-aware bridge */
2187 	if (br_vlan_enabled(br) &&
2188 	    netif_is_bridge_master(info->upper_dev) && info->linking) {
2189 		NL_SET_ERR_MSG_MOD(ext_ack,
2190 				   "Cannot enslave VLAN device into VLAN aware bridge");
2191 		return notifier_from_errno(-EINVAL);
2192 	}
2193 
2194 	return NOTIFY_DONE;
2195 }
2196 
2197 static int
2198 dsa_slave_check_8021q_upper(struct net_device *dev,
2199 			    struct netdev_notifier_changeupper_info *info)
2200 {
2201 	struct dsa_port *dp = dsa_slave_to_port(dev);
2202 	struct net_device *br = dsa_port_bridge_dev_get(dp);
2203 	struct bridge_vlan_info br_info;
2204 	struct netlink_ext_ack *extack;
2205 	int err = NOTIFY_DONE;
2206 	u16 vid;
2207 
2208 	if (!br || !br_vlan_enabled(br))
2209 		return NOTIFY_DONE;
2210 
2211 	extack = netdev_notifier_info_to_extack(&info->info);
2212 	vid = vlan_dev_vlan_id(info->upper_dev);
2213 
2214 	/* br_vlan_get_info() returns -EINVAL or -ENOENT if the
2215 	 * device, respectively the VID is not found, returning
2216 	 * 0 means success, which is a failure for us here.
2217 	 */
2218 	err = br_vlan_get_info(br, vid, &br_info);
2219 	if (err == 0) {
2220 		NL_SET_ERR_MSG_MOD(extack,
2221 				   "This VLAN is already configured by the bridge");
2222 		return notifier_from_errno(-EBUSY);
2223 	}
2224 
2225 	return NOTIFY_DONE;
2226 }
2227 
2228 static int
2229 dsa_slave_prechangeupper_sanity_check(struct net_device *dev,
2230 				      struct netdev_notifier_changeupper_info *info)
2231 {
2232 	struct dsa_switch *ds;
2233 	struct dsa_port *dp;
2234 	int err;
2235 
2236 	if (!dsa_slave_dev_check(dev))
2237 		return dsa_prevent_bridging_8021q_upper(dev, info);
2238 
2239 	dp = dsa_slave_to_port(dev);
2240 	ds = dp->ds;
2241 
2242 	if (ds->ops->port_prechangeupper) {
2243 		err = ds->ops->port_prechangeupper(ds, dp->index, info);
2244 		if (err)
2245 			return notifier_from_errno(err);
2246 	}
2247 
2248 	if (is_vlan_dev(info->upper_dev))
2249 		return dsa_slave_check_8021q_upper(dev, info);
2250 
2251 	return NOTIFY_DONE;
2252 }
2253 
2254 static int dsa_slave_netdevice_event(struct notifier_block *nb,
2255 				     unsigned long event, void *ptr)
2256 {
2257 	struct net_device *dev = netdev_notifier_info_to_dev(ptr);
2258 
2259 	switch (event) {
2260 	case NETDEV_PRECHANGEUPPER: {
2261 		struct netdev_notifier_changeupper_info *info = ptr;
2262 		int err;
2263 
2264 		err = dsa_slave_prechangeupper_sanity_check(dev, info);
2265 		if (err != NOTIFY_DONE)
2266 			return err;
2267 
2268 		if (dsa_slave_dev_check(dev))
2269 			return dsa_slave_prechangeupper(dev, ptr);
2270 
2271 		if (netif_is_lag_master(dev))
2272 			return dsa_slave_lag_prechangeupper(dev, ptr);
2273 
2274 		break;
2275 	}
2276 	case NETDEV_CHANGEUPPER:
2277 		if (dsa_slave_dev_check(dev))
2278 			return dsa_slave_changeupper(dev, ptr);
2279 
2280 		if (netif_is_lag_master(dev))
2281 			return dsa_slave_lag_changeupper(dev, ptr);
2282 
2283 		break;
2284 	case NETDEV_CHANGELOWERSTATE: {
2285 		struct netdev_notifier_changelowerstate_info *info = ptr;
2286 		struct dsa_port *dp;
2287 		int err;
2288 
2289 		if (!dsa_slave_dev_check(dev))
2290 			break;
2291 
2292 		dp = dsa_slave_to_port(dev);
2293 
2294 		err = dsa_port_lag_change(dp, info->lower_state_info);
2295 		return notifier_from_errno(err);
2296 	}
2297 	case NETDEV_CHANGE:
2298 	case NETDEV_UP: {
2299 		/* Track state of master port.
2300 		 * DSA driver may require the master port (and indirectly
2301 		 * the tagger) to be available for some special operation.
2302 		 */
2303 		if (netdev_uses_dsa(dev)) {
2304 			struct dsa_port *cpu_dp = dev->dsa_ptr;
2305 			struct dsa_switch_tree *dst = cpu_dp->ds->dst;
2306 
2307 			/* Track when the master port is UP */
2308 			dsa_tree_master_oper_state_change(dst, dev,
2309 							  netif_oper_up(dev));
2310 
2311 			/* Track when the master port is ready and can accept
2312 			 * packet.
2313 			 * NETDEV_UP event is not enough to flag a port as ready.
2314 			 * We also have to wait for linkwatch_do_dev to dev_activate
2315 			 * and emit a NETDEV_CHANGE event.
2316 			 * We check if a master port is ready by checking if the dev
2317 			 * have a qdisc assigned and is not noop.
2318 			 */
2319 			dsa_tree_master_admin_state_change(dst, dev,
2320 							   !qdisc_tx_is_noop(dev));
2321 
2322 			return NOTIFY_OK;
2323 		}
2324 
2325 		return NOTIFY_DONE;
2326 	}
2327 	case NETDEV_GOING_DOWN: {
2328 		struct dsa_port *dp, *cpu_dp;
2329 		struct dsa_switch_tree *dst;
2330 		LIST_HEAD(close_list);
2331 
2332 		if (!netdev_uses_dsa(dev))
2333 			return NOTIFY_DONE;
2334 
2335 		cpu_dp = dev->dsa_ptr;
2336 		dst = cpu_dp->ds->dst;
2337 
2338 		dsa_tree_master_admin_state_change(dst, dev, false);
2339 
2340 		list_for_each_entry(dp, &dst->ports, list) {
2341 			if (!dsa_port_is_user(dp))
2342 				continue;
2343 
2344 			list_add(&dp->slave->close_list, &close_list);
2345 		}
2346 
2347 		dev_close_many(&close_list, true);
2348 
2349 		return NOTIFY_OK;
2350 	}
2351 	default:
2352 		break;
2353 	}
2354 
2355 	return NOTIFY_DONE;
2356 }
2357 
2358 static void
2359 dsa_fdb_offload_notify(struct dsa_switchdev_event_work *switchdev_work)
2360 {
2361 	struct switchdev_notifier_fdb_info info = {};
2362 	struct dsa_switch *ds = switchdev_work->ds;
2363 	struct dsa_port *dp;
2364 
2365 	if (!dsa_is_user_port(ds, switchdev_work->port))
2366 		return;
2367 
2368 	info.addr = switchdev_work->addr;
2369 	info.vid = switchdev_work->vid;
2370 	info.offloaded = true;
2371 	dp = dsa_to_port(ds, switchdev_work->port);
2372 	call_switchdev_notifiers(SWITCHDEV_FDB_OFFLOADED,
2373 				 dp->slave, &info.info, NULL);
2374 }
2375 
2376 static void dsa_slave_switchdev_event_work(struct work_struct *work)
2377 {
2378 	struct dsa_switchdev_event_work *switchdev_work =
2379 		container_of(work, struct dsa_switchdev_event_work, work);
2380 	struct dsa_switch *ds = switchdev_work->ds;
2381 	struct dsa_port *dp;
2382 	int err;
2383 
2384 	dp = dsa_to_port(ds, switchdev_work->port);
2385 
2386 	switch (switchdev_work->event) {
2387 	case SWITCHDEV_FDB_ADD_TO_DEVICE:
2388 		if (switchdev_work->host_addr)
2389 			err = dsa_port_host_fdb_add(dp, switchdev_work->addr,
2390 						    switchdev_work->vid);
2391 		else
2392 			err = dsa_port_fdb_add(dp, switchdev_work->addr,
2393 					       switchdev_work->vid);
2394 		if (err) {
2395 			dev_err(ds->dev,
2396 				"port %d failed to add %pM vid %d to fdb: %d\n",
2397 				dp->index, switchdev_work->addr,
2398 				switchdev_work->vid, err);
2399 			break;
2400 		}
2401 		dsa_fdb_offload_notify(switchdev_work);
2402 		break;
2403 
2404 	case SWITCHDEV_FDB_DEL_TO_DEVICE:
2405 		if (switchdev_work->host_addr)
2406 			err = dsa_port_host_fdb_del(dp, switchdev_work->addr,
2407 						    switchdev_work->vid);
2408 		else
2409 			err = dsa_port_fdb_del(dp, switchdev_work->addr,
2410 					       switchdev_work->vid);
2411 		if (err) {
2412 			dev_err(ds->dev,
2413 				"port %d failed to delete %pM vid %d from fdb: %d\n",
2414 				dp->index, switchdev_work->addr,
2415 				switchdev_work->vid, err);
2416 		}
2417 
2418 		break;
2419 	}
2420 
2421 	kfree(switchdev_work);
2422 }
2423 
2424 static bool dsa_foreign_dev_check(const struct net_device *dev,
2425 				  const struct net_device *foreign_dev)
2426 {
2427 	const struct dsa_port *dp = dsa_slave_to_port(dev);
2428 	struct dsa_switch_tree *dst = dp->ds->dst;
2429 
2430 	if (netif_is_bridge_master(foreign_dev))
2431 		return !dsa_tree_offloads_bridge_dev(dst, foreign_dev);
2432 
2433 	if (netif_is_bridge_port(foreign_dev))
2434 		return !dsa_tree_offloads_bridge_port(dst, foreign_dev);
2435 
2436 	/* Everything else is foreign */
2437 	return true;
2438 }
2439 
2440 static int dsa_slave_fdb_event(struct net_device *dev,
2441 			       struct net_device *orig_dev,
2442 			       unsigned long event, const void *ctx,
2443 			       const struct switchdev_notifier_fdb_info *fdb_info)
2444 {
2445 	struct dsa_switchdev_event_work *switchdev_work;
2446 	struct dsa_port *dp = dsa_slave_to_port(dev);
2447 	bool host_addr = fdb_info->is_local;
2448 	struct dsa_switch *ds = dp->ds;
2449 
2450 	if (ctx && ctx != dp)
2451 		return 0;
2452 
2453 	if (!ds->ops->port_fdb_add || !ds->ops->port_fdb_del)
2454 		return -EOPNOTSUPP;
2455 
2456 	if (dsa_slave_dev_check(orig_dev) &&
2457 	    switchdev_fdb_is_dynamically_learned(fdb_info))
2458 		return 0;
2459 
2460 	/* FDB entries learned by the software bridge should be installed as
2461 	 * host addresses only if the driver requests assisted learning.
2462 	 */
2463 	if (switchdev_fdb_is_dynamically_learned(fdb_info) &&
2464 	    !ds->assisted_learning_on_cpu_port)
2465 		return 0;
2466 
2467 	/* Also treat FDB entries on foreign interfaces bridged with us as host
2468 	 * addresses.
2469 	 */
2470 	if (dsa_foreign_dev_check(dev, orig_dev))
2471 		host_addr = true;
2472 
2473 	switchdev_work = kzalloc(sizeof(*switchdev_work), GFP_ATOMIC);
2474 	if (!switchdev_work)
2475 		return -ENOMEM;
2476 
2477 	netdev_dbg(dev, "%s FDB entry towards %s, addr %pM vid %d%s\n",
2478 		   event == SWITCHDEV_FDB_ADD_TO_DEVICE ? "Adding" : "Deleting",
2479 		   orig_dev->name, fdb_info->addr, fdb_info->vid,
2480 		   host_addr ? " as host address" : "");
2481 
2482 	INIT_WORK(&switchdev_work->work, dsa_slave_switchdev_event_work);
2483 	switchdev_work->ds = ds;
2484 	switchdev_work->port = dp->index;
2485 	switchdev_work->event = event;
2486 	switchdev_work->dev = dev;
2487 
2488 	ether_addr_copy(switchdev_work->addr, fdb_info->addr);
2489 	switchdev_work->vid = fdb_info->vid;
2490 	switchdev_work->host_addr = host_addr;
2491 
2492 	dsa_schedule_work(&switchdev_work->work);
2493 
2494 	return 0;
2495 }
2496 
2497 /* Called under rcu_read_lock() */
2498 static int dsa_slave_switchdev_event(struct notifier_block *unused,
2499 				     unsigned long event, void *ptr)
2500 {
2501 	struct net_device *dev = switchdev_notifier_info_to_dev(ptr);
2502 	int err;
2503 
2504 	switch (event) {
2505 	case SWITCHDEV_PORT_ATTR_SET:
2506 		err = switchdev_handle_port_attr_set(dev, ptr,
2507 						     dsa_slave_dev_check,
2508 						     dsa_slave_port_attr_set);
2509 		return notifier_from_errno(err);
2510 	case SWITCHDEV_FDB_ADD_TO_DEVICE:
2511 	case SWITCHDEV_FDB_DEL_TO_DEVICE:
2512 		err = switchdev_handle_fdb_event_to_device(dev, event, ptr,
2513 							   dsa_slave_dev_check,
2514 							   dsa_foreign_dev_check,
2515 							   dsa_slave_fdb_event,
2516 							   NULL);
2517 		return notifier_from_errno(err);
2518 	default:
2519 		return NOTIFY_DONE;
2520 	}
2521 
2522 	return NOTIFY_OK;
2523 }
2524 
2525 static int dsa_slave_switchdev_blocking_event(struct notifier_block *unused,
2526 					      unsigned long event, void *ptr)
2527 {
2528 	struct net_device *dev = switchdev_notifier_info_to_dev(ptr);
2529 	int err;
2530 
2531 	switch (event) {
2532 	case SWITCHDEV_PORT_OBJ_ADD:
2533 		err = switchdev_handle_port_obj_add(dev, ptr,
2534 						    dsa_slave_dev_check,
2535 						    dsa_slave_port_obj_add);
2536 		return notifier_from_errno(err);
2537 	case SWITCHDEV_PORT_OBJ_DEL:
2538 		err = switchdev_handle_port_obj_del(dev, ptr,
2539 						    dsa_slave_dev_check,
2540 						    dsa_slave_port_obj_del);
2541 		return notifier_from_errno(err);
2542 	case SWITCHDEV_PORT_ATTR_SET:
2543 		err = switchdev_handle_port_attr_set(dev, ptr,
2544 						     dsa_slave_dev_check,
2545 						     dsa_slave_port_attr_set);
2546 		return notifier_from_errno(err);
2547 	}
2548 
2549 	return NOTIFY_DONE;
2550 }
2551 
2552 static struct notifier_block dsa_slave_nb __read_mostly = {
2553 	.notifier_call  = dsa_slave_netdevice_event,
2554 };
2555 
2556 struct notifier_block dsa_slave_switchdev_notifier = {
2557 	.notifier_call = dsa_slave_switchdev_event,
2558 };
2559 
2560 struct notifier_block dsa_slave_switchdev_blocking_notifier = {
2561 	.notifier_call = dsa_slave_switchdev_blocking_event,
2562 };
2563 
2564 int dsa_slave_register_notifier(void)
2565 {
2566 	struct notifier_block *nb;
2567 	int err;
2568 
2569 	err = register_netdevice_notifier(&dsa_slave_nb);
2570 	if (err)
2571 		return err;
2572 
2573 	err = register_switchdev_notifier(&dsa_slave_switchdev_notifier);
2574 	if (err)
2575 		goto err_switchdev_nb;
2576 
2577 	nb = &dsa_slave_switchdev_blocking_notifier;
2578 	err = register_switchdev_blocking_notifier(nb);
2579 	if (err)
2580 		goto err_switchdev_blocking_nb;
2581 
2582 	return 0;
2583 
2584 err_switchdev_blocking_nb:
2585 	unregister_switchdev_notifier(&dsa_slave_switchdev_notifier);
2586 err_switchdev_nb:
2587 	unregister_netdevice_notifier(&dsa_slave_nb);
2588 	return err;
2589 }
2590 
2591 void dsa_slave_unregister_notifier(void)
2592 {
2593 	struct notifier_block *nb;
2594 	int err;
2595 
2596 	nb = &dsa_slave_switchdev_blocking_notifier;
2597 	err = unregister_switchdev_blocking_notifier(nb);
2598 	if (err)
2599 		pr_err("DSA: failed to unregister switchdev blocking notifier (%d)\n", err);
2600 
2601 	err = unregister_switchdev_notifier(&dsa_slave_switchdev_notifier);
2602 	if (err)
2603 		pr_err("DSA: failed to unregister switchdev notifier (%d)\n", err);
2604 
2605 	err = unregister_netdevice_notifier(&dsa_slave_nb);
2606 	if (err)
2607 		pr_err("DSA: failed to unregister slave notifier (%d)\n", err);
2608 }
2609