mae.c source code [linux/drivers/net/ethernet/sfc/mae.c]

1	// SPDX-License-Identifier: GPL-2.0-only
2	/****************************************************************************
3	* Driver for Solarflare network controllers and boards
4	* 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 it
8	* under the terms of the GNU General Public License version 2 as published
9	* 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
21	int 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, inlen: sizeof(inbuf),
38	outbuf, outlen: sizeof(outbuf), outlen_actual: &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
48	int 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, inlen: sizeof(inbuf),
55	NULL, outlen: `0`, NULL);
56	}
57
58	void 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
68	void 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
79	void 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 /
91	void 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 /
102	int 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, inlen: sizeof(inbuf),
111	outbuf, outlen: sizeof(outbuf), outlen_actual: &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
120	int 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, inlen: sizeof(inbuf), outbuf, outlen: sizeof(outbuf), outlen_actual: &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`;
155	out_stop:
156	efx_mae_stop_counters(efx, rx_queue);
157	return -EOPNOTSUPP;
158	}
159
160	static 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
170	int 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, inlen: sizeof(inbuf), outbuf, outlen: sizeof(outbuf), outlen_actual: &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; whatever*
199	* timeout we use, that delay is added to unload on nonresponsive
200	* 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
214	void 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, inlen: sizeof(inbuf), NULL, outlen: `0`, NULL))
228	rx_queue->granted_count += credits;
229	}
230
231	static 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);
244	more:
245	MCDI_SET_DWORD(inbuf, TABLE_DESCRIPTOR_IN_FIRST_FIELDS_INDEX, offset);
246	rc = efx_mcdi_rpc(efx, MC_CMD_TABLE_DESCRIPTOR, inbuf, inlen: sizeof(inbuf),
247	outbuf, outlen: sizeof(outbuf), outlen_actual: &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(n: desc->n_keys,
270	size: sizeof(struct efx_tc_table_field_fmt),
271	GFP_KERNEL);
272	if (!desc->keys)
273	goto fail;
274	desc->resps = kcalloc(n: desc->n_resps,
275	size: 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 we*
281	* made room for in our outbuf
282	*/
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	else
295	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
307	fail:
308	kfree(objp: desc->keys);
309	kfree(objp: desc->resps);
310	return rc;
311	}
312
313	static 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
354	static 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
399	static void efx_mae_table_free_desc(struct efx_tc_table_desc *desc)
400	{
401	kfree(objp: desc->keys);
402	kfree(objp: desc->resps);
403	memset(desc, `0`, sizeof(*desc));
404	}
405
406	static 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;
417	more:
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, inlen: sizeof(inbuf), outbuf,
421	outlen: msg_max, outlen_actual: &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
446	int 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, desc: &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, meta_ct: &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
475	void efx_mae_free_tables(struct efx_nic *efx)
476	{
477	efx_mae_table_free_desc(desc: &efx->tc->meta_ct.desc);
478	efx->tc->meta_ct.hooked = false;
479	}
480
481	static 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, inlen: `0`, outbuf,
490	outlen: sizeof(outbuf), outlen_actual: &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
501	static 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 the*
511	* 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, inlen: `0`, outbuf, outlen: sizeof(outbuf), outlen_actual: &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 other*
529	* 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
537	int 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	field_support: 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	field_support: caps->outer_rule_fields);
550	}
551
552	/ Bit twiddling:*
553	* Prefix: 1...110...0
554	* ~: 0...001...1
555	* + 1: 0...010...0 is power of two
556	* so (~x) & ((~x) + 1) == 0. Converse holds also.
557	*/
558	#define is_prefix_byte(_x) !(((_x) ^ 0xff) & (((_x) ^ 0xff) + 1))
559
560	enum mask_type { MASK_ONES, MASK_ZEROES, MASK_PREFIX, MASK_OTHER };
561
562	static 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 /
579	static 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
607	static 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
660	int 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(mask: (const u8 *)&ingress_port,
671	len: sizeof(ingress_port));
672	rc = efx_mae_match_check_cap_typ(support: supported_fields[MAE_FIELD_INGRESS_PORT],
673	typ: 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_IPV6
692	CHECK(SRC_IP6, src_ip6) \|\|
693	CHECK(DST_IP6, dst_ip6) \|\|
694	#endif
695	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 an
709	* exact match on Outer Rule ID if any outer field matches are
710	* present. The exception is the VNI/VSID (enc_keyid), which is
711	* available to the Action Rule match iff the Outer Rule matched
712	* (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	support: supported_fields[MAE_FIELD_OUTER_RULE_ID],
717	typ: 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 means*
751	* they use ENC_ fields in hardware to match regular (not enc_) fields from
752	* &struct efx_tc_match_fields.
753	*/
754	int 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(mask: (const u8 *)&ingress_port,
765	len: sizeof(ingress_port));
766	rc = efx_mae_match_check_cap_typ(support: supported_fields[MAE_FIELD_INGRESS_PORT],
767	typ: 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_IPV6
789	CHECK(ENC_SRC_IP6, src_ip6) \|\|
790	CHECK(ENC_DST_IP6, dst_ip6) \|\|
791	#endif
792	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, translated*
799	* 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 UNSUPPORTED
814	#undef CHECK_BIT
815	#undef CHECK
816
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 the*
826	* MAE. All the fields are exact-match, except possibly ENC_IP_TOS.
827	*/
828	int 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(mask: (const u8 )&udp_sport_mask, len: sizeof*(udp_sport_mask));
851	rc = efx_mae_match_check_cap_typ(support: 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(mask: &ip_tos_mask, len: sizeof(ip_tos_mask));
859	rc = efx_mae_match_check_cap_typ(support: 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 CHECK
869
870	int 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
889	int 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, inlen: sizeof(inbuf),
902	outbuf, outlen: sizeof(outbuf), outlen_actual: &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
913	int 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, inlen: sizeof(inbuf),
924	outbuf, outlen: sizeof(outbuf), outlen_actual: &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 of
932	* 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
940	static 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
954	int 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(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, outlen: sizeof(outbuf), outlen_actual: &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
982	int 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(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, outlen: `0`, NULL);
1005	}
1006
1007	int 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	inlen: sizeof(inbuf), outbuf, outlen: sizeof(outbuf), outlen_actual: &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 of
1024	* 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 its*
1029	* 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
1035	int 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(ht: &mae->mports_ht, iter: &walk);
1044	rhashtable_walk_start(iter: &walk);
1045	while ((m = rhashtable_walk_next(iter: &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(iter: &walk);
1056	rhashtable_walk_exit(iter: &walk);
1057	return rc;
1058	}
1059
1060	static bool efx_mae_asl_id(u32 id)
1061	{
1062	return !!(id & BIT(`31`));
1063	}
1064
1065	/ mport handling /
1066	static 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
1072	struct mae_mport_desc efx_mae_get_mport(struct* efx_nic *efx, u32 mport_id)
1073	{
1074	return rhashtable_lookup_fast(ht: &efx->mae->mports_ht, key: &mport_id,
1075	params: efx_mae_mports_ht_params);
1076	}
1077
1078	static 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(ht: &mae->mports_ht, obj: &desc->linkage,
1084	params: 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(objp: desc);
1090	return rc;
1091	}
1092
1093	return rc;
1094	}
1095
1096	void efx_mae_remove_mport(void desc, void* *arg)
1097	{
1098	struct mae_mport_desc *mport = desc;
1099
1100	synchronize_rcu();
1101	kfree(objp: mport);
1102	}
1103
1104	static 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, mport_id: desc->mport_id);
1111	if (!IS_ERR_OR_NULL(ptr: 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
1134	int 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	inlen: sizeof(inbuf), outbuf,
1147	MCDI_MPORT_JOURNAL_LEN, outlen_actual: &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(size: 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, desc: 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));
1217	fail:
1218	kfree(objp: 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 on
1225	* @ped: pedit MAC action to be installed
1226	*
1227	* Attempts to install @ped in HW and populates its id with an index of this
1228	* entry in the firmware MAC address table on success.
1229	*
1230	* Return: negative value on error, 0 in success.
1231	*/
1232	int 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, inlen: sizeof(inbuf),
1245	outbuf, outlen: sizeof(outbuf), outlen_actual: &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 on
1257	* @ped: pedit MAC action that needs to be freed
1258	*
1259	* Frees @ped in HW, check that firmware did not free a different one and clears
1260	* the id (which denotes the index of the entry in the MAC address table).
1261	*/
1262	void 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	inlen: sizeof(inbuf), outbuf, outlen: sizeof(outbuf), outlen_actual: &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 of
1277	* 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 its*
1282	* 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
1287	int 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	else
1306	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	else
1313	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	else
1320	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	else
1340	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, inlen: sizeof(inbuf),
1347	outbuf, outlen: sizeof(outbuf), outlen_actual: &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, fw_id: act->fw_id);
1358	return -EIO;
1359	}
1360	return `0`;
1361	}
1362
1363	int 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, inlen: sizeof(inbuf),
1372	outbuf, outlen: sizeof(outbuf), outlen_actual: &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 of
1379	* 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
1386	int 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_ID*
1401	* 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(size: 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, outlen: sizeof(outbuf), outlen_actual: &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	}
1436	out_free:
1437	kfree(objp: inbuf);
1438	return rc;
1439	}
1440
1441	int 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 is*
1450	* nothing for us to free. (The AS will be freed later.)
1451	*/
1452	if (efx_mae_asl_id(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	inlen: sizeof(inbuf), outbuf, outlen: sizeof(outbuf), outlen_actual: &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 of
1463	* 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 its*
1469	* 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
1475	int 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(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, and
1490	* ipproto == udp.
1491	*/
1492	MCDI_SET_DWORD(inbuf, MAE_OUTER_RULE_INSERT_IN_ENCAP_TYPE, rc);
1493	#ifdef CONFIG_IPV6
1494	if (encap->src_ip \| encap->dst_ip) {
1495	#endif
1496	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_IPV6
1507	} 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	#endif
1520	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	inlen: sizeof(inbuf), outbuf, outlen: sizeof(outbuf), outlen_actual: &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
1546	int 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	inlen: sizeof(inbuf), outbuf, outlen: sizeof(outbuf), outlen_actual: &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 of
1563	* 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 its*
1568	* 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
1574	static 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_IPV6
1643	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	#endif
1652	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; any*
1661	* enc-keys from an fLHS should have been translated to regular keys
1662	* and any EM should be a pseudo (we're an OR so can't have a direct
1663	* 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_IPV6
1672	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	#endif
1677	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
1690	static 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, match: &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(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 the*
1714	* SW path needs to process the packet to update the conntrack tables
1715	* 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	inlen: sizeof(inbuf), outbuf, outlen: sizeof(outbuf), outlen_actual: &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
1740	static int efx_mae_populate_match_criteria(MCDI_DECLARE_STRUCT_PTR(match_crit),
1741	const struct efx_tc_match *match);
1742
1743	static 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, match: &rule->match);
1776	if (rc)
1777	return rc;
1778
1779	rc = efx_mcdi_rpc(efx, MC_CMD_MAE_ACTION_RULE_INSERT, inbuf, inlen: sizeof(inbuf),
1780	outbuf, outlen: sizeof(outbuf), outlen_actual: &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
1789	int 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
1797	static 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	inlen: sizeof(inbuf), outbuf, outlen: sizeof(outbuf), outlen_actual: &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 of
1814	* 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 its*
1819	* 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
1825	int 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, id: 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 storing*
1833	* it in the appropriate bits of @row. @value must be big-endian; we
1834	* convert it to little-endianness as we go.
1835	*/
1836	static 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 here*
1843	* (rather than, say, in calling code, which knows the semantics and
1844	* 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
1866	static 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, value: &v, value_size: `1`);
1874	}
1875
1876	static 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, value: &v, value_size: sizeof(v));
1886	}
1887
1888	static 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, and*
1894	* the pointer to the value is set discarding the first byte which is
1895	* the most significant byte for a big-endian 4-bytes value.
1896	*/
1897	return efx_mae_table_populate(field, row, row_bits, value: ((void *)&v) + `1`,
1898	value_size: 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
1936	static 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	else
1951	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	else
1957	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
1969	int 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(size: inlen, GFP_KERNEL);
1989	if (!inbuf)
1990	return -ENOMEM;
1991
1992	key = kcalloc(n: kw, size: sizeof(__le32), GFP_KERNEL);
1993	if (!key)
1994	goto out_free;
1995	resp = kcalloc(n: rw, size: 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, outlen: `0`, NULL);
2034
2035	out_free:
2036	kfree(objp: resp);
2037	kfree(objp: key);
2038	kfree(objp: inbuf);
2039	return rc;
2040	}
2041
2042	int 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(size: inlen, GFP_KERNEL);
2060	if (!inbuf)
2061	return -ENOMEM;
2062
2063	key = kcalloc(n: kw, size: 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, outlen: `0`, NULL);
2081
2082	out_free:
2083	kfree(objp: key);
2084	kfree(objp: inbuf);
2085	return rc;
2086	}
2087
2088	static 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_IPV6
2183	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	#endif
2192	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
2230	int 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(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, inlen: sizeof(inbuf),
2261	outbuf, outlen: sizeof(outbuf), outlen_actual: &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
2270	int 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(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, inlen: sizeof(inbuf),
2290	NULL, outlen: `0`, NULL);
2291	}
2292
2293	int 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, inlen: sizeof(inbuf),
2302	outbuf, outlen: sizeof(outbuf), outlen_actual: &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 of
2309	* 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
2316	int 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(size: sizeof(*mae), GFP_KERNEL);
2326	if (!mae)
2327	return -ENOMEM;
2328
2329	rc = rhashtable_init(ht: &mae->mports_ht, params: &efx_mae_mports_ht_params);
2330	if (rc < `0`) {
2331	kfree(objp: mae);
2332	return rc;
2333	}
2334	efx->mae = mae;
2335	mae->efx = efx;
2336	return `0`;
2337	}
2338
2339	void efx_fini_mae(struct efx_nic *efx)
2340	{
2341	struct efx_mae *mae = efx->mae;
2342
2343	kfree(objp: mae);
2344	efx->mae = NULL;
2345	}
2346

source code of linux/drivers/net/ethernet/sfc/mae.c