| // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0 |
| /* Copyright (c) 2015-2018 Mellanox Technologies. All rights reserved */ |
| |
| #include <linux/kernel.h> |
| #include <linux/types.h> |
| #include <linux/netdevice.h> |
| #include <linux/etherdevice.h> |
| #include <linux/slab.h> |
| #include <linux/device.h> |
| #include <linux/skbuff.h> |
| #include <linux/if_vlan.h> |
| #include <linux/if_bridge.h> |
| #include <linux/workqueue.h> |
| #include <linux/jiffies.h> |
| #include <linux/rtnetlink.h> |
| #include <linux/netlink.h> |
| #include <net/switchdev.h> |
| #include <net/vxlan.h> |
| |
| #include "spectrum_span.h" |
| #include "spectrum_switchdev.h" |
| #include "spectrum.h" |
| #include "core.h" |
| #include "reg.h" |
| |
| struct mlxsw_sp_bridge_ops; |
| |
| struct mlxsw_sp_bridge { |
| struct mlxsw_sp *mlxsw_sp; |
| struct { |
| struct delayed_work dw; |
| #define MLXSW_SP_DEFAULT_LEARNING_INTERVAL 100 |
| unsigned int interval; /* ms */ |
| } fdb_notify; |
| #define MLXSW_SP_MIN_AGEING_TIME 10 |
| #define MLXSW_SP_MAX_AGEING_TIME 1000000 |
| #define MLXSW_SP_DEFAULT_AGEING_TIME 300 |
| u32 ageing_time; |
| bool vlan_enabled_exists; |
| struct list_head bridges_list; |
| DECLARE_BITMAP(mids_bitmap, MLXSW_SP_MID_MAX); |
| const struct mlxsw_sp_bridge_ops *bridge_8021q_ops; |
| const struct mlxsw_sp_bridge_ops *bridge_8021d_ops; |
| }; |
| |
| struct mlxsw_sp_bridge_device { |
| struct net_device *dev; |
| struct list_head list; |
| struct list_head ports_list; |
| struct list_head mids_list; |
| u8 vlan_enabled:1, |
| multicast_enabled:1, |
| mrouter:1; |
| const struct mlxsw_sp_bridge_ops *ops; |
| }; |
| |
| struct mlxsw_sp_bridge_port { |
| struct net_device *dev; |
| struct mlxsw_sp_bridge_device *bridge_device; |
| struct list_head list; |
| struct list_head vlans_list; |
| unsigned int ref_count; |
| u8 stp_state; |
| unsigned long flags; |
| bool mrouter; |
| bool lagged; |
| union { |
| u16 lag_id; |
| u16 system_port; |
| }; |
| }; |
| |
| struct mlxsw_sp_bridge_vlan { |
| struct list_head list; |
| struct list_head port_vlan_list; |
| u16 vid; |
| }; |
| |
| struct mlxsw_sp_bridge_ops { |
| int (*port_join)(struct mlxsw_sp_bridge_device *bridge_device, |
| struct mlxsw_sp_bridge_port *bridge_port, |
| struct mlxsw_sp_port *mlxsw_sp_port, |
| struct netlink_ext_ack *extack); |
| void (*port_leave)(struct mlxsw_sp_bridge_device *bridge_device, |
| struct mlxsw_sp_bridge_port *bridge_port, |
| struct mlxsw_sp_port *mlxsw_sp_port); |
| int (*vxlan_join)(struct mlxsw_sp_bridge_device *bridge_device, |
| const struct net_device *vxlan_dev, u16 vid, |
| struct netlink_ext_ack *extack); |
| struct mlxsw_sp_fid * |
| (*fid_get)(struct mlxsw_sp_bridge_device *bridge_device, |
| u16 vid, struct netlink_ext_ack *extack); |
| struct mlxsw_sp_fid * |
| (*fid_lookup)(struct mlxsw_sp_bridge_device *bridge_device, |
| u16 vid); |
| u16 (*fid_vid)(struct mlxsw_sp_bridge_device *bridge_device, |
| const struct mlxsw_sp_fid *fid); |
| }; |
| |
| static int |
| mlxsw_sp_bridge_port_fdb_flush(struct mlxsw_sp *mlxsw_sp, |
| struct mlxsw_sp_bridge_port *bridge_port, |
| u16 fid_index); |
| |
| static void |
| mlxsw_sp_bridge_port_mdb_flush(struct mlxsw_sp_port *mlxsw_sp_port, |
| struct mlxsw_sp_bridge_port *bridge_port); |
| |
| static void |
| mlxsw_sp_bridge_mdb_mc_enable_sync(struct mlxsw_sp_port *mlxsw_sp_port, |
| struct mlxsw_sp_bridge_device |
| *bridge_device); |
| |
| static void |
| mlxsw_sp_port_mrouter_update_mdb(struct mlxsw_sp_port *mlxsw_sp_port, |
| struct mlxsw_sp_bridge_port *bridge_port, |
| bool add); |
| |
| static struct mlxsw_sp_bridge_device * |
| mlxsw_sp_bridge_device_find(const struct mlxsw_sp_bridge *bridge, |
| const struct net_device *br_dev) |
| { |
| struct mlxsw_sp_bridge_device *bridge_device; |
| |
| list_for_each_entry(bridge_device, &bridge->bridges_list, list) |
| if (bridge_device->dev == br_dev) |
| return bridge_device; |
| |
| return NULL; |
| } |
| |
| bool mlxsw_sp_bridge_device_is_offloaded(const struct mlxsw_sp *mlxsw_sp, |
| const struct net_device *br_dev) |
| { |
| return !!mlxsw_sp_bridge_device_find(mlxsw_sp->bridge, br_dev); |
| } |
| |
| static int mlxsw_sp_bridge_device_upper_rif_destroy(struct net_device *dev, |
| void *data) |
| { |
| struct mlxsw_sp *mlxsw_sp = data; |
| |
| mlxsw_sp_rif_destroy_by_dev(mlxsw_sp, dev); |
| return 0; |
| } |
| |
| static void mlxsw_sp_bridge_device_rifs_destroy(struct mlxsw_sp *mlxsw_sp, |
| struct net_device *dev) |
| { |
| mlxsw_sp_rif_destroy_by_dev(mlxsw_sp, dev); |
| netdev_walk_all_upper_dev_rcu(dev, |
| mlxsw_sp_bridge_device_upper_rif_destroy, |
| mlxsw_sp); |
| } |
| |
| static struct mlxsw_sp_bridge_device * |
| mlxsw_sp_bridge_device_create(struct mlxsw_sp_bridge *bridge, |
| struct net_device *br_dev) |
| { |
| struct device *dev = bridge->mlxsw_sp->bus_info->dev; |
| struct mlxsw_sp_bridge_device *bridge_device; |
| bool vlan_enabled = br_vlan_enabled(br_dev); |
| |
| if (vlan_enabled && bridge->vlan_enabled_exists) { |
| dev_err(dev, "Only one VLAN-aware bridge is supported\n"); |
| return ERR_PTR(-EINVAL); |
| } |
| |
| bridge_device = kzalloc(sizeof(*bridge_device), GFP_KERNEL); |
| if (!bridge_device) |
| return ERR_PTR(-ENOMEM); |
| |
| bridge_device->dev = br_dev; |
| bridge_device->vlan_enabled = vlan_enabled; |
| bridge_device->multicast_enabled = br_multicast_enabled(br_dev); |
| bridge_device->mrouter = br_multicast_router(br_dev); |
| INIT_LIST_HEAD(&bridge_device->ports_list); |
| if (vlan_enabled) { |
| bridge->vlan_enabled_exists = true; |
| bridge_device->ops = bridge->bridge_8021q_ops; |
| } else { |
| bridge_device->ops = bridge->bridge_8021d_ops; |
| } |
| INIT_LIST_HEAD(&bridge_device->mids_list); |
| list_add(&bridge_device->list, &bridge->bridges_list); |
| |
| return bridge_device; |
| } |
| |
| static void |
| mlxsw_sp_bridge_device_destroy(struct mlxsw_sp_bridge *bridge, |
| struct mlxsw_sp_bridge_device *bridge_device) |
| { |
| mlxsw_sp_bridge_device_rifs_destroy(bridge->mlxsw_sp, |
| bridge_device->dev); |
| list_del(&bridge_device->list); |
| if (bridge_device->vlan_enabled) |
| bridge->vlan_enabled_exists = false; |
| WARN_ON(!list_empty(&bridge_device->ports_list)); |
| WARN_ON(!list_empty(&bridge_device->mids_list)); |
| kfree(bridge_device); |
| } |
| |
| static struct mlxsw_sp_bridge_device * |
| mlxsw_sp_bridge_device_get(struct mlxsw_sp_bridge *bridge, |
| struct net_device *br_dev) |
| { |
| struct mlxsw_sp_bridge_device *bridge_device; |
| |
| bridge_device = mlxsw_sp_bridge_device_find(bridge, br_dev); |
| if (bridge_device) |
| return bridge_device; |
| |
| return mlxsw_sp_bridge_device_create(bridge, br_dev); |
| } |
| |
| static void |
| mlxsw_sp_bridge_device_put(struct mlxsw_sp_bridge *bridge, |
| struct mlxsw_sp_bridge_device *bridge_device) |
| { |
| if (list_empty(&bridge_device->ports_list)) |
| mlxsw_sp_bridge_device_destroy(bridge, bridge_device); |
| } |
| |
| static struct mlxsw_sp_bridge_port * |
| __mlxsw_sp_bridge_port_find(const struct mlxsw_sp_bridge_device *bridge_device, |
| const struct net_device *brport_dev) |
| { |
| struct mlxsw_sp_bridge_port *bridge_port; |
| |
| list_for_each_entry(bridge_port, &bridge_device->ports_list, list) { |
| if (bridge_port->dev == brport_dev) |
| return bridge_port; |
| } |
| |
| return NULL; |
| } |
| |
| struct mlxsw_sp_bridge_port * |
| mlxsw_sp_bridge_port_find(struct mlxsw_sp_bridge *bridge, |
| struct net_device *brport_dev) |
| { |
| struct net_device *br_dev = netdev_master_upper_dev_get(brport_dev); |
| struct mlxsw_sp_bridge_device *bridge_device; |
| |
| if (!br_dev) |
| return NULL; |
| |
| bridge_device = mlxsw_sp_bridge_device_find(bridge, br_dev); |
| if (!bridge_device) |
| return NULL; |
| |
| return __mlxsw_sp_bridge_port_find(bridge_device, brport_dev); |
| } |
| |
| static struct mlxsw_sp_bridge_port * |
| mlxsw_sp_bridge_port_create(struct mlxsw_sp_bridge_device *bridge_device, |
| struct net_device *brport_dev) |
| { |
| struct mlxsw_sp_bridge_port *bridge_port; |
| struct mlxsw_sp_port *mlxsw_sp_port; |
| |
| bridge_port = kzalloc(sizeof(*bridge_port), GFP_KERNEL); |
| if (!bridge_port) |
| return NULL; |
| |
| mlxsw_sp_port = mlxsw_sp_port_dev_lower_find(brport_dev); |
| bridge_port->lagged = mlxsw_sp_port->lagged; |
| if (bridge_port->lagged) |
| bridge_port->lag_id = mlxsw_sp_port->lag_id; |
| else |
| bridge_port->system_port = mlxsw_sp_port->local_port; |
| bridge_port->dev = brport_dev; |
| bridge_port->bridge_device = bridge_device; |
| bridge_port->stp_state = BR_STATE_DISABLED; |
| bridge_port->flags = BR_LEARNING | BR_FLOOD | BR_LEARNING_SYNC | |
| BR_MCAST_FLOOD; |
| INIT_LIST_HEAD(&bridge_port->vlans_list); |
| list_add(&bridge_port->list, &bridge_device->ports_list); |
| bridge_port->ref_count = 1; |
| |
| return bridge_port; |
| } |
| |
| static void |
| mlxsw_sp_bridge_port_destroy(struct mlxsw_sp_bridge_port *bridge_port) |
| { |
| list_del(&bridge_port->list); |
| WARN_ON(!list_empty(&bridge_port->vlans_list)); |
| kfree(bridge_port); |
| } |
| |
| static struct mlxsw_sp_bridge_port * |
| mlxsw_sp_bridge_port_get(struct mlxsw_sp_bridge *bridge, |
| struct net_device *brport_dev) |
| { |
| struct net_device *br_dev = netdev_master_upper_dev_get(brport_dev); |
| struct mlxsw_sp_bridge_device *bridge_device; |
| struct mlxsw_sp_bridge_port *bridge_port; |
| int err; |
| |
| bridge_port = mlxsw_sp_bridge_port_find(bridge, brport_dev); |
| if (bridge_port) { |
| bridge_port->ref_count++; |
| return bridge_port; |
| } |
| |
| bridge_device = mlxsw_sp_bridge_device_get(bridge, br_dev); |
| if (IS_ERR(bridge_device)) |
| return ERR_CAST(bridge_device); |
| |
| bridge_port = mlxsw_sp_bridge_port_create(bridge_device, brport_dev); |
| if (!bridge_port) { |
| err = -ENOMEM; |
| goto err_bridge_port_create; |
| } |
| |
| return bridge_port; |
| |
| err_bridge_port_create: |
| mlxsw_sp_bridge_device_put(bridge, bridge_device); |
| return ERR_PTR(err); |
| } |
| |
| static void mlxsw_sp_bridge_port_put(struct mlxsw_sp_bridge *bridge, |
| struct mlxsw_sp_bridge_port *bridge_port) |
| { |
| struct mlxsw_sp_bridge_device *bridge_device; |
| |
| if (--bridge_port->ref_count != 0) |
| return; |
| bridge_device = bridge_port->bridge_device; |
| mlxsw_sp_bridge_port_destroy(bridge_port); |
| mlxsw_sp_bridge_device_put(bridge, bridge_device); |
| } |
| |
| static struct mlxsw_sp_port_vlan * |
| mlxsw_sp_port_vlan_find_by_bridge(struct mlxsw_sp_port *mlxsw_sp_port, |
| const struct mlxsw_sp_bridge_device * |
| bridge_device, |
| u16 vid) |
| { |
| struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan; |
| |
| list_for_each_entry(mlxsw_sp_port_vlan, &mlxsw_sp_port->vlans_list, |
| list) { |
| if (!mlxsw_sp_port_vlan->bridge_port) |
| continue; |
| if (mlxsw_sp_port_vlan->bridge_port->bridge_device != |
| bridge_device) |
| continue; |
| if (bridge_device->vlan_enabled && |
| mlxsw_sp_port_vlan->vid != vid) |
| continue; |
| return mlxsw_sp_port_vlan; |
| } |
| |
| return NULL; |
| } |
| |
| static struct mlxsw_sp_port_vlan* |
| mlxsw_sp_port_vlan_find_by_fid(struct mlxsw_sp_port *mlxsw_sp_port, |
| u16 fid_index) |
| { |
| struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan; |
| |
| list_for_each_entry(mlxsw_sp_port_vlan, &mlxsw_sp_port->vlans_list, |
| list) { |
| struct mlxsw_sp_fid *fid = mlxsw_sp_port_vlan->fid; |
| |
| if (fid && mlxsw_sp_fid_index(fid) == fid_index) |
| return mlxsw_sp_port_vlan; |
| } |
| |
| return NULL; |
| } |
| |
| static struct mlxsw_sp_bridge_vlan * |
| mlxsw_sp_bridge_vlan_find(const struct mlxsw_sp_bridge_port *bridge_port, |
| u16 vid) |
| { |
| struct mlxsw_sp_bridge_vlan *bridge_vlan; |
| |
| list_for_each_entry(bridge_vlan, &bridge_port->vlans_list, list) { |
| if (bridge_vlan->vid == vid) |
| return bridge_vlan; |
| } |
| |
| return NULL; |
| } |
| |
| static struct mlxsw_sp_bridge_vlan * |
| mlxsw_sp_bridge_vlan_create(struct mlxsw_sp_bridge_port *bridge_port, u16 vid) |
| { |
| struct mlxsw_sp_bridge_vlan *bridge_vlan; |
| |
| bridge_vlan = kzalloc(sizeof(*bridge_vlan), GFP_KERNEL); |
| if (!bridge_vlan) |
| return NULL; |
| |
| INIT_LIST_HEAD(&bridge_vlan->port_vlan_list); |
| bridge_vlan->vid = vid; |
| list_add(&bridge_vlan->list, &bridge_port->vlans_list); |
| |
| return bridge_vlan; |
| } |
| |
| static void |
| mlxsw_sp_bridge_vlan_destroy(struct mlxsw_sp_bridge_vlan *bridge_vlan) |
| { |
| list_del(&bridge_vlan->list); |
| WARN_ON(!list_empty(&bridge_vlan->port_vlan_list)); |
| kfree(bridge_vlan); |
| } |
| |
| static struct mlxsw_sp_bridge_vlan * |
| mlxsw_sp_bridge_vlan_get(struct mlxsw_sp_bridge_port *bridge_port, u16 vid) |
| { |
| struct mlxsw_sp_bridge_vlan *bridge_vlan; |
| |
| bridge_vlan = mlxsw_sp_bridge_vlan_find(bridge_port, vid); |
| if (bridge_vlan) |
| return bridge_vlan; |
| |
| return mlxsw_sp_bridge_vlan_create(bridge_port, vid); |
| } |
| |
| static void mlxsw_sp_bridge_vlan_put(struct mlxsw_sp_bridge_vlan *bridge_vlan) |
| { |
| if (list_empty(&bridge_vlan->port_vlan_list)) |
| mlxsw_sp_bridge_vlan_destroy(bridge_vlan); |
| } |
| |
| static void mlxsw_sp_port_bridge_flags_get(struct mlxsw_sp_bridge *bridge, |
| struct net_device *dev, |
| unsigned long *brport_flags) |
| { |
| struct mlxsw_sp_bridge_port *bridge_port; |
| |
| bridge_port = mlxsw_sp_bridge_port_find(bridge, dev); |
| if (WARN_ON(!bridge_port)) |
| return; |
| |
| memcpy(brport_flags, &bridge_port->flags, sizeof(*brport_flags)); |
| } |
| |
| static int mlxsw_sp_port_attr_get(struct net_device *dev, |
| struct switchdev_attr *attr) |
| { |
| struct mlxsw_sp_port *mlxsw_sp_port = netdev_priv(dev); |
| struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp; |
| |
| switch (attr->id) { |
| case SWITCHDEV_ATTR_ID_PORT_PARENT_ID: |
| attr->u.ppid.id_len = sizeof(mlxsw_sp->base_mac); |
| memcpy(&attr->u.ppid.id, &mlxsw_sp->base_mac, |
| attr->u.ppid.id_len); |
| break; |
| case SWITCHDEV_ATTR_ID_PORT_BRIDGE_FLAGS: |
| mlxsw_sp_port_bridge_flags_get(mlxsw_sp->bridge, attr->orig_dev, |
| &attr->u.brport_flags); |
| break; |
| case SWITCHDEV_ATTR_ID_PORT_BRIDGE_FLAGS_SUPPORT: |
| attr->u.brport_flags_support = BR_LEARNING | BR_FLOOD | |
| BR_MCAST_FLOOD; |
| break; |
| default: |
| return -EOPNOTSUPP; |
| } |
| |
| return 0; |
| } |
| |
| static int |
| mlxsw_sp_port_bridge_vlan_stp_set(struct mlxsw_sp_port *mlxsw_sp_port, |
| struct mlxsw_sp_bridge_vlan *bridge_vlan, |
| u8 state) |
| { |
| struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan; |
| |
| list_for_each_entry(mlxsw_sp_port_vlan, &bridge_vlan->port_vlan_list, |
| bridge_vlan_node) { |
| if (mlxsw_sp_port_vlan->mlxsw_sp_port != mlxsw_sp_port) |
| continue; |
| return mlxsw_sp_port_vid_stp_set(mlxsw_sp_port, |
| bridge_vlan->vid, state); |
| } |
| |
| return 0; |
| } |
| |
| static int mlxsw_sp_port_attr_stp_state_set(struct mlxsw_sp_port *mlxsw_sp_port, |
| struct switchdev_trans *trans, |
| struct net_device *orig_dev, |
| u8 state) |
| { |
| struct mlxsw_sp_bridge_port *bridge_port; |
| struct mlxsw_sp_bridge_vlan *bridge_vlan; |
| int err; |
| |
| if (switchdev_trans_ph_prepare(trans)) |
| return 0; |
| |
| /* It's possible we failed to enslave the port, yet this |
| * operation is executed due to it being deferred. |
| */ |
| bridge_port = mlxsw_sp_bridge_port_find(mlxsw_sp_port->mlxsw_sp->bridge, |
| orig_dev); |
| if (!bridge_port) |
| return 0; |
| |
| list_for_each_entry(bridge_vlan, &bridge_port->vlans_list, list) { |
| err = mlxsw_sp_port_bridge_vlan_stp_set(mlxsw_sp_port, |
| bridge_vlan, state); |
| if (err) |
| goto err_port_bridge_vlan_stp_set; |
| } |
| |
| bridge_port->stp_state = state; |
| |
| return 0; |
| |
| err_port_bridge_vlan_stp_set: |
| list_for_each_entry_continue_reverse(bridge_vlan, |
| &bridge_port->vlans_list, list) |
| mlxsw_sp_port_bridge_vlan_stp_set(mlxsw_sp_port, bridge_vlan, |
| bridge_port->stp_state); |
| return err; |
| } |
| |
| static int |
| mlxsw_sp_port_bridge_vlan_flood_set(struct mlxsw_sp_port *mlxsw_sp_port, |
| struct mlxsw_sp_bridge_vlan *bridge_vlan, |
| enum mlxsw_sp_flood_type packet_type, |
| bool member) |
| { |
| struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan; |
| |
| list_for_each_entry(mlxsw_sp_port_vlan, &bridge_vlan->port_vlan_list, |
| bridge_vlan_node) { |
| if (mlxsw_sp_port_vlan->mlxsw_sp_port != mlxsw_sp_port) |
| continue; |
| return mlxsw_sp_fid_flood_set(mlxsw_sp_port_vlan->fid, |
| packet_type, |
| mlxsw_sp_port->local_port, |
| member); |
| } |
| |
| return 0; |
| } |
| |
| static int |
| mlxsw_sp_bridge_port_flood_table_set(struct mlxsw_sp_port *mlxsw_sp_port, |
| struct mlxsw_sp_bridge_port *bridge_port, |
| enum mlxsw_sp_flood_type packet_type, |
| bool member) |
| { |
| struct mlxsw_sp_bridge_vlan *bridge_vlan; |
| int err; |
| |
| list_for_each_entry(bridge_vlan, &bridge_port->vlans_list, list) { |
| err = mlxsw_sp_port_bridge_vlan_flood_set(mlxsw_sp_port, |
| bridge_vlan, |
| packet_type, |
| member); |
| if (err) |
| goto err_port_bridge_vlan_flood_set; |
| } |
| |
| return 0; |
| |
| err_port_bridge_vlan_flood_set: |
| list_for_each_entry_continue_reverse(bridge_vlan, |
| &bridge_port->vlans_list, list) |
| mlxsw_sp_port_bridge_vlan_flood_set(mlxsw_sp_port, bridge_vlan, |
| packet_type, !member); |
| return err; |
| } |
| |
| static int |
| mlxsw_sp_port_bridge_vlan_learning_set(struct mlxsw_sp_port *mlxsw_sp_port, |
| struct mlxsw_sp_bridge_vlan *bridge_vlan, |
| bool set) |
| { |
| struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan; |
| u16 vid = bridge_vlan->vid; |
| |
| list_for_each_entry(mlxsw_sp_port_vlan, &bridge_vlan->port_vlan_list, |
| bridge_vlan_node) { |
| if (mlxsw_sp_port_vlan->mlxsw_sp_port != mlxsw_sp_port) |
| continue; |
| return mlxsw_sp_port_vid_learning_set(mlxsw_sp_port, vid, set); |
| } |
| |
| return 0; |
| } |
| |
| static int |
| mlxsw_sp_bridge_port_learning_set(struct mlxsw_sp_port *mlxsw_sp_port, |
| struct mlxsw_sp_bridge_port *bridge_port, |
| bool set) |
| { |
| struct mlxsw_sp_bridge_vlan *bridge_vlan; |
| int err; |
| |
| list_for_each_entry(bridge_vlan, &bridge_port->vlans_list, list) { |
| err = mlxsw_sp_port_bridge_vlan_learning_set(mlxsw_sp_port, |
| bridge_vlan, set); |
| if (err) |
| goto err_port_bridge_vlan_learning_set; |
| } |
| |
| return 0; |
| |
| err_port_bridge_vlan_learning_set: |
| list_for_each_entry_continue_reverse(bridge_vlan, |
| &bridge_port->vlans_list, list) |
| mlxsw_sp_port_bridge_vlan_learning_set(mlxsw_sp_port, |
| bridge_vlan, !set); |
| return err; |
| } |
| |
| static int mlxsw_sp_port_attr_br_flags_set(struct mlxsw_sp_port *mlxsw_sp_port, |
| struct switchdev_trans *trans, |
| struct net_device *orig_dev, |
| unsigned long brport_flags) |
| { |
| struct mlxsw_sp_bridge_port *bridge_port; |
| int err; |
| |
| if (switchdev_trans_ph_prepare(trans)) |
| return 0; |
| |
| bridge_port = mlxsw_sp_bridge_port_find(mlxsw_sp_port->mlxsw_sp->bridge, |
| orig_dev); |
| if (!bridge_port) |
| return 0; |
| |
| err = mlxsw_sp_bridge_port_flood_table_set(mlxsw_sp_port, bridge_port, |
| MLXSW_SP_FLOOD_TYPE_UC, |
| brport_flags & BR_FLOOD); |
| if (err) |
| return err; |
| |
| err = mlxsw_sp_bridge_port_learning_set(mlxsw_sp_port, bridge_port, |
| brport_flags & BR_LEARNING); |
| if (err) |
| return err; |
| |
| if (bridge_port->bridge_device->multicast_enabled) |
| goto out; |
| |
| err = mlxsw_sp_bridge_port_flood_table_set(mlxsw_sp_port, bridge_port, |
| MLXSW_SP_FLOOD_TYPE_MC, |
| brport_flags & |
| BR_MCAST_FLOOD); |
| if (err) |
| return err; |
| |
| out: |
| memcpy(&bridge_port->flags, &brport_flags, sizeof(brport_flags)); |
| return 0; |
| } |
| |
| static int mlxsw_sp_ageing_set(struct mlxsw_sp *mlxsw_sp, u32 ageing_time) |
| { |
| char sfdat_pl[MLXSW_REG_SFDAT_LEN]; |
| int err; |
| |
| mlxsw_reg_sfdat_pack(sfdat_pl, ageing_time); |
| err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(sfdat), sfdat_pl); |
| if (err) |
| return err; |
| mlxsw_sp->bridge->ageing_time = ageing_time; |
| return 0; |
| } |
| |
| static int mlxsw_sp_port_attr_br_ageing_set(struct mlxsw_sp_port *mlxsw_sp_port, |
| struct switchdev_trans *trans, |
| unsigned long ageing_clock_t) |
| { |
| struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp; |
| unsigned long ageing_jiffies = clock_t_to_jiffies(ageing_clock_t); |
| u32 ageing_time = jiffies_to_msecs(ageing_jiffies) / 1000; |
| |
| if (switchdev_trans_ph_prepare(trans)) { |
| if (ageing_time < MLXSW_SP_MIN_AGEING_TIME || |
| ageing_time > MLXSW_SP_MAX_AGEING_TIME) |
| return -ERANGE; |
| else |
| return 0; |
| } |
| |
| return mlxsw_sp_ageing_set(mlxsw_sp, ageing_time); |
| } |
| |
| static int mlxsw_sp_port_attr_br_vlan_set(struct mlxsw_sp_port *mlxsw_sp_port, |
| struct switchdev_trans *trans, |
| struct net_device *orig_dev, |
| bool vlan_enabled) |
| { |
| struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp; |
| struct mlxsw_sp_bridge_device *bridge_device; |
| |
| if (!switchdev_trans_ph_prepare(trans)) |
| return 0; |
| |
| bridge_device = mlxsw_sp_bridge_device_find(mlxsw_sp->bridge, orig_dev); |
| if (WARN_ON(!bridge_device)) |
| return -EINVAL; |
| |
| if (bridge_device->vlan_enabled == vlan_enabled) |
| return 0; |
| |
| netdev_err(bridge_device->dev, "VLAN filtering can't be changed for existing bridge\n"); |
| return -EINVAL; |
| } |
| |
| static int mlxsw_sp_port_attr_mrouter_set(struct mlxsw_sp_port *mlxsw_sp_port, |
| struct switchdev_trans *trans, |
| struct net_device *orig_dev, |
| bool is_port_mrouter) |
| { |
| struct mlxsw_sp_bridge_port *bridge_port; |
| int err; |
| |
| if (switchdev_trans_ph_prepare(trans)) |
| return 0; |
| |
| bridge_port = mlxsw_sp_bridge_port_find(mlxsw_sp_port->mlxsw_sp->bridge, |
| orig_dev); |
| if (!bridge_port) |
| return 0; |
| |
| if (!bridge_port->bridge_device->multicast_enabled) |
| goto out; |
| |
| err = mlxsw_sp_bridge_port_flood_table_set(mlxsw_sp_port, bridge_port, |
| MLXSW_SP_FLOOD_TYPE_MC, |
| is_port_mrouter); |
| if (err) |
| return err; |
| |
| mlxsw_sp_port_mrouter_update_mdb(mlxsw_sp_port, bridge_port, |
| is_port_mrouter); |
| out: |
| bridge_port->mrouter = is_port_mrouter; |
| return 0; |
| } |
| |
| static bool mlxsw_sp_mc_flood(const struct mlxsw_sp_bridge_port *bridge_port) |
| { |
| const struct mlxsw_sp_bridge_device *bridge_device; |
| |
| bridge_device = bridge_port->bridge_device; |
| return bridge_device->multicast_enabled ? bridge_port->mrouter : |
| bridge_port->flags & BR_MCAST_FLOOD; |
| } |
| |
| static int mlxsw_sp_port_mc_disabled_set(struct mlxsw_sp_port *mlxsw_sp_port, |
| struct switchdev_trans *trans, |
| struct net_device *orig_dev, |
| bool mc_disabled) |
| { |
| struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp; |
| struct mlxsw_sp_bridge_device *bridge_device; |
| struct mlxsw_sp_bridge_port *bridge_port; |
| int err; |
| |
| if (switchdev_trans_ph_prepare(trans)) |
| return 0; |
| |
| /* It's possible we failed to enslave the port, yet this |
| * operation is executed due to it being deferred. |
| */ |
| bridge_device = mlxsw_sp_bridge_device_find(mlxsw_sp->bridge, orig_dev); |
| if (!bridge_device) |
| return 0; |
| |
| if (bridge_device->multicast_enabled != !mc_disabled) { |
| bridge_device->multicast_enabled = !mc_disabled; |
| mlxsw_sp_bridge_mdb_mc_enable_sync(mlxsw_sp_port, |
| bridge_device); |
| } |
| |
| list_for_each_entry(bridge_port, &bridge_device->ports_list, list) { |
| enum mlxsw_sp_flood_type packet_type = MLXSW_SP_FLOOD_TYPE_MC; |
| bool member = mlxsw_sp_mc_flood(bridge_port); |
| |
| err = mlxsw_sp_bridge_port_flood_table_set(mlxsw_sp_port, |
| bridge_port, |
| packet_type, member); |
| if (err) |
| return err; |
| } |
| |
| bridge_device->multicast_enabled = !mc_disabled; |
| |
| return 0; |
| } |
| |
| static int mlxsw_sp_smid_router_port_set(struct mlxsw_sp *mlxsw_sp, |
| u16 mid_idx, bool add) |
| { |
| char *smid_pl; |
| int err; |
| |
| smid_pl = kmalloc(MLXSW_REG_SMID_LEN, GFP_KERNEL); |
| if (!smid_pl) |
| return -ENOMEM; |
| |
| mlxsw_reg_smid_pack(smid_pl, mid_idx, |
| mlxsw_sp_router_port(mlxsw_sp), add); |
| err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(smid), smid_pl); |
| kfree(smid_pl); |
| return err; |
| } |
| |
| static void |
| mlxsw_sp_bridge_mrouter_update_mdb(struct mlxsw_sp *mlxsw_sp, |
| struct mlxsw_sp_bridge_device *bridge_device, |
| bool add) |
| { |
| struct mlxsw_sp_mid *mid; |
| |
| list_for_each_entry(mid, &bridge_device->mids_list, list) |
| mlxsw_sp_smid_router_port_set(mlxsw_sp, mid->mid, add); |
| } |
| |
| static int |
| mlxsw_sp_port_attr_br_mrouter_set(struct mlxsw_sp_port *mlxsw_sp_port, |
| struct switchdev_trans *trans, |
| struct net_device *orig_dev, |
| bool is_mrouter) |
| { |
| struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp; |
| struct mlxsw_sp_bridge_device *bridge_device; |
| |
| if (switchdev_trans_ph_prepare(trans)) |
| return 0; |
| |
| /* It's possible we failed to enslave the port, yet this |
| * operation is executed due to it being deferred. |
| */ |
| bridge_device = mlxsw_sp_bridge_device_find(mlxsw_sp->bridge, orig_dev); |
| if (!bridge_device) |
| return 0; |
| |
| if (bridge_device->mrouter != is_mrouter) |
| mlxsw_sp_bridge_mrouter_update_mdb(mlxsw_sp, bridge_device, |
| is_mrouter); |
| bridge_device->mrouter = is_mrouter; |
| return 0; |
| } |
| |
| static int mlxsw_sp_port_attr_set(struct net_device *dev, |
| const struct switchdev_attr *attr, |
| struct switchdev_trans *trans) |
| { |
| struct mlxsw_sp_port *mlxsw_sp_port = netdev_priv(dev); |
| int err; |
| |
| switch (attr->id) { |
| case SWITCHDEV_ATTR_ID_PORT_STP_STATE: |
| err = mlxsw_sp_port_attr_stp_state_set(mlxsw_sp_port, trans, |
| attr->orig_dev, |
| attr->u.stp_state); |
| break; |
| case SWITCHDEV_ATTR_ID_PORT_BRIDGE_FLAGS: |
| err = mlxsw_sp_port_attr_br_flags_set(mlxsw_sp_port, trans, |
| attr->orig_dev, |
| attr->u.brport_flags); |
| break; |
| case SWITCHDEV_ATTR_ID_BRIDGE_AGEING_TIME: |
| err = mlxsw_sp_port_attr_br_ageing_set(mlxsw_sp_port, trans, |
| attr->u.ageing_time); |
| break; |
| case SWITCHDEV_ATTR_ID_BRIDGE_VLAN_FILTERING: |
| err = mlxsw_sp_port_attr_br_vlan_set(mlxsw_sp_port, trans, |
| attr->orig_dev, |
| attr->u.vlan_filtering); |
| break; |
| case SWITCHDEV_ATTR_ID_PORT_MROUTER: |
| err = mlxsw_sp_port_attr_mrouter_set(mlxsw_sp_port, trans, |
| attr->orig_dev, |
| attr->u.mrouter); |
| break; |
| case SWITCHDEV_ATTR_ID_BRIDGE_MC_DISABLED: |
| err = mlxsw_sp_port_mc_disabled_set(mlxsw_sp_port, trans, |
| attr->orig_dev, |
| attr->u.mc_disabled); |
| break; |
| case SWITCHDEV_ATTR_ID_BRIDGE_MROUTER: |
| err = mlxsw_sp_port_attr_br_mrouter_set(mlxsw_sp_port, trans, |
| attr->orig_dev, |
| attr->u.mrouter); |
| break; |
| default: |
| err = -EOPNOTSUPP; |
| break; |
| } |
| |
| if (switchdev_trans_ph_commit(trans)) |
| mlxsw_sp_span_respin(mlxsw_sp_port->mlxsw_sp); |
| |
| return err; |
| } |
| |
| static int |
| mlxsw_sp_port_vlan_fid_join(struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan, |
| struct mlxsw_sp_bridge_port *bridge_port, |
| struct netlink_ext_ack *extack) |
| { |
| struct mlxsw_sp_port *mlxsw_sp_port = mlxsw_sp_port_vlan->mlxsw_sp_port; |
| struct mlxsw_sp_bridge_device *bridge_device; |
| u8 local_port = mlxsw_sp_port->local_port; |
| u16 vid = mlxsw_sp_port_vlan->vid; |
| struct mlxsw_sp_fid *fid; |
| int err; |
| |
| bridge_device = bridge_port->bridge_device; |
| fid = bridge_device->ops->fid_get(bridge_device, vid, extack); |
| if (IS_ERR(fid)) |
| return PTR_ERR(fid); |
| |
| err = mlxsw_sp_fid_flood_set(fid, MLXSW_SP_FLOOD_TYPE_UC, local_port, |
| bridge_port->flags & BR_FLOOD); |
| if (err) |
| goto err_fid_uc_flood_set; |
| |
| err = mlxsw_sp_fid_flood_set(fid, MLXSW_SP_FLOOD_TYPE_MC, local_port, |
| mlxsw_sp_mc_flood(bridge_port)); |
| if (err) |
| goto err_fid_mc_flood_set; |
| |
| err = mlxsw_sp_fid_flood_set(fid, MLXSW_SP_FLOOD_TYPE_BC, local_port, |
| true); |
| if (err) |
| goto err_fid_bc_flood_set; |
| |
| err = mlxsw_sp_fid_port_vid_map(fid, mlxsw_sp_port, vid); |
| if (err) |
| goto err_fid_port_vid_map; |
| |
| mlxsw_sp_port_vlan->fid = fid; |
| |
| return 0; |
| |
| err_fid_port_vid_map: |
| mlxsw_sp_fid_flood_set(fid, MLXSW_SP_FLOOD_TYPE_BC, local_port, false); |
| err_fid_bc_flood_set: |
| mlxsw_sp_fid_flood_set(fid, MLXSW_SP_FLOOD_TYPE_MC, local_port, false); |
| err_fid_mc_flood_set: |
| mlxsw_sp_fid_flood_set(fid, MLXSW_SP_FLOOD_TYPE_UC, local_port, false); |
| err_fid_uc_flood_set: |
| mlxsw_sp_fid_put(fid); |
| return err; |
| } |
| |
| static void |
| mlxsw_sp_port_vlan_fid_leave(struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan) |
| { |
| struct mlxsw_sp_port *mlxsw_sp_port = mlxsw_sp_port_vlan->mlxsw_sp_port; |
| struct mlxsw_sp_fid *fid = mlxsw_sp_port_vlan->fid; |
| u8 local_port = mlxsw_sp_port->local_port; |
| u16 vid = mlxsw_sp_port_vlan->vid; |
| |
| mlxsw_sp_port_vlan->fid = NULL; |
| mlxsw_sp_fid_port_vid_unmap(fid, mlxsw_sp_port, vid); |
| mlxsw_sp_fid_flood_set(fid, MLXSW_SP_FLOOD_TYPE_BC, local_port, false); |
| mlxsw_sp_fid_flood_set(fid, MLXSW_SP_FLOOD_TYPE_MC, local_port, false); |
| mlxsw_sp_fid_flood_set(fid, MLXSW_SP_FLOOD_TYPE_UC, local_port, false); |
| mlxsw_sp_fid_put(fid); |
| } |
| |
| static u16 |
| mlxsw_sp_port_pvid_determine(const struct mlxsw_sp_port *mlxsw_sp_port, |
| u16 vid, bool is_pvid) |
| { |
| if (is_pvid) |
| return vid; |
| else if (mlxsw_sp_port->pvid == vid) |
| return 0; /* Dis-allow untagged packets */ |
| else |
| return mlxsw_sp_port->pvid; |
| } |
| |
| static int |
| mlxsw_sp_port_vlan_bridge_join(struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan, |
| struct mlxsw_sp_bridge_port *bridge_port, |
| struct netlink_ext_ack *extack) |
| { |
| struct mlxsw_sp_port *mlxsw_sp_port = mlxsw_sp_port_vlan->mlxsw_sp_port; |
| struct mlxsw_sp_bridge_vlan *bridge_vlan; |
| u16 vid = mlxsw_sp_port_vlan->vid; |
| int err; |
| |
| /* No need to continue if only VLAN flags were changed */ |
| if (mlxsw_sp_port_vlan->bridge_port) |
| return 0; |
| |
| err = mlxsw_sp_port_vlan_fid_join(mlxsw_sp_port_vlan, bridge_port, |
| extack); |
| if (err) |
| return err; |
| |
| err = mlxsw_sp_port_vid_learning_set(mlxsw_sp_port, vid, |
| bridge_port->flags & BR_LEARNING); |
| if (err) |
| goto err_port_vid_learning_set; |
| |
| err = mlxsw_sp_port_vid_stp_set(mlxsw_sp_port, vid, |
| bridge_port->stp_state); |
| if (err) |
| goto err_port_vid_stp_set; |
| |
| bridge_vlan = mlxsw_sp_bridge_vlan_get(bridge_port, vid); |
| if (!bridge_vlan) { |
| err = -ENOMEM; |
| goto err_bridge_vlan_get; |
| } |
| |
| list_add(&mlxsw_sp_port_vlan->bridge_vlan_node, |
| &bridge_vlan->port_vlan_list); |
| |
| mlxsw_sp_bridge_port_get(mlxsw_sp_port->mlxsw_sp->bridge, |
| bridge_port->dev); |
| mlxsw_sp_port_vlan->bridge_port = bridge_port; |
| |
| return 0; |
| |
| err_bridge_vlan_get: |
| mlxsw_sp_port_vid_stp_set(mlxsw_sp_port, vid, BR_STATE_DISABLED); |
| err_port_vid_stp_set: |
| mlxsw_sp_port_vid_learning_set(mlxsw_sp_port, vid, false); |
| err_port_vid_learning_set: |
| mlxsw_sp_port_vlan_fid_leave(mlxsw_sp_port_vlan); |
| return err; |
| } |
| |
| void |
| mlxsw_sp_port_vlan_bridge_leave(struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan) |
| { |
| struct mlxsw_sp_port *mlxsw_sp_port = mlxsw_sp_port_vlan->mlxsw_sp_port; |
| struct mlxsw_sp_fid *fid = mlxsw_sp_port_vlan->fid; |
| struct mlxsw_sp_bridge_vlan *bridge_vlan; |
| struct mlxsw_sp_bridge_port *bridge_port; |
| u16 vid = mlxsw_sp_port_vlan->vid; |
| bool last_port, last_vlan; |
| |
| if (WARN_ON(mlxsw_sp_fid_type(fid) != MLXSW_SP_FID_TYPE_8021Q && |
| mlxsw_sp_fid_type(fid) != MLXSW_SP_FID_TYPE_8021D)) |
| return; |
| |
| bridge_port = mlxsw_sp_port_vlan->bridge_port; |
| last_vlan = list_is_singular(&bridge_port->vlans_list); |
| bridge_vlan = mlxsw_sp_bridge_vlan_find(bridge_port, vid); |
| last_port = list_is_singular(&bridge_vlan->port_vlan_list); |
| |
| list_del(&mlxsw_sp_port_vlan->bridge_vlan_node); |
| mlxsw_sp_bridge_vlan_put(bridge_vlan); |
| mlxsw_sp_port_vid_stp_set(mlxsw_sp_port, vid, BR_STATE_DISABLED); |
| mlxsw_sp_port_vid_learning_set(mlxsw_sp_port, vid, false); |
| if (last_port) |
| mlxsw_sp_bridge_port_fdb_flush(mlxsw_sp_port->mlxsw_sp, |
| bridge_port, |
| mlxsw_sp_fid_index(fid)); |
| if (last_vlan) |
| mlxsw_sp_bridge_port_mdb_flush(mlxsw_sp_port, bridge_port); |
| |
| mlxsw_sp_port_vlan_fid_leave(mlxsw_sp_port_vlan); |
| |
| mlxsw_sp_bridge_port_put(mlxsw_sp_port->mlxsw_sp->bridge, bridge_port); |
| mlxsw_sp_port_vlan->bridge_port = NULL; |
| } |
| |
| static int |
| mlxsw_sp_bridge_port_vlan_add(struct mlxsw_sp_port *mlxsw_sp_port, |
| struct mlxsw_sp_bridge_port *bridge_port, |
| u16 vid, bool is_untagged, bool is_pvid, |
| struct netlink_ext_ack *extack) |
| { |
| u16 pvid = mlxsw_sp_port_pvid_determine(mlxsw_sp_port, vid, is_pvid); |
| struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan; |
| u16 old_pvid = mlxsw_sp_port->pvid; |
| int err; |
| |
| /* The only valid scenario in which a port-vlan already exists, is if |
| * the VLAN flags were changed and the port-vlan is associated with the |
| * correct bridge port |
| */ |
| mlxsw_sp_port_vlan = mlxsw_sp_port_vlan_find_by_vid(mlxsw_sp_port, vid); |
| if (mlxsw_sp_port_vlan && |
| mlxsw_sp_port_vlan->bridge_port != bridge_port) |
| return -EEXIST; |
| |
| if (!mlxsw_sp_port_vlan) { |
| mlxsw_sp_port_vlan = mlxsw_sp_port_vlan_create(mlxsw_sp_port, |
| vid); |
| if (IS_ERR(mlxsw_sp_port_vlan)) |
| return PTR_ERR(mlxsw_sp_port_vlan); |
| } |
| |
| err = mlxsw_sp_port_vlan_set(mlxsw_sp_port, vid, vid, true, |
| is_untagged); |
| if (err) |
| goto err_port_vlan_set; |
| |
| err = mlxsw_sp_port_pvid_set(mlxsw_sp_port, pvid); |
| if (err) |
| goto err_port_pvid_set; |
| |
| err = mlxsw_sp_port_vlan_bridge_join(mlxsw_sp_port_vlan, bridge_port, |
| extack); |
| if (err) |
| goto err_port_vlan_bridge_join; |
| |
| return 0; |
| |
| err_port_vlan_bridge_join: |
| mlxsw_sp_port_pvid_set(mlxsw_sp_port, old_pvid); |
| err_port_pvid_set: |
| mlxsw_sp_port_vlan_set(mlxsw_sp_port, vid, vid, false, false); |
| err_port_vlan_set: |
| mlxsw_sp_port_vlan_destroy(mlxsw_sp_port_vlan); |
| return err; |
| } |
| |
| static int |
| mlxsw_sp_br_ban_rif_pvid_change(struct mlxsw_sp *mlxsw_sp, |
| const struct net_device *br_dev, |
| const struct switchdev_obj_port_vlan *vlan) |
| { |
| struct mlxsw_sp_rif *rif; |
| struct mlxsw_sp_fid *fid; |
| u16 pvid; |
| u16 vid; |
| |
| rif = mlxsw_sp_rif_find_by_dev(mlxsw_sp, br_dev); |
| if (!rif) |
| return 0; |
| fid = mlxsw_sp_rif_fid(rif); |
| pvid = mlxsw_sp_fid_8021q_vid(fid); |
| |
| for (vid = vlan->vid_begin; vid <= vlan->vid_end; ++vid) { |
| if (vlan->flags & BRIDGE_VLAN_INFO_PVID) { |
| if (vid != pvid) { |
| netdev_err(br_dev, "Can't change PVID, it's used by router interface\n"); |
| return -EBUSY; |
| } |
| } else { |
| if (vid == pvid) { |
| netdev_err(br_dev, "Can't remove PVID, it's used by router interface\n"); |
| return -EBUSY; |
| } |
| } |
| } |
| |
| return 0; |
| } |
| |
| static int mlxsw_sp_port_vlans_add(struct mlxsw_sp_port *mlxsw_sp_port, |
| const struct switchdev_obj_port_vlan *vlan, |
| struct switchdev_trans *trans, |
| struct netlink_ext_ack *extack) |
| { |
| bool flag_untagged = vlan->flags & BRIDGE_VLAN_INFO_UNTAGGED; |
| bool flag_pvid = vlan->flags & BRIDGE_VLAN_INFO_PVID; |
| struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp; |
| struct net_device *orig_dev = vlan->obj.orig_dev; |
| struct mlxsw_sp_bridge_port *bridge_port; |
| u16 vid; |
| |
| if (netif_is_bridge_master(orig_dev)) { |
| int err = 0; |
| |
| if ((vlan->flags & BRIDGE_VLAN_INFO_BRENTRY) && |
| br_vlan_enabled(orig_dev) && |
| switchdev_trans_ph_prepare(trans)) |
| err = mlxsw_sp_br_ban_rif_pvid_change(mlxsw_sp, |
| orig_dev, vlan); |
| if (!err) |
| err = -EOPNOTSUPP; |
| return err; |
| } |
| |
| if (switchdev_trans_ph_commit(trans)) |
| return 0; |
| |
| bridge_port = mlxsw_sp_bridge_port_find(mlxsw_sp->bridge, orig_dev); |
| if (WARN_ON(!bridge_port)) |
| return -EINVAL; |
| |
| if (!bridge_port->bridge_device->vlan_enabled) |
| return 0; |
| |
| for (vid = vlan->vid_begin; vid <= vlan->vid_end; vid++) { |
| int err; |
| |
| err = mlxsw_sp_bridge_port_vlan_add(mlxsw_sp_port, bridge_port, |
| vid, flag_untagged, |
| flag_pvid, extack); |
| if (err) |
| return err; |
| } |
| |
| return 0; |
| } |
| |
| static enum mlxsw_reg_sfdf_flush_type mlxsw_sp_fdb_flush_type(bool lagged) |
| { |
| return lagged ? MLXSW_REG_SFDF_FLUSH_PER_LAG_AND_FID : |
| MLXSW_REG_SFDF_FLUSH_PER_PORT_AND_FID; |
| } |
| |
| static int |
| mlxsw_sp_bridge_port_fdb_flush(struct mlxsw_sp *mlxsw_sp, |
| struct mlxsw_sp_bridge_port *bridge_port, |
| u16 fid_index) |
| { |
| bool lagged = bridge_port->lagged; |
| char sfdf_pl[MLXSW_REG_SFDF_LEN]; |
| u16 system_port; |
| |
| system_port = lagged ? bridge_port->lag_id : bridge_port->system_port; |
| mlxsw_reg_sfdf_pack(sfdf_pl, mlxsw_sp_fdb_flush_type(lagged)); |
| mlxsw_reg_sfdf_fid_set(sfdf_pl, fid_index); |
| mlxsw_reg_sfdf_port_fid_system_port_set(sfdf_pl, system_port); |
| |
| return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(sfdf), sfdf_pl); |
| } |
| |
| static enum mlxsw_reg_sfd_rec_policy mlxsw_sp_sfd_rec_policy(bool dynamic) |
| { |
| return dynamic ? MLXSW_REG_SFD_REC_POLICY_DYNAMIC_ENTRY_INGRESS : |
| MLXSW_REG_SFD_REC_POLICY_DYNAMIC_ENTRY_MLAG; |
| } |
| |
| static enum mlxsw_reg_sfd_op mlxsw_sp_sfd_op(bool adding) |
| { |
| return adding ? MLXSW_REG_SFD_OP_WRITE_EDIT : |
| MLXSW_REG_SFD_OP_WRITE_REMOVE; |
| } |
| |
| static int mlxsw_sp_port_fdb_tunnel_uc_op(struct mlxsw_sp *mlxsw_sp, |
| const char *mac, u16 fid, |
| enum mlxsw_sp_l3proto proto, |
| const union mlxsw_sp_l3addr *addr, |
| bool adding, bool dynamic) |
| { |
| enum mlxsw_reg_sfd_uc_tunnel_protocol sfd_proto; |
| char *sfd_pl; |
| u8 num_rec; |
| u32 uip; |
| int err; |
| |
| switch (proto) { |
| case MLXSW_SP_L3_PROTO_IPV4: |
| uip = be32_to_cpu(addr->addr4); |
| sfd_proto = MLXSW_REG_SFD_UC_TUNNEL_PROTOCOL_IPV4; |
| break; |
| case MLXSW_SP_L3_PROTO_IPV6: /* fall through */ |
| default: |
| WARN_ON(1); |
| return -EOPNOTSUPP; |
| } |
| |
| sfd_pl = kmalloc(MLXSW_REG_SFD_LEN, GFP_KERNEL); |
| if (!sfd_pl) |
| return -ENOMEM; |
| |
| mlxsw_reg_sfd_pack(sfd_pl, mlxsw_sp_sfd_op(adding), 0); |
| mlxsw_reg_sfd_uc_tunnel_pack(sfd_pl, 0, |
| mlxsw_sp_sfd_rec_policy(dynamic), mac, fid, |
| MLXSW_REG_SFD_REC_ACTION_NOP, uip, |
| sfd_proto); |
| num_rec = mlxsw_reg_sfd_num_rec_get(sfd_pl); |
| err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(sfd), sfd_pl); |
| if (err) |
| goto out; |
| |
| if (num_rec != mlxsw_reg_sfd_num_rec_get(sfd_pl)) |
| err = -EBUSY; |
| |
| out: |
| kfree(sfd_pl); |
| return err; |
| } |
| |
| static int __mlxsw_sp_port_fdb_uc_op(struct mlxsw_sp *mlxsw_sp, u8 local_port, |
| const char *mac, u16 fid, bool adding, |
| enum mlxsw_reg_sfd_rec_action action, |
| enum mlxsw_reg_sfd_rec_policy policy) |
| { |
| char *sfd_pl; |
| u8 num_rec; |
| int err; |
| |
| sfd_pl = kmalloc(MLXSW_REG_SFD_LEN, GFP_KERNEL); |
| if (!sfd_pl) |
| return -ENOMEM; |
| |
| mlxsw_reg_sfd_pack(sfd_pl, mlxsw_sp_sfd_op(adding), 0); |
| mlxsw_reg_sfd_uc_pack(sfd_pl, 0, policy, mac, fid, action, local_port); |
| num_rec = mlxsw_reg_sfd_num_rec_get(sfd_pl); |
| err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(sfd), sfd_pl); |
| if (err) |
| goto out; |
| |
| if (num_rec != mlxsw_reg_sfd_num_rec_get(sfd_pl)) |
| err = -EBUSY; |
| |
| out: |
| kfree(sfd_pl); |
| return err; |
| } |
| |
| static int mlxsw_sp_port_fdb_uc_op(struct mlxsw_sp *mlxsw_sp, u8 local_port, |
| const char *mac, u16 fid, bool adding, |
| bool dynamic) |
| { |
| return __mlxsw_sp_port_fdb_uc_op(mlxsw_sp, local_port, mac, fid, adding, |
| MLXSW_REG_SFD_REC_ACTION_NOP, |
| mlxsw_sp_sfd_rec_policy(dynamic)); |
| } |
| |
| int mlxsw_sp_rif_fdb_op(struct mlxsw_sp *mlxsw_sp, const char *mac, u16 fid, |
| bool adding) |
| { |
| return __mlxsw_sp_port_fdb_uc_op(mlxsw_sp, 0, mac, fid, adding, |
| MLXSW_REG_SFD_REC_ACTION_FORWARD_IP_ROUTER, |
| MLXSW_REG_SFD_REC_POLICY_STATIC_ENTRY); |
| } |
| |
| static int mlxsw_sp_port_fdb_uc_lag_op(struct mlxsw_sp *mlxsw_sp, u16 lag_id, |
| const char *mac, u16 fid, u16 lag_vid, |
| bool adding, bool dynamic) |
| { |
| char *sfd_pl; |
| u8 num_rec; |
| int err; |
| |
| sfd_pl = kmalloc(MLXSW_REG_SFD_LEN, GFP_KERNEL); |
| if (!sfd_pl) |
| return -ENOMEM; |
| |
| mlxsw_reg_sfd_pack(sfd_pl, mlxsw_sp_sfd_op(adding), 0); |
| mlxsw_reg_sfd_uc_lag_pack(sfd_pl, 0, mlxsw_sp_sfd_rec_policy(dynamic), |
| mac, fid, MLXSW_REG_SFD_REC_ACTION_NOP, |
| lag_vid, lag_id); |
| num_rec = mlxsw_reg_sfd_num_rec_get(sfd_pl); |
| err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(sfd), sfd_pl); |
| if (err) |
| goto out; |
| |
| if (num_rec != mlxsw_reg_sfd_num_rec_get(sfd_pl)) |
| err = -EBUSY; |
| |
| out: |
| kfree(sfd_pl); |
| return err; |
| } |
| |
| static int |
| mlxsw_sp_port_fdb_set(struct mlxsw_sp_port *mlxsw_sp_port, |
| struct switchdev_notifier_fdb_info *fdb_info, bool adding) |
| { |
| struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp; |
| struct net_device *orig_dev = fdb_info->info.dev; |
| struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan; |
| struct mlxsw_sp_bridge_device *bridge_device; |
| struct mlxsw_sp_bridge_port *bridge_port; |
| u16 fid_index, vid; |
| |
| bridge_port = mlxsw_sp_bridge_port_find(mlxsw_sp->bridge, orig_dev); |
| if (!bridge_port) |
| return -EINVAL; |
| |
| bridge_device = bridge_port->bridge_device; |
| mlxsw_sp_port_vlan = mlxsw_sp_port_vlan_find_by_bridge(mlxsw_sp_port, |
| bridge_device, |
| fdb_info->vid); |
| if (!mlxsw_sp_port_vlan) |
| return 0; |
| |
| fid_index = mlxsw_sp_fid_index(mlxsw_sp_port_vlan->fid); |
| vid = mlxsw_sp_port_vlan->vid; |
| |
| if (!bridge_port->lagged) |
| return mlxsw_sp_port_fdb_uc_op(mlxsw_sp, |
| bridge_port->system_port, |
| fdb_info->addr, fid_index, |
| adding, false); |
| else |
| return mlxsw_sp_port_fdb_uc_lag_op(mlxsw_sp, |
| bridge_port->lag_id, |
| fdb_info->addr, fid_index, |
| vid, adding, false); |
| } |
| |
| static int mlxsw_sp_port_mdb_op(struct mlxsw_sp *mlxsw_sp, const char *addr, |
| u16 fid, u16 mid_idx, bool adding) |
| { |
| char *sfd_pl; |
| u8 num_rec; |
| int err; |
| |
| sfd_pl = kmalloc(MLXSW_REG_SFD_LEN, GFP_KERNEL); |
| if (!sfd_pl) |
| return -ENOMEM; |
| |
| mlxsw_reg_sfd_pack(sfd_pl, mlxsw_sp_sfd_op(adding), 0); |
| mlxsw_reg_sfd_mc_pack(sfd_pl, 0, addr, fid, |
| MLXSW_REG_SFD_REC_ACTION_NOP, mid_idx); |
| num_rec = mlxsw_reg_sfd_num_rec_get(sfd_pl); |
| err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(sfd), sfd_pl); |
| if (err) |
| goto out; |
| |
| if (num_rec != mlxsw_reg_sfd_num_rec_get(sfd_pl)) |
| err = -EBUSY; |
| |
| out: |
| kfree(sfd_pl); |
| return err; |
| } |
| |
| static int mlxsw_sp_port_smid_full_entry(struct mlxsw_sp *mlxsw_sp, u16 mid_idx, |
| long *ports_bitmap, |
| bool set_router_port) |
| { |
| char *smid_pl; |
| int err, i; |
| |
| smid_pl = kmalloc(MLXSW_REG_SMID_LEN, GFP_KERNEL); |
| if (!smid_pl) |
| return -ENOMEM; |
| |
| mlxsw_reg_smid_pack(smid_pl, mid_idx, 0, false); |
| for (i = 1; i < mlxsw_core_max_ports(mlxsw_sp->core); i++) { |
| if (mlxsw_sp->ports[i]) |
| mlxsw_reg_smid_port_mask_set(smid_pl, i, 1); |
| } |
| |
| mlxsw_reg_smid_port_mask_set(smid_pl, |
| mlxsw_sp_router_port(mlxsw_sp), 1); |
| |
| for_each_set_bit(i, ports_bitmap, mlxsw_core_max_ports(mlxsw_sp->core)) |
| mlxsw_reg_smid_port_set(smid_pl, i, 1); |
| |
| mlxsw_reg_smid_port_set(smid_pl, mlxsw_sp_router_port(mlxsw_sp), |
| set_router_port); |
| |
| err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(smid), smid_pl); |
| kfree(smid_pl); |
| return err; |
| } |
| |
| static int mlxsw_sp_port_smid_set(struct mlxsw_sp_port *mlxsw_sp_port, |
| u16 mid_idx, bool add) |
| { |
| struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp; |
| char *smid_pl; |
| int err; |
| |
| smid_pl = kmalloc(MLXSW_REG_SMID_LEN, GFP_KERNEL); |
| if (!smid_pl) |
| return -ENOMEM; |
| |
| mlxsw_reg_smid_pack(smid_pl, mid_idx, mlxsw_sp_port->local_port, add); |
| err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(smid), smid_pl); |
| kfree(smid_pl); |
| return err; |
| } |
| |
| static struct |
| mlxsw_sp_mid *__mlxsw_sp_mc_get(struct mlxsw_sp_bridge_device *bridge_device, |
| const unsigned char *addr, |
| u16 fid) |
| { |
| struct mlxsw_sp_mid *mid; |
| |
| list_for_each_entry(mid, &bridge_device->mids_list, list) { |
| if (ether_addr_equal(mid->addr, addr) && mid->fid == fid) |
| return mid; |
| } |
| return NULL; |
| } |
| |
| static void |
| mlxsw_sp_bridge_port_get_ports_bitmap(struct mlxsw_sp *mlxsw_sp, |
| struct mlxsw_sp_bridge_port *bridge_port, |
| unsigned long *ports_bitmap) |
| { |
| struct mlxsw_sp_port *mlxsw_sp_port; |
| u64 max_lag_members, i; |
| int lag_id; |
| |
| if (!bridge_port->lagged) { |
| set_bit(bridge_port->system_port, ports_bitmap); |
| } else { |
| max_lag_members = MLXSW_CORE_RES_GET(mlxsw_sp->core, |
| MAX_LAG_MEMBERS); |
| lag_id = bridge_port->lag_id; |
| for (i = 0; i < max_lag_members; i++) { |
| mlxsw_sp_port = mlxsw_sp_port_lagged_get(mlxsw_sp, |
| lag_id, i); |
| if (mlxsw_sp_port) |
| set_bit(mlxsw_sp_port->local_port, |
| ports_bitmap); |
| } |
| } |
| } |
| |
| static void |
| mlxsw_sp_mc_get_mrouters_bitmap(unsigned long *flood_bitmap, |
| struct mlxsw_sp_bridge_device *bridge_device, |
| struct mlxsw_sp *mlxsw_sp) |
| { |
| struct mlxsw_sp_bridge_port *bridge_port; |
| |
| list_for_each_entry(bridge_port, &bridge_device->ports_list, list) { |
| if (bridge_port->mrouter) { |
| mlxsw_sp_bridge_port_get_ports_bitmap(mlxsw_sp, |
| bridge_port, |
| flood_bitmap); |
| } |
| } |
| } |
| |
| static bool |
| mlxsw_sp_mc_write_mdb_entry(struct mlxsw_sp *mlxsw_sp, |
| struct mlxsw_sp_mid *mid, |
| struct mlxsw_sp_bridge_device *bridge_device) |
| { |
| long *flood_bitmap; |
| int num_of_ports; |
| int alloc_size; |
| u16 mid_idx; |
| int err; |
| |
| mid_idx = find_first_zero_bit(mlxsw_sp->bridge->mids_bitmap, |
| MLXSW_SP_MID_MAX); |
| if (mid_idx == MLXSW_SP_MID_MAX) |
| return false; |
| |
| num_of_ports = mlxsw_core_max_ports(mlxsw_sp->core); |
| alloc_size = sizeof(long) * BITS_TO_LONGS(num_of_ports); |
| flood_bitmap = kzalloc(alloc_size, GFP_KERNEL); |
| if (!flood_bitmap) |
| return false; |
| |
| bitmap_copy(flood_bitmap, mid->ports_in_mid, num_of_ports); |
| mlxsw_sp_mc_get_mrouters_bitmap(flood_bitmap, bridge_device, mlxsw_sp); |
| |
| mid->mid = mid_idx; |
| err = mlxsw_sp_port_smid_full_entry(mlxsw_sp, mid_idx, flood_bitmap, |
| bridge_device->mrouter); |
| kfree(flood_bitmap); |
| if (err) |
| return false; |
| |
| err = mlxsw_sp_port_mdb_op(mlxsw_sp, mid->addr, mid->fid, mid_idx, |
| true); |
| if (err) |
| return false; |
| |
| set_bit(mid_idx, mlxsw_sp->bridge->mids_bitmap); |
| mid->in_hw = true; |
| return true; |
| } |
| |
| static int mlxsw_sp_mc_remove_mdb_entry(struct mlxsw_sp *mlxsw_sp, |
| struct mlxsw_sp_mid *mid) |
| { |
| if (!mid->in_hw) |
| return 0; |
| |
| clear_bit(mid->mid, mlxsw_sp->bridge->mids_bitmap); |
| mid->in_hw = false; |
| return mlxsw_sp_port_mdb_op(mlxsw_sp, mid->addr, mid->fid, mid->mid, |
| false); |
| } |
| |
| static struct |
| mlxsw_sp_mid *__mlxsw_sp_mc_alloc(struct mlxsw_sp *mlxsw_sp, |
| struct mlxsw_sp_bridge_device *bridge_device, |
| const unsigned char *addr, |
| u16 fid) |
| { |
| struct mlxsw_sp_mid *mid; |
| size_t alloc_size; |
| |
| mid = kzalloc(sizeof(*mid), GFP_KERNEL); |
| if (!mid) |
| return NULL; |
| |
| alloc_size = sizeof(unsigned long) * |
| BITS_TO_LONGS(mlxsw_core_max_ports(mlxsw_sp->core)); |
| |
| mid->ports_in_mid = kzalloc(alloc_size, GFP_KERNEL); |
| if (!mid->ports_in_mid) |
| goto err_ports_in_mid_alloc; |
| |
| ether_addr_copy(mid->addr, addr); |
| mid->fid = fid; |
| mid->in_hw = false; |
| |
| if (!bridge_device->multicast_enabled) |
| goto out; |
| |
| if (!mlxsw_sp_mc_write_mdb_entry(mlxsw_sp, mid, bridge_device)) |
| goto err_write_mdb_entry; |
| |
| out: |
| list_add_tail(&mid->list, &bridge_device->mids_list); |
| return mid; |
| |
| err_write_mdb_entry: |
| kfree(mid->ports_in_mid); |
| err_ports_in_mid_alloc: |
| kfree(mid); |
| return NULL; |
| } |
| |
| static int mlxsw_sp_port_remove_from_mid(struct mlxsw_sp_port *mlxsw_sp_port, |
| struct mlxsw_sp_mid *mid) |
| { |
| struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp; |
| int err = 0; |
| |
| clear_bit(mlxsw_sp_port->local_port, mid->ports_in_mid); |
| if (bitmap_empty(mid->ports_in_mid, |
| mlxsw_core_max_ports(mlxsw_sp->core))) { |
| err = mlxsw_sp_mc_remove_mdb_entry(mlxsw_sp, mid); |
| list_del(&mid->list); |
| kfree(mid->ports_in_mid); |
| kfree(mid); |
| } |
| return err; |
| } |
| |
| static int mlxsw_sp_port_mdb_add(struct mlxsw_sp_port *mlxsw_sp_port, |
| const struct switchdev_obj_port_mdb *mdb, |
| struct switchdev_trans *trans) |
| { |
| struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp; |
| struct net_device *orig_dev = mdb->obj.orig_dev; |
| struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan; |
| struct net_device *dev = mlxsw_sp_port->dev; |
| struct mlxsw_sp_bridge_device *bridge_device; |
| struct mlxsw_sp_bridge_port *bridge_port; |
| struct mlxsw_sp_mid *mid; |
| u16 fid_index; |
| int err = 0; |
| |
| if (switchdev_trans_ph_prepare(trans)) |
| return 0; |
| |
| bridge_port = mlxsw_sp_bridge_port_find(mlxsw_sp->bridge, orig_dev); |
| if (!bridge_port) |
| return 0; |
| |
| bridge_device = bridge_port->bridge_device; |
| mlxsw_sp_port_vlan = mlxsw_sp_port_vlan_find_by_bridge(mlxsw_sp_port, |
| bridge_device, |
| mdb->vid); |
| if (!mlxsw_sp_port_vlan) |
| return 0; |
| |
| fid_index = mlxsw_sp_fid_index(mlxsw_sp_port_vlan->fid); |
| |
| mid = __mlxsw_sp_mc_get(bridge_device, mdb->addr, fid_index); |
| if (!mid) { |
| mid = __mlxsw_sp_mc_alloc(mlxsw_sp, bridge_device, mdb->addr, |
| fid_index); |
| if (!mid) { |
| netdev_err(dev, "Unable to allocate MC group\n"); |
| return -ENOMEM; |
| } |
| } |
| set_bit(mlxsw_sp_port->local_port, mid->ports_in_mid); |
| |
| if (!bridge_device->multicast_enabled) |
| return 0; |
| |
| if (bridge_port->mrouter) |
| return 0; |
| |
| err = mlxsw_sp_port_smid_set(mlxsw_sp_port, mid->mid, true); |
| if (err) { |
| netdev_err(dev, "Unable to set SMID\n"); |
| goto err_out; |
| } |
| |
| return 0; |
| |
| err_out: |
| mlxsw_sp_port_remove_from_mid(mlxsw_sp_port, mid); |
| return err; |
| } |
| |
| static void |
| mlxsw_sp_bridge_mdb_mc_enable_sync(struct mlxsw_sp_port *mlxsw_sp_port, |
| struct mlxsw_sp_bridge_device |
| *bridge_device) |
| { |
| struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp; |
| struct mlxsw_sp_mid *mid; |
| bool mc_enabled; |
| |
| mc_enabled = bridge_device->multicast_enabled; |
| |
| list_for_each_entry(mid, &bridge_device->mids_list, list) { |
| if (mc_enabled) |
| mlxsw_sp_mc_write_mdb_entry(mlxsw_sp, mid, |
| bridge_device); |
| else |
| mlxsw_sp_mc_remove_mdb_entry(mlxsw_sp, mid); |
| } |
| } |
| |
| static void |
| mlxsw_sp_port_mrouter_update_mdb(struct mlxsw_sp_port *mlxsw_sp_port, |
| struct mlxsw_sp_bridge_port *bridge_port, |
| bool add) |
| { |
| struct mlxsw_sp_bridge_device *bridge_device; |
| struct mlxsw_sp_mid *mid; |
| |
| bridge_device = bridge_port->bridge_device; |
| |
| list_for_each_entry(mid, &bridge_device->mids_list, list) { |
| if (!test_bit(mlxsw_sp_port->local_port, mid->ports_in_mid)) |
| mlxsw_sp_port_smid_set(mlxsw_sp_port, mid->mid, add); |
| } |
| } |
| |
| struct mlxsw_sp_span_respin_work { |
| struct work_struct work; |
| struct mlxsw_sp *mlxsw_sp; |
| }; |
| |
| static void mlxsw_sp_span_respin_work(struct work_struct *work) |
| { |
| struct mlxsw_sp_span_respin_work *respin_work = |
| container_of(work, struct mlxsw_sp_span_respin_work, work); |
| |
| rtnl_lock(); |
| mlxsw_sp_span_respin(respin_work->mlxsw_sp); |
| rtnl_unlock(); |
| kfree(respin_work); |
| } |
| |
| static void mlxsw_sp_span_respin_schedule(struct mlxsw_sp *mlxsw_sp) |
| { |
| struct mlxsw_sp_span_respin_work *respin_work; |
| |
| respin_work = kzalloc(sizeof(*respin_work), GFP_ATOMIC); |
| if (!respin_work) |
| return; |
| |
| INIT_WORK(&respin_work->work, mlxsw_sp_span_respin_work); |
| respin_work->mlxsw_sp = mlxsw_sp; |
| |
| mlxsw_core_schedule_work(&respin_work->work); |
| } |
| |
| static int mlxsw_sp_port_obj_add(struct net_device *dev, |
| const struct switchdev_obj *obj, |
| struct switchdev_trans *trans, |
| struct netlink_ext_ack *extack) |
| { |
| struct mlxsw_sp_port *mlxsw_sp_port = netdev_priv(dev); |
| const struct switchdev_obj_port_vlan *vlan; |
| int err = 0; |
| |
| switch (obj->id) { |
| case SWITCHDEV_OBJ_ID_PORT_VLAN: |
| vlan = SWITCHDEV_OBJ_PORT_VLAN(obj); |
| err = mlxsw_sp_port_vlans_add(mlxsw_sp_port, vlan, trans, |
| extack); |
| |
| if (switchdev_trans_ph_prepare(trans)) { |
| /* The event is emitted before the changes are actually |
| * applied to the bridge. Therefore schedule the respin |
| * call for later, so that the respin logic sees the |
| * updated bridge state. |
| */ |
| mlxsw_sp_span_respin_schedule(mlxsw_sp_port->mlxsw_sp); |
| } |
| break; |
| case SWITCHDEV_OBJ_ID_PORT_MDB: |
| err = mlxsw_sp_port_mdb_add(mlxsw_sp_port, |
| SWITCHDEV_OBJ_PORT_MDB(obj), |
| trans); |
| break; |
| default: |
| err = -EOPNOTSUPP; |
| break; |
| } |
| |
| return err; |
| } |
| |
| static void |
| mlxsw_sp_bridge_port_vlan_del(struct mlxsw_sp_port *mlxsw_sp_port, |
| struct mlxsw_sp_bridge_port *bridge_port, u16 vid) |
| { |
| u16 pvid = mlxsw_sp_port->pvid == vid ? 0 : mlxsw_sp_port->pvid; |
| struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan; |
| |
| mlxsw_sp_port_vlan = mlxsw_sp_port_vlan_find_by_vid(mlxsw_sp_port, vid); |
| if (WARN_ON(!mlxsw_sp_port_vlan)) |
| return; |
| |
| mlxsw_sp_port_vlan_bridge_leave(mlxsw_sp_port_vlan); |
| mlxsw_sp_port_pvid_set(mlxsw_sp_port, pvid); |
| mlxsw_sp_port_vlan_set(mlxsw_sp_port, vid, vid, false, false); |
| mlxsw_sp_port_vlan_destroy(mlxsw_sp_port_vlan); |
| } |
| |
| static int mlxsw_sp_port_vlans_del(struct mlxsw_sp_port *mlxsw_sp_port, |
| const struct switchdev_obj_port_vlan *vlan) |
| { |
| struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp; |
| struct net_device *orig_dev = vlan->obj.orig_dev; |
| struct mlxsw_sp_bridge_port *bridge_port; |
| u16 vid; |
| |
| if (netif_is_bridge_master(orig_dev)) |
| return -EOPNOTSUPP; |
| |
| bridge_port = mlxsw_sp_bridge_port_find(mlxsw_sp->bridge, orig_dev); |
| if (WARN_ON(!bridge_port)) |
| return -EINVAL; |
| |
| if (!bridge_port->bridge_device->vlan_enabled) |
| return 0; |
| |
| for (vid = vlan->vid_begin; vid <= vlan->vid_end; vid++) |
| mlxsw_sp_bridge_port_vlan_del(mlxsw_sp_port, bridge_port, vid); |
| |
| return 0; |
| } |
| |
| static int |
| __mlxsw_sp_port_mdb_del(struct mlxsw_sp_port *mlxsw_sp_port, |
| struct mlxsw_sp_bridge_port *bridge_port, |
| struct mlxsw_sp_mid *mid) |
| { |
| struct net_device *dev = mlxsw_sp_port->dev; |
| int err; |
| |
| if (bridge_port->bridge_device->multicast_enabled && |
| !bridge_port->mrouter) { |
| err = mlxsw_sp_port_smid_set(mlxsw_sp_port, mid->mid, false); |
| if (err) |
| netdev_err(dev, "Unable to remove port from SMID\n"); |
| } |
| |
| err = mlxsw_sp_port_remove_from_mid(mlxsw_sp_port, mid); |
| if (err) |
| netdev_err(dev, "Unable to remove MC SFD\n"); |
| |
| return err; |
| } |
| |
| static int mlxsw_sp_port_mdb_del(struct mlxsw_sp_port *mlxsw_sp_port, |
| const struct switchdev_obj_port_mdb *mdb) |
| { |
| struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp; |
| struct net_device *orig_dev = mdb->obj.orig_dev; |
| struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan; |
| struct mlxsw_sp_bridge_device *bridge_device; |
| struct net_device *dev = mlxsw_sp_port->dev; |
| struct mlxsw_sp_bridge_port *bridge_port; |
| struct mlxsw_sp_mid *mid; |
| u16 fid_index; |
| |
| bridge_port = mlxsw_sp_bridge_port_find(mlxsw_sp->bridge, orig_dev); |
| if (!bridge_port) |
| return 0; |
| |
| bridge_device = bridge_port->bridge_device; |
| mlxsw_sp_port_vlan = mlxsw_sp_port_vlan_find_by_bridge(mlxsw_sp_port, |
| bridge_device, |
| mdb->vid); |
| if (!mlxsw_sp_port_vlan) |
| return 0; |
| |
| fid_index = mlxsw_sp_fid_index(mlxsw_sp_port_vlan->fid); |
| |
| mid = __mlxsw_sp_mc_get(bridge_device, mdb->addr, fid_index); |
| if (!mid) { |
| netdev_err(dev, "Unable to remove port from MC DB\n"); |
| return -EINVAL; |
| } |
| |
| return __mlxsw_sp_port_mdb_del(mlxsw_sp_port, bridge_port, mid); |
| } |
| |
| static void |
| mlxsw_sp_bridge_port_mdb_flush(struct mlxsw_sp_port *mlxsw_sp_port, |
| struct mlxsw_sp_bridge_port *bridge_port) |
| { |
| struct mlxsw_sp_bridge_device *bridge_device; |
| struct mlxsw_sp_mid *mid, *tmp; |
| |
| bridge_device = bridge_port->bridge_device; |
| |
| list_for_each_entry_safe(mid, tmp, &bridge_device->mids_list, list) { |
| if (test_bit(mlxsw_sp_port->local_port, mid->ports_in_mid)) { |
| __mlxsw_sp_port_mdb_del(mlxsw_sp_port, bridge_port, |
| mid); |
| } else if (bridge_device->multicast_enabled && |
| bridge_port->mrouter) { |
| mlxsw_sp_port_smid_set(mlxsw_sp_port, mid->mid, false); |
| } |
| } |
| } |
| |
| static int mlxsw_sp_port_obj_del(struct net_device *dev, |
| const struct switchdev_obj *obj) |
| { |
| struct mlxsw_sp_port *mlxsw_sp_port = netdev_priv(dev); |
| int err = 0; |
| |
| switch (obj->id) { |
| case SWITCHDEV_OBJ_ID_PORT_VLAN: |
| err = mlxsw_sp_port_vlans_del(mlxsw_sp_port, |
| SWITCHDEV_OBJ_PORT_VLAN(obj)); |
| break; |
| case SWITCHDEV_OBJ_ID_PORT_MDB: |
| err = mlxsw_sp_port_mdb_del(mlxsw_sp_port, |
| SWITCHDEV_OBJ_PORT_MDB(obj)); |
| break; |
| default: |
| err = -EOPNOTSUPP; |
| break; |
| } |
| |
| mlxsw_sp_span_respin_schedule(mlxsw_sp_port->mlxsw_sp); |
| |
| return err; |
| } |
| |
| static struct mlxsw_sp_port *mlxsw_sp_lag_rep_port(struct mlxsw_sp *mlxsw_sp, |
| u16 lag_id) |
| { |
| struct mlxsw_sp_port *mlxsw_sp_port; |
| u64 max_lag_members; |
| int i; |
| |
| max_lag_members = MLXSW_CORE_RES_GET(mlxsw_sp->core, |
| MAX_LAG_MEMBERS); |
| for (i = 0; i < max_lag_members; i++) { |
| mlxsw_sp_port = mlxsw_sp_port_lagged_get(mlxsw_sp, lag_id, i); |
| if (mlxsw_sp_port) |
| return mlxsw_sp_port; |
| } |
| return NULL; |
| } |
| |
| static const struct switchdev_ops mlxsw_sp_port_switchdev_ops = { |
| .switchdev_port_attr_get = mlxsw_sp_port_attr_get, |
| .switchdev_port_attr_set = mlxsw_sp_port_attr_set, |
| }; |
| |
| static int |
| mlxsw_sp_bridge_8021q_port_join(struct mlxsw_sp_bridge_device *bridge_device, |
| struct mlxsw_sp_bridge_port *bridge_port, |
| struct mlxsw_sp_port *mlxsw_sp_port, |
| struct netlink_ext_ack *extack) |
| { |
| if (is_vlan_dev(bridge_port->dev)) { |
| NL_SET_ERR_MSG_MOD(extack, "Can not enslave a VLAN device to a VLAN-aware bridge"); |
| return -EINVAL; |
| } |
| |
| /* Port is no longer usable as a router interface */ |
| if (mlxsw_sp_port->default_vlan->fid) |
| mlxsw_sp_port_vlan_router_leave(mlxsw_sp_port->default_vlan); |
| |
| return 0; |
| } |
| |
| static void |
| mlxsw_sp_bridge_8021q_port_leave(struct mlxsw_sp_bridge_device *bridge_device, |
| struct mlxsw_sp_bridge_port *bridge_port, |
| struct mlxsw_sp_port *mlxsw_sp_port) |
| { |
| /* Make sure untagged frames are allowed to ingress */ |
| mlxsw_sp_port_pvid_set(mlxsw_sp_port, MLXSW_SP_DEFAULT_VID); |
| } |
| |
| static int |
| mlxsw_sp_bridge_8021q_vxlan_join(struct mlxsw_sp_bridge_device *bridge_device, |
| const struct net_device *vxlan_dev, u16 vid, |
| struct netlink_ext_ack *extack) |
| { |
| struct mlxsw_sp *mlxsw_sp = mlxsw_sp_lower_get(bridge_device->dev); |
| struct vxlan_dev *vxlan = netdev_priv(vxlan_dev); |
| struct mlxsw_sp_nve_params params = { |
| .type = MLXSW_SP_NVE_TYPE_VXLAN, |
| .vni = vxlan->cfg.vni, |
| .dev = vxlan_dev, |
| }; |
| struct mlxsw_sp_fid *fid; |
| int err; |
| |
| /* If the VLAN is 0, we need to find the VLAN that is configured as |
| * PVID and egress untagged on the bridge port of the VxLAN device. |
| * It is possible no such VLAN exists |
| */ |
| if (!vid) { |
| err = mlxsw_sp_vxlan_mapped_vid(vxlan_dev, &vid); |
| if (err || !vid) |
| return err; |
| } |
| |
| /* If no other port is member in the VLAN, then the FID does not exist. |
| * NVE will be enabled on the FID once a port joins the VLAN |
| */ |
| fid = mlxsw_sp_fid_8021q_lookup(mlxsw_sp, vid); |
| if (!fid) |
| return 0; |
| |
| if (mlxsw_sp_fid_vni_is_set(fid)) { |
| err = -EINVAL; |
| goto err_vni_exists; |
| } |
| |
| err = mlxsw_sp_nve_fid_enable(mlxsw_sp, fid, ¶ms, extack); |
| if (err) |
| goto err_nve_fid_enable; |
| |
| /* The tunnel port does not hold a reference on the FID. Only |
| * local ports and the router port |
| */ |
| mlxsw_sp_fid_put(fid); |
| |
| return 0; |
| |
| err_nve_fid_enable: |
| err_vni_exists: |
| mlxsw_sp_fid_put(fid); |
| return err; |
| } |
| |
| static struct net_device * |
| mlxsw_sp_bridge_8021q_vxlan_dev_find(struct net_device *br_dev, u16 vid) |
| { |
| struct net_device *dev; |
| struct list_head *iter; |
| |
| netdev_for_each_lower_dev(br_dev, dev, iter) { |
| u16 pvid; |
| int err; |
| |
| if (!netif_is_vxlan(dev)) |
| continue; |
| |
| err = mlxsw_sp_vxlan_mapped_vid(dev, &pvid); |
| if (err || pvid != vid) |
| continue; |
| |
| return dev; |
| } |
| |
| return NULL; |
| } |
| |
| static struct mlxsw_sp_fid * |
| mlxsw_sp_bridge_8021q_fid_get(struct mlxsw_sp_bridge_device *bridge_device, |
| u16 vid, struct netlink_ext_ack *extack) |
| { |
| struct mlxsw_sp *mlxsw_sp = mlxsw_sp_lower_get(bridge_device->dev); |
| struct net_device *vxlan_dev; |
| struct mlxsw_sp_fid *fid; |
| int err; |
| |
| fid = mlxsw_sp_fid_8021q_get(mlxsw_sp, vid); |
| if (IS_ERR(fid)) |
| return fid; |
| |
| if (mlxsw_sp_fid_vni_is_set(fid)) |
| return fid; |
| |
| /* Find the VxLAN device that has the specified VLAN configured as |
| * PVID and egress untagged. There can be at most one such device |
| */ |
| vxlan_dev = mlxsw_sp_bridge_8021q_vxlan_dev_find(bridge_device->dev, |
| vid); |
| if (!vxlan_dev) |
| return fid; |
| |
| if (!netif_running(vxlan_dev)) |
| return fid; |
| |
| err = mlxsw_sp_bridge_8021q_vxlan_join(bridge_device, vxlan_dev, vid, |
| extack); |
| if (err) |
| goto err_vxlan_join; |
| |
| return fid; |
| |
| err_vxlan_join: |
| mlxsw_sp_fid_put(fid); |
| return ERR_PTR(err); |
| } |
| |
| static struct mlxsw_sp_fid * |
| mlxsw_sp_bridge_8021q_fid_lookup(struct mlxsw_sp_bridge_device *bridge_device, |
| u16 vid) |
| { |
| struct mlxsw_sp *mlxsw_sp = mlxsw_sp_lower_get(bridge_device->dev); |
| |
| return mlxsw_sp_fid_8021q_lookup(mlxsw_sp, vid); |
| } |
| |
| static u16 |
| mlxsw_sp_bridge_8021q_fid_vid(struct mlxsw_sp_bridge_device *bridge_device, |
| const struct mlxsw_sp_fid *fid) |
| { |
| return mlxsw_sp_fid_8021q_vid(fid); |
| } |
| |
| static const struct mlxsw_sp_bridge_ops mlxsw_sp_bridge_8021q_ops = { |
| .port_join = mlxsw_sp_bridge_8021q_port_join, |
| .port_leave = mlxsw_sp_bridge_8021q_port_leave, |
| .vxlan_join = mlxsw_sp_bridge_8021q_vxlan_join, |
| .fid_get = mlxsw_sp_bridge_8021q_fid_get, |
| .fid_lookup = mlxsw_sp_bridge_8021q_fid_lookup, |
| .fid_vid = mlxsw_sp_bridge_8021q_fid_vid, |
| }; |
| |
| static bool |
| mlxsw_sp_port_is_br_member(const struct mlxsw_sp_port *mlxsw_sp_port, |
| const struct net_device *br_dev) |
| { |
| struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan; |
| |
| list_for_each_entry(mlxsw_sp_port_vlan, &mlxsw_sp_port->vlans_list, |
| list) { |
| if (mlxsw_sp_port_vlan->bridge_port && |
| mlxsw_sp_port_vlan->bridge_port->bridge_device->dev == |
| br_dev) |
| return true; |
| } |
| |
| return false; |
| } |
| |
| static int |
| mlxsw_sp_bridge_8021d_port_join(struct mlxsw_sp_bridge_device *bridge_device, |
| struct mlxsw_sp_bridge_port *bridge_port, |
| struct mlxsw_sp_port *mlxsw_sp_port, |
| struct netlink_ext_ack *extack) |
| { |
| struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan; |
| struct net_device *dev = bridge_port->dev; |
| u16 vid; |
| |
| vid = is_vlan_dev(dev) ? vlan_dev_vlan_id(dev) : MLXSW_SP_DEFAULT_VID; |
| mlxsw_sp_port_vlan = mlxsw_sp_port_vlan_find_by_vid(mlxsw_sp_port, vid); |
| if (WARN_ON(!mlxsw_sp_port_vlan)) |
| return -EINVAL; |
| |
| if (mlxsw_sp_port_is_br_member(mlxsw_sp_port, bridge_device->dev)) { |
| NL_SET_ERR_MSG_MOD(extack, "Can not bridge VLAN uppers of the same port"); |
| return -EINVAL; |
| } |
| |
| /* Port is no longer usable as a router interface */ |
| if (mlxsw_sp_port_vlan->fid) |
| mlxsw_sp_port_vlan_router_leave(mlxsw_sp_port_vlan); |
| |
| return mlxsw_sp_port_vlan_bridge_join(mlxsw_sp_port_vlan, bridge_port, |
| extack); |
| } |
| |
| static void |
| mlxsw_sp_bridge_8021d_port_leave(struct mlxsw_sp_bridge_device *bridge_device, |
| struct mlxsw_sp_bridge_port *bridge_port, |
| struct mlxsw_sp_port *mlxsw_sp_port) |
| { |
| struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan; |
| struct net_device *dev = bridge_port->dev; |
| u16 vid; |
| |
| vid = is_vlan_dev(dev) ? vlan_dev_vlan_id(dev) : MLXSW_SP_DEFAULT_VID; |
| mlxsw_sp_port_vlan = mlxsw_sp_port_vlan_find_by_vid(mlxsw_sp_port, vid); |
| if (!mlxsw_sp_port_vlan || !mlxsw_sp_port_vlan->bridge_port) |
| return; |
| |
| mlxsw_sp_port_vlan_bridge_leave(mlxsw_sp_port_vlan); |
| } |
| |
| static int |
| mlxsw_sp_bridge_8021d_vxlan_join(struct mlxsw_sp_bridge_device *bridge_device, |
| const struct net_device *vxlan_dev, u16 vid, |
| struct netlink_ext_ack *extack) |
| { |
| struct mlxsw_sp *mlxsw_sp = mlxsw_sp_lower_get(bridge_device->dev); |
| struct vxlan_dev *vxlan = netdev_priv(vxlan_dev); |
| struct mlxsw_sp_nve_params params = { |
| .type = MLXSW_SP_NVE_TYPE_VXLAN, |
| .vni = vxlan->cfg.vni, |
| .dev = vxlan_dev, |
| }; |
| struct mlxsw_sp_fid *fid; |
| int err; |
| |
| fid = mlxsw_sp_fid_8021d_lookup(mlxsw_sp, bridge_device->dev->ifindex); |
| if (!fid) |
| return -EINVAL; |
| |
| if (mlxsw_sp_fid_vni_is_set(fid)) { |
| err = -EINVAL; |
| goto err_vni_exists; |
| } |
| |
| err = mlxsw_sp_nve_fid_enable(mlxsw_sp, fid, ¶ms, extack); |
| if (err) |
| goto err_nve_fid_enable; |
| |
| /* The tunnel port does not hold a reference on the FID. Only |
| * local ports and the router port |
| */ |
| mlxsw_sp_fid_put(fid); |
| |
| return 0; |
| |
| err_nve_fid_enable: |
| err_vni_exists: |
| mlxsw_sp_fid_put(fid); |
| return err; |
| } |
| |
| static struct mlxsw_sp_fid * |
| mlxsw_sp_bridge_8021d_fid_get(struct mlxsw_sp_bridge_device *bridge_device, |
| u16 vid, struct netlink_ext_ack *extack) |
| { |
| struct mlxsw_sp *mlxsw_sp = mlxsw_sp_lower_get(bridge_device->dev); |
| struct net_device *vxlan_dev; |
| struct mlxsw_sp_fid *fid; |
| int err; |
| |
| fid = mlxsw_sp_fid_8021d_get(mlxsw_sp, bridge_device->dev->ifindex); |
| if (IS_ERR(fid)) |
| return fid; |
| |
| if (mlxsw_sp_fid_vni_is_set(fid)) |
| return fid; |
| |
| vxlan_dev = mlxsw_sp_bridge_vxlan_dev_find(bridge_device->dev); |
| if (!vxlan_dev) |
| return fid; |
| |
| if (!netif_running(vxlan_dev)) |
| return fid; |
| |
| err = mlxsw_sp_bridge_8021d_vxlan_join(bridge_device, vxlan_dev, 0, |
| extack); |
| if (err) |
| goto err_vxlan_join; |
| |
| return fid; |
| |
| err_vxlan_join: |
| mlxsw_sp_fid_put(fid); |
| return ERR_PTR(err); |
| } |
| |
| static struct mlxsw_sp_fid * |
| mlxsw_sp_bridge_8021d_fid_lookup(struct mlxsw_sp_bridge_device *bridge_device, |
| u16 vid) |
| { |
| struct mlxsw_sp *mlxsw_sp = mlxsw_sp_lower_get(bridge_device->dev); |
| |
| /* The only valid VLAN for a VLAN-unaware bridge is 0 */ |
| if (vid) |
| return NULL; |
| |
| return mlxsw_sp_fid_8021d_lookup(mlxsw_sp, bridge_device->dev->ifindex); |
| } |
| |
| static u16 |
| mlxsw_sp_bridge_8021d_fid_vid(struct mlxsw_sp_bridge_device *bridge_device, |
| const struct mlxsw_sp_fid *fid) |
| { |
| return 0; |
| } |
| |
| static const struct mlxsw_sp_bridge_ops mlxsw_sp_bridge_8021d_ops = { |
| .port_join = mlxsw_sp_bridge_8021d_port_join, |
| .port_leave = mlxsw_sp_bridge_8021d_port_leave, |
| .vxlan_join = mlxsw_sp_bridge_8021d_vxlan_join, |
| .fid_get = mlxsw_sp_bridge_8021d_fid_get, |
| .fid_lookup = mlxsw_sp_bridge_8021d_fid_lookup, |
| .fid_vid = mlxsw_sp_bridge_8021d_fid_vid, |
| }; |
| |
| int mlxsw_sp_port_bridge_join(struct mlxsw_sp_port *mlxsw_sp_port, |
| struct net_device *brport_dev, |
| struct net_device *br_dev, |
| struct netlink_ext_ack *extack) |
| { |
| struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp; |
| struct mlxsw_sp_bridge_device *bridge_device; |
| struct mlxsw_sp_bridge_port *bridge_port; |
| int err; |
| |
| bridge_port = mlxsw_sp_bridge_port_get(mlxsw_sp->bridge, brport_dev); |
| if (IS_ERR(bridge_port)) |
| return PTR_ERR(bridge_port); |
| bridge_device = bridge_port->bridge_device; |
| |
| err = bridge_device->ops->port_join(bridge_device, bridge_port, |
| mlxsw_sp_port, extack); |
| if (err) |
| goto err_port_join; |
| |
| return 0; |
| |
| err_port_join: |
| mlxsw_sp_bridge_port_put(mlxsw_sp->bridge, bridge_port); |
| return err; |
| } |
| |
| void mlxsw_sp_port_bridge_leave(struct mlxsw_sp_port *mlxsw_sp_port, |
| struct net_device *brport_dev, |
| struct net_device *br_dev) |
| { |
| struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp; |
| struct mlxsw_sp_bridge_device *bridge_device; |
| struct mlxsw_sp_bridge_port *bridge_port; |
| |
| bridge_device = mlxsw_sp_bridge_device_find(mlxsw_sp->bridge, br_dev); |
| if (!bridge_device) |
| return; |
| bridge_port = __mlxsw_sp_bridge_port_find(bridge_device, brport_dev); |
| if (!bridge_port) |
| return; |
| |
| bridge_device->ops->port_leave(bridge_device, bridge_port, |
| mlxsw_sp_port); |
| mlxsw_sp_bridge_port_put(mlxsw_sp->bridge, bridge_port); |
| } |
| |
| int mlxsw_sp_bridge_vxlan_join(struct mlxsw_sp *mlxsw_sp, |
| const struct net_device *br_dev, |
| const struct net_device *vxlan_dev, u16 vid, |
| struct netlink_ext_ack *extack) |
| { |
| struct mlxsw_sp_bridge_device *bridge_device; |
| |
| bridge_device = mlxsw_sp_bridge_device_find(mlxsw_sp->bridge, br_dev); |
| if (WARN_ON(!bridge_device)) |
| return -EINVAL; |
| |
| return bridge_device->ops->vxlan_join(bridge_device, vxlan_dev, vid, |
| extack); |
| } |
| |
| void mlxsw_sp_bridge_vxlan_leave(struct mlxsw_sp *mlxsw_sp, |
| const struct net_device *vxlan_dev) |
| { |
| struct vxlan_dev *vxlan = netdev_priv(vxlan_dev); |
| struct mlxsw_sp_fid *fid; |
| |
| /* If the VxLAN device is down, then the FID does not have a VNI */ |
| fid = mlxsw_sp_fid_lookup_by_vni(mlxsw_sp, vxlan->cfg.vni); |
| if (!fid) |
| return; |
| |
| mlxsw_sp_nve_fid_disable(mlxsw_sp, fid); |
| mlxsw_sp_fid_put(fid); |
| } |
| |
| struct mlxsw_sp_fid *mlxsw_sp_bridge_fid_get(struct mlxsw_sp *mlxsw_sp, |
| const struct net_device *br_dev, |
| u16 vid, |
| struct netlink_ext_ack *extack) |
| { |
| struct mlxsw_sp_bridge_device *bridge_device; |
| |
| bridge_device = mlxsw_sp_bridge_device_find(mlxsw_sp->bridge, br_dev); |
| if (WARN_ON(!bridge_device)) |
| return ERR_PTR(-EINVAL); |
| |
| return bridge_device->ops->fid_get(bridge_device, vid, extack); |
| } |
| |
| static void |
| mlxsw_sp_switchdev_vxlan_addr_convert(const union vxlan_addr *vxlan_addr, |
| enum mlxsw_sp_l3proto *proto, |
| union mlxsw_sp_l3addr *addr) |
| { |
| if (vxlan_addr->sa.sa_family == AF_INET) { |
| addr->addr4 = vxlan_addr->sin.sin_addr.s_addr; |
| *proto = MLXSW_SP_L3_PROTO_IPV4; |
| } else { |
| addr->addr6 = vxlan_addr->sin6.sin6_addr; |
| *proto = MLXSW_SP_L3_PROTO_IPV6; |
| } |
| } |
| |
| static void |
| mlxsw_sp_switchdev_addr_vxlan_convert(enum mlxsw_sp_l3proto proto, |
| const union mlxsw_sp_l3addr *addr, |
| union vxlan_addr *vxlan_addr) |
| { |
| switch (proto) { |
| case MLXSW_SP_L3_PROTO_IPV4: |
| vxlan_addr->sa.sa_family = AF_INET; |
| vxlan_addr->sin.sin_addr.s_addr = addr->addr4; |
| break; |
| case MLXSW_SP_L3_PROTO_IPV6: |
| vxlan_addr->sa.sa_family = AF_INET6; |
| vxlan_addr->sin6.sin6_addr = addr->addr6; |
| break; |
| } |
| } |
| |
| static void mlxsw_sp_fdb_vxlan_call_notifiers(struct net_device *dev, |
| const char *mac, |
| enum mlxsw_sp_l3proto proto, |
| union mlxsw_sp_l3addr *addr, |
| __be32 vni, bool adding) |
| { |
| struct switchdev_notifier_vxlan_fdb_info info; |
| struct vxlan_dev *vxlan = netdev_priv(dev); |
| enum switchdev_notifier_type type; |
| |
| type = adding ? SWITCHDEV_VXLAN_FDB_ADD_TO_BRIDGE : |
| SWITCHDEV_VXLAN_FDB_DEL_TO_BRIDGE; |
| mlxsw_sp_switchdev_addr_vxlan_convert(proto, addr, &info.remote_ip); |
| info.remote_port = vxlan->cfg.dst_port; |
| info.remote_vni = vni; |
| info.remote_ifindex = 0; |
| ether_addr_copy(info.eth_addr, mac); |
| info.vni = vni; |
| info.offloaded = adding; |
| call_switchdev_notifiers(type, dev, &info.info); |
| } |
| |
| static void mlxsw_sp_fdb_nve_call_notifiers(struct net_device *dev, |
| const char *mac, |
| enum mlxsw_sp_l3proto proto, |
| union mlxsw_sp_l3addr *addr, |
| __be32 vni, |
| bool adding) |
| { |
| if (netif_is_vxlan(dev)) |
| mlxsw_sp_fdb_vxlan_call_notifiers(dev, mac, proto, addr, vni, |
| adding); |
| } |
| |
| static void |
| mlxsw_sp_fdb_call_notifiers(enum switchdev_notifier_type type, |
| const char *mac, u16 vid, |
| struct net_device *dev, bool offloaded) |
| { |
| struct switchdev_notifier_fdb_info info; |
| |
| info.addr = mac; |
| info.vid = vid; |
| info.offloaded = offloaded; |
| call_switchdev_notifiers(type, dev, &info.info); |
| } |
| |
| static void mlxsw_sp_fdb_notify_mac_process(struct mlxsw_sp *mlxsw_sp, |
| char *sfn_pl, int rec_index, |
| bool adding) |
| { |
| struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan; |
| struct mlxsw_sp_bridge_device *bridge_device; |
| struct mlxsw_sp_bridge_port *bridge_port; |
| struct mlxsw_sp_port *mlxsw_sp_port; |
| enum switchdev_notifier_type type; |
| char mac[ETH_ALEN]; |
| u8 local_port; |
| u16 vid, fid; |
| bool do_notification = true; |
| int err; |
| |
| mlxsw_reg_sfn_mac_unpack(sfn_pl, rec_index, mac, &fid, &local_port); |
| mlxsw_sp_port = mlxsw_sp->ports[local_port]; |
| if (!mlxsw_sp_port) { |
| dev_err_ratelimited(mlxsw_sp->bus_info->dev, "Incorrect local port in FDB notification\n"); |
| goto just_remove; |
| } |
| |
| mlxsw_sp_port_vlan = mlxsw_sp_port_vlan_find_by_fid(mlxsw_sp_port, fid); |
| if (!mlxsw_sp_port_vlan) { |
| netdev_err(mlxsw_sp_port->dev, "Failed to find a matching {Port, VID} following FDB notification\n"); |
| goto just_remove; |
| } |
| |
| bridge_port = mlxsw_sp_port_vlan->bridge_port; |
| if (!bridge_port) { |
| netdev_err(mlxsw_sp_port->dev, "{Port, VID} not associated with a bridge\n"); |
| goto just_remove; |
| } |
| |
| bridge_device = bridge_port->bridge_device; |
| vid = bridge_device->vlan_enabled ? mlxsw_sp_port_vlan->vid : 0; |
| |
| do_fdb_op: |
| err = mlxsw_sp_port_fdb_uc_op(mlxsw_sp, local_port, mac, fid, |
| adding, true); |
| if (err) { |
| dev_err_ratelimited(mlxsw_sp->bus_info->dev, "Failed to set FDB entry\n"); |
| return; |
| } |
| |
| if (!do_notification) |
| return; |
| type = adding ? SWITCHDEV_FDB_ADD_TO_BRIDGE : SWITCHDEV_FDB_DEL_TO_BRIDGE; |
| mlxsw_sp_fdb_call_notifiers(type, mac, vid, bridge_port->dev, adding); |
| |
| return; |
| |
| just_remove: |
| adding = false; |
| do_notification = false; |
| goto do_fdb_op; |
| } |
| |
| static void mlxsw_sp_fdb_notify_mac_lag_process(struct mlxsw_sp *mlxsw_sp, |
| char *sfn_pl, int rec_index, |
| bool adding) |
| { |
| struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan; |
| struct mlxsw_sp_bridge_device *bridge_device; |
| struct mlxsw_sp_bridge_port *bridge_port; |
| struct mlxsw_sp_port *mlxsw_sp_port; |
| enum switchdev_notifier_type type; |
| char mac[ETH_ALEN]; |
| u16 lag_vid = 0; |
| u16 lag_id; |
| u16 vid, fid; |
| bool do_notification = true; |
| int err; |
| |
| mlxsw_reg_sfn_mac_lag_unpack(sfn_pl, rec_index, mac, &fid, &lag_id); |
| mlxsw_sp_port = mlxsw_sp_lag_rep_port(mlxsw_sp, lag_id); |
| if (!mlxsw_sp_port) { |
| dev_err_ratelimited(mlxsw_sp->bus_info->dev, "Cannot find port representor for LAG\n"); |
| goto just_remove; |
| } |
| |
| mlxsw_sp_port_vlan = mlxsw_sp_port_vlan_find_by_fid(mlxsw_sp_port, fid); |
| if (!mlxsw_sp_port_vlan) { |
| netdev_err(mlxsw_sp_port->dev, "Failed to find a matching {Port, VID} following FDB notification\n"); |
| goto just_remove; |
| } |
| |
| bridge_port = mlxsw_sp_port_vlan->bridge_port; |
| if (!bridge_port) { |
| netdev_err(mlxsw_sp_port->dev, "{Port, VID} not associated with a bridge\n"); |
| goto just_remove; |
| } |
| |
| bridge_device = bridge_port->bridge_device; |
| vid = bridge_device->vlan_enabled ? mlxsw_sp_port_vlan->vid : 0; |
| lag_vid = mlxsw_sp_fid_lag_vid_valid(mlxsw_sp_port_vlan->fid) ? |
| mlxsw_sp_port_vlan->vid : 0; |
| |
| do_fdb_op: |
| err = mlxsw_sp_port_fdb_uc_lag_op(mlxsw_sp, lag_id, mac, fid, lag_vid, |
| adding, true); |
| if (err) { |
| dev_err_ratelimited(mlxsw_sp->bus_info->dev, "Failed to set FDB entry\n"); |
| return; |
| } |
| |
| if (!do_notification) |
| return; |
| type = adding ? SWITCHDEV_FDB_ADD_TO_BRIDGE : SWITCHDEV_FDB_DEL_TO_BRIDGE; |
| mlxsw_sp_fdb_call_notifiers(type, mac, vid, bridge_port->dev, adding); |
| |
| return; |
| |
| just_remove: |
| adding = false; |
| do_notification = false; |
| goto do_fdb_op; |
| } |
| |
| static int |
| __mlxsw_sp_fdb_notify_mac_uc_tunnel_process(struct mlxsw_sp *mlxsw_sp, |
| const struct mlxsw_sp_fid *fid, |
| bool adding, |
| struct net_device **nve_dev, |
| u16 *p_vid, __be32 *p_vni) |
| { |
| struct mlxsw_sp_bridge_device *bridge_device; |
| struct net_device *br_dev, *dev; |
| int nve_ifindex; |
| int err; |
| |
| err = mlxsw_sp_fid_nve_ifindex(fid, &nve_ifindex); |
| if (err) |
| return err; |
| |
| err = mlxsw_sp_fid_vni(fid, p_vni); |
| if (err) |
| return err; |
| |
| dev = __dev_get_by_index(&init_net, nve_ifindex); |
| if (!dev) |
| return -EINVAL; |
| *nve_dev = dev; |
| |
| if (!netif_running(dev)) |
| return -EINVAL; |
| |
| if (adding && !br_port_flag_is_set(dev, BR_LEARNING)) |
| return -EINVAL; |
| |
| if (adding && netif_is_vxlan(dev)) { |
| struct vxlan_dev *vxlan = netdev_priv(dev); |
| |
| if (!(vxlan->cfg.flags & VXLAN_F_LEARN)) |
| return -EINVAL; |
| } |
| |
| br_dev = netdev_master_upper_dev_get(dev); |
| if (!br_dev) |
| return -EINVAL; |
| |
| bridge_device = mlxsw_sp_bridge_device_find(mlxsw_sp->bridge, br_dev); |
| if (!bridge_device) |
| return -EINVAL; |
| |
| *p_vid = bridge_device->ops->fid_vid(bridge_device, fid); |
| |
| return 0; |
| } |
| |
| static void mlxsw_sp_fdb_notify_mac_uc_tunnel_process(struct mlxsw_sp *mlxsw_sp, |
| char *sfn_pl, |
| int rec_index, |
| bool adding) |
| { |
| enum mlxsw_reg_sfn_uc_tunnel_protocol sfn_proto; |
| enum switchdev_notifier_type type; |
| struct net_device *nve_dev; |
| union mlxsw_sp_l3addr addr; |
| struct mlxsw_sp_fid *fid; |
| char mac[ETH_ALEN]; |
| u16 fid_index, vid; |
| __be32 vni; |
| u32 uip; |
| int err; |
| |
| mlxsw_reg_sfn_uc_tunnel_unpack(sfn_pl, rec_index, mac, &fid_index, |
| &uip, &sfn_proto); |
| |
| fid = mlxsw_sp_fid_lookup_by_index(mlxsw_sp, fid_index); |
| if (!fid) |
| goto err_fid_lookup; |
| |
| err = mlxsw_sp_nve_learned_ip_resolve(mlxsw_sp, uip, |
| (enum mlxsw_sp_l3proto) sfn_proto, |
| &addr); |
| if (err) |
| goto err_ip_resolve; |
| |
| err = __mlxsw_sp_fdb_notify_mac_uc_tunnel_process(mlxsw_sp, fid, adding, |
| &nve_dev, &vid, &vni); |
| if (err) |
| goto err_fdb_process; |
| |
| err = mlxsw_sp_port_fdb_tunnel_uc_op(mlxsw_sp, mac, fid_index, |
| (enum mlxsw_sp_l3proto) sfn_proto, |
| &addr, adding, true); |
| if (err) |
| goto err_fdb_op; |
| |
| mlxsw_sp_fdb_nve_call_notifiers(nve_dev, mac, |
| (enum mlxsw_sp_l3proto) sfn_proto, |
| &addr, vni, adding); |
| |
| type = adding ? SWITCHDEV_FDB_ADD_TO_BRIDGE : |
| SWITCHDEV_FDB_DEL_TO_BRIDGE; |
| mlxsw_sp_fdb_call_notifiers(type, mac, vid, nve_dev, adding); |
| |
| mlxsw_sp_fid_put(fid); |
| |
| return; |
| |
| err_fdb_op: |
| err_fdb_process: |
| err_ip_resolve: |
| mlxsw_sp_fid_put(fid); |
| err_fid_lookup: |
| /* Remove an FDB entry in case we cannot process it. Otherwise the |
| * device will keep sending the same notification over and over again. |
| */ |
| mlxsw_sp_port_fdb_tunnel_uc_op(mlxsw_sp, mac, fid_index, |
| (enum mlxsw_sp_l3proto) sfn_proto, &addr, |
| false, true); |
| } |
| |
| static void mlxsw_sp_fdb_notify_rec_process(struct mlxsw_sp *mlxsw_sp, |
| char *sfn_pl, int rec_index) |
| { |
| switch (mlxsw_reg_sfn_rec_type_get(sfn_pl, rec_index)) { |
| case MLXSW_REG_SFN_REC_TYPE_LEARNED_MAC: |
| mlxsw_sp_fdb_notify_mac_process(mlxsw_sp, sfn_pl, |
| rec_index, true); |
| break; |
| case MLXSW_REG_SFN_REC_TYPE_AGED_OUT_MAC: |
| mlxsw_sp_fdb_notify_mac_process(mlxsw_sp, sfn_pl, |
| rec_index, false); |
| break; |
| case MLXSW_REG_SFN_REC_TYPE_LEARNED_MAC_LAG: |
| mlxsw_sp_fdb_notify_mac_lag_process(mlxsw_sp, sfn_pl, |
| rec_index, true); |
| break; |
| case MLXSW_REG_SFN_REC_TYPE_AGED_OUT_MAC_LAG: |
| mlxsw_sp_fdb_notify_mac_lag_process(mlxsw_sp, sfn_pl, |
| rec_index, false); |
| break; |
| case MLXSW_REG_SFN_REC_TYPE_LEARNED_UNICAST_TUNNEL: |
| mlxsw_sp_fdb_notify_mac_uc_tunnel_process(mlxsw_sp, sfn_pl, |
| rec_index, true); |
| break; |
| case MLXSW_REG_SFN_REC_TYPE_AGED_OUT_UNICAST_TUNNEL: |
| mlxsw_sp_fdb_notify_mac_uc_tunnel_process(mlxsw_sp, sfn_pl, |
| rec_index, false); |
| break; |
| } |
| } |
| |
| static void mlxsw_sp_fdb_notify_work_schedule(struct mlxsw_sp *mlxsw_sp) |
| { |
| struct mlxsw_sp_bridge *bridge = mlxsw_sp->bridge; |
| |
| mlxsw_core_schedule_dw(&bridge->fdb_notify.dw, |
| msecs_to_jiffies(bridge->fdb_notify.interval)); |
| } |
| |
| static void mlxsw_sp_fdb_notify_work(struct work_struct *work) |
| { |
| struct mlxsw_sp_bridge *bridge; |
| struct mlxsw_sp *mlxsw_sp; |
| char *sfn_pl; |
| u8 num_rec; |
| int i; |
| int err; |
| |
| sfn_pl = kmalloc(MLXSW_REG_SFN_LEN, GFP_KERNEL); |
| if (!sfn_pl) |
| return; |
| |
| bridge = container_of(work, struct mlxsw_sp_bridge, fdb_notify.dw.work); |
| mlxsw_sp = bridge->mlxsw_sp; |
| |
| rtnl_lock(); |
| mlxsw_reg_sfn_pack(sfn_pl); |
| err = mlxsw_reg_query(mlxsw_sp->core, MLXSW_REG(sfn), sfn_pl); |
| if (err) { |
| dev_err_ratelimited(mlxsw_sp->bus_info->dev, "Failed to get FDB notifications\n"); |
| goto out; |
| } |
| num_rec = mlxsw_reg_sfn_num_rec_get(sfn_pl); |
| for (i = 0; i < num_rec; i++) |
| mlxsw_sp_fdb_notify_rec_process(mlxsw_sp, sfn_pl, i); |
| |
| out: |
| rtnl_unlock(); |
| kfree(sfn_pl); |
| mlxsw_sp_fdb_notify_work_schedule(mlxsw_sp); |
| } |
| |
| struct mlxsw_sp_switchdev_event_work { |
| struct work_struct work; |
| union { |
| struct switchdev_notifier_fdb_info fdb_info; |
| struct switchdev_notifier_vxlan_fdb_info vxlan_fdb_info; |
| }; |
| struct net_device *dev; |
| unsigned long event; |
| }; |
| |
| static void |
| mlxsw_sp_switchdev_bridge_vxlan_fdb_event(struct mlxsw_sp *mlxsw_sp, |
| struct mlxsw_sp_switchdev_event_work * |
| switchdev_work, |
| struct mlxsw_sp_fid *fid, __be32 vni) |
| { |
| struct switchdev_notifier_vxlan_fdb_info vxlan_fdb_info; |
| struct switchdev_notifier_fdb_info *fdb_info; |
| struct net_device *dev = switchdev_work->dev; |
| enum mlxsw_sp_l3proto proto; |
| union mlxsw_sp_l3addr addr; |
| int err; |
| |
| fdb_info = &switchdev_work->fdb_info; |
| err = vxlan_fdb_find_uc(dev, fdb_info->addr, vni, &vxlan_fdb_info); |
| if (err) |
| return; |
| |
| mlxsw_sp_switchdev_vxlan_addr_convert(&vxlan_fdb_info.remote_ip, |
| &proto, &addr); |
| |
| switch (switchdev_work->event) { |
| case SWITCHDEV_FDB_ADD_TO_DEVICE: |
| err = mlxsw_sp_port_fdb_tunnel_uc_op(mlxsw_sp, |
| vxlan_fdb_info.eth_addr, |
| mlxsw_sp_fid_index(fid), |
| proto, &addr, true, false); |
| if (err) |
| return; |
| vxlan_fdb_info.offloaded = true; |
| call_switchdev_notifiers(SWITCHDEV_VXLAN_FDB_OFFLOADED, dev, |
| &vxlan_fdb_info.info); |
| mlxsw_sp_fdb_call_notifiers(SWITCHDEV_FDB_OFFLOADED, |
| vxlan_fdb_info.eth_addr, |
| fdb_info->vid, dev, true); |
| break; |
| case SWITCHDEV_FDB_DEL_TO_DEVICE: |
| err = mlxsw_sp_port_fdb_tunnel_uc_op(mlxsw_sp, |
| vxlan_fdb_info.eth_addr, |
| mlxsw_sp_fid_index(fid), |
| proto, &addr, false, |
| false); |
| vxlan_fdb_info.offloaded = false; |
| call_switchdev_notifiers(SWITCHDEV_VXLAN_FDB_OFFLOADED, dev, |
| &vxlan_fdb_info.info); |
| break; |
| } |
| } |
| |
| static void |
| mlxsw_sp_switchdev_bridge_nve_fdb_event(struct mlxsw_sp_switchdev_event_work * |
| switchdev_work) |
| { |
| struct mlxsw_sp_bridge_device *bridge_device; |
| struct net_device *dev = switchdev_work->dev; |
| struct net_device *br_dev; |
| struct mlxsw_sp *mlxsw_sp; |
| struct mlxsw_sp_fid *fid; |
| __be32 vni; |
| int err; |
| |
| if (switchdev_work->event != SWITCHDEV_FDB_ADD_TO_DEVICE && |
| switchdev_work->event != SWITCHDEV_FDB_DEL_TO_DEVICE) |
| return; |
| |
| if (switchdev_work->event == SWITCHDEV_FDB_ADD_TO_DEVICE && |
| !switchdev_work->fdb_info.added_by_user) |
| return; |
| |
| if (!netif_running(dev)) |
| return; |
| br_dev = netdev_master_upper_dev_get(dev); |
| if (!br_dev) |
| return; |
| if (!netif_is_bridge_master(br_dev)) |
| return; |
| mlxsw_sp = mlxsw_sp_lower_get(br_dev); |
| if (!mlxsw_sp) |
| return; |
| bridge_device = mlxsw_sp_bridge_device_find(mlxsw_sp->bridge, br_dev); |
| if (!bridge_device) |
| return; |
| |
| fid = bridge_device->ops->fid_lookup(bridge_device, |
| switchdev_work->fdb_info.vid); |
| if (!fid) |
| return; |
| |
| err = mlxsw_sp_fid_vni(fid, &vni); |
| if (err) |
| goto out; |
| |
| mlxsw_sp_switchdev_bridge_vxlan_fdb_event(mlxsw_sp, switchdev_work, fid, |
| vni); |
| |
| out: |
| mlxsw_sp_fid_put(fid); |
| } |
| |
| static void mlxsw_sp_switchdev_bridge_fdb_event_work(struct work_struct *work) |
| { |
| struct mlxsw_sp_switchdev_event_work *switchdev_work = |
| container_of(work, struct mlxsw_sp_switchdev_event_work, work); |
| struct net_device *dev = switchdev_work->dev; |
| struct switchdev_notifier_fdb_info *fdb_info; |
| struct mlxsw_sp_port *mlxsw_sp_port; |
| int err; |
| |
| rtnl_lock(); |
| if (netif_is_vxlan(dev)) { |
| mlxsw_sp_switchdev_bridge_nve_fdb_event(switchdev_work); |
| goto out; |
| } |
| |
| mlxsw_sp_port = mlxsw_sp_port_dev_lower_find(dev); |
| if (!mlxsw_sp_port) |
| goto out; |
| |
| switch (switchdev_work->event) { |
| case SWITCHDEV_FDB_ADD_TO_DEVICE: |
| fdb_info = &switchdev_work->fdb_info; |
| if (!fdb_info->added_by_user) |
| break; |
| err = mlxsw_sp_port_fdb_set(mlxsw_sp_port, fdb_info, true); |
| if (err) |
| break; |
| mlxsw_sp_fdb_call_notifiers(SWITCHDEV_FDB_OFFLOADED, |
| fdb_info->addr, |
| fdb_info->vid, dev, true); |
| break; |
| case SWITCHDEV_FDB_DEL_TO_DEVICE: |
| fdb_info = &switchdev_work->fdb_info; |
| mlxsw_sp_port_fdb_set(mlxsw_sp_port, fdb_info, false); |
| break; |
| case SWITCHDEV_FDB_ADD_TO_BRIDGE: /* fall through */ |
| case SWITCHDEV_FDB_DEL_TO_BRIDGE: |
| /* These events are only used to potentially update an existing |
| * SPAN mirror. |
| */ |
| break; |
| } |
| |
| mlxsw_sp_span_respin(mlxsw_sp_port->mlxsw_sp); |
| |
| out: |
| rtnl_unlock(); |
| kfree(switchdev_work->fdb_info.addr); |
| kfree(switchdev_work); |
| dev_put(dev); |
| } |
| |
| static void |
| mlxsw_sp_switchdev_vxlan_fdb_add(struct mlxsw_sp *mlxsw_sp, |
| struct mlxsw_sp_switchdev_event_work * |
| switchdev_work) |
| { |
| struct switchdev_notifier_vxlan_fdb_info *vxlan_fdb_info; |
| struct mlxsw_sp_bridge_device *bridge_device; |
| struct net_device *dev = switchdev_work->dev; |
| u8 all_zeros_mac[ETH_ALEN] = { 0 }; |
| enum mlxsw_sp_l3proto proto; |
| union mlxsw_sp_l3addr addr; |
| struct net_device *br_dev; |
| struct mlxsw_sp_fid *fid; |
| u16 vid; |
| int err; |
| |
| vxlan_fdb_info = &switchdev_work->vxlan_fdb_info; |
| br_dev = netdev_master_upper_dev_get(dev); |
| |
| bridge_device = mlxsw_sp_bridge_device_find(mlxsw_sp->bridge, br_dev); |
| if (!bridge_device) |
| return; |
| |
| fid = mlxsw_sp_fid_lookup_by_vni(mlxsw_sp, vxlan_fdb_info->vni); |
| if (!fid) |
| return; |
| |
| mlxsw_sp_switchdev_vxlan_addr_convert(&vxlan_fdb_info->remote_ip, |
| &proto, &addr); |
| |
| if (ether_addr_equal(vxlan_fdb_info->eth_addr, all_zeros_mac)) { |
| err = mlxsw_sp_nve_flood_ip_add(mlxsw_sp, fid, proto, &addr); |
| if (err) { |
| mlxsw_sp_fid_put(fid); |
| return; |
| } |
| vxlan_fdb_info->offloaded = true; |
| call_switchdev_notifiers(SWITCHDEV_VXLAN_FDB_OFFLOADED, dev, |
| &vxlan_fdb_info->info); |
| mlxsw_sp_fid_put(fid); |
| return; |
| } |
| |
| /* The device has a single FDB table, whereas Linux has two - one |
| * in the bridge driver and another in the VxLAN driver. We only |
| * program an entry to the device if the MAC points to the VxLAN |
| * device in the bridge's FDB table |
| */ |
| vid = bridge_device->ops->fid_vid(bridge_device, fid); |
| if (br_fdb_find_port(br_dev, vxlan_fdb_info->eth_addr, vid) != dev) |
| goto err_br_fdb_find; |
| |
| err = mlxsw_sp_port_fdb_tunnel_uc_op(mlxsw_sp, vxlan_fdb_info->eth_addr, |
| mlxsw_sp_fid_index(fid), proto, |
| &addr, true, false); |
| if (err) |
| goto err_fdb_tunnel_uc_op; |
| vxlan_fdb_info->offloaded = true; |
| call_switchdev_notifiers(SWITCHDEV_VXLAN_FDB_OFFLOADED, dev, |
| &vxlan_fdb_info->info); |
| mlxsw_sp_fdb_call_notifiers(SWITCHDEV_FDB_OFFLOADED, |
| vxlan_fdb_info->eth_addr, vid, dev, true); |
| |
| mlxsw_sp_fid_put(fid); |
| |
| return; |
| |
| err_fdb_tunnel_uc_op: |
| err_br_fdb_find: |
| mlxsw_sp_fid_put(fid); |
| } |
| |
| static void |
| mlxsw_sp_switchdev_vxlan_fdb_del(struct mlxsw_sp *mlxsw_sp, |
| struct mlxsw_sp_switchdev_event_work * |
| switchdev_work) |
| { |
| struct switchdev_notifier_vxlan_fdb_info *vxlan_fdb_info; |
| struct mlxsw_sp_bridge_device *bridge_device; |
| struct net_device *dev = switchdev_work->dev; |
| struct net_device *br_dev = netdev_master_upper_dev_get(dev); |
| u8 all_zeros_mac[ETH_ALEN] = { 0 }; |
| enum mlxsw_sp_l3proto proto; |
| union mlxsw_sp_l3addr addr; |
| struct mlxsw_sp_fid *fid; |
| u16 vid; |
| |
| vxlan_fdb_info = &switchdev_work->vxlan_fdb_info; |
| |
| bridge_device = mlxsw_sp_bridge_device_find(mlxsw_sp->bridge, br_dev); |
| if (!bridge_device) |
| return; |
| |
| fid = mlxsw_sp_fid_lookup_by_vni(mlxsw_sp, vxlan_fdb_info->vni); |
| if (!fid) |
| return; |
| |
| mlxsw_sp_switchdev_vxlan_addr_convert(&vxlan_fdb_info->remote_ip, |
| &proto, &addr); |
| |
| if (ether_addr_equal(vxlan_fdb_info->eth_addr, all_zeros_mac)) { |
| mlxsw_sp_nve_flood_ip_del(mlxsw_sp, fid, proto, &addr); |
| mlxsw_sp_fid_put(fid); |
| return; |
| } |
| |
| mlxsw_sp_port_fdb_tunnel_uc_op(mlxsw_sp, vxlan_fdb_info->eth_addr, |
| mlxsw_sp_fid_index(fid), proto, &addr, |
| false, false); |
| vid = bridge_device->ops->fid_vid(bridge_device, fid); |
| mlxsw_sp_fdb_call_notifiers(SWITCHDEV_FDB_OFFLOADED, |
| vxlan_fdb_info->eth_addr, vid, dev, false); |
| |
| mlxsw_sp_fid_put(fid); |
| } |
| |
| static void mlxsw_sp_switchdev_vxlan_fdb_event_work(struct work_struct *work) |
| { |
| struct mlxsw_sp_switchdev_event_work *switchdev_work = |
| container_of(work, struct mlxsw_sp_switchdev_event_work, work); |
| struct net_device *dev = switchdev_work->dev; |
| struct mlxsw_sp *mlxsw_sp; |
| struct net_device *br_dev; |
| |
| rtnl_lock(); |
| |
| if (!netif_running(dev)) |
| goto out; |
| br_dev = netdev_master_upper_dev_get(dev); |
| if (!br_dev) |
| goto out; |
| if (!netif_is_bridge_master(br_dev)) |
| goto out; |
| mlxsw_sp = mlxsw_sp_lower_get(br_dev); |
| if (!mlxsw_sp) |
| goto out; |
| |
| switch (switchdev_work->event) { |
| case SWITCHDEV_VXLAN_FDB_ADD_TO_DEVICE: |
| mlxsw_sp_switchdev_vxlan_fdb_add(mlxsw_sp, switchdev_work); |
| break; |
| case SWITCHDEV_VXLAN_FDB_DEL_TO_DEVICE: |
| mlxsw_sp_switchdev_vxlan_fdb_del(mlxsw_sp, switchdev_work); |
| break; |
| } |
| |
| out: |
| rtnl_unlock(); |
| kfree(switchdev_work); |
| dev_put(dev); |
| } |
| |
| static int |
| mlxsw_sp_switchdev_vxlan_work_prepare(struct mlxsw_sp_switchdev_event_work * |
| switchdev_work, |
| struct switchdev_notifier_info *info) |
| { |
| struct vxlan_dev *vxlan = netdev_priv(switchdev_work->dev); |
| struct switchdev_notifier_vxlan_fdb_info *vxlan_fdb_info; |
| struct vxlan_config *cfg = &vxlan->cfg; |
| |
| vxlan_fdb_info = container_of(info, |
| struct switchdev_notifier_vxlan_fdb_info, |
| info); |
| |
| if (vxlan_fdb_info->remote_port != cfg->dst_port) |
| return -EOPNOTSUPP; |
| if (vxlan_fdb_info->remote_vni != cfg->vni) |
| return -EOPNOTSUPP; |
| if (vxlan_fdb_info->vni != cfg->vni) |
| return -EOPNOTSUPP; |
| if (vxlan_fdb_info->remote_ifindex) |
| return -EOPNOTSUPP; |
| if (is_multicast_ether_addr(vxlan_fdb_info->eth_addr)) |
| return -EOPNOTSUPP; |
| if (vxlan_addr_multicast(&vxlan_fdb_info->remote_ip)) |
| return -EOPNOTSUPP; |
| |
| switchdev_work->vxlan_fdb_info = *vxlan_fdb_info; |
| |
| return 0; |
| } |
| |
| /* Called under rcu_read_lock() */ |
| static int mlxsw_sp_switchdev_event(struct notifier_block *unused, |
| unsigned long event, void *ptr) |
| { |
| struct net_device *dev = switchdev_notifier_info_to_dev(ptr); |
| struct mlxsw_sp_switchdev_event_work *switchdev_work; |
| struct switchdev_notifier_fdb_info *fdb_info; |
| struct switchdev_notifier_info *info = ptr; |
| struct net_device *br_dev; |
| int err; |
| |
| /* Tunnel devices are not our uppers, so check their master instead */ |
| br_dev = netdev_master_upper_dev_get_rcu(dev); |
| if (!br_dev) |
| return NOTIFY_DONE; |
| if (!netif_is_bridge_master(br_dev)) |
| return NOTIFY_DONE; |
| if (!mlxsw_sp_port_dev_lower_find_rcu(br_dev)) |
| return NOTIFY_DONE; |
| |
| switchdev_work = kzalloc(sizeof(*switchdev_work), GFP_ATOMIC); |
| if (!switchdev_work) |
| return NOTIFY_BAD; |
| |
| switchdev_work->dev = dev; |
| switchdev_work->event = event; |
| |
| switch (event) { |
| case SWITCHDEV_FDB_ADD_TO_DEVICE: /* fall through */ |
| case SWITCHDEV_FDB_DEL_TO_DEVICE: /* fall through */ |
| case SWITCHDEV_FDB_ADD_TO_BRIDGE: /* fall through */ |
| case SWITCHDEV_FDB_DEL_TO_BRIDGE: |
| fdb_info = container_of(info, |
| struct switchdev_notifier_fdb_info, |
| info); |
| INIT_WORK(&switchdev_work->work, |
| mlxsw_sp_switchdev_bridge_fdb_event_work); |
| memcpy(&switchdev_work->fdb_info, ptr, |
| sizeof(switchdev_work->fdb_info)); |
| switchdev_work->fdb_info.addr = kzalloc(ETH_ALEN, GFP_ATOMIC); |
| if (!switchdev_work->fdb_info.addr) |
| goto err_addr_alloc; |
| ether_addr_copy((u8 *)switchdev_work->fdb_info.addr, |
| fdb_info->addr); |
| /* Take a reference on the device. This can be either |
| * upper device containig mlxsw_sp_port or just a |
| * mlxsw_sp_port |
| */ |
| dev_hold(dev); |
| break; |
| case SWITCHDEV_VXLAN_FDB_ADD_TO_DEVICE: /* fall through */ |
| case SWITCHDEV_VXLAN_FDB_DEL_TO_DEVICE: |
| INIT_WORK(&switchdev_work->work, |
| mlxsw_sp_switchdev_vxlan_fdb_event_work); |
| err = mlxsw_sp_switchdev_vxlan_work_prepare(switchdev_work, |
| info); |
| if (err) |
| goto err_vxlan_work_prepare; |
| dev_hold(dev); |
| break; |
| default: |
| kfree(switchdev_work); |
| return NOTIFY_DONE; |
| } |
| |
| mlxsw_core_schedule_work(&switchdev_work->work); |
| |
| return NOTIFY_DONE; |
| |
| err_vxlan_work_prepare: |
| err_addr_alloc: |
| kfree(switchdev_work); |
| return NOTIFY_BAD; |
| } |
| |
| struct notifier_block mlxsw_sp_switchdev_notifier = { |
| .notifier_call = mlxsw_sp_switchdev_event, |
| }; |
| |
| static int |
| mlxsw_sp_switchdev_vxlan_vlan_add(struct mlxsw_sp *mlxsw_sp, |
| struct mlxsw_sp_bridge_device *bridge_device, |
| const struct net_device *vxlan_dev, u16 vid, |
| bool flag_untagged, bool flag_pvid, |
| struct netlink_ext_ack *extack) |
| { |
| struct vxlan_dev *vxlan = netdev_priv(vxlan_dev); |
| __be32 vni = vxlan->cfg.vni; |
| struct mlxsw_sp_fid *fid; |
| u16 old_vid; |
| int err; |
| |
| /* We cannot have the same VLAN as PVID and egress untagged on multiple |
| * VxLAN devices. Note that we get this notification before the VLAN is |
| * actually added to the bridge's database, so it is not possible for |
| * the lookup function to return 'vxlan_dev' |
| */ |
| if (flag_untagged && flag_pvid && |
| mlxsw_sp_bridge_8021q_vxlan_dev_find(bridge_device->dev, vid)) |
| return -EINVAL; |
| |
| if (!netif_running(vxlan_dev)) |
| return 0; |
| |
| /* First case: FID is not associated with this VNI, but the new VLAN |
| * is both PVID and egress untagged. Need to enable NVE on the FID, if |
| * it exists |
| */ |
| fid = mlxsw_sp_fid_lookup_by_vni(mlxsw_sp, vni); |
| if (!fid) { |
| if (!flag_untagged || !flag_pvid) |
| return 0; |
| return mlxsw_sp_bridge_8021q_vxlan_join(bridge_device, |
| vxlan_dev, vid, extack); |
| } |
| |
| /* Second case: FID is associated with the VNI and the VLAN associated |
| * with the FID is the same as the notified VLAN. This means the flags |
| * (PVID / egress untagged) were toggled and that NVE should be |
| * disabled on the FID |
| */ |
| old_vid = mlxsw_sp_fid_8021q_vid(fid); |
| if (vid == old_vid) { |
| if (WARN_ON(flag_untagged && flag_pvid)) { |
| mlxsw_sp_fid_put(fid); |
| return -EINVAL; |
| } |
| mlxsw_sp_bridge_vxlan_leave(mlxsw_sp, vxlan_dev); |
| mlxsw_sp_fid_put(fid); |
| return 0; |
| } |
| |
| /* Third case: A new VLAN was configured on the VxLAN device, but this |
| * VLAN is not PVID, so there is nothing to do. |
| */ |
| if (!flag_pvid) { |
| mlxsw_sp_fid_put(fid); |
| return 0; |
| } |
| |
| /* Fourth case: Thew new VLAN is PVID, which means the VLAN currently |
| * mapped to the VNI should be unmapped |
| */ |
| mlxsw_sp_bridge_vxlan_leave(mlxsw_sp, vxlan_dev); |
| mlxsw_sp_fid_put(fid); |
| |
| /* Fifth case: The new VLAN is also egress untagged, which means the |
| * VLAN needs to be mapped to the VNI |
| */ |
| if (!flag_untagged) |
| return 0; |
| |
| err = mlxsw_sp_bridge_8021q_vxlan_join(bridge_device, vxlan_dev, vid, |
| extack); |
| if (err) |
| goto err_vxlan_join; |
| |
| return 0; |
| |
| err_vxlan_join: |
| mlxsw_sp_bridge_8021q_vxlan_join(bridge_device, vxlan_dev, old_vid, |
| NULL); |
| return err; |
| } |
| |
| static void |
| mlxsw_sp_switchdev_vxlan_vlan_del(struct mlxsw_sp *mlxsw_sp, |
| struct mlxsw_sp_bridge_device *bridge_device, |
| const struct net_device *vxlan_dev, u16 vid) |
| { |
| struct vxlan_dev *vxlan = netdev_priv(vxlan_dev); |
| __be32 vni = vxlan->cfg.vni; |
| struct mlxsw_sp_fid *fid; |
| |
| if (!netif_running(vxlan_dev)) |
| return; |
| |
| fid = mlxsw_sp_fid_lookup_by_vni(mlxsw_sp, vni); |
| if (!fid) |
| return; |
| |
| /* A different VLAN than the one mapped to the VNI is deleted */ |
| if (mlxsw_sp_fid_8021q_vid(fid) != vid) |
| goto out; |
| |
| mlxsw_sp_bridge_vxlan_leave(mlxsw_sp, vxlan_dev); |
| |
| out: |
| mlxsw_sp_fid_put(fid); |
| } |
| |
| static int |
| mlxsw_sp_switchdev_vxlan_vlans_add(struct net_device *vxlan_dev, |
| struct switchdev_notifier_port_obj_info * |
| port_obj_info) |
| { |
| struct switchdev_obj_port_vlan *vlan = |
| SWITCHDEV_OBJ_PORT_VLAN(port_obj_info->obj); |
| bool flag_untagged = vlan->flags & BRIDGE_VLAN_INFO_UNTAGGED; |
| bool flag_pvid = vlan->flags & BRIDGE_VLAN_INFO_PVID; |
| struct switchdev_trans *trans = port_obj_info->trans; |
| struct mlxsw_sp_bridge_device *bridge_device; |
| struct netlink_ext_ack *extack; |
| struct mlxsw_sp *mlxsw_sp; |
| struct net_device *br_dev; |
| u16 vid; |
| |
| extack = switchdev_notifier_info_to_extack(&port_obj_info->info); |
| br_dev = netdev_master_upper_dev_get(vxlan_dev); |
| if (!br_dev) |
| return 0; |
| |
| mlxsw_sp = mlxsw_sp_lower_get(br_dev); |
| if (!mlxsw_sp) |
| return 0; |
| |
| port_obj_info->handled = true; |
| |
| if (switchdev_trans_ph_commit(trans)) |
| return 0; |
| |
| bridge_device = mlxsw_sp_bridge_device_find(mlxsw_sp->bridge, br_dev); |
| if (!bridge_device) |
| return -EINVAL; |
| |
| if (!bridge_device->vlan_enabled) |
| return 0; |
| |
| for (vid = vlan->vid_begin; vid <= vlan->vid_end; vid++) { |
| int err; |
| |
| err = mlxsw_sp_switchdev_vxlan_vlan_add(mlxsw_sp, bridge_device, |
| vxlan_dev, vid, |
| flag_untagged, |
| flag_pvid, extack); |
| if (err) |
| return err; |
| } |
| |
| return 0; |
| } |
| |
| static void |
| mlxsw_sp_switchdev_vxlan_vlans_del(struct net_device *vxlan_dev, |
| struct switchdev_notifier_port_obj_info * |
| port_obj_info) |
| { |
| struct switchdev_obj_port_vlan *vlan = |
| SWITCHDEV_OBJ_PORT_VLAN(port_obj_info->obj); |
| struct mlxsw_sp_bridge_device *bridge_device; |
| struct mlxsw_sp *mlxsw_sp; |
| struct net_device *br_dev; |
| u16 vid; |
| |
| br_dev = netdev_master_upper_dev_get(vxlan_dev); |
| if (!br_dev) |
| return; |
| |
| mlxsw_sp = mlxsw_sp_lower_get(br_dev); |
| if (!mlxsw_sp) |
| return; |
| |
| port_obj_info->handled = true; |
| |
| bridge_device = mlxsw_sp_bridge_device_find(mlxsw_sp->bridge, br_dev); |
| if (!bridge_device) |
| return; |
| |
| if (!bridge_device->vlan_enabled) |
| return; |
| |
| for (vid = vlan->vid_begin; vid <= vlan->vid_end; vid++) |
| mlxsw_sp_switchdev_vxlan_vlan_del(mlxsw_sp, bridge_device, |
| vxlan_dev, vid); |
| } |
| |
| static int |
| mlxsw_sp_switchdev_handle_vxlan_obj_add(struct net_device *vxlan_dev, |
| struct switchdev_notifier_port_obj_info * |
| port_obj_info) |
| { |
| int err = 0; |
| |
| switch (port_obj_info->obj->id) { |
| case SWITCHDEV_OBJ_ID_PORT_VLAN: |
| err = mlxsw_sp_switchdev_vxlan_vlans_add(vxlan_dev, |
| port_obj_info); |
| break; |
| default: |
| break; |
| } |
| |
| return err; |
| } |
| |
| static void |
| mlxsw_sp_switchdev_handle_vxlan_obj_del(struct net_device *vxlan_dev, |
| struct switchdev_notifier_port_obj_info * |
| port_obj_info) |
| { |
| switch (port_obj_info->obj->id) { |
| case SWITCHDEV_OBJ_ID_PORT_VLAN: |
| mlxsw_sp_switchdev_vxlan_vlans_del(vxlan_dev, port_obj_info); |
| break; |
| default: |
| break; |
| } |
| } |
| |
| static int mlxsw_sp_switchdev_blocking_event(struct notifier_block *unused, |
| unsigned long event, void *ptr) |
| { |
| struct net_device *dev = switchdev_notifier_info_to_dev(ptr); |
| int err = 0; |
| |
| switch (event) { |
| case SWITCHDEV_PORT_OBJ_ADD: |
| if (netif_is_vxlan(dev)) |
| err = mlxsw_sp_switchdev_handle_vxlan_obj_add(dev, ptr); |
| else |
| err = switchdev_handle_port_obj_add(dev, ptr, |
| mlxsw_sp_port_dev_check, |
| mlxsw_sp_port_obj_add); |
| return notifier_from_errno(err); |
| case SWITCHDEV_PORT_OBJ_DEL: |
| if (netif_is_vxlan(dev)) |
| mlxsw_sp_switchdev_handle_vxlan_obj_del(dev, ptr); |
| else |
| err = switchdev_handle_port_obj_del(dev, ptr, |
| mlxsw_sp_port_dev_check, |
| mlxsw_sp_port_obj_del); |
| return notifier_from_errno(err); |
| } |
| |
| return NOTIFY_DONE; |
| } |
| |
| static struct notifier_block mlxsw_sp_switchdev_blocking_notifier = { |
| .notifier_call = mlxsw_sp_switchdev_blocking_event, |
| }; |
| |
| u8 |
| mlxsw_sp_bridge_port_stp_state(struct mlxsw_sp_bridge_port *bridge_port) |
| { |
| return bridge_port->stp_state; |
| } |
| |
| static int mlxsw_sp_fdb_init(struct mlxsw_sp *mlxsw_sp) |
| { |
| struct mlxsw_sp_bridge *bridge = mlxsw_sp->bridge; |
| struct notifier_block *nb; |
| int err; |
| |
| err = mlxsw_sp_ageing_set(mlxsw_sp, MLXSW_SP_DEFAULT_AGEING_TIME); |
| if (err) { |
| dev_err(mlxsw_sp->bus_info->dev, "Failed to set default ageing time\n"); |
| return err; |
| } |
| |
| err = register_switchdev_notifier(&mlxsw_sp_switchdev_notifier); |
| if (err) { |
| dev_err(mlxsw_sp->bus_info->dev, "Failed to register switchdev notifier\n"); |
| return err; |
| } |
| |
| nb = &mlxsw_sp_switchdev_blocking_notifier; |
| err = register_switchdev_blocking_notifier(nb); |
| if (err) { |
| dev_err(mlxsw_sp->bus_info->dev, "Failed to register switchdev blocking notifier\n"); |
| goto err_register_switchdev_blocking_notifier; |
| } |
| |
| INIT_DELAYED_WORK(&bridge->fdb_notify.dw, mlxsw_sp_fdb_notify_work); |
| bridge->fdb_notify.interval = MLXSW_SP_DEFAULT_LEARNING_INTERVAL; |
| mlxsw_sp_fdb_notify_work_schedule(mlxsw_sp); |
| return 0; |
| |
| err_register_switchdev_blocking_notifier: |
| unregister_switchdev_notifier(&mlxsw_sp_switchdev_notifier); |
| return err; |
| } |
| |
| static void mlxsw_sp_fdb_fini(struct mlxsw_sp *mlxsw_sp) |
| { |
| struct notifier_block *nb; |
| |
| cancel_delayed_work_sync(&mlxsw_sp->bridge->fdb_notify.dw); |
| |
| nb = &mlxsw_sp_switchdev_blocking_notifier; |
| unregister_switchdev_blocking_notifier(nb); |
| |
| unregister_switchdev_notifier(&mlxsw_sp_switchdev_notifier); |
| } |
| |
| int mlxsw_sp_switchdev_init(struct mlxsw_sp *mlxsw_sp) |
| { |
| struct mlxsw_sp_bridge *bridge; |
| |
| bridge = kzalloc(sizeof(*mlxsw_sp->bridge), GFP_KERNEL); |
| if (!bridge) |
| return -ENOMEM; |
| mlxsw_sp->bridge = bridge; |
| bridge->mlxsw_sp = mlxsw_sp; |
| |
| INIT_LIST_HEAD(&mlxsw_sp->bridge->bridges_list); |
| |
| bridge->bridge_8021q_ops = &mlxsw_sp_bridge_8021q_ops; |
| bridge->bridge_8021d_ops = &mlxsw_sp_bridge_8021d_ops; |
| |
| return mlxsw_sp_fdb_init(mlxsw_sp); |
| } |
| |
| void mlxsw_sp_switchdev_fini(struct mlxsw_sp *mlxsw_sp) |
| { |
| mlxsw_sp_fdb_fini(mlxsw_sp); |
| WARN_ON(!list_empty(&mlxsw_sp->bridge->bridges_list)); |
| kfree(mlxsw_sp->bridge); |
| } |
| |
| void mlxsw_sp_port_switchdev_init(struct mlxsw_sp_port *mlxsw_sp_port) |
| { |
| mlxsw_sp_port->dev->switchdev_ops = &mlxsw_sp_port_switchdev_ops; |
| } |
| |
| void mlxsw_sp_port_switchdev_fini(struct mlxsw_sp_port *mlxsw_sp_port) |
| { |
| } |