| // SPDX-License-Identifier: GPL-2.0-only |
| /**************************************************************************** |
| * Driver for Solarflare network controllers and boards |
| * Copyright 2019 Solarflare Communications Inc. |
| * Copyright 2020-2022 Xilinx Inc. |
| * |
| * This program is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 as published |
| * by the Free Software Foundation, incorporated herein by reference. |
| */ |
| |
| #include "mae.h" |
| #include "mcdi.h" |
| #include "mcdi_pcol_mae.h" |
| |
| int efx_mae_allocate_mport(struct efx_nic *efx, u32 *id, u32 *label) |
| { |
| MCDI_DECLARE_BUF(outbuf, MC_CMD_MAE_MPORT_ALLOC_ALIAS_OUT_LEN); |
| MCDI_DECLARE_BUF(inbuf, MC_CMD_MAE_MPORT_ALLOC_ALIAS_IN_LEN); |
| size_t outlen; |
| int rc; |
| |
| if (WARN_ON_ONCE(!id)) |
| return -EINVAL; |
| if (WARN_ON_ONCE(!label)) |
| return -EINVAL; |
| |
| MCDI_SET_DWORD(inbuf, MAE_MPORT_ALLOC_ALIAS_IN_TYPE, |
| MC_CMD_MAE_MPORT_ALLOC_ALIAS_IN_MPORT_TYPE_ALIAS); |
| MCDI_SET_DWORD(inbuf, MAE_MPORT_ALLOC_ALIAS_IN_DELIVER_MPORT, |
| MAE_MPORT_SELECTOR_ASSIGNED); |
| rc = efx_mcdi_rpc(efx, MC_CMD_MAE_MPORT_ALLOC, inbuf, sizeof(inbuf), |
| outbuf, sizeof(outbuf), &outlen); |
| if (rc) |
| return rc; |
| if (outlen < sizeof(outbuf)) |
| return -EIO; |
| *id = MCDI_DWORD(outbuf, MAE_MPORT_ALLOC_ALIAS_OUT_MPORT_ID); |
| *label = MCDI_DWORD(outbuf, MAE_MPORT_ALLOC_ALIAS_OUT_LABEL); |
| return 0; |
| } |
| |
| int efx_mae_free_mport(struct efx_nic *efx, u32 id) |
| { |
| MCDI_DECLARE_BUF(inbuf, MC_CMD_MAE_MPORT_FREE_IN_LEN); |
| |
| BUILD_BUG_ON(MC_CMD_MAE_MPORT_FREE_OUT_LEN); |
| MCDI_SET_DWORD(inbuf, MAE_MPORT_FREE_IN_MPORT_ID, id); |
| return efx_mcdi_rpc(efx, MC_CMD_MAE_MPORT_FREE, inbuf, sizeof(inbuf), |
| NULL, 0, NULL); |
| } |
| |
| void efx_mae_mport_wire(struct efx_nic *efx, u32 *out) |
| { |
| efx_dword_t mport; |
| |
| EFX_POPULATE_DWORD_2(mport, |
| MAE_MPORT_SELECTOR_TYPE, MAE_MPORT_SELECTOR_TYPE_PPORT, |
| MAE_MPORT_SELECTOR_PPORT_ID, efx->port_num); |
| *out = EFX_DWORD_VAL(mport); |
| } |
| |
| void efx_mae_mport_uplink(struct efx_nic *efx __always_unused, u32 *out) |
| { |
| efx_dword_t mport; |
| |
| EFX_POPULATE_DWORD_3(mport, |
| MAE_MPORT_SELECTOR_TYPE, MAE_MPORT_SELECTOR_TYPE_FUNC, |
| MAE_MPORT_SELECTOR_FUNC_PF_ID, MAE_MPORT_SELECTOR_FUNC_PF_ID_CALLER, |
| MAE_MPORT_SELECTOR_FUNC_VF_ID, MAE_MPORT_SELECTOR_FUNC_VF_ID_NULL); |
| *out = EFX_DWORD_VAL(mport); |
| } |
| |
| void efx_mae_mport_vf(struct efx_nic *efx __always_unused, u32 vf_id, u32 *out) |
| { |
| efx_dword_t mport; |
| |
| EFX_POPULATE_DWORD_3(mport, |
| MAE_MPORT_SELECTOR_TYPE, MAE_MPORT_SELECTOR_TYPE_FUNC, |
| MAE_MPORT_SELECTOR_FUNC_PF_ID, MAE_MPORT_SELECTOR_FUNC_PF_ID_CALLER, |
| MAE_MPORT_SELECTOR_FUNC_VF_ID, vf_id); |
| *out = EFX_DWORD_VAL(mport); |
| } |
| |
| /* Constructs an mport selector from an mport ID, because they're not the same */ |
| void efx_mae_mport_mport(struct efx_nic *efx __always_unused, u32 mport_id, u32 *out) |
| { |
| efx_dword_t mport; |
| |
| EFX_POPULATE_DWORD_2(mport, |
| MAE_MPORT_SELECTOR_TYPE, MAE_MPORT_SELECTOR_TYPE_MPORT_ID, |
| MAE_MPORT_SELECTOR_MPORT_ID, mport_id); |
| *out = EFX_DWORD_VAL(mport); |
| } |
| |
| /* id is really only 24 bits wide */ |
| int efx_mae_lookup_mport(struct efx_nic *efx, u32 selector, u32 *id) |
| { |
| MCDI_DECLARE_BUF(outbuf, MC_CMD_MAE_MPORT_LOOKUP_OUT_LEN); |
| MCDI_DECLARE_BUF(inbuf, MC_CMD_MAE_MPORT_LOOKUP_IN_LEN); |
| size_t outlen; |
| int rc; |
| |
| MCDI_SET_DWORD(inbuf, MAE_MPORT_LOOKUP_IN_MPORT_SELECTOR, selector); |
| rc = efx_mcdi_rpc(efx, MC_CMD_MAE_MPORT_LOOKUP, inbuf, sizeof(inbuf), |
| outbuf, sizeof(outbuf), &outlen); |
| if (rc) |
| return rc; |
| if (outlen < sizeof(outbuf)) |
| return -EIO; |
| *id = MCDI_DWORD(outbuf, MAE_MPORT_LOOKUP_OUT_MPORT_ID); |
| return 0; |
| } |
| |
| static bool efx_mae_asl_id(u32 id) |
| { |
| return !!(id & BIT(31)); |
| } |
| |
| int efx_mae_alloc_action_set(struct efx_nic *efx, struct efx_tc_action_set *act) |
| { |
| MCDI_DECLARE_BUF(outbuf, MC_CMD_MAE_ACTION_SET_ALLOC_OUT_LEN); |
| MCDI_DECLARE_BUF(inbuf, MC_CMD_MAE_ACTION_SET_ALLOC_IN_LEN); |
| size_t outlen; |
| int rc; |
| |
| MCDI_SET_DWORD(inbuf, MAE_ACTION_SET_ALLOC_IN_SRC_MAC_ID, |
| MC_CMD_MAE_MAC_ADDR_ALLOC_OUT_MAC_ID_NULL); |
| MCDI_SET_DWORD(inbuf, MAE_ACTION_SET_ALLOC_IN_DST_MAC_ID, |
| MC_CMD_MAE_MAC_ADDR_ALLOC_OUT_MAC_ID_NULL); |
| MCDI_SET_DWORD(inbuf, MAE_ACTION_SET_ALLOC_IN_COUNTER_ID, |
| MC_CMD_MAE_COUNTER_ALLOC_OUT_COUNTER_ID_NULL); |
| MCDI_SET_DWORD(inbuf, MAE_ACTION_SET_ALLOC_IN_COUNTER_LIST_ID, |
| MC_CMD_MAE_COUNTER_LIST_ALLOC_OUT_COUNTER_LIST_ID_NULL); |
| MCDI_SET_DWORD(inbuf, MAE_ACTION_SET_ALLOC_IN_ENCAP_HEADER_ID, |
| MC_CMD_MAE_ENCAP_HEADER_ALLOC_OUT_ENCAP_HEADER_ID_NULL); |
| if (act->deliver) |
| MCDI_SET_DWORD(inbuf, MAE_ACTION_SET_ALLOC_IN_DELIVER, |
| act->dest_mport); |
| BUILD_BUG_ON(MAE_MPORT_SELECTOR_NULL); |
| rc = efx_mcdi_rpc(efx, MC_CMD_MAE_ACTION_SET_ALLOC, inbuf, sizeof(inbuf), |
| outbuf, sizeof(outbuf), &outlen); |
| if (rc) |
| return rc; |
| if (outlen < sizeof(outbuf)) |
| return -EIO; |
| act->fw_id = MCDI_DWORD(outbuf, MAE_ACTION_SET_ALLOC_OUT_AS_ID); |
| /* We rely on the high bit of AS IDs always being clear. |
| * The firmware API guarantees this, but let's check it ourselves. |
| */ |
| if (WARN_ON_ONCE(efx_mae_asl_id(act->fw_id))) { |
| efx_mae_free_action_set(efx, act->fw_id); |
| return -EIO; |
| } |
| return 0; |
| } |
| |
| int efx_mae_free_action_set(struct efx_nic *efx, u32 fw_id) |
| { |
| MCDI_DECLARE_BUF(outbuf, MC_CMD_MAE_ACTION_SET_FREE_OUT_LEN(1)); |
| MCDI_DECLARE_BUF(inbuf, MC_CMD_MAE_ACTION_SET_FREE_IN_LEN(1)); |
| size_t outlen; |
| int rc; |
| |
| MCDI_SET_DWORD(inbuf, MAE_ACTION_SET_FREE_IN_AS_ID, fw_id); |
| rc = efx_mcdi_rpc(efx, MC_CMD_MAE_ACTION_SET_FREE, inbuf, sizeof(inbuf), |
| outbuf, sizeof(outbuf), &outlen); |
| if (rc) |
| return rc; |
| if (outlen < sizeof(outbuf)) |
| return -EIO; |
| /* FW freed a different ID than we asked for, should never happen. |
| * Warn because it means we've now got a different idea to the FW of |
| * what action-sets exist, which could cause mayhem later. |
| */ |
| if (WARN_ON(MCDI_DWORD(outbuf, MAE_ACTION_SET_FREE_OUT_FREED_AS_ID) != fw_id)) |
| return -EIO; |
| return 0; |
| } |
| |
| int efx_mae_alloc_action_set_list(struct efx_nic *efx, |
| struct efx_tc_action_set_list *acts) |
| { |
| MCDI_DECLARE_BUF(outbuf, MC_CMD_MAE_ACTION_SET_LIST_ALLOC_OUT_LEN); |
| struct efx_tc_action_set *act; |
| size_t inlen, outlen, i = 0; |
| efx_dword_t *inbuf; |
| int rc; |
| |
| list_for_each_entry(act, &acts->list, list) |
| i++; |
| if (i == 0) |
| return -EINVAL; |
| if (i == 1) { |
| /* Don't wrap an ASL around a single AS, just use the AS_ID |
| * directly. ASLs are a more limited resource. |
| */ |
| act = list_first_entry(&acts->list, struct efx_tc_action_set, list); |
| acts->fw_id = act->fw_id; |
| return 0; |
| } |
| if (i > MC_CMD_MAE_ACTION_SET_LIST_ALLOC_IN_AS_IDS_MAXNUM_MCDI2) |
| return -EOPNOTSUPP; /* Too many actions */ |
| inlen = MC_CMD_MAE_ACTION_SET_LIST_ALLOC_IN_LEN(i); |
| inbuf = kzalloc(inlen, GFP_KERNEL); |
| if (!inbuf) |
| return -ENOMEM; |
| i = 0; |
| list_for_each_entry(act, &acts->list, list) { |
| MCDI_SET_ARRAY_DWORD(inbuf, MAE_ACTION_SET_LIST_ALLOC_IN_AS_IDS, |
| i, act->fw_id); |
| i++; |
| } |
| MCDI_SET_DWORD(inbuf, MAE_ACTION_SET_LIST_ALLOC_IN_COUNT, i); |
| rc = efx_mcdi_rpc(efx, MC_CMD_MAE_ACTION_SET_LIST_ALLOC, inbuf, inlen, |
| outbuf, sizeof(outbuf), &outlen); |
| if (rc) |
| goto out_free; |
| if (outlen < sizeof(outbuf)) { |
| rc = -EIO; |
| goto out_free; |
| } |
| acts->fw_id = MCDI_DWORD(outbuf, MAE_ACTION_SET_LIST_ALLOC_OUT_ASL_ID); |
| /* We rely on the high bit of ASL IDs always being set. |
| * The firmware API guarantees this, but let's check it ourselves. |
| */ |
| if (WARN_ON_ONCE(!efx_mae_asl_id(acts->fw_id))) { |
| efx_mae_free_action_set_list(efx, acts); |
| rc = -EIO; |
| } |
| out_free: |
| kfree(inbuf); |
| return rc; |
| } |
| |
| int efx_mae_free_action_set_list(struct efx_nic *efx, |
| struct efx_tc_action_set_list *acts) |
| { |
| MCDI_DECLARE_BUF(outbuf, MC_CMD_MAE_ACTION_SET_LIST_FREE_OUT_LEN(1)); |
| MCDI_DECLARE_BUF(inbuf, MC_CMD_MAE_ACTION_SET_LIST_FREE_IN_LEN(1)); |
| size_t outlen; |
| int rc; |
| |
| /* If this is just an AS_ID with no ASL wrapper, then there is |
| * nothing for us to free. (The AS will be freed later.) |
| */ |
| if (efx_mae_asl_id(acts->fw_id)) { |
| MCDI_SET_DWORD(inbuf, MAE_ACTION_SET_LIST_FREE_IN_ASL_ID, |
| acts->fw_id); |
| rc = efx_mcdi_rpc(efx, MC_CMD_MAE_ACTION_SET_LIST_FREE, inbuf, |
| sizeof(inbuf), outbuf, sizeof(outbuf), &outlen); |
| if (rc) |
| return rc; |
| if (outlen < sizeof(outbuf)) |
| return -EIO; |
| /* FW freed a different ID than we asked for, should never happen. |
| * Warn because it means we've now got a different idea to the FW of |
| * what action-set-lists exist, which could cause mayhem later. |
| */ |
| if (WARN_ON(MCDI_DWORD(outbuf, MAE_ACTION_SET_LIST_FREE_OUT_FREED_ASL_ID) != acts->fw_id)) |
| return -EIO; |
| } |
| /* We're probably about to free @acts, but let's just make sure its |
| * fw_id is blatted so that it won't look valid if it leaks out. |
| */ |
| acts->fw_id = MC_CMD_MAE_ACTION_SET_LIST_ALLOC_OUT_ACTION_SET_LIST_ID_NULL; |
| return 0; |
| } |
| |
| static int efx_mae_populate_match_criteria(MCDI_DECLARE_STRUCT_PTR(match_crit), |
| const struct efx_tc_match *match) |
| { |
| if (match->mask.ingress_port) { |
| if (~match->mask.ingress_port) |
| return -EOPNOTSUPP; |
| MCDI_STRUCT_SET_DWORD(match_crit, |
| MAE_FIELD_MASK_VALUE_PAIRS_V2_INGRESS_MPORT_SELECTOR, |
| match->value.ingress_port); |
| } |
| MCDI_STRUCT_SET_DWORD(match_crit, MAE_FIELD_MASK_VALUE_PAIRS_V2_INGRESS_MPORT_SELECTOR_MASK, |
| match->mask.ingress_port); |
| return 0; |
| } |
| |
| int efx_mae_insert_rule(struct efx_nic *efx, const struct efx_tc_match *match, |
| u32 prio, u32 acts_id, u32 *id) |
| { |
| MCDI_DECLARE_BUF(inbuf, MC_CMD_MAE_ACTION_RULE_INSERT_IN_LEN(MAE_FIELD_MASK_VALUE_PAIRS_V2_LEN)); |
| MCDI_DECLARE_BUF(outbuf, MC_CMD_MAE_ACTION_RULE_INSERT_OUT_LEN); |
| MCDI_DECLARE_STRUCT_PTR(match_crit); |
| MCDI_DECLARE_STRUCT_PTR(response); |
| size_t outlen; |
| int rc; |
| |
| if (!id) |
| return -EINVAL; |
| |
| match_crit = _MCDI_DWORD(inbuf, MAE_ACTION_RULE_INSERT_IN_MATCH_CRITERIA); |
| response = _MCDI_DWORD(inbuf, MAE_ACTION_RULE_INSERT_IN_RESPONSE); |
| if (efx_mae_asl_id(acts_id)) { |
| MCDI_STRUCT_SET_DWORD(response, MAE_ACTION_RULE_RESPONSE_ASL_ID, acts_id); |
| MCDI_STRUCT_SET_DWORD(response, MAE_ACTION_RULE_RESPONSE_AS_ID, |
| MC_CMD_MAE_ACTION_SET_ALLOC_OUT_ACTION_SET_ID_NULL); |
| } else { |
| /* We only had one AS, so we didn't wrap it in an ASL */ |
| MCDI_STRUCT_SET_DWORD(response, MAE_ACTION_RULE_RESPONSE_ASL_ID, |
| MC_CMD_MAE_ACTION_SET_LIST_ALLOC_OUT_ACTION_SET_LIST_ID_NULL); |
| MCDI_STRUCT_SET_DWORD(response, MAE_ACTION_RULE_RESPONSE_AS_ID, acts_id); |
| } |
| MCDI_SET_DWORD(inbuf, MAE_ACTION_RULE_INSERT_IN_PRIO, prio); |
| rc = efx_mae_populate_match_criteria(match_crit, match); |
| if (rc) |
| return rc; |
| |
| rc = efx_mcdi_rpc(efx, MC_CMD_MAE_ACTION_RULE_INSERT, inbuf, sizeof(inbuf), |
| outbuf, sizeof(outbuf), &outlen); |
| if (rc) |
| return rc; |
| if (outlen < sizeof(outbuf)) |
| return -EIO; |
| *id = MCDI_DWORD(outbuf, MAE_ACTION_RULE_INSERT_OUT_AR_ID); |
| return 0; |
| } |
| |
| int efx_mae_delete_rule(struct efx_nic *efx, u32 id) |
| { |
| MCDI_DECLARE_BUF(outbuf, MC_CMD_MAE_ACTION_RULE_DELETE_OUT_LEN(1)); |
| MCDI_DECLARE_BUF(inbuf, MC_CMD_MAE_ACTION_RULE_DELETE_IN_LEN(1)); |
| size_t outlen; |
| int rc; |
| |
| MCDI_SET_DWORD(inbuf, MAE_ACTION_RULE_DELETE_IN_AR_ID, id); |
| rc = efx_mcdi_rpc(efx, MC_CMD_MAE_ACTION_RULE_DELETE, inbuf, sizeof(inbuf), |
| outbuf, sizeof(outbuf), &outlen); |
| if (rc) |
| return rc; |
| if (outlen < sizeof(outbuf)) |
| return -EIO; |
| /* FW freed a different ID than we asked for, should also never happen. |
| * Warn because it means we've now got a different idea to the FW of |
| * what rules exist, which could cause mayhem later. |
| */ |
| if (WARN_ON(MCDI_DWORD(outbuf, MAE_ACTION_RULE_DELETE_OUT_DELETED_AR_ID) != id)) |
| return -EIO; |
| return 0; |
| } |