Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
0002 /* Copyright (c) 2019-2020 Marvell International Ltd. All rights reserved */
0003 
0004 #include <linux/if_bridge.h>
0005 #include <linux/if_vlan.h>
0006 #include <linux/kernel.h>
0007 #include <linux/module.h>
0008 #include <linux/notifier.h>
0009 #include <net/netevent.h>
0010 #include <net/switchdev.h>
0011 
0012 #include "prestera.h"
0013 #include "prestera_hw.h"
0014 #include "prestera_switchdev.h"
0015 
0016 #define PRESTERA_VID_ALL (0xffff)
0017 
0018 #define PRESTERA_DEFAULT_AGEING_TIME_MS 300000
0019 #define PRESTERA_MAX_AGEING_TIME_MS 1000000000
0020 #define PRESTERA_MIN_AGEING_TIME_MS 32000
0021 
0022 struct prestera_fdb_event_work {
0023     struct work_struct work;
0024     struct switchdev_notifier_fdb_info fdb_info;
0025     struct net_device *dev;
0026     unsigned long event;
0027 };
0028 
0029 struct prestera_switchdev {
0030     struct prestera_switch *sw;
0031     struct list_head bridge_list;
0032     bool bridge_8021q_exists;
0033     struct notifier_block swdev_nb_blk;
0034     struct notifier_block swdev_nb;
0035 };
0036 
0037 struct prestera_bridge {
0038     struct list_head head;
0039     struct net_device *dev;
0040     struct prestera_switchdev *swdev;
0041     struct list_head port_list;
0042     struct list_head br_mdb_entry_list;
0043     bool mrouter_exist;
0044     bool vlan_enabled;
0045     bool multicast_enabled;
0046     u16 bridge_id;
0047 };
0048 
0049 struct prestera_bridge_port {
0050     struct list_head head;
0051     struct net_device *dev;
0052     struct prestera_bridge *bridge;
0053     struct list_head vlan_list;
0054     struct list_head br_mdb_port_list;
0055     refcount_t ref_count;
0056     unsigned long flags;
0057     bool mrouter;
0058     u8 stp_state;
0059 };
0060 
0061 struct prestera_bridge_vlan {
0062     struct list_head head;
0063     struct list_head port_vlan_list;
0064     u16 vid;
0065 };
0066 
0067 struct prestera_port_vlan {
0068     struct list_head br_vlan_head;
0069     struct list_head port_head;
0070     struct prestera_port *port;
0071     struct prestera_bridge_port *br_port;
0072     u16 vid;
0073 };
0074 
0075 struct prestera_br_mdb_port {
0076     struct prestera_bridge_port *br_port;
0077     struct list_head br_mdb_port_node;
0078 };
0079 
0080 /* Software representation of MDB table. */
0081 struct prestera_br_mdb_entry {
0082     struct prestera_bridge *bridge;
0083     struct prestera_mdb_entry *mdb;
0084     struct list_head br_mdb_port_list;
0085     struct list_head br_mdb_entry_node;
0086     bool enabled;
0087 };
0088 
0089 static struct workqueue_struct *swdev_wq;
0090 
0091 static void prestera_bridge_port_put(struct prestera_bridge_port *br_port);
0092 
0093 static int prestera_port_vid_stp_set(struct prestera_port *port, u16 vid,
0094                      u8 state);
0095 
0096 static struct prestera_bridge *
0097 prestera_bridge_find(const struct prestera_switch *sw,
0098              const struct net_device *br_dev)
0099 {
0100     struct prestera_bridge *bridge;
0101 
0102     list_for_each_entry(bridge, &sw->swdev->bridge_list, head)
0103         if (bridge->dev == br_dev)
0104             return bridge;
0105 
0106     return NULL;
0107 }
0108 
0109 static struct prestera_bridge_port *
0110 __prestera_bridge_port_find(const struct prestera_bridge *bridge,
0111                 const struct net_device *brport_dev)
0112 {
0113     struct prestera_bridge_port *br_port;
0114 
0115     list_for_each_entry(br_port, &bridge->port_list, head)
0116         if (br_port->dev == brport_dev)
0117             return br_port;
0118 
0119     return NULL;
0120 }
0121 
0122 static struct prestera_bridge_port *
0123 prestera_bridge_port_find(struct prestera_switch *sw,
0124               struct net_device *brport_dev)
0125 {
0126     struct net_device *br_dev = netdev_master_upper_dev_get(brport_dev);
0127     struct prestera_bridge *bridge;
0128 
0129     if (!br_dev)
0130         return NULL;
0131 
0132     bridge = prestera_bridge_find(sw, br_dev);
0133     if (!bridge)
0134         return NULL;
0135 
0136     return __prestera_bridge_port_find(bridge, brport_dev);
0137 }
0138 
0139 static void
0140 prestera_br_port_flags_reset(struct prestera_bridge_port *br_port,
0141                  struct prestera_port *port)
0142 {
0143     prestera_port_uc_flood_set(port, false);
0144     prestera_port_mc_flood_set(port, false);
0145     prestera_port_learning_set(port, false);
0146 }
0147 
0148 static int prestera_br_port_flags_set(struct prestera_bridge_port *br_port,
0149                       struct prestera_port *port)
0150 {
0151     int err;
0152 
0153     err = prestera_port_uc_flood_set(port, br_port->flags & BR_FLOOD);
0154     if (err)
0155         goto err_out;
0156 
0157     err = prestera_port_mc_flood_set(port, br_port->flags & BR_MCAST_FLOOD);
0158     if (err)
0159         goto err_out;
0160 
0161     err = prestera_port_learning_set(port, br_port->flags & BR_LEARNING);
0162     if (err)
0163         goto err_out;
0164 
0165     return 0;
0166 
0167 err_out:
0168     prestera_br_port_flags_reset(br_port, port);
0169     return err;
0170 }
0171 
0172 static struct prestera_bridge_vlan *
0173 prestera_bridge_vlan_create(struct prestera_bridge_port *br_port, u16 vid)
0174 {
0175     struct prestera_bridge_vlan *br_vlan;
0176 
0177     br_vlan = kzalloc(sizeof(*br_vlan), GFP_KERNEL);
0178     if (!br_vlan)
0179         return NULL;
0180 
0181     INIT_LIST_HEAD(&br_vlan->port_vlan_list);
0182     br_vlan->vid = vid;
0183     list_add(&br_vlan->head, &br_port->vlan_list);
0184 
0185     return br_vlan;
0186 }
0187 
0188 static void prestera_bridge_vlan_destroy(struct prestera_bridge_vlan *br_vlan)
0189 {
0190     list_del(&br_vlan->head);
0191     WARN_ON(!list_empty(&br_vlan->port_vlan_list));
0192     kfree(br_vlan);
0193 }
0194 
0195 static struct prestera_bridge_vlan *
0196 prestera_bridge_vlan_by_vid(struct prestera_bridge_port *br_port, u16 vid)
0197 {
0198     struct prestera_bridge_vlan *br_vlan;
0199 
0200     list_for_each_entry(br_vlan, &br_port->vlan_list, head) {
0201         if (br_vlan->vid == vid)
0202             return br_vlan;
0203     }
0204 
0205     return NULL;
0206 }
0207 
0208 static int prestera_bridge_vlan_port_count(struct prestera_bridge *bridge,
0209                        u16 vid)
0210 {
0211     struct prestera_bridge_port *br_port;
0212     struct prestera_bridge_vlan *br_vlan;
0213     int count = 0;
0214 
0215     list_for_each_entry(br_port, &bridge->port_list, head) {
0216         list_for_each_entry(br_vlan, &br_port->vlan_list, head) {
0217             if (br_vlan->vid == vid) {
0218                 count += 1;
0219                 break;
0220             }
0221         }
0222     }
0223 
0224     return count;
0225 }
0226 
0227 static void prestera_bridge_vlan_put(struct prestera_bridge_vlan *br_vlan)
0228 {
0229     if (list_empty(&br_vlan->port_vlan_list))
0230         prestera_bridge_vlan_destroy(br_vlan);
0231 }
0232 
0233 static struct prestera_port_vlan *
0234 prestera_port_vlan_by_vid(struct prestera_port *port, u16 vid)
0235 {
0236     struct prestera_port_vlan *port_vlan;
0237 
0238     list_for_each_entry(port_vlan, &port->vlans_list, port_head) {
0239         if (port_vlan->vid == vid)
0240             return port_vlan;
0241     }
0242 
0243     return NULL;
0244 }
0245 
0246 static struct prestera_port_vlan *
0247 prestera_port_vlan_create(struct prestera_port *port, u16 vid, bool untagged)
0248 {
0249     struct prestera_port_vlan *port_vlan;
0250     int err;
0251 
0252     port_vlan = prestera_port_vlan_by_vid(port, vid);
0253     if (port_vlan)
0254         return ERR_PTR(-EEXIST);
0255 
0256     err = prestera_hw_vlan_port_set(port, vid, true, untagged);
0257     if (err)
0258         return ERR_PTR(err);
0259 
0260     port_vlan = kzalloc(sizeof(*port_vlan), GFP_KERNEL);
0261     if (!port_vlan) {
0262         err = -ENOMEM;
0263         goto err_port_vlan_alloc;
0264     }
0265 
0266     port_vlan->port = port;
0267     port_vlan->vid = vid;
0268 
0269     list_add(&port_vlan->port_head, &port->vlans_list);
0270 
0271     return port_vlan;
0272 
0273 err_port_vlan_alloc:
0274     prestera_hw_vlan_port_set(port, vid, false, false);
0275     return ERR_PTR(err);
0276 }
0277 
0278 static int prestera_fdb_add(struct prestera_port *port,
0279                 const unsigned char *mac, u16 vid, bool dynamic)
0280 {
0281     if (prestera_port_is_lag_member(port))
0282         return prestera_hw_lag_fdb_add(port->sw, prestera_port_lag_id(port),
0283                           mac, vid, dynamic);
0284 
0285     return prestera_hw_fdb_add(port, mac, vid, dynamic);
0286 }
0287 
0288 static int prestera_fdb_del(struct prestera_port *port,
0289                 const unsigned char *mac, u16 vid)
0290 {
0291     if (prestera_port_is_lag_member(port))
0292         return prestera_hw_lag_fdb_del(port->sw, prestera_port_lag_id(port),
0293                           mac, vid);
0294     else
0295         return prestera_hw_fdb_del(port, mac, vid);
0296 }
0297 
0298 static int prestera_fdb_flush_port_vlan(struct prestera_port *port, u16 vid,
0299                     u32 mode)
0300 {
0301     if (prestera_port_is_lag_member(port))
0302         return prestera_hw_fdb_flush_lag_vlan(port->sw, prestera_port_lag_id(port),
0303                               vid, mode);
0304     else
0305         return prestera_hw_fdb_flush_port_vlan(port, vid, mode);
0306 }
0307 
0308 static int prestera_fdb_flush_port(struct prestera_port *port, u32 mode)
0309 {
0310     if (prestera_port_is_lag_member(port))
0311         return prestera_hw_fdb_flush_lag(port->sw, prestera_port_lag_id(port),
0312                          mode);
0313     else
0314         return prestera_hw_fdb_flush_port(port, mode);
0315 }
0316 
0317 static void
0318 prestera_mdb_port_del(struct prestera_mdb_entry *mdb,
0319               struct net_device *orig_dev)
0320 {
0321     struct prestera_flood_domain *fl_domain = mdb->flood_domain;
0322     struct prestera_flood_domain_port *flood_domain_port;
0323 
0324     flood_domain_port = prestera_flood_domain_port_find(fl_domain,
0325                                 orig_dev,
0326                                 mdb->vid);
0327     if (flood_domain_port)
0328         prestera_flood_domain_port_destroy(flood_domain_port);
0329 }
0330 
0331 static void
0332 prestera_br_mdb_entry_put(struct prestera_br_mdb_entry *br_mdb)
0333 {
0334     struct prestera_bridge_port *br_port;
0335 
0336     if (list_empty(&br_mdb->br_mdb_port_list)) {
0337         list_for_each_entry(br_port, &br_mdb->bridge->port_list, head)
0338             prestera_mdb_port_del(br_mdb->mdb, br_port->dev);
0339 
0340         prestera_mdb_entry_destroy(br_mdb->mdb);
0341         list_del(&br_mdb->br_mdb_entry_node);
0342         kfree(br_mdb);
0343     }
0344 }
0345 
0346 static void
0347 prestera_br_mdb_port_del(struct prestera_br_mdb_entry *br_mdb,
0348              struct prestera_bridge_port *br_port)
0349 {
0350     struct prestera_br_mdb_port *br_mdb_port, *tmp;
0351 
0352     list_for_each_entry_safe(br_mdb_port, tmp, &br_mdb->br_mdb_port_list,
0353                  br_mdb_port_node) {
0354         if (br_mdb_port->br_port == br_port) {
0355             list_del(&br_mdb_port->br_mdb_port_node);
0356             kfree(br_mdb_port);
0357         }
0358     }
0359 }
0360 
0361 static void
0362 prestera_mdb_flush_bridge_port(struct prestera_bridge_port *br_port)
0363 {
0364     struct prestera_br_mdb_port *br_mdb_port, *tmp_port;
0365     struct prestera_br_mdb_entry *br_mdb, *br_mdb_tmp;
0366     struct prestera_bridge *br_dev = br_port->bridge;
0367 
0368     list_for_each_entry_safe(br_mdb, br_mdb_tmp, &br_dev->br_mdb_entry_list,
0369                  br_mdb_entry_node) {
0370         list_for_each_entry_safe(br_mdb_port, tmp_port,
0371                      &br_mdb->br_mdb_port_list,
0372                      br_mdb_port_node) {
0373             prestera_mdb_port_del(br_mdb->mdb,
0374                           br_mdb_port->br_port->dev);
0375             prestera_br_mdb_port_del(br_mdb,  br_mdb_port->br_port);
0376         }
0377         prestera_br_mdb_entry_put(br_mdb);
0378     }
0379 }
0380 
0381 static void
0382 prestera_port_vlan_bridge_leave(struct prestera_port_vlan *port_vlan)
0383 {
0384     u32 fdb_flush_mode = PRESTERA_FDB_FLUSH_MODE_DYNAMIC;
0385     struct prestera_port *port = port_vlan->port;
0386     struct prestera_bridge_vlan *br_vlan;
0387     struct prestera_bridge_port *br_port;
0388     bool last_port, last_vlan;
0389     u16 vid = port_vlan->vid;
0390     int port_count;
0391 
0392     br_port = port_vlan->br_port;
0393     port_count = prestera_bridge_vlan_port_count(br_port->bridge, vid);
0394     br_vlan = prestera_bridge_vlan_by_vid(br_port, vid);
0395 
0396     last_vlan = list_is_singular(&br_port->vlan_list);
0397     last_port = port_count == 1;
0398 
0399     if (last_vlan)
0400         prestera_fdb_flush_port(port, fdb_flush_mode);
0401     else if (last_port)
0402         prestera_hw_fdb_flush_vlan(port->sw, vid, fdb_flush_mode);
0403     else
0404         prestera_fdb_flush_port_vlan(port, vid, fdb_flush_mode);
0405 
0406     prestera_mdb_flush_bridge_port(br_port);
0407 
0408     list_del(&port_vlan->br_vlan_head);
0409     prestera_bridge_vlan_put(br_vlan);
0410     prestera_bridge_port_put(br_port);
0411     port_vlan->br_port = NULL;
0412 }
0413 
0414 static void prestera_port_vlan_destroy(struct prestera_port_vlan *port_vlan)
0415 {
0416     struct prestera_port *port = port_vlan->port;
0417     u16 vid = port_vlan->vid;
0418 
0419     if (port_vlan->br_port)
0420         prestera_port_vlan_bridge_leave(port_vlan);
0421 
0422     prestera_hw_vlan_port_set(port, vid, false, false);
0423     list_del(&port_vlan->port_head);
0424     kfree(port_vlan);
0425 }
0426 
0427 static struct prestera_bridge *
0428 prestera_bridge_create(struct prestera_switchdev *swdev, struct net_device *dev)
0429 {
0430     bool vlan_enabled = br_vlan_enabled(dev);
0431     struct prestera_bridge *bridge;
0432     u16 bridge_id;
0433     int err;
0434 
0435     if (vlan_enabled && swdev->bridge_8021q_exists) {
0436         netdev_err(dev, "Only one VLAN-aware bridge is supported\n");
0437         return ERR_PTR(-EINVAL);
0438     }
0439 
0440     bridge = kzalloc(sizeof(*bridge), GFP_KERNEL);
0441     if (!bridge)
0442         return ERR_PTR(-ENOMEM);
0443 
0444     if (vlan_enabled) {
0445         swdev->bridge_8021q_exists = true;
0446     } else {
0447         err = prestera_hw_bridge_create(swdev->sw, &bridge_id);
0448         if (err) {
0449             kfree(bridge);
0450             return ERR_PTR(err);
0451         }
0452 
0453         bridge->bridge_id = bridge_id;
0454     }
0455 
0456     bridge->vlan_enabled = vlan_enabled;
0457     bridge->swdev = swdev;
0458     bridge->dev = dev;
0459     bridge->multicast_enabled = br_multicast_enabled(dev);
0460 
0461     INIT_LIST_HEAD(&bridge->port_list);
0462     INIT_LIST_HEAD(&bridge->br_mdb_entry_list);
0463 
0464     list_add(&bridge->head, &swdev->bridge_list);
0465 
0466     return bridge;
0467 }
0468 
0469 static void prestera_bridge_destroy(struct prestera_bridge *bridge)
0470 {
0471     struct prestera_switchdev *swdev = bridge->swdev;
0472 
0473     list_del(&bridge->head);
0474 
0475     if (bridge->vlan_enabled)
0476         swdev->bridge_8021q_exists = false;
0477     else
0478         prestera_hw_bridge_delete(swdev->sw, bridge->bridge_id);
0479 
0480     WARN_ON(!list_empty(&bridge->br_mdb_entry_list));
0481     WARN_ON(!list_empty(&bridge->port_list));
0482     kfree(bridge);
0483 }
0484 
0485 static void prestera_bridge_put(struct prestera_bridge *bridge)
0486 {
0487     if (list_empty(&bridge->port_list))
0488         prestera_bridge_destroy(bridge);
0489 }
0490 
0491 static
0492 struct prestera_bridge *prestera_bridge_by_dev(struct prestera_switchdev *swdev,
0493                            const struct net_device *dev)
0494 {
0495     struct prestera_bridge *bridge;
0496 
0497     list_for_each_entry(bridge, &swdev->bridge_list, head)
0498         if (bridge->dev == dev)
0499             return bridge;
0500 
0501     return NULL;
0502 }
0503 
0504 static struct prestera_bridge_port *
0505 __prestera_bridge_port_by_dev(struct prestera_bridge *bridge,
0506                   struct net_device *dev)
0507 {
0508     struct prestera_bridge_port *br_port;
0509 
0510     list_for_each_entry(br_port, &bridge->port_list, head) {
0511         if (br_port->dev == dev)
0512             return br_port;
0513     }
0514 
0515     return NULL;
0516 }
0517 
0518 static int prestera_match_upper_bridge_dev(struct net_device *dev,
0519                        struct netdev_nested_priv *priv)
0520 {
0521     if (netif_is_bridge_master(dev))
0522         priv->data = dev;
0523 
0524     return 0;
0525 }
0526 
0527 static struct net_device *prestera_get_upper_bridge_dev(struct net_device *dev)
0528 {
0529     struct netdev_nested_priv priv = { };
0530 
0531     netdev_walk_all_upper_dev_rcu(dev, prestera_match_upper_bridge_dev,
0532                       &priv);
0533     return priv.data;
0534 }
0535 
0536 static struct prestera_bridge_port *
0537 prestera_bridge_port_by_dev(struct prestera_switchdev *swdev,
0538                 struct net_device *dev)
0539 {
0540     struct net_device *br_dev = prestera_get_upper_bridge_dev(dev);
0541     struct prestera_bridge *bridge;
0542 
0543     if (!br_dev)
0544         return NULL;
0545 
0546     bridge = prestera_bridge_by_dev(swdev, br_dev);
0547     if (!bridge)
0548         return NULL;
0549 
0550     return __prestera_bridge_port_by_dev(bridge, dev);
0551 }
0552 
0553 static struct prestera_bridge_port *
0554 prestera_bridge_port_create(struct prestera_bridge *bridge,
0555                 struct net_device *dev)
0556 {
0557     struct prestera_bridge_port *br_port;
0558 
0559     br_port = kzalloc(sizeof(*br_port), GFP_KERNEL);
0560     if (!br_port)
0561         return NULL;
0562 
0563     br_port->flags = BR_LEARNING | BR_FLOOD | BR_LEARNING_SYNC |
0564                 BR_MCAST_FLOOD;
0565     br_port->stp_state = BR_STATE_DISABLED;
0566     refcount_set(&br_port->ref_count, 1);
0567     br_port->bridge = bridge;
0568     br_port->dev = dev;
0569 
0570     INIT_LIST_HEAD(&br_port->vlan_list);
0571     list_add(&br_port->head, &bridge->port_list);
0572     INIT_LIST_HEAD(&br_port->br_mdb_port_list);
0573 
0574     return br_port;
0575 }
0576 
0577 static void
0578 prestera_bridge_port_destroy(struct prestera_bridge_port *br_port)
0579 {
0580     list_del(&br_port->head);
0581     WARN_ON(!list_empty(&br_port->vlan_list));
0582     WARN_ON(!list_empty(&br_port->br_mdb_port_list));
0583     kfree(br_port);
0584 }
0585 
0586 static void prestera_bridge_port_get(struct prestera_bridge_port *br_port)
0587 {
0588     refcount_inc(&br_port->ref_count);
0589 }
0590 
0591 static void prestera_bridge_port_put(struct prestera_bridge_port *br_port)
0592 {
0593     struct prestera_bridge *bridge = br_port->bridge;
0594 
0595     if (refcount_dec_and_test(&br_port->ref_count)) {
0596         prestera_bridge_port_destroy(br_port);
0597         prestera_bridge_put(bridge);
0598     }
0599 }
0600 
0601 static struct prestera_bridge_port *
0602 prestera_bridge_port_add(struct prestera_bridge *bridge, struct net_device *dev)
0603 {
0604     struct prestera_bridge_port *br_port;
0605 
0606     br_port = __prestera_bridge_port_by_dev(bridge, dev);
0607     if (br_port) {
0608         prestera_bridge_port_get(br_port);
0609         return br_port;
0610     }
0611 
0612     br_port = prestera_bridge_port_create(bridge, dev);
0613     if (!br_port)
0614         return ERR_PTR(-ENOMEM);
0615 
0616     return br_port;
0617 }
0618 
0619 static int
0620 prestera_bridge_1d_port_join(struct prestera_bridge_port *br_port)
0621 {
0622     struct prestera_port *port = netdev_priv(br_port->dev);
0623     struct prestera_bridge *bridge = br_port->bridge;
0624     int err;
0625 
0626     err = prestera_hw_bridge_port_add(port, bridge->bridge_id);
0627     if (err)
0628         return err;
0629 
0630     err = prestera_br_port_flags_set(br_port, port);
0631     if (err)
0632         goto err_flags2port_set;
0633 
0634     return 0;
0635 
0636 err_flags2port_set:
0637     prestera_hw_bridge_port_delete(port, bridge->bridge_id);
0638 
0639     return err;
0640 }
0641 
0642 int prestera_bridge_port_join(struct net_device *br_dev,
0643                   struct prestera_port *port,
0644                   struct netlink_ext_ack *extack)
0645 {
0646     struct prestera_switchdev *swdev = port->sw->swdev;
0647     struct prestera_bridge_port *br_port;
0648     struct prestera_bridge *bridge;
0649     int err;
0650 
0651     bridge = prestera_bridge_by_dev(swdev, br_dev);
0652     if (!bridge) {
0653         bridge = prestera_bridge_create(swdev, br_dev);
0654         if (IS_ERR(bridge))
0655             return PTR_ERR(bridge);
0656     }
0657 
0658     br_port = prestera_bridge_port_add(bridge, port->dev);
0659     if (IS_ERR(br_port)) {
0660         prestera_bridge_put(bridge);
0661         return PTR_ERR(br_port);
0662     }
0663 
0664     err = switchdev_bridge_port_offload(br_port->dev, port->dev, NULL,
0665                         NULL, NULL, false, extack);
0666     if (err)
0667         goto err_switchdev_offload;
0668 
0669     if (bridge->vlan_enabled)
0670         return 0;
0671 
0672     err = prestera_bridge_1d_port_join(br_port);
0673     if (err)
0674         goto err_port_join;
0675 
0676     return 0;
0677 
0678 err_port_join:
0679     switchdev_bridge_port_unoffload(br_port->dev, NULL, NULL, NULL);
0680 err_switchdev_offload:
0681     prestera_bridge_port_put(br_port);
0682     return err;
0683 }
0684 
0685 static void prestera_bridge_1q_port_leave(struct prestera_bridge_port *br_port)
0686 {
0687     struct prestera_port *port = netdev_priv(br_port->dev);
0688 
0689     prestera_hw_fdb_flush_port(port, PRESTERA_FDB_FLUSH_MODE_ALL);
0690     prestera_port_pvid_set(port, PRESTERA_DEFAULT_VID);
0691 }
0692 
0693 static void prestera_bridge_1d_port_leave(struct prestera_bridge_port *br_port)
0694 {
0695     struct prestera_port *port = netdev_priv(br_port->dev);
0696 
0697     prestera_hw_fdb_flush_port(port, PRESTERA_FDB_FLUSH_MODE_ALL);
0698     prestera_hw_bridge_port_delete(port, br_port->bridge->bridge_id);
0699 }
0700 
0701 static int prestera_port_vid_stp_set(struct prestera_port *port, u16 vid,
0702                      u8 state)
0703 {
0704     u8 hw_state = state;
0705 
0706     switch (state) {
0707     case BR_STATE_DISABLED:
0708         hw_state = PRESTERA_STP_DISABLED;
0709         break;
0710 
0711     case BR_STATE_BLOCKING:
0712     case BR_STATE_LISTENING:
0713         hw_state = PRESTERA_STP_BLOCK_LISTEN;
0714         break;
0715 
0716     case BR_STATE_LEARNING:
0717         hw_state = PRESTERA_STP_LEARN;
0718         break;
0719 
0720     case BR_STATE_FORWARDING:
0721         hw_state = PRESTERA_STP_FORWARD;
0722         break;
0723 
0724     default:
0725         return -EINVAL;
0726     }
0727 
0728     return prestera_hw_vlan_port_stp_set(port, vid, hw_state);
0729 }
0730 
0731 void prestera_bridge_port_leave(struct net_device *br_dev,
0732                 struct prestera_port *port)
0733 {
0734     struct prestera_switchdev *swdev = port->sw->swdev;
0735     struct prestera_bridge_port *br_port;
0736     struct prestera_bridge *bridge;
0737 
0738     bridge = prestera_bridge_by_dev(swdev, br_dev);
0739     if (!bridge)
0740         return;
0741 
0742     br_port = __prestera_bridge_port_by_dev(bridge, port->dev);
0743     if (!br_port)
0744         return;
0745 
0746     bridge = br_port->bridge;
0747 
0748     if (bridge->vlan_enabled)
0749         prestera_bridge_1q_port_leave(br_port);
0750     else
0751         prestera_bridge_1d_port_leave(br_port);
0752 
0753     switchdev_bridge_port_unoffload(br_port->dev, NULL, NULL, NULL);
0754 
0755     prestera_mdb_flush_bridge_port(br_port);
0756 
0757     prestera_br_port_flags_reset(br_port, port);
0758     prestera_port_vid_stp_set(port, PRESTERA_VID_ALL, BR_STATE_FORWARDING);
0759     prestera_bridge_port_put(br_port);
0760 }
0761 
0762 static int prestera_port_attr_br_flags_set(struct prestera_port *port,
0763                        struct net_device *dev,
0764                        struct switchdev_brport_flags flags)
0765 {
0766     struct prestera_bridge_port *br_port;
0767 
0768     br_port = prestera_bridge_port_by_dev(port->sw->swdev, dev);
0769     if (!br_port)
0770         return 0;
0771 
0772     br_port->flags &= ~flags.mask;
0773     br_port->flags |= flags.val & flags.mask;
0774     return prestera_br_port_flags_set(br_port, port);
0775 }
0776 
0777 static int prestera_port_attr_br_ageing_set(struct prestera_port *port,
0778                         unsigned long ageing_clock_t)
0779 {
0780     unsigned long ageing_jiffies = clock_t_to_jiffies(ageing_clock_t);
0781     u32 ageing_time_ms = jiffies_to_msecs(ageing_jiffies);
0782     struct prestera_switch *sw = port->sw;
0783 
0784     if (ageing_time_ms < PRESTERA_MIN_AGEING_TIME_MS ||
0785         ageing_time_ms > PRESTERA_MAX_AGEING_TIME_MS)
0786         return -ERANGE;
0787 
0788     return prestera_hw_switch_ageing_set(sw, ageing_time_ms);
0789 }
0790 
0791 static int prestera_port_attr_br_vlan_set(struct prestera_port *port,
0792                       struct net_device *dev,
0793                       bool vlan_enabled)
0794 {
0795     struct prestera_switch *sw = port->sw;
0796     struct prestera_bridge *bridge;
0797 
0798     bridge = prestera_bridge_by_dev(sw->swdev, dev);
0799     if (WARN_ON(!bridge))
0800         return -EINVAL;
0801 
0802     if (bridge->vlan_enabled == vlan_enabled)
0803         return 0;
0804 
0805     netdev_err(bridge->dev, "VLAN filtering can't be changed for existing bridge\n");
0806 
0807     return -EINVAL;
0808 }
0809 
0810 static int prestera_port_bridge_vlan_stp_set(struct prestera_port *port,
0811                          struct prestera_bridge_vlan *br_vlan,
0812                          u8 state)
0813 {
0814     struct prestera_port_vlan *port_vlan;
0815 
0816     list_for_each_entry(port_vlan, &br_vlan->port_vlan_list, br_vlan_head) {
0817         if (port_vlan->port != port)
0818             continue;
0819 
0820         return prestera_port_vid_stp_set(port, br_vlan->vid, state);
0821     }
0822 
0823     return 0;
0824 }
0825 
0826 static int prestera_port_attr_stp_state_set(struct prestera_port *port,
0827                         struct net_device *dev,
0828                         u8 state)
0829 {
0830     struct prestera_bridge_port *br_port;
0831     struct prestera_bridge_vlan *br_vlan;
0832     int err;
0833     u16 vid;
0834 
0835     br_port = prestera_bridge_port_by_dev(port->sw->swdev, dev);
0836     if (!br_port)
0837         return 0;
0838 
0839     if (!br_port->bridge->vlan_enabled) {
0840         vid = br_port->bridge->bridge_id;
0841         err = prestera_port_vid_stp_set(port, vid, state);
0842         if (err)
0843             goto err_port_stp_set;
0844     } else {
0845         list_for_each_entry(br_vlan, &br_port->vlan_list, head) {
0846             err = prestera_port_bridge_vlan_stp_set(port, br_vlan,
0847                                 state);
0848             if (err)
0849                 goto err_port_vlan_stp_set;
0850         }
0851     }
0852 
0853     br_port->stp_state = state;
0854 
0855     return 0;
0856 
0857 err_port_vlan_stp_set:
0858     list_for_each_entry_continue_reverse(br_vlan, &br_port->vlan_list, head)
0859         prestera_port_bridge_vlan_stp_set(port, br_vlan, br_port->stp_state);
0860     return err;
0861 
0862 err_port_stp_set:
0863     prestera_port_vid_stp_set(port, vid, br_port->stp_state);
0864 
0865     return err;
0866 }
0867 
0868 static int
0869 prestera_br_port_lag_mdb_mc_enable_sync(struct prestera_bridge_port *br_port,
0870                     bool enabled)
0871 {
0872     struct prestera_port *pr_port;
0873     struct prestera_switch *sw;
0874     u16 lag_id;
0875     int err;
0876 
0877     pr_port = prestera_port_dev_lower_find(br_port->dev);
0878     if (!pr_port)
0879         return 0;
0880 
0881     sw = pr_port->sw;
0882     err = prestera_lag_id(sw, br_port->dev, &lag_id);
0883     if (err)
0884         return err;
0885 
0886     list_for_each_entry(pr_port, &sw->port_list, list) {
0887         if (pr_port->lag->lag_id == lag_id) {
0888             err = prestera_port_mc_flood_set(pr_port, enabled);
0889             if (err)
0890                 return err;
0891         }
0892     }
0893 
0894     return 0;
0895 }
0896 
0897 static int prestera_br_mdb_mc_enable_sync(struct prestera_bridge *br_dev)
0898 {
0899     struct prestera_bridge_port *br_port;
0900     struct prestera_port *port;
0901     bool enabled;
0902     int err;
0903 
0904     /* if mrouter exists:
0905      *  - make sure every mrouter receives unreg mcast traffic;
0906      * if mrouter doesn't exists:
0907      *  - make sure every port receives unreg mcast traffic;
0908      */
0909     list_for_each_entry(br_port, &br_dev->port_list, head) {
0910         if (br_dev->multicast_enabled && br_dev->mrouter_exist)
0911             enabled = br_port->mrouter;
0912         else
0913             enabled = br_port->flags & BR_MCAST_FLOOD;
0914 
0915         if (netif_is_lag_master(br_port->dev)) {
0916             err = prestera_br_port_lag_mdb_mc_enable_sync(br_port,
0917                                       enabled);
0918             if (err)
0919                 return err;
0920             continue;
0921         }
0922 
0923         port = prestera_port_dev_lower_find(br_port->dev);
0924         if (!port)
0925             continue;
0926 
0927         err = prestera_port_mc_flood_set(port, enabled);
0928         if (err)
0929             return err;
0930     }
0931 
0932     return 0;
0933 }
0934 
0935 static bool
0936 prestera_br_mdb_port_is_member(struct prestera_br_mdb_entry *br_mdb,
0937                    struct net_device *orig_dev)
0938 {
0939     struct prestera_br_mdb_port *tmp_port;
0940 
0941     list_for_each_entry(tmp_port, &br_mdb->br_mdb_port_list,
0942                 br_mdb_port_node)
0943         if (tmp_port->br_port->dev == orig_dev)
0944             return true;
0945 
0946     return false;
0947 }
0948 
0949 static int
0950 prestera_mdb_port_add(struct prestera_mdb_entry *mdb,
0951               struct net_device *orig_dev,
0952               const unsigned char addr[ETH_ALEN], u16 vid)
0953 {
0954     struct prestera_flood_domain *flood_domain = mdb->flood_domain;
0955     int err;
0956 
0957     if (!prestera_flood_domain_port_find(flood_domain,
0958                          orig_dev, vid)) {
0959         err = prestera_flood_domain_port_create(flood_domain, orig_dev,
0960                             vid);
0961         if (err)
0962             return err;
0963     }
0964 
0965     return 0;
0966 }
0967 
0968 /* Sync bridge mdb (software table) with HW table (if MC is enabled). */
0969 static int prestera_br_mdb_sync(struct prestera_bridge *br_dev)
0970 {
0971     struct prestera_br_mdb_port *br_mdb_port;
0972     struct prestera_bridge_port *br_port;
0973     struct prestera_br_mdb_entry *br_mdb;
0974     struct prestera_mdb_entry *mdb;
0975     struct prestera_port *pr_port;
0976     int err = 0;
0977 
0978     if (!br_dev->multicast_enabled)
0979         return 0;
0980 
0981     list_for_each_entry(br_mdb, &br_dev->br_mdb_entry_list,
0982                 br_mdb_entry_node) {
0983         mdb = br_mdb->mdb;
0984         /* Make sure every port that explicitly been added to the mdb
0985          * joins the specified group.
0986          */
0987         list_for_each_entry(br_mdb_port, &br_mdb->br_mdb_port_list,
0988                     br_mdb_port_node) {
0989             br_port = br_mdb_port->br_port;
0990             pr_port = prestera_port_dev_lower_find(br_port->dev);
0991 
0992             /* Match only mdb and br_mdb ports that belong to the
0993              * same broadcast domain.
0994              */
0995             if (br_dev->vlan_enabled &&
0996                 !prestera_port_vlan_by_vid(pr_port,
0997                                mdb->vid))
0998                 continue;
0999 
1000             /* If port is not in MDB or there's no Mrouter
1001              * clear HW mdb.
1002              */
1003             if (prestera_br_mdb_port_is_member(br_mdb,
1004                                br_mdb_port->br_port->dev) &&
1005                                br_dev->mrouter_exist)
1006                 err = prestera_mdb_port_add(mdb, br_port->dev,
1007                                 mdb->addr,
1008                                 mdb->vid);
1009             else
1010                 prestera_mdb_port_del(mdb, br_port->dev);
1011 
1012             if (err)
1013                 return err;
1014         }
1015 
1016         /* Make sure that every mrouter port joins every MC group int
1017          * broadcast domain. If it's not an mrouter - it should leave
1018          */
1019         list_for_each_entry(br_port, &br_dev->port_list, head) {
1020             pr_port = prestera_port_dev_lower_find(br_port->dev);
1021 
1022             /* Make sure mrouter woudln't receive traffci from
1023              * another broadcast domain (e.g. from a vlan, which
1024              * mrouter port is not a member of).
1025              */
1026             if (br_dev->vlan_enabled &&
1027                 !prestera_port_vlan_by_vid(pr_port,
1028                                mdb->vid))
1029                 continue;
1030 
1031             if (br_port->mrouter) {
1032                 err = prestera_mdb_port_add(mdb, br_port->dev,
1033                                 mdb->addr,
1034                                 mdb->vid);
1035                 if (err)
1036                     return err;
1037             } else if (!br_port->mrouter &&
1038                    !prestera_br_mdb_port_is_member
1039                    (br_mdb, br_port->dev)) {
1040                 prestera_mdb_port_del(mdb, br_port->dev);
1041             }
1042         }
1043     }
1044 
1045     return 0;
1046 }
1047 
1048 static int
1049 prestera_mdb_enable_set(struct prestera_br_mdb_entry *br_mdb, bool enable)
1050 {
1051     int err;
1052 
1053     if (enable != br_mdb->enabled) {
1054         if (enable)
1055             err = prestera_hw_mdb_create(br_mdb->mdb);
1056         else
1057             err = prestera_hw_mdb_destroy(br_mdb->mdb);
1058 
1059         if (err)
1060             return err;
1061 
1062         br_mdb->enabled = enable;
1063     }
1064 
1065     return 0;
1066 }
1067 
1068 static int
1069 prestera_br_mdb_enable_set(struct prestera_bridge *br_dev, bool enable)
1070 {
1071     struct prestera_br_mdb_entry *br_mdb;
1072     int err;
1073 
1074     list_for_each_entry(br_mdb, &br_dev->br_mdb_entry_list,
1075                 br_mdb_entry_node) {
1076         err = prestera_mdb_enable_set(br_mdb, enable);
1077         if (err)
1078             return err;
1079     }
1080 
1081     return 0;
1082 }
1083 
1084 static int prestera_port_attr_br_mc_disabled_set(struct prestera_port *port,
1085                          struct net_device *orig_dev,
1086                          bool mc_disabled)
1087 {
1088     struct prestera_switch *sw = port->sw;
1089     struct prestera_bridge *br_dev;
1090 
1091     br_dev = prestera_bridge_find(sw, orig_dev);
1092     if (!br_dev)
1093         return 0;
1094 
1095     br_dev->multicast_enabled = !mc_disabled;
1096 
1097     /* There's no point in enabling mdb back if router is missing. */
1098     WARN_ON(prestera_br_mdb_enable_set(br_dev, br_dev->multicast_enabled &&
1099                        br_dev->mrouter_exist));
1100 
1101     WARN_ON(prestera_br_mdb_sync(br_dev));
1102 
1103     WARN_ON(prestera_br_mdb_mc_enable_sync(br_dev));
1104 
1105     return 0;
1106 }
1107 
1108 static bool
1109 prestera_bridge_mdb_mc_mrouter_exists(struct prestera_bridge *br_dev)
1110 {
1111     struct prestera_bridge_port *br_port;
1112 
1113     list_for_each_entry(br_port, &br_dev->port_list, head)
1114         if (br_port->mrouter)
1115             return true;
1116 
1117     return false;
1118 }
1119 
1120 static int
1121 prestera_port_attr_mrouter_set(struct prestera_port *port,
1122                    struct net_device *orig_dev,
1123                    bool is_port_mrouter)
1124 {
1125     struct prestera_bridge_port *br_port;
1126     struct prestera_bridge *br_dev;
1127 
1128     br_port = prestera_bridge_port_find(port->sw, orig_dev);
1129     if (!br_port)
1130         return 0;
1131 
1132     br_dev = br_port->bridge;
1133     br_port->mrouter = is_port_mrouter;
1134 
1135     br_dev->mrouter_exist = prestera_bridge_mdb_mc_mrouter_exists(br_dev);
1136 
1137     /* Enable MDB processing if both mrouter exists and mc is enabled.
1138      * In case if MC enabled, but there is no mrouter, device would flood
1139      * all multicast traffic (even if MDB table is not empty) with the use
1140      * of bridge's flood capabilities (without the use of flood_domain).
1141      */
1142     WARN_ON(prestera_br_mdb_enable_set(br_dev, br_dev->multicast_enabled &&
1143                        br_dev->mrouter_exist));
1144 
1145     WARN_ON(prestera_br_mdb_sync(br_dev));
1146 
1147     WARN_ON(prestera_br_mdb_mc_enable_sync(br_dev));
1148 
1149     return 0;
1150 }
1151 
1152 static int prestera_port_obj_attr_set(struct net_device *dev, const void *ctx,
1153                       const struct switchdev_attr *attr,
1154                       struct netlink_ext_ack *extack)
1155 {
1156     struct prestera_port *port = netdev_priv(dev);
1157     int err = 0;
1158 
1159     switch (attr->id) {
1160     case SWITCHDEV_ATTR_ID_PORT_STP_STATE:
1161         err = prestera_port_attr_stp_state_set(port, attr->orig_dev,
1162                                attr->u.stp_state);
1163         break;
1164     case SWITCHDEV_ATTR_ID_PORT_PRE_BRIDGE_FLAGS:
1165         if (attr->u.brport_flags.mask &
1166             ~(BR_LEARNING | BR_FLOOD | BR_MCAST_FLOOD))
1167             err = -EINVAL;
1168         break;
1169     case SWITCHDEV_ATTR_ID_PORT_BRIDGE_FLAGS:
1170         err = prestera_port_attr_br_flags_set(port, attr->orig_dev,
1171                               attr->u.brport_flags);
1172         break;
1173     case SWITCHDEV_ATTR_ID_BRIDGE_AGEING_TIME:
1174         err = prestera_port_attr_br_ageing_set(port,
1175                                attr->u.ageing_time);
1176         break;
1177     case SWITCHDEV_ATTR_ID_BRIDGE_VLAN_FILTERING:
1178         err = prestera_port_attr_br_vlan_set(port, attr->orig_dev,
1179                              attr->u.vlan_filtering);
1180         break;
1181     case SWITCHDEV_ATTR_ID_PORT_MROUTER:
1182         err = prestera_port_attr_mrouter_set(port, attr->orig_dev,
1183                              attr->u.mrouter);
1184         break;
1185     case SWITCHDEV_ATTR_ID_BRIDGE_MC_DISABLED:
1186         err = prestera_port_attr_br_mc_disabled_set(port, attr->orig_dev,
1187                                 attr->u.mc_disabled);
1188         break;
1189     default:
1190         err = -EOPNOTSUPP;
1191     }
1192 
1193     return err;
1194 }
1195 
1196 static void
1197 prestera_fdb_offload_notify(struct prestera_port *port,
1198                 struct switchdev_notifier_fdb_info *info)
1199 {
1200     struct switchdev_notifier_fdb_info send_info = {};
1201 
1202     send_info.addr = info->addr;
1203     send_info.vid = info->vid;
1204     send_info.offloaded = true;
1205 
1206     call_switchdev_notifiers(SWITCHDEV_FDB_OFFLOADED, port->dev,
1207                  &send_info.info, NULL);
1208 }
1209 
1210 static int prestera_port_fdb_set(struct prestera_port *port,
1211                  struct switchdev_notifier_fdb_info *fdb_info,
1212                  bool adding)
1213 {
1214     struct prestera_switch *sw = port->sw;
1215     struct prestera_bridge_port *br_port;
1216     struct prestera_bridge *bridge;
1217     int err;
1218     u16 vid;
1219 
1220     br_port = prestera_bridge_port_by_dev(sw->swdev, port->dev);
1221     if (!br_port)
1222         return -EINVAL;
1223 
1224     bridge = br_port->bridge;
1225 
1226     if (bridge->vlan_enabled)
1227         vid = fdb_info->vid;
1228     else
1229         vid = bridge->bridge_id;
1230 
1231     if (adding)
1232         err = prestera_fdb_add(port, fdb_info->addr, vid, false);
1233     else
1234         err = prestera_fdb_del(port, fdb_info->addr, vid);
1235 
1236     return err;
1237 }
1238 
1239 static void prestera_fdb_event_work(struct work_struct *work)
1240 {
1241     struct switchdev_notifier_fdb_info *fdb_info;
1242     struct prestera_fdb_event_work *swdev_work;
1243     struct prestera_port *port;
1244     struct net_device *dev;
1245     int err;
1246 
1247     swdev_work = container_of(work, struct prestera_fdb_event_work, work);
1248     dev = swdev_work->dev;
1249 
1250     rtnl_lock();
1251 
1252     port = prestera_port_dev_lower_find(dev);
1253     if (!port)
1254         goto out_unlock;
1255 
1256     switch (swdev_work->event) {
1257     case SWITCHDEV_FDB_ADD_TO_DEVICE:
1258         fdb_info = &swdev_work->fdb_info;
1259         if (!fdb_info->added_by_user || fdb_info->is_local)
1260             break;
1261 
1262         err = prestera_port_fdb_set(port, fdb_info, true);
1263         if (err)
1264             break;
1265 
1266         prestera_fdb_offload_notify(port, fdb_info);
1267         break;
1268 
1269     case SWITCHDEV_FDB_DEL_TO_DEVICE:
1270         fdb_info = &swdev_work->fdb_info;
1271         prestera_port_fdb_set(port, fdb_info, false);
1272         break;
1273     }
1274 
1275 out_unlock:
1276     rtnl_unlock();
1277 
1278     kfree(swdev_work->fdb_info.addr);
1279     kfree(swdev_work);
1280     dev_put(dev);
1281 }
1282 
1283 static int prestera_switchdev_event(struct notifier_block *unused,
1284                     unsigned long event, void *ptr)
1285 {
1286     struct net_device *dev = switchdev_notifier_info_to_dev(ptr);
1287     struct switchdev_notifier_fdb_info *fdb_info;
1288     struct switchdev_notifier_info *info = ptr;
1289     struct prestera_fdb_event_work *swdev_work;
1290     struct net_device *upper;
1291     int err;
1292 
1293     if (event == SWITCHDEV_PORT_ATTR_SET) {
1294         err = switchdev_handle_port_attr_set(dev, ptr,
1295                              prestera_netdev_check,
1296                              prestera_port_obj_attr_set);
1297         return notifier_from_errno(err);
1298     }
1299 
1300     if (!prestera_netdev_check(dev))
1301         return NOTIFY_DONE;
1302 
1303     upper = netdev_master_upper_dev_get_rcu(dev);
1304     if (!upper)
1305         return NOTIFY_DONE;
1306 
1307     if (!netif_is_bridge_master(upper))
1308         return NOTIFY_DONE;
1309 
1310     swdev_work = kzalloc(sizeof(*swdev_work), GFP_ATOMIC);
1311     if (!swdev_work)
1312         return NOTIFY_BAD;
1313 
1314     swdev_work->event = event;
1315     swdev_work->dev = dev;
1316 
1317     switch (event) {
1318     case SWITCHDEV_FDB_ADD_TO_DEVICE:
1319     case SWITCHDEV_FDB_DEL_TO_DEVICE:
1320         fdb_info = container_of(info,
1321                     struct switchdev_notifier_fdb_info,
1322                     info);
1323 
1324         INIT_WORK(&swdev_work->work, prestera_fdb_event_work);
1325         memcpy(&swdev_work->fdb_info, ptr,
1326                sizeof(swdev_work->fdb_info));
1327 
1328         swdev_work->fdb_info.addr = kzalloc(ETH_ALEN, GFP_ATOMIC);
1329         if (!swdev_work->fdb_info.addr)
1330             goto out_bad;
1331 
1332         ether_addr_copy((u8 *)swdev_work->fdb_info.addr,
1333                 fdb_info->addr);
1334         dev_hold(dev);
1335         break;
1336 
1337     default:
1338         kfree(swdev_work);
1339         return NOTIFY_DONE;
1340     }
1341 
1342     queue_work(swdev_wq, &swdev_work->work);
1343     return NOTIFY_DONE;
1344 
1345 out_bad:
1346     kfree(swdev_work);
1347     return NOTIFY_BAD;
1348 }
1349 
1350 static int
1351 prestera_port_vlan_bridge_join(struct prestera_port_vlan *port_vlan,
1352                    struct prestera_bridge_port *br_port)
1353 {
1354     struct prestera_port *port = port_vlan->port;
1355     struct prestera_bridge_vlan *br_vlan;
1356     u16 vid = port_vlan->vid;
1357     int err;
1358 
1359     if (port_vlan->br_port)
1360         return 0;
1361 
1362     err = prestera_br_port_flags_set(br_port, port);
1363     if (err)
1364         goto err_flags2port_set;
1365 
1366     err = prestera_port_vid_stp_set(port, vid, br_port->stp_state);
1367     if (err)
1368         goto err_port_vid_stp_set;
1369 
1370     br_vlan = prestera_bridge_vlan_by_vid(br_port, vid);
1371     if (!br_vlan) {
1372         br_vlan = prestera_bridge_vlan_create(br_port, vid);
1373         if (!br_vlan) {
1374             err = -ENOMEM;
1375             goto err_bridge_vlan_get;
1376         }
1377     }
1378 
1379     list_add(&port_vlan->br_vlan_head, &br_vlan->port_vlan_list);
1380 
1381     prestera_bridge_port_get(br_port);
1382     port_vlan->br_port = br_port;
1383 
1384     return 0;
1385 
1386 err_bridge_vlan_get:
1387     prestera_port_vid_stp_set(port, vid, BR_STATE_FORWARDING);
1388 err_port_vid_stp_set:
1389     prestera_br_port_flags_reset(br_port, port);
1390 err_flags2port_set:
1391     return err;
1392 }
1393 
1394 static int
1395 prestera_bridge_port_vlan_add(struct prestera_port *port,
1396                   struct prestera_bridge_port *br_port,
1397                   u16 vid, bool is_untagged, bool is_pvid,
1398                   struct netlink_ext_ack *extack)
1399 {
1400     struct prestera_port_vlan *port_vlan;
1401     u16 old_pvid = port->pvid;
1402     u16 pvid;
1403     int err;
1404 
1405     if (is_pvid)
1406         pvid = vid;
1407     else
1408         pvid = port->pvid == vid ? 0 : port->pvid;
1409 
1410     port_vlan = prestera_port_vlan_by_vid(port, vid);
1411     if (port_vlan && port_vlan->br_port != br_port)
1412         return -EEXIST;
1413 
1414     if (!port_vlan) {
1415         port_vlan = prestera_port_vlan_create(port, vid, is_untagged);
1416         if (IS_ERR(port_vlan))
1417             return PTR_ERR(port_vlan);
1418     } else {
1419         err = prestera_hw_vlan_port_set(port, vid, true, is_untagged);
1420         if (err)
1421             goto err_port_vlan_set;
1422     }
1423 
1424     err = prestera_port_pvid_set(port, pvid);
1425     if (err)
1426         goto err_port_pvid_set;
1427 
1428     err = prestera_port_vlan_bridge_join(port_vlan, br_port);
1429     if (err)
1430         goto err_port_vlan_bridge_join;
1431 
1432     return 0;
1433 
1434 err_port_vlan_bridge_join:
1435     prestera_port_pvid_set(port, old_pvid);
1436 err_port_pvid_set:
1437     prestera_hw_vlan_port_set(port, vid, false, false);
1438 err_port_vlan_set:
1439     prestera_port_vlan_destroy(port_vlan);
1440 
1441     return err;
1442 }
1443 
1444 static void
1445 prestera_bridge_port_vlan_del(struct prestera_port *port,
1446                   struct prestera_bridge_port *br_port, u16 vid)
1447 {
1448     u16 pvid = port->pvid == vid ? 0 : port->pvid;
1449     struct prestera_port_vlan *port_vlan;
1450 
1451     port_vlan = prestera_port_vlan_by_vid(port, vid);
1452     if (WARN_ON(!port_vlan))
1453         return;
1454 
1455     prestera_port_vlan_bridge_leave(port_vlan);
1456     prestera_port_pvid_set(port, pvid);
1457     prestera_port_vlan_destroy(port_vlan);
1458 }
1459 
1460 static int prestera_port_vlans_add(struct prestera_port *port,
1461                    const struct switchdev_obj_port_vlan *vlan,
1462                    struct netlink_ext_ack *extack)
1463 {
1464     bool flag_untagged = vlan->flags & BRIDGE_VLAN_INFO_UNTAGGED;
1465     bool flag_pvid = vlan->flags & BRIDGE_VLAN_INFO_PVID;
1466     struct net_device *orig_dev = vlan->obj.orig_dev;
1467     struct prestera_bridge_port *br_port;
1468     struct prestera_switch *sw = port->sw;
1469     struct prestera_bridge *bridge;
1470 
1471     if (netif_is_bridge_master(orig_dev))
1472         return 0;
1473 
1474     br_port = prestera_bridge_port_by_dev(sw->swdev, port->dev);
1475     if (WARN_ON(!br_port))
1476         return -EINVAL;
1477 
1478     bridge = br_port->bridge;
1479     if (!bridge->vlan_enabled)
1480         return 0;
1481 
1482     return prestera_bridge_port_vlan_add(port, br_port,
1483                          vlan->vid, flag_untagged,
1484                          flag_pvid, extack);
1485 }
1486 
1487 static struct prestera_br_mdb_entry *
1488 prestera_br_mdb_entry_create(struct prestera_switch *sw,
1489                  struct prestera_bridge *br_dev,
1490                  const unsigned char *addr, u16 vid)
1491 {
1492     struct prestera_br_mdb_entry *br_mdb_entry;
1493     struct prestera_mdb_entry *mdb_entry;
1494 
1495     br_mdb_entry = kzalloc(sizeof(*br_mdb_entry), GFP_KERNEL);
1496     if (!br_mdb_entry)
1497         return NULL;
1498 
1499     mdb_entry = prestera_mdb_entry_create(sw, addr, vid);
1500     if (!mdb_entry)
1501         goto err_mdb_alloc;
1502 
1503     br_mdb_entry->mdb = mdb_entry;
1504     br_mdb_entry->bridge = br_dev;
1505     br_mdb_entry->enabled = true;
1506     INIT_LIST_HEAD(&br_mdb_entry->br_mdb_port_list);
1507 
1508     list_add(&br_mdb_entry->br_mdb_entry_node, &br_dev->br_mdb_entry_list);
1509 
1510     return br_mdb_entry;
1511 
1512 err_mdb_alloc:
1513     kfree(br_mdb_entry);
1514     return NULL;
1515 }
1516 
1517 static int prestera_br_mdb_port_add(struct prestera_br_mdb_entry *br_mdb,
1518                     struct prestera_bridge_port *br_port)
1519 {
1520     struct prestera_br_mdb_port *br_mdb_port;
1521 
1522     list_for_each_entry(br_mdb_port, &br_mdb->br_mdb_port_list,
1523                 br_mdb_port_node)
1524         if (br_mdb_port->br_port == br_port)
1525             return 0;
1526 
1527     br_mdb_port = kzalloc(sizeof(*br_mdb_port), GFP_KERNEL);
1528     if (!br_mdb_port)
1529         return -ENOMEM;
1530 
1531     br_mdb_port->br_port = br_port;
1532     list_add(&br_mdb_port->br_mdb_port_node,
1533          &br_mdb->br_mdb_port_list);
1534 
1535     return 0;
1536 }
1537 
1538 static struct prestera_br_mdb_entry *
1539 prestera_br_mdb_entry_find(struct prestera_bridge *br_dev,
1540                const unsigned char *addr, u16 vid)
1541 {
1542     struct prestera_br_mdb_entry *br_mdb;
1543 
1544     list_for_each_entry(br_mdb, &br_dev->br_mdb_entry_list,
1545                 br_mdb_entry_node)
1546         if (ether_addr_equal(&br_mdb->mdb->addr[0], addr) &&
1547             vid == br_mdb->mdb->vid)
1548             return br_mdb;
1549 
1550     return NULL;
1551 }
1552 
1553 static struct prestera_br_mdb_entry *
1554 prestera_br_mdb_entry_get(struct prestera_switch *sw,
1555               struct prestera_bridge *br_dev,
1556               const unsigned char *addr, u16 vid)
1557 {
1558     struct prestera_br_mdb_entry *br_mdb;
1559 
1560     br_mdb = prestera_br_mdb_entry_find(br_dev, addr, vid);
1561     if (br_mdb)
1562         return br_mdb;
1563 
1564     return prestera_br_mdb_entry_create(sw, br_dev, addr, vid);
1565 }
1566 
1567 static int
1568 prestera_mdb_port_addr_obj_add(const struct switchdev_obj_port_mdb *mdb)
1569 {
1570     struct prestera_br_mdb_entry *br_mdb;
1571     struct prestera_bridge_port *br_port;
1572     struct prestera_bridge *br_dev;
1573     struct prestera_switch *sw;
1574     struct prestera_port *port;
1575     int err;
1576 
1577     sw = prestera_switch_get(mdb->obj.orig_dev);
1578     port = prestera_port_dev_lower_find(mdb->obj.orig_dev);
1579 
1580     br_port = prestera_bridge_port_find(sw, mdb->obj.orig_dev);
1581     if (!br_port)
1582         return 0;
1583 
1584     br_dev = br_port->bridge;
1585 
1586     if (mdb->vid && !prestera_port_vlan_by_vid(port, mdb->vid))
1587         return 0;
1588 
1589     if (mdb->vid)
1590         br_mdb = prestera_br_mdb_entry_get(sw, br_dev, &mdb->addr[0],
1591                            mdb->vid);
1592     else
1593         br_mdb = prestera_br_mdb_entry_get(sw, br_dev, &mdb->addr[0],
1594                            br_dev->bridge_id);
1595 
1596     if (!br_mdb)
1597         return -ENOMEM;
1598 
1599     /* Make sure newly allocated MDB entry gets disabled if either MC is
1600      * disabled, or the mrouter does not exist.
1601      */
1602     WARN_ON(prestera_mdb_enable_set(br_mdb, br_dev->multicast_enabled &&
1603                     br_dev->mrouter_exist));
1604 
1605     err = prestera_br_mdb_port_add(br_mdb, br_port);
1606     if (err) {
1607         prestera_br_mdb_entry_put(br_mdb);
1608         return err;
1609     }
1610 
1611     err = prestera_br_mdb_sync(br_dev);
1612     if (err)
1613         return err;
1614 
1615     return 0;
1616 }
1617 
1618 static int prestera_port_obj_add(struct net_device *dev, const void *ctx,
1619                  const struct switchdev_obj *obj,
1620                  struct netlink_ext_ack *extack)
1621 {
1622     struct prestera_port *port = netdev_priv(dev);
1623     const struct switchdev_obj_port_vlan *vlan;
1624     const struct switchdev_obj_port_mdb *mdb;
1625     int err = 0;
1626 
1627     switch (obj->id) {
1628     case SWITCHDEV_OBJ_ID_PORT_VLAN:
1629         vlan = SWITCHDEV_OBJ_PORT_VLAN(obj);
1630         return prestera_port_vlans_add(port, vlan, extack);
1631     case SWITCHDEV_OBJ_ID_PORT_MDB:
1632         mdb = SWITCHDEV_OBJ_PORT_MDB(obj);
1633         err = prestera_mdb_port_addr_obj_add(mdb);
1634         break;
1635     case SWITCHDEV_OBJ_ID_HOST_MDB:
1636         fallthrough;
1637     default:
1638         err = -EOPNOTSUPP;
1639         break;
1640     }
1641 
1642     return err;
1643 }
1644 
1645 static int prestera_port_vlans_del(struct prestera_port *port,
1646                    const struct switchdev_obj_port_vlan *vlan)
1647 {
1648     struct net_device *orig_dev = vlan->obj.orig_dev;
1649     struct prestera_bridge_port *br_port;
1650     struct prestera_switch *sw = port->sw;
1651 
1652     if (netif_is_bridge_master(orig_dev))
1653         return -EOPNOTSUPP;
1654 
1655     br_port = prestera_bridge_port_by_dev(sw->swdev, port->dev);
1656     if (WARN_ON(!br_port))
1657         return -EINVAL;
1658 
1659     if (!br_port->bridge->vlan_enabled)
1660         return 0;
1661 
1662     prestera_bridge_port_vlan_del(port, br_port, vlan->vid);
1663 
1664     return 0;
1665 }
1666 
1667 static int
1668 prestera_mdb_port_addr_obj_del(struct prestera_port *port,
1669                    const struct switchdev_obj_port_mdb *mdb)
1670 {
1671     struct prestera_br_mdb_entry *br_mdb;
1672     struct prestera_bridge_port *br_port;
1673     struct prestera_bridge *br_dev;
1674     int err;
1675 
1676     /* Bridge port no longer exists - and so does this MDB entry */
1677     br_port = prestera_bridge_port_find(port->sw, mdb->obj.orig_dev);
1678     if (!br_port)
1679         return 0;
1680 
1681     /* Removing MDB with non-existing VLAN - not supported; */
1682     if (mdb->vid && !prestera_port_vlan_by_vid(port, mdb->vid))
1683         return 0;
1684 
1685     br_dev = br_port->bridge;
1686 
1687     if (br_port->bridge->vlan_enabled)
1688         br_mdb = prestera_br_mdb_entry_find(br_dev, &mdb->addr[0],
1689                             mdb->vid);
1690     else
1691         br_mdb = prestera_br_mdb_entry_find(br_dev, &mdb->addr[0],
1692                             br_port->bridge->bridge_id);
1693 
1694     if (!br_mdb)
1695         return 0;
1696 
1697     /* Since there might be a situation that this port was the last in the
1698      * MDB group, we have to both remove this port from software and HW MDB,
1699      * sync MDB table, and then destroy software MDB (if needed).
1700      */
1701     prestera_br_mdb_port_del(br_mdb, br_port);
1702 
1703     prestera_br_mdb_entry_put(br_mdb);
1704 
1705     err = prestera_br_mdb_sync(br_dev);
1706     if (err)
1707         return err;
1708 
1709     return 0;
1710 }
1711 
1712 static int prestera_port_obj_del(struct net_device *dev, const void *ctx,
1713                  const struct switchdev_obj *obj)
1714 {
1715     struct prestera_port *port = netdev_priv(dev);
1716     const struct switchdev_obj_port_mdb *mdb;
1717     int err = 0;
1718 
1719     switch (obj->id) {
1720     case SWITCHDEV_OBJ_ID_PORT_VLAN:
1721         return prestera_port_vlans_del(port, SWITCHDEV_OBJ_PORT_VLAN(obj));
1722     case SWITCHDEV_OBJ_ID_PORT_MDB:
1723         mdb = SWITCHDEV_OBJ_PORT_MDB(obj);
1724         err = prestera_mdb_port_addr_obj_del(port, mdb);
1725         break;
1726     default:
1727         err = -EOPNOTSUPP;
1728         break;
1729     }
1730 
1731     return err;
1732 }
1733 
1734 static int prestera_switchdev_blk_event(struct notifier_block *unused,
1735                     unsigned long event, void *ptr)
1736 {
1737     struct net_device *dev = switchdev_notifier_info_to_dev(ptr);
1738     int err;
1739 
1740     switch (event) {
1741     case SWITCHDEV_PORT_OBJ_ADD:
1742         err = switchdev_handle_port_obj_add(dev, ptr,
1743                             prestera_netdev_check,
1744                             prestera_port_obj_add);
1745         break;
1746     case SWITCHDEV_PORT_OBJ_DEL:
1747         err = switchdev_handle_port_obj_del(dev, ptr,
1748                             prestera_netdev_check,
1749                             prestera_port_obj_del);
1750         break;
1751     case SWITCHDEV_PORT_ATTR_SET:
1752         err = switchdev_handle_port_attr_set(dev, ptr,
1753                              prestera_netdev_check,
1754                              prestera_port_obj_attr_set);
1755         break;
1756     default:
1757         return NOTIFY_DONE;
1758     }
1759 
1760     return notifier_from_errno(err);
1761 }
1762 
1763 static void prestera_fdb_event(struct prestera_switch *sw,
1764                    struct prestera_event *evt, void *arg)
1765 {
1766     struct switchdev_notifier_fdb_info info = {};
1767     struct net_device *dev = NULL;
1768     struct prestera_port *port;
1769     struct prestera_lag *lag;
1770 
1771     switch (evt->fdb_evt.type) {
1772     case PRESTERA_FDB_ENTRY_TYPE_REG_PORT:
1773         port = prestera_find_port(sw, evt->fdb_evt.dest.port_id);
1774         if (port)
1775             dev = port->dev;
1776         break;
1777     case PRESTERA_FDB_ENTRY_TYPE_LAG:
1778         lag = prestera_lag_by_id(sw, evt->fdb_evt.dest.lag_id);
1779         if (lag)
1780             dev = lag->dev;
1781         break;
1782     default:
1783         return;
1784     }
1785 
1786     if (!dev)
1787         return;
1788 
1789     info.addr = evt->fdb_evt.data.mac;
1790     info.vid = evt->fdb_evt.vid;
1791     info.offloaded = true;
1792 
1793     rtnl_lock();
1794 
1795     switch (evt->id) {
1796     case PRESTERA_FDB_EVENT_LEARNED:
1797         call_switchdev_notifiers(SWITCHDEV_FDB_ADD_TO_BRIDGE,
1798                      dev, &info.info, NULL);
1799         break;
1800     case PRESTERA_FDB_EVENT_AGED:
1801         call_switchdev_notifiers(SWITCHDEV_FDB_DEL_TO_BRIDGE,
1802                      dev, &info.info, NULL);
1803         break;
1804     }
1805 
1806     rtnl_unlock();
1807 }
1808 
1809 static int prestera_fdb_init(struct prestera_switch *sw)
1810 {
1811     int err;
1812 
1813     err = prestera_hw_event_handler_register(sw, PRESTERA_EVENT_TYPE_FDB,
1814                          prestera_fdb_event, NULL);
1815     if (err)
1816         return err;
1817 
1818     err = prestera_hw_switch_ageing_set(sw, PRESTERA_DEFAULT_AGEING_TIME_MS);
1819     if (err)
1820         goto err_ageing_set;
1821 
1822     return 0;
1823 
1824 err_ageing_set:
1825     prestera_hw_event_handler_unregister(sw, PRESTERA_EVENT_TYPE_FDB,
1826                          prestera_fdb_event);
1827     return err;
1828 }
1829 
1830 static void prestera_fdb_fini(struct prestera_switch *sw)
1831 {
1832     prestera_hw_event_handler_unregister(sw, PRESTERA_EVENT_TYPE_FDB,
1833                          prestera_fdb_event);
1834 }
1835 
1836 static int prestera_switchdev_handler_init(struct prestera_switchdev *swdev)
1837 {
1838     int err;
1839 
1840     swdev->swdev_nb.notifier_call = prestera_switchdev_event;
1841     err = register_switchdev_notifier(&swdev->swdev_nb);
1842     if (err)
1843         goto err_register_swdev_notifier;
1844 
1845     swdev->swdev_nb_blk.notifier_call = prestera_switchdev_blk_event;
1846     err = register_switchdev_blocking_notifier(&swdev->swdev_nb_blk);
1847     if (err)
1848         goto err_register_blk_swdev_notifier;
1849 
1850     return 0;
1851 
1852 err_register_blk_swdev_notifier:
1853     unregister_switchdev_notifier(&swdev->swdev_nb);
1854 err_register_swdev_notifier:
1855     destroy_workqueue(swdev_wq);
1856     return err;
1857 }
1858 
1859 static void prestera_switchdev_handler_fini(struct prestera_switchdev *swdev)
1860 {
1861     unregister_switchdev_blocking_notifier(&swdev->swdev_nb_blk);
1862     unregister_switchdev_notifier(&swdev->swdev_nb);
1863 }
1864 
1865 int prestera_switchdev_init(struct prestera_switch *sw)
1866 {
1867     struct prestera_switchdev *swdev;
1868     int err;
1869 
1870     swdev = kzalloc(sizeof(*swdev), GFP_KERNEL);
1871     if (!swdev)
1872         return -ENOMEM;
1873 
1874     sw->swdev = swdev;
1875     swdev->sw = sw;
1876 
1877     INIT_LIST_HEAD(&swdev->bridge_list);
1878 
1879     swdev_wq = alloc_ordered_workqueue("%s_ordered", 0, "prestera_br");
1880     if (!swdev_wq) {
1881         err = -ENOMEM;
1882         goto err_alloc_wq;
1883     }
1884 
1885     err = prestera_switchdev_handler_init(swdev);
1886     if (err)
1887         goto err_swdev_init;
1888 
1889     err = prestera_fdb_init(sw);
1890     if (err)
1891         goto err_fdb_init;
1892 
1893     return 0;
1894 
1895 err_fdb_init:
1896 err_swdev_init:
1897     destroy_workqueue(swdev_wq);
1898 err_alloc_wq:
1899     kfree(swdev);
1900 
1901     return err;
1902 }
1903 
1904 void prestera_switchdev_fini(struct prestera_switch *sw)
1905 {
1906     struct prestera_switchdev *swdev = sw->swdev;
1907 
1908     prestera_fdb_fini(sw);
1909     prestera_switchdev_handler_fini(swdev);
1910     destroy_workqueue(swdev_wq);
1911     kfree(swdev);
1912 }
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!