1 // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
2 /* Copyright (c) 2015-2018 Mellanox Technologies. All rights reserved */
4 #include <linux/kernel.h>
5 #include <linux/types.h>
6 #include <linux/netdevice.h>
7 #include <linux/etherdevice.h>
8 #include <linux/slab.h>
9 #include <linux/device.h>
10 #include <linux/skbuff.h>
11 #include <linux/if_vlan.h>
12 #include <linux/if_bridge.h>
13 #include <linux/workqueue.h>
14 #include <linux/jiffies.h>
15 #include <linux/rtnetlink.h>
16 #include <linux/netlink.h>
17 #include <net/switchdev.h>
18 #include <net/vxlan.h>
20 #include "spectrum_span.h"
21 #include "spectrum_switchdev.h"
26 struct mlxsw_sp_bridge_ops;
28 struct mlxsw_sp_bridge {
29 struct mlxsw_sp *mlxsw_sp;
31 struct delayed_work dw;
32 #define MLXSW_SP_DEFAULT_LEARNING_INTERVAL 100
33 unsigned int interval; /* ms */
35 #define MLXSW_SP_MIN_AGEING_TIME 10
36 #define MLXSW_SP_MAX_AGEING_TIME 1000000
37 #define MLXSW_SP_DEFAULT_AGEING_TIME 300
39 bool vlan_enabled_exists;
40 struct list_head bridges_list;
41 DECLARE_BITMAP(mids_bitmap, MLXSW_SP_MID_MAX);
42 const struct mlxsw_sp_bridge_ops *bridge_8021q_ops;
43 const struct mlxsw_sp_bridge_ops *bridge_8021d_ops;
44 const struct mlxsw_sp_bridge_ops *bridge_8021ad_ops;
47 struct mlxsw_sp_bridge_device {
48 struct net_device *dev;
49 struct list_head list;
50 struct list_head ports_list;
51 struct list_head mids_list;
55 const struct mlxsw_sp_bridge_ops *ops;
58 struct mlxsw_sp_bridge_port {
59 struct net_device *dev;
60 struct mlxsw_sp_bridge_device *bridge_device;
61 struct list_head list;
62 struct list_head vlans_list;
63 unsigned int ref_count;
74 struct mlxsw_sp_bridge_vlan {
75 struct list_head list;
76 struct list_head port_vlan_list;
80 struct mlxsw_sp_bridge_ops {
81 int (*port_join)(struct mlxsw_sp_bridge_device *bridge_device,
82 struct mlxsw_sp_bridge_port *bridge_port,
83 struct mlxsw_sp_port *mlxsw_sp_port,
84 struct netlink_ext_ack *extack);
85 void (*port_leave)(struct mlxsw_sp_bridge_device *bridge_device,
86 struct mlxsw_sp_bridge_port *bridge_port,
87 struct mlxsw_sp_port *mlxsw_sp_port);
88 int (*vxlan_join)(struct mlxsw_sp_bridge_device *bridge_device,
89 const struct net_device *vxlan_dev, u16 vid,
90 struct netlink_ext_ack *extack);
92 (*fid_get)(struct mlxsw_sp_bridge_device *bridge_device,
93 u16 vid, struct netlink_ext_ack *extack);
95 (*fid_lookup)(struct mlxsw_sp_bridge_device *bridge_device,
97 u16 (*fid_vid)(struct mlxsw_sp_bridge_device *bridge_device,
98 const struct mlxsw_sp_fid *fid);
102 mlxsw_sp_bridge_port_fdb_flush(struct mlxsw_sp *mlxsw_sp,
103 struct mlxsw_sp_bridge_port *bridge_port,
107 mlxsw_sp_bridge_port_mdb_flush(struct mlxsw_sp_port *mlxsw_sp_port,
108 struct mlxsw_sp_bridge_port *bridge_port);
111 mlxsw_sp_bridge_mdb_mc_enable_sync(struct mlxsw_sp_port *mlxsw_sp_port,
112 struct mlxsw_sp_bridge_device
116 mlxsw_sp_port_mrouter_update_mdb(struct mlxsw_sp_port *mlxsw_sp_port,
117 struct mlxsw_sp_bridge_port *bridge_port,
120 static struct mlxsw_sp_bridge_device *
121 mlxsw_sp_bridge_device_find(const struct mlxsw_sp_bridge *bridge,
122 const struct net_device *br_dev)
124 struct mlxsw_sp_bridge_device *bridge_device;
126 list_for_each_entry(bridge_device, &bridge->bridges_list, list)
127 if (bridge_device->dev == br_dev)
128 return bridge_device;
133 bool mlxsw_sp_bridge_device_is_offloaded(const struct mlxsw_sp *mlxsw_sp,
134 const struct net_device *br_dev)
136 return !!mlxsw_sp_bridge_device_find(mlxsw_sp->bridge, br_dev);
139 static int mlxsw_sp_bridge_device_upper_rif_destroy(struct net_device *dev,
140 struct netdev_nested_priv *priv)
142 struct mlxsw_sp *mlxsw_sp = priv->data;
144 mlxsw_sp_rif_destroy_by_dev(mlxsw_sp, dev);
148 static void mlxsw_sp_bridge_device_rifs_destroy(struct mlxsw_sp *mlxsw_sp,
149 struct net_device *dev)
151 struct netdev_nested_priv priv = {
152 .data = (void *)mlxsw_sp,
155 mlxsw_sp_rif_destroy_by_dev(mlxsw_sp, dev);
156 netdev_walk_all_upper_dev_rcu(dev,
157 mlxsw_sp_bridge_device_upper_rif_destroy,
161 static int mlxsw_sp_bridge_device_vxlan_init(struct mlxsw_sp_bridge *bridge,
162 struct net_device *br_dev,
163 struct netlink_ext_ack *extack)
165 struct net_device *dev, *stop_dev;
166 struct list_head *iter;
169 netdev_for_each_lower_dev(br_dev, dev, iter) {
170 if (netif_is_vxlan(dev) && netif_running(dev)) {
171 err = mlxsw_sp_bridge_vxlan_join(bridge->mlxsw_sp,
184 netdev_for_each_lower_dev(br_dev, dev, iter) {
185 if (netif_is_vxlan(dev) && netif_running(dev)) {
188 mlxsw_sp_bridge_vxlan_leave(bridge->mlxsw_sp, dev);
194 static void mlxsw_sp_bridge_device_vxlan_fini(struct mlxsw_sp_bridge *bridge,
195 struct net_device *br_dev)
197 struct net_device *dev;
198 struct list_head *iter;
200 netdev_for_each_lower_dev(br_dev, dev, iter) {
201 if (netif_is_vxlan(dev) && netif_running(dev))
202 mlxsw_sp_bridge_vxlan_leave(bridge->mlxsw_sp, dev);
206 static struct mlxsw_sp_bridge_device *
207 mlxsw_sp_bridge_device_create(struct mlxsw_sp_bridge *bridge,
208 struct net_device *br_dev,
209 struct netlink_ext_ack *extack)
211 struct device *dev = bridge->mlxsw_sp->bus_info->dev;
212 struct mlxsw_sp_bridge_device *bridge_device;
213 bool vlan_enabled = br_vlan_enabled(br_dev);
216 if (vlan_enabled && bridge->vlan_enabled_exists) {
217 dev_err(dev, "Only one VLAN-aware bridge is supported\n");
218 NL_SET_ERR_MSG_MOD(extack, "Only one VLAN-aware bridge is supported");
219 return ERR_PTR(-EINVAL);
222 bridge_device = kzalloc(sizeof(*bridge_device), GFP_KERNEL);
224 return ERR_PTR(-ENOMEM);
226 bridge_device->dev = br_dev;
227 bridge_device->vlan_enabled = vlan_enabled;
228 bridge_device->multicast_enabled = br_multicast_enabled(br_dev);
229 bridge_device->mrouter = br_multicast_router(br_dev);
230 INIT_LIST_HEAD(&bridge_device->ports_list);
234 bridge->vlan_enabled_exists = true;
235 br_vlan_get_proto(br_dev, &proto);
236 if (proto == ETH_P_8021AD)
237 bridge_device->ops = bridge->bridge_8021ad_ops;
239 bridge_device->ops = bridge->bridge_8021q_ops;
241 bridge_device->ops = bridge->bridge_8021d_ops;
243 INIT_LIST_HEAD(&bridge_device->mids_list);
244 list_add(&bridge_device->list, &bridge->bridges_list);
246 /* It is possible we already have VXLAN devices enslaved to the bridge.
247 * In which case, we need to replay their configuration as if they were
248 * just now enslaved to the bridge.
250 err = mlxsw_sp_bridge_device_vxlan_init(bridge, br_dev, extack);
254 return bridge_device;
257 list_del(&bridge_device->list);
258 if (bridge_device->vlan_enabled)
259 bridge->vlan_enabled_exists = false;
260 kfree(bridge_device);
265 mlxsw_sp_bridge_device_destroy(struct mlxsw_sp_bridge *bridge,
266 struct mlxsw_sp_bridge_device *bridge_device)
268 mlxsw_sp_bridge_device_vxlan_fini(bridge, bridge_device->dev);
269 mlxsw_sp_bridge_device_rifs_destroy(bridge->mlxsw_sp,
271 list_del(&bridge_device->list);
272 if (bridge_device->vlan_enabled)
273 bridge->vlan_enabled_exists = false;
274 WARN_ON(!list_empty(&bridge_device->ports_list));
275 WARN_ON(!list_empty(&bridge_device->mids_list));
276 kfree(bridge_device);
279 static struct mlxsw_sp_bridge_device *
280 mlxsw_sp_bridge_device_get(struct mlxsw_sp_bridge *bridge,
281 struct net_device *br_dev,
282 struct netlink_ext_ack *extack)
284 struct mlxsw_sp_bridge_device *bridge_device;
286 bridge_device = mlxsw_sp_bridge_device_find(bridge, br_dev);
288 return bridge_device;
290 return mlxsw_sp_bridge_device_create(bridge, br_dev, extack);
294 mlxsw_sp_bridge_device_put(struct mlxsw_sp_bridge *bridge,
295 struct mlxsw_sp_bridge_device *bridge_device)
297 if (list_empty(&bridge_device->ports_list))
298 mlxsw_sp_bridge_device_destroy(bridge, bridge_device);
301 static struct mlxsw_sp_bridge_port *
302 __mlxsw_sp_bridge_port_find(const struct mlxsw_sp_bridge_device *bridge_device,
303 const struct net_device *brport_dev)
305 struct mlxsw_sp_bridge_port *bridge_port;
307 list_for_each_entry(bridge_port, &bridge_device->ports_list, list) {
308 if (bridge_port->dev == brport_dev)
315 struct mlxsw_sp_bridge_port *
316 mlxsw_sp_bridge_port_find(struct mlxsw_sp_bridge *bridge,
317 struct net_device *brport_dev)
319 struct net_device *br_dev = netdev_master_upper_dev_get(brport_dev);
320 struct mlxsw_sp_bridge_device *bridge_device;
325 bridge_device = mlxsw_sp_bridge_device_find(bridge, br_dev);
329 return __mlxsw_sp_bridge_port_find(bridge_device, brport_dev);
332 static struct mlxsw_sp_bridge_port *
333 mlxsw_sp_bridge_port_create(struct mlxsw_sp_bridge_device *bridge_device,
334 struct net_device *brport_dev)
336 struct mlxsw_sp_bridge_port *bridge_port;
337 struct mlxsw_sp_port *mlxsw_sp_port;
339 bridge_port = kzalloc(sizeof(*bridge_port), GFP_KERNEL);
343 mlxsw_sp_port = mlxsw_sp_port_dev_lower_find(brport_dev);
344 bridge_port->lagged = mlxsw_sp_port->lagged;
345 if (bridge_port->lagged)
346 bridge_port->lag_id = mlxsw_sp_port->lag_id;
348 bridge_port->system_port = mlxsw_sp_port->local_port;
349 bridge_port->dev = brport_dev;
350 bridge_port->bridge_device = bridge_device;
351 bridge_port->stp_state = BR_STATE_DISABLED;
352 bridge_port->flags = BR_LEARNING | BR_FLOOD | BR_LEARNING_SYNC |
354 INIT_LIST_HEAD(&bridge_port->vlans_list);
355 list_add(&bridge_port->list, &bridge_device->ports_list);
356 bridge_port->ref_count = 1;
362 mlxsw_sp_bridge_port_destroy(struct mlxsw_sp_bridge_port *bridge_port)
364 list_del(&bridge_port->list);
365 WARN_ON(!list_empty(&bridge_port->vlans_list));
369 static struct mlxsw_sp_bridge_port *
370 mlxsw_sp_bridge_port_get(struct mlxsw_sp_bridge *bridge,
371 struct net_device *brport_dev,
372 struct netlink_ext_ack *extack)
374 struct net_device *br_dev = netdev_master_upper_dev_get(brport_dev);
375 struct mlxsw_sp_bridge_device *bridge_device;
376 struct mlxsw_sp_bridge_port *bridge_port;
379 bridge_port = mlxsw_sp_bridge_port_find(bridge, brport_dev);
381 bridge_port->ref_count++;
385 bridge_device = mlxsw_sp_bridge_device_get(bridge, br_dev, extack);
386 if (IS_ERR(bridge_device))
387 return ERR_CAST(bridge_device);
389 bridge_port = mlxsw_sp_bridge_port_create(bridge_device, brport_dev);
392 goto err_bridge_port_create;
397 err_bridge_port_create:
398 mlxsw_sp_bridge_device_put(bridge, bridge_device);
402 static void mlxsw_sp_bridge_port_put(struct mlxsw_sp_bridge *bridge,
403 struct mlxsw_sp_bridge_port *bridge_port)
405 struct mlxsw_sp_bridge_device *bridge_device;
407 if (--bridge_port->ref_count != 0)
409 bridge_device = bridge_port->bridge_device;
410 mlxsw_sp_bridge_port_destroy(bridge_port);
411 mlxsw_sp_bridge_device_put(bridge, bridge_device);
414 static struct mlxsw_sp_port_vlan *
415 mlxsw_sp_port_vlan_find_by_bridge(struct mlxsw_sp_port *mlxsw_sp_port,
416 const struct mlxsw_sp_bridge_device *
420 struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
422 list_for_each_entry(mlxsw_sp_port_vlan, &mlxsw_sp_port->vlans_list,
424 if (!mlxsw_sp_port_vlan->bridge_port)
426 if (mlxsw_sp_port_vlan->bridge_port->bridge_device !=
429 if (bridge_device->vlan_enabled &&
430 mlxsw_sp_port_vlan->vid != vid)
432 return mlxsw_sp_port_vlan;
438 static struct mlxsw_sp_port_vlan*
439 mlxsw_sp_port_vlan_find_by_fid(struct mlxsw_sp_port *mlxsw_sp_port,
442 struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
444 list_for_each_entry(mlxsw_sp_port_vlan, &mlxsw_sp_port->vlans_list,
446 struct mlxsw_sp_fid *fid = mlxsw_sp_port_vlan->fid;
448 if (fid && mlxsw_sp_fid_index(fid) == fid_index)
449 return mlxsw_sp_port_vlan;
455 static struct mlxsw_sp_bridge_vlan *
456 mlxsw_sp_bridge_vlan_find(const struct mlxsw_sp_bridge_port *bridge_port,
459 struct mlxsw_sp_bridge_vlan *bridge_vlan;
461 list_for_each_entry(bridge_vlan, &bridge_port->vlans_list, list) {
462 if (bridge_vlan->vid == vid)
469 static struct mlxsw_sp_bridge_vlan *
470 mlxsw_sp_bridge_vlan_create(struct mlxsw_sp_bridge_port *bridge_port, u16 vid)
472 struct mlxsw_sp_bridge_vlan *bridge_vlan;
474 bridge_vlan = kzalloc(sizeof(*bridge_vlan), GFP_KERNEL);
478 INIT_LIST_HEAD(&bridge_vlan->port_vlan_list);
479 bridge_vlan->vid = vid;
480 list_add(&bridge_vlan->list, &bridge_port->vlans_list);
486 mlxsw_sp_bridge_vlan_destroy(struct mlxsw_sp_bridge_vlan *bridge_vlan)
488 list_del(&bridge_vlan->list);
489 WARN_ON(!list_empty(&bridge_vlan->port_vlan_list));
493 static struct mlxsw_sp_bridge_vlan *
494 mlxsw_sp_bridge_vlan_get(struct mlxsw_sp_bridge_port *bridge_port, u16 vid)
496 struct mlxsw_sp_bridge_vlan *bridge_vlan;
498 bridge_vlan = mlxsw_sp_bridge_vlan_find(bridge_port, vid);
502 return mlxsw_sp_bridge_vlan_create(bridge_port, vid);
505 static void mlxsw_sp_bridge_vlan_put(struct mlxsw_sp_bridge_vlan *bridge_vlan)
507 if (list_empty(&bridge_vlan->port_vlan_list))
508 mlxsw_sp_bridge_vlan_destroy(bridge_vlan);
512 mlxsw_sp_port_bridge_vlan_stp_set(struct mlxsw_sp_port *mlxsw_sp_port,
513 struct mlxsw_sp_bridge_vlan *bridge_vlan,
516 struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
518 list_for_each_entry(mlxsw_sp_port_vlan, &bridge_vlan->port_vlan_list,
520 if (mlxsw_sp_port_vlan->mlxsw_sp_port != mlxsw_sp_port)
522 return mlxsw_sp_port_vid_stp_set(mlxsw_sp_port,
523 bridge_vlan->vid, state);
529 static int mlxsw_sp_port_attr_stp_state_set(struct mlxsw_sp_port *mlxsw_sp_port,
530 struct net_device *orig_dev,
533 struct mlxsw_sp_bridge_port *bridge_port;
534 struct mlxsw_sp_bridge_vlan *bridge_vlan;
537 /* It's possible we failed to enslave the port, yet this
538 * operation is executed due to it being deferred.
540 bridge_port = mlxsw_sp_bridge_port_find(mlxsw_sp_port->mlxsw_sp->bridge,
545 list_for_each_entry(bridge_vlan, &bridge_port->vlans_list, list) {
546 err = mlxsw_sp_port_bridge_vlan_stp_set(mlxsw_sp_port,
549 goto err_port_bridge_vlan_stp_set;
552 bridge_port->stp_state = state;
556 err_port_bridge_vlan_stp_set:
557 list_for_each_entry_continue_reverse(bridge_vlan,
558 &bridge_port->vlans_list, list)
559 mlxsw_sp_port_bridge_vlan_stp_set(mlxsw_sp_port, bridge_vlan,
560 bridge_port->stp_state);
565 mlxsw_sp_port_bridge_vlan_flood_set(struct mlxsw_sp_port *mlxsw_sp_port,
566 struct mlxsw_sp_bridge_vlan *bridge_vlan,
567 enum mlxsw_sp_flood_type packet_type,
570 struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
572 list_for_each_entry(mlxsw_sp_port_vlan, &bridge_vlan->port_vlan_list,
574 if (mlxsw_sp_port_vlan->mlxsw_sp_port != mlxsw_sp_port)
576 return mlxsw_sp_fid_flood_set(mlxsw_sp_port_vlan->fid,
578 mlxsw_sp_port->local_port,
586 mlxsw_sp_bridge_port_flood_table_set(struct mlxsw_sp_port *mlxsw_sp_port,
587 struct mlxsw_sp_bridge_port *bridge_port,
588 enum mlxsw_sp_flood_type packet_type,
591 struct mlxsw_sp_bridge_vlan *bridge_vlan;
594 list_for_each_entry(bridge_vlan, &bridge_port->vlans_list, list) {
595 err = mlxsw_sp_port_bridge_vlan_flood_set(mlxsw_sp_port,
600 goto err_port_bridge_vlan_flood_set;
605 err_port_bridge_vlan_flood_set:
606 list_for_each_entry_continue_reverse(bridge_vlan,
607 &bridge_port->vlans_list, list)
608 mlxsw_sp_port_bridge_vlan_flood_set(mlxsw_sp_port, bridge_vlan,
609 packet_type, !member);
614 mlxsw_sp_port_bridge_vlan_learning_set(struct mlxsw_sp_port *mlxsw_sp_port,
615 struct mlxsw_sp_bridge_vlan *bridge_vlan,
618 struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
619 u16 vid = bridge_vlan->vid;
621 list_for_each_entry(mlxsw_sp_port_vlan, &bridge_vlan->port_vlan_list,
623 if (mlxsw_sp_port_vlan->mlxsw_sp_port != mlxsw_sp_port)
625 return mlxsw_sp_port_vid_learning_set(mlxsw_sp_port, vid, set);
632 mlxsw_sp_bridge_port_learning_set(struct mlxsw_sp_port *mlxsw_sp_port,
633 struct mlxsw_sp_bridge_port *bridge_port,
636 struct mlxsw_sp_bridge_vlan *bridge_vlan;
639 list_for_each_entry(bridge_vlan, &bridge_port->vlans_list, list) {
640 err = mlxsw_sp_port_bridge_vlan_learning_set(mlxsw_sp_port,
643 goto err_port_bridge_vlan_learning_set;
648 err_port_bridge_vlan_learning_set:
649 list_for_each_entry_continue_reverse(bridge_vlan,
650 &bridge_port->vlans_list, list)
651 mlxsw_sp_port_bridge_vlan_learning_set(mlxsw_sp_port,
657 mlxsw_sp_port_attr_br_pre_flags_set(struct mlxsw_sp_port *mlxsw_sp_port,
658 struct switchdev_brport_flags flags)
660 if (flags.mask & ~(BR_LEARNING | BR_FLOOD | BR_MCAST_FLOOD))
666 static int mlxsw_sp_port_attr_br_flags_set(struct mlxsw_sp_port *mlxsw_sp_port,
667 struct net_device *orig_dev,
668 struct switchdev_brport_flags flags)
670 struct mlxsw_sp_bridge_port *bridge_port;
673 bridge_port = mlxsw_sp_bridge_port_find(mlxsw_sp_port->mlxsw_sp->bridge,
678 if (flags.mask & BR_FLOOD) {
679 err = mlxsw_sp_bridge_port_flood_table_set(mlxsw_sp_port,
681 MLXSW_SP_FLOOD_TYPE_UC,
682 flags.val & BR_FLOOD);
687 if (flags.mask & BR_LEARNING) {
688 err = mlxsw_sp_bridge_port_learning_set(mlxsw_sp_port,
690 flags.val & BR_LEARNING);
695 if (bridge_port->bridge_device->multicast_enabled)
698 if (flags.mask & BR_MCAST_FLOOD) {
699 err = mlxsw_sp_bridge_port_flood_table_set(mlxsw_sp_port,
701 MLXSW_SP_FLOOD_TYPE_MC,
702 flags.val & BR_MCAST_FLOOD);
708 memcpy(&bridge_port->flags, &flags.val, sizeof(flags.val));
712 static int mlxsw_sp_ageing_set(struct mlxsw_sp *mlxsw_sp, u32 ageing_time)
714 char sfdat_pl[MLXSW_REG_SFDAT_LEN];
717 mlxsw_reg_sfdat_pack(sfdat_pl, ageing_time);
718 err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(sfdat), sfdat_pl);
721 mlxsw_sp->bridge->ageing_time = ageing_time;
725 static int mlxsw_sp_port_attr_br_ageing_set(struct mlxsw_sp_port *mlxsw_sp_port,
726 unsigned long ageing_clock_t)
728 struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
729 unsigned long ageing_jiffies = clock_t_to_jiffies(ageing_clock_t);
730 u32 ageing_time = jiffies_to_msecs(ageing_jiffies) / 1000;
732 if (ageing_time < MLXSW_SP_MIN_AGEING_TIME ||
733 ageing_time > MLXSW_SP_MAX_AGEING_TIME)
736 return mlxsw_sp_ageing_set(mlxsw_sp, ageing_time);
739 static int mlxsw_sp_port_attr_br_vlan_set(struct mlxsw_sp_port *mlxsw_sp_port,
740 struct net_device *orig_dev,
743 struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
744 struct mlxsw_sp_bridge_device *bridge_device;
746 bridge_device = mlxsw_sp_bridge_device_find(mlxsw_sp->bridge, orig_dev);
747 if (WARN_ON(!bridge_device))
750 if (bridge_device->vlan_enabled == vlan_enabled)
753 netdev_err(bridge_device->dev, "VLAN filtering can't be changed for existing bridge\n");
757 static int mlxsw_sp_port_attr_br_vlan_proto_set(struct mlxsw_sp_port *mlxsw_sp_port,
758 struct net_device *orig_dev,
761 struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
762 struct mlxsw_sp_bridge_device *bridge_device;
764 bridge_device = mlxsw_sp_bridge_device_find(mlxsw_sp->bridge, orig_dev);
765 if (WARN_ON(!bridge_device))
768 netdev_err(bridge_device->dev, "VLAN protocol can't be changed on existing bridge\n");
772 static int mlxsw_sp_port_attr_mrouter_set(struct mlxsw_sp_port *mlxsw_sp_port,
773 struct net_device *orig_dev,
774 bool is_port_mrouter)
776 struct mlxsw_sp_bridge_port *bridge_port;
779 bridge_port = mlxsw_sp_bridge_port_find(mlxsw_sp_port->mlxsw_sp->bridge,
784 if (!bridge_port->bridge_device->multicast_enabled)
787 err = mlxsw_sp_bridge_port_flood_table_set(mlxsw_sp_port, bridge_port,
788 MLXSW_SP_FLOOD_TYPE_MC,
793 mlxsw_sp_port_mrouter_update_mdb(mlxsw_sp_port, bridge_port,
796 bridge_port->mrouter = is_port_mrouter;
800 static bool mlxsw_sp_mc_flood(const struct mlxsw_sp_bridge_port *bridge_port)
802 const struct mlxsw_sp_bridge_device *bridge_device;
804 bridge_device = bridge_port->bridge_device;
805 return bridge_device->multicast_enabled ? bridge_port->mrouter :
806 bridge_port->flags & BR_MCAST_FLOOD;
809 static int mlxsw_sp_port_mc_disabled_set(struct mlxsw_sp_port *mlxsw_sp_port,
810 struct net_device *orig_dev,
813 struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
814 struct mlxsw_sp_bridge_device *bridge_device;
815 struct mlxsw_sp_bridge_port *bridge_port;
818 /* It's possible we failed to enslave the port, yet this
819 * operation is executed due to it being deferred.
821 bridge_device = mlxsw_sp_bridge_device_find(mlxsw_sp->bridge, orig_dev);
825 if (bridge_device->multicast_enabled != !mc_disabled) {
826 bridge_device->multicast_enabled = !mc_disabled;
827 mlxsw_sp_bridge_mdb_mc_enable_sync(mlxsw_sp_port,
831 list_for_each_entry(bridge_port, &bridge_device->ports_list, list) {
832 enum mlxsw_sp_flood_type packet_type = MLXSW_SP_FLOOD_TYPE_MC;
833 bool member = mlxsw_sp_mc_flood(bridge_port);
835 err = mlxsw_sp_bridge_port_flood_table_set(mlxsw_sp_port,
837 packet_type, member);
842 bridge_device->multicast_enabled = !mc_disabled;
847 static int mlxsw_sp_smid_router_port_set(struct mlxsw_sp *mlxsw_sp,
848 u16 mid_idx, bool add)
853 smid_pl = kmalloc(MLXSW_REG_SMID_LEN, GFP_KERNEL);
857 mlxsw_reg_smid_pack(smid_pl, mid_idx,
858 mlxsw_sp_router_port(mlxsw_sp), add);
859 err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(smid), smid_pl);
865 mlxsw_sp_bridge_mrouter_update_mdb(struct mlxsw_sp *mlxsw_sp,
866 struct mlxsw_sp_bridge_device *bridge_device,
869 struct mlxsw_sp_mid *mid;
871 list_for_each_entry(mid, &bridge_device->mids_list, list)
872 mlxsw_sp_smid_router_port_set(mlxsw_sp, mid->mid, add);
876 mlxsw_sp_port_attr_br_mrouter_set(struct mlxsw_sp_port *mlxsw_sp_port,
877 struct net_device *orig_dev,
880 struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
881 struct mlxsw_sp_bridge_device *bridge_device;
883 /* It's possible we failed to enslave the port, yet this
884 * operation is executed due to it being deferred.
886 bridge_device = mlxsw_sp_bridge_device_find(mlxsw_sp->bridge, orig_dev);
890 if (bridge_device->mrouter != is_mrouter)
891 mlxsw_sp_bridge_mrouter_update_mdb(mlxsw_sp, bridge_device,
893 bridge_device->mrouter = is_mrouter;
897 static int mlxsw_sp_port_attr_set(struct net_device *dev,
898 const struct switchdev_attr *attr,
899 struct netlink_ext_ack *extack)
901 struct mlxsw_sp_port *mlxsw_sp_port = netdev_priv(dev);
905 case SWITCHDEV_ATTR_ID_PORT_STP_STATE:
906 err = mlxsw_sp_port_attr_stp_state_set(mlxsw_sp_port,
910 case SWITCHDEV_ATTR_ID_PORT_PRE_BRIDGE_FLAGS:
911 err = mlxsw_sp_port_attr_br_pre_flags_set(mlxsw_sp_port,
912 attr->u.brport_flags);
914 case SWITCHDEV_ATTR_ID_PORT_BRIDGE_FLAGS:
915 err = mlxsw_sp_port_attr_br_flags_set(mlxsw_sp_port,
917 attr->u.brport_flags);
919 case SWITCHDEV_ATTR_ID_BRIDGE_AGEING_TIME:
920 err = mlxsw_sp_port_attr_br_ageing_set(mlxsw_sp_port,
921 attr->u.ageing_time);
923 case SWITCHDEV_ATTR_ID_BRIDGE_VLAN_FILTERING:
924 err = mlxsw_sp_port_attr_br_vlan_set(mlxsw_sp_port,
926 attr->u.vlan_filtering);
928 case SWITCHDEV_ATTR_ID_BRIDGE_VLAN_PROTOCOL:
929 err = mlxsw_sp_port_attr_br_vlan_proto_set(mlxsw_sp_port,
931 attr->u.vlan_protocol);
933 case SWITCHDEV_ATTR_ID_PORT_MROUTER:
934 err = mlxsw_sp_port_attr_mrouter_set(mlxsw_sp_port,
938 case SWITCHDEV_ATTR_ID_BRIDGE_MC_DISABLED:
939 err = mlxsw_sp_port_mc_disabled_set(mlxsw_sp_port,
941 attr->u.mc_disabled);
943 case SWITCHDEV_ATTR_ID_BRIDGE_MROUTER:
944 err = mlxsw_sp_port_attr_br_mrouter_set(mlxsw_sp_port,
953 mlxsw_sp_span_respin(mlxsw_sp_port->mlxsw_sp);
959 mlxsw_sp_port_vlan_fid_join(struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan,
960 struct mlxsw_sp_bridge_port *bridge_port,
961 struct netlink_ext_ack *extack)
963 struct mlxsw_sp_port *mlxsw_sp_port = mlxsw_sp_port_vlan->mlxsw_sp_port;
964 struct mlxsw_sp_bridge_device *bridge_device;
965 u8 local_port = mlxsw_sp_port->local_port;
966 u16 vid = mlxsw_sp_port_vlan->vid;
967 struct mlxsw_sp_fid *fid;
970 bridge_device = bridge_port->bridge_device;
971 fid = bridge_device->ops->fid_get(bridge_device, vid, extack);
975 err = mlxsw_sp_fid_flood_set(fid, MLXSW_SP_FLOOD_TYPE_UC, local_port,
976 bridge_port->flags & BR_FLOOD);
978 goto err_fid_uc_flood_set;
980 err = mlxsw_sp_fid_flood_set(fid, MLXSW_SP_FLOOD_TYPE_MC, local_port,
981 mlxsw_sp_mc_flood(bridge_port));
983 goto err_fid_mc_flood_set;
985 err = mlxsw_sp_fid_flood_set(fid, MLXSW_SP_FLOOD_TYPE_BC, local_port,
988 goto err_fid_bc_flood_set;
990 err = mlxsw_sp_fid_port_vid_map(fid, mlxsw_sp_port, vid);
992 goto err_fid_port_vid_map;
994 mlxsw_sp_port_vlan->fid = fid;
998 err_fid_port_vid_map:
999 mlxsw_sp_fid_flood_set(fid, MLXSW_SP_FLOOD_TYPE_BC, local_port, false);
1000 err_fid_bc_flood_set:
1001 mlxsw_sp_fid_flood_set(fid, MLXSW_SP_FLOOD_TYPE_MC, local_port, false);
1002 err_fid_mc_flood_set:
1003 mlxsw_sp_fid_flood_set(fid, MLXSW_SP_FLOOD_TYPE_UC, local_port, false);
1004 err_fid_uc_flood_set:
1005 mlxsw_sp_fid_put(fid);
1010 mlxsw_sp_port_vlan_fid_leave(struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan)
1012 struct mlxsw_sp_port *mlxsw_sp_port = mlxsw_sp_port_vlan->mlxsw_sp_port;
1013 struct mlxsw_sp_fid *fid = mlxsw_sp_port_vlan->fid;
1014 u8 local_port = mlxsw_sp_port->local_port;
1015 u16 vid = mlxsw_sp_port_vlan->vid;
1017 mlxsw_sp_port_vlan->fid = NULL;
1018 mlxsw_sp_fid_port_vid_unmap(fid, mlxsw_sp_port, vid);
1019 mlxsw_sp_fid_flood_set(fid, MLXSW_SP_FLOOD_TYPE_BC, local_port, false);
1020 mlxsw_sp_fid_flood_set(fid, MLXSW_SP_FLOOD_TYPE_MC, local_port, false);
1021 mlxsw_sp_fid_flood_set(fid, MLXSW_SP_FLOOD_TYPE_UC, local_port, false);
1022 mlxsw_sp_fid_put(fid);
1026 mlxsw_sp_port_pvid_determine(const struct mlxsw_sp_port *mlxsw_sp_port,
1027 u16 vid, bool is_pvid)
1031 else if (mlxsw_sp_port->pvid == vid)
1032 return 0; /* Dis-allow untagged packets */
1034 return mlxsw_sp_port->pvid;
1038 mlxsw_sp_port_vlan_bridge_join(struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan,
1039 struct mlxsw_sp_bridge_port *bridge_port,
1040 struct netlink_ext_ack *extack)
1042 struct mlxsw_sp_port *mlxsw_sp_port = mlxsw_sp_port_vlan->mlxsw_sp_port;
1043 struct mlxsw_sp_bridge_vlan *bridge_vlan;
1044 u16 vid = mlxsw_sp_port_vlan->vid;
1047 /* No need to continue if only VLAN flags were changed */
1048 if (mlxsw_sp_port_vlan->bridge_port)
1051 err = mlxsw_sp_port_vlan_fid_join(mlxsw_sp_port_vlan, bridge_port,
1056 err = mlxsw_sp_port_vid_learning_set(mlxsw_sp_port, vid,
1057 bridge_port->flags & BR_LEARNING);
1059 goto err_port_vid_learning_set;
1061 err = mlxsw_sp_port_vid_stp_set(mlxsw_sp_port, vid,
1062 bridge_port->stp_state);
1064 goto err_port_vid_stp_set;
1066 bridge_vlan = mlxsw_sp_bridge_vlan_get(bridge_port, vid);
1069 goto err_bridge_vlan_get;
1072 list_add(&mlxsw_sp_port_vlan->bridge_vlan_node,
1073 &bridge_vlan->port_vlan_list);
1075 mlxsw_sp_bridge_port_get(mlxsw_sp_port->mlxsw_sp->bridge,
1076 bridge_port->dev, extack);
1077 mlxsw_sp_port_vlan->bridge_port = bridge_port;
1081 err_bridge_vlan_get:
1082 mlxsw_sp_port_vid_stp_set(mlxsw_sp_port, vid, BR_STATE_DISABLED);
1083 err_port_vid_stp_set:
1084 mlxsw_sp_port_vid_learning_set(mlxsw_sp_port, vid, false);
1085 err_port_vid_learning_set:
1086 mlxsw_sp_port_vlan_fid_leave(mlxsw_sp_port_vlan);
1091 mlxsw_sp_port_vlan_bridge_leave(struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan)
1093 struct mlxsw_sp_port *mlxsw_sp_port = mlxsw_sp_port_vlan->mlxsw_sp_port;
1094 struct mlxsw_sp_fid *fid = mlxsw_sp_port_vlan->fid;
1095 struct mlxsw_sp_bridge_vlan *bridge_vlan;
1096 struct mlxsw_sp_bridge_port *bridge_port;
1097 u16 vid = mlxsw_sp_port_vlan->vid;
1098 bool last_port, last_vlan;
1100 if (WARN_ON(mlxsw_sp_fid_type(fid) != MLXSW_SP_FID_TYPE_8021Q &&
1101 mlxsw_sp_fid_type(fid) != MLXSW_SP_FID_TYPE_8021D))
1104 bridge_port = mlxsw_sp_port_vlan->bridge_port;
1105 last_vlan = list_is_singular(&bridge_port->vlans_list);
1106 bridge_vlan = mlxsw_sp_bridge_vlan_find(bridge_port, vid);
1107 last_port = list_is_singular(&bridge_vlan->port_vlan_list);
1109 list_del(&mlxsw_sp_port_vlan->bridge_vlan_node);
1110 mlxsw_sp_bridge_vlan_put(bridge_vlan);
1111 mlxsw_sp_port_vid_stp_set(mlxsw_sp_port, vid, BR_STATE_DISABLED);
1112 mlxsw_sp_port_vid_learning_set(mlxsw_sp_port, vid, false);
1114 mlxsw_sp_bridge_port_fdb_flush(mlxsw_sp_port->mlxsw_sp,
1116 mlxsw_sp_fid_index(fid));
1118 mlxsw_sp_bridge_port_mdb_flush(mlxsw_sp_port, bridge_port);
1120 mlxsw_sp_port_vlan_fid_leave(mlxsw_sp_port_vlan);
1122 mlxsw_sp_bridge_port_put(mlxsw_sp_port->mlxsw_sp->bridge, bridge_port);
1123 mlxsw_sp_port_vlan->bridge_port = NULL;
1127 mlxsw_sp_bridge_port_vlan_add(struct mlxsw_sp_port *mlxsw_sp_port,
1128 struct mlxsw_sp_bridge_port *bridge_port,
1129 u16 vid, bool is_untagged, bool is_pvid,
1130 struct netlink_ext_ack *extack)
1132 u16 pvid = mlxsw_sp_port_pvid_determine(mlxsw_sp_port, vid, is_pvid);
1133 struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
1134 u16 old_pvid = mlxsw_sp_port->pvid;
1138 /* The only valid scenario in which a port-vlan already exists, is if
1139 * the VLAN flags were changed and the port-vlan is associated with the
1140 * correct bridge port
1142 mlxsw_sp_port_vlan = mlxsw_sp_port_vlan_find_by_vid(mlxsw_sp_port, vid);
1143 if (mlxsw_sp_port_vlan &&
1144 mlxsw_sp_port_vlan->bridge_port != bridge_port)
1147 if (!mlxsw_sp_port_vlan) {
1148 mlxsw_sp_port_vlan = mlxsw_sp_port_vlan_create(mlxsw_sp_port,
1150 if (IS_ERR(mlxsw_sp_port_vlan))
1151 return PTR_ERR(mlxsw_sp_port_vlan);
1154 err = mlxsw_sp_port_vlan_set(mlxsw_sp_port, vid, vid, true,
1157 goto err_port_vlan_set;
1159 br_vlan_get_proto(bridge_port->bridge_device->dev, &proto);
1160 err = mlxsw_sp_port_pvid_set(mlxsw_sp_port, pvid, proto);
1162 goto err_port_pvid_set;
1164 err = mlxsw_sp_port_vlan_bridge_join(mlxsw_sp_port_vlan, bridge_port,
1167 goto err_port_vlan_bridge_join;
1171 err_port_vlan_bridge_join:
1172 mlxsw_sp_port_pvid_set(mlxsw_sp_port, old_pvid, proto);
1174 mlxsw_sp_port_vlan_set(mlxsw_sp_port, vid, vid, false, false);
1176 mlxsw_sp_port_vlan_destroy(mlxsw_sp_port_vlan);
1181 mlxsw_sp_br_ban_rif_pvid_change(struct mlxsw_sp *mlxsw_sp,
1182 const struct net_device *br_dev,
1183 const struct switchdev_obj_port_vlan *vlan)
1187 pvid = mlxsw_sp_rif_vid(mlxsw_sp, br_dev);
1191 if (vlan->flags & BRIDGE_VLAN_INFO_PVID) {
1192 if (vlan->vid != pvid) {
1193 netdev_err(br_dev, "Can't change PVID, it's used by router interface\n");
1197 if (vlan->vid == pvid) {
1198 netdev_err(br_dev, "Can't remove PVID, it's used by router interface\n");
1206 static int mlxsw_sp_port_vlans_add(struct mlxsw_sp_port *mlxsw_sp_port,
1207 const struct switchdev_obj_port_vlan *vlan,
1208 struct netlink_ext_ack *extack)
1210 bool flag_untagged = vlan->flags & BRIDGE_VLAN_INFO_UNTAGGED;
1211 bool flag_pvid = vlan->flags & BRIDGE_VLAN_INFO_PVID;
1212 struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
1213 struct net_device *orig_dev = vlan->obj.orig_dev;
1214 struct mlxsw_sp_bridge_port *bridge_port;
1216 if (netif_is_bridge_master(orig_dev)) {
1219 if ((vlan->flags & BRIDGE_VLAN_INFO_BRENTRY) &&
1220 br_vlan_enabled(orig_dev))
1221 err = mlxsw_sp_br_ban_rif_pvid_change(mlxsw_sp,
1228 bridge_port = mlxsw_sp_bridge_port_find(mlxsw_sp->bridge, orig_dev);
1229 if (WARN_ON(!bridge_port))
1232 if (!bridge_port->bridge_device->vlan_enabled)
1235 return mlxsw_sp_bridge_port_vlan_add(mlxsw_sp_port, bridge_port,
1236 vlan->vid, flag_untagged,
1240 static enum mlxsw_reg_sfdf_flush_type mlxsw_sp_fdb_flush_type(bool lagged)
1242 return lagged ? MLXSW_REG_SFDF_FLUSH_PER_LAG_AND_FID :
1243 MLXSW_REG_SFDF_FLUSH_PER_PORT_AND_FID;
1247 mlxsw_sp_bridge_port_fdb_flush(struct mlxsw_sp *mlxsw_sp,
1248 struct mlxsw_sp_bridge_port *bridge_port,
1251 bool lagged = bridge_port->lagged;
1252 char sfdf_pl[MLXSW_REG_SFDF_LEN];
1255 system_port = lagged ? bridge_port->lag_id : bridge_port->system_port;
1256 mlxsw_reg_sfdf_pack(sfdf_pl, mlxsw_sp_fdb_flush_type(lagged));
1257 mlxsw_reg_sfdf_fid_set(sfdf_pl, fid_index);
1258 mlxsw_reg_sfdf_port_fid_system_port_set(sfdf_pl, system_port);
1260 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(sfdf), sfdf_pl);
1263 static enum mlxsw_reg_sfd_rec_policy mlxsw_sp_sfd_rec_policy(bool dynamic)
1265 return dynamic ? MLXSW_REG_SFD_REC_POLICY_DYNAMIC_ENTRY_INGRESS :
1266 MLXSW_REG_SFD_REC_POLICY_DYNAMIC_ENTRY_MLAG;
1269 static enum mlxsw_reg_sfd_op mlxsw_sp_sfd_op(bool adding)
1271 return adding ? MLXSW_REG_SFD_OP_WRITE_EDIT :
1272 MLXSW_REG_SFD_OP_WRITE_REMOVE;
1275 static int mlxsw_sp_port_fdb_tunnel_uc_op(struct mlxsw_sp *mlxsw_sp,
1276 const char *mac, u16 fid,
1277 enum mlxsw_sp_l3proto proto,
1278 const union mlxsw_sp_l3addr *addr,
1279 bool adding, bool dynamic)
1281 enum mlxsw_reg_sfd_uc_tunnel_protocol sfd_proto;
1288 case MLXSW_SP_L3_PROTO_IPV4:
1289 uip = be32_to_cpu(addr->addr4);
1290 sfd_proto = MLXSW_REG_SFD_UC_TUNNEL_PROTOCOL_IPV4;
1292 case MLXSW_SP_L3_PROTO_IPV6:
1298 sfd_pl = kmalloc(MLXSW_REG_SFD_LEN, GFP_KERNEL);
1302 mlxsw_reg_sfd_pack(sfd_pl, mlxsw_sp_sfd_op(adding), 0);
1303 mlxsw_reg_sfd_uc_tunnel_pack(sfd_pl, 0,
1304 mlxsw_sp_sfd_rec_policy(dynamic), mac, fid,
1305 MLXSW_REG_SFD_REC_ACTION_NOP, uip,
1307 num_rec = mlxsw_reg_sfd_num_rec_get(sfd_pl);
1308 err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(sfd), sfd_pl);
1312 if (num_rec != mlxsw_reg_sfd_num_rec_get(sfd_pl))
1320 static int __mlxsw_sp_port_fdb_uc_op(struct mlxsw_sp *mlxsw_sp, u8 local_port,
1321 const char *mac, u16 fid, bool adding,
1322 enum mlxsw_reg_sfd_rec_action action,
1323 enum mlxsw_reg_sfd_rec_policy policy)
1329 sfd_pl = kmalloc(MLXSW_REG_SFD_LEN, GFP_KERNEL);
1333 mlxsw_reg_sfd_pack(sfd_pl, mlxsw_sp_sfd_op(adding), 0);
1334 mlxsw_reg_sfd_uc_pack(sfd_pl, 0, policy, mac, fid, action, local_port);
1335 num_rec = mlxsw_reg_sfd_num_rec_get(sfd_pl);
1336 err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(sfd), sfd_pl);
1340 if (num_rec != mlxsw_reg_sfd_num_rec_get(sfd_pl))
1348 static int mlxsw_sp_port_fdb_uc_op(struct mlxsw_sp *mlxsw_sp, u8 local_port,
1349 const char *mac, u16 fid, bool adding,
1352 return __mlxsw_sp_port_fdb_uc_op(mlxsw_sp, local_port, mac, fid, adding,
1353 MLXSW_REG_SFD_REC_ACTION_NOP,
1354 mlxsw_sp_sfd_rec_policy(dynamic));
1357 int mlxsw_sp_rif_fdb_op(struct mlxsw_sp *mlxsw_sp, const char *mac, u16 fid,
1360 return __mlxsw_sp_port_fdb_uc_op(mlxsw_sp, 0, mac, fid, adding,
1361 MLXSW_REG_SFD_REC_ACTION_FORWARD_IP_ROUTER,
1362 MLXSW_REG_SFD_REC_POLICY_STATIC_ENTRY);
1365 static int mlxsw_sp_port_fdb_uc_lag_op(struct mlxsw_sp *mlxsw_sp, u16 lag_id,
1366 const char *mac, u16 fid, u16 lag_vid,
1367 bool adding, bool dynamic)
1373 sfd_pl = kmalloc(MLXSW_REG_SFD_LEN, GFP_KERNEL);
1377 mlxsw_reg_sfd_pack(sfd_pl, mlxsw_sp_sfd_op(adding), 0);
1378 mlxsw_reg_sfd_uc_lag_pack(sfd_pl, 0, mlxsw_sp_sfd_rec_policy(dynamic),
1379 mac, fid, MLXSW_REG_SFD_REC_ACTION_NOP,
1381 num_rec = mlxsw_reg_sfd_num_rec_get(sfd_pl);
1382 err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(sfd), sfd_pl);
1386 if (num_rec != mlxsw_reg_sfd_num_rec_get(sfd_pl))
1395 mlxsw_sp_port_fdb_set(struct mlxsw_sp_port *mlxsw_sp_port,
1396 struct switchdev_notifier_fdb_info *fdb_info, bool adding)
1398 struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
1399 struct net_device *orig_dev = fdb_info->info.dev;
1400 struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
1401 struct mlxsw_sp_bridge_device *bridge_device;
1402 struct mlxsw_sp_bridge_port *bridge_port;
1405 bridge_port = mlxsw_sp_bridge_port_find(mlxsw_sp->bridge, orig_dev);
1409 bridge_device = bridge_port->bridge_device;
1410 mlxsw_sp_port_vlan = mlxsw_sp_port_vlan_find_by_bridge(mlxsw_sp_port,
1413 if (!mlxsw_sp_port_vlan)
1416 fid_index = mlxsw_sp_fid_index(mlxsw_sp_port_vlan->fid);
1417 vid = mlxsw_sp_port_vlan->vid;
1419 if (!bridge_port->lagged)
1420 return mlxsw_sp_port_fdb_uc_op(mlxsw_sp,
1421 bridge_port->system_port,
1422 fdb_info->addr, fid_index,
1425 return mlxsw_sp_port_fdb_uc_lag_op(mlxsw_sp,
1426 bridge_port->lag_id,
1427 fdb_info->addr, fid_index,
1428 vid, adding, false);
1431 static int mlxsw_sp_port_mdb_op(struct mlxsw_sp *mlxsw_sp, const char *addr,
1432 u16 fid, u16 mid_idx, bool adding)
1438 sfd_pl = kmalloc(MLXSW_REG_SFD_LEN, GFP_KERNEL);
1442 mlxsw_reg_sfd_pack(sfd_pl, mlxsw_sp_sfd_op(adding), 0);
1443 mlxsw_reg_sfd_mc_pack(sfd_pl, 0, addr, fid,
1444 MLXSW_REG_SFD_REC_ACTION_NOP, mid_idx);
1445 num_rec = mlxsw_reg_sfd_num_rec_get(sfd_pl);
1446 err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(sfd), sfd_pl);
1450 if (num_rec != mlxsw_reg_sfd_num_rec_get(sfd_pl))
1458 static int mlxsw_sp_port_smid_full_entry(struct mlxsw_sp *mlxsw_sp, u16 mid_idx,
1460 bool set_router_port)
1465 smid_pl = kmalloc(MLXSW_REG_SMID_LEN, GFP_KERNEL);
1469 mlxsw_reg_smid_pack(smid_pl, mid_idx, 0, false);
1470 for (i = 1; i < mlxsw_core_max_ports(mlxsw_sp->core); i++) {
1471 if (mlxsw_sp->ports[i])
1472 mlxsw_reg_smid_port_mask_set(smid_pl, i, 1);
1475 mlxsw_reg_smid_port_mask_set(smid_pl,
1476 mlxsw_sp_router_port(mlxsw_sp), 1);
1478 for_each_set_bit(i, ports_bitmap, mlxsw_core_max_ports(mlxsw_sp->core))
1479 mlxsw_reg_smid_port_set(smid_pl, i, 1);
1481 mlxsw_reg_smid_port_set(smid_pl, mlxsw_sp_router_port(mlxsw_sp),
1484 err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(smid), smid_pl);
1489 static int mlxsw_sp_port_smid_set(struct mlxsw_sp_port *mlxsw_sp_port,
1490 u16 mid_idx, bool add)
1492 struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
1496 smid_pl = kmalloc(MLXSW_REG_SMID_LEN, GFP_KERNEL);
1500 mlxsw_reg_smid_pack(smid_pl, mid_idx, mlxsw_sp_port->local_port, add);
1501 err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(smid), smid_pl);
1507 mlxsw_sp_mid *__mlxsw_sp_mc_get(struct mlxsw_sp_bridge_device *bridge_device,
1508 const unsigned char *addr,
1511 struct mlxsw_sp_mid *mid;
1513 list_for_each_entry(mid, &bridge_device->mids_list, list) {
1514 if (ether_addr_equal(mid->addr, addr) && mid->fid == fid)
1521 mlxsw_sp_bridge_port_get_ports_bitmap(struct mlxsw_sp *mlxsw_sp,
1522 struct mlxsw_sp_bridge_port *bridge_port,
1523 unsigned long *ports_bitmap)
1525 struct mlxsw_sp_port *mlxsw_sp_port;
1526 u64 max_lag_members, i;
1529 if (!bridge_port->lagged) {
1530 set_bit(bridge_port->system_port, ports_bitmap);
1532 max_lag_members = MLXSW_CORE_RES_GET(mlxsw_sp->core,
1534 lag_id = bridge_port->lag_id;
1535 for (i = 0; i < max_lag_members; i++) {
1536 mlxsw_sp_port = mlxsw_sp_port_lagged_get(mlxsw_sp,
1539 set_bit(mlxsw_sp_port->local_port,
1546 mlxsw_sp_mc_get_mrouters_bitmap(unsigned long *flood_bitmap,
1547 struct mlxsw_sp_bridge_device *bridge_device,
1548 struct mlxsw_sp *mlxsw_sp)
1550 struct mlxsw_sp_bridge_port *bridge_port;
1552 list_for_each_entry(bridge_port, &bridge_device->ports_list, list) {
1553 if (bridge_port->mrouter) {
1554 mlxsw_sp_bridge_port_get_ports_bitmap(mlxsw_sp,
1562 mlxsw_sp_mc_write_mdb_entry(struct mlxsw_sp *mlxsw_sp,
1563 struct mlxsw_sp_mid *mid,
1564 struct mlxsw_sp_bridge_device *bridge_device)
1572 mid_idx = find_first_zero_bit(mlxsw_sp->bridge->mids_bitmap,
1574 if (mid_idx == MLXSW_SP_MID_MAX)
1577 num_of_ports = mlxsw_core_max_ports(mlxsw_sp->core);
1578 alloc_size = sizeof(long) * BITS_TO_LONGS(num_of_ports);
1579 flood_bitmap = kzalloc(alloc_size, GFP_KERNEL);
1583 bitmap_copy(flood_bitmap, mid->ports_in_mid, num_of_ports);
1584 mlxsw_sp_mc_get_mrouters_bitmap(flood_bitmap, bridge_device, mlxsw_sp);
1587 err = mlxsw_sp_port_smid_full_entry(mlxsw_sp, mid_idx, flood_bitmap,
1588 bridge_device->mrouter);
1589 kfree(flood_bitmap);
1593 err = mlxsw_sp_port_mdb_op(mlxsw_sp, mid->addr, mid->fid, mid_idx,
1598 set_bit(mid_idx, mlxsw_sp->bridge->mids_bitmap);
1603 static int mlxsw_sp_mc_remove_mdb_entry(struct mlxsw_sp *mlxsw_sp,
1604 struct mlxsw_sp_mid *mid)
1609 clear_bit(mid->mid, mlxsw_sp->bridge->mids_bitmap);
1611 return mlxsw_sp_port_mdb_op(mlxsw_sp, mid->addr, mid->fid, mid->mid,
1616 mlxsw_sp_mid *__mlxsw_sp_mc_alloc(struct mlxsw_sp *mlxsw_sp,
1617 struct mlxsw_sp_bridge_device *bridge_device,
1618 const unsigned char *addr,
1621 struct mlxsw_sp_mid *mid;
1624 mid = kzalloc(sizeof(*mid), GFP_KERNEL);
1628 alloc_size = sizeof(unsigned long) *
1629 BITS_TO_LONGS(mlxsw_core_max_ports(mlxsw_sp->core));
1631 mid->ports_in_mid = kzalloc(alloc_size, GFP_KERNEL);
1632 if (!mid->ports_in_mid)
1633 goto err_ports_in_mid_alloc;
1635 ether_addr_copy(mid->addr, addr);
1639 if (!bridge_device->multicast_enabled)
1642 if (!mlxsw_sp_mc_write_mdb_entry(mlxsw_sp, mid, bridge_device))
1643 goto err_write_mdb_entry;
1646 list_add_tail(&mid->list, &bridge_device->mids_list);
1649 err_write_mdb_entry:
1650 kfree(mid->ports_in_mid);
1651 err_ports_in_mid_alloc:
1656 static int mlxsw_sp_port_remove_from_mid(struct mlxsw_sp_port *mlxsw_sp_port,
1657 struct mlxsw_sp_mid *mid)
1659 struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
1662 clear_bit(mlxsw_sp_port->local_port, mid->ports_in_mid);
1663 if (bitmap_empty(mid->ports_in_mid,
1664 mlxsw_core_max_ports(mlxsw_sp->core))) {
1665 err = mlxsw_sp_mc_remove_mdb_entry(mlxsw_sp, mid);
1666 list_del(&mid->list);
1667 kfree(mid->ports_in_mid);
1673 static int mlxsw_sp_port_mdb_add(struct mlxsw_sp_port *mlxsw_sp_port,
1674 const struct switchdev_obj_port_mdb *mdb)
1676 struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
1677 struct net_device *orig_dev = mdb->obj.orig_dev;
1678 struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
1679 struct net_device *dev = mlxsw_sp_port->dev;
1680 struct mlxsw_sp_bridge_device *bridge_device;
1681 struct mlxsw_sp_bridge_port *bridge_port;
1682 struct mlxsw_sp_mid *mid;
1686 bridge_port = mlxsw_sp_bridge_port_find(mlxsw_sp->bridge, orig_dev);
1690 bridge_device = bridge_port->bridge_device;
1691 mlxsw_sp_port_vlan = mlxsw_sp_port_vlan_find_by_bridge(mlxsw_sp_port,
1694 if (!mlxsw_sp_port_vlan)
1697 fid_index = mlxsw_sp_fid_index(mlxsw_sp_port_vlan->fid);
1699 mid = __mlxsw_sp_mc_get(bridge_device, mdb->addr, fid_index);
1701 mid = __mlxsw_sp_mc_alloc(mlxsw_sp, bridge_device, mdb->addr,
1704 netdev_err(dev, "Unable to allocate MC group\n");
1708 set_bit(mlxsw_sp_port->local_port, mid->ports_in_mid);
1710 if (!bridge_device->multicast_enabled)
1713 if (bridge_port->mrouter)
1716 err = mlxsw_sp_port_smid_set(mlxsw_sp_port, mid->mid, true);
1718 netdev_err(dev, "Unable to set SMID\n");
1725 mlxsw_sp_port_remove_from_mid(mlxsw_sp_port, mid);
1730 mlxsw_sp_bridge_mdb_mc_enable_sync(struct mlxsw_sp_port *mlxsw_sp_port,
1731 struct mlxsw_sp_bridge_device
1734 struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
1735 struct mlxsw_sp_mid *mid;
1738 mc_enabled = bridge_device->multicast_enabled;
1740 list_for_each_entry(mid, &bridge_device->mids_list, list) {
1742 mlxsw_sp_mc_write_mdb_entry(mlxsw_sp, mid,
1745 mlxsw_sp_mc_remove_mdb_entry(mlxsw_sp, mid);
1750 mlxsw_sp_port_mrouter_update_mdb(struct mlxsw_sp_port *mlxsw_sp_port,
1751 struct mlxsw_sp_bridge_port *bridge_port,
1754 struct mlxsw_sp_bridge_device *bridge_device;
1755 struct mlxsw_sp_mid *mid;
1757 bridge_device = bridge_port->bridge_device;
1759 list_for_each_entry(mid, &bridge_device->mids_list, list) {
1760 if (!test_bit(mlxsw_sp_port->local_port, mid->ports_in_mid))
1761 mlxsw_sp_port_smid_set(mlxsw_sp_port, mid->mid, add);
1765 static int mlxsw_sp_port_obj_add(struct net_device *dev,
1766 const struct switchdev_obj *obj,
1767 struct netlink_ext_ack *extack)
1769 struct mlxsw_sp_port *mlxsw_sp_port = netdev_priv(dev);
1770 const struct switchdev_obj_port_vlan *vlan;
1774 case SWITCHDEV_OBJ_ID_PORT_VLAN:
1775 vlan = SWITCHDEV_OBJ_PORT_VLAN(obj);
1777 err = mlxsw_sp_port_vlans_add(mlxsw_sp_port, vlan, extack);
1779 /* The event is emitted before the changes are actually
1780 * applied to the bridge. Therefore schedule the respin
1781 * call for later, so that the respin logic sees the
1782 * updated bridge state.
1784 mlxsw_sp_span_respin(mlxsw_sp_port->mlxsw_sp);
1786 case SWITCHDEV_OBJ_ID_PORT_MDB:
1787 err = mlxsw_sp_port_mdb_add(mlxsw_sp_port,
1788 SWITCHDEV_OBJ_PORT_MDB(obj));
1799 mlxsw_sp_bridge_port_vlan_del(struct mlxsw_sp_port *mlxsw_sp_port,
1800 struct mlxsw_sp_bridge_port *bridge_port, u16 vid)
1802 u16 pvid = mlxsw_sp_port->pvid == vid ? 0 : mlxsw_sp_port->pvid;
1803 struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
1806 mlxsw_sp_port_vlan = mlxsw_sp_port_vlan_find_by_vid(mlxsw_sp_port, vid);
1807 if (WARN_ON(!mlxsw_sp_port_vlan))
1810 mlxsw_sp_port_vlan_bridge_leave(mlxsw_sp_port_vlan);
1811 br_vlan_get_proto(bridge_port->bridge_device->dev, &proto);
1812 mlxsw_sp_port_pvid_set(mlxsw_sp_port, pvid, proto);
1813 mlxsw_sp_port_vlan_set(mlxsw_sp_port, vid, vid, false, false);
1814 mlxsw_sp_port_vlan_destroy(mlxsw_sp_port_vlan);
1817 static int mlxsw_sp_port_vlans_del(struct mlxsw_sp_port *mlxsw_sp_port,
1818 const struct switchdev_obj_port_vlan *vlan)
1820 struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
1821 struct net_device *orig_dev = vlan->obj.orig_dev;
1822 struct mlxsw_sp_bridge_port *bridge_port;
1824 if (netif_is_bridge_master(orig_dev))
1827 bridge_port = mlxsw_sp_bridge_port_find(mlxsw_sp->bridge, orig_dev);
1828 if (WARN_ON(!bridge_port))
1831 if (!bridge_port->bridge_device->vlan_enabled)
1834 mlxsw_sp_bridge_port_vlan_del(mlxsw_sp_port, bridge_port, vlan->vid);
1840 __mlxsw_sp_port_mdb_del(struct mlxsw_sp_port *mlxsw_sp_port,
1841 struct mlxsw_sp_bridge_port *bridge_port,
1842 struct mlxsw_sp_mid *mid)
1844 struct net_device *dev = mlxsw_sp_port->dev;
1847 if (bridge_port->bridge_device->multicast_enabled &&
1848 !bridge_port->mrouter) {
1849 err = mlxsw_sp_port_smid_set(mlxsw_sp_port, mid->mid, false);
1851 netdev_err(dev, "Unable to remove port from SMID\n");
1854 err = mlxsw_sp_port_remove_from_mid(mlxsw_sp_port, mid);
1856 netdev_err(dev, "Unable to remove MC SFD\n");
1861 static int mlxsw_sp_port_mdb_del(struct mlxsw_sp_port *mlxsw_sp_port,
1862 const struct switchdev_obj_port_mdb *mdb)
1864 struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
1865 struct net_device *orig_dev = mdb->obj.orig_dev;
1866 struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
1867 struct mlxsw_sp_bridge_device *bridge_device;
1868 struct net_device *dev = mlxsw_sp_port->dev;
1869 struct mlxsw_sp_bridge_port *bridge_port;
1870 struct mlxsw_sp_mid *mid;
1873 bridge_port = mlxsw_sp_bridge_port_find(mlxsw_sp->bridge, orig_dev);
1877 bridge_device = bridge_port->bridge_device;
1878 mlxsw_sp_port_vlan = mlxsw_sp_port_vlan_find_by_bridge(mlxsw_sp_port,
1881 if (!mlxsw_sp_port_vlan)
1884 fid_index = mlxsw_sp_fid_index(mlxsw_sp_port_vlan->fid);
1886 mid = __mlxsw_sp_mc_get(bridge_device, mdb->addr, fid_index);
1888 netdev_err(dev, "Unable to remove port from MC DB\n");
1892 return __mlxsw_sp_port_mdb_del(mlxsw_sp_port, bridge_port, mid);
1896 mlxsw_sp_bridge_port_mdb_flush(struct mlxsw_sp_port *mlxsw_sp_port,
1897 struct mlxsw_sp_bridge_port *bridge_port)
1899 struct mlxsw_sp_bridge_device *bridge_device;
1900 struct mlxsw_sp_mid *mid, *tmp;
1902 bridge_device = bridge_port->bridge_device;
1904 list_for_each_entry_safe(mid, tmp, &bridge_device->mids_list, list) {
1905 if (test_bit(mlxsw_sp_port->local_port, mid->ports_in_mid)) {
1906 __mlxsw_sp_port_mdb_del(mlxsw_sp_port, bridge_port,
1908 } else if (bridge_device->multicast_enabled &&
1909 bridge_port->mrouter) {
1910 mlxsw_sp_port_smid_set(mlxsw_sp_port, mid->mid, false);
1915 static int mlxsw_sp_port_obj_del(struct net_device *dev,
1916 const struct switchdev_obj *obj)
1918 struct mlxsw_sp_port *mlxsw_sp_port = netdev_priv(dev);
1922 case SWITCHDEV_OBJ_ID_PORT_VLAN:
1923 err = mlxsw_sp_port_vlans_del(mlxsw_sp_port,
1924 SWITCHDEV_OBJ_PORT_VLAN(obj));
1926 case SWITCHDEV_OBJ_ID_PORT_MDB:
1927 err = mlxsw_sp_port_mdb_del(mlxsw_sp_port,
1928 SWITCHDEV_OBJ_PORT_MDB(obj));
1935 mlxsw_sp_span_respin(mlxsw_sp_port->mlxsw_sp);
1940 static struct mlxsw_sp_port *mlxsw_sp_lag_rep_port(struct mlxsw_sp *mlxsw_sp,
1943 struct mlxsw_sp_port *mlxsw_sp_port;
1944 u64 max_lag_members;
1947 max_lag_members = MLXSW_CORE_RES_GET(mlxsw_sp->core,
1949 for (i = 0; i < max_lag_members; i++) {
1950 mlxsw_sp_port = mlxsw_sp_port_lagged_get(mlxsw_sp, lag_id, i);
1952 return mlxsw_sp_port;
1958 mlxsw_sp_bridge_vlan_aware_port_join(struct mlxsw_sp_bridge_port *bridge_port,
1959 struct mlxsw_sp_port *mlxsw_sp_port,
1960 struct netlink_ext_ack *extack)
1962 if (is_vlan_dev(bridge_port->dev)) {
1963 NL_SET_ERR_MSG_MOD(extack, "Can not enslave a VLAN device to a VLAN-aware bridge");
1967 /* Port is no longer usable as a router interface */
1968 if (mlxsw_sp_port->default_vlan->fid)
1969 mlxsw_sp_port_vlan_router_leave(mlxsw_sp_port->default_vlan);
1975 mlxsw_sp_bridge_8021q_port_join(struct mlxsw_sp_bridge_device *bridge_device,
1976 struct mlxsw_sp_bridge_port *bridge_port,
1977 struct mlxsw_sp_port *mlxsw_sp_port,
1978 struct netlink_ext_ack *extack)
1980 return mlxsw_sp_bridge_vlan_aware_port_join(bridge_port, mlxsw_sp_port,
1985 mlxsw_sp_bridge_vlan_aware_port_leave(struct mlxsw_sp_port *mlxsw_sp_port)
1987 /* Make sure untagged frames are allowed to ingress */
1988 mlxsw_sp_port_pvid_set(mlxsw_sp_port, MLXSW_SP_DEFAULT_VID,
1993 mlxsw_sp_bridge_8021q_port_leave(struct mlxsw_sp_bridge_device *bridge_device,
1994 struct mlxsw_sp_bridge_port *bridge_port,
1995 struct mlxsw_sp_port *mlxsw_sp_port)
1997 mlxsw_sp_bridge_vlan_aware_port_leave(mlxsw_sp_port);
2001 mlxsw_sp_bridge_vlan_aware_vxlan_join(struct mlxsw_sp_bridge_device *bridge_device,
2002 const struct net_device *vxlan_dev,
2003 u16 vid, u16 ethertype,
2004 struct netlink_ext_ack *extack)
2006 struct mlxsw_sp *mlxsw_sp = mlxsw_sp_lower_get(bridge_device->dev);
2007 struct vxlan_dev *vxlan = netdev_priv(vxlan_dev);
2008 struct mlxsw_sp_nve_params params = {
2009 .type = MLXSW_SP_NVE_TYPE_VXLAN,
2010 .vni = vxlan->cfg.vni,
2012 .ethertype = ethertype,
2014 struct mlxsw_sp_fid *fid;
2017 /* If the VLAN is 0, we need to find the VLAN that is configured as
2018 * PVID and egress untagged on the bridge port of the VxLAN device.
2019 * It is possible no such VLAN exists
2022 err = mlxsw_sp_vxlan_mapped_vid(vxlan_dev, &vid);
2027 fid = mlxsw_sp_fid_8021q_get(mlxsw_sp, vid);
2029 NL_SET_ERR_MSG_MOD(extack, "Failed to create 802.1Q FID");
2030 return PTR_ERR(fid);
2033 if (mlxsw_sp_fid_vni_is_set(fid)) {
2034 NL_SET_ERR_MSG_MOD(extack, "VNI is already set on FID");
2036 goto err_vni_exists;
2039 err = mlxsw_sp_nve_fid_enable(mlxsw_sp, fid, ¶ms, extack);
2041 goto err_nve_fid_enable;
2047 mlxsw_sp_fid_put(fid);
2052 mlxsw_sp_bridge_8021q_vxlan_join(struct mlxsw_sp_bridge_device *bridge_device,
2053 const struct net_device *vxlan_dev, u16 vid,
2054 struct netlink_ext_ack *extack)
2056 return mlxsw_sp_bridge_vlan_aware_vxlan_join(bridge_device, vxlan_dev,
2057 vid, ETH_P_8021Q, extack);
2060 static struct net_device *
2061 mlxsw_sp_bridge_8021q_vxlan_dev_find(struct net_device *br_dev, u16 vid)
2063 struct net_device *dev;
2064 struct list_head *iter;
2066 netdev_for_each_lower_dev(br_dev, dev, iter) {
2070 if (!netif_is_vxlan(dev))
2073 err = mlxsw_sp_vxlan_mapped_vid(dev, &pvid);
2074 if (err || pvid != vid)
2083 static struct mlxsw_sp_fid *
2084 mlxsw_sp_bridge_8021q_fid_get(struct mlxsw_sp_bridge_device *bridge_device,
2085 u16 vid, struct netlink_ext_ack *extack)
2087 struct mlxsw_sp *mlxsw_sp = mlxsw_sp_lower_get(bridge_device->dev);
2089 return mlxsw_sp_fid_8021q_get(mlxsw_sp, vid);
2092 static struct mlxsw_sp_fid *
2093 mlxsw_sp_bridge_8021q_fid_lookup(struct mlxsw_sp_bridge_device *bridge_device,
2096 struct mlxsw_sp *mlxsw_sp = mlxsw_sp_lower_get(bridge_device->dev);
2098 return mlxsw_sp_fid_8021q_lookup(mlxsw_sp, vid);
2102 mlxsw_sp_bridge_8021q_fid_vid(struct mlxsw_sp_bridge_device *bridge_device,
2103 const struct mlxsw_sp_fid *fid)
2105 return mlxsw_sp_fid_8021q_vid(fid);
2108 static const struct mlxsw_sp_bridge_ops mlxsw_sp_bridge_8021q_ops = {
2109 .port_join = mlxsw_sp_bridge_8021q_port_join,
2110 .port_leave = mlxsw_sp_bridge_8021q_port_leave,
2111 .vxlan_join = mlxsw_sp_bridge_8021q_vxlan_join,
2112 .fid_get = mlxsw_sp_bridge_8021q_fid_get,
2113 .fid_lookup = mlxsw_sp_bridge_8021q_fid_lookup,
2114 .fid_vid = mlxsw_sp_bridge_8021q_fid_vid,
2118 mlxsw_sp_port_is_br_member(const struct mlxsw_sp_port *mlxsw_sp_port,
2119 const struct net_device *br_dev)
2121 struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
2123 list_for_each_entry(mlxsw_sp_port_vlan, &mlxsw_sp_port->vlans_list,
2125 if (mlxsw_sp_port_vlan->bridge_port &&
2126 mlxsw_sp_port_vlan->bridge_port->bridge_device->dev ==
2135 mlxsw_sp_bridge_8021d_port_join(struct mlxsw_sp_bridge_device *bridge_device,
2136 struct mlxsw_sp_bridge_port *bridge_port,
2137 struct mlxsw_sp_port *mlxsw_sp_port,
2138 struct netlink_ext_ack *extack)
2140 struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
2141 struct net_device *dev = bridge_port->dev;
2144 vid = is_vlan_dev(dev) ? vlan_dev_vlan_id(dev) : MLXSW_SP_DEFAULT_VID;
2145 mlxsw_sp_port_vlan = mlxsw_sp_port_vlan_find_by_vid(mlxsw_sp_port, vid);
2146 if (WARN_ON(!mlxsw_sp_port_vlan))
2149 if (mlxsw_sp_port_is_br_member(mlxsw_sp_port, bridge_device->dev)) {
2150 NL_SET_ERR_MSG_MOD(extack, "Can not bridge VLAN uppers of the same port");
2154 /* Port is no longer usable as a router interface */
2155 if (mlxsw_sp_port_vlan->fid)
2156 mlxsw_sp_port_vlan_router_leave(mlxsw_sp_port_vlan);
2158 return mlxsw_sp_port_vlan_bridge_join(mlxsw_sp_port_vlan, bridge_port,
2163 mlxsw_sp_bridge_8021d_port_leave(struct mlxsw_sp_bridge_device *bridge_device,
2164 struct mlxsw_sp_bridge_port *bridge_port,
2165 struct mlxsw_sp_port *mlxsw_sp_port)
2167 struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
2168 struct net_device *dev = bridge_port->dev;
2171 vid = is_vlan_dev(dev) ? vlan_dev_vlan_id(dev) : MLXSW_SP_DEFAULT_VID;
2172 mlxsw_sp_port_vlan = mlxsw_sp_port_vlan_find_by_vid(mlxsw_sp_port, vid);
2173 if (!mlxsw_sp_port_vlan || !mlxsw_sp_port_vlan->bridge_port)
2176 mlxsw_sp_port_vlan_bridge_leave(mlxsw_sp_port_vlan);
2180 mlxsw_sp_bridge_8021d_vxlan_join(struct mlxsw_sp_bridge_device *bridge_device,
2181 const struct net_device *vxlan_dev, u16 vid,
2182 struct netlink_ext_ack *extack)
2184 struct mlxsw_sp *mlxsw_sp = mlxsw_sp_lower_get(bridge_device->dev);
2185 struct vxlan_dev *vxlan = netdev_priv(vxlan_dev);
2186 struct mlxsw_sp_nve_params params = {
2187 .type = MLXSW_SP_NVE_TYPE_VXLAN,
2188 .vni = vxlan->cfg.vni,
2190 .ethertype = ETH_P_8021Q,
2192 struct mlxsw_sp_fid *fid;
2195 fid = mlxsw_sp_fid_8021d_get(mlxsw_sp, bridge_device->dev->ifindex);
2197 NL_SET_ERR_MSG_MOD(extack, "Failed to create 802.1D FID");
2201 if (mlxsw_sp_fid_vni_is_set(fid)) {
2202 NL_SET_ERR_MSG_MOD(extack, "VNI is already set on FID");
2204 goto err_vni_exists;
2207 err = mlxsw_sp_nve_fid_enable(mlxsw_sp, fid, ¶ms, extack);
2209 goto err_nve_fid_enable;
2215 mlxsw_sp_fid_put(fid);
2219 static struct mlxsw_sp_fid *
2220 mlxsw_sp_bridge_8021d_fid_get(struct mlxsw_sp_bridge_device *bridge_device,
2221 u16 vid, struct netlink_ext_ack *extack)
2223 struct mlxsw_sp *mlxsw_sp = mlxsw_sp_lower_get(bridge_device->dev);
2225 return mlxsw_sp_fid_8021d_get(mlxsw_sp, bridge_device->dev->ifindex);
2228 static struct mlxsw_sp_fid *
2229 mlxsw_sp_bridge_8021d_fid_lookup(struct mlxsw_sp_bridge_device *bridge_device,
2232 struct mlxsw_sp *mlxsw_sp = mlxsw_sp_lower_get(bridge_device->dev);
2234 /* The only valid VLAN for a VLAN-unaware bridge is 0 */
2238 return mlxsw_sp_fid_8021d_lookup(mlxsw_sp, bridge_device->dev->ifindex);
2242 mlxsw_sp_bridge_8021d_fid_vid(struct mlxsw_sp_bridge_device *bridge_device,
2243 const struct mlxsw_sp_fid *fid)
2248 static const struct mlxsw_sp_bridge_ops mlxsw_sp_bridge_8021d_ops = {
2249 .port_join = mlxsw_sp_bridge_8021d_port_join,
2250 .port_leave = mlxsw_sp_bridge_8021d_port_leave,
2251 .vxlan_join = mlxsw_sp_bridge_8021d_vxlan_join,
2252 .fid_get = mlxsw_sp_bridge_8021d_fid_get,
2253 .fid_lookup = mlxsw_sp_bridge_8021d_fid_lookup,
2254 .fid_vid = mlxsw_sp_bridge_8021d_fid_vid,
2258 mlxsw_sp_bridge_8021ad_port_join(struct mlxsw_sp_bridge_device *bridge_device,
2259 struct mlxsw_sp_bridge_port *bridge_port,
2260 struct mlxsw_sp_port *mlxsw_sp_port,
2261 struct netlink_ext_ack *extack)
2265 err = mlxsw_sp_port_vlan_classification_set(mlxsw_sp_port, true, false);
2269 err = mlxsw_sp_bridge_vlan_aware_port_join(bridge_port, mlxsw_sp_port,
2272 goto err_bridge_vlan_aware_port_join;
2276 err_bridge_vlan_aware_port_join:
2277 mlxsw_sp_port_vlan_classification_set(mlxsw_sp_port, false, true);
2282 mlxsw_sp_bridge_8021ad_port_leave(struct mlxsw_sp_bridge_device *bridge_device,
2283 struct mlxsw_sp_bridge_port *bridge_port,
2284 struct mlxsw_sp_port *mlxsw_sp_port)
2286 mlxsw_sp_bridge_vlan_aware_port_leave(mlxsw_sp_port);
2287 mlxsw_sp_port_vlan_classification_set(mlxsw_sp_port, false, true);
2291 mlxsw_sp_bridge_8021ad_vxlan_join(struct mlxsw_sp_bridge_device *bridge_device,
2292 const struct net_device *vxlan_dev, u16 vid,
2293 struct netlink_ext_ack *extack)
2295 return mlxsw_sp_bridge_vlan_aware_vxlan_join(bridge_device, vxlan_dev,
2296 vid, ETH_P_8021AD, extack);
2299 static const struct mlxsw_sp_bridge_ops mlxsw_sp_bridge_8021ad_ops = {
2300 .port_join = mlxsw_sp_bridge_8021ad_port_join,
2301 .port_leave = mlxsw_sp_bridge_8021ad_port_leave,
2302 .vxlan_join = mlxsw_sp_bridge_8021ad_vxlan_join,
2303 .fid_get = mlxsw_sp_bridge_8021q_fid_get,
2304 .fid_lookup = mlxsw_sp_bridge_8021q_fid_lookup,
2305 .fid_vid = mlxsw_sp_bridge_8021q_fid_vid,
2308 int mlxsw_sp_port_bridge_join(struct mlxsw_sp_port *mlxsw_sp_port,
2309 struct net_device *brport_dev,
2310 struct net_device *br_dev,
2311 struct netlink_ext_ack *extack)
2313 struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
2314 struct mlxsw_sp_bridge_device *bridge_device;
2315 struct mlxsw_sp_bridge_port *bridge_port;
2318 bridge_port = mlxsw_sp_bridge_port_get(mlxsw_sp->bridge, brport_dev,
2320 if (IS_ERR(bridge_port))
2321 return PTR_ERR(bridge_port);
2322 bridge_device = bridge_port->bridge_device;
2324 err = bridge_device->ops->port_join(bridge_device, bridge_port,
2325 mlxsw_sp_port, extack);
2332 mlxsw_sp_bridge_port_put(mlxsw_sp->bridge, bridge_port);
2336 void mlxsw_sp_port_bridge_leave(struct mlxsw_sp_port *mlxsw_sp_port,
2337 struct net_device *brport_dev,
2338 struct net_device *br_dev)
2340 struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
2341 struct mlxsw_sp_bridge_device *bridge_device;
2342 struct mlxsw_sp_bridge_port *bridge_port;
2344 bridge_device = mlxsw_sp_bridge_device_find(mlxsw_sp->bridge, br_dev);
2347 bridge_port = __mlxsw_sp_bridge_port_find(bridge_device, brport_dev);
2351 bridge_device->ops->port_leave(bridge_device, bridge_port,
2353 mlxsw_sp_bridge_port_put(mlxsw_sp->bridge, bridge_port);
2356 int mlxsw_sp_bridge_vxlan_join(struct mlxsw_sp *mlxsw_sp,
2357 const struct net_device *br_dev,
2358 const struct net_device *vxlan_dev, u16 vid,
2359 struct netlink_ext_ack *extack)
2361 struct mlxsw_sp_bridge_device *bridge_device;
2363 bridge_device = mlxsw_sp_bridge_device_find(mlxsw_sp->bridge, br_dev);
2364 if (WARN_ON(!bridge_device))
2367 return bridge_device->ops->vxlan_join(bridge_device, vxlan_dev, vid,
2371 void mlxsw_sp_bridge_vxlan_leave(struct mlxsw_sp *mlxsw_sp,
2372 const struct net_device *vxlan_dev)
2374 struct vxlan_dev *vxlan = netdev_priv(vxlan_dev);
2375 struct mlxsw_sp_fid *fid;
2377 /* If the VxLAN device is down, then the FID does not have a VNI */
2378 fid = mlxsw_sp_fid_lookup_by_vni(mlxsw_sp, vxlan->cfg.vni);
2382 mlxsw_sp_nve_fid_disable(mlxsw_sp, fid);
2383 /* Drop both the reference we just took during lookup and the reference
2384 * the VXLAN device took.
2386 mlxsw_sp_fid_put(fid);
2387 mlxsw_sp_fid_put(fid);
2391 mlxsw_sp_switchdev_vxlan_addr_convert(const union vxlan_addr *vxlan_addr,
2392 enum mlxsw_sp_l3proto *proto,
2393 union mlxsw_sp_l3addr *addr)
2395 if (vxlan_addr->sa.sa_family == AF_INET) {
2396 addr->addr4 = vxlan_addr->sin.sin_addr.s_addr;
2397 *proto = MLXSW_SP_L3_PROTO_IPV4;
2399 addr->addr6 = vxlan_addr->sin6.sin6_addr;
2400 *proto = MLXSW_SP_L3_PROTO_IPV6;
2405 mlxsw_sp_switchdev_addr_vxlan_convert(enum mlxsw_sp_l3proto proto,
2406 const union mlxsw_sp_l3addr *addr,
2407 union vxlan_addr *vxlan_addr)
2410 case MLXSW_SP_L3_PROTO_IPV4:
2411 vxlan_addr->sa.sa_family = AF_INET;
2412 vxlan_addr->sin.sin_addr.s_addr = addr->addr4;
2414 case MLXSW_SP_L3_PROTO_IPV6:
2415 vxlan_addr->sa.sa_family = AF_INET6;
2416 vxlan_addr->sin6.sin6_addr = addr->addr6;
2421 static void mlxsw_sp_fdb_vxlan_call_notifiers(struct net_device *dev,
2423 enum mlxsw_sp_l3proto proto,
2424 union mlxsw_sp_l3addr *addr,
2425 __be32 vni, bool adding)
2427 struct switchdev_notifier_vxlan_fdb_info info;
2428 struct vxlan_dev *vxlan = netdev_priv(dev);
2429 enum switchdev_notifier_type type;
2431 type = adding ? SWITCHDEV_VXLAN_FDB_ADD_TO_BRIDGE :
2432 SWITCHDEV_VXLAN_FDB_DEL_TO_BRIDGE;
2433 mlxsw_sp_switchdev_addr_vxlan_convert(proto, addr, &info.remote_ip);
2434 info.remote_port = vxlan->cfg.dst_port;
2435 info.remote_vni = vni;
2436 info.remote_ifindex = 0;
2437 ether_addr_copy(info.eth_addr, mac);
2439 info.offloaded = adding;
2440 call_switchdev_notifiers(type, dev, &info.info, NULL);
2443 static void mlxsw_sp_fdb_nve_call_notifiers(struct net_device *dev,
2445 enum mlxsw_sp_l3proto proto,
2446 union mlxsw_sp_l3addr *addr,
2450 if (netif_is_vxlan(dev))
2451 mlxsw_sp_fdb_vxlan_call_notifiers(dev, mac, proto, addr, vni,
2456 mlxsw_sp_fdb_call_notifiers(enum switchdev_notifier_type type,
2457 const char *mac, u16 vid,
2458 struct net_device *dev, bool offloaded)
2460 struct switchdev_notifier_fdb_info info;
2464 info.offloaded = offloaded;
2465 call_switchdev_notifiers(type, dev, &info.info, NULL);
2468 static void mlxsw_sp_fdb_notify_mac_process(struct mlxsw_sp *mlxsw_sp,
2469 char *sfn_pl, int rec_index,
2472 struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
2473 struct mlxsw_sp_bridge_device *bridge_device;
2474 struct mlxsw_sp_bridge_port *bridge_port;
2475 struct mlxsw_sp_port *mlxsw_sp_port;
2476 enum switchdev_notifier_type type;
2480 bool do_notification = true;
2483 mlxsw_reg_sfn_mac_unpack(sfn_pl, rec_index, mac, &fid, &local_port);
2484 mlxsw_sp_port = mlxsw_sp->ports[local_port];
2485 if (!mlxsw_sp_port) {
2486 dev_err_ratelimited(mlxsw_sp->bus_info->dev, "Incorrect local port in FDB notification\n");
2490 if (mlxsw_sp_fid_is_dummy(mlxsw_sp, fid))
2493 mlxsw_sp_port_vlan = mlxsw_sp_port_vlan_find_by_fid(mlxsw_sp_port, fid);
2494 if (!mlxsw_sp_port_vlan) {
2495 netdev_err(mlxsw_sp_port->dev, "Failed to find a matching {Port, VID} following FDB notification\n");
2499 bridge_port = mlxsw_sp_port_vlan->bridge_port;
2501 netdev_err(mlxsw_sp_port->dev, "{Port, VID} not associated with a bridge\n");
2505 bridge_device = bridge_port->bridge_device;
2506 vid = bridge_device->vlan_enabled ? mlxsw_sp_port_vlan->vid : 0;
2509 err = mlxsw_sp_port_fdb_uc_op(mlxsw_sp, local_port, mac, fid,
2512 dev_err_ratelimited(mlxsw_sp->bus_info->dev, "Failed to set FDB entry\n");
2516 if (!do_notification)
2518 type = adding ? SWITCHDEV_FDB_ADD_TO_BRIDGE : SWITCHDEV_FDB_DEL_TO_BRIDGE;
2519 mlxsw_sp_fdb_call_notifiers(type, mac, vid, bridge_port->dev, adding);
2525 do_notification = false;
2529 static void mlxsw_sp_fdb_notify_mac_lag_process(struct mlxsw_sp *mlxsw_sp,
2530 char *sfn_pl, int rec_index,
2533 struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
2534 struct mlxsw_sp_bridge_device *bridge_device;
2535 struct mlxsw_sp_bridge_port *bridge_port;
2536 struct mlxsw_sp_port *mlxsw_sp_port;
2537 enum switchdev_notifier_type type;
2542 bool do_notification = true;
2545 mlxsw_reg_sfn_mac_lag_unpack(sfn_pl, rec_index, mac, &fid, &lag_id);
2546 mlxsw_sp_port = mlxsw_sp_lag_rep_port(mlxsw_sp, lag_id);
2547 if (!mlxsw_sp_port) {
2548 dev_err_ratelimited(mlxsw_sp->bus_info->dev, "Cannot find port representor for LAG\n");
2552 if (mlxsw_sp_fid_is_dummy(mlxsw_sp, fid))
2555 mlxsw_sp_port_vlan = mlxsw_sp_port_vlan_find_by_fid(mlxsw_sp_port, fid);
2556 if (!mlxsw_sp_port_vlan) {
2557 netdev_err(mlxsw_sp_port->dev, "Failed to find a matching {Port, VID} following FDB notification\n");
2561 bridge_port = mlxsw_sp_port_vlan->bridge_port;
2563 netdev_err(mlxsw_sp_port->dev, "{Port, VID} not associated with a bridge\n");
2567 bridge_device = bridge_port->bridge_device;
2568 vid = bridge_device->vlan_enabled ? mlxsw_sp_port_vlan->vid : 0;
2569 lag_vid = mlxsw_sp_fid_lag_vid_valid(mlxsw_sp_port_vlan->fid) ?
2570 mlxsw_sp_port_vlan->vid : 0;
2573 err = mlxsw_sp_port_fdb_uc_lag_op(mlxsw_sp, lag_id, mac, fid, lag_vid,
2576 dev_err_ratelimited(mlxsw_sp->bus_info->dev, "Failed to set FDB entry\n");
2580 if (!do_notification)
2582 type = adding ? SWITCHDEV_FDB_ADD_TO_BRIDGE : SWITCHDEV_FDB_DEL_TO_BRIDGE;
2583 mlxsw_sp_fdb_call_notifiers(type, mac, vid, bridge_port->dev, adding);
2589 do_notification = false;
2594 __mlxsw_sp_fdb_notify_mac_uc_tunnel_process(struct mlxsw_sp *mlxsw_sp,
2595 const struct mlxsw_sp_fid *fid,
2597 struct net_device **nve_dev,
2598 u16 *p_vid, __be32 *p_vni)
2600 struct mlxsw_sp_bridge_device *bridge_device;
2601 struct net_device *br_dev, *dev;
2605 err = mlxsw_sp_fid_nve_ifindex(fid, &nve_ifindex);
2609 err = mlxsw_sp_fid_vni(fid, p_vni);
2613 dev = __dev_get_by_index(mlxsw_sp_net(mlxsw_sp), nve_ifindex);
2618 if (!netif_running(dev))
2621 if (adding && !br_port_flag_is_set(dev, BR_LEARNING))
2624 if (adding && netif_is_vxlan(dev)) {
2625 struct vxlan_dev *vxlan = netdev_priv(dev);
2627 if (!(vxlan->cfg.flags & VXLAN_F_LEARN))
2631 br_dev = netdev_master_upper_dev_get(dev);
2635 bridge_device = mlxsw_sp_bridge_device_find(mlxsw_sp->bridge, br_dev);
2639 *p_vid = bridge_device->ops->fid_vid(bridge_device, fid);
2644 static void mlxsw_sp_fdb_notify_mac_uc_tunnel_process(struct mlxsw_sp *mlxsw_sp,
2649 enum mlxsw_reg_sfn_uc_tunnel_protocol sfn_proto;
2650 enum switchdev_notifier_type type;
2651 struct net_device *nve_dev;
2652 union mlxsw_sp_l3addr addr;
2653 struct mlxsw_sp_fid *fid;
2660 mlxsw_reg_sfn_uc_tunnel_unpack(sfn_pl, rec_index, mac, &fid_index,
2663 fid = mlxsw_sp_fid_lookup_by_index(mlxsw_sp, fid_index);
2665 goto err_fid_lookup;
2667 err = mlxsw_sp_nve_learned_ip_resolve(mlxsw_sp, uip,
2668 (enum mlxsw_sp_l3proto) sfn_proto,
2671 goto err_ip_resolve;
2673 err = __mlxsw_sp_fdb_notify_mac_uc_tunnel_process(mlxsw_sp, fid, adding,
2674 &nve_dev, &vid, &vni);
2676 goto err_fdb_process;
2678 err = mlxsw_sp_port_fdb_tunnel_uc_op(mlxsw_sp, mac, fid_index,
2679 (enum mlxsw_sp_l3proto) sfn_proto,
2680 &addr, adding, true);
2684 mlxsw_sp_fdb_nve_call_notifiers(nve_dev, mac,
2685 (enum mlxsw_sp_l3proto) sfn_proto,
2686 &addr, vni, adding);
2688 type = adding ? SWITCHDEV_FDB_ADD_TO_BRIDGE :
2689 SWITCHDEV_FDB_DEL_TO_BRIDGE;
2690 mlxsw_sp_fdb_call_notifiers(type, mac, vid, nve_dev, adding);
2692 mlxsw_sp_fid_put(fid);
2699 mlxsw_sp_fid_put(fid);
2701 /* Remove an FDB entry in case we cannot process it. Otherwise the
2702 * device will keep sending the same notification over and over again.
2704 mlxsw_sp_port_fdb_tunnel_uc_op(mlxsw_sp, mac, fid_index,
2705 (enum mlxsw_sp_l3proto) sfn_proto, &addr,
2709 static void mlxsw_sp_fdb_notify_rec_process(struct mlxsw_sp *mlxsw_sp,
2710 char *sfn_pl, int rec_index)
2712 switch (mlxsw_reg_sfn_rec_type_get(sfn_pl, rec_index)) {
2713 case MLXSW_REG_SFN_REC_TYPE_LEARNED_MAC:
2714 mlxsw_sp_fdb_notify_mac_process(mlxsw_sp, sfn_pl,
2717 case MLXSW_REG_SFN_REC_TYPE_AGED_OUT_MAC:
2718 mlxsw_sp_fdb_notify_mac_process(mlxsw_sp, sfn_pl,
2721 case MLXSW_REG_SFN_REC_TYPE_LEARNED_MAC_LAG:
2722 mlxsw_sp_fdb_notify_mac_lag_process(mlxsw_sp, sfn_pl,
2725 case MLXSW_REG_SFN_REC_TYPE_AGED_OUT_MAC_LAG:
2726 mlxsw_sp_fdb_notify_mac_lag_process(mlxsw_sp, sfn_pl,
2729 case MLXSW_REG_SFN_REC_TYPE_LEARNED_UNICAST_TUNNEL:
2730 mlxsw_sp_fdb_notify_mac_uc_tunnel_process(mlxsw_sp, sfn_pl,
2733 case MLXSW_REG_SFN_REC_TYPE_AGED_OUT_UNICAST_TUNNEL:
2734 mlxsw_sp_fdb_notify_mac_uc_tunnel_process(mlxsw_sp, sfn_pl,
2740 static void mlxsw_sp_fdb_notify_work_schedule(struct mlxsw_sp *mlxsw_sp,
2743 struct mlxsw_sp_bridge *bridge = mlxsw_sp->bridge;
2744 unsigned int interval = no_delay ? 0 : bridge->fdb_notify.interval;
2746 mlxsw_core_schedule_dw(&bridge->fdb_notify.dw,
2747 msecs_to_jiffies(interval));
2750 #define MLXSW_SP_FDB_SFN_QUERIES_PER_SESSION 10
2752 static void mlxsw_sp_fdb_notify_work(struct work_struct *work)
2754 struct mlxsw_sp_bridge *bridge;
2755 struct mlxsw_sp *mlxsw_sp;
2762 sfn_pl = kmalloc(MLXSW_REG_SFN_LEN, GFP_KERNEL);
2766 bridge = container_of(work, struct mlxsw_sp_bridge, fdb_notify.dw.work);
2767 mlxsw_sp = bridge->mlxsw_sp;
2770 queries = MLXSW_SP_FDB_SFN_QUERIES_PER_SESSION;
2771 while (queries > 0) {
2772 mlxsw_reg_sfn_pack(sfn_pl);
2773 err = mlxsw_reg_query(mlxsw_sp->core, MLXSW_REG(sfn), sfn_pl);
2775 dev_err_ratelimited(mlxsw_sp->bus_info->dev, "Failed to get FDB notifications\n");
2778 num_rec = mlxsw_reg_sfn_num_rec_get(sfn_pl);
2779 for (i = 0; i < num_rec; i++)
2780 mlxsw_sp_fdb_notify_rec_process(mlxsw_sp, sfn_pl, i);
2781 if (num_rec != MLXSW_REG_SFN_REC_MAX_COUNT)
2789 mlxsw_sp_fdb_notify_work_schedule(mlxsw_sp, !queries);
2792 struct mlxsw_sp_switchdev_event_work {
2793 struct work_struct work;
2795 struct switchdev_notifier_fdb_info fdb_info;
2796 struct switchdev_notifier_vxlan_fdb_info vxlan_fdb_info;
2798 struct net_device *dev;
2799 unsigned long event;
2803 mlxsw_sp_switchdev_bridge_vxlan_fdb_event(struct mlxsw_sp *mlxsw_sp,
2804 struct mlxsw_sp_switchdev_event_work *
2806 struct mlxsw_sp_fid *fid, __be32 vni)
2808 struct switchdev_notifier_vxlan_fdb_info vxlan_fdb_info;
2809 struct switchdev_notifier_fdb_info *fdb_info;
2810 struct net_device *dev = switchdev_work->dev;
2811 enum mlxsw_sp_l3proto proto;
2812 union mlxsw_sp_l3addr addr;
2815 fdb_info = &switchdev_work->fdb_info;
2816 err = vxlan_fdb_find_uc(dev, fdb_info->addr, vni, &vxlan_fdb_info);
2820 mlxsw_sp_switchdev_vxlan_addr_convert(&vxlan_fdb_info.remote_ip,
2823 switch (switchdev_work->event) {
2824 case SWITCHDEV_FDB_ADD_TO_DEVICE:
2825 err = mlxsw_sp_port_fdb_tunnel_uc_op(mlxsw_sp,
2826 vxlan_fdb_info.eth_addr,
2827 mlxsw_sp_fid_index(fid),
2828 proto, &addr, true, false);
2831 vxlan_fdb_info.offloaded = true;
2832 call_switchdev_notifiers(SWITCHDEV_VXLAN_FDB_OFFLOADED, dev,
2833 &vxlan_fdb_info.info, NULL);
2834 mlxsw_sp_fdb_call_notifiers(SWITCHDEV_FDB_OFFLOADED,
2835 vxlan_fdb_info.eth_addr,
2836 fdb_info->vid, dev, true);
2838 case SWITCHDEV_FDB_DEL_TO_DEVICE:
2839 err = mlxsw_sp_port_fdb_tunnel_uc_op(mlxsw_sp,
2840 vxlan_fdb_info.eth_addr,
2841 mlxsw_sp_fid_index(fid),
2842 proto, &addr, false,
2844 vxlan_fdb_info.offloaded = false;
2845 call_switchdev_notifiers(SWITCHDEV_VXLAN_FDB_OFFLOADED, dev,
2846 &vxlan_fdb_info.info, NULL);
2852 mlxsw_sp_switchdev_bridge_nve_fdb_event(struct mlxsw_sp_switchdev_event_work *
2855 struct mlxsw_sp_bridge_device *bridge_device;
2856 struct net_device *dev = switchdev_work->dev;
2857 struct net_device *br_dev;
2858 struct mlxsw_sp *mlxsw_sp;
2859 struct mlxsw_sp_fid *fid;
2863 if (switchdev_work->event != SWITCHDEV_FDB_ADD_TO_DEVICE &&
2864 switchdev_work->event != SWITCHDEV_FDB_DEL_TO_DEVICE)
2867 if (switchdev_work->event == SWITCHDEV_FDB_ADD_TO_DEVICE &&
2868 !switchdev_work->fdb_info.added_by_user)
2871 if (!netif_running(dev))
2873 br_dev = netdev_master_upper_dev_get(dev);
2876 if (!netif_is_bridge_master(br_dev))
2878 mlxsw_sp = mlxsw_sp_lower_get(br_dev);
2881 bridge_device = mlxsw_sp_bridge_device_find(mlxsw_sp->bridge, br_dev);
2885 fid = bridge_device->ops->fid_lookup(bridge_device,
2886 switchdev_work->fdb_info.vid);
2890 err = mlxsw_sp_fid_vni(fid, &vni);
2894 mlxsw_sp_switchdev_bridge_vxlan_fdb_event(mlxsw_sp, switchdev_work, fid,
2898 mlxsw_sp_fid_put(fid);
2901 static void mlxsw_sp_switchdev_bridge_fdb_event_work(struct work_struct *work)
2903 struct mlxsw_sp_switchdev_event_work *switchdev_work =
2904 container_of(work, struct mlxsw_sp_switchdev_event_work, work);
2905 struct net_device *dev = switchdev_work->dev;
2906 struct switchdev_notifier_fdb_info *fdb_info;
2907 struct mlxsw_sp_port *mlxsw_sp_port;
2911 if (netif_is_vxlan(dev)) {
2912 mlxsw_sp_switchdev_bridge_nve_fdb_event(switchdev_work);
2916 mlxsw_sp_port = mlxsw_sp_port_dev_lower_find(dev);
2920 switch (switchdev_work->event) {
2921 case SWITCHDEV_FDB_ADD_TO_DEVICE:
2922 fdb_info = &switchdev_work->fdb_info;
2923 if (!fdb_info->added_by_user)
2925 err = mlxsw_sp_port_fdb_set(mlxsw_sp_port, fdb_info, true);
2928 mlxsw_sp_fdb_call_notifiers(SWITCHDEV_FDB_OFFLOADED,
2930 fdb_info->vid, dev, true);
2932 case SWITCHDEV_FDB_DEL_TO_DEVICE:
2933 fdb_info = &switchdev_work->fdb_info;
2934 mlxsw_sp_port_fdb_set(mlxsw_sp_port, fdb_info, false);
2936 case SWITCHDEV_FDB_ADD_TO_BRIDGE:
2937 case SWITCHDEV_FDB_DEL_TO_BRIDGE:
2938 /* These events are only used to potentially update an existing
2944 mlxsw_sp_span_respin(mlxsw_sp_port->mlxsw_sp);
2948 kfree(switchdev_work->fdb_info.addr);
2949 kfree(switchdev_work);
2954 mlxsw_sp_switchdev_vxlan_fdb_add(struct mlxsw_sp *mlxsw_sp,
2955 struct mlxsw_sp_switchdev_event_work *
2958 struct switchdev_notifier_vxlan_fdb_info *vxlan_fdb_info;
2959 struct mlxsw_sp_bridge_device *bridge_device;
2960 struct net_device *dev = switchdev_work->dev;
2961 u8 all_zeros_mac[ETH_ALEN] = { 0 };
2962 enum mlxsw_sp_l3proto proto;
2963 union mlxsw_sp_l3addr addr;
2964 struct net_device *br_dev;
2965 struct mlxsw_sp_fid *fid;
2969 vxlan_fdb_info = &switchdev_work->vxlan_fdb_info;
2970 br_dev = netdev_master_upper_dev_get(dev);
2972 bridge_device = mlxsw_sp_bridge_device_find(mlxsw_sp->bridge, br_dev);
2976 fid = mlxsw_sp_fid_lookup_by_vni(mlxsw_sp, vxlan_fdb_info->vni);
2980 mlxsw_sp_switchdev_vxlan_addr_convert(&vxlan_fdb_info->remote_ip,
2983 if (ether_addr_equal(vxlan_fdb_info->eth_addr, all_zeros_mac)) {
2984 err = mlxsw_sp_nve_flood_ip_add(mlxsw_sp, fid, proto, &addr);
2986 mlxsw_sp_fid_put(fid);
2989 vxlan_fdb_info->offloaded = true;
2990 call_switchdev_notifiers(SWITCHDEV_VXLAN_FDB_OFFLOADED, dev,
2991 &vxlan_fdb_info->info, NULL);
2992 mlxsw_sp_fid_put(fid);
2996 /* The device has a single FDB table, whereas Linux has two - one
2997 * in the bridge driver and another in the VxLAN driver. We only
2998 * program an entry to the device if the MAC points to the VxLAN
2999 * device in the bridge's FDB table
3001 vid = bridge_device->ops->fid_vid(bridge_device, fid);
3002 if (br_fdb_find_port(br_dev, vxlan_fdb_info->eth_addr, vid) != dev)
3003 goto err_br_fdb_find;
3005 err = mlxsw_sp_port_fdb_tunnel_uc_op(mlxsw_sp, vxlan_fdb_info->eth_addr,
3006 mlxsw_sp_fid_index(fid), proto,
3007 &addr, true, false);
3009 goto err_fdb_tunnel_uc_op;
3010 vxlan_fdb_info->offloaded = true;
3011 call_switchdev_notifiers(SWITCHDEV_VXLAN_FDB_OFFLOADED, dev,
3012 &vxlan_fdb_info->info, NULL);
3013 mlxsw_sp_fdb_call_notifiers(SWITCHDEV_FDB_OFFLOADED,
3014 vxlan_fdb_info->eth_addr, vid, dev, true);
3016 mlxsw_sp_fid_put(fid);
3020 err_fdb_tunnel_uc_op:
3022 mlxsw_sp_fid_put(fid);
3026 mlxsw_sp_switchdev_vxlan_fdb_del(struct mlxsw_sp *mlxsw_sp,
3027 struct mlxsw_sp_switchdev_event_work *
3030 struct switchdev_notifier_vxlan_fdb_info *vxlan_fdb_info;
3031 struct mlxsw_sp_bridge_device *bridge_device;
3032 struct net_device *dev = switchdev_work->dev;
3033 struct net_device *br_dev = netdev_master_upper_dev_get(dev);
3034 u8 all_zeros_mac[ETH_ALEN] = { 0 };
3035 enum mlxsw_sp_l3proto proto;
3036 union mlxsw_sp_l3addr addr;
3037 struct mlxsw_sp_fid *fid;
3040 vxlan_fdb_info = &switchdev_work->vxlan_fdb_info;
3042 bridge_device = mlxsw_sp_bridge_device_find(mlxsw_sp->bridge, br_dev);
3046 fid = mlxsw_sp_fid_lookup_by_vni(mlxsw_sp, vxlan_fdb_info->vni);
3050 mlxsw_sp_switchdev_vxlan_addr_convert(&vxlan_fdb_info->remote_ip,
3053 if (ether_addr_equal(vxlan_fdb_info->eth_addr, all_zeros_mac)) {
3054 mlxsw_sp_nve_flood_ip_del(mlxsw_sp, fid, proto, &addr);
3055 mlxsw_sp_fid_put(fid);
3059 mlxsw_sp_port_fdb_tunnel_uc_op(mlxsw_sp, vxlan_fdb_info->eth_addr,
3060 mlxsw_sp_fid_index(fid), proto, &addr,
3062 vid = bridge_device->ops->fid_vid(bridge_device, fid);
3063 mlxsw_sp_fdb_call_notifiers(SWITCHDEV_FDB_OFFLOADED,
3064 vxlan_fdb_info->eth_addr, vid, dev, false);
3066 mlxsw_sp_fid_put(fid);
3069 static void mlxsw_sp_switchdev_vxlan_fdb_event_work(struct work_struct *work)
3071 struct mlxsw_sp_switchdev_event_work *switchdev_work =
3072 container_of(work, struct mlxsw_sp_switchdev_event_work, work);
3073 struct net_device *dev = switchdev_work->dev;
3074 struct mlxsw_sp *mlxsw_sp;
3075 struct net_device *br_dev;
3079 if (!netif_running(dev))
3081 br_dev = netdev_master_upper_dev_get(dev);
3084 if (!netif_is_bridge_master(br_dev))
3086 mlxsw_sp = mlxsw_sp_lower_get(br_dev);
3090 switch (switchdev_work->event) {
3091 case SWITCHDEV_VXLAN_FDB_ADD_TO_DEVICE:
3092 mlxsw_sp_switchdev_vxlan_fdb_add(mlxsw_sp, switchdev_work);
3094 case SWITCHDEV_VXLAN_FDB_DEL_TO_DEVICE:
3095 mlxsw_sp_switchdev_vxlan_fdb_del(mlxsw_sp, switchdev_work);
3101 kfree(switchdev_work);
3106 mlxsw_sp_switchdev_vxlan_work_prepare(struct mlxsw_sp_switchdev_event_work *
3108 struct switchdev_notifier_info *info)
3110 struct vxlan_dev *vxlan = netdev_priv(switchdev_work->dev);
3111 struct switchdev_notifier_vxlan_fdb_info *vxlan_fdb_info;
3112 struct vxlan_config *cfg = &vxlan->cfg;
3113 struct netlink_ext_ack *extack;
3115 extack = switchdev_notifier_info_to_extack(info);
3116 vxlan_fdb_info = container_of(info,
3117 struct switchdev_notifier_vxlan_fdb_info,
3120 if (vxlan_fdb_info->remote_port != cfg->dst_port) {
3121 NL_SET_ERR_MSG_MOD(extack, "VxLAN: FDB: Non-default remote port is not supported");
3124 if (vxlan_fdb_info->remote_vni != cfg->vni ||
3125 vxlan_fdb_info->vni != cfg->vni) {
3126 NL_SET_ERR_MSG_MOD(extack, "VxLAN: FDB: Non-default VNI is not supported");
3129 if (vxlan_fdb_info->remote_ifindex) {
3130 NL_SET_ERR_MSG_MOD(extack, "VxLAN: FDB: Local interface is not supported");
3133 if (is_multicast_ether_addr(vxlan_fdb_info->eth_addr)) {
3134 NL_SET_ERR_MSG_MOD(extack, "VxLAN: FDB: Multicast MAC addresses not supported");
3137 if (vxlan_addr_multicast(&vxlan_fdb_info->remote_ip)) {
3138 NL_SET_ERR_MSG_MOD(extack, "VxLAN: FDB: Multicast destination IP is not supported");
3142 switchdev_work->vxlan_fdb_info = *vxlan_fdb_info;
3147 /* Called under rcu_read_lock() */
3148 static int mlxsw_sp_switchdev_event(struct notifier_block *unused,
3149 unsigned long event, void *ptr)
3151 struct net_device *dev = switchdev_notifier_info_to_dev(ptr);
3152 struct mlxsw_sp_switchdev_event_work *switchdev_work;
3153 struct switchdev_notifier_fdb_info *fdb_info;
3154 struct switchdev_notifier_info *info = ptr;
3155 struct net_device *br_dev;
3158 if (event == SWITCHDEV_PORT_ATTR_SET) {
3159 err = switchdev_handle_port_attr_set(dev, ptr,
3160 mlxsw_sp_port_dev_check,
3161 mlxsw_sp_port_attr_set);
3162 return notifier_from_errno(err);
3165 /* Tunnel devices are not our uppers, so check their master instead */
3166 br_dev = netdev_master_upper_dev_get_rcu(dev);
3169 if (!netif_is_bridge_master(br_dev))
3171 if (!mlxsw_sp_port_dev_lower_find_rcu(br_dev))
3174 switchdev_work = kzalloc(sizeof(*switchdev_work), GFP_ATOMIC);
3175 if (!switchdev_work)
3178 switchdev_work->dev = dev;
3179 switchdev_work->event = event;
3182 case SWITCHDEV_FDB_ADD_TO_DEVICE:
3183 case SWITCHDEV_FDB_DEL_TO_DEVICE:
3184 case SWITCHDEV_FDB_ADD_TO_BRIDGE:
3185 case SWITCHDEV_FDB_DEL_TO_BRIDGE:
3186 fdb_info = container_of(info,
3187 struct switchdev_notifier_fdb_info,
3189 INIT_WORK(&switchdev_work->work,
3190 mlxsw_sp_switchdev_bridge_fdb_event_work);
3191 memcpy(&switchdev_work->fdb_info, ptr,
3192 sizeof(switchdev_work->fdb_info));
3193 switchdev_work->fdb_info.addr = kzalloc(ETH_ALEN, GFP_ATOMIC);
3194 if (!switchdev_work->fdb_info.addr)
3195 goto err_addr_alloc;
3196 ether_addr_copy((u8 *)switchdev_work->fdb_info.addr,
3198 /* Take a reference on the device. This can be either
3199 * upper device containig mlxsw_sp_port or just a
3204 case SWITCHDEV_VXLAN_FDB_ADD_TO_DEVICE:
3205 case SWITCHDEV_VXLAN_FDB_DEL_TO_DEVICE:
3206 INIT_WORK(&switchdev_work->work,
3207 mlxsw_sp_switchdev_vxlan_fdb_event_work);
3208 err = mlxsw_sp_switchdev_vxlan_work_prepare(switchdev_work,
3211 goto err_vxlan_work_prepare;
3215 kfree(switchdev_work);
3219 mlxsw_core_schedule_work(&switchdev_work->work);
3223 err_vxlan_work_prepare:
3225 kfree(switchdev_work);
3229 struct notifier_block mlxsw_sp_switchdev_notifier = {
3230 .notifier_call = mlxsw_sp_switchdev_event,
3234 mlxsw_sp_switchdev_vxlan_vlan_add(struct mlxsw_sp *mlxsw_sp,
3235 struct mlxsw_sp_bridge_device *bridge_device,
3236 const struct net_device *vxlan_dev, u16 vid,
3237 bool flag_untagged, bool flag_pvid,
3238 struct netlink_ext_ack *extack)
3240 struct vxlan_dev *vxlan = netdev_priv(vxlan_dev);
3241 __be32 vni = vxlan->cfg.vni;
3242 struct mlxsw_sp_fid *fid;
3246 /* We cannot have the same VLAN as PVID and egress untagged on multiple
3247 * VxLAN devices. Note that we get this notification before the VLAN is
3248 * actually added to the bridge's database, so it is not possible for
3249 * the lookup function to return 'vxlan_dev'
3251 if (flag_untagged && flag_pvid &&
3252 mlxsw_sp_bridge_8021q_vxlan_dev_find(bridge_device->dev, vid)) {
3253 NL_SET_ERR_MSG_MOD(extack, "VLAN already mapped to a different VNI");
3257 if (!netif_running(vxlan_dev))
3260 /* First case: FID is not associated with this VNI, but the new VLAN
3261 * is both PVID and egress untagged. Need to enable NVE on the FID, if
3264 fid = mlxsw_sp_fid_lookup_by_vni(mlxsw_sp, vni);
3266 if (!flag_untagged || !flag_pvid)
3268 return bridge_device->ops->vxlan_join(bridge_device, vxlan_dev,
3272 /* Second case: FID is associated with the VNI and the VLAN associated
3273 * with the FID is the same as the notified VLAN. This means the flags
3274 * (PVID / egress untagged) were toggled and that NVE should be
3275 * disabled on the FID
3277 old_vid = mlxsw_sp_fid_8021q_vid(fid);
3278 if (vid == old_vid) {
3279 if (WARN_ON(flag_untagged && flag_pvid)) {
3280 mlxsw_sp_fid_put(fid);
3283 mlxsw_sp_bridge_vxlan_leave(mlxsw_sp, vxlan_dev);
3284 mlxsw_sp_fid_put(fid);
3288 /* Third case: A new VLAN was configured on the VxLAN device, but this
3289 * VLAN is not PVID, so there is nothing to do.
3292 mlxsw_sp_fid_put(fid);
3296 /* Fourth case: Thew new VLAN is PVID, which means the VLAN currently
3297 * mapped to the VNI should be unmapped
3299 mlxsw_sp_bridge_vxlan_leave(mlxsw_sp, vxlan_dev);
3300 mlxsw_sp_fid_put(fid);
3302 /* Fifth case: The new VLAN is also egress untagged, which means the
3303 * VLAN needs to be mapped to the VNI
3308 err = bridge_device->ops->vxlan_join(bridge_device, vxlan_dev, vid, extack);
3310 goto err_vxlan_join;
3315 bridge_device->ops->vxlan_join(bridge_device, vxlan_dev, old_vid, NULL);
3320 mlxsw_sp_switchdev_vxlan_vlan_del(struct mlxsw_sp *mlxsw_sp,
3321 struct mlxsw_sp_bridge_device *bridge_device,
3322 const struct net_device *vxlan_dev, u16 vid)
3324 struct vxlan_dev *vxlan = netdev_priv(vxlan_dev);
3325 __be32 vni = vxlan->cfg.vni;
3326 struct mlxsw_sp_fid *fid;
3328 if (!netif_running(vxlan_dev))
3331 fid = mlxsw_sp_fid_lookup_by_vni(mlxsw_sp, vni);
3335 /* A different VLAN than the one mapped to the VNI is deleted */
3336 if (mlxsw_sp_fid_8021q_vid(fid) != vid)
3339 mlxsw_sp_bridge_vxlan_leave(mlxsw_sp, vxlan_dev);
3342 mlxsw_sp_fid_put(fid);
3346 mlxsw_sp_switchdev_vxlan_vlans_add(struct net_device *vxlan_dev,
3347 struct switchdev_notifier_port_obj_info *
3350 struct switchdev_obj_port_vlan *vlan =
3351 SWITCHDEV_OBJ_PORT_VLAN(port_obj_info->obj);
3352 bool flag_untagged = vlan->flags & BRIDGE_VLAN_INFO_UNTAGGED;
3353 bool flag_pvid = vlan->flags & BRIDGE_VLAN_INFO_PVID;
3354 struct mlxsw_sp_bridge_device *bridge_device;
3355 struct netlink_ext_ack *extack;
3356 struct mlxsw_sp *mlxsw_sp;
3357 struct net_device *br_dev;
3359 extack = switchdev_notifier_info_to_extack(&port_obj_info->info);
3360 br_dev = netdev_master_upper_dev_get(vxlan_dev);
3364 mlxsw_sp = mlxsw_sp_lower_get(br_dev);
3368 port_obj_info->handled = true;
3370 bridge_device = mlxsw_sp_bridge_device_find(mlxsw_sp->bridge, br_dev);
3374 if (!bridge_device->vlan_enabled)
3377 return mlxsw_sp_switchdev_vxlan_vlan_add(mlxsw_sp, bridge_device,
3378 vxlan_dev, vlan->vid,
3384 mlxsw_sp_switchdev_vxlan_vlans_del(struct net_device *vxlan_dev,
3385 struct switchdev_notifier_port_obj_info *
3388 struct switchdev_obj_port_vlan *vlan =
3389 SWITCHDEV_OBJ_PORT_VLAN(port_obj_info->obj);
3390 struct mlxsw_sp_bridge_device *bridge_device;
3391 struct mlxsw_sp *mlxsw_sp;
3392 struct net_device *br_dev;
3394 br_dev = netdev_master_upper_dev_get(vxlan_dev);
3398 mlxsw_sp = mlxsw_sp_lower_get(br_dev);
3402 port_obj_info->handled = true;
3404 bridge_device = mlxsw_sp_bridge_device_find(mlxsw_sp->bridge, br_dev);
3408 if (!bridge_device->vlan_enabled)
3411 mlxsw_sp_switchdev_vxlan_vlan_del(mlxsw_sp, bridge_device, vxlan_dev,
3416 mlxsw_sp_switchdev_handle_vxlan_obj_add(struct net_device *vxlan_dev,
3417 struct switchdev_notifier_port_obj_info *
3422 switch (port_obj_info->obj->id) {
3423 case SWITCHDEV_OBJ_ID_PORT_VLAN:
3424 err = mlxsw_sp_switchdev_vxlan_vlans_add(vxlan_dev,
3435 mlxsw_sp_switchdev_handle_vxlan_obj_del(struct net_device *vxlan_dev,
3436 struct switchdev_notifier_port_obj_info *
3439 switch (port_obj_info->obj->id) {
3440 case SWITCHDEV_OBJ_ID_PORT_VLAN:
3441 mlxsw_sp_switchdev_vxlan_vlans_del(vxlan_dev, port_obj_info);
3448 static int mlxsw_sp_switchdev_blocking_event(struct notifier_block *unused,
3449 unsigned long event, void *ptr)
3451 struct net_device *dev = switchdev_notifier_info_to_dev(ptr);
3455 case SWITCHDEV_PORT_OBJ_ADD:
3456 if (netif_is_vxlan(dev))
3457 err = mlxsw_sp_switchdev_handle_vxlan_obj_add(dev, ptr);
3459 err = switchdev_handle_port_obj_add(dev, ptr,
3460 mlxsw_sp_port_dev_check,
3461 mlxsw_sp_port_obj_add);
3462 return notifier_from_errno(err);
3463 case SWITCHDEV_PORT_OBJ_DEL:
3464 if (netif_is_vxlan(dev))
3465 mlxsw_sp_switchdev_handle_vxlan_obj_del(dev, ptr);
3467 err = switchdev_handle_port_obj_del(dev, ptr,
3468 mlxsw_sp_port_dev_check,
3469 mlxsw_sp_port_obj_del);
3470 return notifier_from_errno(err);
3471 case SWITCHDEV_PORT_ATTR_SET:
3472 err = switchdev_handle_port_attr_set(dev, ptr,
3473 mlxsw_sp_port_dev_check,
3474 mlxsw_sp_port_attr_set);
3475 return notifier_from_errno(err);
3481 static struct notifier_block mlxsw_sp_switchdev_blocking_notifier = {
3482 .notifier_call = mlxsw_sp_switchdev_blocking_event,
3486 mlxsw_sp_bridge_port_stp_state(struct mlxsw_sp_bridge_port *bridge_port)
3488 return bridge_port->stp_state;
3491 static int mlxsw_sp_fdb_init(struct mlxsw_sp *mlxsw_sp)
3493 struct mlxsw_sp_bridge *bridge = mlxsw_sp->bridge;
3494 struct notifier_block *nb;
3497 err = mlxsw_sp_ageing_set(mlxsw_sp, MLXSW_SP_DEFAULT_AGEING_TIME);
3499 dev_err(mlxsw_sp->bus_info->dev, "Failed to set default ageing time\n");
3503 err = register_switchdev_notifier(&mlxsw_sp_switchdev_notifier);
3505 dev_err(mlxsw_sp->bus_info->dev, "Failed to register switchdev notifier\n");
3509 nb = &mlxsw_sp_switchdev_blocking_notifier;
3510 err = register_switchdev_blocking_notifier(nb);
3512 dev_err(mlxsw_sp->bus_info->dev, "Failed to register switchdev blocking notifier\n");
3513 goto err_register_switchdev_blocking_notifier;
3516 INIT_DELAYED_WORK(&bridge->fdb_notify.dw, mlxsw_sp_fdb_notify_work);
3517 bridge->fdb_notify.interval = MLXSW_SP_DEFAULT_LEARNING_INTERVAL;
3518 mlxsw_sp_fdb_notify_work_schedule(mlxsw_sp, false);
3521 err_register_switchdev_blocking_notifier:
3522 unregister_switchdev_notifier(&mlxsw_sp_switchdev_notifier);
3526 static void mlxsw_sp_fdb_fini(struct mlxsw_sp *mlxsw_sp)
3528 struct notifier_block *nb;
3530 cancel_delayed_work_sync(&mlxsw_sp->bridge->fdb_notify.dw);
3532 nb = &mlxsw_sp_switchdev_blocking_notifier;
3533 unregister_switchdev_blocking_notifier(nb);
3535 unregister_switchdev_notifier(&mlxsw_sp_switchdev_notifier);
3538 int mlxsw_sp_switchdev_init(struct mlxsw_sp *mlxsw_sp)
3540 struct mlxsw_sp_bridge *bridge;
3542 bridge = kzalloc(sizeof(*mlxsw_sp->bridge), GFP_KERNEL);
3545 mlxsw_sp->bridge = bridge;
3546 bridge->mlxsw_sp = mlxsw_sp;
3548 INIT_LIST_HEAD(&mlxsw_sp->bridge->bridges_list);
3550 bridge->bridge_8021q_ops = &mlxsw_sp_bridge_8021q_ops;
3551 bridge->bridge_8021d_ops = &mlxsw_sp_bridge_8021d_ops;
3552 bridge->bridge_8021ad_ops = &mlxsw_sp_bridge_8021ad_ops;
3554 return mlxsw_sp_fdb_init(mlxsw_sp);
3557 void mlxsw_sp_switchdev_fini(struct mlxsw_sp *mlxsw_sp)
3559 mlxsw_sp_fdb_fini(mlxsw_sp);
3560 WARN_ON(!list_empty(&mlxsw_sp->bridge->bridges_list));
3561 kfree(mlxsw_sp->bridge);