1 // SPDX-License-Identifier: GPL-2.0+
2 /* Microchip Sparx5 Switch driver
3  *
4  * Copyright (c) 2021 Microchip Technology Inc. and its subsidiaries.
5  */
6 
7 #include <linux/if_bridge.h>
8 #include <net/switchdev.h>
9 
10 #include "sparx5_main_regs.h"
11 #include "sparx5_main.h"
12 
13 static struct workqueue_struct *sparx5_owq;
14 
15 struct sparx5_switchdev_event_work {
16 	struct work_struct work;
17 	struct switchdev_notifier_fdb_info fdb_info;
18 	struct net_device *dev;
19 	struct sparx5 *sparx5;
20 	unsigned long event;
21 };
22 
23 static int sparx5_port_attr_pre_bridge_flags(struct sparx5_port *port,
24 					     struct switchdev_brport_flags flags)
25 {
26 	if (flags.mask & ~(BR_FLOOD | BR_MCAST_FLOOD | BR_BCAST_FLOOD))
27 		return -EINVAL;
28 
29 	return 0;
30 }
31 
32 static void sparx5_port_update_mcast_ip_flood(struct sparx5_port *port, bool flood_flag)
33 {
34 	bool should_flood = flood_flag || port->is_mrouter;
35 	int pgid;
36 
37 	for (pgid = PGID_IPV4_MC_DATA; pgid <= PGID_IPV6_MC_CTRL; pgid++)
38 		sparx5_pgid_update_mask(port, pgid, should_flood);
39 }
40 
41 static void sparx5_port_attr_bridge_flags(struct sparx5_port *port,
42 					  struct switchdev_brport_flags flags)
43 {
44 	if (flags.mask & BR_MCAST_FLOOD) {
45 		sparx5_pgid_update_mask(port, PGID_MC_FLOOD, !!(flags.val & BR_MCAST_FLOOD));
46 		sparx5_port_update_mcast_ip_flood(port, !!(flags.val & BR_MCAST_FLOOD));
47 	}
48 
49 	if (flags.mask & BR_FLOOD)
50 		sparx5_pgid_update_mask(port, PGID_UC_FLOOD, !!(flags.val & BR_FLOOD));
51 	if (flags.mask & BR_BCAST_FLOOD)
52 		sparx5_pgid_update_mask(port, PGID_BCAST, !!(flags.val & BR_BCAST_FLOOD));
53 }
54 
55 static void sparx5_attr_stp_state_set(struct sparx5_port *port,
56 				      u8 state)
57 {
58 	struct sparx5 *sparx5 = port->sparx5;
59 
60 	if (!test_bit(port->portno, sparx5->bridge_mask)) {
61 		netdev_err(port->ndev,
62 			   "Controlling non-bridged port %d?\n", port->portno);
63 		return;
64 	}
65 
66 	switch (state) {
67 	case BR_STATE_FORWARDING:
68 		set_bit(port->portno, sparx5->bridge_fwd_mask);
69 		fallthrough;
70 	case BR_STATE_LEARNING:
71 		set_bit(port->portno, sparx5->bridge_lrn_mask);
72 		break;
73 
74 	default:
75 		/* All other states treated as blocking */
76 		clear_bit(port->portno, sparx5->bridge_fwd_mask);
77 		clear_bit(port->portno, sparx5->bridge_lrn_mask);
78 		break;
79 	}
80 
81 	/* apply the bridge_fwd_mask to all the ports */
82 	sparx5_update_fwd(sparx5);
83 }
84 
85 static void sparx5_port_attr_ageing_set(struct sparx5_port *port,
86 					unsigned long ageing_clock_t)
87 {
88 	unsigned long ageing_jiffies = clock_t_to_jiffies(ageing_clock_t);
89 	u32 ageing_time = jiffies_to_msecs(ageing_jiffies);
90 
91 	sparx5_set_ageing(port->sparx5, ageing_time);
92 }
93 
94 static void sparx5_port_attr_mrouter_set(struct sparx5_port *port,
95 					 struct net_device *orig_dev,
96 					 bool enable)
97 {
98 	struct sparx5 *sparx5 = port->sparx5;
99 	struct sparx5_mdb_entry *e;
100 	bool flood_flag;
101 
102 	if ((enable && port->is_mrouter) || (!enable && !port->is_mrouter))
103 		return;
104 
105 	/* Add/del mrouter port on all active mdb entries in HW.
106 	 * Don't change entry port mask, since that represents
107 	 * ports that actually joined that group.
108 	 */
109 	mutex_lock(&sparx5->mdb_lock);
110 	list_for_each_entry(e, &sparx5->mdb_entries, list) {
111 		if (!test_bit(port->portno, e->port_mask) &&
112 		    ether_addr_is_ip_mcast(e->addr))
113 			sparx5_pgid_update_mask(port, e->pgid_idx, enable);
114 	}
115 	mutex_unlock(&sparx5->mdb_lock);
116 
117 	/* Enable/disable flooding depending on if port is mrouter port
118 	 * or if mcast flood is enabled.
119 	 */
120 	port->is_mrouter = enable;
121 	flood_flag = br_port_flag_is_set(port->ndev, BR_MCAST_FLOOD);
122 	sparx5_port_update_mcast_ip_flood(port, flood_flag);
123 }
124 
125 static int sparx5_port_attr_set(struct net_device *dev, const void *ctx,
126 				const struct switchdev_attr *attr,
127 				struct netlink_ext_ack *extack)
128 {
129 	struct sparx5_port *port = netdev_priv(dev);
130 
131 	switch (attr->id) {
132 	case SWITCHDEV_ATTR_ID_PORT_PRE_BRIDGE_FLAGS:
133 		return sparx5_port_attr_pre_bridge_flags(port,
134 							 attr->u.brport_flags);
135 	case SWITCHDEV_ATTR_ID_PORT_BRIDGE_FLAGS:
136 		sparx5_port_attr_bridge_flags(port, attr->u.brport_flags);
137 		break;
138 	case SWITCHDEV_ATTR_ID_PORT_STP_STATE:
139 		sparx5_attr_stp_state_set(port, attr->u.stp_state);
140 		break;
141 	case SWITCHDEV_ATTR_ID_BRIDGE_AGEING_TIME:
142 		sparx5_port_attr_ageing_set(port, attr->u.ageing_time);
143 		break;
144 	case SWITCHDEV_ATTR_ID_BRIDGE_VLAN_FILTERING:
145 		/* Used PVID 1 when default_pvid is 0, to avoid
146 		 * collision with non-bridged ports.
147 		 */
148 		if (port->pvid == 0)
149 			port->pvid = 1;
150 		port->vlan_aware = attr->u.vlan_filtering;
151 		sparx5_vlan_port_apply(port->sparx5, port);
152 		break;
153 	case SWITCHDEV_ATTR_ID_PORT_MROUTER:
154 		sparx5_port_attr_mrouter_set(port,
155 					     attr->orig_dev,
156 					     attr->u.mrouter);
157 		break;
158 	default:
159 		return -EOPNOTSUPP;
160 	}
161 
162 	return 0;
163 }
164 
165 static int sparx5_port_bridge_join(struct sparx5_port *port,
166 				   struct net_device *bridge,
167 				   struct netlink_ext_ack *extack)
168 {
169 	struct sparx5 *sparx5 = port->sparx5;
170 	struct net_device *ndev = port->ndev;
171 	int err;
172 
173 	if (bitmap_empty(sparx5->bridge_mask, SPX5_PORTS))
174 		/* First bridged port */
175 		sparx5->hw_bridge_dev = bridge;
176 	else
177 		if (sparx5->hw_bridge_dev != bridge)
178 			/* This is adding the port to a second bridge, this is
179 			 * unsupported
180 			 */
181 			return -ENODEV;
182 
183 	set_bit(port->portno, sparx5->bridge_mask);
184 
185 	err = switchdev_bridge_port_offload(ndev, ndev, NULL, NULL, NULL,
186 					    false, extack);
187 	if (err)
188 		goto err_switchdev_offload;
189 
190 	/* Remove standalone port entry */
191 	sparx5_mact_forget(sparx5, ndev->dev_addr, 0);
192 
193 	/* Port enters in bridge mode therefor don't need to copy to CPU
194 	 * frames for multicast in case the bridge is not requesting them
195 	 */
196 	__dev_mc_unsync(ndev, sparx5_mc_unsync);
197 
198 	return 0;
199 
200 err_switchdev_offload:
201 	clear_bit(port->portno, sparx5->bridge_mask);
202 	return err;
203 }
204 
205 static void sparx5_port_bridge_leave(struct sparx5_port *port,
206 				     struct net_device *bridge)
207 {
208 	struct sparx5 *sparx5 = port->sparx5;
209 
210 	switchdev_bridge_port_unoffload(port->ndev, NULL, NULL, NULL);
211 
212 	clear_bit(port->portno, sparx5->bridge_mask);
213 	if (bitmap_empty(sparx5->bridge_mask, SPX5_PORTS))
214 		sparx5->hw_bridge_dev = NULL;
215 
216 	/* Clear bridge vlan settings before updating the port settings */
217 	port->vlan_aware = 0;
218 	port->pvid = NULL_VID;
219 	port->vid = NULL_VID;
220 
221 	/* Forward frames to CPU */
222 	sparx5_mact_learn(sparx5, PGID_CPU, port->ndev->dev_addr, 0);
223 
224 	/* Port enters in host more therefore restore mc list */
225 	__dev_mc_sync(port->ndev, sparx5_mc_sync, sparx5_mc_unsync);
226 }
227 
228 static int sparx5_port_changeupper(struct net_device *dev,
229 				   struct netdev_notifier_changeupper_info *info)
230 {
231 	struct sparx5_port *port = netdev_priv(dev);
232 	struct netlink_ext_ack *extack;
233 	int err = 0;
234 
235 	extack = netdev_notifier_info_to_extack(&info->info);
236 
237 	if (netif_is_bridge_master(info->upper_dev)) {
238 		if (info->linking)
239 			err = sparx5_port_bridge_join(port, info->upper_dev,
240 						      extack);
241 		else
242 			sparx5_port_bridge_leave(port, info->upper_dev);
243 
244 		sparx5_vlan_port_apply(port->sparx5, port);
245 	}
246 
247 	return err;
248 }
249 
250 static int sparx5_port_add_addr(struct net_device *dev, bool up)
251 {
252 	struct sparx5_port *port = netdev_priv(dev);
253 	struct sparx5 *sparx5 = port->sparx5;
254 	u16 vid = port->pvid;
255 
256 	if (up)
257 		sparx5_mact_learn(sparx5, PGID_CPU, port->ndev->dev_addr, vid);
258 	else
259 		sparx5_mact_forget(sparx5, port->ndev->dev_addr, vid);
260 
261 	return 0;
262 }
263 
264 static int sparx5_netdevice_port_event(struct net_device *dev,
265 				       struct notifier_block *nb,
266 				       unsigned long event, void *ptr)
267 {
268 	int err = 0;
269 
270 	if (!sparx5_netdevice_check(dev))
271 		return 0;
272 
273 	switch (event) {
274 	case NETDEV_CHANGEUPPER:
275 		err = sparx5_port_changeupper(dev, ptr);
276 		break;
277 	case NETDEV_PRE_UP:
278 		err = sparx5_port_add_addr(dev, true);
279 		break;
280 	case NETDEV_DOWN:
281 		err = sparx5_port_add_addr(dev, false);
282 		break;
283 	}
284 
285 	return err;
286 }
287 
288 static int sparx5_netdevice_event(struct notifier_block *nb,
289 				  unsigned long event, void *ptr)
290 {
291 	struct net_device *dev = netdev_notifier_info_to_dev(ptr);
292 	int ret = 0;
293 
294 	ret = sparx5_netdevice_port_event(dev, nb, event, ptr);
295 
296 	return notifier_from_errno(ret);
297 }
298 
299 static void sparx5_switchdev_bridge_fdb_event_work(struct work_struct *work)
300 {
301 	struct sparx5_switchdev_event_work *switchdev_work =
302 		container_of(work, struct sparx5_switchdev_event_work, work);
303 	struct net_device *dev = switchdev_work->dev;
304 	struct switchdev_notifier_fdb_info *fdb_info;
305 	struct sparx5_port *port;
306 	struct sparx5 *sparx5;
307 	bool host_addr;
308 	u16 vid;
309 
310 	rtnl_lock();
311 	if (!sparx5_netdevice_check(dev)) {
312 		host_addr = true;
313 		sparx5 = switchdev_work->sparx5;
314 	} else {
315 		host_addr = false;
316 		sparx5 = switchdev_work->sparx5;
317 		port = netdev_priv(dev);
318 	}
319 
320 	fdb_info = &switchdev_work->fdb_info;
321 
322 	/* Used PVID 1 when default_pvid is 0, to avoid
323 	 * collision with non-bridged ports.
324 	 */
325 	if (fdb_info->vid == 0)
326 		vid = 1;
327 	else
328 		vid = fdb_info->vid;
329 
330 	switch (switchdev_work->event) {
331 	case SWITCHDEV_FDB_ADD_TO_DEVICE:
332 		if (host_addr)
333 			sparx5_add_mact_entry(sparx5, dev, PGID_CPU,
334 					      fdb_info->addr, vid);
335 		else
336 			sparx5_add_mact_entry(sparx5, port->ndev, port->portno,
337 					      fdb_info->addr, vid);
338 		break;
339 	case SWITCHDEV_FDB_DEL_TO_DEVICE:
340 		sparx5_del_mact_entry(sparx5, fdb_info->addr, vid);
341 		break;
342 	}
343 
344 	rtnl_unlock();
345 	kfree(switchdev_work->fdb_info.addr);
346 	kfree(switchdev_work);
347 	dev_put(dev);
348 }
349 
350 static void sparx5_schedule_work(struct work_struct *work)
351 {
352 	queue_work(sparx5_owq, work);
353 }
354 
355 static int sparx5_switchdev_event(struct notifier_block *nb,
356 				  unsigned long event, void *ptr)
357 {
358 	struct net_device *dev = switchdev_notifier_info_to_dev(ptr);
359 	struct sparx5_switchdev_event_work *switchdev_work;
360 	struct switchdev_notifier_fdb_info *fdb_info;
361 	struct switchdev_notifier_info *info = ptr;
362 	struct sparx5 *spx5;
363 	int err;
364 
365 	spx5 = container_of(nb, struct sparx5, switchdev_nb);
366 
367 	switch (event) {
368 	case SWITCHDEV_PORT_ATTR_SET:
369 		err = switchdev_handle_port_attr_set(dev, ptr,
370 						     sparx5_netdevice_check,
371 						     sparx5_port_attr_set);
372 		return notifier_from_errno(err);
373 	case SWITCHDEV_FDB_ADD_TO_DEVICE:
374 		fallthrough;
375 	case SWITCHDEV_FDB_DEL_TO_DEVICE:
376 		switchdev_work = kzalloc(sizeof(*switchdev_work), GFP_ATOMIC);
377 		if (!switchdev_work)
378 			return NOTIFY_BAD;
379 
380 		switchdev_work->dev = dev;
381 		switchdev_work->event = event;
382 		switchdev_work->sparx5 = spx5;
383 
384 		fdb_info = container_of(info,
385 					struct switchdev_notifier_fdb_info,
386 					info);
387 		INIT_WORK(&switchdev_work->work,
388 			  sparx5_switchdev_bridge_fdb_event_work);
389 		memcpy(&switchdev_work->fdb_info, ptr,
390 		       sizeof(switchdev_work->fdb_info));
391 		switchdev_work->fdb_info.addr = kzalloc(ETH_ALEN, GFP_ATOMIC);
392 		if (!switchdev_work->fdb_info.addr)
393 			goto err_addr_alloc;
394 
395 		ether_addr_copy((u8 *)switchdev_work->fdb_info.addr,
396 				fdb_info->addr);
397 		dev_hold(dev);
398 
399 		sparx5_schedule_work(&switchdev_work->work);
400 		break;
401 	}
402 
403 	return NOTIFY_DONE;
404 err_addr_alloc:
405 	kfree(switchdev_work);
406 	return NOTIFY_BAD;
407 }
408 
409 static int sparx5_handle_port_vlan_add(struct net_device *dev,
410 				       struct notifier_block *nb,
411 				       const struct switchdev_obj_port_vlan *v)
412 {
413 	struct sparx5_port *port = netdev_priv(dev);
414 
415 	if (netif_is_bridge_master(dev)) {
416 		struct sparx5 *sparx5 =
417 			container_of(nb, struct sparx5,
418 				     switchdev_blocking_nb);
419 
420 		/* Flood broadcast to CPU */
421 		sparx5_mact_learn(sparx5, PGID_BCAST, dev->broadcast,
422 				  v->vid);
423 		return 0;
424 	}
425 
426 	if (!sparx5_netdevice_check(dev))
427 		return -EOPNOTSUPP;
428 
429 	return sparx5_vlan_vid_add(port, v->vid,
430 				  v->flags & BRIDGE_VLAN_INFO_PVID,
431 				  v->flags & BRIDGE_VLAN_INFO_UNTAGGED);
432 }
433 
434 static int sparx5_alloc_mdb_entry(struct sparx5 *sparx5,
435 				  const unsigned char *addr,
436 				  u16 vid,
437 				  struct sparx5_mdb_entry **entry_out)
438 {
439 	struct sparx5_mdb_entry *entry;
440 	u16 pgid_idx;
441 	int err;
442 
443 	entry = kzalloc(sizeof(*entry), GFP_KERNEL);
444 	if (!entry)
445 		return -ENOMEM;
446 
447 	err = sparx5_pgid_alloc_mcast(sparx5, &pgid_idx);
448 	if (err) {
449 		kfree(entry);
450 		return err;
451 	}
452 
453 	memcpy(entry->addr, addr, ETH_ALEN);
454 	entry->vid = vid;
455 	entry->pgid_idx = pgid_idx;
456 
457 	mutex_lock(&sparx5->mdb_lock);
458 	list_add_tail(&entry->list, &sparx5->mdb_entries);
459 	mutex_unlock(&sparx5->mdb_lock);
460 
461 	*entry_out = entry;
462 	return 0;
463 }
464 
465 static void sparx5_free_mdb_entry(struct sparx5 *sparx5,
466 				  const unsigned char *addr,
467 				  u16 vid)
468 {
469 	struct sparx5_mdb_entry *entry, *tmp;
470 
471 	mutex_lock(&sparx5->mdb_lock);
472 	list_for_each_entry_safe(entry, tmp, &sparx5->mdb_entries, list) {
473 		if ((vid == 0 || entry->vid == vid) &&
474 		    ether_addr_equal(addr, entry->addr)) {
475 			list_del(&entry->list);
476 
477 			sparx5_pgid_free(sparx5, entry->pgid_idx);
478 			kfree(entry);
479 			goto out;
480 		}
481 	}
482 
483 out:
484 	mutex_unlock(&sparx5->mdb_lock);
485 }
486 
487 static struct sparx5_mdb_entry *sparx5_mdb_get_entry(struct sparx5 *sparx5,
488 						     const unsigned char *addr,
489 						     u16 vid)
490 {
491 	struct sparx5_mdb_entry *e, *found = NULL;
492 
493 	mutex_lock(&sparx5->mdb_lock);
494 	list_for_each_entry(e, &sparx5->mdb_entries, list) {
495 		if (ether_addr_equal(e->addr, addr) && e->vid == vid) {
496 			found = e;
497 			goto out;
498 		}
499 	}
500 
501 out:
502 	mutex_unlock(&sparx5->mdb_lock);
503 	return found;
504 }
505 
506 static void sparx5_cpu_copy_ena(struct sparx5 *spx5, u16 pgid, bool enable)
507 {
508 	spx5_rmw(ANA_AC_PGID_MISC_CFG_PGID_CPU_COPY_ENA_SET(enable),
509 		 ANA_AC_PGID_MISC_CFG_PGID_CPU_COPY_ENA, spx5,
510 		 ANA_AC_PGID_MISC_CFG(pgid));
511 }
512 
513 static int sparx5_handle_port_mdb_add(struct net_device *dev,
514 				      struct notifier_block *nb,
515 				      const struct switchdev_obj_port_mdb *v)
516 {
517 	struct sparx5_port *port = netdev_priv(dev);
518 	struct sparx5 *spx5 = port->sparx5;
519 	struct sparx5_mdb_entry *entry;
520 	bool is_host, is_new;
521 	int err, i;
522 	u16 vid;
523 
524 	if (!sparx5_netdevice_check(dev))
525 		return -EOPNOTSUPP;
526 
527 	is_host = netif_is_bridge_master(v->obj.orig_dev);
528 
529 	/* When VLAN unaware the vlan value is not parsed and we receive vid 0.
530 	 * Fall back to bridge vid 1.
531 	 */
532 	if (!br_vlan_enabled(spx5->hw_bridge_dev))
533 		vid = 1;
534 	else
535 		vid = v->vid;
536 
537 	is_new = false;
538 	entry = sparx5_mdb_get_entry(spx5, v->addr, vid);
539 	if (!entry) {
540 		err = sparx5_alloc_mdb_entry(spx5, v->addr, vid, &entry);
541 		is_new = true;
542 		if (err)
543 			return err;
544 	}
545 
546 	mutex_lock(&spx5->mdb_lock);
547 
548 	/* Add any mrouter ports to the new entry */
549 	if (is_new && ether_addr_is_ip_mcast(v->addr))
550 		for (i = 0; i < SPX5_PORTS; i++)
551 			if (spx5->ports[i] && spx5->ports[i]->is_mrouter)
552 				sparx5_pgid_update_mask(spx5->ports[i],
553 							entry->pgid_idx,
554 							true);
555 
556 	if (is_host && !entry->cpu_copy) {
557 		sparx5_cpu_copy_ena(spx5, entry->pgid_idx, true);
558 		entry->cpu_copy = true;
559 	} else if (!is_host) {
560 		sparx5_pgid_update_mask(port, entry->pgid_idx, true);
561 		set_bit(port->portno, entry->port_mask);
562 	}
563 	mutex_unlock(&spx5->mdb_lock);
564 
565 	sparx5_mact_learn(spx5, entry->pgid_idx, entry->addr, entry->vid);
566 
567 	return 0;
568 }
569 
570 static int sparx5_handle_port_mdb_del(struct net_device *dev,
571 				      struct notifier_block *nb,
572 				      const struct switchdev_obj_port_mdb *v)
573 {
574 	struct sparx5_port *port = netdev_priv(dev);
575 	struct sparx5 *spx5 = port->sparx5;
576 	struct sparx5_mdb_entry *entry;
577 	bool is_host;
578 	u16 vid;
579 
580 	if (!sparx5_netdevice_check(dev))
581 		return -EOPNOTSUPP;
582 
583 	is_host = netif_is_bridge_master(v->obj.orig_dev);
584 
585 	if (!br_vlan_enabled(spx5->hw_bridge_dev))
586 		vid = 1;
587 	else
588 		vid = v->vid;
589 
590 	entry = sparx5_mdb_get_entry(spx5, v->addr, vid);
591 	if (!entry)
592 		return 0;
593 
594 	mutex_lock(&spx5->mdb_lock);
595 	if (is_host && entry->cpu_copy) {
596 		sparx5_cpu_copy_ena(spx5, entry->pgid_idx, false);
597 		entry->cpu_copy = false;
598 	} else if (!is_host) {
599 		clear_bit(port->portno, entry->port_mask);
600 
601 		/* Port not mrouter port or addr is L2 mcast, remove port from mask. */
602 		if (!port->is_mrouter || !ether_addr_is_ip_mcast(v->addr))
603 			sparx5_pgid_update_mask(port, entry->pgid_idx, false);
604 	}
605 	mutex_unlock(&spx5->mdb_lock);
606 
607 	if (bitmap_empty(entry->port_mask, SPX5_PORTS) && !entry->cpu_copy) {
608 		 /* Clear pgid in case mrouter ports exists
609 		  * that are not part of the group.
610 		  */
611 		sparx5_pgid_clear(spx5, entry->pgid_idx);
612 		sparx5_mact_forget(spx5, entry->addr, entry->vid);
613 		sparx5_free_mdb_entry(spx5, entry->addr, entry->vid);
614 	}
615 	return 0;
616 }
617 
618 static int sparx5_handle_port_obj_add(struct net_device *dev,
619 				      struct notifier_block *nb,
620 				      struct switchdev_notifier_port_obj_info *info)
621 {
622 	const struct switchdev_obj *obj = info->obj;
623 	int err;
624 
625 	switch (obj->id) {
626 	case SWITCHDEV_OBJ_ID_PORT_VLAN:
627 		err = sparx5_handle_port_vlan_add(dev, nb,
628 						  SWITCHDEV_OBJ_PORT_VLAN(obj));
629 		break;
630 	case SWITCHDEV_OBJ_ID_PORT_MDB:
631 	case SWITCHDEV_OBJ_ID_HOST_MDB:
632 		err = sparx5_handle_port_mdb_add(dev, nb,
633 						 SWITCHDEV_OBJ_PORT_MDB(obj));
634 		break;
635 	default:
636 		err = -EOPNOTSUPP;
637 		break;
638 	}
639 
640 	info->handled = true;
641 	return err;
642 }
643 
644 static int sparx5_handle_port_vlan_del(struct net_device *dev,
645 				       struct notifier_block *nb,
646 				       u16 vid)
647 {
648 	struct sparx5_port *port = netdev_priv(dev);
649 	int ret;
650 
651 	/* Master bridge? */
652 	if (netif_is_bridge_master(dev)) {
653 		struct sparx5 *sparx5 =
654 			container_of(nb, struct sparx5,
655 				     switchdev_blocking_nb);
656 
657 		sparx5_mact_forget(sparx5, dev->broadcast, vid);
658 		return 0;
659 	}
660 
661 	if (!sparx5_netdevice_check(dev))
662 		return -EOPNOTSUPP;
663 
664 	ret = sparx5_vlan_vid_del(port, vid);
665 	if (ret)
666 		return ret;
667 
668 	return 0;
669 }
670 
671 static int sparx5_handle_port_obj_del(struct net_device *dev,
672 				      struct notifier_block *nb,
673 				      struct switchdev_notifier_port_obj_info *info)
674 {
675 	const struct switchdev_obj *obj = info->obj;
676 	int err;
677 
678 	switch (obj->id) {
679 	case SWITCHDEV_OBJ_ID_PORT_VLAN:
680 		err = sparx5_handle_port_vlan_del(dev, nb,
681 						  SWITCHDEV_OBJ_PORT_VLAN(obj)->vid);
682 		break;
683 	case SWITCHDEV_OBJ_ID_PORT_MDB:
684 	case SWITCHDEV_OBJ_ID_HOST_MDB:
685 		err = sparx5_handle_port_mdb_del(dev, nb,
686 						 SWITCHDEV_OBJ_PORT_MDB(obj));
687 		break;
688 	default:
689 		err = -EOPNOTSUPP;
690 		break;
691 	}
692 
693 	info->handled = true;
694 	return err;
695 }
696 
697 static int sparx5_switchdev_blocking_event(struct notifier_block *nb,
698 					   unsigned long event,
699 					   void *ptr)
700 {
701 	struct net_device *dev = switchdev_notifier_info_to_dev(ptr);
702 	int err;
703 
704 	switch (event) {
705 	case SWITCHDEV_PORT_OBJ_ADD:
706 		err = sparx5_handle_port_obj_add(dev, nb, ptr);
707 		return notifier_from_errno(err);
708 	case SWITCHDEV_PORT_OBJ_DEL:
709 		err = sparx5_handle_port_obj_del(dev, nb, ptr);
710 		return notifier_from_errno(err);
711 	case SWITCHDEV_PORT_ATTR_SET:
712 		err = switchdev_handle_port_attr_set(dev, ptr,
713 						     sparx5_netdevice_check,
714 						     sparx5_port_attr_set);
715 		return notifier_from_errno(err);
716 	}
717 
718 	return NOTIFY_DONE;
719 }
720 
721 int sparx5_register_notifier_blocks(struct sparx5 *s5)
722 {
723 	int err;
724 
725 	s5->netdevice_nb.notifier_call = sparx5_netdevice_event;
726 	err = register_netdevice_notifier(&s5->netdevice_nb);
727 	if (err)
728 		return err;
729 
730 	s5->switchdev_nb.notifier_call = sparx5_switchdev_event;
731 	err = register_switchdev_notifier(&s5->switchdev_nb);
732 	if (err)
733 		goto err_switchdev_nb;
734 
735 	s5->switchdev_blocking_nb.notifier_call = sparx5_switchdev_blocking_event;
736 	err = register_switchdev_blocking_notifier(&s5->switchdev_blocking_nb);
737 	if (err)
738 		goto err_switchdev_blocking_nb;
739 
740 	sparx5_owq = alloc_ordered_workqueue("sparx5_order", 0);
741 	if (!sparx5_owq) {
742 		err = -ENOMEM;
743 		goto err_switchdev_blocking_nb;
744 	}
745 
746 	return 0;
747 
748 err_switchdev_blocking_nb:
749 	unregister_switchdev_notifier(&s5->switchdev_nb);
750 err_switchdev_nb:
751 	unregister_netdevice_notifier(&s5->netdevice_nb);
752 
753 	return err;
754 }
755 
756 void sparx5_unregister_notifier_blocks(struct sparx5 *s5)
757 {
758 	destroy_workqueue(sparx5_owq);
759 
760 	unregister_switchdev_blocking_notifier(&s5->switchdev_blocking_nb);
761 	unregister_switchdev_notifier(&s5->switchdev_nb);
762 	unregister_netdevice_notifier(&s5->netdevice_nb);
763 }
764