1 // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
2 /* Copyright (c) 2019-2020 Marvell International Ltd. All rights reserved */
4 #include <linux/if_bridge.h>
5 #include <linux/if_vlan.h>
6 #include <linux/kernel.h>
7 #include <linux/module.h>
8 #include <linux/notifier.h>
9 #include <net/netevent.h>
10 #include <net/switchdev.h>
13 #include "prestera_hw.h"
14 #include "prestera_switchdev.h"
16 #define PRESTERA_VID_ALL (0xffff)
18 #define PRESTERA_DEFAULT_AGEING_TIME_MS 300000
19 #define PRESTERA_MAX_AGEING_TIME_MS 1000000000
20 #define PRESTERA_MIN_AGEING_TIME_MS 32000
22 struct prestera_fdb_event_work {
23 struct work_struct work;
24 struct switchdev_notifier_fdb_info fdb_info;
25 struct net_device *dev;
29 struct prestera_switchdev {
30 struct prestera_switch *sw;
31 struct list_head bridge_list;
32 bool bridge_8021q_exists;
33 struct notifier_block swdev_nb_blk;
34 struct notifier_block swdev_nb;
37 struct prestera_bridge {
38 struct list_head head;
39 struct net_device *dev;
40 struct prestera_switchdev *swdev;
41 struct list_head port_list;
46 struct prestera_bridge_port {
47 struct list_head head;
48 struct net_device *dev;
49 struct prestera_bridge *bridge;
50 struct list_head vlan_list;
56 struct prestera_bridge_vlan {
57 struct list_head head;
58 struct list_head port_vlan_list;
62 struct prestera_port_vlan {
63 struct list_head br_vlan_head;
64 struct list_head port_head;
65 struct prestera_port *port;
66 struct prestera_bridge_port *br_port;
70 static struct workqueue_struct *swdev_wq;
72 static void prestera_bridge_port_put(struct prestera_bridge_port *br_port);
74 static int prestera_port_vid_stp_set(struct prestera_port *port, u16 vid,
77 static struct prestera_bridge_vlan *
78 prestera_bridge_vlan_create(struct prestera_bridge_port *br_port, u16 vid)
80 struct prestera_bridge_vlan *br_vlan;
82 br_vlan = kzalloc(sizeof(*br_vlan), GFP_KERNEL);
86 INIT_LIST_HEAD(&br_vlan->port_vlan_list);
88 list_add(&br_vlan->head, &br_port->vlan_list);
93 static void prestera_bridge_vlan_destroy(struct prestera_bridge_vlan *br_vlan)
95 list_del(&br_vlan->head);
96 WARN_ON(!list_empty(&br_vlan->port_vlan_list));
100 static struct prestera_bridge_vlan *
101 prestera_bridge_vlan_by_vid(struct prestera_bridge_port *br_port, u16 vid)
103 struct prestera_bridge_vlan *br_vlan;
105 list_for_each_entry(br_vlan, &br_port->vlan_list, head) {
106 if (br_vlan->vid == vid)
113 static int prestera_bridge_vlan_port_count(struct prestera_bridge *bridge,
116 struct prestera_bridge_port *br_port;
117 struct prestera_bridge_vlan *br_vlan;
120 list_for_each_entry(br_port, &bridge->port_list, head) {
121 list_for_each_entry(br_vlan, &br_port->vlan_list, head) {
122 if (br_vlan->vid == vid) {
132 static void prestera_bridge_vlan_put(struct prestera_bridge_vlan *br_vlan)
134 if (list_empty(&br_vlan->port_vlan_list))
135 prestera_bridge_vlan_destroy(br_vlan);
138 static struct prestera_port_vlan *
139 prestera_port_vlan_by_vid(struct prestera_port *port, u16 vid)
141 struct prestera_port_vlan *port_vlan;
143 list_for_each_entry(port_vlan, &port->vlans_list, port_head) {
144 if (port_vlan->vid == vid)
151 static struct prestera_port_vlan *
152 prestera_port_vlan_create(struct prestera_port *port, u16 vid, bool untagged)
154 struct prestera_port_vlan *port_vlan;
157 port_vlan = prestera_port_vlan_by_vid(port, vid);
159 return ERR_PTR(-EEXIST);
161 err = prestera_hw_vlan_port_set(port, vid, true, untagged);
165 port_vlan = kzalloc(sizeof(*port_vlan), GFP_KERNEL);
168 goto err_port_vlan_alloc;
171 port_vlan->port = port;
172 port_vlan->vid = vid;
174 list_add(&port_vlan->port_head, &port->vlans_list);
179 prestera_hw_vlan_port_set(port, vid, false, false);
184 prestera_port_vlan_bridge_leave(struct prestera_port_vlan *port_vlan)
186 u32 fdb_flush_mode = PRESTERA_FDB_FLUSH_MODE_DYNAMIC;
187 struct prestera_port *port = port_vlan->port;
188 struct prestera_bridge_vlan *br_vlan;
189 struct prestera_bridge_port *br_port;
190 bool last_port, last_vlan;
191 u16 vid = port_vlan->vid;
194 br_port = port_vlan->br_port;
195 port_count = prestera_bridge_vlan_port_count(br_port->bridge, vid);
196 br_vlan = prestera_bridge_vlan_by_vid(br_port, vid);
198 last_vlan = list_is_singular(&br_port->vlan_list);
199 last_port = port_count == 1;
202 prestera_hw_fdb_flush_port(port, fdb_flush_mode);
204 prestera_hw_fdb_flush_vlan(port->sw, vid, fdb_flush_mode);
206 prestera_hw_fdb_flush_port_vlan(port, vid, fdb_flush_mode);
208 list_del(&port_vlan->br_vlan_head);
209 prestera_bridge_vlan_put(br_vlan);
210 prestera_bridge_port_put(br_port);
211 port_vlan->br_port = NULL;
214 static void prestera_port_vlan_destroy(struct prestera_port_vlan *port_vlan)
216 struct prestera_port *port = port_vlan->port;
217 u16 vid = port_vlan->vid;
219 if (port_vlan->br_port)
220 prestera_port_vlan_bridge_leave(port_vlan);
222 prestera_hw_vlan_port_set(port, vid, false, false);
223 list_del(&port_vlan->port_head);
227 static struct prestera_bridge *
228 prestera_bridge_create(struct prestera_switchdev *swdev, struct net_device *dev)
230 bool vlan_enabled = br_vlan_enabled(dev);
231 struct prestera_bridge *bridge;
235 if (vlan_enabled && swdev->bridge_8021q_exists) {
236 netdev_err(dev, "Only one VLAN-aware bridge is supported\n");
237 return ERR_PTR(-EINVAL);
240 bridge = kzalloc(sizeof(*bridge), GFP_KERNEL);
242 return ERR_PTR(-ENOMEM);
245 swdev->bridge_8021q_exists = true;
247 err = prestera_hw_bridge_create(swdev->sw, &bridge_id);
253 bridge->bridge_id = bridge_id;
256 bridge->vlan_enabled = vlan_enabled;
257 bridge->swdev = swdev;
260 INIT_LIST_HEAD(&bridge->port_list);
262 list_add(&bridge->head, &swdev->bridge_list);
267 static void prestera_bridge_destroy(struct prestera_bridge *bridge)
269 struct prestera_switchdev *swdev = bridge->swdev;
271 list_del(&bridge->head);
273 if (bridge->vlan_enabled)
274 swdev->bridge_8021q_exists = false;
276 prestera_hw_bridge_delete(swdev->sw, bridge->bridge_id);
278 WARN_ON(!list_empty(&bridge->port_list));
282 static void prestera_bridge_put(struct prestera_bridge *bridge)
284 if (list_empty(&bridge->port_list))
285 prestera_bridge_destroy(bridge);
289 struct prestera_bridge *prestera_bridge_by_dev(struct prestera_switchdev *swdev,
290 const struct net_device *dev)
292 struct prestera_bridge *bridge;
294 list_for_each_entry(bridge, &swdev->bridge_list, head)
295 if (bridge->dev == dev)
301 static struct prestera_bridge_port *
302 __prestera_bridge_port_by_dev(struct prestera_bridge *bridge,
303 struct net_device *dev)
305 struct prestera_bridge_port *br_port;
307 list_for_each_entry(br_port, &bridge->port_list, head) {
308 if (br_port->dev == dev)
315 static struct prestera_bridge_port *
316 prestera_bridge_port_by_dev(struct prestera_switchdev *swdev,
317 struct net_device *dev)
319 struct net_device *br_dev = netdev_master_upper_dev_get(dev);
320 struct prestera_bridge *bridge;
325 bridge = prestera_bridge_by_dev(swdev, br_dev);
329 return __prestera_bridge_port_by_dev(bridge, dev);
332 static struct prestera_bridge_port *
333 prestera_bridge_port_create(struct prestera_bridge *bridge,
334 struct net_device *dev)
336 struct prestera_bridge_port *br_port;
338 br_port = kzalloc(sizeof(*br_port), GFP_KERNEL);
342 br_port->flags = BR_LEARNING | BR_FLOOD | BR_LEARNING_SYNC |
344 br_port->stp_state = BR_STATE_DISABLED;
345 refcount_set(&br_port->ref_count, 1);
346 br_port->bridge = bridge;
349 INIT_LIST_HEAD(&br_port->vlan_list);
350 list_add(&br_port->head, &bridge->port_list);
356 prestera_bridge_port_destroy(struct prestera_bridge_port *br_port)
358 list_del(&br_port->head);
359 WARN_ON(!list_empty(&br_port->vlan_list));
363 static void prestera_bridge_port_get(struct prestera_bridge_port *br_port)
365 refcount_inc(&br_port->ref_count);
368 static void prestera_bridge_port_put(struct prestera_bridge_port *br_port)
370 struct prestera_bridge *bridge = br_port->bridge;
372 if (refcount_dec_and_test(&br_port->ref_count)) {
373 prestera_bridge_port_destroy(br_port);
374 prestera_bridge_put(bridge);
378 static struct prestera_bridge_port *
379 prestera_bridge_port_add(struct prestera_bridge *bridge, struct net_device *dev)
381 struct prestera_bridge_port *br_port;
383 br_port = __prestera_bridge_port_by_dev(bridge, dev);
385 prestera_bridge_port_get(br_port);
389 br_port = prestera_bridge_port_create(bridge, dev);
391 return ERR_PTR(-ENOMEM);
397 prestera_bridge_1d_port_join(struct prestera_bridge_port *br_port)
399 struct prestera_port *port = netdev_priv(br_port->dev);
400 struct prestera_bridge *bridge = br_port->bridge;
403 err = prestera_hw_bridge_port_add(port, bridge->bridge_id);
407 err = prestera_hw_port_flood_set(port, br_port->flags & BR_FLOOD);
409 goto err_port_flood_set;
411 err = prestera_hw_port_learning_set(port, br_port->flags & BR_LEARNING);
413 goto err_port_learning_set;
417 err_port_learning_set:
418 prestera_hw_port_flood_set(port, false);
420 prestera_hw_bridge_port_delete(port, bridge->bridge_id);
425 static int prestera_port_bridge_join(struct prestera_port *port,
426 struct net_device *upper)
428 struct prestera_switchdev *swdev = port->sw->swdev;
429 struct prestera_bridge_port *br_port;
430 struct prestera_bridge *bridge;
433 bridge = prestera_bridge_by_dev(swdev, upper);
435 bridge = prestera_bridge_create(swdev, upper);
437 return PTR_ERR(bridge);
440 br_port = prestera_bridge_port_add(bridge, port->dev);
441 if (IS_ERR(br_port)) {
442 prestera_bridge_put(bridge);
443 return PTR_ERR(br_port);
446 if (bridge->vlan_enabled)
449 err = prestera_bridge_1d_port_join(br_port);
456 prestera_bridge_port_put(br_port);
460 static void prestera_bridge_1q_port_leave(struct prestera_bridge_port *br_port)
462 struct prestera_port *port = netdev_priv(br_port->dev);
464 prestera_hw_fdb_flush_port(port, PRESTERA_FDB_FLUSH_MODE_ALL);
465 prestera_port_pvid_set(port, PRESTERA_DEFAULT_VID);
468 static void prestera_bridge_1d_port_leave(struct prestera_bridge_port *br_port)
470 struct prestera_port *port = netdev_priv(br_port->dev);
472 prestera_hw_fdb_flush_port(port, PRESTERA_FDB_FLUSH_MODE_ALL);
473 prestera_hw_bridge_port_delete(port, br_port->bridge->bridge_id);
476 static int prestera_port_vid_stp_set(struct prestera_port *port, u16 vid,
482 case BR_STATE_DISABLED:
483 hw_state = PRESTERA_STP_DISABLED;
486 case BR_STATE_BLOCKING:
487 case BR_STATE_LISTENING:
488 hw_state = PRESTERA_STP_BLOCK_LISTEN;
491 case BR_STATE_LEARNING:
492 hw_state = PRESTERA_STP_LEARN;
495 case BR_STATE_FORWARDING:
496 hw_state = PRESTERA_STP_FORWARD;
503 return prestera_hw_vlan_port_stp_set(port, vid, hw_state);
506 static void prestera_port_bridge_leave(struct prestera_port *port,
507 struct net_device *upper)
509 struct prestera_switchdev *swdev = port->sw->swdev;
510 struct prestera_bridge_port *br_port;
511 struct prestera_bridge *bridge;
513 bridge = prestera_bridge_by_dev(swdev, upper);
517 br_port = __prestera_bridge_port_by_dev(bridge, port->dev);
521 bridge = br_port->bridge;
523 if (bridge->vlan_enabled)
524 prestera_bridge_1q_port_leave(br_port);
526 prestera_bridge_1d_port_leave(br_port);
528 prestera_hw_port_learning_set(port, false);
529 prestera_hw_port_flood_set(port, false);
530 prestera_port_vid_stp_set(port, PRESTERA_VID_ALL, BR_STATE_FORWARDING);
531 prestera_bridge_port_put(br_port);
534 int prestera_bridge_port_event(struct net_device *dev, unsigned long event,
537 struct netdev_notifier_changeupper_info *info = ptr;
538 struct netlink_ext_ack *extack;
539 struct prestera_port *port;
540 struct net_device *upper;
543 extack = netdev_notifier_info_to_extack(&info->info);
544 port = netdev_priv(dev);
545 upper = info->upper_dev;
548 case NETDEV_PRECHANGEUPPER:
549 if (!netif_is_bridge_master(upper)) {
550 NL_SET_ERR_MSG_MOD(extack, "Unknown upper device type");
557 if (netdev_has_any_upper_dev(upper)) {
558 NL_SET_ERR_MSG_MOD(extack, "Upper device is already enslaved");
563 case NETDEV_CHANGEUPPER:
564 if (!netif_is_bridge_master(upper))
568 err = prestera_port_bridge_join(port, upper);
572 prestera_port_bridge_leave(port, upper);
580 static int prestera_port_attr_br_flags_set(struct prestera_port *port,
581 struct switchdev_trans *trans,
582 struct net_device *dev,
585 struct prestera_bridge_port *br_port;
588 if (switchdev_trans_ph_prepare(trans))
591 br_port = prestera_bridge_port_by_dev(port->sw->swdev, dev);
595 err = prestera_hw_port_flood_set(port, flags & BR_FLOOD);
599 err = prestera_hw_port_learning_set(port, flags & BR_LEARNING);
603 memcpy(&br_port->flags, &flags, sizeof(flags));
608 static int prestera_port_attr_br_ageing_set(struct prestera_port *port,
609 struct switchdev_trans *trans,
610 unsigned long ageing_clock_t)
612 unsigned long ageing_jiffies = clock_t_to_jiffies(ageing_clock_t);
613 u32 ageing_time_ms = jiffies_to_msecs(ageing_jiffies);
614 struct prestera_switch *sw = port->sw;
616 if (switchdev_trans_ph_prepare(trans)) {
617 if (ageing_time_ms < PRESTERA_MIN_AGEING_TIME_MS ||
618 ageing_time_ms > PRESTERA_MAX_AGEING_TIME_MS)
624 return prestera_hw_switch_ageing_set(sw, ageing_time_ms);
627 static int prestera_port_attr_br_vlan_set(struct prestera_port *port,
628 struct switchdev_trans *trans,
629 struct net_device *dev,
632 struct prestera_switch *sw = port->sw;
633 struct prestera_bridge *bridge;
635 if (!switchdev_trans_ph_prepare(trans))
638 bridge = prestera_bridge_by_dev(sw->swdev, dev);
639 if (WARN_ON(!bridge))
642 if (bridge->vlan_enabled == vlan_enabled)
645 netdev_err(bridge->dev, "VLAN filtering can't be changed for existing bridge\n");
650 static int prestera_port_bridge_vlan_stp_set(struct prestera_port *port,
651 struct prestera_bridge_vlan *br_vlan,
654 struct prestera_port_vlan *port_vlan;
656 list_for_each_entry(port_vlan, &br_vlan->port_vlan_list, br_vlan_head) {
657 if (port_vlan->port != port)
660 return prestera_port_vid_stp_set(port, br_vlan->vid, state);
666 static int presterar_port_attr_stp_state_set(struct prestera_port *port,
667 struct switchdev_trans *trans,
668 struct net_device *dev,
671 struct prestera_bridge_port *br_port;
672 struct prestera_bridge_vlan *br_vlan;
676 if (switchdev_trans_ph_prepare(trans))
679 br_port = prestera_bridge_port_by_dev(port->sw->swdev, dev);
683 if (!br_port->bridge->vlan_enabled) {
684 vid = br_port->bridge->bridge_id;
685 err = prestera_port_vid_stp_set(port, vid, state);
687 goto err_port_stp_set;
689 list_for_each_entry(br_vlan, &br_port->vlan_list, head) {
690 err = prestera_port_bridge_vlan_stp_set(port, br_vlan,
693 goto err_port_vlan_stp_set;
697 br_port->stp_state = state;
701 err_port_vlan_stp_set:
702 list_for_each_entry_continue_reverse(br_vlan, &br_port->vlan_list, head)
703 prestera_port_bridge_vlan_stp_set(port, br_vlan, br_port->stp_state);
707 prestera_port_vid_stp_set(port, vid, br_port->stp_state);
712 static int prestera_port_obj_attr_set(struct net_device *dev,
713 const struct switchdev_attr *attr,
714 struct switchdev_trans *trans)
716 struct prestera_port *port = netdev_priv(dev);
720 case SWITCHDEV_ATTR_ID_PORT_STP_STATE:
721 err = presterar_port_attr_stp_state_set(port, trans,
725 case SWITCHDEV_ATTR_ID_PORT_PRE_BRIDGE_FLAGS:
726 if (attr->u.brport_flags &
727 ~(BR_LEARNING | BR_FLOOD | BR_MCAST_FLOOD))
730 case SWITCHDEV_ATTR_ID_PORT_BRIDGE_FLAGS:
731 err = prestera_port_attr_br_flags_set(port, trans,
733 attr->u.brport_flags);
735 case SWITCHDEV_ATTR_ID_BRIDGE_AGEING_TIME:
736 err = prestera_port_attr_br_ageing_set(port, trans,
737 attr->u.ageing_time);
739 case SWITCHDEV_ATTR_ID_BRIDGE_VLAN_FILTERING:
740 err = prestera_port_attr_br_vlan_set(port, trans,
742 attr->u.vlan_filtering);
752 prestera_fdb_offload_notify(struct prestera_port *port,
753 struct switchdev_notifier_fdb_info *info)
755 struct switchdev_notifier_fdb_info send_info;
757 send_info.addr = info->addr;
758 send_info.vid = info->vid;
759 send_info.offloaded = true;
761 call_switchdev_notifiers(SWITCHDEV_FDB_OFFLOADED, port->dev,
762 &send_info.info, NULL);
765 static int prestera_port_fdb_set(struct prestera_port *port,
766 struct switchdev_notifier_fdb_info *fdb_info,
769 struct prestera_switch *sw = port->sw;
770 struct prestera_bridge_port *br_port;
771 struct prestera_bridge *bridge;
775 br_port = prestera_bridge_port_by_dev(sw->swdev, port->dev);
779 bridge = br_port->bridge;
781 if (bridge->vlan_enabled)
784 vid = bridge->bridge_id;
787 err = prestera_hw_fdb_add(port, fdb_info->addr, vid, false);
789 err = prestera_hw_fdb_del(port, fdb_info->addr, vid);
794 static void prestera_fdb_event_work(struct work_struct *work)
796 struct switchdev_notifier_fdb_info *fdb_info;
797 struct prestera_fdb_event_work *swdev_work;
798 struct prestera_port *port;
799 struct net_device *dev;
802 swdev_work = container_of(work, struct prestera_fdb_event_work, work);
803 dev = swdev_work->dev;
807 port = prestera_port_dev_lower_find(dev);
811 switch (swdev_work->event) {
812 case SWITCHDEV_FDB_ADD_TO_DEVICE:
813 fdb_info = &swdev_work->fdb_info;
814 if (!fdb_info->added_by_user)
817 err = prestera_port_fdb_set(port, fdb_info, true);
821 prestera_fdb_offload_notify(port, fdb_info);
824 case SWITCHDEV_FDB_DEL_TO_DEVICE:
825 fdb_info = &swdev_work->fdb_info;
826 prestera_port_fdb_set(port, fdb_info, false);
833 kfree(swdev_work->fdb_info.addr);
838 static int prestera_switchdev_event(struct notifier_block *unused,
839 unsigned long event, void *ptr)
841 struct net_device *dev = switchdev_notifier_info_to_dev(ptr);
842 struct switchdev_notifier_fdb_info *fdb_info;
843 struct switchdev_notifier_info *info = ptr;
844 struct prestera_fdb_event_work *swdev_work;
845 struct net_device *upper;
848 if (event == SWITCHDEV_PORT_ATTR_SET) {
849 err = switchdev_handle_port_attr_set(dev, ptr,
850 prestera_netdev_check,
851 prestera_port_obj_attr_set);
852 return notifier_from_errno(err);
855 if (!prestera_netdev_check(dev))
858 upper = netdev_master_upper_dev_get_rcu(dev);
862 if (!netif_is_bridge_master(upper))
865 swdev_work = kzalloc(sizeof(*swdev_work), GFP_ATOMIC);
869 swdev_work->event = event;
870 swdev_work->dev = dev;
873 case SWITCHDEV_FDB_ADD_TO_DEVICE:
874 case SWITCHDEV_FDB_DEL_TO_DEVICE:
875 fdb_info = container_of(info,
876 struct switchdev_notifier_fdb_info,
879 INIT_WORK(&swdev_work->work, prestera_fdb_event_work);
880 memcpy(&swdev_work->fdb_info, ptr,
881 sizeof(swdev_work->fdb_info));
883 swdev_work->fdb_info.addr = kzalloc(ETH_ALEN, GFP_ATOMIC);
884 if (!swdev_work->fdb_info.addr)
887 ether_addr_copy((u8 *)swdev_work->fdb_info.addr,
897 queue_work(swdev_wq, &swdev_work->work);
906 prestera_port_vlan_bridge_join(struct prestera_port_vlan *port_vlan,
907 struct prestera_bridge_port *br_port)
909 struct prestera_port *port = port_vlan->port;
910 struct prestera_bridge_vlan *br_vlan;
911 u16 vid = port_vlan->vid;
914 if (port_vlan->br_port)
917 err = prestera_hw_port_flood_set(port, br_port->flags & BR_FLOOD);
921 err = prestera_hw_port_learning_set(port, br_port->flags & BR_LEARNING);
923 goto err_port_learning_set;
925 err = prestera_port_vid_stp_set(port, vid, br_port->stp_state);
927 goto err_port_vid_stp_set;
929 br_vlan = prestera_bridge_vlan_by_vid(br_port, vid);
931 br_vlan = prestera_bridge_vlan_create(br_port, vid);
934 goto err_bridge_vlan_get;
938 list_add(&port_vlan->br_vlan_head, &br_vlan->port_vlan_list);
940 prestera_bridge_port_get(br_port);
941 port_vlan->br_port = br_port;
946 prestera_port_vid_stp_set(port, vid, BR_STATE_FORWARDING);
947 err_port_vid_stp_set:
948 prestera_hw_port_learning_set(port, false);
949 err_port_learning_set:
954 prestera_bridge_port_vlan_add(struct prestera_port *port,
955 struct prestera_bridge_port *br_port,
956 u16 vid, bool is_untagged, bool is_pvid,
957 struct netlink_ext_ack *extack)
959 struct prestera_port_vlan *port_vlan;
960 u16 old_pvid = port->pvid;
967 pvid = port->pvid == vid ? 0 : port->pvid;
969 port_vlan = prestera_port_vlan_by_vid(port, vid);
970 if (port_vlan && port_vlan->br_port != br_port)
974 port_vlan = prestera_port_vlan_create(port, vid, is_untagged);
975 if (IS_ERR(port_vlan))
976 return PTR_ERR(port_vlan);
978 err = prestera_hw_vlan_port_set(port, vid, true, is_untagged);
980 goto err_port_vlan_set;
983 err = prestera_port_pvid_set(port, pvid);
985 goto err_port_pvid_set;
987 err = prestera_port_vlan_bridge_join(port_vlan, br_port);
989 goto err_port_vlan_bridge_join;
993 err_port_vlan_bridge_join:
994 prestera_port_pvid_set(port, old_pvid);
996 prestera_hw_vlan_port_set(port, vid, false, false);
998 prestera_port_vlan_destroy(port_vlan);
1004 prestera_bridge_port_vlan_del(struct prestera_port *port,
1005 struct prestera_bridge_port *br_port, u16 vid)
1007 u16 pvid = port->pvid == vid ? 0 : port->pvid;
1008 struct prestera_port_vlan *port_vlan;
1010 port_vlan = prestera_port_vlan_by_vid(port, vid);
1011 if (WARN_ON(!port_vlan))
1014 prestera_port_vlan_bridge_leave(port_vlan);
1015 prestera_port_pvid_set(port, pvid);
1016 prestera_port_vlan_destroy(port_vlan);
1019 static int prestera_port_vlans_add(struct prestera_port *port,
1020 const struct switchdev_obj_port_vlan *vlan,
1021 struct switchdev_trans *trans,
1022 struct netlink_ext_ack *extack)
1024 bool flag_untagged = vlan->flags & BRIDGE_VLAN_INFO_UNTAGGED;
1025 bool flag_pvid = vlan->flags & BRIDGE_VLAN_INFO_PVID;
1026 struct net_device *dev = vlan->obj.orig_dev;
1027 struct prestera_bridge_port *br_port;
1028 struct prestera_switch *sw = port->sw;
1029 struct prestera_bridge *bridge;
1032 if (netif_is_bridge_master(dev))
1035 if (switchdev_trans_ph_commit(trans))
1038 br_port = prestera_bridge_port_by_dev(sw->swdev, dev);
1039 if (WARN_ON(!br_port))
1042 bridge = br_port->bridge;
1043 if (!bridge->vlan_enabled)
1046 for (vid = vlan->vid_begin; vid <= vlan->vid_end; vid++) {
1049 err = prestera_bridge_port_vlan_add(port, br_port,
1059 static int prestera_port_obj_add(struct net_device *dev,
1060 const struct switchdev_obj *obj,
1061 struct switchdev_trans *trans,
1062 struct netlink_ext_ack *extack)
1064 struct prestera_port *port = netdev_priv(dev);
1065 const struct switchdev_obj_port_vlan *vlan;
1068 case SWITCHDEV_OBJ_ID_PORT_VLAN:
1069 vlan = SWITCHDEV_OBJ_PORT_VLAN(obj);
1070 return prestera_port_vlans_add(port, vlan, trans, extack);
1076 static int prestera_port_vlans_del(struct prestera_port *port,
1077 const struct switchdev_obj_port_vlan *vlan)
1079 struct net_device *dev = vlan->obj.orig_dev;
1080 struct prestera_bridge_port *br_port;
1081 struct prestera_switch *sw = port->sw;
1084 if (netif_is_bridge_master(dev))
1087 br_port = prestera_bridge_port_by_dev(sw->swdev, dev);
1088 if (WARN_ON(!br_port))
1091 if (!br_port->bridge->vlan_enabled)
1094 for (vid = vlan->vid_begin; vid <= vlan->vid_end; vid++)
1095 prestera_bridge_port_vlan_del(port, br_port, vid);
1100 static int prestera_port_obj_del(struct net_device *dev,
1101 const struct switchdev_obj *obj)
1103 struct prestera_port *port = netdev_priv(dev);
1106 case SWITCHDEV_OBJ_ID_PORT_VLAN:
1107 return prestera_port_vlans_del(port, SWITCHDEV_OBJ_PORT_VLAN(obj));
1113 static int prestera_switchdev_blk_event(struct notifier_block *unused,
1114 unsigned long event, void *ptr)
1116 struct net_device *dev = switchdev_notifier_info_to_dev(ptr);
1120 case SWITCHDEV_PORT_OBJ_ADD:
1121 err = switchdev_handle_port_obj_add(dev, ptr,
1122 prestera_netdev_check,
1123 prestera_port_obj_add);
1125 case SWITCHDEV_PORT_OBJ_DEL:
1126 err = switchdev_handle_port_obj_del(dev, ptr,
1127 prestera_netdev_check,
1128 prestera_port_obj_del);
1130 case SWITCHDEV_PORT_ATTR_SET:
1131 err = switchdev_handle_port_attr_set(dev, ptr,
1132 prestera_netdev_check,
1133 prestera_port_obj_attr_set);
1139 return notifier_from_errno(err);
1142 static void prestera_fdb_event(struct prestera_switch *sw,
1143 struct prestera_event *evt, void *arg)
1145 struct switchdev_notifier_fdb_info info;
1146 struct prestera_port *port;
1148 port = prestera_find_port(sw, evt->fdb_evt.port_id);
1152 info.addr = evt->fdb_evt.data.mac;
1153 info.vid = evt->fdb_evt.vid;
1154 info.offloaded = true;
1159 case PRESTERA_FDB_EVENT_LEARNED:
1160 call_switchdev_notifiers(SWITCHDEV_FDB_ADD_TO_BRIDGE,
1161 port->dev, &info.info, NULL);
1163 case PRESTERA_FDB_EVENT_AGED:
1164 call_switchdev_notifiers(SWITCHDEV_FDB_DEL_TO_BRIDGE,
1165 port->dev, &info.info, NULL);
1172 static int prestera_fdb_init(struct prestera_switch *sw)
1176 err = prestera_hw_event_handler_register(sw, PRESTERA_EVENT_TYPE_FDB,
1177 prestera_fdb_event, NULL);
1181 err = prestera_hw_switch_ageing_set(sw, PRESTERA_DEFAULT_AGEING_TIME_MS);
1183 goto err_ageing_set;
1188 prestera_hw_event_handler_unregister(sw, PRESTERA_EVENT_TYPE_FDB,
1189 prestera_fdb_event);
1193 static void prestera_fdb_fini(struct prestera_switch *sw)
1195 prestera_hw_event_handler_unregister(sw, PRESTERA_EVENT_TYPE_FDB,
1196 prestera_fdb_event);
1199 static int prestera_switchdev_handler_init(struct prestera_switchdev *swdev)
1203 swdev->swdev_nb.notifier_call = prestera_switchdev_event;
1204 err = register_switchdev_notifier(&swdev->swdev_nb);
1206 goto err_register_swdev_notifier;
1208 swdev->swdev_nb_blk.notifier_call = prestera_switchdev_blk_event;
1209 err = register_switchdev_blocking_notifier(&swdev->swdev_nb_blk);
1211 goto err_register_blk_swdev_notifier;
1215 err_register_blk_swdev_notifier:
1216 unregister_switchdev_notifier(&swdev->swdev_nb);
1217 err_register_swdev_notifier:
1218 destroy_workqueue(swdev_wq);
1222 static void prestera_switchdev_handler_fini(struct prestera_switchdev *swdev)
1224 unregister_switchdev_blocking_notifier(&swdev->swdev_nb_blk);
1225 unregister_switchdev_notifier(&swdev->swdev_nb);
1228 int prestera_switchdev_init(struct prestera_switch *sw)
1230 struct prestera_switchdev *swdev;
1233 swdev = kzalloc(sizeof(*swdev), GFP_KERNEL);
1240 INIT_LIST_HEAD(&swdev->bridge_list);
1242 swdev_wq = alloc_ordered_workqueue("%s_ordered", 0, "prestera_br");
1248 err = prestera_switchdev_handler_init(swdev);
1250 goto err_swdev_init;
1252 err = prestera_fdb_init(sw);
1260 destroy_workqueue(swdev_wq);
1267 void prestera_switchdev_fini(struct prestera_switch *sw)
1269 struct prestera_switchdev *swdev = sw->swdev;
1271 prestera_fdb_fini(sw);
1272 prestera_switchdev_handler_fini(swdev);
1273 destroy_workqueue(swdev_wq);