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, 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
  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, sizeof(inbuf),
  55                             NULL, 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, 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
 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, 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;
 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, 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; 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, sizeof(inbuf), NULL, 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, 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 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(desc->keys);
 309         kfree(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(desc->keys);
 402         kfree(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, 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
 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, &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
 475 void 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
 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, 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
 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, 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 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                                      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...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((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_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                                 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 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((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_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((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 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, 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
 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, 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 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(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
 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(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
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                           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 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(&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
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(&efx->mae->mports_ht, &mport_id,
1075                                       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(&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
1096 void 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
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, 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
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                                   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));
1217 fail:
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 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, 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 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                           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 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, 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
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, 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 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(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         }
1436 out_free:
1437         kfree(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(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 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(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                           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
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                           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 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, &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 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                           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
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, &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
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                           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 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, 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, &v, 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, &v, 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, ((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
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(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
2035 out_free:
2036         kfree(resp);
2037         kfree(key);
2038         kfree(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(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
2082 out_free:
2083         kfree(key);
2084         kfree(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(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
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(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
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, 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 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(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
2339 void efx_fini_mae(struct efx_nic *efx)
2340 {
2341         struct efx_mae *mae = efx->mae;
2342
2343         kfree(mae);
2344         efx->mae = NULL;
2345 }