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