191ad1bd9SKonstantin Belousov /*- 291ad1bd9SKonstantin Belousov * Copyright (c) 2013-2017, Mellanox Technologies, Ltd. All rights reserved. 391ad1bd9SKonstantin Belousov * 491ad1bd9SKonstantin Belousov * Redistribution and use in source and binary forms, with or without 591ad1bd9SKonstantin Belousov * modification, are permitted provided that the following conditions 691ad1bd9SKonstantin Belousov * are met: 791ad1bd9SKonstantin Belousov * 1. Redistributions of source code must retain the above copyright 891ad1bd9SKonstantin Belousov * notice, this list of conditions and the following disclaimer. 991ad1bd9SKonstantin Belousov * 2. Redistributions in binary form must reproduce the above copyright 1091ad1bd9SKonstantin Belousov * notice, this list of conditions and the following disclaimer in the 1191ad1bd9SKonstantin Belousov * documentation and/or other materials provided with the distribution. 1291ad1bd9SKonstantin Belousov * 1391ad1bd9SKonstantin Belousov * THIS SOFTWARE IS PROVIDED BY AUTHOR AND CONTRIBUTORS `AS IS' AND 1491ad1bd9SKonstantin Belousov * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 1591ad1bd9SKonstantin Belousov * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 1691ad1bd9SKonstantin Belousov * ARE DISCLAIMED. IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE 1791ad1bd9SKonstantin Belousov * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 1891ad1bd9SKonstantin Belousov * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 1991ad1bd9SKonstantin Belousov * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 2091ad1bd9SKonstantin Belousov * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 2191ad1bd9SKonstantin Belousov * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 2291ad1bd9SKonstantin Belousov * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 2391ad1bd9SKonstantin Belousov * SUCH DAMAGE. 2491ad1bd9SKonstantin Belousov * 2591ad1bd9SKonstantin Belousov * $FreeBSD$ 2691ad1bd9SKonstantin Belousov */ 2791ad1bd9SKonstantin Belousov 28ee9d634bSKonstantin Belousov #include "opt_rss.h" 29ee9d634bSKonstantin Belousov #include "opt_ratelimit.h" 30ee9d634bSKonstantin Belousov 3191ad1bd9SKonstantin Belousov #include <linux/etherdevice.h> 3291ad1bd9SKonstantin Belousov #include <dev/mlx5/driver.h> 3391ad1bd9SKonstantin Belousov #include <dev/mlx5/mlx5_ifc.h> 3491ad1bd9SKonstantin Belousov #include <dev/mlx5/vport.h> 3591ad1bd9SKonstantin Belousov #include <dev/mlx5/fs.h> 36f6ca0b21SKonstantin Belousov #include <dev/mlx5/mpfs.h> 3712c56d7dSHans Petter Selasky #include <dev/mlx5/mlx5_core/mlx5_core.h> 3812c56d7dSHans Petter Selasky #include <dev/mlx5/mlx5_core/eswitch.h> 3991ad1bd9SKonstantin Belousov 4091ad1bd9SKonstantin Belousov #define UPLINK_VPORT 0xFFFF 4191ad1bd9SKonstantin Belousov 4291ad1bd9SKonstantin Belousov #define MLX5_DEBUG_ESWITCH_MASK BIT(3) 4391ad1bd9SKonstantin Belousov 4491ad1bd9SKonstantin Belousov #define esw_info(dev, format, ...) \ 4591ad1bd9SKonstantin Belousov printf("mlx5_core: INFO: ""(%s): E-Switch: " format, (dev)->priv.name, ##__VA_ARGS__) 4691ad1bd9SKonstantin Belousov 4791ad1bd9SKonstantin Belousov #define esw_warn(dev, format, ...) \ 4891ad1bd9SKonstantin Belousov printf("mlx5_core: WARN: ""(%s): E-Switch: " format, (dev)->priv.name, ##__VA_ARGS__) 4991ad1bd9SKonstantin Belousov 5091ad1bd9SKonstantin Belousov #define esw_debug(dev, format, ...) \ 5191ad1bd9SKonstantin Belousov mlx5_core_dbg_mask(dev, MLX5_DEBUG_ESWITCH_MASK, format, ##__VA_ARGS__) 5291ad1bd9SKonstantin Belousov 5391ad1bd9SKonstantin Belousov enum { 5491ad1bd9SKonstantin Belousov MLX5_ACTION_NONE = 0, 5591ad1bd9SKonstantin Belousov MLX5_ACTION_ADD = 1, 5691ad1bd9SKonstantin Belousov MLX5_ACTION_DEL = 2, 5791ad1bd9SKonstantin Belousov }; 5891ad1bd9SKonstantin Belousov 5991ad1bd9SKonstantin Belousov /* E-Switch UC L2 table hash node */ 6091ad1bd9SKonstantin Belousov struct esw_uc_addr { 6191ad1bd9SKonstantin Belousov struct l2addr_node node; 6291ad1bd9SKonstantin Belousov u32 table_index; 6391ad1bd9SKonstantin Belousov u32 vport; 6491ad1bd9SKonstantin Belousov }; 6591ad1bd9SKonstantin Belousov 6691ad1bd9SKonstantin Belousov /* E-Switch MC FDB table hash node */ 6791ad1bd9SKonstantin Belousov struct esw_mc_addr { /* SRIOV only */ 6891ad1bd9SKonstantin Belousov struct l2addr_node node; 6991ad1bd9SKonstantin Belousov struct mlx5_flow_rule *uplink_rule; /* Forward to uplink rule */ 7091ad1bd9SKonstantin Belousov u32 refcnt; 7191ad1bd9SKonstantin Belousov }; 7291ad1bd9SKonstantin Belousov 7391ad1bd9SKonstantin Belousov /* Vport UC/MC hash node */ 7491ad1bd9SKonstantin Belousov struct vport_addr { 7591ad1bd9SKonstantin Belousov struct l2addr_node node; 7691ad1bd9SKonstantin Belousov u8 action; 7791ad1bd9SKonstantin Belousov u32 vport; 7891ad1bd9SKonstantin Belousov struct mlx5_flow_rule *flow_rule; /* SRIOV only */ 7991ad1bd9SKonstantin Belousov }; 8091ad1bd9SKonstantin Belousov 8191ad1bd9SKonstantin Belousov enum { 8291ad1bd9SKonstantin Belousov UC_ADDR_CHANGE = BIT(0), 8391ad1bd9SKonstantin Belousov MC_ADDR_CHANGE = BIT(1), 8491ad1bd9SKonstantin Belousov }; 8591ad1bd9SKonstantin Belousov 8691ad1bd9SKonstantin Belousov /* Vport context events */ 8791ad1bd9SKonstantin Belousov #define SRIOV_VPORT_EVENTS (UC_ADDR_CHANGE | \ 8891ad1bd9SKonstantin Belousov MC_ADDR_CHANGE) 8991ad1bd9SKonstantin Belousov 9091ad1bd9SKonstantin Belousov static int arm_vport_context_events_cmd(struct mlx5_core_dev *dev, u16 vport, 9191ad1bd9SKonstantin Belousov u32 events_mask) 9291ad1bd9SKonstantin Belousov { 9391ad1bd9SKonstantin Belousov int in[MLX5_ST_SZ_DW(modify_nic_vport_context_in)] = {0}; 9491ad1bd9SKonstantin Belousov int out[MLX5_ST_SZ_DW(modify_nic_vport_context_out)] = {0}; 9591ad1bd9SKonstantin Belousov void *nic_vport_ctx; 9691ad1bd9SKonstantin Belousov 9791ad1bd9SKonstantin Belousov MLX5_SET(modify_nic_vport_context_in, in, 9891ad1bd9SKonstantin Belousov opcode, MLX5_CMD_OP_MODIFY_NIC_VPORT_CONTEXT); 9991ad1bd9SKonstantin Belousov MLX5_SET(modify_nic_vport_context_in, in, field_select.change_event, 1); 10091ad1bd9SKonstantin Belousov MLX5_SET(modify_nic_vport_context_in, in, vport_number, vport); 10191ad1bd9SKonstantin Belousov if (vport) 10291ad1bd9SKonstantin Belousov MLX5_SET(modify_nic_vport_context_in, in, other_vport, 1); 10391ad1bd9SKonstantin Belousov nic_vport_ctx = MLX5_ADDR_OF(modify_nic_vport_context_in, 10491ad1bd9SKonstantin Belousov in, nic_vport_context); 10591ad1bd9SKonstantin Belousov 10691ad1bd9SKonstantin Belousov MLX5_SET(nic_vport_context, nic_vport_ctx, arm_change_event, 1); 10791ad1bd9SKonstantin Belousov 10891ad1bd9SKonstantin Belousov if (events_mask & UC_ADDR_CHANGE) 10991ad1bd9SKonstantin Belousov MLX5_SET(nic_vport_context, nic_vport_ctx, 11091ad1bd9SKonstantin Belousov event_on_uc_address_change, 1); 11191ad1bd9SKonstantin Belousov if (events_mask & MC_ADDR_CHANGE) 11291ad1bd9SKonstantin Belousov MLX5_SET(nic_vport_context, nic_vport_ctx, 11391ad1bd9SKonstantin Belousov event_on_mc_address_change, 1); 11491ad1bd9SKonstantin Belousov 11591ad1bd9SKonstantin Belousov return mlx5_cmd_exec(dev, in, sizeof(in), out, sizeof(out)); 11691ad1bd9SKonstantin Belousov } 11791ad1bd9SKonstantin Belousov 11891ad1bd9SKonstantin Belousov /* E-Switch vport context HW commands */ 11991ad1bd9SKonstantin Belousov static int query_esw_vport_context_cmd(struct mlx5_core_dev *mdev, u32 vport, 12091ad1bd9SKonstantin Belousov u32 *out, int outlen) 12191ad1bd9SKonstantin Belousov { 12291ad1bd9SKonstantin Belousov u32 in[MLX5_ST_SZ_DW(query_esw_vport_context_in)] = {0}; 12391ad1bd9SKonstantin Belousov 12491ad1bd9SKonstantin Belousov MLX5_SET(query_nic_vport_context_in, in, opcode, 12591ad1bd9SKonstantin Belousov MLX5_CMD_OP_QUERY_ESW_VPORT_CONTEXT); 12691ad1bd9SKonstantin Belousov 12791ad1bd9SKonstantin Belousov MLX5_SET(query_esw_vport_context_in, in, vport_number, vport); 12891ad1bd9SKonstantin Belousov if (vport) 12991ad1bd9SKonstantin Belousov MLX5_SET(query_esw_vport_context_in, in, other_vport, 1); 13091ad1bd9SKonstantin Belousov 13191ad1bd9SKonstantin Belousov return mlx5_cmd_exec(mdev, in, sizeof(in), out, outlen); 13291ad1bd9SKonstantin Belousov } 13391ad1bd9SKonstantin Belousov 13491ad1bd9SKonstantin Belousov static int query_esw_vport_cvlan(struct mlx5_core_dev *dev, u32 vport, 13591ad1bd9SKonstantin Belousov u16 *vlan, u8 *qos) 13691ad1bd9SKonstantin Belousov { 13791ad1bd9SKonstantin Belousov u32 out[MLX5_ST_SZ_DW(query_esw_vport_context_out)] = {0}; 13891ad1bd9SKonstantin Belousov int err; 13991ad1bd9SKonstantin Belousov bool cvlan_strip; 14091ad1bd9SKonstantin Belousov bool cvlan_insert; 14191ad1bd9SKonstantin Belousov 14291ad1bd9SKonstantin Belousov *vlan = 0; 14391ad1bd9SKonstantin Belousov *qos = 0; 14491ad1bd9SKonstantin Belousov 14591ad1bd9SKonstantin Belousov if (!MLX5_CAP_ESW(dev, vport_cvlan_strip) || 14691ad1bd9SKonstantin Belousov !MLX5_CAP_ESW(dev, vport_cvlan_insert_if_not_exist)) 14791ad1bd9SKonstantin Belousov return -ENOTSUPP; 14891ad1bd9SKonstantin Belousov 14991ad1bd9SKonstantin Belousov err = query_esw_vport_context_cmd(dev, vport, out, sizeof(out)); 15091ad1bd9SKonstantin Belousov if (err) 15191ad1bd9SKonstantin Belousov goto out; 15291ad1bd9SKonstantin Belousov 15391ad1bd9SKonstantin Belousov cvlan_strip = MLX5_GET(query_esw_vport_context_out, out, 15491ad1bd9SKonstantin Belousov esw_vport_context.vport_cvlan_strip); 15591ad1bd9SKonstantin Belousov 15691ad1bd9SKonstantin Belousov cvlan_insert = MLX5_GET(query_esw_vport_context_out, out, 15791ad1bd9SKonstantin Belousov esw_vport_context.vport_cvlan_insert); 15891ad1bd9SKonstantin Belousov 15991ad1bd9SKonstantin Belousov if (cvlan_strip || cvlan_insert) { 16091ad1bd9SKonstantin Belousov *vlan = MLX5_GET(query_esw_vport_context_out, out, 16191ad1bd9SKonstantin Belousov esw_vport_context.cvlan_id); 16291ad1bd9SKonstantin Belousov *qos = MLX5_GET(query_esw_vport_context_out, out, 16391ad1bd9SKonstantin Belousov esw_vport_context.cvlan_pcp); 16491ad1bd9SKonstantin Belousov } 16591ad1bd9SKonstantin Belousov 16691ad1bd9SKonstantin Belousov esw_debug(dev, "Query Vport[%d] cvlan: VLAN %d qos=%d\n", 16791ad1bd9SKonstantin Belousov vport, *vlan, *qos); 16891ad1bd9SKonstantin Belousov out: 16991ad1bd9SKonstantin Belousov return err; 17091ad1bd9SKonstantin Belousov } 17191ad1bd9SKonstantin Belousov 17291ad1bd9SKonstantin Belousov static int modify_esw_vport_context_cmd(struct mlx5_core_dev *dev, u16 vport, 17391ad1bd9SKonstantin Belousov void *in, int inlen) 17491ad1bd9SKonstantin Belousov { 17591ad1bd9SKonstantin Belousov u32 out[MLX5_ST_SZ_DW(modify_esw_vport_context_out)] = {0}; 17691ad1bd9SKonstantin Belousov 17791ad1bd9SKonstantin Belousov MLX5_SET(modify_esw_vport_context_in, in, vport_number, vport); 17891ad1bd9SKonstantin Belousov if (vport) 17991ad1bd9SKonstantin Belousov MLX5_SET(modify_esw_vport_context_in, in, other_vport, 1); 18091ad1bd9SKonstantin Belousov 18191ad1bd9SKonstantin Belousov MLX5_SET(modify_esw_vport_context_in, in, opcode, 18291ad1bd9SKonstantin Belousov MLX5_CMD_OP_MODIFY_ESW_VPORT_CONTEXT); 18391ad1bd9SKonstantin Belousov 18491ad1bd9SKonstantin Belousov return mlx5_cmd_exec(dev, in, inlen, out, sizeof(out)); 18591ad1bd9SKonstantin Belousov } 18691ad1bd9SKonstantin Belousov 18791ad1bd9SKonstantin Belousov static int modify_esw_vport_cvlan(struct mlx5_core_dev *dev, u32 vport, 18891ad1bd9SKonstantin Belousov u16 vlan, u8 qos, bool set) 18991ad1bd9SKonstantin Belousov { 19091ad1bd9SKonstantin Belousov u32 in[MLX5_ST_SZ_DW(modify_esw_vport_context_in)] = {0}; 19191ad1bd9SKonstantin Belousov 19291ad1bd9SKonstantin Belousov if (!MLX5_CAP_ESW(dev, vport_cvlan_strip) || 19391ad1bd9SKonstantin Belousov !MLX5_CAP_ESW(dev, vport_cvlan_insert_if_not_exist)) 19491ad1bd9SKonstantin Belousov return -ENOTSUPP; 19591ad1bd9SKonstantin Belousov 19691ad1bd9SKonstantin Belousov esw_debug(dev, "Set Vport[%d] VLAN %d qos %d set=%d\n", 19791ad1bd9SKonstantin Belousov vport, vlan, qos, set); 19891ad1bd9SKonstantin Belousov 19991ad1bd9SKonstantin Belousov if (set) { 20091ad1bd9SKonstantin Belousov MLX5_SET(modify_esw_vport_context_in, in, 20191ad1bd9SKonstantin Belousov esw_vport_context.vport_cvlan_strip, 1); 20291ad1bd9SKonstantin Belousov /* insert only if no vlan in packet */ 20391ad1bd9SKonstantin Belousov MLX5_SET(modify_esw_vport_context_in, in, 20491ad1bd9SKonstantin Belousov esw_vport_context.vport_cvlan_insert, 1); 20591ad1bd9SKonstantin Belousov MLX5_SET(modify_esw_vport_context_in, in, 20691ad1bd9SKonstantin Belousov esw_vport_context.cvlan_pcp, qos); 20791ad1bd9SKonstantin Belousov MLX5_SET(modify_esw_vport_context_in, in, 20891ad1bd9SKonstantin Belousov esw_vport_context.cvlan_id, vlan); 20991ad1bd9SKonstantin Belousov } 21091ad1bd9SKonstantin Belousov 21191ad1bd9SKonstantin Belousov MLX5_SET(modify_esw_vport_context_in, in, 21291ad1bd9SKonstantin Belousov field_select.vport_cvlan_strip, 1); 21391ad1bd9SKonstantin Belousov MLX5_SET(modify_esw_vport_context_in, in, 21491ad1bd9SKonstantin Belousov field_select.vport_cvlan_insert, 1); 21591ad1bd9SKonstantin Belousov 21691ad1bd9SKonstantin Belousov return modify_esw_vport_context_cmd(dev, vport, in, sizeof(in)); 21791ad1bd9SKonstantin Belousov } 21891ad1bd9SKonstantin Belousov 21991ad1bd9SKonstantin Belousov /* E-Switch FDB */ 22091ad1bd9SKonstantin Belousov static struct mlx5_flow_rule * 22191ad1bd9SKonstantin Belousov esw_fdb_set_vport_rule(struct mlx5_eswitch *esw, u8 mac[ETH_ALEN], u32 vport) 22291ad1bd9SKonstantin Belousov { 22391ad1bd9SKonstantin Belousov int match_header = MLX5_MATCH_OUTER_HEADERS; 22491ad1bd9SKonstantin Belousov struct mlx5_flow_destination dest; 22591ad1bd9SKonstantin Belousov struct mlx5_flow_rule *flow_rule = NULL; 22691ad1bd9SKonstantin Belousov u32 *match_v; 22791ad1bd9SKonstantin Belousov u32 *match_c; 22891ad1bd9SKonstantin Belousov u8 *dmac_v; 22991ad1bd9SKonstantin Belousov u8 *dmac_c; 23091ad1bd9SKonstantin Belousov 23191ad1bd9SKonstantin Belousov match_v = kzalloc(MLX5_ST_SZ_BYTES(fte_match_param), GFP_KERNEL); 23291ad1bd9SKonstantin Belousov match_c = kzalloc(MLX5_ST_SZ_BYTES(fte_match_param), GFP_KERNEL); 23391ad1bd9SKonstantin Belousov if (!match_v || !match_c) { 23491ad1bd9SKonstantin Belousov printf("mlx5_core: WARN: ""FDB: Failed to alloc match parameters\n"); 23591ad1bd9SKonstantin Belousov goto out; 23691ad1bd9SKonstantin Belousov } 23791ad1bd9SKonstantin Belousov dmac_v = MLX5_ADDR_OF(fte_match_param, match_v, 23891ad1bd9SKonstantin Belousov outer_headers.dmac_47_16); 23991ad1bd9SKonstantin Belousov dmac_c = MLX5_ADDR_OF(fte_match_param, match_c, 24091ad1bd9SKonstantin Belousov outer_headers.dmac_47_16); 24191ad1bd9SKonstantin Belousov 24291ad1bd9SKonstantin Belousov ether_addr_copy(dmac_v, mac); 24391ad1bd9SKonstantin Belousov /* Match criteria mask */ 24491ad1bd9SKonstantin Belousov memset(dmac_c, 0xff, 6); 24591ad1bd9SKonstantin Belousov 24691ad1bd9SKonstantin Belousov dest.type = MLX5_FLOW_CONTEXT_DEST_TYPE_VPORT; 24791ad1bd9SKonstantin Belousov dest.vport_num = vport; 24891ad1bd9SKonstantin Belousov 24991ad1bd9SKonstantin Belousov esw_debug(esw->dev, 25091ad1bd9SKonstantin Belousov "\tFDB add rule dmac_v(%pM) dmac_c(%pM) -> vport(%d)\n", 25191ad1bd9SKonstantin Belousov dmac_v, dmac_c, vport); 25291ad1bd9SKonstantin Belousov flow_rule = 25391ad1bd9SKonstantin Belousov mlx5_add_flow_rule(esw->fdb_table.fdb, 25491ad1bd9SKonstantin Belousov match_header, 25591ad1bd9SKonstantin Belousov match_c, 25691ad1bd9SKonstantin Belousov match_v, 25791ad1bd9SKonstantin Belousov MLX5_FLOW_CONTEXT_ACTION_FWD_DEST, 25891ad1bd9SKonstantin Belousov 0, &dest); 25991ad1bd9SKonstantin Belousov if (IS_ERR_OR_NULL(flow_rule)) { 26091ad1bd9SKonstantin Belousov printf("mlx5_core: WARN: ""FDB: Failed to add flow rule: dmac_v(%pM) dmac_c(%pM) -> vport(%d), err(%ld)\n", dmac_v, dmac_c, vport, PTR_ERR(flow_rule)); 26191ad1bd9SKonstantin Belousov flow_rule = NULL; 26291ad1bd9SKonstantin Belousov } 26391ad1bd9SKonstantin Belousov out: 26491ad1bd9SKonstantin Belousov kfree(match_v); 26591ad1bd9SKonstantin Belousov kfree(match_c); 26691ad1bd9SKonstantin Belousov return flow_rule; 26791ad1bd9SKonstantin Belousov } 26891ad1bd9SKonstantin Belousov 26991ad1bd9SKonstantin Belousov static int esw_create_fdb_table(struct mlx5_eswitch *esw) 27091ad1bd9SKonstantin Belousov { 27191ad1bd9SKonstantin Belousov int inlen = MLX5_ST_SZ_BYTES(create_flow_group_in); 27291ad1bd9SKonstantin Belousov struct mlx5_core_dev *dev = esw->dev; 27391ad1bd9SKonstantin Belousov struct mlx5_flow_namespace *root_ns; 27491ad1bd9SKonstantin Belousov struct mlx5_flow_table *fdb; 27591ad1bd9SKonstantin Belousov struct mlx5_flow_group *g; 27691ad1bd9SKonstantin Belousov void *match_criteria; 27791ad1bd9SKonstantin Belousov int table_size; 27891ad1bd9SKonstantin Belousov u32 *flow_group_in; 27991ad1bd9SKonstantin Belousov u8 *dmac; 28091ad1bd9SKonstantin Belousov int err = 0; 28191ad1bd9SKonstantin Belousov 28291ad1bd9SKonstantin Belousov esw_debug(dev, "Create FDB log_max_size(%d)\n", 28391ad1bd9SKonstantin Belousov MLX5_CAP_ESW_FLOWTABLE_FDB(dev, log_max_ft_size)); 28491ad1bd9SKonstantin Belousov 28591ad1bd9SKonstantin Belousov root_ns = mlx5_get_flow_namespace(dev, MLX5_FLOW_NAMESPACE_FDB); 28691ad1bd9SKonstantin Belousov if (!root_ns) { 28791ad1bd9SKonstantin Belousov esw_warn(dev, "Failed to get FDB flow namespace\n"); 28891ad1bd9SKonstantin Belousov return -ENOMEM; 28991ad1bd9SKonstantin Belousov } 29091ad1bd9SKonstantin Belousov 29191ad1bd9SKonstantin Belousov flow_group_in = mlx5_vzalloc(inlen); 29291ad1bd9SKonstantin Belousov if (!flow_group_in) 29391ad1bd9SKonstantin Belousov return -ENOMEM; 29491ad1bd9SKonstantin Belousov memset(flow_group_in, 0, inlen); 29591ad1bd9SKonstantin Belousov 29691ad1bd9SKonstantin Belousov /* (-2) Since MaorG said so .. */ 29791ad1bd9SKonstantin Belousov table_size = BIT(MLX5_CAP_ESW_FLOWTABLE_FDB(dev, log_max_ft_size)) - 2; 29891ad1bd9SKonstantin Belousov 29991ad1bd9SKonstantin Belousov fdb = mlx5_create_flow_table(root_ns, 0, "FDB", table_size); 30091ad1bd9SKonstantin Belousov if (IS_ERR_OR_NULL(fdb)) { 30191ad1bd9SKonstantin Belousov err = PTR_ERR(fdb); 30291ad1bd9SKonstantin Belousov esw_warn(dev, "Failed to create FDB Table err %d\n", err); 30391ad1bd9SKonstantin Belousov goto out; 30491ad1bd9SKonstantin Belousov } 30591ad1bd9SKonstantin Belousov 30691ad1bd9SKonstantin Belousov MLX5_SET(create_flow_group_in, flow_group_in, match_criteria_enable, 30791ad1bd9SKonstantin Belousov MLX5_MATCH_OUTER_HEADERS); 30891ad1bd9SKonstantin Belousov match_criteria = MLX5_ADDR_OF(create_flow_group_in, flow_group_in, match_criteria); 30991ad1bd9SKonstantin Belousov dmac = MLX5_ADDR_OF(fte_match_param, match_criteria, outer_headers.dmac_47_16); 31091ad1bd9SKonstantin Belousov MLX5_SET(create_flow_group_in, flow_group_in, start_flow_index, 0); 31191ad1bd9SKonstantin Belousov MLX5_SET(create_flow_group_in, flow_group_in, end_flow_index, table_size - 1); 31291ad1bd9SKonstantin Belousov eth_broadcast_addr(dmac); 31391ad1bd9SKonstantin Belousov 31491ad1bd9SKonstantin Belousov g = mlx5_create_flow_group(fdb, flow_group_in); 31591ad1bd9SKonstantin Belousov if (IS_ERR_OR_NULL(g)) { 31691ad1bd9SKonstantin Belousov err = PTR_ERR(g); 31791ad1bd9SKonstantin Belousov esw_warn(dev, "Failed to create flow group err(%d)\n", err); 31891ad1bd9SKonstantin Belousov goto out; 31991ad1bd9SKonstantin Belousov } 32091ad1bd9SKonstantin Belousov 32191ad1bd9SKonstantin Belousov esw->fdb_table.addr_grp = g; 32291ad1bd9SKonstantin Belousov esw->fdb_table.fdb = fdb; 32391ad1bd9SKonstantin Belousov out: 32491ad1bd9SKonstantin Belousov kfree(flow_group_in); 32591ad1bd9SKonstantin Belousov if (err && !IS_ERR_OR_NULL(fdb)) 32691ad1bd9SKonstantin Belousov mlx5_destroy_flow_table(fdb); 32791ad1bd9SKonstantin Belousov return err; 32891ad1bd9SKonstantin Belousov } 32991ad1bd9SKonstantin Belousov 33091ad1bd9SKonstantin Belousov static void esw_destroy_fdb_table(struct mlx5_eswitch *esw) 33191ad1bd9SKonstantin Belousov { 33291ad1bd9SKonstantin Belousov if (!esw->fdb_table.fdb) 33391ad1bd9SKonstantin Belousov return; 33491ad1bd9SKonstantin Belousov 33591ad1bd9SKonstantin Belousov esw_debug(esw->dev, "Destroy FDB Table\n"); 33691ad1bd9SKonstantin Belousov mlx5_destroy_flow_group(esw->fdb_table.addr_grp); 33791ad1bd9SKonstantin Belousov mlx5_destroy_flow_table(esw->fdb_table.fdb); 33891ad1bd9SKonstantin Belousov esw->fdb_table.fdb = NULL; 33991ad1bd9SKonstantin Belousov esw->fdb_table.addr_grp = NULL; 34091ad1bd9SKonstantin Belousov } 34191ad1bd9SKonstantin Belousov 34291ad1bd9SKonstantin Belousov /* E-Switch vport UC/MC lists management */ 34391ad1bd9SKonstantin Belousov typedef int (*vport_addr_action)(struct mlx5_eswitch *esw, 34491ad1bd9SKonstantin Belousov struct vport_addr *vaddr); 34591ad1bd9SKonstantin Belousov 34691ad1bd9SKonstantin Belousov static int esw_add_uc_addr(struct mlx5_eswitch *esw, struct vport_addr *vaddr) 34791ad1bd9SKonstantin Belousov { 34891ad1bd9SKonstantin Belousov struct hlist_head *hash = esw->l2_table.l2_hash; 34991ad1bd9SKonstantin Belousov struct esw_uc_addr *esw_uc; 35091ad1bd9SKonstantin Belousov u8 *mac = vaddr->node.addr; 35191ad1bd9SKonstantin Belousov u32 vport = vaddr->vport; 35291ad1bd9SKonstantin Belousov int err; 35391ad1bd9SKonstantin Belousov 35491ad1bd9SKonstantin Belousov esw_uc = l2addr_hash_find(hash, mac, struct esw_uc_addr); 35591ad1bd9SKonstantin Belousov if (esw_uc) { 35691ad1bd9SKonstantin Belousov esw_warn(esw->dev, 35791ad1bd9SKonstantin Belousov "Failed to set L2 mac(%pM) for vport(%d), mac is already in use by vport(%d)\n", 35891ad1bd9SKonstantin Belousov mac, vport, esw_uc->vport); 35991ad1bd9SKonstantin Belousov return -EEXIST; 36091ad1bd9SKonstantin Belousov } 36191ad1bd9SKonstantin Belousov 36291ad1bd9SKonstantin Belousov esw_uc = l2addr_hash_add(hash, mac, struct esw_uc_addr, GFP_KERNEL); 36391ad1bd9SKonstantin Belousov if (!esw_uc) 36491ad1bd9SKonstantin Belousov return -ENOMEM; 36591ad1bd9SKonstantin Belousov esw_uc->vport = vport; 36691ad1bd9SKonstantin Belousov 367f6ca0b21SKonstantin Belousov err = mlx5_mpfs_add_mac(esw->dev, &esw_uc->table_index, mac, 0, 0); 36891ad1bd9SKonstantin Belousov if (err) 36991ad1bd9SKonstantin Belousov goto abort; 37091ad1bd9SKonstantin Belousov 37191ad1bd9SKonstantin Belousov if (esw->fdb_table.fdb) /* SRIOV is enabled: Forward UC MAC to vport */ 37291ad1bd9SKonstantin Belousov vaddr->flow_rule = esw_fdb_set_vport_rule(esw, mac, vport); 37391ad1bd9SKonstantin Belousov 37491ad1bd9SKonstantin Belousov esw_debug(esw->dev, "\tADDED UC MAC: vport[%d] %pM index:%d fr(%p)\n", 37591ad1bd9SKonstantin Belousov vport, mac, esw_uc->table_index, vaddr->flow_rule); 37691ad1bd9SKonstantin Belousov return err; 37791ad1bd9SKonstantin Belousov abort: 37891ad1bd9SKonstantin Belousov l2addr_hash_del(esw_uc); 37991ad1bd9SKonstantin Belousov return err; 38091ad1bd9SKonstantin Belousov } 38191ad1bd9SKonstantin Belousov 38291ad1bd9SKonstantin Belousov static int esw_del_uc_addr(struct mlx5_eswitch *esw, struct vport_addr *vaddr) 38391ad1bd9SKonstantin Belousov { 38491ad1bd9SKonstantin Belousov struct hlist_head *hash = esw->l2_table.l2_hash; 38591ad1bd9SKonstantin Belousov struct esw_uc_addr *esw_uc; 38691ad1bd9SKonstantin Belousov u8 *mac = vaddr->node.addr; 38791ad1bd9SKonstantin Belousov u32 vport = vaddr->vport; 38891ad1bd9SKonstantin Belousov 38991ad1bd9SKonstantin Belousov esw_uc = l2addr_hash_find(hash, mac, struct esw_uc_addr); 39091ad1bd9SKonstantin Belousov if (!esw_uc || esw_uc->vport != vport) { 39191ad1bd9SKonstantin Belousov esw_debug(esw->dev, 39291ad1bd9SKonstantin Belousov "MAC(%pM) doesn't belong to vport (%d)\n", 39391ad1bd9SKonstantin Belousov mac, vport); 39491ad1bd9SKonstantin Belousov return -EINVAL; 39591ad1bd9SKonstantin Belousov } 39691ad1bd9SKonstantin Belousov esw_debug(esw->dev, "\tDELETE UC MAC: vport[%d] %pM index:%d fr(%p)\n", 39791ad1bd9SKonstantin Belousov vport, mac, esw_uc->table_index, vaddr->flow_rule); 39891ad1bd9SKonstantin Belousov 399f6ca0b21SKonstantin Belousov mlx5_mpfs_del_mac(esw->dev, esw_uc->table_index); 40091ad1bd9SKonstantin Belousov 40191ad1bd9SKonstantin Belousov if (vaddr->flow_rule) 40291ad1bd9SKonstantin Belousov mlx5_del_flow_rule(vaddr->flow_rule); 40391ad1bd9SKonstantin Belousov vaddr->flow_rule = NULL; 40491ad1bd9SKonstantin Belousov 40591ad1bd9SKonstantin Belousov l2addr_hash_del(esw_uc); 40691ad1bd9SKonstantin Belousov return 0; 40791ad1bd9SKonstantin Belousov } 40891ad1bd9SKonstantin Belousov 40991ad1bd9SKonstantin Belousov static int esw_add_mc_addr(struct mlx5_eswitch *esw, struct vport_addr *vaddr) 41091ad1bd9SKonstantin Belousov { 41191ad1bd9SKonstantin Belousov struct hlist_head *hash = esw->mc_table; 41291ad1bd9SKonstantin Belousov struct esw_mc_addr *esw_mc; 41391ad1bd9SKonstantin Belousov u8 *mac = vaddr->node.addr; 41491ad1bd9SKonstantin Belousov u32 vport = vaddr->vport; 41591ad1bd9SKonstantin Belousov 41691ad1bd9SKonstantin Belousov if (!esw->fdb_table.fdb) 41791ad1bd9SKonstantin Belousov return 0; 41891ad1bd9SKonstantin Belousov 41991ad1bd9SKonstantin Belousov esw_mc = l2addr_hash_find(hash, mac, struct esw_mc_addr); 42091ad1bd9SKonstantin Belousov if (esw_mc) 42191ad1bd9SKonstantin Belousov goto add; 42291ad1bd9SKonstantin Belousov 42391ad1bd9SKonstantin Belousov esw_mc = l2addr_hash_add(hash, mac, struct esw_mc_addr, GFP_KERNEL); 42491ad1bd9SKonstantin Belousov if (!esw_mc) 42591ad1bd9SKonstantin Belousov return -ENOMEM; 42691ad1bd9SKonstantin Belousov 42791ad1bd9SKonstantin Belousov esw_mc->uplink_rule = /* Forward MC MAC to Uplink */ 42891ad1bd9SKonstantin Belousov esw_fdb_set_vport_rule(esw, mac, UPLINK_VPORT); 42991ad1bd9SKonstantin Belousov add: 43091ad1bd9SKonstantin Belousov esw_mc->refcnt++; 43191ad1bd9SKonstantin Belousov /* Forward MC MAC to vport */ 43291ad1bd9SKonstantin Belousov vaddr->flow_rule = esw_fdb_set_vport_rule(esw, mac, vport); 43391ad1bd9SKonstantin Belousov esw_debug(esw->dev, 43491ad1bd9SKonstantin Belousov "\tADDED MC MAC: vport[%d] %pM fr(%p) refcnt(%d) uplinkfr(%p)\n", 43591ad1bd9SKonstantin Belousov vport, mac, vaddr->flow_rule, 43691ad1bd9SKonstantin Belousov esw_mc->refcnt, esw_mc->uplink_rule); 43791ad1bd9SKonstantin Belousov return 0; 43891ad1bd9SKonstantin Belousov } 43991ad1bd9SKonstantin Belousov 44091ad1bd9SKonstantin Belousov static int esw_del_mc_addr(struct mlx5_eswitch *esw, struct vport_addr *vaddr) 44191ad1bd9SKonstantin Belousov { 44291ad1bd9SKonstantin Belousov struct hlist_head *hash = esw->mc_table; 44391ad1bd9SKonstantin Belousov struct esw_mc_addr *esw_mc; 44491ad1bd9SKonstantin Belousov u8 *mac = vaddr->node.addr; 44591ad1bd9SKonstantin Belousov u32 vport = vaddr->vport; 44691ad1bd9SKonstantin Belousov 44791ad1bd9SKonstantin Belousov if (!esw->fdb_table.fdb) 44891ad1bd9SKonstantin Belousov return 0; 44991ad1bd9SKonstantin Belousov 45091ad1bd9SKonstantin Belousov esw_mc = l2addr_hash_find(hash, mac, struct esw_mc_addr); 45191ad1bd9SKonstantin Belousov if (!esw_mc) { 45291ad1bd9SKonstantin Belousov esw_warn(esw->dev, 45391ad1bd9SKonstantin Belousov "Failed to find eswitch MC addr for MAC(%pM) vport(%d)", 45491ad1bd9SKonstantin Belousov mac, vport); 45591ad1bd9SKonstantin Belousov return -EINVAL; 45691ad1bd9SKonstantin Belousov } 45791ad1bd9SKonstantin Belousov esw_debug(esw->dev, 45891ad1bd9SKonstantin Belousov "\tDELETE MC MAC: vport[%d] %pM fr(%p) refcnt(%d) uplinkfr(%p)\n", 45991ad1bd9SKonstantin Belousov vport, mac, vaddr->flow_rule, esw_mc->refcnt, 46091ad1bd9SKonstantin Belousov esw_mc->uplink_rule); 46191ad1bd9SKonstantin Belousov 46291ad1bd9SKonstantin Belousov if (vaddr->flow_rule) 46391ad1bd9SKonstantin Belousov mlx5_del_flow_rule(vaddr->flow_rule); 46491ad1bd9SKonstantin Belousov vaddr->flow_rule = NULL; 46591ad1bd9SKonstantin Belousov 46691ad1bd9SKonstantin Belousov if (--esw_mc->refcnt) 46791ad1bd9SKonstantin Belousov return 0; 46891ad1bd9SKonstantin Belousov 46991ad1bd9SKonstantin Belousov if (esw_mc->uplink_rule) 47091ad1bd9SKonstantin Belousov mlx5_del_flow_rule(esw_mc->uplink_rule); 47191ad1bd9SKonstantin Belousov 47291ad1bd9SKonstantin Belousov l2addr_hash_del(esw_mc); 47391ad1bd9SKonstantin Belousov return 0; 47491ad1bd9SKonstantin Belousov } 47591ad1bd9SKonstantin Belousov 47691ad1bd9SKonstantin Belousov /* Apply vport UC/MC list to HW l2 table and FDB table */ 47791ad1bd9SKonstantin Belousov static void esw_apply_vport_addr_list(struct mlx5_eswitch *esw, 47891ad1bd9SKonstantin Belousov u32 vport_num, int list_type) 47991ad1bd9SKonstantin Belousov { 48091ad1bd9SKonstantin Belousov struct mlx5_vport *vport = &esw->vports[vport_num]; 48191ad1bd9SKonstantin Belousov bool is_uc = list_type == MLX5_NIC_VPORT_LIST_TYPE_UC; 48291ad1bd9SKonstantin Belousov vport_addr_action vport_addr_add; 48391ad1bd9SKonstantin Belousov vport_addr_action vport_addr_del; 48491ad1bd9SKonstantin Belousov struct vport_addr *addr; 48591ad1bd9SKonstantin Belousov struct l2addr_node *node; 48691ad1bd9SKonstantin Belousov struct hlist_head *hash; 48791ad1bd9SKonstantin Belousov struct hlist_node *tmp; 48891ad1bd9SKonstantin Belousov int hi; 48991ad1bd9SKonstantin Belousov 49091ad1bd9SKonstantin Belousov vport_addr_add = is_uc ? esw_add_uc_addr : 49191ad1bd9SKonstantin Belousov esw_add_mc_addr; 49291ad1bd9SKonstantin Belousov vport_addr_del = is_uc ? esw_del_uc_addr : 49391ad1bd9SKonstantin Belousov esw_del_mc_addr; 49491ad1bd9SKonstantin Belousov 49591ad1bd9SKonstantin Belousov hash = is_uc ? vport->uc_list : vport->mc_list; 49691ad1bd9SKonstantin Belousov for_each_l2hash_node(node, tmp, hash, hi) { 49791ad1bd9SKonstantin Belousov addr = container_of(node, struct vport_addr, node); 49891ad1bd9SKonstantin Belousov switch (addr->action) { 49991ad1bd9SKonstantin Belousov case MLX5_ACTION_ADD: 50091ad1bd9SKonstantin Belousov vport_addr_add(esw, addr); 50191ad1bd9SKonstantin Belousov addr->action = MLX5_ACTION_NONE; 50291ad1bd9SKonstantin Belousov break; 50391ad1bd9SKonstantin Belousov case MLX5_ACTION_DEL: 50491ad1bd9SKonstantin Belousov vport_addr_del(esw, addr); 50591ad1bd9SKonstantin Belousov l2addr_hash_del(addr); 50691ad1bd9SKonstantin Belousov break; 50791ad1bd9SKonstantin Belousov } 50891ad1bd9SKonstantin Belousov } 50991ad1bd9SKonstantin Belousov } 51091ad1bd9SKonstantin Belousov 51191ad1bd9SKonstantin Belousov /* Sync vport UC/MC list from vport context */ 51291ad1bd9SKonstantin Belousov static void esw_update_vport_addr_list(struct mlx5_eswitch *esw, 51391ad1bd9SKonstantin Belousov u32 vport_num, int list_type) 51491ad1bd9SKonstantin Belousov { 51591ad1bd9SKonstantin Belousov struct mlx5_vport *vport = &esw->vports[vport_num]; 51691ad1bd9SKonstantin Belousov bool is_uc = list_type == MLX5_NIC_VPORT_LIST_TYPE_UC; 51791ad1bd9SKonstantin Belousov u8 (*mac_list)[ETH_ALEN]; 51891ad1bd9SKonstantin Belousov struct l2addr_node *node; 51991ad1bd9SKonstantin Belousov struct vport_addr *addr; 52091ad1bd9SKonstantin Belousov struct hlist_head *hash; 52191ad1bd9SKonstantin Belousov struct hlist_node *tmp; 52291ad1bd9SKonstantin Belousov int size; 52391ad1bd9SKonstantin Belousov int err; 52491ad1bd9SKonstantin Belousov int hi; 52591ad1bd9SKonstantin Belousov int i; 52691ad1bd9SKonstantin Belousov 52791ad1bd9SKonstantin Belousov size = is_uc ? MLX5_MAX_UC_PER_VPORT(esw->dev) : 52891ad1bd9SKonstantin Belousov MLX5_MAX_MC_PER_VPORT(esw->dev); 52991ad1bd9SKonstantin Belousov 53091ad1bd9SKonstantin Belousov mac_list = kcalloc(size, ETH_ALEN, GFP_KERNEL); 53191ad1bd9SKonstantin Belousov if (!mac_list) 53291ad1bd9SKonstantin Belousov return; 53391ad1bd9SKonstantin Belousov 53491ad1bd9SKonstantin Belousov hash = is_uc ? vport->uc_list : vport->mc_list; 53591ad1bd9SKonstantin Belousov 53691ad1bd9SKonstantin Belousov for_each_l2hash_node(node, tmp, hash, hi) { 53791ad1bd9SKonstantin Belousov addr = container_of(node, struct vport_addr, node); 53891ad1bd9SKonstantin Belousov addr->action = MLX5_ACTION_DEL; 53991ad1bd9SKonstantin Belousov } 54091ad1bd9SKonstantin Belousov 54191ad1bd9SKonstantin Belousov err = mlx5_query_nic_vport_mac_list(esw->dev, vport_num, list_type, 54291ad1bd9SKonstantin Belousov mac_list, &size); 54391ad1bd9SKonstantin Belousov if (err) 54491ad1bd9SKonstantin Belousov return; 54591ad1bd9SKonstantin Belousov esw_debug(esw->dev, "vport[%d] context update %s list size (%d)\n", 54691ad1bd9SKonstantin Belousov vport_num, is_uc ? "UC" : "MC", size); 54791ad1bd9SKonstantin Belousov 54891ad1bd9SKonstantin Belousov for (i = 0; i < size; i++) { 54991ad1bd9SKonstantin Belousov if (is_uc && !is_valid_ether_addr(mac_list[i])) 55091ad1bd9SKonstantin Belousov continue; 55191ad1bd9SKonstantin Belousov 55291ad1bd9SKonstantin Belousov if (!is_uc && !is_multicast_ether_addr(mac_list[i])) 55391ad1bd9SKonstantin Belousov continue; 55491ad1bd9SKonstantin Belousov 55591ad1bd9SKonstantin Belousov addr = l2addr_hash_find(hash, mac_list[i], struct vport_addr); 55691ad1bd9SKonstantin Belousov if (addr) { 55791ad1bd9SKonstantin Belousov addr->action = MLX5_ACTION_NONE; 55891ad1bd9SKonstantin Belousov continue; 55991ad1bd9SKonstantin Belousov } 56091ad1bd9SKonstantin Belousov 56191ad1bd9SKonstantin Belousov addr = l2addr_hash_add(hash, mac_list[i], struct vport_addr, 56291ad1bd9SKonstantin Belousov GFP_KERNEL); 56391ad1bd9SKonstantin Belousov if (!addr) { 56491ad1bd9SKonstantin Belousov esw_warn(esw->dev, 56591ad1bd9SKonstantin Belousov "Failed to add MAC(%pM) to vport[%d] DB\n", 56691ad1bd9SKonstantin Belousov mac_list[i], vport_num); 56791ad1bd9SKonstantin Belousov continue; 56891ad1bd9SKonstantin Belousov } 56991ad1bd9SKonstantin Belousov addr->vport = vport_num; 57091ad1bd9SKonstantin Belousov addr->action = MLX5_ACTION_ADD; 57191ad1bd9SKonstantin Belousov } 57291ad1bd9SKonstantin Belousov kfree(mac_list); 57391ad1bd9SKonstantin Belousov } 57491ad1bd9SKonstantin Belousov 57591ad1bd9SKonstantin Belousov static void esw_vport_change_handler(struct work_struct *work) 57691ad1bd9SKonstantin Belousov { 57791ad1bd9SKonstantin Belousov struct mlx5_vport *vport = 57891ad1bd9SKonstantin Belousov container_of(work, struct mlx5_vport, vport_change_handler); 57991ad1bd9SKonstantin Belousov struct mlx5_core_dev *dev = vport->dev; 58091ad1bd9SKonstantin Belousov struct mlx5_eswitch *esw = dev->priv.eswitch; 58191ad1bd9SKonstantin Belousov u8 mac[ETH_ALEN]; 58291ad1bd9SKonstantin Belousov 58391ad1bd9SKonstantin Belousov mlx5_query_nic_vport_mac_address(dev, vport->vport, mac); 58491ad1bd9SKonstantin Belousov esw_debug(dev, "vport[%d] Context Changed: perm mac: %pM\n", 58591ad1bd9SKonstantin Belousov vport->vport, mac); 58691ad1bd9SKonstantin Belousov 58791ad1bd9SKonstantin Belousov if (vport->enabled_events & UC_ADDR_CHANGE) { 58891ad1bd9SKonstantin Belousov esw_update_vport_addr_list(esw, vport->vport, 58991ad1bd9SKonstantin Belousov MLX5_NIC_VPORT_LIST_TYPE_UC); 59091ad1bd9SKonstantin Belousov esw_apply_vport_addr_list(esw, vport->vport, 59191ad1bd9SKonstantin Belousov MLX5_NIC_VPORT_LIST_TYPE_UC); 59291ad1bd9SKonstantin Belousov } 59391ad1bd9SKonstantin Belousov 59491ad1bd9SKonstantin Belousov if (vport->enabled_events & MC_ADDR_CHANGE) { 59591ad1bd9SKonstantin Belousov esw_update_vport_addr_list(esw, vport->vport, 59691ad1bd9SKonstantin Belousov MLX5_NIC_VPORT_LIST_TYPE_MC); 59791ad1bd9SKonstantin Belousov esw_apply_vport_addr_list(esw, vport->vport, 59891ad1bd9SKonstantin Belousov MLX5_NIC_VPORT_LIST_TYPE_MC); 59991ad1bd9SKonstantin Belousov } 60091ad1bd9SKonstantin Belousov 60191ad1bd9SKonstantin Belousov esw_debug(esw->dev, "vport[%d] Context Changed: Done\n", vport->vport); 60291ad1bd9SKonstantin Belousov if (vport->enabled) 60391ad1bd9SKonstantin Belousov arm_vport_context_events_cmd(dev, vport->vport, 60491ad1bd9SKonstantin Belousov vport->enabled_events); 60591ad1bd9SKonstantin Belousov } 60691ad1bd9SKonstantin Belousov 60791ad1bd9SKonstantin Belousov static void esw_vport_enable_egress_acl(struct mlx5_eswitch *esw, 60891ad1bd9SKonstantin Belousov struct mlx5_vport *vport) 60991ad1bd9SKonstantin Belousov { 61091ad1bd9SKonstantin Belousov int inlen = MLX5_ST_SZ_BYTES(create_flow_group_in); 61191ad1bd9SKonstantin Belousov struct mlx5_flow_group *vlan_grp = NULL; 61291ad1bd9SKonstantin Belousov struct mlx5_flow_group *drop_grp = NULL; 61391ad1bd9SKonstantin Belousov struct mlx5_core_dev *dev = esw->dev; 61491ad1bd9SKonstantin Belousov struct mlx5_flow_namespace *root_ns; 61591ad1bd9SKonstantin Belousov struct mlx5_flow_table *acl; 61691ad1bd9SKonstantin Belousov void *match_criteria; 61791ad1bd9SKonstantin Belousov char table_name[32]; 61891ad1bd9SKonstantin Belousov u32 *flow_group_in; 61991ad1bd9SKonstantin Belousov int table_size = 2; 62091ad1bd9SKonstantin Belousov int err = 0; 62191ad1bd9SKonstantin Belousov 62291ad1bd9SKonstantin Belousov if (!MLX5_CAP_ESW_EGRESS_ACL(dev, ft_support)) 62391ad1bd9SKonstantin Belousov return; 62491ad1bd9SKonstantin Belousov 62591ad1bd9SKonstantin Belousov esw_debug(dev, "Create vport[%d] egress ACL log_max_size(%d)\n", 62691ad1bd9SKonstantin Belousov vport->vport, MLX5_CAP_ESW_EGRESS_ACL(dev, log_max_ft_size)); 62791ad1bd9SKonstantin Belousov 62891ad1bd9SKonstantin Belousov root_ns = mlx5_get_flow_namespace(dev, MLX5_FLOW_NAMESPACE_ESW_EGRESS); 62991ad1bd9SKonstantin Belousov if (!root_ns) { 63091ad1bd9SKonstantin Belousov esw_warn(dev, "Failed to get E-Switch egress flow namespace\n"); 63191ad1bd9SKonstantin Belousov return; 63291ad1bd9SKonstantin Belousov } 63391ad1bd9SKonstantin Belousov 63491ad1bd9SKonstantin Belousov flow_group_in = mlx5_vzalloc(inlen); 63591ad1bd9SKonstantin Belousov if (!flow_group_in) 63691ad1bd9SKonstantin Belousov return; 63791ad1bd9SKonstantin Belousov 63891ad1bd9SKonstantin Belousov snprintf(table_name, 32, "egress_%d", vport->vport); 63991ad1bd9SKonstantin Belousov acl = mlx5_create_vport_flow_table(root_ns, vport->vport, 0, table_name, table_size); 64091ad1bd9SKonstantin Belousov if (IS_ERR_OR_NULL(acl)) { 64191ad1bd9SKonstantin Belousov err = PTR_ERR(acl); 64291ad1bd9SKonstantin Belousov esw_warn(dev, "Failed to create E-Switch vport[%d] egress flow Table, err(%d)\n", 64391ad1bd9SKonstantin Belousov vport->vport, err); 64491ad1bd9SKonstantin Belousov goto out; 64591ad1bd9SKonstantin Belousov } 64691ad1bd9SKonstantin Belousov 64791ad1bd9SKonstantin Belousov MLX5_SET(create_flow_group_in, flow_group_in, match_criteria_enable, MLX5_MATCH_OUTER_HEADERS); 64891ad1bd9SKonstantin Belousov match_criteria = MLX5_ADDR_OF(create_flow_group_in, flow_group_in, match_criteria); 64991ad1bd9SKonstantin Belousov MLX5_SET_TO_ONES(fte_match_param, match_criteria, outer_headers.cvlan_tag); 65091ad1bd9SKonstantin Belousov MLX5_SET_TO_ONES(fte_match_param, match_criteria, outer_headers.first_vid); 65191ad1bd9SKonstantin Belousov MLX5_SET(create_flow_group_in, flow_group_in, start_flow_index, 0); 65291ad1bd9SKonstantin Belousov MLX5_SET(create_flow_group_in, flow_group_in, end_flow_index, 0); 65391ad1bd9SKonstantin Belousov 65491ad1bd9SKonstantin Belousov vlan_grp = mlx5_create_flow_group(acl, flow_group_in); 65591ad1bd9SKonstantin Belousov if (IS_ERR_OR_NULL(vlan_grp)) { 65691ad1bd9SKonstantin Belousov err = PTR_ERR(vlan_grp); 65791ad1bd9SKonstantin Belousov esw_warn(dev, "Failed to create E-Switch vport[%d] egress allowed vlans flow group, err(%d)\n", 65891ad1bd9SKonstantin Belousov vport->vport, err); 65991ad1bd9SKonstantin Belousov goto out; 66091ad1bd9SKonstantin Belousov } 66191ad1bd9SKonstantin Belousov 66291ad1bd9SKonstantin Belousov memset(flow_group_in, 0, inlen); 66391ad1bd9SKonstantin Belousov MLX5_SET(create_flow_group_in, flow_group_in, start_flow_index, 1); 66491ad1bd9SKonstantin Belousov MLX5_SET(create_flow_group_in, flow_group_in, end_flow_index, 1); 66591ad1bd9SKonstantin Belousov drop_grp = mlx5_create_flow_group(acl, flow_group_in); 66691ad1bd9SKonstantin Belousov if (IS_ERR_OR_NULL(drop_grp)) { 66791ad1bd9SKonstantin Belousov err = PTR_ERR(drop_grp); 66891ad1bd9SKonstantin Belousov esw_warn(dev, "Failed to create E-Switch vport[%d] egress drop flow group, err(%d)\n", 66991ad1bd9SKonstantin Belousov vport->vport, err); 67091ad1bd9SKonstantin Belousov goto out; 67191ad1bd9SKonstantin Belousov } 67291ad1bd9SKonstantin Belousov 67391ad1bd9SKonstantin Belousov vport->egress.acl = acl; 67491ad1bd9SKonstantin Belousov vport->egress.drop_grp = drop_grp; 67591ad1bd9SKonstantin Belousov vport->egress.allowed_vlans_grp = vlan_grp; 67691ad1bd9SKonstantin Belousov out: 67791ad1bd9SKonstantin Belousov kfree(flow_group_in); 67891ad1bd9SKonstantin Belousov if (err && !IS_ERR_OR_NULL(vlan_grp)) 67991ad1bd9SKonstantin Belousov mlx5_destroy_flow_group(vlan_grp); 68091ad1bd9SKonstantin Belousov if (err && !IS_ERR_OR_NULL(acl)) 68191ad1bd9SKonstantin Belousov mlx5_destroy_flow_table(acl); 68291ad1bd9SKonstantin Belousov } 68391ad1bd9SKonstantin Belousov 68491ad1bd9SKonstantin Belousov static void esw_vport_cleanup_egress_rules(struct mlx5_eswitch *esw, 68591ad1bd9SKonstantin Belousov struct mlx5_vport *vport) 68691ad1bd9SKonstantin Belousov { 68791ad1bd9SKonstantin Belousov if (!IS_ERR_OR_NULL(vport->egress.allowed_vlan)) 68891ad1bd9SKonstantin Belousov mlx5_del_flow_rule(vport->egress.allowed_vlan); 68991ad1bd9SKonstantin Belousov 69091ad1bd9SKonstantin Belousov if (!IS_ERR_OR_NULL(vport->egress.drop_rule)) 69191ad1bd9SKonstantin Belousov mlx5_del_flow_rule(vport->egress.drop_rule); 69291ad1bd9SKonstantin Belousov 69391ad1bd9SKonstantin Belousov vport->egress.allowed_vlan = NULL; 69491ad1bd9SKonstantin Belousov vport->egress.drop_rule = NULL; 69591ad1bd9SKonstantin Belousov } 69691ad1bd9SKonstantin Belousov 69791ad1bd9SKonstantin Belousov static void esw_vport_disable_egress_acl(struct mlx5_eswitch *esw, 69891ad1bd9SKonstantin Belousov struct mlx5_vport *vport) 69991ad1bd9SKonstantin Belousov { 70091ad1bd9SKonstantin Belousov if (IS_ERR_OR_NULL(vport->egress.acl)) 70191ad1bd9SKonstantin Belousov return; 70291ad1bd9SKonstantin Belousov 70391ad1bd9SKonstantin Belousov esw_debug(esw->dev, "Destroy vport[%d] E-Switch egress ACL\n", vport->vport); 70491ad1bd9SKonstantin Belousov 70591ad1bd9SKonstantin Belousov esw_vport_cleanup_egress_rules(esw, vport); 70691ad1bd9SKonstantin Belousov mlx5_destroy_flow_group(vport->egress.allowed_vlans_grp); 70791ad1bd9SKonstantin Belousov mlx5_destroy_flow_group(vport->egress.drop_grp); 70891ad1bd9SKonstantin Belousov mlx5_destroy_flow_table(vport->egress.acl); 70991ad1bd9SKonstantin Belousov vport->egress.allowed_vlans_grp = NULL; 71091ad1bd9SKonstantin Belousov vport->egress.drop_grp = NULL; 71191ad1bd9SKonstantin Belousov vport->egress.acl = NULL; 71291ad1bd9SKonstantin Belousov } 71391ad1bd9SKonstantin Belousov 71491ad1bd9SKonstantin Belousov static void esw_vport_enable_ingress_acl(struct mlx5_eswitch *esw, 71591ad1bd9SKonstantin Belousov struct mlx5_vport *vport) 71691ad1bd9SKonstantin Belousov { 71791ad1bd9SKonstantin Belousov int inlen = MLX5_ST_SZ_BYTES(create_flow_group_in); 71891ad1bd9SKonstantin Belousov struct mlx5_core_dev *dev = esw->dev; 71991ad1bd9SKonstantin Belousov struct mlx5_flow_namespace *root_ns; 72091ad1bd9SKonstantin Belousov struct mlx5_flow_table *acl; 72191ad1bd9SKonstantin Belousov struct mlx5_flow_group *g; 72291ad1bd9SKonstantin Belousov void *match_criteria; 72391ad1bd9SKonstantin Belousov char table_name[32]; 72491ad1bd9SKonstantin Belousov u32 *flow_group_in; 72591ad1bd9SKonstantin Belousov int table_size = 1; 72691ad1bd9SKonstantin Belousov int err = 0; 72791ad1bd9SKonstantin Belousov 72891ad1bd9SKonstantin Belousov if (!MLX5_CAP_ESW_INGRESS_ACL(dev, ft_support)) 72991ad1bd9SKonstantin Belousov return; 73091ad1bd9SKonstantin Belousov 73191ad1bd9SKonstantin Belousov esw_debug(dev, "Create vport[%d] ingress ACL log_max_size(%d)\n", 73291ad1bd9SKonstantin Belousov vport->vport, MLX5_CAP_ESW_INGRESS_ACL(dev, log_max_ft_size)); 73391ad1bd9SKonstantin Belousov 73491ad1bd9SKonstantin Belousov root_ns = mlx5_get_flow_namespace(dev, MLX5_FLOW_NAMESPACE_ESW_INGRESS); 73591ad1bd9SKonstantin Belousov if (!root_ns) { 73691ad1bd9SKonstantin Belousov esw_warn(dev, "Failed to get E-Switch ingress flow namespace\n"); 73791ad1bd9SKonstantin Belousov return; 73891ad1bd9SKonstantin Belousov } 73991ad1bd9SKonstantin Belousov 74091ad1bd9SKonstantin Belousov flow_group_in = mlx5_vzalloc(inlen); 74191ad1bd9SKonstantin Belousov if (!flow_group_in) 74291ad1bd9SKonstantin Belousov return; 74391ad1bd9SKonstantin Belousov 74491ad1bd9SKonstantin Belousov snprintf(table_name, 32, "ingress_%d", vport->vport); 74591ad1bd9SKonstantin Belousov acl = mlx5_create_vport_flow_table(root_ns, vport->vport, 0, table_name, table_size); 74691ad1bd9SKonstantin Belousov if (IS_ERR_OR_NULL(acl)) { 74791ad1bd9SKonstantin Belousov err = PTR_ERR(acl); 74891ad1bd9SKonstantin Belousov esw_warn(dev, "Failed to create E-Switch vport[%d] ingress flow Table, err(%d)\n", 74991ad1bd9SKonstantin Belousov vport->vport, err); 75091ad1bd9SKonstantin Belousov goto out; 75191ad1bd9SKonstantin Belousov } 75291ad1bd9SKonstantin Belousov 75391ad1bd9SKonstantin Belousov MLX5_SET(create_flow_group_in, flow_group_in, match_criteria_enable, MLX5_MATCH_OUTER_HEADERS); 75491ad1bd9SKonstantin Belousov match_criteria = MLX5_ADDR_OF(create_flow_group_in, flow_group_in, match_criteria); 75591ad1bd9SKonstantin Belousov MLX5_SET_TO_ONES(fte_match_param, match_criteria, outer_headers.cvlan_tag); 75691ad1bd9SKonstantin Belousov MLX5_SET(create_flow_group_in, flow_group_in, start_flow_index, 0); 75791ad1bd9SKonstantin Belousov MLX5_SET(create_flow_group_in, flow_group_in, end_flow_index, 0); 75891ad1bd9SKonstantin Belousov 75991ad1bd9SKonstantin Belousov g = mlx5_create_flow_group(acl, flow_group_in); 76091ad1bd9SKonstantin Belousov if (IS_ERR_OR_NULL(g)) { 76191ad1bd9SKonstantin Belousov err = PTR_ERR(g); 76291ad1bd9SKonstantin Belousov esw_warn(dev, "Failed to create E-Switch vport[%d] ingress flow group, err(%d)\n", 76391ad1bd9SKonstantin Belousov vport->vport, err); 76491ad1bd9SKonstantin Belousov goto out; 76591ad1bd9SKonstantin Belousov } 76691ad1bd9SKonstantin Belousov 76791ad1bd9SKonstantin Belousov vport->ingress.acl = acl; 76891ad1bd9SKonstantin Belousov vport->ingress.drop_grp = g; 76991ad1bd9SKonstantin Belousov out: 77091ad1bd9SKonstantin Belousov kfree(flow_group_in); 77191ad1bd9SKonstantin Belousov if (err && !IS_ERR_OR_NULL(acl)) 77291ad1bd9SKonstantin Belousov mlx5_destroy_flow_table(acl); 77391ad1bd9SKonstantin Belousov } 77491ad1bd9SKonstantin Belousov 77591ad1bd9SKonstantin Belousov static void esw_vport_cleanup_ingress_rules(struct mlx5_eswitch *esw, 77691ad1bd9SKonstantin Belousov struct mlx5_vport *vport) 77791ad1bd9SKonstantin Belousov { 77891ad1bd9SKonstantin Belousov if (!IS_ERR_OR_NULL(vport->ingress.drop_rule)) 77991ad1bd9SKonstantin Belousov mlx5_del_flow_rule(vport->ingress.drop_rule); 78091ad1bd9SKonstantin Belousov vport->ingress.drop_rule = NULL; 78191ad1bd9SKonstantin Belousov } 78291ad1bd9SKonstantin Belousov 78391ad1bd9SKonstantin Belousov static void esw_vport_disable_ingress_acl(struct mlx5_eswitch *esw, 78491ad1bd9SKonstantin Belousov struct mlx5_vport *vport) 78591ad1bd9SKonstantin Belousov { 78691ad1bd9SKonstantin Belousov if (IS_ERR_OR_NULL(vport->ingress.acl)) 78791ad1bd9SKonstantin Belousov return; 78891ad1bd9SKonstantin Belousov 78991ad1bd9SKonstantin Belousov esw_debug(esw->dev, "Destroy vport[%d] E-Switch ingress ACL\n", vport->vport); 79091ad1bd9SKonstantin Belousov 79191ad1bd9SKonstantin Belousov esw_vport_cleanup_ingress_rules(esw, vport); 79291ad1bd9SKonstantin Belousov mlx5_destroy_flow_group(vport->ingress.drop_grp); 79391ad1bd9SKonstantin Belousov mlx5_destroy_flow_table(vport->ingress.acl); 79491ad1bd9SKonstantin Belousov vport->ingress.acl = NULL; 79591ad1bd9SKonstantin Belousov vport->ingress.drop_grp = NULL; 79691ad1bd9SKonstantin Belousov } 79791ad1bd9SKonstantin Belousov 79891ad1bd9SKonstantin Belousov static int esw_vport_ingress_config(struct mlx5_eswitch *esw, 79991ad1bd9SKonstantin Belousov struct mlx5_vport *vport) 80091ad1bd9SKonstantin Belousov { 80191ad1bd9SKonstantin Belousov struct mlx5_flow_destination dest; 80291ad1bd9SKonstantin Belousov u32 *match_v; 80391ad1bd9SKonstantin Belousov u32 *match_c; 80491ad1bd9SKonstantin Belousov int err = 0; 80591ad1bd9SKonstantin Belousov 80691ad1bd9SKonstantin Belousov if (IS_ERR_OR_NULL(vport->ingress.acl)) { 80791ad1bd9SKonstantin Belousov esw_warn(esw->dev, 80891ad1bd9SKonstantin Belousov "vport[%d] configure ingress rules failed, ingress acl is not initialized!\n", 80991ad1bd9SKonstantin Belousov vport->vport); 81091ad1bd9SKonstantin Belousov return -EPERM; 81191ad1bd9SKonstantin Belousov } 81291ad1bd9SKonstantin Belousov 81391ad1bd9SKonstantin Belousov esw_vport_cleanup_ingress_rules(esw, vport); 81491ad1bd9SKonstantin Belousov 81591ad1bd9SKonstantin Belousov if (!vport->vlan && !vport->qos) 81691ad1bd9SKonstantin Belousov return 0; 81791ad1bd9SKonstantin Belousov 81891ad1bd9SKonstantin Belousov esw_debug(esw->dev, 81991ad1bd9SKonstantin Belousov "vport[%d] configure ingress rules, vlan(%d) qos(%d)\n", 82091ad1bd9SKonstantin Belousov vport->vport, vport->vlan, vport->qos); 82191ad1bd9SKonstantin Belousov 82291ad1bd9SKonstantin Belousov match_v = kzalloc(MLX5_ST_SZ_BYTES(fte_match_param), GFP_KERNEL); 82391ad1bd9SKonstantin Belousov match_c = kzalloc(MLX5_ST_SZ_BYTES(fte_match_param), GFP_KERNEL); 82491ad1bd9SKonstantin Belousov if (!match_v || !match_c) { 82591ad1bd9SKonstantin Belousov err = -ENOMEM; 82691ad1bd9SKonstantin Belousov esw_warn(esw->dev, "vport[%d] configure ingress rules failed, err(%d)\n", 82791ad1bd9SKonstantin Belousov vport->vport, err); 82891ad1bd9SKonstantin Belousov goto out; 82991ad1bd9SKonstantin Belousov } 83091ad1bd9SKonstantin Belousov MLX5_SET_TO_ONES(fte_match_param, match_c, outer_headers.cvlan_tag); 83191ad1bd9SKonstantin Belousov MLX5_SET_TO_ONES(fte_match_param, match_v, outer_headers.cvlan_tag); 83291ad1bd9SKonstantin Belousov 83391ad1bd9SKonstantin Belousov dest.type = MLX5_FLOW_CONTEXT_DEST_TYPE_VPORT; 83491ad1bd9SKonstantin Belousov dest.vport_num = vport->vport; 83591ad1bd9SKonstantin Belousov 83691ad1bd9SKonstantin Belousov vport->ingress.drop_rule = 83791ad1bd9SKonstantin Belousov mlx5_add_flow_rule(vport->ingress.acl, 83891ad1bd9SKonstantin Belousov MLX5_MATCH_OUTER_HEADERS, 83991ad1bd9SKonstantin Belousov match_c, 84091ad1bd9SKonstantin Belousov match_v, 84191ad1bd9SKonstantin Belousov MLX5_FLOW_CONTEXT_ACTION_DROP, 84291ad1bd9SKonstantin Belousov 0, &dest); 84391ad1bd9SKonstantin Belousov if (IS_ERR_OR_NULL(vport->ingress.drop_rule)) { 84491ad1bd9SKonstantin Belousov err = PTR_ERR(vport->ingress.drop_rule); 84591ad1bd9SKonstantin Belousov printf("mlx5_core: WARN: ""vport[%d] configure ingress rules, err(%d)\n", vport->vport, err); 84691ad1bd9SKonstantin Belousov vport->ingress.drop_rule = NULL; 84791ad1bd9SKonstantin Belousov } 84891ad1bd9SKonstantin Belousov out: 84991ad1bd9SKonstantin Belousov kfree(match_v); 85091ad1bd9SKonstantin Belousov kfree(match_c); 85191ad1bd9SKonstantin Belousov return err; 85291ad1bd9SKonstantin Belousov } 85391ad1bd9SKonstantin Belousov 85491ad1bd9SKonstantin Belousov static int esw_vport_egress_config(struct mlx5_eswitch *esw, 85591ad1bd9SKonstantin Belousov struct mlx5_vport *vport) 85691ad1bd9SKonstantin Belousov { 85791ad1bd9SKonstantin Belousov struct mlx5_flow_destination dest; 85891ad1bd9SKonstantin Belousov u32 *match_v; 85991ad1bd9SKonstantin Belousov u32 *match_c; 86091ad1bd9SKonstantin Belousov int err = 0; 86191ad1bd9SKonstantin Belousov 86291ad1bd9SKonstantin Belousov if (IS_ERR_OR_NULL(vport->egress.acl)) { 86391ad1bd9SKonstantin Belousov esw_warn(esw->dev, "vport[%d] configure rgress rules failed, egress acl is not initialized!\n", 86491ad1bd9SKonstantin Belousov vport->vport); 86591ad1bd9SKonstantin Belousov return -EPERM; 86691ad1bd9SKonstantin Belousov } 86791ad1bd9SKonstantin Belousov 86891ad1bd9SKonstantin Belousov esw_vport_cleanup_egress_rules(esw, vport); 86991ad1bd9SKonstantin Belousov 87091ad1bd9SKonstantin Belousov if (!vport->vlan && !vport->qos) 87191ad1bd9SKonstantin Belousov return 0; 87291ad1bd9SKonstantin Belousov 87391ad1bd9SKonstantin Belousov esw_debug(esw->dev, 87491ad1bd9SKonstantin Belousov "vport[%d] configure egress rules, vlan(%d) qos(%d)\n", 87591ad1bd9SKonstantin Belousov vport->vport, vport->vlan, vport->qos); 87691ad1bd9SKonstantin Belousov 87791ad1bd9SKonstantin Belousov match_v = kzalloc(MLX5_ST_SZ_BYTES(fte_match_param), GFP_KERNEL); 87891ad1bd9SKonstantin Belousov match_c = kzalloc(MLX5_ST_SZ_BYTES(fte_match_param), GFP_KERNEL); 87991ad1bd9SKonstantin Belousov if (!match_v || !match_c) { 88091ad1bd9SKonstantin Belousov err = -ENOMEM; 88191ad1bd9SKonstantin Belousov esw_warn(esw->dev, "vport[%d] configure egress rules failed, err(%d)\n", 88291ad1bd9SKonstantin Belousov vport->vport, err); 88391ad1bd9SKonstantin Belousov goto out; 88491ad1bd9SKonstantin Belousov } 88591ad1bd9SKonstantin Belousov 88691ad1bd9SKonstantin Belousov /* Allowed vlan rule */ 88791ad1bd9SKonstantin Belousov MLX5_SET_TO_ONES(fte_match_param, match_c, outer_headers.cvlan_tag); 88891ad1bd9SKonstantin Belousov MLX5_SET_TO_ONES(fte_match_param, match_v, outer_headers.cvlan_tag); 88991ad1bd9SKonstantin Belousov MLX5_SET_TO_ONES(fte_match_param, match_c, outer_headers.first_vid); 89091ad1bd9SKonstantin Belousov MLX5_SET(fte_match_param, match_v, outer_headers.first_vid, vport->vlan); 89191ad1bd9SKonstantin Belousov 89291ad1bd9SKonstantin Belousov dest.type = MLX5_FLOW_CONTEXT_DEST_TYPE_VPORT; 89391ad1bd9SKonstantin Belousov dest.vport_num = vport->vport; 89491ad1bd9SKonstantin Belousov 89591ad1bd9SKonstantin Belousov vport->egress.allowed_vlan = 89691ad1bd9SKonstantin Belousov mlx5_add_flow_rule(vport->egress.acl, 89791ad1bd9SKonstantin Belousov MLX5_MATCH_OUTER_HEADERS, 89891ad1bd9SKonstantin Belousov match_c, 89991ad1bd9SKonstantin Belousov match_v, 90091ad1bd9SKonstantin Belousov MLX5_FLOW_CONTEXT_ACTION_ALLOW, 90191ad1bd9SKonstantin Belousov 0, &dest); 90291ad1bd9SKonstantin Belousov if (IS_ERR_OR_NULL(vport->egress.allowed_vlan)) { 90391ad1bd9SKonstantin Belousov err = PTR_ERR(vport->egress.allowed_vlan); 90491ad1bd9SKonstantin Belousov printf("mlx5_core: WARN: ""vport[%d] configure egress allowed vlan rule failed, err(%d)\n", vport->vport, err); 90591ad1bd9SKonstantin Belousov vport->egress.allowed_vlan = NULL; 90691ad1bd9SKonstantin Belousov goto out; 90791ad1bd9SKonstantin Belousov } 90891ad1bd9SKonstantin Belousov 90991ad1bd9SKonstantin Belousov /* Drop others rule (star rule) */ 91091ad1bd9SKonstantin Belousov memset(match_c, 0, MLX5_ST_SZ_BYTES(fte_match_param)); 91191ad1bd9SKonstantin Belousov memset(match_v, 0, MLX5_ST_SZ_BYTES(fte_match_param)); 91291ad1bd9SKonstantin Belousov vport->egress.drop_rule = 91391ad1bd9SKonstantin Belousov mlx5_add_flow_rule(vport->egress.acl, 91491ad1bd9SKonstantin Belousov 0, 91591ad1bd9SKonstantin Belousov match_c, 91691ad1bd9SKonstantin Belousov match_v, 91791ad1bd9SKonstantin Belousov MLX5_FLOW_CONTEXT_ACTION_DROP, 91891ad1bd9SKonstantin Belousov 0, &dest); 91991ad1bd9SKonstantin Belousov if (IS_ERR_OR_NULL(vport->egress.drop_rule)) { 92091ad1bd9SKonstantin Belousov err = PTR_ERR(vport->egress.drop_rule); 92191ad1bd9SKonstantin Belousov printf("mlx5_core: WARN: ""vport[%d] configure egress drop rule failed, err(%d)\n", vport->vport, err); 92291ad1bd9SKonstantin Belousov vport->egress.drop_rule = NULL; 92391ad1bd9SKonstantin Belousov } 92491ad1bd9SKonstantin Belousov out: 92591ad1bd9SKonstantin Belousov kfree(match_v); 92691ad1bd9SKonstantin Belousov kfree(match_c); 92791ad1bd9SKonstantin Belousov return err; 92891ad1bd9SKonstantin Belousov } 92991ad1bd9SKonstantin Belousov 93091ad1bd9SKonstantin Belousov static void esw_enable_vport(struct mlx5_eswitch *esw, int vport_num, 93191ad1bd9SKonstantin Belousov int enable_events) 93291ad1bd9SKonstantin Belousov { 93391ad1bd9SKonstantin Belousov struct mlx5_vport *vport = &esw->vports[vport_num]; 93491ad1bd9SKonstantin Belousov unsigned long flags; 93591ad1bd9SKonstantin Belousov 93691ad1bd9SKonstantin Belousov mutex_lock(&vport->state_lock); 93791ad1bd9SKonstantin Belousov WARN_ON(vport->enabled); 93891ad1bd9SKonstantin Belousov 93991ad1bd9SKonstantin Belousov esw_debug(esw->dev, "Enabling VPORT(%d)\n", vport_num); 94091ad1bd9SKonstantin Belousov 94191ad1bd9SKonstantin Belousov if (vport_num) { /* Only VFs need ACLs for VST and spoofchk filtering */ 94291ad1bd9SKonstantin Belousov esw_vport_enable_ingress_acl(esw, vport); 94391ad1bd9SKonstantin Belousov esw_vport_enable_egress_acl(esw, vport); 94491ad1bd9SKonstantin Belousov esw_vport_ingress_config(esw, vport); 94591ad1bd9SKonstantin Belousov esw_vport_egress_config(esw, vport); 94691ad1bd9SKonstantin Belousov } 94791ad1bd9SKonstantin Belousov 94891ad1bd9SKonstantin Belousov mlx5_modify_vport_admin_state(esw->dev, 94991ad1bd9SKonstantin Belousov MLX5_QUERY_VPORT_STATE_IN_OP_MOD_ESW_VPORT, 95091ad1bd9SKonstantin Belousov vport_num, 95191ad1bd9SKonstantin Belousov MLX5_ESW_VPORT_ADMIN_STATE_AUTO); 95291ad1bd9SKonstantin Belousov 95391ad1bd9SKonstantin Belousov /* Sync with current vport context */ 95491ad1bd9SKonstantin Belousov vport->enabled_events = enable_events; 95591ad1bd9SKonstantin Belousov esw_vport_change_handler(&vport->vport_change_handler); 95691ad1bd9SKonstantin Belousov 95791ad1bd9SKonstantin Belousov spin_lock_irqsave(&vport->lock, flags); 95891ad1bd9SKonstantin Belousov vport->enabled = true; 95991ad1bd9SKonstantin Belousov spin_unlock_irqrestore(&vport->lock, flags); 96091ad1bd9SKonstantin Belousov 96191ad1bd9SKonstantin Belousov arm_vport_context_events_cmd(esw->dev, vport_num, enable_events); 96291ad1bd9SKonstantin Belousov 96391ad1bd9SKonstantin Belousov esw->enabled_vports++; 96491ad1bd9SKonstantin Belousov esw_debug(esw->dev, "Enabled VPORT(%d)\n", vport_num); 96591ad1bd9SKonstantin Belousov mutex_unlock(&vport->state_lock); 96691ad1bd9SKonstantin Belousov } 96791ad1bd9SKonstantin Belousov 96891ad1bd9SKonstantin Belousov static void esw_cleanup_vport(struct mlx5_eswitch *esw, u16 vport_num) 96991ad1bd9SKonstantin Belousov { 97091ad1bd9SKonstantin Belousov struct mlx5_vport *vport = &esw->vports[vport_num]; 97191ad1bd9SKonstantin Belousov struct l2addr_node *node; 97291ad1bd9SKonstantin Belousov struct vport_addr *addr; 97391ad1bd9SKonstantin Belousov struct hlist_node *tmp; 97491ad1bd9SKonstantin Belousov int hi; 97591ad1bd9SKonstantin Belousov 97691ad1bd9SKonstantin Belousov for_each_l2hash_node(node, tmp, vport->uc_list, hi) { 97791ad1bd9SKonstantin Belousov addr = container_of(node, struct vport_addr, node); 97891ad1bd9SKonstantin Belousov addr->action = MLX5_ACTION_DEL; 97991ad1bd9SKonstantin Belousov } 98091ad1bd9SKonstantin Belousov esw_apply_vport_addr_list(esw, vport_num, MLX5_NIC_VPORT_LIST_TYPE_UC); 98191ad1bd9SKonstantin Belousov 98291ad1bd9SKonstantin Belousov for_each_l2hash_node(node, tmp, vport->mc_list, hi) { 98391ad1bd9SKonstantin Belousov addr = container_of(node, struct vport_addr, node); 98491ad1bd9SKonstantin Belousov addr->action = MLX5_ACTION_DEL; 98591ad1bd9SKonstantin Belousov } 98691ad1bd9SKonstantin Belousov esw_apply_vport_addr_list(esw, vport_num, MLX5_NIC_VPORT_LIST_TYPE_MC); 98791ad1bd9SKonstantin Belousov } 98891ad1bd9SKonstantin Belousov 98991ad1bd9SKonstantin Belousov static void esw_disable_vport(struct mlx5_eswitch *esw, int vport_num) 99091ad1bd9SKonstantin Belousov { 99191ad1bd9SKonstantin Belousov struct mlx5_vport *vport = &esw->vports[vport_num]; 99291ad1bd9SKonstantin Belousov unsigned long flags; 99391ad1bd9SKonstantin Belousov 99491ad1bd9SKonstantin Belousov mutex_lock(&vport->state_lock); 99591ad1bd9SKonstantin Belousov if (!vport->enabled) { 99691ad1bd9SKonstantin Belousov mutex_unlock(&vport->state_lock); 99791ad1bd9SKonstantin Belousov return; 99891ad1bd9SKonstantin Belousov } 99991ad1bd9SKonstantin Belousov 100091ad1bd9SKonstantin Belousov esw_debug(esw->dev, "Disabling vport(%d)\n", vport_num); 100191ad1bd9SKonstantin Belousov /* Mark this vport as disabled to discard new events */ 100291ad1bd9SKonstantin Belousov spin_lock_irqsave(&vport->lock, flags); 100391ad1bd9SKonstantin Belousov vport->enabled = false; 100491ad1bd9SKonstantin Belousov vport->enabled_events = 0; 100591ad1bd9SKonstantin Belousov spin_unlock_irqrestore(&vport->lock, flags); 100691ad1bd9SKonstantin Belousov 100791ad1bd9SKonstantin Belousov mlx5_modify_vport_admin_state(esw->dev, 100891ad1bd9SKonstantin Belousov MLX5_QUERY_VPORT_STATE_IN_OP_MOD_ESW_VPORT, 100991ad1bd9SKonstantin Belousov vport_num, 101091ad1bd9SKonstantin Belousov MLX5_ESW_VPORT_ADMIN_STATE_DOWN); 101191ad1bd9SKonstantin Belousov /* Wait for current already scheduled events to complete */ 101291ad1bd9SKonstantin Belousov flush_workqueue(esw->work_queue); 101391ad1bd9SKonstantin Belousov /* Disable events from this vport */ 101491ad1bd9SKonstantin Belousov arm_vport_context_events_cmd(esw->dev, vport->vport, 0); 101591ad1bd9SKonstantin Belousov /* We don't assume VFs will cleanup after themselves */ 101691ad1bd9SKonstantin Belousov esw_cleanup_vport(esw, vport_num); 101791ad1bd9SKonstantin Belousov if (vport_num) { 101891ad1bd9SKonstantin Belousov esw_vport_disable_egress_acl(esw, vport); 101991ad1bd9SKonstantin Belousov esw_vport_disable_ingress_acl(esw, vport); 102091ad1bd9SKonstantin Belousov } 102191ad1bd9SKonstantin Belousov esw->enabled_vports--; 102291ad1bd9SKonstantin Belousov mutex_unlock(&vport->state_lock); 102391ad1bd9SKonstantin Belousov } 102491ad1bd9SKonstantin Belousov 102591ad1bd9SKonstantin Belousov /* Public E-Switch API */ 102691ad1bd9SKonstantin Belousov int mlx5_eswitch_enable_sriov(struct mlx5_eswitch *esw, int nvfs) 102791ad1bd9SKonstantin Belousov { 102891ad1bd9SKonstantin Belousov int err; 102991ad1bd9SKonstantin Belousov int i; 103091ad1bd9SKonstantin Belousov 103191ad1bd9SKonstantin Belousov if (!esw || !MLX5_CAP_GEN(esw->dev, vport_group_manager) || 103291ad1bd9SKonstantin Belousov MLX5_CAP_GEN(esw->dev, port_type) != MLX5_CAP_PORT_TYPE_ETH) 103391ad1bd9SKonstantin Belousov return 0; 103491ad1bd9SKonstantin Belousov 103591ad1bd9SKonstantin Belousov if (!MLX5_CAP_GEN(esw->dev, eswitch_flow_table) || 103691ad1bd9SKonstantin Belousov !MLX5_CAP_ESW_FLOWTABLE_FDB(esw->dev, ft_support)) { 103791ad1bd9SKonstantin Belousov esw_warn(esw->dev, "E-Switch FDB is not supported, aborting ...\n"); 103891ad1bd9SKonstantin Belousov return -ENOTSUPP; 103991ad1bd9SKonstantin Belousov } 104091ad1bd9SKonstantin Belousov 104191ad1bd9SKonstantin Belousov if (!MLX5_CAP_ESW_INGRESS_ACL(esw->dev, ft_support)) 104291ad1bd9SKonstantin Belousov esw_warn(esw->dev, "E-Switch ingress ACL is not supported by FW\n"); 104391ad1bd9SKonstantin Belousov 104491ad1bd9SKonstantin Belousov if (!MLX5_CAP_ESW_EGRESS_ACL(esw->dev, ft_support)) 104591ad1bd9SKonstantin Belousov esw_warn(esw->dev, "E-Switch engress ACL is not supported by FW\n"); 104691ad1bd9SKonstantin Belousov 104791ad1bd9SKonstantin Belousov esw_info(esw->dev, "E-Switch enable SRIOV: nvfs(%d)\n", nvfs); 104891ad1bd9SKonstantin Belousov 104991ad1bd9SKonstantin Belousov esw_disable_vport(esw, 0); 105091ad1bd9SKonstantin Belousov 105191ad1bd9SKonstantin Belousov err = esw_create_fdb_table(esw); 105291ad1bd9SKonstantin Belousov if (err) 105391ad1bd9SKonstantin Belousov goto abort; 105491ad1bd9SKonstantin Belousov 105591ad1bd9SKonstantin Belousov for (i = 0; i <= nvfs; i++) 105691ad1bd9SKonstantin Belousov esw_enable_vport(esw, i, SRIOV_VPORT_EVENTS); 105791ad1bd9SKonstantin Belousov 105891ad1bd9SKonstantin Belousov esw_info(esw->dev, "SRIOV enabled: active vports(%d)\n", 105991ad1bd9SKonstantin Belousov esw->enabled_vports); 106091ad1bd9SKonstantin Belousov return 0; 106191ad1bd9SKonstantin Belousov 106291ad1bd9SKonstantin Belousov abort: 106391ad1bd9SKonstantin Belousov esw_enable_vport(esw, 0, UC_ADDR_CHANGE); 106491ad1bd9SKonstantin Belousov return err; 106591ad1bd9SKonstantin Belousov } 106691ad1bd9SKonstantin Belousov 106791ad1bd9SKonstantin Belousov void mlx5_eswitch_disable_sriov(struct mlx5_eswitch *esw) 106891ad1bd9SKonstantin Belousov { 106991ad1bd9SKonstantin Belousov int i; 107091ad1bd9SKonstantin Belousov 107191ad1bd9SKonstantin Belousov if (!esw || !MLX5_CAP_GEN(esw->dev, vport_group_manager) || 107291ad1bd9SKonstantin Belousov MLX5_CAP_GEN(esw->dev, port_type) != MLX5_CAP_PORT_TYPE_ETH) 107391ad1bd9SKonstantin Belousov return; 107491ad1bd9SKonstantin Belousov 107591ad1bd9SKonstantin Belousov esw_info(esw->dev, "disable SRIOV: active vports(%d)\n", 107691ad1bd9SKonstantin Belousov esw->enabled_vports); 107791ad1bd9SKonstantin Belousov 107891ad1bd9SKonstantin Belousov for (i = 0; i < esw->total_vports; i++) 107991ad1bd9SKonstantin Belousov esw_disable_vport(esw, i); 108091ad1bd9SKonstantin Belousov 108191ad1bd9SKonstantin Belousov esw_destroy_fdb_table(esw); 108291ad1bd9SKonstantin Belousov 108391ad1bd9SKonstantin Belousov /* VPORT 0 (PF) must be enabled back with non-sriov configuration */ 108491ad1bd9SKonstantin Belousov esw_enable_vport(esw, 0, UC_ADDR_CHANGE); 108591ad1bd9SKonstantin Belousov } 108691ad1bd9SKonstantin Belousov 108790959e7eSKonstantin Belousov int mlx5_eswitch_init(struct mlx5_core_dev *dev, int total_vports) 108891ad1bd9SKonstantin Belousov { 108991ad1bd9SKonstantin Belousov int l2_table_size = 1 << MLX5_CAP_GEN(dev, log_max_l2_table); 109091ad1bd9SKonstantin Belousov struct mlx5_eswitch *esw; 109191ad1bd9SKonstantin Belousov int vport_num; 109291ad1bd9SKonstantin Belousov int err; 109391ad1bd9SKonstantin Belousov 109491ad1bd9SKonstantin Belousov if (!MLX5_CAP_GEN(dev, vport_group_manager) || 109591ad1bd9SKonstantin Belousov MLX5_CAP_GEN(dev, port_type) != MLX5_CAP_PORT_TYPE_ETH) 109691ad1bd9SKonstantin Belousov return 0; 109791ad1bd9SKonstantin Belousov 109891ad1bd9SKonstantin Belousov esw_info(dev, 109991ad1bd9SKonstantin Belousov "Total vports %d, l2 table size(%d), per vport: max uc(%d) max mc(%d)\n", 110091ad1bd9SKonstantin Belousov total_vports, l2_table_size, 110191ad1bd9SKonstantin Belousov MLX5_MAX_UC_PER_VPORT(dev), 110291ad1bd9SKonstantin Belousov MLX5_MAX_MC_PER_VPORT(dev)); 110391ad1bd9SKonstantin Belousov 110491ad1bd9SKonstantin Belousov esw = kzalloc(sizeof(*esw), GFP_KERNEL); 110591ad1bd9SKonstantin Belousov if (!esw) 110691ad1bd9SKonstantin Belousov return -ENOMEM; 110791ad1bd9SKonstantin Belousov 110891ad1bd9SKonstantin Belousov esw->dev = dev; 110991ad1bd9SKonstantin Belousov 111091ad1bd9SKonstantin Belousov esw->l2_table.bitmap = kcalloc(BITS_TO_LONGS(l2_table_size), 111191ad1bd9SKonstantin Belousov sizeof(uintptr_t), GFP_KERNEL); 111291ad1bd9SKonstantin Belousov if (!esw->l2_table.bitmap) { 111391ad1bd9SKonstantin Belousov err = -ENOMEM; 111491ad1bd9SKonstantin Belousov goto abort; 111591ad1bd9SKonstantin Belousov } 111691ad1bd9SKonstantin Belousov esw->l2_table.size = l2_table_size; 111791ad1bd9SKonstantin Belousov 111891ad1bd9SKonstantin Belousov esw->work_queue = create_singlethread_workqueue("mlx5_esw_wq"); 111991ad1bd9SKonstantin Belousov if (!esw->work_queue) { 112091ad1bd9SKonstantin Belousov err = -ENOMEM; 112191ad1bd9SKonstantin Belousov goto abort; 112291ad1bd9SKonstantin Belousov } 112391ad1bd9SKonstantin Belousov 112491ad1bd9SKonstantin Belousov esw->vports = kcalloc(total_vports, sizeof(struct mlx5_vport), 112591ad1bd9SKonstantin Belousov GFP_KERNEL); 112691ad1bd9SKonstantin Belousov if (!esw->vports) { 112791ad1bd9SKonstantin Belousov err = -ENOMEM; 112891ad1bd9SKonstantin Belousov goto abort; 112991ad1bd9SKonstantin Belousov } 113091ad1bd9SKonstantin Belousov 113191ad1bd9SKonstantin Belousov for (vport_num = 0; vport_num < total_vports; vport_num++) { 113291ad1bd9SKonstantin Belousov struct mlx5_vport *vport = &esw->vports[vport_num]; 113391ad1bd9SKonstantin Belousov 113491ad1bd9SKonstantin Belousov vport->vport = vport_num; 113591ad1bd9SKonstantin Belousov vport->dev = dev; 113691ad1bd9SKonstantin Belousov INIT_WORK(&vport->vport_change_handler, 113791ad1bd9SKonstantin Belousov esw_vport_change_handler); 113891ad1bd9SKonstantin Belousov spin_lock_init(&vport->lock); 113991ad1bd9SKonstantin Belousov mutex_init(&vport->state_lock); 114091ad1bd9SKonstantin Belousov } 114191ad1bd9SKonstantin Belousov 114291ad1bd9SKonstantin Belousov esw->total_vports = total_vports; 114391ad1bd9SKonstantin Belousov esw->enabled_vports = 0; 114491ad1bd9SKonstantin Belousov 114591ad1bd9SKonstantin Belousov dev->priv.eswitch = esw; 114691ad1bd9SKonstantin Belousov esw_enable_vport(esw, 0, UC_ADDR_CHANGE); 114791ad1bd9SKonstantin Belousov /* VF Vports will be enabled when SRIOV is enabled */ 114891ad1bd9SKonstantin Belousov return 0; 114991ad1bd9SKonstantin Belousov abort: 115091ad1bd9SKonstantin Belousov if (esw->work_queue) 115191ad1bd9SKonstantin Belousov destroy_workqueue(esw->work_queue); 115291ad1bd9SKonstantin Belousov kfree(esw->l2_table.bitmap); 115391ad1bd9SKonstantin Belousov kfree(esw->vports); 115491ad1bd9SKonstantin Belousov kfree(esw); 115591ad1bd9SKonstantin Belousov return err; 115691ad1bd9SKonstantin Belousov } 115791ad1bd9SKonstantin Belousov 115891ad1bd9SKonstantin Belousov void mlx5_eswitch_cleanup(struct mlx5_eswitch *esw) 115991ad1bd9SKonstantin Belousov { 116091ad1bd9SKonstantin Belousov if (!esw || !MLX5_CAP_GEN(esw->dev, vport_group_manager) || 116191ad1bd9SKonstantin Belousov MLX5_CAP_GEN(esw->dev, port_type) != MLX5_CAP_PORT_TYPE_ETH) 116291ad1bd9SKonstantin Belousov return; 116391ad1bd9SKonstantin Belousov 116491ad1bd9SKonstantin Belousov esw_info(esw->dev, "cleanup\n"); 116591ad1bd9SKonstantin Belousov esw_disable_vport(esw, 0); 116691ad1bd9SKonstantin Belousov 116791ad1bd9SKonstantin Belousov esw->dev->priv.eswitch = NULL; 116891ad1bd9SKonstantin Belousov destroy_workqueue(esw->work_queue); 116991ad1bd9SKonstantin Belousov kfree(esw->l2_table.bitmap); 117091ad1bd9SKonstantin Belousov kfree(esw->vports); 117191ad1bd9SKonstantin Belousov kfree(esw); 117291ad1bd9SKonstantin Belousov } 117391ad1bd9SKonstantin Belousov 117491ad1bd9SKonstantin Belousov void mlx5_eswitch_vport_event(struct mlx5_eswitch *esw, struct mlx5_eqe *eqe) 117591ad1bd9SKonstantin Belousov { 117691ad1bd9SKonstantin Belousov struct mlx5_eqe_vport_change *vc_eqe = &eqe->data.vport_change; 117791ad1bd9SKonstantin Belousov u16 vport_num = be16_to_cpu(vc_eqe->vport_num); 117891ad1bd9SKonstantin Belousov struct mlx5_vport *vport; 117991ad1bd9SKonstantin Belousov 118091ad1bd9SKonstantin Belousov if (!esw) { 118191ad1bd9SKonstantin Belousov printf("mlx5_core: WARN: ""MLX5 E-Switch: vport %d got an event while eswitch is not initialized\n", vport_num); 118291ad1bd9SKonstantin Belousov return; 118391ad1bd9SKonstantin Belousov } 118491ad1bd9SKonstantin Belousov 118591ad1bd9SKonstantin Belousov vport = &esw->vports[vport_num]; 118691ad1bd9SKonstantin Belousov spin_lock(&vport->lock); 118791ad1bd9SKonstantin Belousov if (vport->enabled) 118891ad1bd9SKonstantin Belousov queue_work(esw->work_queue, &vport->vport_change_handler); 118991ad1bd9SKonstantin Belousov spin_unlock(&vport->lock); 119091ad1bd9SKonstantin Belousov } 119191ad1bd9SKonstantin Belousov 119291ad1bd9SKonstantin Belousov /* Vport Administration */ 119391ad1bd9SKonstantin Belousov #define ESW_ALLOWED(esw) \ 119491ad1bd9SKonstantin Belousov (esw && MLX5_CAP_GEN(esw->dev, vport_group_manager) && mlx5_core_is_pf(esw->dev)) 119591ad1bd9SKonstantin Belousov #define LEGAL_VPORT(esw, vport) (vport >= 0 && vport < esw->total_vports) 119691ad1bd9SKonstantin Belousov 119791ad1bd9SKonstantin Belousov static void node_guid_gen_from_mac(u64 *node_guid, u8 mac[ETH_ALEN]) 119891ad1bd9SKonstantin Belousov { 119991ad1bd9SKonstantin Belousov ((u8 *)node_guid)[7] = mac[0]; 120091ad1bd9SKonstantin Belousov ((u8 *)node_guid)[6] = mac[1]; 120191ad1bd9SKonstantin Belousov ((u8 *)node_guid)[5] = mac[2]; 120291ad1bd9SKonstantin Belousov ((u8 *)node_guid)[4] = 0xff; 120391ad1bd9SKonstantin Belousov ((u8 *)node_guid)[3] = 0xfe; 120491ad1bd9SKonstantin Belousov ((u8 *)node_guid)[2] = mac[3]; 120591ad1bd9SKonstantin Belousov ((u8 *)node_guid)[1] = mac[4]; 120691ad1bd9SKonstantin Belousov ((u8 *)node_guid)[0] = mac[5]; 120791ad1bd9SKonstantin Belousov } 120891ad1bd9SKonstantin Belousov 120991ad1bd9SKonstantin Belousov int mlx5_eswitch_set_vport_mac(struct mlx5_eswitch *esw, 121091ad1bd9SKonstantin Belousov int vport, u8 mac[ETH_ALEN]) 121191ad1bd9SKonstantin Belousov { 121291ad1bd9SKonstantin Belousov int err = 0; 121391ad1bd9SKonstantin Belousov u64 node_guid; 121491ad1bd9SKonstantin Belousov 121591ad1bd9SKonstantin Belousov if (!ESW_ALLOWED(esw)) 121691ad1bd9SKonstantin Belousov return -EPERM; 121791ad1bd9SKonstantin Belousov if (!LEGAL_VPORT(esw, vport)) 121891ad1bd9SKonstantin Belousov return -EINVAL; 121991ad1bd9SKonstantin Belousov 122091ad1bd9SKonstantin Belousov err = mlx5_modify_nic_vport_mac_address(esw->dev, vport, mac); 122191ad1bd9SKonstantin Belousov if (err) { 122291ad1bd9SKonstantin Belousov mlx5_core_warn(esw->dev, 122391ad1bd9SKonstantin Belousov "Failed to mlx5_modify_nic_vport_mac vport(%d) err=(%d)\n", 122491ad1bd9SKonstantin Belousov vport, err); 122591ad1bd9SKonstantin Belousov return err; 122691ad1bd9SKonstantin Belousov } 122791ad1bd9SKonstantin Belousov 122891ad1bd9SKonstantin Belousov node_guid_gen_from_mac(&node_guid, mac); 122991ad1bd9SKonstantin Belousov err = mlx5_modify_nic_vport_node_guid(esw->dev, vport, node_guid); 123091ad1bd9SKonstantin Belousov if (err) { 123191ad1bd9SKonstantin Belousov mlx5_core_warn(esw->dev, 123291ad1bd9SKonstantin Belousov "Failed to mlx5_modify_nic_vport_node_guid vport(%d) err=(%d)\n", 123391ad1bd9SKonstantin Belousov vport, err); 123491ad1bd9SKonstantin Belousov return err; 123591ad1bd9SKonstantin Belousov } 123691ad1bd9SKonstantin Belousov 123791ad1bd9SKonstantin Belousov return err; 123891ad1bd9SKonstantin Belousov } 123991ad1bd9SKonstantin Belousov 124091ad1bd9SKonstantin Belousov int mlx5_eswitch_set_vport_state(struct mlx5_eswitch *esw, 124191ad1bd9SKonstantin Belousov int vport, int link_state) 124291ad1bd9SKonstantin Belousov { 124391ad1bd9SKonstantin Belousov if (!ESW_ALLOWED(esw)) 124491ad1bd9SKonstantin Belousov return -EPERM; 124591ad1bd9SKonstantin Belousov if (!LEGAL_VPORT(esw, vport)) 124691ad1bd9SKonstantin Belousov return -EINVAL; 124791ad1bd9SKonstantin Belousov 124891ad1bd9SKonstantin Belousov return mlx5_modify_vport_admin_state(esw->dev, 124991ad1bd9SKonstantin Belousov MLX5_QUERY_VPORT_STATE_IN_OP_MOD_ESW_VPORT, 125091ad1bd9SKonstantin Belousov vport, link_state); 125191ad1bd9SKonstantin Belousov } 125291ad1bd9SKonstantin Belousov 125391ad1bd9SKonstantin Belousov int mlx5_eswitch_get_vport_config(struct mlx5_eswitch *esw, 125491ad1bd9SKonstantin Belousov int vport, struct mlx5_esw_vport_info *ivi) 125591ad1bd9SKonstantin Belousov { 125691ad1bd9SKonstantin Belousov u16 vlan; 125791ad1bd9SKonstantin Belousov u8 qos; 125891ad1bd9SKonstantin Belousov 125991ad1bd9SKonstantin Belousov if (!ESW_ALLOWED(esw)) 126091ad1bd9SKonstantin Belousov return -EPERM; 126191ad1bd9SKonstantin Belousov if (!LEGAL_VPORT(esw, vport)) 126291ad1bd9SKonstantin Belousov return -EINVAL; 126391ad1bd9SKonstantin Belousov 126491ad1bd9SKonstantin Belousov memset(ivi, 0, sizeof(*ivi)); 126591ad1bd9SKonstantin Belousov ivi->vf = vport - 1; 126691ad1bd9SKonstantin Belousov 126791ad1bd9SKonstantin Belousov mlx5_query_nic_vport_mac_address(esw->dev, vport, ivi->mac); 126891ad1bd9SKonstantin Belousov ivi->linkstate = mlx5_query_vport_admin_state(esw->dev, 126991ad1bd9SKonstantin Belousov MLX5_QUERY_VPORT_STATE_IN_OP_MOD_ESW_VPORT, 127091ad1bd9SKonstantin Belousov vport); 127191ad1bd9SKonstantin Belousov query_esw_vport_cvlan(esw->dev, vport, &vlan, &qos); 127291ad1bd9SKonstantin Belousov ivi->vlan = vlan; 127391ad1bd9SKonstantin Belousov ivi->qos = qos; 127491ad1bd9SKonstantin Belousov ivi->spoofchk = 0; 127591ad1bd9SKonstantin Belousov 127691ad1bd9SKonstantin Belousov return 0; 127791ad1bd9SKonstantin Belousov } 127891ad1bd9SKonstantin Belousov 127991ad1bd9SKonstantin Belousov int mlx5_eswitch_set_vport_vlan(struct mlx5_eswitch *esw, 128091ad1bd9SKonstantin Belousov int vport, u16 vlan, u8 qos) 128191ad1bd9SKonstantin Belousov { 128291ad1bd9SKonstantin Belousov struct mlx5_vport *evport; 128391ad1bd9SKonstantin Belousov int err = 0; 128491ad1bd9SKonstantin Belousov int set = 0; 128591ad1bd9SKonstantin Belousov 128691ad1bd9SKonstantin Belousov if (!ESW_ALLOWED(esw)) 128791ad1bd9SKonstantin Belousov return -EPERM; 128891ad1bd9SKonstantin Belousov if (!LEGAL_VPORT(esw, vport) || (vlan > 4095) || (qos > 7)) 128991ad1bd9SKonstantin Belousov return -EINVAL; 129091ad1bd9SKonstantin Belousov 129191ad1bd9SKonstantin Belousov if (vlan || qos) 129291ad1bd9SKonstantin Belousov set = 1; 129391ad1bd9SKonstantin Belousov 129491ad1bd9SKonstantin Belousov evport = &esw->vports[vport]; 129591ad1bd9SKonstantin Belousov 129691ad1bd9SKonstantin Belousov err = modify_esw_vport_cvlan(esw->dev, vport, vlan, qos, set); 129791ad1bd9SKonstantin Belousov if (err) 129891ad1bd9SKonstantin Belousov return err; 129991ad1bd9SKonstantin Belousov 130091ad1bd9SKonstantin Belousov mutex_lock(&evport->state_lock); 130191ad1bd9SKonstantin Belousov evport->vlan = vlan; 130291ad1bd9SKonstantin Belousov evport->qos = qos; 130391ad1bd9SKonstantin Belousov if (evport->enabled) { 130491ad1bd9SKonstantin Belousov esw_vport_ingress_config(esw, evport); 130591ad1bd9SKonstantin Belousov esw_vport_egress_config(esw, evport); 130691ad1bd9SKonstantin Belousov } 130791ad1bd9SKonstantin Belousov mutex_unlock(&evport->state_lock); 130891ad1bd9SKonstantin Belousov return err; 130991ad1bd9SKonstantin Belousov } 131091ad1bd9SKonstantin Belousov 1311