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