brintos / linux-shallow public Read only

1// SPDX-License-Identifier: GPL-2.0-only2/****************************************************************************3 * Driver for Solarflare network controllers and boards4 * Copyright 2019 Solarflare Communications Inc.5 * Copyright 2020-2022 Xilinx Inc.6 *7 * This program is free software; you can redistribute it and/or modify it8 * under the terms of the GNU General Public License version 2 as published9 * by the Free Software Foundation, incorporated herein by reference.10 */11 12#include <linux/rhashtable.h>13#include "ef100_nic.h"14#include "mae.h"15#include "mcdi.h"16#include "mcdi_pcol.h"17#include "mcdi_pcol_mae.h"18#include "tc_encap_actions.h"19#include "tc_conntrack.h"20 21int efx_mae_allocate_mport(struct efx_nic *efx, u32 *id, u32 *label)22{23	MCDI_DECLARE_BUF(outbuf, MC_CMD_MAE_MPORT_ALLOC_ALIAS_OUT_LEN);24	MCDI_DECLARE_BUF(inbuf, MC_CMD_MAE_MPORT_ALLOC_ALIAS_IN_LEN);25	size_t outlen;26	int rc;27 28	if (WARN_ON_ONCE(!id))29		return -EINVAL;30	if (WARN_ON_ONCE(!label))31		return -EINVAL;32 33	MCDI_SET_DWORD(inbuf, MAE_MPORT_ALLOC_ALIAS_IN_TYPE,34		       MC_CMD_MAE_MPORT_ALLOC_ALIAS_IN_MPORT_TYPE_ALIAS);35	MCDI_SET_DWORD(inbuf, MAE_MPORT_ALLOC_ALIAS_IN_DELIVER_MPORT,36		       MAE_MPORT_SELECTOR_ASSIGNED);37	rc = efx_mcdi_rpc(efx, MC_CMD_MAE_MPORT_ALLOC, inbuf, sizeof(inbuf),38			  outbuf, sizeof(outbuf), &outlen);39	if (rc)40		return rc;41	if (outlen < sizeof(outbuf))42		return -EIO;43	*id = MCDI_DWORD(outbuf, MAE_MPORT_ALLOC_ALIAS_OUT_MPORT_ID);44	*label = MCDI_DWORD(outbuf, MAE_MPORT_ALLOC_ALIAS_OUT_LABEL);45	return 0;46}47 48int efx_mae_free_mport(struct efx_nic *efx, u32 id)49{50	MCDI_DECLARE_BUF(inbuf, MC_CMD_MAE_MPORT_FREE_IN_LEN);51 52	BUILD_BUG_ON(MC_CMD_MAE_MPORT_FREE_OUT_LEN);53	MCDI_SET_DWORD(inbuf, MAE_MPORT_FREE_IN_MPORT_ID, id);54	return efx_mcdi_rpc(efx, MC_CMD_MAE_MPORT_FREE, inbuf, sizeof(inbuf),55			    NULL, 0, NULL);56}57 58void efx_mae_mport_wire(struct efx_nic *efx, u32 *out)59{60	efx_dword_t mport;61 62	EFX_POPULATE_DWORD_2(mport,63			     MAE_MPORT_SELECTOR_TYPE, MAE_MPORT_SELECTOR_TYPE_PPORT,64			     MAE_MPORT_SELECTOR_PPORT_ID, efx->port_num);65	*out = EFX_DWORD_VAL(mport);66}67 68void efx_mae_mport_uplink(struct efx_nic *efx __always_unused, u32 *out)69{70	efx_dword_t mport;71 72	EFX_POPULATE_DWORD_3(mport,73			     MAE_MPORT_SELECTOR_TYPE, MAE_MPORT_SELECTOR_TYPE_FUNC,74			     MAE_MPORT_SELECTOR_FUNC_PF_ID, MAE_MPORT_SELECTOR_FUNC_PF_ID_CALLER,75			     MAE_MPORT_SELECTOR_FUNC_VF_ID, MAE_MPORT_SELECTOR_FUNC_VF_ID_NULL);76	*out = EFX_DWORD_VAL(mport);77}78 79void efx_mae_mport_vf(struct efx_nic *efx __always_unused, u32 vf_id, u32 *out)80{81	efx_dword_t mport;82 83	EFX_POPULATE_DWORD_3(mport,84			     MAE_MPORT_SELECTOR_TYPE, MAE_MPORT_SELECTOR_TYPE_FUNC,85			     MAE_MPORT_SELECTOR_FUNC_PF_ID, MAE_MPORT_SELECTOR_FUNC_PF_ID_CALLER,86			     MAE_MPORT_SELECTOR_FUNC_VF_ID, vf_id);87	*out = EFX_DWORD_VAL(mport);88}89 90/* Constructs an mport selector from an mport ID, because they're not the same */91void efx_mae_mport_mport(struct efx_nic *efx __always_unused, u32 mport_id, u32 *out)92{93	efx_dword_t mport;94 95	EFX_POPULATE_DWORD_2(mport,96			     MAE_MPORT_SELECTOR_TYPE, MAE_MPORT_SELECTOR_TYPE_MPORT_ID,97			     MAE_MPORT_SELECTOR_MPORT_ID, mport_id);98	*out = EFX_DWORD_VAL(mport);99}100 101/* id is really only 24 bits wide */102int efx_mae_fw_lookup_mport(struct efx_nic *efx, u32 selector, u32 *id)103{104	MCDI_DECLARE_BUF(outbuf, MC_CMD_MAE_MPORT_LOOKUP_OUT_LEN);105	MCDI_DECLARE_BUF(inbuf, MC_CMD_MAE_MPORT_LOOKUP_IN_LEN);106	size_t outlen;107	int rc;108 109	MCDI_SET_DWORD(inbuf, MAE_MPORT_LOOKUP_IN_MPORT_SELECTOR, selector);110	rc = efx_mcdi_rpc(efx, MC_CMD_MAE_MPORT_LOOKUP, inbuf, sizeof(inbuf),111			  outbuf, sizeof(outbuf), &outlen);112	if (rc)113		return rc;114	if (outlen < sizeof(outbuf))115		return -EIO;116	*id = MCDI_DWORD(outbuf, MAE_MPORT_LOOKUP_OUT_MPORT_ID);117	return 0;118}119 120int efx_mae_start_counters(struct efx_nic *efx, struct efx_rx_queue *rx_queue)121{122	MCDI_DECLARE_BUF(inbuf, MC_CMD_MAE_COUNTERS_STREAM_START_V2_IN_LEN);123	MCDI_DECLARE_BUF(outbuf, MC_CMD_MAE_COUNTERS_STREAM_START_OUT_LEN);124	u32 out_flags;125	size_t outlen;126	int rc;127 128	MCDI_SET_WORD(inbuf, MAE_COUNTERS_STREAM_START_V2_IN_QID,129		      efx_rx_queue_index(rx_queue));130	MCDI_SET_WORD(inbuf, MAE_COUNTERS_STREAM_START_V2_IN_PACKET_SIZE,131		      efx->net_dev->mtu);132	MCDI_SET_DWORD(inbuf, MAE_COUNTERS_STREAM_START_V2_IN_COUNTER_TYPES_MASK,133		       BIT(MAE_COUNTER_TYPE_AR) | BIT(MAE_COUNTER_TYPE_CT) |134		       BIT(MAE_COUNTER_TYPE_OR));135	rc = efx_mcdi_rpc(efx, MC_CMD_MAE_COUNTERS_STREAM_START,136			  inbuf, sizeof(inbuf), outbuf, sizeof(outbuf), &outlen);137	if (rc)138		return rc;139	if (outlen < sizeof(outbuf))140		return -EIO;141	out_flags = MCDI_DWORD(outbuf, MAE_COUNTERS_STREAM_START_OUT_FLAGS);142	if (out_flags & BIT(MC_CMD_MAE_COUNTERS_STREAM_START_OUT_USES_CREDITS_OFST)) {143		netif_dbg(efx, drv, efx->net_dev,144			  "MAE counter stream uses credits\n");145		rx_queue->grant_credits = true;146		out_flags &= ~BIT(MC_CMD_MAE_COUNTERS_STREAM_START_OUT_USES_CREDITS_OFST);147	}148	if (out_flags) {149		netif_err(efx, drv, efx->net_dev,150			  "MAE counter stream start: unrecognised flags %x\n",151			  out_flags);152		goto out_stop;153	}154	return 0;155out_stop:156	efx_mae_stop_counters(efx, rx_queue);157	return -EOPNOTSUPP;158}159 160static bool efx_mae_counters_flushed(u32 *flush_gen, u32 *seen_gen)161{162	int i;163 164	for (i = 0; i < EFX_TC_COUNTER_TYPE_MAX; i++)165		if ((s32)(flush_gen[i] - seen_gen[i]) > 0)166			return false;167	return true;168}169 170int efx_mae_stop_counters(struct efx_nic *efx, struct efx_rx_queue *rx_queue)171{172	MCDI_DECLARE_BUF(outbuf, MC_CMD_MAE_COUNTERS_STREAM_STOP_V2_OUT_LENMAX);173	MCDI_DECLARE_BUF(inbuf, MC_CMD_MAE_COUNTERS_STREAM_STOP_IN_LEN);174	size_t outlen;175	int rc, i;176 177	MCDI_SET_WORD(inbuf, MAE_COUNTERS_STREAM_STOP_IN_QID,178		      efx_rx_queue_index(rx_queue));179	rc = efx_mcdi_rpc(efx, MC_CMD_MAE_COUNTERS_STREAM_STOP,180			  inbuf, sizeof(inbuf), outbuf, sizeof(outbuf), &outlen);181 182	if (rc)183		return rc;184 185	netif_dbg(efx, drv, efx->net_dev, "Draining counters:\n");186	/* Only process received generation counts */187	for (i = 0; (i < (outlen / 4)) && (i < EFX_TC_COUNTER_TYPE_MAX); i++) {188		efx->tc->flush_gen[i] = MCDI_ARRAY_DWORD(outbuf,189							 MAE_COUNTERS_STREAM_STOP_V2_OUT_GENERATION_COUNT,190							 i);191		netif_dbg(efx, drv, efx->net_dev,192			  "\ttype %u, awaiting gen %u\n", i,193			  efx->tc->flush_gen[i]);194	}195 196	efx->tc->flush_counters = true;197 198	/* Drain can take up to 2 seconds owing to FWRIVERHD-2884; whatever199	 * timeout we use, that delay is added to unload on nonresponsive200	 * hardware, so 2500ms seems like a reasonable compromise.201	 */202	if (!wait_event_timeout(efx->tc->flush_wq,203				efx_mae_counters_flushed(efx->tc->flush_gen,204							 efx->tc->seen_gen),205				msecs_to_jiffies(2500)))206		netif_warn(efx, drv, efx->net_dev,207			   "Failed to drain counters RXQ, FW may be unhappy\n");208 209	efx->tc->flush_counters = false;210 211	return rc;212}213 214void efx_mae_counters_grant_credits(struct work_struct *work)215{216	MCDI_DECLARE_BUF(inbuf, MC_CMD_MAE_COUNTERS_STREAM_GIVE_CREDITS_IN_LEN);217	struct efx_rx_queue *rx_queue = container_of(work, struct efx_rx_queue,218						     grant_work);219	struct efx_nic *efx = rx_queue->efx;220	unsigned int credits;221 222	BUILD_BUG_ON(MC_CMD_MAE_COUNTERS_STREAM_GIVE_CREDITS_OUT_LEN);223	credits = READ_ONCE(rx_queue->notified_count) - rx_queue->granted_count;224	MCDI_SET_DWORD(inbuf, MAE_COUNTERS_STREAM_GIVE_CREDITS_IN_NUM_CREDITS,225		       credits);226	if (!efx_mcdi_rpc(efx, MC_CMD_MAE_COUNTERS_STREAM_GIVE_CREDITS,227			  inbuf, sizeof(inbuf), NULL, 0, NULL))228		rx_queue->granted_count += credits;229}230 231static int efx_mae_table_get_desc(struct efx_nic *efx,232				  struct efx_tc_table_desc *desc,233				  u32 table_id)234{235	MCDI_DECLARE_BUF(outbuf, MC_CMD_TABLE_DESCRIPTOR_OUT_LEN(16));236	MCDI_DECLARE_BUF(inbuf, MC_CMD_TABLE_DESCRIPTOR_IN_LEN);237	unsigned int offset = 0, i;238	size_t outlen;239	int rc;240 241	memset(desc, 0, sizeof(*desc));242 243	MCDI_SET_DWORD(inbuf, TABLE_DESCRIPTOR_IN_TABLE_ID, table_id);244more:245	MCDI_SET_DWORD(inbuf, TABLE_DESCRIPTOR_IN_FIRST_FIELDS_INDEX, offset);246	rc = efx_mcdi_rpc(efx, MC_CMD_TABLE_DESCRIPTOR, inbuf, sizeof(inbuf),247			  outbuf, sizeof(outbuf), &outlen);248	if (rc)249		goto fail;250	if (outlen < MC_CMD_TABLE_DESCRIPTOR_OUT_LEN(1)) {251		rc = -EIO;252		goto fail;253	}254	if (!offset) { /* first iteration: get metadata */255		desc->type = MCDI_WORD(outbuf, TABLE_DESCRIPTOR_OUT_TYPE);256		desc->key_width = MCDI_WORD(outbuf, TABLE_DESCRIPTOR_OUT_KEY_WIDTH);257		desc->resp_width = MCDI_WORD(outbuf, TABLE_DESCRIPTOR_OUT_RESP_WIDTH);258		desc->n_keys = MCDI_WORD(outbuf, TABLE_DESCRIPTOR_OUT_N_KEY_FIELDS);259		desc->n_resps = MCDI_WORD(outbuf, TABLE_DESCRIPTOR_OUT_N_RESP_FIELDS);260		desc->n_prios = MCDI_WORD(outbuf, TABLE_DESCRIPTOR_OUT_N_PRIORITIES);261		desc->flags = MCDI_BYTE(outbuf, TABLE_DESCRIPTOR_OUT_FLAGS);262		rc = -EOPNOTSUPP;263		if (desc->flags)264			goto fail;265		desc->scheme = MCDI_BYTE(outbuf, TABLE_DESCRIPTOR_OUT_SCHEME);266		if (desc->scheme)267			goto fail;268		rc = -ENOMEM;269		desc->keys = kcalloc(desc->n_keys,270				     sizeof(struct efx_tc_table_field_fmt),271				     GFP_KERNEL);272		if (!desc->keys)273			goto fail;274		desc->resps = kcalloc(desc->n_resps,275				      sizeof(struct efx_tc_table_field_fmt),276				      GFP_KERNEL);277		if (!desc->resps)278			goto fail;279	}280	/* FW could have returned more than the 16 field_descrs we281	 * made room for in our outbuf282	 */283	outlen = min(outlen, sizeof(outbuf));284	for (i = 0; i + offset < desc->n_keys + desc->n_resps; i++) {285		struct efx_tc_table_field_fmt *field;286		MCDI_DECLARE_STRUCT_PTR(fdesc);287 288		if (outlen < MC_CMD_TABLE_DESCRIPTOR_OUT_LEN(i + 1)) {289			offset += i;290			goto more;291		}292		if (i + offset < desc->n_keys)293			field = desc->keys + i + offset;294		else295			field = desc->resps + (i + offset - desc->n_keys);296		fdesc = MCDI_ARRAY_STRUCT_PTR(outbuf,297					      TABLE_DESCRIPTOR_OUT_FIELDS, i);298		field->field_id = MCDI_STRUCT_WORD(fdesc,299						   TABLE_FIELD_DESCR_FIELD_ID);300		field->lbn = MCDI_STRUCT_WORD(fdesc, TABLE_FIELD_DESCR_LBN);301		field->width = MCDI_STRUCT_WORD(fdesc, TABLE_FIELD_DESCR_WIDTH);302		field->masking = MCDI_STRUCT_BYTE(fdesc, TABLE_FIELD_DESCR_MASK_TYPE);303		field->scheme = MCDI_STRUCT_BYTE(fdesc, TABLE_FIELD_DESCR_SCHEME);304	}305	return 0;306 307fail:308	kfree(desc->keys);309	kfree(desc->resps);310	return rc;311}312 313static int efx_mae_table_hook_find(u16 n_fields,314				   struct efx_tc_table_field_fmt *fields,315				   u16 field_id)316{317	unsigned int i;318 319	for (i = 0; i < n_fields; i++) {320		if (fields[i].field_id == field_id)321			return i;322	}323	return -EPROTO;324}325 326#define TABLE_FIND_KEY(_desc, _id)	\327	efx_mae_table_hook_find((_desc)->n_keys, (_desc)->keys, _id)328#define TABLE_FIND_RESP(_desc, _id)	\329	efx_mae_table_hook_find((_desc)->n_resps, (_desc)->resps, _id)330 331#define TABLE_HOOK_KEY(_meta, _name, _mcdi_name)	({			\332	int _rc = TABLE_FIND_KEY(&_meta->desc, TABLE_FIELD_ID_##_mcdi_name);	\333										\334	if (_rc > U8_MAX)							\335		_rc = -EOPNOTSUPP;						\336	if (_rc >= 0) {								\337		_meta->keys._name##_idx = _rc;					\338		_rc = 0;							\339	}									\340	_rc;									\341})342#define TABLE_HOOK_RESP(_meta, _name, _mcdi_name)	({			\343	int _rc = TABLE_FIND_RESP(&_meta->desc, TABLE_FIELD_ID_##_mcdi_name);	\344										\345	if (_rc > U8_MAX)							\346		_rc = -EOPNOTSUPP;						\347	if (_rc >= 0) {								\348		_meta->resps._name##_idx = _rc;					\349		_rc = 0;							\350	}									\351	_rc;									\352})353 354static int efx_mae_table_hook_ct(struct efx_nic *efx,355				 struct efx_tc_table_ct *meta_ct)356{357	int rc;358 359	rc = TABLE_HOOK_KEY(meta_ct, eth_proto, ETHER_TYPE);360	if (rc)361		return rc;362	rc = TABLE_HOOK_KEY(meta_ct, ip_proto, IP_PROTO);363	if (rc)364		return rc;365	rc = TABLE_HOOK_KEY(meta_ct, src_ip, SRC_IP);366	if (rc)367		return rc;368	rc = TABLE_HOOK_KEY(meta_ct, dst_ip, DST_IP);369	if (rc)370		return rc;371	rc = TABLE_HOOK_KEY(meta_ct, l4_sport, SRC_PORT);372	if (rc)373		return rc;374	rc = TABLE_HOOK_KEY(meta_ct, l4_dport, DST_PORT);375	if (rc)376		return rc;377	rc = TABLE_HOOK_KEY(meta_ct, zone, DOMAIN);378	if (rc)379		return rc;380	rc = TABLE_HOOK_RESP(meta_ct, dnat, NAT_DIR);381	if (rc)382		return rc;383	rc = TABLE_HOOK_RESP(meta_ct, nat_ip, NAT_IP);384	if (rc)385		return rc;386	rc = TABLE_HOOK_RESP(meta_ct, l4_natport, NAT_PORT);387	if (rc)388		return rc;389	rc = TABLE_HOOK_RESP(meta_ct, mark, CT_MARK);390	if (rc)391		return rc;392	rc = TABLE_HOOK_RESP(meta_ct, counter_id, COUNTER_ID);393	if (rc)394		return rc;395	meta_ct->hooked = true;396	return 0;397}398 399static void efx_mae_table_free_desc(struct efx_tc_table_desc *desc)400{401	kfree(desc->keys);402	kfree(desc->resps);403	memset(desc, 0, sizeof(*desc));404}405 406static bool efx_mae_check_table_exists(struct efx_nic *efx, u32 tbl_req)407{408	MCDI_DECLARE_BUF(outbuf, MC_CMD_TABLE_LIST_OUT_LEN(16));409	MCDI_DECLARE_BUF(inbuf, MC_CMD_TABLE_LIST_IN_LEN);410	u32 tbl_id, tbl_total, tbl_cnt, pos = 0;411	size_t outlen, msg_max;412	bool ct_tbl = false;413	int rc, idx;414 415	msg_max = sizeof(outbuf);416	efx->tc->meta_ct.hooked = false;417more:418	memset(outbuf, 0, sizeof(*outbuf));419	MCDI_SET_DWORD(inbuf, TABLE_LIST_IN_FIRST_TABLE_ID_INDEX, pos);420	rc = efx_mcdi_rpc(efx, MC_CMD_TABLE_LIST, inbuf, sizeof(inbuf), outbuf,421			  msg_max, &outlen);422	if (rc)423		return false;424 425	if (outlen < MC_CMD_TABLE_LIST_OUT_LEN(1))426		return false;427 428	tbl_total = MCDI_DWORD(outbuf, TABLE_LIST_OUT_N_TABLES);429	tbl_cnt = MC_CMD_TABLE_LIST_OUT_TABLE_ID_NUM(min(outlen, msg_max));430 431	for (idx = 0; idx < tbl_cnt; idx++) {432		tbl_id = MCDI_ARRAY_DWORD(outbuf, TABLE_LIST_OUT_TABLE_ID, idx);433		if (tbl_id == tbl_req) {434			ct_tbl = true;435			break;436		}437	}438 439	pos += tbl_cnt;440	if (!ct_tbl && pos < tbl_total)441		goto more;442 443	return ct_tbl;444}445 446int efx_mae_get_tables(struct efx_nic *efx)447{448	int rc;449 450	efx->tc->meta_ct.hooked = false;451	if (efx_mae_check_table_exists(efx, TABLE_ID_CONNTRACK_TABLE)) {452		rc = efx_mae_table_get_desc(efx, &efx->tc->meta_ct.desc,453					    TABLE_ID_CONNTRACK_TABLE);454		if (rc) {455			pci_info(efx->pci_dev,456				 "FW does not support conntrack desc rc %d\n",457				 rc);458			return 0;459		}460 461		rc = efx_mae_table_hook_ct(efx, &efx->tc->meta_ct);462		if (rc) {463			pci_info(efx->pci_dev,464				 "FW does not support conntrack hook rc %d\n",465				 rc);466			return 0;467		}468	} else {469		pci_info(efx->pci_dev,470			 "FW does not support conntrack table\n");471	}472	return 0;473}474 475void efx_mae_free_tables(struct efx_nic *efx)476{477	efx_mae_table_free_desc(&efx->tc->meta_ct.desc);478	efx->tc->meta_ct.hooked = false;479}480 481static int efx_mae_get_basic_caps(struct efx_nic *efx, struct mae_caps *caps)482{483	MCDI_DECLARE_BUF(outbuf, MC_CMD_MAE_GET_CAPS_OUT_LEN);484	size_t outlen;485	int rc;486 487	BUILD_BUG_ON(MC_CMD_MAE_GET_CAPS_IN_LEN);488 489	rc = efx_mcdi_rpc(efx, MC_CMD_MAE_GET_CAPS, NULL, 0, outbuf,490			  sizeof(outbuf), &outlen);491	if (rc)492		return rc;493	if (outlen < sizeof(outbuf))494		return -EIO;495	caps->match_field_count = MCDI_DWORD(outbuf, MAE_GET_CAPS_OUT_MATCH_FIELD_COUNT);496	caps->encap_types = MCDI_DWORD(outbuf, MAE_GET_CAPS_OUT_ENCAP_TYPES_SUPPORTED);497	caps->action_prios = MCDI_DWORD(outbuf, MAE_GET_CAPS_OUT_ACTION_PRIOS);498	return 0;499}500 501static int efx_mae_get_rule_fields(struct efx_nic *efx, u32 cmd,502				   u8 *field_support)503{504	MCDI_DECLARE_BUF(outbuf, MC_CMD_MAE_GET_AR_CAPS_OUT_LEN(MAE_NUM_FIELDS));505	MCDI_DECLARE_STRUCT_PTR(caps);506	unsigned int count;507	size_t outlen;508	int rc, i;509 510	/* AR and OR caps MCDIs have identical layout, so we are using the511	 * same code for both.512	 */513	BUILD_BUG_ON(MC_CMD_MAE_GET_AR_CAPS_OUT_LEN(MAE_NUM_FIELDS) <514		     MC_CMD_MAE_GET_OR_CAPS_OUT_LEN(MAE_NUM_FIELDS));515	BUILD_BUG_ON(MC_CMD_MAE_GET_AR_CAPS_IN_LEN);516	BUILD_BUG_ON(MC_CMD_MAE_GET_OR_CAPS_IN_LEN);517 518	rc = efx_mcdi_rpc(efx, cmd, NULL, 0, outbuf, sizeof(outbuf), &outlen);519	if (rc)520		return rc;521	BUILD_BUG_ON(MC_CMD_MAE_GET_AR_CAPS_OUT_COUNT_OFST !=522		     MC_CMD_MAE_GET_OR_CAPS_OUT_COUNT_OFST);523	count = MCDI_DWORD(outbuf, MAE_GET_AR_CAPS_OUT_COUNT);524	memset(field_support, MAE_FIELD_UNSUPPORTED, MAE_NUM_FIELDS);525	BUILD_BUG_ON(MC_CMD_MAE_GET_AR_CAPS_OUT_FIELD_FLAGS_OFST !=526		     MC_CMD_MAE_GET_OR_CAPS_OUT_FIELD_FLAGS_OFST);527	caps = _MCDI_DWORD(outbuf, MAE_GET_AR_CAPS_OUT_FIELD_FLAGS);528	/* We're only interested in the support status enum, not any other529	 * flags, so just extract that from each entry.530	 */531	for (i = 0; i < count; i++)532		if (i * sizeof(*outbuf) + MC_CMD_MAE_GET_AR_CAPS_OUT_FIELD_FLAGS_OFST < outlen)533			field_support[i] = EFX_DWORD_FIELD(caps[i], MAE_FIELD_FLAGS_SUPPORT_STATUS);534	return 0;535}536 537int efx_mae_get_caps(struct efx_nic *efx, struct mae_caps *caps)538{539	int rc;540 541	rc = efx_mae_get_basic_caps(efx, caps);542	if (rc)543		return rc;544	rc = efx_mae_get_rule_fields(efx, MC_CMD_MAE_GET_AR_CAPS,545				     caps->action_rule_fields);546	if (rc)547		return rc;548	return efx_mae_get_rule_fields(efx, MC_CMD_MAE_GET_OR_CAPS,549				       caps->outer_rule_fields);550}551 552/* Bit twiddling:553 * Prefix: 1...110...0554 *      ~: 0...001...1555 *    + 1: 0...010...0 is power of two556 * so (~x) & ((~x) + 1) == 0.  Converse holds also.557 */558#define is_prefix_byte(_x)	!(((_x) ^ 0xff) & (((_x) ^ 0xff) + 1))559 560enum mask_type { MASK_ONES, MASK_ZEROES, MASK_PREFIX, MASK_OTHER };561 562static const char *mask_type_name(enum mask_type typ)563{564	switch (typ) {565	case MASK_ONES:566		return "all-1s";567	case MASK_ZEROES:568		return "all-0s";569	case MASK_PREFIX:570		return "prefix";571	case MASK_OTHER:572		return "arbitrary";573	default: /* can't happen */574		return "unknown";575	}576}577 578/* Checks a (big-endian) bytestring is a bit prefix */579static enum mask_type classify_mask(const u8 *mask, size_t len)580{581	bool zeroes = true; /* All bits seen so far are zeroes */582	bool ones = true; /* All bits seen so far are ones */583	bool prefix = true; /* Valid prefix so far */584	size_t i;585 586	for (i = 0; i < len; i++) {587		if (ones) {588			if (!is_prefix_byte(mask[i]))589				prefix = false;590		} else if (mask[i]) {591			prefix = false;592		}593		if (mask[i] != 0xff)594			ones = false;595		if (mask[i])596			zeroes = false;597	}598	if (ones)599		return MASK_ONES;600	if (zeroes)601		return MASK_ZEROES;602	if (prefix)603		return MASK_PREFIX;604	return MASK_OTHER;605}606 607static int efx_mae_match_check_cap_typ(u8 support, enum mask_type typ)608{609	switch (support) {610	case MAE_FIELD_UNSUPPORTED:611	case MAE_FIELD_SUPPORTED_MATCH_NEVER:612		if (typ == MASK_ZEROES)613			return 0;614		return -EOPNOTSUPP;615	case MAE_FIELD_SUPPORTED_MATCH_OPTIONAL:616		if (typ == MASK_ZEROES)617			return 0;618		fallthrough;619	case MAE_FIELD_SUPPORTED_MATCH_ALWAYS:620		if (typ == MASK_ONES)621			return 0;622		return -EINVAL;623	case MAE_FIELD_SUPPORTED_MATCH_PREFIX:624		if (typ == MASK_OTHER)625			return -EOPNOTSUPP;626		return 0;627	case MAE_FIELD_SUPPORTED_MATCH_MASK:628		return 0;629	default:630		return -EIO;631	}632}633 634/* Validate field mask against hardware capabilities.  Captures caller's 'rc' */635#define CHECK(_mcdi, _field)	({					       \636	enum mask_type typ = classify_mask((const u8 *)&mask->_field,	       \637					   sizeof(mask->_field));	       \638									       \639	rc = efx_mae_match_check_cap_typ(supported_fields[MAE_FIELD_ ## _mcdi],\640					 typ);				       \641	if (rc)								       \642		NL_SET_ERR_MSG_FMT_MOD(extack,				       \643				       "No support for %s mask in field %s",   \644				       mask_type_name(typ), #_field);	       \645	rc;								       \646})647/* Booleans need special handling */648#define CHECK_BIT(_mcdi, _field)	({				       \649	enum mask_type typ = mask->_field ? MASK_ONES : MASK_ZEROES;	       \650									       \651	rc = efx_mae_match_check_cap_typ(supported_fields[MAE_FIELD_ ## _mcdi],\652					 typ);				       \653	if (rc)								       \654		NL_SET_ERR_MSG_FMT_MOD(extack,				       \655				       "No support for %s mask in field %s",   \656				       mask_type_name(typ), #_field);	       \657	rc;								       \658})659 660int efx_mae_match_check_caps(struct efx_nic *efx,661			     const struct efx_tc_match_fields *mask,662			     struct netlink_ext_ack *extack)663{664	const u8 *supported_fields = efx->tc->caps->action_rule_fields;665	__be32 ingress_port = cpu_to_be32(mask->ingress_port);666	enum mask_type ingress_port_mask_type;667	int rc;668 669	/* Check for _PREFIX assumes big-endian, so we need to convert */670	ingress_port_mask_type = classify_mask((const u8 *)&ingress_port,671					       sizeof(ingress_port));672	rc = efx_mae_match_check_cap_typ(supported_fields[MAE_FIELD_INGRESS_PORT],673					 ingress_port_mask_type);674	if (rc) {675		NL_SET_ERR_MSG_FMT_MOD(extack, "No support for %s mask in field ingress_port",676				       mask_type_name(ingress_port_mask_type));677		return rc;678	}679	if (CHECK(ETHER_TYPE, eth_proto) ||680	    CHECK(VLAN0_TCI, vlan_tci[0]) ||681	    CHECK(VLAN0_PROTO, vlan_proto[0]) ||682	    CHECK(VLAN1_TCI, vlan_tci[1]) ||683	    CHECK(VLAN1_PROTO, vlan_proto[1]) ||684	    CHECK(ETH_SADDR, eth_saddr) ||685	    CHECK(ETH_DADDR, eth_daddr) ||686	    CHECK(IP_PROTO, ip_proto) ||687	    CHECK(IP_TOS, ip_tos) ||688	    CHECK(IP_TTL, ip_ttl) ||689	    CHECK(SRC_IP4, src_ip) ||690	    CHECK(DST_IP4, dst_ip) ||691#ifdef CONFIG_IPV6692	    CHECK(SRC_IP6, src_ip6) ||693	    CHECK(DST_IP6, dst_ip6) ||694#endif695	    CHECK(L4_SPORT, l4_sport) ||696	    CHECK(L4_DPORT, l4_dport) ||697	    CHECK(TCP_FLAGS, tcp_flags) ||698	    CHECK_BIT(TCP_SYN_FIN_RST, tcp_syn_fin_rst) ||699	    CHECK_BIT(IS_IP_FRAG, ip_frag) ||700	    CHECK_BIT(IP_FIRST_FRAG, ip_firstfrag) ||701	    CHECK_BIT(DO_CT, ct_state_trk) ||702	    CHECK_BIT(CT_HIT, ct_state_est) ||703	    CHECK(CT_MARK, ct_mark) ||704	    CHECK(CT_DOMAIN, ct_zone) ||705	    CHECK(RECIRC_ID, recirc_id))706		return rc;707	/* Matches on outer fields are done in a separate hardware table,708	 * the Outer Rule table.  Thus the Action Rule merely does an709	 * exact match on Outer Rule ID if any outer field matches are710	 * present.  The exception is the VNI/VSID (enc_keyid), which is711	 * available to the Action Rule match iff the Outer Rule matched712	 * (and thus identified the encap protocol to use to extract it).713	 */714	if (efx_tc_match_is_encap(mask)) {715		rc = efx_mae_match_check_cap_typ(716				supported_fields[MAE_FIELD_OUTER_RULE_ID],717				MASK_ONES);718		if (rc) {719			NL_SET_ERR_MSG_MOD(extack, "No support for encap rule ID matches");720			return rc;721		}722		if (CHECK(ENC_VNET_ID, enc_keyid))723			return rc;724	} else if (mask->enc_keyid) {725		NL_SET_ERR_MSG_MOD(extack, "Match on enc_keyid requires other encap fields");726		return -EINVAL;727	}728	return 0;729}730 731/* Checks for match fields not supported in LHS Outer Rules */732#define UNSUPPORTED(_field)	({					       \733	enum mask_type typ = classify_mask((const u8 *)&mask->_field,	       \734					   sizeof(mask->_field));	       \735									       \736	if (typ != MASK_ZEROES) {					       \737		NL_SET_ERR_MSG_MOD(extack, "Unsupported match field " #_field);\738		rc = -EOPNOTSUPP;					       \739	}								       \740	rc;								       \741})742#define UNSUPPORTED_BIT(_field)	({					       \743	if (mask->_field) {						       \744		NL_SET_ERR_MSG_MOD(extack, "Unsupported match field " #_field);\745		rc = -EOPNOTSUPP;					       \746	}								       \747	rc;								       \748})749 750/* LHS rules are (normally) inserted in the Outer Rule table, which means751 * they use ENC_ fields in hardware to match regular (not enc_) fields from752 * &struct efx_tc_match_fields.753 */754int efx_mae_match_check_caps_lhs(struct efx_nic *efx,755				 const struct efx_tc_match_fields *mask,756				 struct netlink_ext_ack *extack)757{758	const u8 *supported_fields = efx->tc->caps->outer_rule_fields;759	__be32 ingress_port = cpu_to_be32(mask->ingress_port);760	enum mask_type ingress_port_mask_type;761	int rc;762 763	/* Check for _PREFIX assumes big-endian, so we need to convert */764	ingress_port_mask_type = classify_mask((const u8 *)&ingress_port,765					       sizeof(ingress_port));766	rc = efx_mae_match_check_cap_typ(supported_fields[MAE_FIELD_INGRESS_PORT],767					 ingress_port_mask_type);768	if (rc) {769		NL_SET_ERR_MSG_FMT_MOD(extack, "No support for %s mask in field %s\n",770				       mask_type_name(ingress_port_mask_type),771				       "ingress_port");772		return rc;773	}774	if (CHECK(ENC_ETHER_TYPE, eth_proto) ||775	    CHECK(ENC_VLAN0_TCI, vlan_tci[0]) ||776	    CHECK(ENC_VLAN0_PROTO, vlan_proto[0]) ||777	    CHECK(ENC_VLAN1_TCI, vlan_tci[1]) ||778	    CHECK(ENC_VLAN1_PROTO, vlan_proto[1]) ||779	    CHECK(ENC_ETH_SADDR, eth_saddr) ||780	    CHECK(ENC_ETH_DADDR, eth_daddr) ||781	    CHECK(ENC_IP_PROTO, ip_proto) ||782	    CHECK(ENC_IP_TOS, ip_tos) ||783	    CHECK(ENC_IP_TTL, ip_ttl) ||784	    CHECK_BIT(ENC_IP_FRAG, ip_frag) ||785	    UNSUPPORTED_BIT(ip_firstfrag) ||786	    CHECK(ENC_SRC_IP4, src_ip) ||787	    CHECK(ENC_DST_IP4, dst_ip) ||788#ifdef CONFIG_IPV6789	    CHECK(ENC_SRC_IP6, src_ip6) ||790	    CHECK(ENC_DST_IP6, dst_ip6) ||791#endif792	    CHECK(ENC_L4_SPORT, l4_sport) ||793	    CHECK(ENC_L4_DPORT, l4_dport) ||794	    UNSUPPORTED(tcp_flags) ||795	    CHECK_BIT(TCP_SYN_FIN_RST, tcp_syn_fin_rst))796		return rc;797	if (efx_tc_match_is_encap(mask)) {798		/* can't happen; disallowed for local rules, translated799		 * for foreign rules.800		 */801		NL_SET_ERR_MSG_MOD(extack, "Unexpected encap match in LHS rule");802		return -EOPNOTSUPP;803	}804	if (UNSUPPORTED(enc_keyid) ||805	    /* Can't filter on conntrack in LHS rules */806	    UNSUPPORTED_BIT(ct_state_trk) ||807	    UNSUPPORTED_BIT(ct_state_est) ||808	    UNSUPPORTED(ct_mark) ||809	    UNSUPPORTED(recirc_id))810		return rc;811	return 0;812}813#undef UNSUPPORTED814#undef CHECK_BIT815#undef CHECK816 817#define CHECK(_mcdi)	({						       \818	rc = efx_mae_match_check_cap_typ(supported_fields[MAE_FIELD_ ## _mcdi],\819					 MASK_ONES);			       \820	if (rc)								       \821		NL_SET_ERR_MSG_FMT_MOD(extack,				       \822				       "No support for field %s", #_mcdi);     \823	rc;								       \824})825/* Checks that the fields needed for encap-rule matches are supported by the826 * MAE.  All the fields are exact-match, except possibly ENC_IP_TOS.827 */828int efx_mae_check_encap_match_caps(struct efx_nic *efx, bool ipv6,829				   u8 ip_tos_mask, __be16 udp_sport_mask,830				   struct netlink_ext_ack *extack)831{832	u8 *supported_fields = efx->tc->caps->outer_rule_fields;833	enum mask_type typ;834	int rc;835 836	if (CHECK(ENC_ETHER_TYPE))837		return rc;838	if (ipv6) {839		if (CHECK(ENC_SRC_IP6) ||840		    CHECK(ENC_DST_IP6))841			return rc;842	} else {843		if (CHECK(ENC_SRC_IP4) ||844		    CHECK(ENC_DST_IP4))845			return rc;846	}847	if (CHECK(ENC_L4_DPORT) ||848	    CHECK(ENC_IP_PROTO))849		return rc;850	typ = classify_mask((const u8 *)&udp_sport_mask, sizeof(udp_sport_mask));851	rc = efx_mae_match_check_cap_typ(supported_fields[MAE_FIELD_ENC_L4_SPORT],852					 typ);853	if (rc) {854		NL_SET_ERR_MSG_FMT_MOD(extack, "No support for %s mask in field %s",855				       mask_type_name(typ), "enc_src_port");856		return rc;857	}858	typ = classify_mask(&ip_tos_mask, sizeof(ip_tos_mask));859	rc = efx_mae_match_check_cap_typ(supported_fields[MAE_FIELD_ENC_IP_TOS],860					 typ);861	if (rc) {862		NL_SET_ERR_MSG_FMT_MOD(extack, "No support for %s mask in field %s",863				       mask_type_name(typ), "enc_ip_tos");864		return rc;865	}866	return 0;867}868#undef CHECK869 870int efx_mae_check_encap_type_supported(struct efx_nic *efx, enum efx_encap_type typ)871{872	unsigned int bit;873 874	switch (typ & EFX_ENCAP_TYPES_MASK) {875	case EFX_ENCAP_TYPE_VXLAN:876		bit = MC_CMD_MAE_GET_CAPS_OUT_ENCAP_TYPE_VXLAN_LBN;877		break;878	case EFX_ENCAP_TYPE_GENEVE:879		bit = MC_CMD_MAE_GET_CAPS_OUT_ENCAP_TYPE_GENEVE_LBN;880		break;881	default:882		return -EOPNOTSUPP;883	}884	if (efx->tc->caps->encap_types & BIT(bit))885		return 0;886	return -EOPNOTSUPP;887}888 889int efx_mae_allocate_counter(struct efx_nic *efx, struct efx_tc_counter *cnt)890{891	MCDI_DECLARE_BUF(outbuf, MC_CMD_MAE_COUNTER_ALLOC_OUT_LEN(1));892	MCDI_DECLARE_BUF(inbuf, MC_CMD_MAE_COUNTER_ALLOC_V2_IN_LEN);893	size_t outlen;894	int rc;895 896	if (!cnt)897		return -EINVAL;898 899	MCDI_SET_DWORD(inbuf, MAE_COUNTER_ALLOC_V2_IN_REQUESTED_COUNT, 1);900	MCDI_SET_DWORD(inbuf, MAE_COUNTER_ALLOC_V2_IN_COUNTER_TYPE, cnt->type);901	rc = efx_mcdi_rpc(efx, MC_CMD_MAE_COUNTER_ALLOC, inbuf, sizeof(inbuf),902			  outbuf, sizeof(outbuf), &outlen);903	if (rc)904		return rc;905	/* pcol says this can't happen, since count is 1 */906	if (outlen < sizeof(outbuf))907		return -EIO;908	cnt->fw_id = MCDI_DWORD(outbuf, MAE_COUNTER_ALLOC_OUT_COUNTER_ID);909	cnt->gen = MCDI_DWORD(outbuf, MAE_COUNTER_ALLOC_OUT_GENERATION_COUNT);910	return 0;911}912 913int efx_mae_free_counter(struct efx_nic *efx, struct efx_tc_counter *cnt)914{915	MCDI_DECLARE_BUF(outbuf, MC_CMD_MAE_COUNTER_FREE_OUT_LEN(1));916	MCDI_DECLARE_BUF(inbuf, MC_CMD_MAE_COUNTER_FREE_V2_IN_LEN);917	size_t outlen;918	int rc;919 920	MCDI_SET_DWORD(inbuf, MAE_COUNTER_FREE_V2_IN_COUNTER_ID_COUNT, 1);921	MCDI_SET_DWORD(inbuf, MAE_COUNTER_FREE_V2_IN_FREE_COUNTER_ID, cnt->fw_id);922	MCDI_SET_DWORD(inbuf, MAE_COUNTER_FREE_V2_IN_COUNTER_TYPE, cnt->type);923	rc = efx_mcdi_rpc(efx, MC_CMD_MAE_COUNTER_FREE, inbuf, sizeof(inbuf),924			  outbuf, sizeof(outbuf), &outlen);925	if (rc)926		return rc;927	/* pcol says this can't happen, since count is 1 */928	if (outlen < sizeof(outbuf))929		return -EIO;930	/* FW freed a different ID than we asked for, should also never happen.931	 * Warn because it means we've now got a different idea to the FW of932	 * what counters exist, which could cause mayhem later.933	 */934	if (WARN_ON(MCDI_DWORD(outbuf, MAE_COUNTER_FREE_OUT_FREED_COUNTER_ID) !=935		    cnt->fw_id))936		return -EIO;937	return 0;938}939 940static int efx_mae_encap_type_to_mae_type(enum efx_encap_type type)941{942	switch (type & EFX_ENCAP_TYPES_MASK) {943	case EFX_ENCAP_TYPE_NONE:944		return MAE_MCDI_ENCAP_TYPE_NONE;945	case EFX_ENCAP_TYPE_VXLAN:946		return MAE_MCDI_ENCAP_TYPE_VXLAN;947	case EFX_ENCAP_TYPE_GENEVE:948		return MAE_MCDI_ENCAP_TYPE_GENEVE;949	default:950		return -EOPNOTSUPP;951	}952}953 954int efx_mae_allocate_encap_md(struct efx_nic *efx,955			      struct efx_tc_encap_action *encap)956{957	MCDI_DECLARE_BUF(inbuf, MC_CMD_MAE_ENCAP_HEADER_ALLOC_IN_LEN(EFX_TC_MAX_ENCAP_HDR));958	MCDI_DECLARE_BUF(outbuf, MC_CMD_MAE_ENCAP_HEADER_ALLOC_OUT_LEN);959	size_t inlen, outlen;960	int rc;961 962	rc = efx_mae_encap_type_to_mae_type(encap->type);963	if (rc < 0)964		return rc;965	MCDI_SET_DWORD(inbuf, MAE_ENCAP_HEADER_ALLOC_IN_ENCAP_TYPE, rc);966	inlen = MC_CMD_MAE_ENCAP_HEADER_ALLOC_IN_LEN(encap->encap_hdr_len);967	if (WARN_ON(inlen > sizeof(inbuf))) /* can't happen */968		return -EINVAL;969	memcpy(MCDI_PTR(inbuf, MAE_ENCAP_HEADER_ALLOC_IN_HDR_DATA),970	       encap->encap_hdr,971	       encap->encap_hdr_len);972	rc = efx_mcdi_rpc(efx, MC_CMD_MAE_ENCAP_HEADER_ALLOC, inbuf,973			  inlen, outbuf, sizeof(outbuf), &outlen);974	if (rc)975		return rc;976	if (outlen < sizeof(outbuf))977		return -EIO;978	encap->fw_id = MCDI_DWORD(outbuf, MAE_ENCAP_HEADER_ALLOC_OUT_ENCAP_HEADER_ID);979	return 0;980}981 982int efx_mae_update_encap_md(struct efx_nic *efx,983			    struct efx_tc_encap_action *encap)984{985	MCDI_DECLARE_BUF(inbuf, MC_CMD_MAE_ENCAP_HEADER_UPDATE_IN_LEN(EFX_TC_MAX_ENCAP_HDR));986	size_t inlen;987	int rc;988 989	rc = efx_mae_encap_type_to_mae_type(encap->type);990	if (rc < 0)991		return rc;992	MCDI_SET_DWORD(inbuf, MAE_ENCAP_HEADER_UPDATE_IN_ENCAP_TYPE, rc);993	MCDI_SET_DWORD(inbuf, MAE_ENCAP_HEADER_UPDATE_IN_EH_ID,994		       encap->fw_id);995	inlen = MC_CMD_MAE_ENCAP_HEADER_UPDATE_IN_LEN(encap->encap_hdr_len);996	if (WARN_ON(inlen > sizeof(inbuf))) /* can't happen */997		return -EINVAL;998	memcpy(MCDI_PTR(inbuf, MAE_ENCAP_HEADER_UPDATE_IN_HDR_DATA),999	       encap->encap_hdr,1000	       encap->encap_hdr_len);1001 1002	BUILD_BUG_ON(MC_CMD_MAE_ENCAP_HEADER_UPDATE_OUT_LEN != 0);1003	return efx_mcdi_rpc(efx, MC_CMD_MAE_ENCAP_HEADER_UPDATE, inbuf,1004			    inlen, NULL, 0, NULL);1005}1006 1007int efx_mae_free_encap_md(struct efx_nic *efx,1008			  struct efx_tc_encap_action *encap)1009{1010	MCDI_DECLARE_BUF(outbuf, MC_CMD_MAE_ENCAP_HEADER_FREE_OUT_LEN(1));1011	MCDI_DECLARE_BUF(inbuf, MC_CMD_MAE_ENCAP_HEADER_FREE_IN_LEN(1));1012	size_t outlen;1013	int rc;1014 1015	MCDI_SET_DWORD(inbuf, MAE_ENCAP_HEADER_FREE_IN_EH_ID, encap->fw_id);1016	rc = efx_mcdi_rpc(efx, MC_CMD_MAE_ENCAP_HEADER_FREE, inbuf,1017			  sizeof(inbuf), outbuf, sizeof(outbuf), &outlen);1018	if (rc)1019		return rc;1020	if (outlen < sizeof(outbuf))1021		return -EIO;1022	/* FW freed a different ID than we asked for, should also never happen.1023	 * Warn because it means we've now got a different idea to the FW of1024	 * what encap_mds exist, which could cause mayhem later.1025	 */1026	if (WARN_ON(MCDI_DWORD(outbuf, MAE_ENCAP_HEADER_FREE_OUT_FREED_EH_ID) != encap->fw_id))1027		return -EIO;1028	/* We're probably about to free @encap, but let's just make sure its1029	 * fw_id is blatted so that it won't look valid if it leaks out.1030	 */1031	encap->fw_id = MC_CMD_MAE_ENCAP_HEADER_ALLOC_OUT_ENCAP_HEADER_ID_NULL;1032	return 0;1033}1034 1035int efx_mae_lookup_mport(struct efx_nic *efx, u32 vf_idx, u32 *id)1036{1037	struct ef100_nic_data *nic_data = efx->nic_data;1038	struct efx_mae *mae = efx->mae;1039	struct rhashtable_iter walk;1040	struct mae_mport_desc *m;1041	int rc = -ENOENT;1042 1043	rhashtable_walk_enter(&mae->mports_ht, &walk);1044	rhashtable_walk_start(&walk);1045	while ((m = rhashtable_walk_next(&walk)) != NULL) {1046		if (m->mport_type == MAE_MPORT_DESC_MPORT_TYPE_VNIC &&1047		    m->interface_idx == nic_data->local_mae_intf &&1048		    m->pf_idx == 0 &&1049		    m->vf_idx == vf_idx) {1050			*id = m->mport_id;1051			rc = 0;1052			break;1053		}1054	}1055	rhashtable_walk_stop(&walk);1056	rhashtable_walk_exit(&walk);1057	return rc;1058}1059 1060static bool efx_mae_asl_id(u32 id)1061{1062	return !!(id & BIT(31));1063}1064 1065/* mport handling */1066static const struct rhashtable_params efx_mae_mports_ht_params = {1067	.key_len	= sizeof(u32),1068	.key_offset	= offsetof(struct mae_mport_desc, mport_id),1069	.head_offset	= offsetof(struct mae_mport_desc, linkage),1070};1071 1072struct mae_mport_desc *efx_mae_get_mport(struct efx_nic *efx, u32 mport_id)1073{1074	return rhashtable_lookup_fast(&efx->mae->mports_ht, &mport_id,1075				      efx_mae_mports_ht_params);1076}1077 1078static int efx_mae_add_mport(struct efx_nic *efx, struct mae_mport_desc *desc)1079{1080	struct efx_mae *mae = efx->mae;1081	int rc;1082 1083	rc = rhashtable_insert_fast(&mae->mports_ht, &desc->linkage,1084				    efx_mae_mports_ht_params);1085 1086	if (rc) {1087		pci_err(efx->pci_dev, "Failed to insert MPORT %08x, rc %d\n",1088			desc->mport_id, rc);1089		kfree(desc);1090		return rc;1091	}1092 1093	return rc;1094}1095 1096void efx_mae_remove_mport(void *desc, void *arg)1097{1098	struct mae_mport_desc *mport = desc;1099 1100	synchronize_rcu();1101	kfree(mport);1102}1103 1104static int efx_mae_process_mport(struct efx_nic *efx,1105				 struct mae_mport_desc *desc)1106{1107	struct ef100_nic_data *nic_data = efx->nic_data;1108	struct mae_mport_desc *mport;1109 1110	mport = efx_mae_get_mport(efx, desc->mport_id);1111	if (!IS_ERR_OR_NULL(mport)) {1112		netif_err(efx, drv, efx->net_dev,1113			  "mport with id %u does exist!!!\n", desc->mport_id);1114		return -EEXIST;1115	}1116 1117	if (nic_data->have_own_mport &&1118	    desc->mport_id == nic_data->own_mport) {1119		WARN_ON(desc->mport_type != MAE_MPORT_DESC_MPORT_TYPE_VNIC);1120		WARN_ON(desc->vnic_client_type !=1121			MAE_MPORT_DESC_VNIC_CLIENT_TYPE_FUNCTION);1122		nic_data->local_mae_intf = desc->interface_idx;1123		nic_data->have_local_intf = true;1124		pci_dbg(efx->pci_dev, "MAE interface_idx is %u\n",1125			nic_data->local_mae_intf);1126	}1127 1128	return efx_mae_add_mport(efx, desc);1129}1130 1131#define MCDI_MPORT_JOURNAL_LEN \1132	ALIGN(MC_CMD_MAE_MPORT_READ_JOURNAL_OUT_LENMAX_MCDI2, 4)1133 1134int efx_mae_enumerate_mports(struct efx_nic *efx)1135{1136	efx_dword_t *outbuf = kzalloc(MCDI_MPORT_JOURNAL_LEN, GFP_KERNEL);1137	MCDI_DECLARE_BUF(inbuf, MC_CMD_MAE_MPORT_READ_JOURNAL_IN_LEN);1138	MCDI_DECLARE_STRUCT_PTR(desc);1139	size_t outlen, stride, count;1140	int rc = 0, i;1141 1142	if (!outbuf)1143		return -ENOMEM;1144	do {1145		rc = efx_mcdi_rpc(efx, MC_CMD_MAE_MPORT_READ_JOURNAL, inbuf,1146				  sizeof(inbuf), outbuf,1147				  MCDI_MPORT_JOURNAL_LEN, &outlen);1148		if (rc)1149			goto fail;1150		if (outlen < MC_CMD_MAE_MPORT_READ_JOURNAL_OUT_MPORT_DESC_DATA_OFST) {1151			rc = -EIO;1152			goto fail;1153		}1154		count = MCDI_DWORD(outbuf, MAE_MPORT_READ_JOURNAL_OUT_MPORT_DESC_COUNT);1155		if (!count)1156			continue; /* not break; we want to look at MORE flag */1157		stride = MCDI_DWORD(outbuf, MAE_MPORT_READ_JOURNAL_OUT_SIZEOF_MPORT_DESC);1158		if (stride < MAE_MPORT_DESC_LEN) {1159			rc = -EIO;1160			goto fail;1161		}1162		if (outlen < MC_CMD_MAE_MPORT_READ_JOURNAL_OUT_LEN(count * stride)) {1163			rc = -EIO;1164			goto fail;1165		}1166 1167		for (i = 0; i < count; i++) {1168			struct mae_mport_desc *d;1169 1170			d = kzalloc(sizeof(*d), GFP_KERNEL);1171			if (!d) {1172				rc = -ENOMEM;1173				goto fail;1174			}1175 1176			desc = (efx_dword_t *)1177				_MCDI_PTR(outbuf, MC_CMD_MAE_MPORT_READ_JOURNAL_OUT_MPORT_DESC_DATA_OFST +1178					  i * stride);1179			d->mport_id = MCDI_STRUCT_DWORD(desc, MAE_MPORT_DESC_MPORT_ID);1180			d->flags = MCDI_STRUCT_DWORD(desc, MAE_MPORT_DESC_FLAGS);1181			d->caller_flags = MCDI_STRUCT_DWORD(desc,1182							    MAE_MPORT_DESC_CALLER_FLAGS);1183			d->mport_type = MCDI_STRUCT_DWORD(desc,1184							  MAE_MPORT_DESC_MPORT_TYPE);1185			switch (d->mport_type) {1186			case MAE_MPORT_DESC_MPORT_TYPE_NET_PORT:1187				d->port_idx = MCDI_STRUCT_DWORD(desc,1188								MAE_MPORT_DESC_NET_PORT_IDX);1189				break;1190			case MAE_MPORT_DESC_MPORT_TYPE_ALIAS:1191				d->alias_mport_id = MCDI_STRUCT_DWORD(desc,1192								      MAE_MPORT_DESC_ALIAS_DELIVER_MPORT_ID);1193				break;1194			case MAE_MPORT_DESC_MPORT_TYPE_VNIC:1195				d->vnic_client_type = MCDI_STRUCT_DWORD(desc,1196									MAE_MPORT_DESC_VNIC_CLIENT_TYPE);1197				d->interface_idx = MCDI_STRUCT_DWORD(desc,1198								     MAE_MPORT_DESC_VNIC_FUNCTION_INTERFACE);1199				d->pf_idx = MCDI_STRUCT_WORD(desc,1200							     MAE_MPORT_DESC_VNIC_FUNCTION_PF_IDX);1201				d->vf_idx = MCDI_STRUCT_WORD(desc,1202							     MAE_MPORT_DESC_VNIC_FUNCTION_VF_IDX);1203				break;1204			default:1205				/* Unknown mport_type, just accept it */1206				break;1207			}1208			rc = efx_mae_process_mport(efx, d);1209			/* Any failure will be due to memory allocation faiure,1210			 * so there is no point to try subsequent entries.1211			 */1212			if (rc)1213				goto fail;1214		}1215	} while (MCDI_FIELD(outbuf, MAE_MPORT_READ_JOURNAL_OUT, MORE) &&1216		 !WARN_ON(!count));1217fail:1218	kfree(outbuf);1219	return rc;1220}1221 1222/**1223 * efx_mae_allocate_pedit_mac() - allocate pedit MAC address in HW.1224 * @efx:	NIC we're installing a pedit MAC address on1225 * @ped:	pedit MAC action to be installed1226 *1227 * Attempts to install @ped in HW and populates its id with an index of this1228 * entry in the firmware MAC address table on success.1229 *1230 * Return: negative value on error, 0 in success.1231 */1232int efx_mae_allocate_pedit_mac(struct efx_nic *efx,1233			       struct efx_tc_mac_pedit_action *ped)1234{1235	MCDI_DECLARE_BUF(outbuf, MC_CMD_MAE_MAC_ADDR_ALLOC_OUT_LEN);1236	MCDI_DECLARE_BUF(inbuf, MC_CMD_MAE_MAC_ADDR_ALLOC_IN_LEN);1237	size_t outlen;1238	int rc;1239 1240	BUILD_BUG_ON(MC_CMD_MAE_MAC_ADDR_ALLOC_IN_MAC_ADDR_LEN !=1241		     sizeof(ped->h_addr));1242	memcpy(MCDI_PTR(inbuf, MAE_MAC_ADDR_ALLOC_IN_MAC_ADDR), ped->h_addr,1243	       sizeof(ped->h_addr));1244	rc = efx_mcdi_rpc(efx, MC_CMD_MAE_MAC_ADDR_ALLOC, inbuf, sizeof(inbuf),1245			  outbuf, sizeof(outbuf), &outlen);1246	if (rc)1247		return rc;1248	if (outlen < sizeof(outbuf))1249		return -EIO;1250	ped->fw_id = MCDI_DWORD(outbuf, MAE_MAC_ADDR_ALLOC_OUT_MAC_ID);1251	return 0;1252}1253 1254/**1255 * efx_mae_free_pedit_mac() - free pedit MAC address in HW.1256 * @efx:	NIC we're installing a pedit MAC address on1257 * @ped:	pedit MAC action that needs to be freed1258 *1259 * Frees @ped in HW, check that firmware did not free a different one and clears1260 * the id (which denotes the index of the entry in the MAC address table).1261 */1262void efx_mae_free_pedit_mac(struct efx_nic *efx,1263			    struct efx_tc_mac_pedit_action *ped)1264{1265	MCDI_DECLARE_BUF(outbuf, MC_CMD_MAE_MAC_ADDR_FREE_OUT_LEN(1));1266	MCDI_DECLARE_BUF(inbuf, MC_CMD_MAE_MAC_ADDR_FREE_IN_LEN(1));1267	size_t outlen;1268	int rc;1269 1270	MCDI_SET_DWORD(inbuf, MAE_MAC_ADDR_FREE_IN_MAC_ID, ped->fw_id);1271	rc = efx_mcdi_rpc(efx, MC_CMD_MAE_MAC_ADDR_FREE, inbuf,1272			  sizeof(inbuf), outbuf, sizeof(outbuf), &outlen);1273	if (rc || outlen < sizeof(outbuf))1274		return;1275	/* FW freed a different ID than we asked for, should also never happen.1276	 * Warn because it means we've now got a different idea to the FW of1277	 * what MAC addresses exist, which could cause mayhem later.1278	 */1279	if (WARN_ON(MCDI_DWORD(outbuf, MAE_MAC_ADDR_FREE_OUT_FREED_MAC_ID) != ped->fw_id))1280		return;1281	/* We're probably about to free @ped, but let's just make sure its1282	 * fw_id is blatted so that it won't look valid if it leaks out.1283	 */1284	ped->fw_id = MC_CMD_MAE_MAC_ADDR_ALLOC_OUT_MAC_ID_NULL;1285}1286 1287int efx_mae_alloc_action_set(struct efx_nic *efx, struct efx_tc_action_set *act)1288{1289	MCDI_DECLARE_BUF(outbuf, MC_CMD_MAE_ACTION_SET_ALLOC_OUT_LEN);1290	MCDI_DECLARE_BUF(inbuf, MC_CMD_MAE_ACTION_SET_ALLOC_IN_LEN);1291	size_t outlen;1292	int rc;1293 1294	MCDI_POPULATE_DWORD_5(inbuf, MAE_ACTION_SET_ALLOC_IN_FLAGS,1295			      MAE_ACTION_SET_ALLOC_IN_VLAN_PUSH, act->vlan_push,1296			      MAE_ACTION_SET_ALLOC_IN_VLAN_POP, act->vlan_pop,1297			      MAE_ACTION_SET_ALLOC_IN_DECAP, act->decap,1298			      MAE_ACTION_SET_ALLOC_IN_DO_NAT, act->do_nat,1299			      MAE_ACTION_SET_ALLOC_IN_DO_DECR_IP_TTL,1300			      act->do_ttl_dec);1301 1302	if (act->src_mac)1303		MCDI_SET_DWORD(inbuf, MAE_ACTION_SET_ALLOC_IN_SRC_MAC_ID,1304			       act->src_mac->fw_id);1305	else1306		MCDI_SET_DWORD(inbuf, MAE_ACTION_SET_ALLOC_IN_SRC_MAC_ID,1307			       MC_CMD_MAE_MAC_ADDR_ALLOC_OUT_MAC_ID_NULL);1308 1309	if (act->dst_mac)1310		MCDI_SET_DWORD(inbuf, MAE_ACTION_SET_ALLOC_IN_DST_MAC_ID,1311			       act->dst_mac->fw_id);1312	else1313		MCDI_SET_DWORD(inbuf, MAE_ACTION_SET_ALLOC_IN_DST_MAC_ID,1314			       MC_CMD_MAE_MAC_ADDR_ALLOC_OUT_MAC_ID_NULL);1315 1316	if (act->count && !WARN_ON(!act->count->cnt))1317		MCDI_SET_DWORD(inbuf, MAE_ACTION_SET_ALLOC_IN_COUNTER_ID,1318			       act->count->cnt->fw_id);1319	else1320		MCDI_SET_DWORD(inbuf, MAE_ACTION_SET_ALLOC_IN_COUNTER_ID,1321			       MC_CMD_MAE_COUNTER_ALLOC_OUT_COUNTER_ID_NULL);1322	MCDI_SET_DWORD(inbuf, MAE_ACTION_SET_ALLOC_IN_COUNTER_LIST_ID,1323		       MC_CMD_MAE_COUNTER_LIST_ALLOC_OUT_COUNTER_LIST_ID_NULL);1324	if (act->vlan_push) {1325		MCDI_SET_WORD_BE(inbuf, MAE_ACTION_SET_ALLOC_IN_VLAN0_TCI_BE,1326				 act->vlan_tci[0]);1327		MCDI_SET_WORD_BE(inbuf, MAE_ACTION_SET_ALLOC_IN_VLAN0_PROTO_BE,1328				 act->vlan_proto[0]);1329	}1330	if (act->vlan_push >= 2) {1331		MCDI_SET_WORD_BE(inbuf, MAE_ACTION_SET_ALLOC_IN_VLAN1_TCI_BE,1332				 act->vlan_tci[1]);1333		MCDI_SET_WORD_BE(inbuf, MAE_ACTION_SET_ALLOC_IN_VLAN1_PROTO_BE,1334				 act->vlan_proto[1]);1335	}1336	if (act->encap_md)1337		MCDI_SET_DWORD(inbuf, MAE_ACTION_SET_ALLOC_IN_ENCAP_HEADER_ID,1338			       act->encap_md->fw_id);1339	else1340		MCDI_SET_DWORD(inbuf, MAE_ACTION_SET_ALLOC_IN_ENCAP_HEADER_ID,1341			       MC_CMD_MAE_ENCAP_HEADER_ALLOC_OUT_ENCAP_HEADER_ID_NULL);1342	if (act->deliver)1343		MCDI_SET_DWORD(inbuf, MAE_ACTION_SET_ALLOC_IN_DELIVER,1344			       act->dest_mport);1345	BUILD_BUG_ON(MAE_MPORT_SELECTOR_NULL);1346	rc = efx_mcdi_rpc(efx, MC_CMD_MAE_ACTION_SET_ALLOC, inbuf, sizeof(inbuf),1347			  outbuf, sizeof(outbuf), &outlen);1348	if (rc)1349		return rc;1350	if (outlen < sizeof(outbuf))1351		return -EIO;1352	act->fw_id = MCDI_DWORD(outbuf, MAE_ACTION_SET_ALLOC_OUT_AS_ID);1353	/* We rely on the high bit of AS IDs always being clear.1354	 * The firmware API guarantees this, but let's check it ourselves.1355	 */1356	if (WARN_ON_ONCE(efx_mae_asl_id(act->fw_id))) {1357		efx_mae_free_action_set(efx, act->fw_id);1358		return -EIO;1359	}1360	return 0;1361}1362 1363int efx_mae_free_action_set(struct efx_nic *efx, u32 fw_id)1364{1365	MCDI_DECLARE_BUF(outbuf, MC_CMD_MAE_ACTION_SET_FREE_OUT_LEN(1));1366	MCDI_DECLARE_BUF(inbuf, MC_CMD_MAE_ACTION_SET_FREE_IN_LEN(1));1367	size_t outlen;1368	int rc;1369 1370	MCDI_SET_DWORD(inbuf, MAE_ACTION_SET_FREE_IN_AS_ID, fw_id);1371	rc = efx_mcdi_rpc(efx, MC_CMD_MAE_ACTION_SET_FREE, inbuf, sizeof(inbuf),1372			  outbuf, sizeof(outbuf), &outlen);1373	if (rc)1374		return rc;1375	if (outlen < sizeof(outbuf))1376		return -EIO;1377	/* FW freed a different ID than we asked for, should never happen.1378	 * Warn because it means we've now got a different idea to the FW of1379	 * what action-sets exist, which could cause mayhem later.1380	 */1381	if (WARN_ON(MCDI_DWORD(outbuf, MAE_ACTION_SET_FREE_OUT_FREED_AS_ID) != fw_id))1382		return -EIO;1383	return 0;1384}1385 1386int efx_mae_alloc_action_set_list(struct efx_nic *efx,1387				  struct efx_tc_action_set_list *acts)1388{1389	MCDI_DECLARE_BUF(outbuf, MC_CMD_MAE_ACTION_SET_LIST_ALLOC_OUT_LEN);1390	struct efx_tc_action_set *act;1391	size_t inlen, outlen, i = 0;1392	efx_dword_t *inbuf;1393	int rc;1394 1395	list_for_each_entry(act, &acts->list, list)1396		i++;1397	if (i == 0)1398		return -EINVAL;1399	if (i == 1) {1400		/* Don't wrap an ASL around a single AS, just use the AS_ID1401		 * directly.  ASLs are a more limited resource.1402		 */1403		act = list_first_entry(&acts->list, struct efx_tc_action_set, list);1404		acts->fw_id = act->fw_id;1405		return 0;1406	}1407	if (i > MC_CMD_MAE_ACTION_SET_LIST_ALLOC_IN_AS_IDS_MAXNUM_MCDI2)1408		return -EOPNOTSUPP; /* Too many actions */1409	inlen = MC_CMD_MAE_ACTION_SET_LIST_ALLOC_IN_LEN(i);1410	inbuf = kzalloc(inlen, GFP_KERNEL);1411	if (!inbuf)1412		return -ENOMEM;1413	i = 0;1414	list_for_each_entry(act, &acts->list, list) {1415		MCDI_SET_ARRAY_DWORD(inbuf, MAE_ACTION_SET_LIST_ALLOC_IN_AS_IDS,1416				     i, act->fw_id);1417		i++;1418	}1419	MCDI_SET_DWORD(inbuf, MAE_ACTION_SET_LIST_ALLOC_IN_COUNT, i);1420	rc = efx_mcdi_rpc(efx, MC_CMD_MAE_ACTION_SET_LIST_ALLOC, inbuf, inlen,1421			  outbuf, sizeof(outbuf), &outlen);1422	if (rc)1423		goto out_free;1424	if (outlen < sizeof(outbuf)) {1425		rc = -EIO;1426		goto out_free;1427	}1428	acts->fw_id = MCDI_DWORD(outbuf, MAE_ACTION_SET_LIST_ALLOC_OUT_ASL_ID);1429	/* We rely on the high bit of ASL IDs always being set.1430	 * The firmware API guarantees this, but let's check it ourselves.1431	 */1432	if (WARN_ON_ONCE(!efx_mae_asl_id(acts->fw_id))) {1433		efx_mae_free_action_set_list(efx, acts);1434		rc = -EIO;1435	}1436out_free:1437	kfree(inbuf);1438	return rc;1439}1440 1441int efx_mae_free_action_set_list(struct efx_nic *efx,1442				 struct efx_tc_action_set_list *acts)1443{1444	MCDI_DECLARE_BUF(outbuf, MC_CMD_MAE_ACTION_SET_LIST_FREE_OUT_LEN(1));1445	MCDI_DECLARE_BUF(inbuf, MC_CMD_MAE_ACTION_SET_LIST_FREE_IN_LEN(1));1446	size_t outlen;1447	int rc;1448 1449	/* If this is just an AS_ID with no ASL wrapper, then there is1450	 * nothing for us to free.  (The AS will be freed later.)1451	 */1452	if (efx_mae_asl_id(acts->fw_id)) {1453		MCDI_SET_DWORD(inbuf, MAE_ACTION_SET_LIST_FREE_IN_ASL_ID,1454			       acts->fw_id);1455		rc = efx_mcdi_rpc(efx, MC_CMD_MAE_ACTION_SET_LIST_FREE, inbuf,1456				  sizeof(inbuf), outbuf, sizeof(outbuf), &outlen);1457		if (rc)1458			return rc;1459		if (outlen < sizeof(outbuf))1460			return -EIO;1461		/* FW freed a different ID than we asked for, should never happen.1462		 * Warn because it means we've now got a different idea to the FW of1463		 * what action-set-lists exist, which could cause mayhem later.1464		 */1465		if (WARN_ON(MCDI_DWORD(outbuf, MAE_ACTION_SET_LIST_FREE_OUT_FREED_ASL_ID) != acts->fw_id))1466			return -EIO;1467	}1468	/* We're probably about to free @acts, but let's just make sure its1469	 * fw_id is blatted so that it won't look valid if it leaks out.1470	 */1471	acts->fw_id = MC_CMD_MAE_ACTION_SET_LIST_ALLOC_OUT_ACTION_SET_LIST_ID_NULL;1472	return 0;1473}1474 1475int efx_mae_register_encap_match(struct efx_nic *efx,1476				 struct efx_tc_encap_match *encap)1477{1478	MCDI_DECLARE_BUF(inbuf, MC_CMD_MAE_OUTER_RULE_INSERT_IN_LEN(MAE_ENC_FIELD_PAIRS_LEN));1479	MCDI_DECLARE_BUF(outbuf, MC_CMD_MAE_OUTER_RULE_INSERT_OUT_LEN);1480	MCDI_DECLARE_STRUCT_PTR(match_crit);1481	size_t outlen;1482	int rc;1483 1484	rc = efx_mae_encap_type_to_mae_type(encap->tun_type);1485	if (rc < 0)1486		return rc;1487	match_crit = _MCDI_DWORD(inbuf, MAE_OUTER_RULE_INSERT_IN_FIELD_MATCH_CRITERIA);1488	/* The struct contains IP src and dst, and udp dport.1489	 * So we actually need to filter on IP src and dst, L4 dport, and1490	 * ipproto == udp.1491	 */1492	MCDI_SET_DWORD(inbuf, MAE_OUTER_RULE_INSERT_IN_ENCAP_TYPE, rc);1493#ifdef CONFIG_IPV61494	if (encap->src_ip | encap->dst_ip) {1495#endif1496		MCDI_STRUCT_SET_DWORD_BE(match_crit, MAE_ENC_FIELD_PAIRS_ENC_SRC_IP4_BE,1497					 encap->src_ip);1498		MCDI_STRUCT_SET_DWORD_BE(match_crit, MAE_ENC_FIELD_PAIRS_ENC_SRC_IP4_BE_MASK,1499					 ~(__be32)0);1500		MCDI_STRUCT_SET_DWORD_BE(match_crit, MAE_ENC_FIELD_PAIRS_ENC_DST_IP4_BE,1501					 encap->dst_ip);1502		MCDI_STRUCT_SET_DWORD_BE(match_crit, MAE_ENC_FIELD_PAIRS_ENC_DST_IP4_BE_MASK,1503					 ~(__be32)0);1504		MCDI_STRUCT_SET_WORD_BE(match_crit, MAE_ENC_FIELD_PAIRS_ENC_ETHER_TYPE_BE,1505					htons(ETH_P_IP));1506#ifdef CONFIG_IPV61507	} else {1508		memcpy(MCDI_STRUCT_PTR(match_crit, MAE_ENC_FIELD_PAIRS_ENC_SRC_IP6_BE),1509		       &encap->src_ip6, sizeof(encap->src_ip6));1510		memset(MCDI_STRUCT_PTR(match_crit, MAE_ENC_FIELD_PAIRS_ENC_SRC_IP6_BE_MASK),1511		       0xff, sizeof(encap->src_ip6));1512		memcpy(MCDI_STRUCT_PTR(match_crit, MAE_ENC_FIELD_PAIRS_ENC_DST_IP6_BE),1513		       &encap->dst_ip6, sizeof(encap->dst_ip6));1514		memset(MCDI_STRUCT_PTR(match_crit, MAE_ENC_FIELD_PAIRS_ENC_DST_IP6_BE_MASK),1515		       0xff, sizeof(encap->dst_ip6));1516		MCDI_STRUCT_SET_WORD_BE(match_crit, MAE_ENC_FIELD_PAIRS_ENC_ETHER_TYPE_BE,1517					htons(ETH_P_IPV6));1518	}1519#endif1520	MCDI_STRUCT_SET_WORD_BE(match_crit, MAE_ENC_FIELD_PAIRS_ENC_ETHER_TYPE_BE_MASK,1521				~(__be16)0);1522	MCDI_STRUCT_SET_WORD_BE(match_crit, MAE_ENC_FIELD_PAIRS_ENC_L4_DPORT_BE,1523				encap->udp_dport);1524	MCDI_STRUCT_SET_WORD_BE(match_crit, MAE_ENC_FIELD_PAIRS_ENC_L4_DPORT_BE_MASK,1525				~(__be16)0);1526	MCDI_STRUCT_SET_WORD_BE(match_crit, MAE_ENC_FIELD_PAIRS_ENC_L4_DPORT_BE,1527				encap->udp_sport);1528	MCDI_STRUCT_SET_WORD_BE(match_crit, MAE_ENC_FIELD_PAIRS_ENC_L4_DPORT_BE_MASK,1529				encap->udp_sport_mask);1530	MCDI_STRUCT_SET_BYTE(match_crit, MAE_ENC_FIELD_PAIRS_ENC_IP_PROTO, IPPROTO_UDP);1531	MCDI_STRUCT_SET_BYTE(match_crit, MAE_ENC_FIELD_PAIRS_ENC_IP_PROTO_MASK, ~0);1532	MCDI_STRUCT_SET_BYTE(match_crit, MAE_ENC_FIELD_PAIRS_ENC_IP_TOS,1533			     encap->ip_tos);1534	MCDI_STRUCT_SET_BYTE(match_crit, MAE_ENC_FIELD_PAIRS_ENC_IP_TOS_MASK,1535			     encap->ip_tos_mask);1536	rc = efx_mcdi_rpc(efx, MC_CMD_MAE_OUTER_RULE_INSERT, inbuf,1537			  sizeof(inbuf), outbuf, sizeof(outbuf), &outlen);1538	if (rc)1539		return rc;1540	if (outlen < sizeof(outbuf))1541		return -EIO;1542	encap->fw_id = MCDI_DWORD(outbuf, MAE_OUTER_RULE_INSERT_OUT_OR_ID);1543	return 0;1544}1545 1546int efx_mae_unregister_encap_match(struct efx_nic *efx,1547				   struct efx_tc_encap_match *encap)1548{1549	MCDI_DECLARE_BUF(outbuf, MC_CMD_MAE_OUTER_RULE_REMOVE_OUT_LEN(1));1550	MCDI_DECLARE_BUF(inbuf, MC_CMD_MAE_OUTER_RULE_REMOVE_IN_LEN(1));1551	size_t outlen;1552	int rc;1553 1554	MCDI_SET_DWORD(inbuf, MAE_OUTER_RULE_REMOVE_IN_OR_ID, encap->fw_id);1555	rc = efx_mcdi_rpc(efx, MC_CMD_MAE_OUTER_RULE_REMOVE, inbuf,1556			  sizeof(inbuf), outbuf, sizeof(outbuf), &outlen);1557	if (rc)1558		return rc;1559	if (outlen < sizeof(outbuf))1560		return -EIO;1561	/* FW freed a different ID than we asked for, should also never happen.1562	 * Warn because it means we've now got a different idea to the FW of1563	 * what encap_mds exist, which could cause mayhem later.1564	 */1565	if (WARN_ON(MCDI_DWORD(outbuf, MAE_OUTER_RULE_REMOVE_OUT_REMOVED_OR_ID) != encap->fw_id))1566		return -EIO;1567	/* We're probably about to free @encap, but let's just make sure its1568	 * fw_id is blatted so that it won't look valid if it leaks out.1569	 */1570	encap->fw_id = MC_CMD_MAE_OUTER_RULE_INSERT_OUT_OUTER_RULE_ID_NULL;1571	return 0;1572}1573 1574static int efx_mae_populate_lhs_match_criteria(MCDI_DECLARE_STRUCT_PTR(match_crit),1575					       const struct efx_tc_match *match)1576{1577	if (match->mask.ingress_port) {1578		if (~match->mask.ingress_port)1579			return -EOPNOTSUPP;1580		MCDI_STRUCT_SET_DWORD(match_crit,1581				      MAE_ENC_FIELD_PAIRS_INGRESS_MPORT_SELECTOR,1582				      match->value.ingress_port);1583	}1584	MCDI_STRUCT_SET_DWORD(match_crit, MAE_ENC_FIELD_PAIRS_INGRESS_MPORT_SELECTOR_MASK,1585			      match->mask.ingress_port);1586	MCDI_STRUCT_SET_WORD_BE(match_crit, MAE_ENC_FIELD_PAIRS_ENC_ETHER_TYPE_BE,1587				match->value.eth_proto);1588	MCDI_STRUCT_SET_WORD_BE(match_crit, MAE_ENC_FIELD_PAIRS_ENC_ETHER_TYPE_BE_MASK,1589				match->mask.eth_proto);1590	MCDI_STRUCT_SET_WORD_BE(match_crit, MAE_ENC_FIELD_PAIRS_ENC_VLAN0_TCI_BE,1591				match->value.vlan_tci[0]);1592	MCDI_STRUCT_SET_WORD_BE(match_crit, MAE_ENC_FIELD_PAIRS_ENC_VLAN0_TCI_BE_MASK,1593				match->mask.vlan_tci[0]);1594	MCDI_STRUCT_SET_WORD_BE(match_crit, MAE_ENC_FIELD_PAIRS_ENC_VLAN0_PROTO_BE,1595				match->value.vlan_proto[0]);1596	MCDI_STRUCT_SET_WORD_BE(match_crit, MAE_ENC_FIELD_PAIRS_ENC_VLAN0_PROTO_BE_MASK,1597				match->mask.vlan_proto[0]);1598	MCDI_STRUCT_SET_WORD_BE(match_crit, MAE_ENC_FIELD_PAIRS_ENC_VLAN1_TCI_BE,1599				match->value.vlan_tci[1]);1600	MCDI_STRUCT_SET_WORD_BE(match_crit, MAE_ENC_FIELD_PAIRS_ENC_VLAN1_TCI_BE_MASK,1601				match->mask.vlan_tci[1]);1602	MCDI_STRUCT_SET_WORD_BE(match_crit, MAE_ENC_FIELD_PAIRS_ENC_VLAN1_PROTO_BE,1603				match->value.vlan_proto[1]);1604	MCDI_STRUCT_SET_WORD_BE(match_crit, MAE_ENC_FIELD_PAIRS_ENC_VLAN1_PROTO_BE_MASK,1605				match->mask.vlan_proto[1]);1606	memcpy(MCDI_STRUCT_PTR(match_crit, MAE_ENC_FIELD_PAIRS_ENC_ETH_SADDR_BE),1607	       match->value.eth_saddr, ETH_ALEN);1608	memcpy(MCDI_STRUCT_PTR(match_crit, MAE_ENC_FIELD_PAIRS_ENC_ETH_SADDR_BE_MASK),1609	       match->mask.eth_saddr, ETH_ALEN);1610	memcpy(MCDI_STRUCT_PTR(match_crit, MAE_ENC_FIELD_PAIRS_ENC_ETH_DADDR_BE),1611	       match->value.eth_daddr, ETH_ALEN);1612	memcpy(MCDI_STRUCT_PTR(match_crit, MAE_ENC_FIELD_PAIRS_ENC_ETH_DADDR_BE_MASK),1613	       match->mask.eth_daddr, ETH_ALEN);1614	MCDI_STRUCT_SET_BYTE(match_crit, MAE_ENC_FIELD_PAIRS_ENC_IP_PROTO,1615			     match->value.ip_proto);1616	MCDI_STRUCT_SET_BYTE(match_crit, MAE_ENC_FIELD_PAIRS_ENC_IP_PROTO_MASK,1617			     match->mask.ip_proto);1618	MCDI_STRUCT_SET_BYTE(match_crit, MAE_ENC_FIELD_PAIRS_ENC_IP_TOS,1619			     match->value.ip_tos);1620	MCDI_STRUCT_SET_BYTE(match_crit, MAE_ENC_FIELD_PAIRS_ENC_IP_TOS_MASK,1621			     match->mask.ip_tos);1622	MCDI_STRUCT_SET_BYTE(match_crit, MAE_ENC_FIELD_PAIRS_ENC_IP_TTL,1623			     match->value.ip_ttl);1624	MCDI_STRUCT_SET_BYTE(match_crit, MAE_ENC_FIELD_PAIRS_ENC_IP_TTL_MASK,1625			     match->mask.ip_ttl);1626	MCDI_STRUCT_POPULATE_BYTE_1(match_crit,1627				    MAE_ENC_FIELD_PAIRS_ENC_VLAN_FLAGS,1628				    MAE_ENC_FIELD_PAIRS_ENC_IP_FRAG,1629				    match->value.ip_frag);1630	MCDI_STRUCT_POPULATE_BYTE_1(match_crit,1631				    MAE_ENC_FIELD_PAIRS_ENC_VLAN_FLAGS_MASK,1632				    MAE_ENC_FIELD_PAIRS_ENC_IP_FRAG_MASK,1633				    match->mask.ip_frag);1634	MCDI_STRUCT_SET_DWORD_BE(match_crit, MAE_ENC_FIELD_PAIRS_ENC_SRC_IP4_BE,1635				 match->value.src_ip);1636	MCDI_STRUCT_SET_DWORD_BE(match_crit, MAE_ENC_FIELD_PAIRS_ENC_SRC_IP4_BE_MASK,1637				 match->mask.src_ip);1638	MCDI_STRUCT_SET_DWORD_BE(match_crit, MAE_ENC_FIELD_PAIRS_ENC_DST_IP4_BE,1639				 match->value.dst_ip);1640	MCDI_STRUCT_SET_DWORD_BE(match_crit, MAE_ENC_FIELD_PAIRS_ENC_DST_IP4_BE_MASK,1641				 match->mask.dst_ip);1642#ifdef CONFIG_IPV61643	memcpy(MCDI_STRUCT_PTR(match_crit, MAE_ENC_FIELD_PAIRS_ENC_SRC_IP6_BE),1644	       &match->value.src_ip6, sizeof(struct in6_addr));1645	memcpy(MCDI_STRUCT_PTR(match_crit, MAE_ENC_FIELD_PAIRS_ENC_SRC_IP6_BE_MASK),1646	       &match->mask.src_ip6, sizeof(struct in6_addr));1647	memcpy(MCDI_STRUCT_PTR(match_crit, MAE_ENC_FIELD_PAIRS_ENC_DST_IP6_BE),1648	       &match->value.dst_ip6, sizeof(struct in6_addr));1649	memcpy(MCDI_STRUCT_PTR(match_crit, MAE_ENC_FIELD_PAIRS_ENC_DST_IP6_BE_MASK),1650	       &match->mask.dst_ip6, sizeof(struct in6_addr));1651#endif1652	MCDI_STRUCT_SET_WORD_BE(match_crit, MAE_ENC_FIELD_PAIRS_ENC_L4_SPORT_BE,1653				match->value.l4_sport);1654	MCDI_STRUCT_SET_WORD_BE(match_crit, MAE_ENC_FIELD_PAIRS_ENC_L4_SPORT_BE_MASK,1655				match->mask.l4_sport);1656	MCDI_STRUCT_SET_WORD_BE(match_crit, MAE_ENC_FIELD_PAIRS_ENC_L4_DPORT_BE,1657				match->value.l4_dport);1658	MCDI_STRUCT_SET_WORD_BE(match_crit, MAE_ENC_FIELD_PAIRS_ENC_L4_DPORT_BE_MASK,1659				match->mask.l4_dport);1660	/* No enc-keys in LHS rules.  Caps check should have caught this; any1661	 * enc-keys from an fLHS should have been translated to regular keys1662	 * and any EM should be a pseudo (we're an OR so can't have a direct1663	 * EM with another OR).1664	 */1665	if (WARN_ON_ONCE(match->encap && !match->encap->type))1666		return -EOPNOTSUPP;1667	if (WARN_ON_ONCE(match->mask.enc_src_ip))1668		return -EOPNOTSUPP;1669	if (WARN_ON_ONCE(match->mask.enc_dst_ip))1670		return -EOPNOTSUPP;1671#ifdef CONFIG_IPV61672	if (WARN_ON_ONCE(!ipv6_addr_any(&match->mask.enc_src_ip6)))1673		return -EOPNOTSUPP;1674	if (WARN_ON_ONCE(!ipv6_addr_any(&match->mask.enc_dst_ip6)))1675		return -EOPNOTSUPP;1676#endif1677	if (WARN_ON_ONCE(match->mask.enc_ip_tos))1678		return -EOPNOTSUPP;1679	if (WARN_ON_ONCE(match->mask.enc_ip_ttl))1680		return -EOPNOTSUPP;1681	if (WARN_ON_ONCE(match->mask.enc_sport))1682		return -EOPNOTSUPP;1683	if (WARN_ON_ONCE(match->mask.enc_dport))1684		return -EOPNOTSUPP;1685	if (WARN_ON_ONCE(match->mask.enc_keyid))1686		return -EOPNOTSUPP;1687	return 0;1688}1689 1690static int efx_mae_insert_lhs_outer_rule(struct efx_nic *efx,1691					 struct efx_tc_lhs_rule *rule, u32 prio)1692{1693	MCDI_DECLARE_BUF(inbuf, MC_CMD_MAE_OUTER_RULE_INSERT_IN_LEN(MAE_ENC_FIELD_PAIRS_LEN));1694	MCDI_DECLARE_BUF(outbuf, MC_CMD_MAE_OUTER_RULE_INSERT_OUT_LEN);1695	MCDI_DECLARE_STRUCT_PTR(match_crit);1696	const struct efx_tc_lhs_action *act;1697	size_t outlen;1698	int rc;1699 1700	MCDI_SET_DWORD(inbuf, MAE_OUTER_RULE_INSERT_IN_PRIO, prio);1701	/* match */1702	match_crit = _MCDI_DWORD(inbuf, MAE_OUTER_RULE_INSERT_IN_FIELD_MATCH_CRITERIA);1703	rc = efx_mae_populate_lhs_match_criteria(match_crit, &rule->match);1704	if (rc)1705		return rc;1706 1707	/* action */1708	act = &rule->lhs_act;1709	rc = efx_mae_encap_type_to_mae_type(act->tun_type);1710	if (rc < 0)1711		return rc;1712	MCDI_SET_DWORD(inbuf, MAE_OUTER_RULE_INSERT_IN_ENCAP_TYPE, rc);1713	/* We always inhibit CT lookup on TCP_INTERESTING_FLAGS, since the1714	 * SW path needs to process the packet to update the conntrack tables1715	 * on connection establishment (SYN) or termination (FIN, RST).1716	 */1717	MCDI_POPULATE_DWORD_6(inbuf, MAE_OUTER_RULE_INSERT_IN_LOOKUP_CONTROL,1718			      MAE_OUTER_RULE_INSERT_IN_DO_CT, !!act->zone,1719			      MAE_OUTER_RULE_INSERT_IN_CT_TCP_FLAGS_INHIBIT, 1,1720			      MAE_OUTER_RULE_INSERT_IN_CT_DOMAIN,1721			      act->zone ? act->zone->zone : 0,1722			      MAE_OUTER_RULE_INSERT_IN_CT_VNI_MODE,1723			      MAE_CT_VNI_MODE_ZERO,1724			      MAE_OUTER_RULE_INSERT_IN_DO_COUNT, !!act->count,1725			      MAE_OUTER_RULE_INSERT_IN_RECIRC_ID,1726			      act->rid ? act->rid->fw_id : 0);1727	if (act->count)1728		MCDI_SET_DWORD(inbuf, MAE_OUTER_RULE_INSERT_IN_COUNTER_ID,1729			       act->count->cnt->fw_id);1730	rc = efx_mcdi_rpc(efx, MC_CMD_MAE_OUTER_RULE_INSERT, inbuf,1731			  sizeof(inbuf), outbuf, sizeof(outbuf), &outlen);1732	if (rc)1733		return rc;1734	if (outlen < sizeof(outbuf))1735		return -EIO;1736	rule->fw_id = MCDI_DWORD(outbuf, MAE_OUTER_RULE_INSERT_OUT_OR_ID);1737	return 0;1738}1739 1740static int efx_mae_populate_match_criteria(MCDI_DECLARE_STRUCT_PTR(match_crit),1741					   const struct efx_tc_match *match);1742 1743static int efx_mae_insert_lhs_action_rule(struct efx_nic *efx,1744					  struct efx_tc_lhs_rule *rule,1745					  u32 prio)1746{1747	MCDI_DECLARE_BUF(inbuf, MC_CMD_MAE_ACTION_RULE_INSERT_IN_LEN(MAE_FIELD_MASK_VALUE_PAIRS_V2_LEN));1748	MCDI_DECLARE_BUF(outbuf, MC_CMD_MAE_ACTION_RULE_INSERT_OUT_LEN);1749	struct efx_tc_lhs_action *act = &rule->lhs_act;1750	MCDI_DECLARE_STRUCT_PTR(match_crit);1751	MCDI_DECLARE_STRUCT_PTR(response);1752	size_t outlen;1753	int rc;1754 1755	match_crit = _MCDI_DWORD(inbuf, MAE_ACTION_RULE_INSERT_IN_MATCH_CRITERIA);1756	response = _MCDI_DWORD(inbuf, MAE_ACTION_RULE_INSERT_IN_RESPONSE);1757	MCDI_STRUCT_SET_DWORD(response, MAE_ACTION_RULE_RESPONSE_ASL_ID,1758			      MC_CMD_MAE_ACTION_SET_LIST_ALLOC_OUT_ACTION_SET_LIST_ID_NULL);1759	MCDI_STRUCT_SET_DWORD(response, MAE_ACTION_RULE_RESPONSE_AS_ID,1760			      MC_CMD_MAE_ACTION_SET_ALLOC_OUT_ACTION_SET_ID_NULL);1761	EFX_POPULATE_DWORD_5(*_MCDI_STRUCT_DWORD(response, MAE_ACTION_RULE_RESPONSE_LOOKUP_CONTROL),1762			     MAE_ACTION_RULE_RESPONSE_DO_CT, !!act->zone,1763			     MAE_ACTION_RULE_RESPONSE_DO_RECIRC,1764			     act->rid && !act->zone,1765			     MAE_ACTION_RULE_RESPONSE_CT_VNI_MODE,1766			     MAE_CT_VNI_MODE_ZERO,1767			     MAE_ACTION_RULE_RESPONSE_RECIRC_ID,1768			     act->rid ? act->rid->fw_id : 0,1769			     MAE_ACTION_RULE_RESPONSE_CT_DOMAIN,1770			     act->zone ? act->zone->zone : 0);1771	MCDI_STRUCT_SET_DWORD(response, MAE_ACTION_RULE_RESPONSE_COUNTER_ID,1772			      act->count ? act->count->cnt->fw_id :1773			      MC_CMD_MAE_COUNTER_ALLOC_OUT_COUNTER_ID_NULL);1774	MCDI_SET_DWORD(inbuf, MAE_ACTION_RULE_INSERT_IN_PRIO, prio);1775	rc = efx_mae_populate_match_criteria(match_crit, &rule->match);1776	if (rc)1777		return rc;1778 1779	rc = efx_mcdi_rpc(efx, MC_CMD_MAE_ACTION_RULE_INSERT, inbuf, sizeof(inbuf),1780			  outbuf, sizeof(outbuf), &outlen);1781	if (rc)1782		return rc;1783	if (outlen < sizeof(outbuf))1784		return -EIO;1785	rule->fw_id = MCDI_DWORD(outbuf, MAE_ACTION_RULE_INSERT_OUT_AR_ID);1786	return 0;1787}1788 1789int efx_mae_insert_lhs_rule(struct efx_nic *efx, struct efx_tc_lhs_rule *rule,1790			    u32 prio)1791{1792	if (rule->is_ar)1793		return efx_mae_insert_lhs_action_rule(efx, rule, prio);1794	return efx_mae_insert_lhs_outer_rule(efx, rule, prio);1795}1796 1797static int efx_mae_remove_lhs_outer_rule(struct efx_nic *efx,1798					 struct efx_tc_lhs_rule *rule)1799{1800	MCDI_DECLARE_BUF(outbuf, MC_CMD_MAE_OUTER_RULE_REMOVE_OUT_LEN(1));1801	MCDI_DECLARE_BUF(inbuf, MC_CMD_MAE_OUTER_RULE_REMOVE_IN_LEN(1));1802	size_t outlen;1803	int rc;1804 1805	MCDI_SET_DWORD(inbuf, MAE_OUTER_RULE_REMOVE_IN_OR_ID, rule->fw_id);1806	rc = efx_mcdi_rpc(efx, MC_CMD_MAE_OUTER_RULE_REMOVE, inbuf,1807			  sizeof(inbuf), outbuf, sizeof(outbuf), &outlen);1808	if (rc)1809		return rc;1810	if (outlen < sizeof(outbuf))1811		return -EIO;1812	/* FW freed a different ID than we asked for, should also never happen.1813	 * Warn because it means we've now got a different idea to the FW of1814	 * what encap_mds exist, which could cause mayhem later.1815	 */1816	if (WARN_ON(MCDI_DWORD(outbuf, MAE_OUTER_RULE_REMOVE_OUT_REMOVED_OR_ID) != rule->fw_id))1817		return -EIO;1818	/* We're probably about to free @rule, but let's just make sure its1819	 * fw_id is blatted so that it won't look valid if it leaks out.1820	 */1821	rule->fw_id = MC_CMD_MAE_OUTER_RULE_INSERT_OUT_OUTER_RULE_ID_NULL;1822	return 0;1823}1824 1825int efx_mae_remove_lhs_rule(struct efx_nic *efx, struct efx_tc_lhs_rule *rule)1826{1827	if (rule->is_ar)1828		return efx_mae_delete_rule(efx, rule->fw_id);1829	return efx_mae_remove_lhs_outer_rule(efx, rule);1830}1831 1832/* Populating is done by taking each byte of @value in turn and storing1833 * it in the appropriate bits of @row.  @value must be big-endian; we1834 * convert it to little-endianness as we go.1835 */1836static int efx_mae_table_populate(struct efx_tc_table_field_fmt field,1837				  __le32 *row, size_t row_bits,1838				  void *value, size_t value_size)1839{1840	unsigned int i;1841 1842	/* For now only scheme 0 is supported for any field, so we check here1843	 * (rather than, say, in calling code, which knows the semantics and1844	 * could in principle encode for other schemes).1845	 */1846	if (field.scheme)1847		return -EOPNOTSUPP;1848	if (DIV_ROUND_UP(field.width, 8) != value_size)1849		return -EINVAL;1850	if (field.lbn + field.width > row_bits)1851		return -EINVAL;1852	for (i = 0; i < value_size; i++) {1853		unsigned int bn = field.lbn + i * 8;1854		unsigned int wn = bn / 32;1855		u64 v;1856 1857		v = ((u8 *)value)[value_size - i - 1];1858		v <<= (bn % 32);1859		row[wn] |= cpu_to_le32(v & 0xffffffff);1860		if (wn * 32 < row_bits)1861			row[wn + 1] |= cpu_to_le32(v >> 32);1862	}1863	return 0;1864}1865 1866static int efx_mae_table_populate_bool(struct efx_tc_table_field_fmt field,1867				       __le32 *row, size_t row_bits, bool value)1868{1869	u8 v = value ? 1 : 0;1870 1871	if (field.width != 1)1872		return -EINVAL;1873	return efx_mae_table_populate(field, row, row_bits, &v, 1);1874}1875 1876static int efx_mae_table_populate_ipv4(struct efx_tc_table_field_fmt field,1877				       __le32 *row, size_t row_bits, __be32 value)1878{1879	/* IPv4 is placed in the first 4 bytes of an IPv6-sized field */1880	struct in6_addr v = {};1881 1882	if (field.width != 128)1883		return -EINVAL;1884	v.s6_addr32[0] = value;1885	return efx_mae_table_populate(field, row, row_bits, &v, sizeof(v));1886}1887 1888static int efx_mae_table_populate_u24(struct efx_tc_table_field_fmt field,1889				      __le32 *row, size_t row_bits, u32 value)1890{1891	__be32 v = cpu_to_be32(value);1892 1893	/* We adjust value_size here since just 3 bytes will be copied, and1894	 * the pointer to the value is set discarding the first byte which is1895	 * the most significant byte for a big-endian 4-bytes value.1896	 */1897	return efx_mae_table_populate(field, row, row_bits, ((void *)&v) + 1,1898				      sizeof(v) - 1);1899}1900 1901#define _TABLE_POPULATE(dst, dw, _field, _value) ({	\1902	typeof(_value) _v = _value;			\1903							\1904	(_field.width == sizeof(_value) * 8) ?		\1905	 efx_mae_table_populate(_field, dst, dw, &_v,	\1906				sizeof(_v)) : -EINVAL;	\1907})1908#define TABLE_POPULATE_KEY_IPV4(dst, _table, _field, _value)		       \1909	efx_mae_table_populate_ipv4(efx->tc->meta_##_table.desc.keys	       \1910				    [efx->tc->meta_##_table.keys._field##_idx],\1911				    dst, efx->tc->meta_##_table.desc.key_width,\1912				    _value)1913#define TABLE_POPULATE_KEY(dst, _table, _field, _value)			\1914	_TABLE_POPULATE(dst, efx->tc->meta_##_table.desc.key_width,	\1915			efx->tc->meta_##_table.desc.keys		\1916			[efx->tc->meta_##_table.keys._field##_idx],	\1917			_value)1918 1919#define TABLE_POPULATE_RESP_BOOL(dst, _table, _field, _value)			\1920	efx_mae_table_populate_bool(efx->tc->meta_##_table.desc.resps		\1921				    [efx->tc->meta_##_table.resps._field##_idx],\1922				    dst, efx->tc->meta_##_table.desc.resp_width,\1923				    _value)1924#define TABLE_POPULATE_RESP(dst, _table, _field, _value)		\1925	_TABLE_POPULATE(dst, efx->tc->meta_##_table.desc.resp_width,	\1926			efx->tc->meta_##_table.desc.resps		\1927			[efx->tc->meta_##_table.resps._field##_idx],	\1928			_value)1929 1930#define TABLE_POPULATE_RESP_U24(dst, _table, _field, _value)		       \1931	efx_mae_table_populate_u24(efx->tc->meta_##_table.desc.resps	       \1932				   [efx->tc->meta_##_table.resps._field##_idx],\1933				   dst, efx->tc->meta_##_table.desc.resp_width,\1934				   _value)1935 1936static int efx_mae_populate_ct_key(struct efx_nic *efx, __le32 *key, size_t kw,1937				   struct efx_tc_ct_entry *conn)1938{1939	bool ipv6 = conn->eth_proto == htons(ETH_P_IPV6);1940	int rc;1941 1942	rc = TABLE_POPULATE_KEY(key, ct, eth_proto, conn->eth_proto);1943	if (rc)1944		return rc;1945	rc = TABLE_POPULATE_KEY(key, ct, ip_proto, conn->ip_proto);1946	if (rc)1947		return rc;1948	if (ipv6)1949		rc = TABLE_POPULATE_KEY(key, ct, src_ip, conn->src_ip6);1950	else1951		rc = TABLE_POPULATE_KEY_IPV4(key, ct, src_ip, conn->src_ip);1952	if (rc)1953		return rc;1954	if (ipv6)1955		rc = TABLE_POPULATE_KEY(key, ct, dst_ip, conn->dst_ip6);1956	else1957		rc = TABLE_POPULATE_KEY_IPV4(key, ct, dst_ip, conn->dst_ip);1958	if (rc)1959		return rc;1960	rc = TABLE_POPULATE_KEY(key, ct, l4_sport, conn->l4_sport);1961	if (rc)1962		return rc;1963	rc = TABLE_POPULATE_KEY(key, ct, l4_dport, conn->l4_dport);1964	if (rc)1965		return rc;1966	return TABLE_POPULATE_KEY(key, ct, zone, cpu_to_be16(conn->zone->zone));1967}1968 1969int efx_mae_insert_ct(struct efx_nic *efx, struct efx_tc_ct_entry *conn)1970{1971	bool ipv6 = conn->eth_proto == htons(ETH_P_IPV6);1972	__le32 *key = NULL, *resp = NULL;1973	size_t inlen, kw, rw;1974	efx_dword_t *inbuf;1975	int rc = -ENOMEM;1976 1977	/* Check table access is supported */1978	if (!efx->tc->meta_ct.hooked)1979		return -EOPNOTSUPP;1980 1981	/* key/resp widths are in bits; convert to dwords for IN_LEN */1982	kw = DIV_ROUND_UP(efx->tc->meta_ct.desc.key_width, 32);1983	rw = DIV_ROUND_UP(efx->tc->meta_ct.desc.resp_width, 32);1984	BUILD_BUG_ON(sizeof(__le32) != MC_CMD_TABLE_INSERT_IN_DATA_LEN);1985	inlen = MC_CMD_TABLE_INSERT_IN_LEN(kw + rw);1986	if (inlen > MC_CMD_TABLE_INSERT_IN_LENMAX_MCDI2)1987		return -E2BIG;1988	inbuf = kzalloc(inlen, GFP_KERNEL);1989	if (!inbuf)1990		return -ENOMEM;1991 1992	key = kcalloc(kw, sizeof(__le32), GFP_KERNEL);1993	if (!key)1994		goto out_free;1995	resp = kcalloc(rw, sizeof(__le32), GFP_KERNEL);1996	if (!resp)1997		goto out_free;1998 1999	rc = efx_mae_populate_ct_key(efx, key, kw, conn);2000	if (rc)2001		goto out_free;2002 2003	rc = TABLE_POPULATE_RESP_BOOL(resp, ct, dnat, conn->dnat);2004	if (rc)2005		goto out_free;2006	/* No support in hw for IPv6 NAT; field is only 32 bits */2007	if (!ipv6)2008		rc = TABLE_POPULATE_RESP(resp, ct, nat_ip, conn->nat_ip);2009	if (rc)2010		goto out_free;2011	rc = TABLE_POPULATE_RESP(resp, ct, l4_natport, conn->l4_natport);2012	if (rc)2013		goto out_free;2014	rc = TABLE_POPULATE_RESP(resp, ct, mark, cpu_to_be32(conn->mark));2015	if (rc)2016		goto out_free;2017	rc = TABLE_POPULATE_RESP_U24(resp, ct, counter_id, conn->cnt->fw_id);2018	if (rc)2019		goto out_free;2020 2021	MCDI_SET_DWORD(inbuf, TABLE_INSERT_IN_TABLE_ID, TABLE_ID_CONNTRACK_TABLE);2022	MCDI_SET_WORD(inbuf, TABLE_INSERT_IN_KEY_WIDTH,2023		      efx->tc->meta_ct.desc.key_width);2024	/* MASK_WIDTH is zero as CT is a BCAM */2025	MCDI_SET_WORD(inbuf, TABLE_INSERT_IN_RESP_WIDTH,2026		      efx->tc->meta_ct.desc.resp_width);2027	memcpy(MCDI_PTR(inbuf, TABLE_INSERT_IN_DATA), key, kw * sizeof(__le32));2028	memcpy(MCDI_PTR(inbuf, TABLE_INSERT_IN_DATA) + kw * sizeof(__le32),2029	       resp, rw * sizeof(__le32));2030 2031	BUILD_BUG_ON(MC_CMD_TABLE_INSERT_OUT_LEN);2032 2033	rc = efx_mcdi_rpc(efx, MC_CMD_TABLE_INSERT, inbuf, inlen, NULL, 0, NULL);2034 2035out_free:2036	kfree(resp);2037	kfree(key);2038	kfree(inbuf);2039	return rc;2040}2041 2042int efx_mae_remove_ct(struct efx_nic *efx, struct efx_tc_ct_entry *conn)2043{2044	__le32 *key = NULL;2045	efx_dword_t *inbuf;2046	size_t inlen, kw;2047	int rc = -ENOMEM;2048 2049	/* Check table access is supported */2050	if (!efx->tc->meta_ct.hooked)2051		return -EOPNOTSUPP;2052 2053	/* key width is in bits; convert to dwords for IN_LEN */2054	kw = DIV_ROUND_UP(efx->tc->meta_ct.desc.key_width, 32);2055	BUILD_BUG_ON(sizeof(__le32) != MC_CMD_TABLE_DELETE_IN_DATA_LEN);2056	inlen = MC_CMD_TABLE_DELETE_IN_LEN(kw);2057	if (inlen > MC_CMD_TABLE_DELETE_IN_LENMAX_MCDI2)2058		return -E2BIG;2059	inbuf = kzalloc(inlen, GFP_KERNEL);2060	if (!inbuf)2061		return -ENOMEM;2062 2063	key = kcalloc(kw, sizeof(__le32), GFP_KERNEL);2064	if (!key)2065		goto out_free;2066 2067	rc = efx_mae_populate_ct_key(efx, key, kw, conn);2068	if (rc)2069		goto out_free;2070 2071	MCDI_SET_DWORD(inbuf, TABLE_DELETE_IN_TABLE_ID, TABLE_ID_CONNTRACK_TABLE);2072	MCDI_SET_WORD(inbuf, TABLE_DELETE_IN_KEY_WIDTH,2073		      efx->tc->meta_ct.desc.key_width);2074	/* MASK_WIDTH is zero as CT is a BCAM */2075	/* RESP_WIDTH is zero for DELETE */2076	memcpy(MCDI_PTR(inbuf, TABLE_DELETE_IN_DATA), key, kw * sizeof(__le32));2077 2078	BUILD_BUG_ON(MC_CMD_TABLE_DELETE_OUT_LEN);2079 2080	rc = efx_mcdi_rpc(efx, MC_CMD_TABLE_DELETE, inbuf, inlen, NULL, 0, NULL);2081 2082out_free:2083	kfree(key);2084	kfree(inbuf);2085	return rc;2086}2087 2088static int efx_mae_populate_match_criteria(MCDI_DECLARE_STRUCT_PTR(match_crit),2089					   const struct efx_tc_match *match)2090{2091	if (match->mask.ingress_port) {2092		if (~match->mask.ingress_port)2093			return -EOPNOTSUPP;2094		MCDI_STRUCT_SET_DWORD(match_crit,2095				      MAE_FIELD_MASK_VALUE_PAIRS_V2_INGRESS_MPORT_SELECTOR,2096				      match->value.ingress_port);2097	}2098	MCDI_STRUCT_SET_DWORD(match_crit, MAE_FIELD_MASK_VALUE_PAIRS_V2_INGRESS_MPORT_SELECTOR_MASK,2099			      match->mask.ingress_port);2100	EFX_POPULATE_DWORD_5(*_MCDI_STRUCT_DWORD(match_crit, MAE_FIELD_MASK_VALUE_PAIRS_V2_FLAGS),2101			     MAE_FIELD_MASK_VALUE_PAIRS_V2_DO_CT,2102			     match->value.ct_state_trk,2103			     MAE_FIELD_MASK_VALUE_PAIRS_V2_CT_HIT,2104			     match->value.ct_state_est,2105			     MAE_FIELD_MASK_VALUE_PAIRS_V2_IS_IP_FRAG,2106			     match->value.ip_frag,2107			     MAE_FIELD_MASK_VALUE_PAIRS_V2_IP_FIRST_FRAG,2108			     match->value.ip_firstfrag,2109			     MAE_FIELD_MASK_VALUE_PAIRS_V2_TCP_SYN_FIN_RST,2110			     match->value.tcp_syn_fin_rst);2111	EFX_POPULATE_DWORD_5(*_MCDI_STRUCT_DWORD(match_crit, MAE_FIELD_MASK_VALUE_PAIRS_V2_FLAGS_MASK),2112			     MAE_FIELD_MASK_VALUE_PAIRS_V2_DO_CT,2113			     match->mask.ct_state_trk,2114			     MAE_FIELD_MASK_VALUE_PAIRS_V2_CT_HIT,2115			     match->mask.ct_state_est,2116			     MAE_FIELD_MASK_VALUE_PAIRS_V2_IS_IP_FRAG,2117			     match->mask.ip_frag,2118			     MAE_FIELD_MASK_VALUE_PAIRS_V2_IP_FIRST_FRAG,2119			     match->mask.ip_firstfrag,2120			     MAE_FIELD_MASK_VALUE_PAIRS_V2_TCP_SYN_FIN_RST,2121			     match->mask.tcp_syn_fin_rst);2122	MCDI_STRUCT_SET_BYTE(match_crit, MAE_FIELD_MASK_VALUE_PAIRS_V2_RECIRC_ID,2123			     match->value.recirc_id);2124	MCDI_STRUCT_SET_BYTE(match_crit, MAE_FIELD_MASK_VALUE_PAIRS_V2_RECIRC_ID_MASK,2125			     match->mask.recirc_id);2126	MCDI_STRUCT_SET_DWORD(match_crit, MAE_FIELD_MASK_VALUE_PAIRS_V2_CT_MARK,2127			      match->value.ct_mark);2128	MCDI_STRUCT_SET_DWORD(match_crit, MAE_FIELD_MASK_VALUE_PAIRS_V2_CT_MARK_MASK,2129			      match->mask.ct_mark);2130	MCDI_STRUCT_SET_WORD(match_crit, MAE_FIELD_MASK_VALUE_PAIRS_V2_CT_DOMAIN,2131			     match->value.ct_zone);2132	MCDI_STRUCT_SET_WORD(match_crit, MAE_FIELD_MASK_VALUE_PAIRS_V2_CT_DOMAIN_MASK,2133			     match->mask.ct_zone);2134	MCDI_STRUCT_SET_WORD_BE(match_crit, MAE_FIELD_MASK_VALUE_PAIRS_V2_ETHER_TYPE_BE,2135				match->value.eth_proto);2136	MCDI_STRUCT_SET_WORD_BE(match_crit, MAE_FIELD_MASK_VALUE_PAIRS_V2_ETHER_TYPE_BE_MASK,2137				match->mask.eth_proto);2138	MCDI_STRUCT_SET_WORD_BE(match_crit, MAE_FIELD_MASK_VALUE_PAIRS_V2_VLAN0_TCI_BE,2139				match->value.vlan_tci[0]);2140	MCDI_STRUCT_SET_WORD_BE(match_crit, MAE_FIELD_MASK_VALUE_PAIRS_V2_VLAN0_TCI_BE_MASK,2141				match->mask.vlan_tci[0]);2142	MCDI_STRUCT_SET_WORD_BE(match_crit, MAE_FIELD_MASK_VALUE_PAIRS_V2_VLAN0_PROTO_BE,2143				match->value.vlan_proto[0]);2144	MCDI_STRUCT_SET_WORD_BE(match_crit, MAE_FIELD_MASK_VALUE_PAIRS_V2_VLAN0_PROTO_BE_MASK,2145				match->mask.vlan_proto[0]);2146	MCDI_STRUCT_SET_WORD_BE(match_crit, MAE_FIELD_MASK_VALUE_PAIRS_V2_VLAN1_TCI_BE,2147				match->value.vlan_tci[1]);2148	MCDI_STRUCT_SET_WORD_BE(match_crit, MAE_FIELD_MASK_VALUE_PAIRS_V2_VLAN1_TCI_BE_MASK,2149				match->mask.vlan_tci[1]);2150	MCDI_STRUCT_SET_WORD_BE(match_crit, MAE_FIELD_MASK_VALUE_PAIRS_V2_VLAN1_PROTO_BE,2151				match->value.vlan_proto[1]);2152	MCDI_STRUCT_SET_WORD_BE(match_crit, MAE_FIELD_MASK_VALUE_PAIRS_V2_VLAN1_PROTO_BE_MASK,2153				match->mask.vlan_proto[1]);2154	memcpy(MCDI_STRUCT_PTR(match_crit, MAE_FIELD_MASK_VALUE_PAIRS_V2_ETH_SADDR_BE),2155	       match->value.eth_saddr, ETH_ALEN);2156	memcpy(MCDI_STRUCT_PTR(match_crit, MAE_FIELD_MASK_VALUE_PAIRS_V2_ETH_SADDR_BE_MASK),2157	       match->mask.eth_saddr, ETH_ALEN);2158	memcpy(MCDI_STRUCT_PTR(match_crit, MAE_FIELD_MASK_VALUE_PAIRS_V2_ETH_DADDR_BE),2159	       match->value.eth_daddr, ETH_ALEN);2160	memcpy(MCDI_STRUCT_PTR(match_crit, MAE_FIELD_MASK_VALUE_PAIRS_V2_ETH_DADDR_BE_MASK),2161	       match->mask.eth_daddr, ETH_ALEN);2162	MCDI_STRUCT_SET_BYTE(match_crit, MAE_FIELD_MASK_VALUE_PAIRS_V2_IP_PROTO,2163			     match->value.ip_proto);2164	MCDI_STRUCT_SET_BYTE(match_crit, MAE_FIELD_MASK_VALUE_PAIRS_V2_IP_PROTO_MASK,2165			     match->mask.ip_proto);2166	MCDI_STRUCT_SET_BYTE(match_crit, MAE_FIELD_MASK_VALUE_PAIRS_V2_IP_TOS,2167			     match->value.ip_tos);2168	MCDI_STRUCT_SET_BYTE(match_crit, MAE_FIELD_MASK_VALUE_PAIRS_V2_IP_TOS_MASK,2169			     match->mask.ip_tos);2170	MCDI_STRUCT_SET_BYTE(match_crit, MAE_FIELD_MASK_VALUE_PAIRS_V2_IP_TTL,2171			     match->value.ip_ttl);2172	MCDI_STRUCT_SET_BYTE(match_crit, MAE_FIELD_MASK_VALUE_PAIRS_V2_IP_TTL_MASK,2173			     match->mask.ip_ttl);2174	MCDI_STRUCT_SET_DWORD_BE(match_crit, MAE_FIELD_MASK_VALUE_PAIRS_V2_SRC_IP4_BE,2175				 match->value.src_ip);2176	MCDI_STRUCT_SET_DWORD_BE(match_crit, MAE_FIELD_MASK_VALUE_PAIRS_V2_SRC_IP4_BE_MASK,2177				 match->mask.src_ip);2178	MCDI_STRUCT_SET_DWORD_BE(match_crit, MAE_FIELD_MASK_VALUE_PAIRS_V2_DST_IP4_BE,2179				 match->value.dst_ip);2180	MCDI_STRUCT_SET_DWORD_BE(match_crit, MAE_FIELD_MASK_VALUE_PAIRS_V2_DST_IP4_BE_MASK,2181				 match->mask.dst_ip);2182#ifdef CONFIG_IPV62183	memcpy(MCDI_STRUCT_PTR(match_crit, MAE_FIELD_MASK_VALUE_PAIRS_V2_SRC_IP6_BE),2184	       &match->value.src_ip6, sizeof(struct in6_addr));2185	memcpy(MCDI_STRUCT_PTR(match_crit, MAE_FIELD_MASK_VALUE_PAIRS_V2_SRC_IP6_BE_MASK),2186	       &match->mask.src_ip6, sizeof(struct in6_addr));2187	memcpy(MCDI_STRUCT_PTR(match_crit, MAE_FIELD_MASK_VALUE_PAIRS_V2_DST_IP6_BE),2188	       &match->value.dst_ip6, sizeof(struct in6_addr));2189	memcpy(MCDI_STRUCT_PTR(match_crit, MAE_FIELD_MASK_VALUE_PAIRS_V2_DST_IP6_BE_MASK),2190	       &match->mask.dst_ip6, sizeof(struct in6_addr));2191#endif2192	MCDI_STRUCT_SET_WORD_BE(match_crit, MAE_FIELD_MASK_VALUE_PAIRS_V2_L4_SPORT_BE,2193				match->value.l4_sport);2194	MCDI_STRUCT_SET_WORD_BE(match_crit, MAE_FIELD_MASK_VALUE_PAIRS_V2_L4_SPORT_BE_MASK,2195				match->mask.l4_sport);2196	MCDI_STRUCT_SET_WORD_BE(match_crit, MAE_FIELD_MASK_VALUE_PAIRS_V2_L4_DPORT_BE,2197				match->value.l4_dport);2198	MCDI_STRUCT_SET_WORD_BE(match_crit, MAE_FIELD_MASK_VALUE_PAIRS_V2_L4_DPORT_BE_MASK,2199				match->mask.l4_dport);2200	MCDI_STRUCT_SET_WORD_BE(match_crit, MAE_FIELD_MASK_VALUE_PAIRS_V2_TCP_FLAGS_BE,2201				match->value.tcp_flags);2202	MCDI_STRUCT_SET_WORD_BE(match_crit, MAE_FIELD_MASK_VALUE_PAIRS_V2_TCP_FLAGS_BE_MASK,2203				match->mask.tcp_flags);2204	/* enc-keys are handled indirectly, through encap_match ID */2205	if (match->encap) {2206		MCDI_STRUCT_SET_DWORD(match_crit, MAE_FIELD_MASK_VALUE_PAIRS_V2_OUTER_RULE_ID,2207				      match->encap->fw_id);2208		MCDI_STRUCT_SET_DWORD(match_crit, MAE_FIELD_MASK_VALUE_PAIRS_V2_OUTER_RULE_ID_MASK,2209				      U32_MAX);2210		/* enc_keyid (VNI/VSID) is not part of the encap_match */2211		MCDI_STRUCT_SET_DWORD_BE(match_crit, MAE_FIELD_MASK_VALUE_PAIRS_V2_ENC_VNET_ID_BE,2212					 match->value.enc_keyid);2213		MCDI_STRUCT_SET_DWORD_BE(match_crit, MAE_FIELD_MASK_VALUE_PAIRS_V2_ENC_VNET_ID_BE_MASK,2214					 match->mask.enc_keyid);2215	} else if (WARN_ON_ONCE(match->mask.enc_src_ip) ||2216		   WARN_ON_ONCE(match->mask.enc_dst_ip) ||2217		   WARN_ON_ONCE(!ipv6_addr_any(&match->mask.enc_src_ip6)) ||2218		   WARN_ON_ONCE(!ipv6_addr_any(&match->mask.enc_dst_ip6)) ||2219		   WARN_ON_ONCE(match->mask.enc_ip_tos) ||2220		   WARN_ON_ONCE(match->mask.enc_ip_ttl) ||2221		   WARN_ON_ONCE(match->mask.enc_sport) ||2222		   WARN_ON_ONCE(match->mask.enc_dport) ||2223		   WARN_ON_ONCE(match->mask.enc_keyid)) {2224		/* No enc-keys should appear in a rule without an encap_match */2225		return -EOPNOTSUPP;2226	}2227	return 0;2228}2229 2230int efx_mae_insert_rule(struct efx_nic *efx, const struct efx_tc_match *match,2231			u32 prio, u32 acts_id, u32 *id)2232{2233	MCDI_DECLARE_BUF(inbuf, MC_CMD_MAE_ACTION_RULE_INSERT_IN_LEN(MAE_FIELD_MASK_VALUE_PAIRS_V2_LEN));2234	MCDI_DECLARE_BUF(outbuf, MC_CMD_MAE_ACTION_RULE_INSERT_OUT_LEN);2235	MCDI_DECLARE_STRUCT_PTR(match_crit);2236	MCDI_DECLARE_STRUCT_PTR(response);2237	size_t outlen;2238	int rc;2239 2240	if (!id)2241		return -EINVAL;2242 2243	match_crit = _MCDI_DWORD(inbuf, MAE_ACTION_RULE_INSERT_IN_MATCH_CRITERIA);2244	response = _MCDI_DWORD(inbuf, MAE_ACTION_RULE_INSERT_IN_RESPONSE);2245	if (efx_mae_asl_id(acts_id)) {2246		MCDI_STRUCT_SET_DWORD(response, MAE_ACTION_RULE_RESPONSE_ASL_ID, acts_id);2247		MCDI_STRUCT_SET_DWORD(response, MAE_ACTION_RULE_RESPONSE_AS_ID,2248				      MC_CMD_MAE_ACTION_SET_ALLOC_OUT_ACTION_SET_ID_NULL);2249	} else {2250		/* We only had one AS, so we didn't wrap it in an ASL */2251		MCDI_STRUCT_SET_DWORD(response, MAE_ACTION_RULE_RESPONSE_ASL_ID,2252				      MC_CMD_MAE_ACTION_SET_LIST_ALLOC_OUT_ACTION_SET_LIST_ID_NULL);2253		MCDI_STRUCT_SET_DWORD(response, MAE_ACTION_RULE_RESPONSE_AS_ID, acts_id);2254	}2255	MCDI_SET_DWORD(inbuf, MAE_ACTION_RULE_INSERT_IN_PRIO, prio);2256	rc = efx_mae_populate_match_criteria(match_crit, match);2257	if (rc)2258		return rc;2259 2260	rc = efx_mcdi_rpc(efx, MC_CMD_MAE_ACTION_RULE_INSERT, inbuf, sizeof(inbuf),2261			  outbuf, sizeof(outbuf), &outlen);2262	if (rc)2263		return rc;2264	if (outlen < sizeof(outbuf))2265		return -EIO;2266	*id = MCDI_DWORD(outbuf, MAE_ACTION_RULE_INSERT_OUT_AR_ID);2267	return 0;2268}2269 2270int efx_mae_update_rule(struct efx_nic *efx, u32 acts_id, u32 id)2271{2272	MCDI_DECLARE_BUF(inbuf, MC_CMD_MAE_ACTION_RULE_UPDATE_IN_LEN);2273	MCDI_DECLARE_STRUCT_PTR(response);2274 2275	BUILD_BUG_ON(MC_CMD_MAE_ACTION_RULE_UPDATE_OUT_LEN);2276	response = _MCDI_DWORD(inbuf, MAE_ACTION_RULE_UPDATE_IN_RESPONSE);2277 2278	MCDI_SET_DWORD(inbuf, MAE_ACTION_RULE_UPDATE_IN_AR_ID, id);2279	if (efx_mae_asl_id(acts_id)) {2280		MCDI_STRUCT_SET_DWORD(response, MAE_ACTION_RULE_RESPONSE_ASL_ID, acts_id);2281		MCDI_STRUCT_SET_DWORD(response, MAE_ACTION_RULE_RESPONSE_AS_ID,2282				      MC_CMD_MAE_ACTION_SET_ALLOC_OUT_ACTION_SET_ID_NULL);2283	} else {2284		/* We only had one AS, so we didn't wrap it in an ASL */2285		MCDI_STRUCT_SET_DWORD(response, MAE_ACTION_RULE_RESPONSE_ASL_ID,2286				      MC_CMD_MAE_ACTION_SET_LIST_ALLOC_OUT_ACTION_SET_LIST_ID_NULL);2287		MCDI_STRUCT_SET_DWORD(response, MAE_ACTION_RULE_RESPONSE_AS_ID, acts_id);2288	}2289	return efx_mcdi_rpc(efx, MC_CMD_MAE_ACTION_RULE_UPDATE, inbuf, sizeof(inbuf),2290			    NULL, 0, NULL);2291}2292 2293int efx_mae_delete_rule(struct efx_nic *efx, u32 id)2294{2295	MCDI_DECLARE_BUF(outbuf, MC_CMD_MAE_ACTION_RULE_DELETE_OUT_LEN(1));2296	MCDI_DECLARE_BUF(inbuf, MC_CMD_MAE_ACTION_RULE_DELETE_IN_LEN(1));2297	size_t outlen;2298	int rc;2299 2300	MCDI_SET_DWORD(inbuf, MAE_ACTION_RULE_DELETE_IN_AR_ID, id);2301	rc = efx_mcdi_rpc(efx, MC_CMD_MAE_ACTION_RULE_DELETE, inbuf, sizeof(inbuf),2302			  outbuf, sizeof(outbuf), &outlen);2303	if (rc)2304		return rc;2305	if (outlen < sizeof(outbuf))2306		return -EIO;2307	/* FW freed a different ID than we asked for, should also never happen.2308	 * Warn because it means we've now got a different idea to the FW of2309	 * what rules exist, which could cause mayhem later.2310	 */2311	if (WARN_ON(MCDI_DWORD(outbuf, MAE_ACTION_RULE_DELETE_OUT_DELETED_AR_ID) != id))2312		return -EIO;2313	return 0;2314}2315 2316int efx_init_mae(struct efx_nic *efx)2317{2318	struct ef100_nic_data *nic_data = efx->nic_data;2319	struct efx_mae *mae;2320	int rc;2321 2322	if (!nic_data->have_mport)2323		return -EINVAL;2324 2325	mae = kmalloc(sizeof(*mae), GFP_KERNEL);2326	if (!mae)2327		return -ENOMEM;2328 2329	rc = rhashtable_init(&mae->mports_ht, &efx_mae_mports_ht_params);2330	if (rc < 0) {2331		kfree(mae);2332		return rc;2333	}2334	efx->mae = mae;2335	mae->efx = efx;2336	return 0;2337}2338 2339void efx_fini_mae(struct efx_nic *efx)2340{2341	struct efx_mae *mae = efx->mae;2342 2343	kfree(mae);2344	efx->mae = NULL;2345}2346