drivers/net/ethernet/mellanox/mlx5/core/en_accel/macsec.c

   1 // SPDX-License-Identifier: GPL-2.0 OR Linux-OpenIB
   2 /* Copyright (c) 2022, NVIDIA CORPORATION & AFFILIATES. All rights reserved. */
   3
   4 #include <linux/mlx5/device.h>
   5 #include <linux/mlx5/mlx5_ifc.h>
   6 #include <linux/xarray.h>
   7
   8 #include "en.h"
   9 #include "lib/aso.h"
  10 #include "lib/mlx5.h"
  11 #include "en_accel/macsec.h"
  12 #include "en_accel/macsec_fs.h"
  13
  14 #define MLX5_MACSEC_EPN_SCOPE_MID 0x80000000L
  15 #define MLX5E_MACSEC_ASO_CTX_SZ MLX5_ST_SZ_BYTES(macsec_aso)
  16
  17 enum mlx5_macsec_aso_event_arm {
  18         MLX5E_ASO_EPN_ARM = BIT(0),
  19 };
  20
  21 enum {
  22         MLX5_MACSEC_ASO_REMOVE_FLOW_PKT_CNT_OFFSET,
  23 };
  24
  25 struct mlx5e_macsec_handle {
  26         struct mlx5e_macsec *macsec;
  27         u32 obj_id;
  28         u8 idx;
  29 };
  30
  31 enum {
  32         MLX5_MACSEC_EPN,
  33 };
  34
  35 struct mlx5e_macsec_aso_out {
  36         u8 event_arm;
  37         u32 mode_param;
  38 };
  39
  40 struct mlx5e_macsec_aso_in {
  41         u8 mode;
  42         u32 obj_id;
  43 };
  44
  45 struct mlx5e_macsec_epn_state {
  46         u32 epn_msb;
  47         u8 epn_enabled;
  48         u8 overlap;
  49 };
  50
  51 struct mlx5e_macsec_async_work {
  52         struct mlx5e_macsec *macsec;
  53         struct mlx5_core_dev *mdev;
  54         struct work_struct work;
  55         u32 obj_id;
  56 };
  57
  58 struct mlx5e_macsec_sa {
  59         bool active;
  60         u8  assoc_num;
  61         u32 macsec_obj_id;
  62         u32 enc_key_id;
  63         u32 next_pn;
  64         sci_t sci;
  65         salt_t salt;
  66
  67         struct rhash_head hash;
  68         u32 fs_id;
  69         union mlx5e_macsec_rule *macsec_rule;
  70         struct rcu_head rcu_head;
  71         struct mlx5e_macsec_epn_state epn_state;
  72 };
  73
  74 struct mlx5e_macsec_rx_sc;
  75 struct mlx5e_macsec_rx_sc_xarray_element {
  76         u32 fs_id;
  77         struct mlx5e_macsec_rx_sc *rx_sc;
  78 };
  79
  80 struct mlx5e_macsec_rx_sc {
  81         bool active;
  82         sci_t sci;
  83         struct mlx5e_macsec_sa *rx_sa[MACSEC_NUM_AN];
  84         struct list_head rx_sc_list_element;
  85         struct mlx5e_macsec_rx_sc_xarray_element *sc_xarray_element;
  86         struct metadata_dst *md_dst;
  87         struct rcu_head rcu_head;
  88 };
  89
  90 struct mlx5e_macsec_umr {
  91         dma_addr_t dma_addr;
  92         u8 ctx[MLX5_ST_SZ_BYTES(macsec_aso)];
  93         u32 mkey;
  94 };
  95
  96 struct mlx5e_macsec_aso {
  97         /* ASO */
  98         struct mlx5_aso *maso;
  99         /* Protects macsec ASO */
 100         struct mutex aso_lock;
 101         /* UMR */
 102         struct mlx5e_macsec_umr *umr;
 103
 104         u32 pdn;
 105 };
 106
 107 static const struct rhashtable_params rhash_sci = {
 108         .key_len = sizeof_field(struct mlx5e_macsec_sa, sci),
 109         .key_offset = offsetof(struct mlx5e_macsec_sa, sci),
 110         .head_offset = offsetof(struct mlx5e_macsec_sa, hash),
 111         .automatic_shrinking = true,
 112         .min_size = 1,
 113 };
 114
 115 struct mlx5e_macsec_device {
 116         const struct net_device *netdev;
 117         struct mlx5e_macsec_sa *tx_sa[MACSEC_NUM_AN];
 118         struct list_head macsec_rx_sc_list_head;
 119         unsigned char *dev_addr;
 120         struct list_head macsec_device_list_element;
 121 };
 122
 123 struct mlx5e_macsec {
 124         struct list_head macsec_device_list_head;
 125         int num_of_devices;
 126         struct mlx5e_macsec_fs *macsec_fs;
 127         struct mutex lock; /* Protects mlx5e_macsec internal contexts */
 128
 129         /* Tx sci -> fs id mapping handling */
 130         struct rhashtable sci_hash;      /* sci -> mlx5e_macsec_sa */
 131
 132         /* Rx fs_id -> rx_sc mapping */
 133         struct xarray sc_xarray;
 134
 135         struct mlx5_core_dev *mdev;
 136
 137         /* Stats manage */
 138         struct mlx5e_macsec_stats stats;
 139
 140         /* ASO */
 141         struct mlx5e_macsec_aso aso;
 142
 143         struct notifier_block nb;
 144         struct workqueue_struct *wq;
 145 };
 146
 147 struct mlx5_macsec_obj_attrs {
 148         u32 aso_pdn;
 149         u32 next_pn;
 150         __be64 sci;
 151         u32 enc_key_id;
 152         bool encrypt;
 153         struct mlx5e_macsec_epn_state epn_state;
 154         salt_t salt;
 155         __be32 ssci;
 156         bool replay_protect;
 157         u32 replay_window;
 158 };
 159
 160 struct mlx5_aso_ctrl_param {
 161         u8   data_mask_mode;
 162         u8   condition_0_operand;
 163         u8   condition_1_operand;
 164         u8   condition_0_offset;
 165         u8   condition_1_offset;
 166         u8   data_offset;
 167         u8   condition_operand;
 168         u32  condition_0_data;
 169         u32  condition_0_mask;
 170         u32  condition_1_data;
 171         u32  condition_1_mask;
 172         u64  bitwise_data;
 173         u64  data_mask;
 174 };
 175
 176 static int mlx5e_macsec_aso_reg_mr(struct mlx5_core_dev *mdev, struct mlx5e_macsec_aso *aso)
 177 {
 178         struct mlx5e_macsec_umr *umr;
 179         struct device *dma_device;
 180         dma_addr_t dma_addr;
 181         int err;
 182
 183         umr = kzalloc(sizeof(*umr), GFP_KERNEL);
 184         if (!umr) {
 185                 err = -ENOMEM;
 186                 return err;
 187         }
 188
 189         dma_device = &mdev->pdev->dev;
 190         dma_addr = dma_map_single(dma_device, umr->ctx, sizeof(umr->ctx), DMA_BIDIRECTIONAL);
 191         err = dma_mapping_error(dma_device, dma_addr);
 192         if (err) {
 193                 mlx5_core_err(mdev, "Can't map dma device, err=%d\n", err);
 194                 goto out_dma;
 195         }
 196
 197         err = mlx5e_create_mkey(mdev, aso->pdn, &umr->mkey);
 198         if (err) {
 199                 mlx5_core_err(mdev, "Can't create mkey, err=%d\n", err);
 200                 goto out_mkey;
 201         }
 202
 203         umr->dma_addr = dma_addr;
 204
 205         aso->umr = umr;
 206
 207         return 0;
 208
 209 out_mkey:
 210         dma_unmap_single(dma_device, dma_addr, sizeof(umr->ctx), DMA_BIDIRECTIONAL);
 211 out_dma:
 212         kfree(umr);
 213         return err;
 214 }
 215
 216 static void mlx5e_macsec_aso_dereg_mr(struct mlx5_core_dev *mdev, struct mlx5e_macsec_aso *aso)
 217 {
 218         struct mlx5e_macsec_umr *umr = aso->umr;
 219
 220         mlx5_core_destroy_mkey(mdev, umr->mkey);
 221         dma_unmap_single(&mdev->pdev->dev, umr->dma_addr, sizeof(umr->ctx), DMA_BIDIRECTIONAL);
 222         kfree(umr);
 223 }
 224
 225 static int macsec_set_replay_protection(struct mlx5_macsec_obj_attrs *attrs, void *aso_ctx)
 226 {
 227         u8 window_sz;
 228
 229         if (!attrs->replay_protect)
 230                 return 0;
 231
 232         switch (attrs->replay_window) {
 233         case 256:
 234                 window_sz = MLX5_MACSEC_ASO_REPLAY_WIN_256BIT;
 235                 break;
 236         case 128:
 237                 window_sz = MLX5_MACSEC_ASO_REPLAY_WIN_128BIT;
 238                 break;
 239         case 64:
 240                 window_sz = MLX5_MACSEC_ASO_REPLAY_WIN_64BIT;
 241                 break;
 242         case 32:
 243                 window_sz = MLX5_MACSEC_ASO_REPLAY_WIN_32BIT;
 244                 break;
 245         default:
 246                 return -EINVAL;
 247         }
 248         MLX5_SET(macsec_aso, aso_ctx, window_size, window_sz);
 249         MLX5_SET(macsec_aso, aso_ctx, mode, MLX5_MACSEC_ASO_REPLAY_PROTECTION);
 250
 251         return 0;
 252 }
 253
 254 static int mlx5e_macsec_create_object(struct mlx5_core_dev *mdev,
 255                                       struct mlx5_macsec_obj_attrs *attrs,
 256                                       bool is_tx,
 257                                       u32 *macsec_obj_id)
 258 {
 259         u32 in[MLX5_ST_SZ_DW(create_macsec_obj_in)] = {};
 260         u32 out[MLX5_ST_SZ_DW(general_obj_out_cmd_hdr)];
 261         void *aso_ctx;
 262         void *obj;
 263         int err;
 264
 265         obj = MLX5_ADDR_OF(create_macsec_obj_in, in, macsec_object);
 266         aso_ctx = MLX5_ADDR_OF(macsec_offload_obj, obj, macsec_aso);
 267
 268         MLX5_SET(macsec_offload_obj, obj, confidentiality_en, attrs->encrypt);
 269         MLX5_SET(macsec_offload_obj, obj, dekn, attrs->enc_key_id);
 270         MLX5_SET(macsec_offload_obj, obj, aso_return_reg, MLX5_MACSEC_ASO_REG_C_4_5);
 271         MLX5_SET(macsec_offload_obj, obj, macsec_aso_access_pd, attrs->aso_pdn);
 272         MLX5_SET(macsec_aso, aso_ctx, mode_parameter, attrs->next_pn);
 273
 274         /* Epn */
 275         if (attrs->epn_state.epn_enabled) {
 276                 void *salt_p;
 277                 int i;
 278
 279                 MLX5_SET(macsec_aso, aso_ctx, epn_event_arm, 1);
 280                 MLX5_SET(macsec_offload_obj, obj, epn_en, 1);
 281                 MLX5_SET(macsec_offload_obj, obj, epn_msb, attrs->epn_state.epn_msb);
 282                 MLX5_SET(macsec_offload_obj, obj, epn_overlap, attrs->epn_state.overlap);
 283                 MLX5_SET64(macsec_offload_obj, obj, sci, (__force u64)attrs->ssci);
 284                 salt_p = MLX5_ADDR_OF(macsec_offload_obj, obj, salt);
 285                 for (i = 0; i < 3 ; i++)
 286                         memcpy((u32 *)salt_p + i, &attrs->salt.bytes[4 * (2 - i)], 4);
 287         } else {
 288                 MLX5_SET64(macsec_offload_obj, obj, sci, (__force u64)(attrs->sci));
 289         }
 290
 291         MLX5_SET(macsec_aso, aso_ctx, valid, 0x1);
 292         if (is_tx) {
 293                 MLX5_SET(macsec_aso, aso_ctx, mode, MLX5_MACSEC_ASO_INC_SN);
 294         } else {
 295                 err = macsec_set_replay_protection(attrs, aso_ctx);
 296                 if (err)
 297                         return err;
 298         }
 299
 300         /* general object fields set */
 301         MLX5_SET(general_obj_in_cmd_hdr, in, opcode, MLX5_CMD_OP_CREATE_GENERAL_OBJECT);
 302         MLX5_SET(general_obj_in_cmd_hdr, in, obj_type, MLX5_GENERAL_OBJECT_TYPES_MACSEC);
 303
 304         err = mlx5_cmd_exec(mdev, in, sizeof(in), out, sizeof(out));
 305         if (err) {
 306                 mlx5_core_err(mdev,
 307                               "MACsec offload: Failed to create MACsec object (err = %d)\n",
 308                               err);
 309                 return err;
 310         }
 311
 312         *macsec_obj_id = MLX5_GET(general_obj_out_cmd_hdr, out, obj_id);
 313
 314         return err;
 315 }
 316
 317 static void mlx5e_macsec_destroy_object(struct mlx5_core_dev *mdev, u32 macsec_obj_id)
 318 {
 319         u32 in[MLX5_ST_SZ_DW(general_obj_in_cmd_hdr)] = {};
 320         u32 out[MLX5_ST_SZ_DW(general_obj_out_cmd_hdr)];
 321
 322         MLX5_SET(general_obj_in_cmd_hdr, in, opcode, MLX5_CMD_OP_DESTROY_GENERAL_OBJECT);
 323         MLX5_SET(general_obj_in_cmd_hdr, in, obj_type, MLX5_GENERAL_OBJECT_TYPES_MACSEC);
 324         MLX5_SET(general_obj_in_cmd_hdr, in, obj_id, macsec_obj_id);
 325
 326         mlx5_cmd_exec(mdev, in, sizeof(in), out, sizeof(out));
 327 }
 328
 329 static void mlx5e_macsec_cleanup_sa(struct mlx5e_macsec *macsec,
 330                                     struct mlx5e_macsec_sa *sa,
 331                                     bool is_tx)
 332 {
 333         int action =  (is_tx) ?  MLX5_ACCEL_MACSEC_ACTION_ENCRYPT :
 334                                  MLX5_ACCEL_MACSEC_ACTION_DECRYPT;
 335
 336         if ((is_tx) && sa->fs_id) {
 337                 /* Make sure ongoing datapath readers sees a valid SA */
 338                 rhashtable_remove_fast(&macsec->sci_hash, &sa->hash, rhash_sci);
 339                 sa->fs_id = 0;
 340         }
 341
 342         if (!sa->macsec_rule)
 343                 return;
 344
 345         mlx5e_macsec_fs_del_rule(macsec->macsec_fs, sa->macsec_rule, action);
 346         mlx5e_macsec_destroy_object(macsec->mdev, sa->macsec_obj_id);
 347         sa->macsec_rule = NULL;
 348 }
 349
 350 static int mlx5e_macsec_init_sa(struct macsec_context *ctx,
 351                                 struct mlx5e_macsec_sa *sa,
 352                                 bool encrypt,
 353                                 bool is_tx)
 354 {
 355         struct mlx5e_priv *priv = netdev_priv(ctx->netdev);
 356         struct mlx5e_macsec *macsec = priv->macsec;
 357         struct mlx5_macsec_rule_attrs rule_attrs;
 358         struct mlx5_core_dev *mdev = priv->mdev;
 359         struct mlx5_macsec_obj_attrs obj_attrs;
 360         union mlx5e_macsec_rule *macsec_rule;
 361         struct macsec_key *key;
 362         int err;
 363
 364         obj_attrs.next_pn = sa->next_pn;
 365         obj_attrs.sci = cpu_to_be64((__force u64)sa->sci);
 366         obj_attrs.enc_key_id = sa->enc_key_id;
 367         obj_attrs.encrypt = encrypt;
 368         obj_attrs.aso_pdn = macsec->aso.pdn;
 369         obj_attrs.epn_state = sa->epn_state;
 370
 371         if (is_tx) {
 372                 obj_attrs.ssci = cpu_to_be32((__force u32)ctx->sa.tx_sa->ssci);
 373                 key = &ctx->sa.tx_sa->key;
 374         } else {
 375                 obj_attrs.ssci = cpu_to_be32((__force u32)ctx->sa.rx_sa->ssci);
 376                 key = &ctx->sa.rx_sa->key;
 377         }
 378
 379         memcpy(&obj_attrs.salt, &key->salt, sizeof(key->salt));
 380         obj_attrs.replay_window = ctx->secy->replay_window;
 381         obj_attrs.replay_protect = ctx->secy->replay_protect;
 382
 383         err = mlx5e_macsec_create_object(mdev, &obj_attrs, is_tx, &sa->macsec_obj_id);
 384         if (err)
 385                 return err;
 386
 387         rule_attrs.macsec_obj_id = sa->macsec_obj_id;
 388         rule_attrs.sci = sa->sci;
 389         rule_attrs.assoc_num = sa->assoc_num;
 390         rule_attrs.action = (is_tx) ? MLX5_ACCEL_MACSEC_ACTION_ENCRYPT :
 391                                       MLX5_ACCEL_MACSEC_ACTION_DECRYPT;
 392
 393         macsec_rule = mlx5e_macsec_fs_add_rule(macsec->macsec_fs, ctx, &rule_attrs, &sa->fs_id);
 394         if (!macsec_rule) {
 395                 err = -ENOMEM;
 396                 goto destroy_macsec_object;
 397         }
 398
 399         sa->macsec_rule = macsec_rule;
 400
 401         if (is_tx) {
 402                 err = rhashtable_insert_fast(&macsec->sci_hash, &sa->hash, rhash_sci);
 403                 if (err)
 404                         goto destroy_macsec_object_and_rule;
 405         }
 406
 407         return 0;
 408
 409 destroy_macsec_object_and_rule:
 410         mlx5e_macsec_cleanup_sa(macsec, sa, is_tx);
 411 destroy_macsec_object:
 412         mlx5e_macsec_destroy_object(mdev, sa->macsec_obj_id);
 413
 414         return err;
 415 }
 416
 417 static struct mlx5e_macsec_rx_sc *
 418 mlx5e_macsec_get_rx_sc_from_sc_list(const struct list_head *list, sci_t sci)
 419 {
 420         struct mlx5e_macsec_rx_sc *iter;
 421
 422         list_for_each_entry_rcu(iter, list, rx_sc_list_element) {
 423                 if (iter->sci == sci)
 424                         return iter;
 425         }
 426
 427         return NULL;
 428 }
 429
 430 static int mlx5e_macsec_update_rx_sa(struct mlx5e_macsec *macsec,
 431                                      struct mlx5e_macsec_sa *rx_sa,
 432                                      bool active)
 433 {
 434         struct mlx5_core_dev *mdev = macsec->mdev;
 435         struct mlx5_macsec_obj_attrs attrs;
 436         int err = 0;
 437
 438         if (rx_sa->active != active)
 439                 return 0;
 440
 441         rx_sa->active = active;
 442         if (!active) {
 443                 mlx5e_macsec_cleanup_sa(macsec, rx_sa, false);
 444                 return 0;
 445         }
 446
 447         attrs.sci = rx_sa->sci;
 448         attrs.enc_key_id = rx_sa->enc_key_id;
 449         err = mlx5e_macsec_create_object(mdev, &attrs, false, &rx_sa->macsec_obj_id);
 450         if (err)
 451                 return err;
 452
 453         return 0;
 454 }
 455
 456 static bool mlx5e_macsec_secy_features_validate(struct macsec_context *ctx)
 457 {
 458         const struct net_device *netdev = ctx->netdev;
 459         const struct macsec_secy *secy = ctx->secy;
 460
 461         if (secy->validate_frames != MACSEC_VALIDATE_STRICT) {
 462                 netdev_err(netdev,
 463                            "MACsec offload is supported only when validate_frame is in strict mode\n");
 464                 return false;
 465         }
 466
 467         if (secy->icv_len != MACSEC_DEFAULT_ICV_LEN) {
 468                 netdev_err(netdev, "MACsec offload is supported only when icv_len is %d\n",
 469                            MACSEC_DEFAULT_ICV_LEN);
 470                 return false;
 471         }
 472
 473         if (!secy->protect_frames) {
 474                 netdev_err(netdev,
 475                            "MACsec offload is supported only when protect_frames is set\n");
 476                 return false;
 477         }
 478
 479         return true;
 480 }
 481
 482 static struct mlx5e_macsec_device *
 483 mlx5e_macsec_get_macsec_device_context(const struct mlx5e_macsec *macsec,
 484                                        const struct macsec_context *ctx)
 485 {
 486         struct mlx5e_macsec_device *iter;
 487         const struct list_head *list;
 488
 489         list = &macsec->macsec_device_list_head;
 490         list_for_each_entry_rcu(iter, list, macsec_device_list_element) {
 491                 if (iter->netdev == ctx->secy->netdev)
 492                         return iter;
 493         }
 494
 495         return NULL;
 496 }
 497
 498 static void update_macsec_epn(struct mlx5e_macsec_sa *sa, const struct macsec_key *key,
 499                               const pn_t *next_pn_halves)
 500 {
 501         struct mlx5e_macsec_epn_state *epn_state = &sa->epn_state;
 502
 503         sa->salt = key->salt;
 504         epn_state->epn_enabled = 1;
 505         epn_state->epn_msb = next_pn_halves->upper;
 506         epn_state->overlap = next_pn_halves->lower < MLX5_MACSEC_EPN_SCOPE_MID ? 0 : 1;
 507 }
 508
 509 static int mlx5e_macsec_add_txsa(struct macsec_context *ctx)
 510 {
 511         const struct macsec_tx_sc *tx_sc = &ctx->secy->tx_sc;
 512         const struct macsec_tx_sa *ctx_tx_sa = ctx->sa.tx_sa;
 513         struct mlx5e_priv *priv = netdev_priv(ctx->netdev);
 514         const struct macsec_secy *secy = ctx->secy;
 515         struct mlx5e_macsec_device *macsec_device;
 516         struct mlx5_core_dev *mdev = priv->mdev;
 517         u8 assoc_num = ctx->sa.assoc_num;
 518         struct mlx5e_macsec_sa *tx_sa;
 519         struct mlx5e_macsec *macsec;
 520         int err = 0;
 521
 522         mutex_lock(&priv->macsec->lock);
 523
 524         macsec = priv->macsec;
 525         macsec_device = mlx5e_macsec_get_macsec_device_context(macsec, ctx);
 526         if (!macsec_device) {
 527                 netdev_err(ctx->netdev, "MACsec offload: Failed to find device context\n");
 528                 err = -EEXIST;
 529                 goto out;
 530         }
 531
 532         if (macsec_device->tx_sa[assoc_num]) {
 533                 netdev_err(ctx->netdev, "MACsec offload tx_sa: %d already exist\n", assoc_num);
 534                 err = -EEXIST;
 535                 goto out;
 536         }
 537
 538         tx_sa = kzalloc(sizeof(*tx_sa), GFP_KERNEL);
 539         if (!tx_sa) {
 540                 err = -ENOMEM;
 541                 goto out;
 542         }
 543
 544         tx_sa->active = ctx_tx_sa->active;
 545         tx_sa->next_pn = ctx_tx_sa->next_pn_halves.lower;
 546         tx_sa->sci = secy->sci;
 547         tx_sa->assoc_num = assoc_num;
 548
 549         if (secy->xpn)
 550                 update_macsec_epn(tx_sa, &ctx_tx_sa->key, &ctx_tx_sa->next_pn_halves);
 551
 552         err = mlx5_create_encryption_key(mdev, ctx->sa.key, secy->key_len,
 553                                          MLX5_ACCEL_OBJ_MACSEC_KEY,
 554                                          &tx_sa->enc_key_id);
 555         if (err)
 556                 goto destroy_sa;
 557
 558         macsec_device->tx_sa[assoc_num] = tx_sa;
 559         if (!secy->operational ||
 560             assoc_num != tx_sc->encoding_sa ||
 561             !tx_sa->active)
 562                 goto out;
 563
 564         err = mlx5e_macsec_init_sa(ctx, tx_sa, tx_sc->encrypt, true);
 565         if (err)
 566                 goto destroy_encryption_key;
 567
 568         mutex_unlock(&macsec->lock);
 569
 570         return 0;
 571
 572 destroy_encryption_key:
 573         macsec_device->tx_sa[assoc_num] = NULL;
 574         mlx5_destroy_encryption_key(mdev, tx_sa->enc_key_id);
 575 destroy_sa:
 576         kfree(tx_sa);
 577 out:
 578         mutex_unlock(&macsec->lock);
 579
 580         return err;
 581 }
 582
 583 static int mlx5e_macsec_upd_txsa(struct macsec_context *ctx)
 584 {
 585         const struct macsec_tx_sc *tx_sc = &ctx->secy->tx_sc;
 586         const struct macsec_tx_sa *ctx_tx_sa = ctx->sa.tx_sa;
 587         struct mlx5e_priv *priv = netdev_priv(ctx->netdev);
 588         struct mlx5e_macsec_device *macsec_device;
 589         u8 assoc_num = ctx->sa.assoc_num;
 590         struct mlx5e_macsec_sa *tx_sa;
 591         struct mlx5e_macsec *macsec;
 592         struct net_device *netdev;
 593         int err = 0;
 594
 595         mutex_lock(&priv->macsec->lock);
 596
 597         macsec = priv->macsec;
 598         netdev = ctx->netdev;
 599         macsec_device = mlx5e_macsec_get_macsec_device_context(macsec, ctx);
 600         if (!macsec_device) {
 601                 netdev_err(netdev, "MACsec offload: Failed to find device context\n");
 602                 err = -EINVAL;
 603                 goto out;
 604         }
 605
 606         tx_sa = macsec_device->tx_sa[assoc_num];
 607         if (!tx_sa) {
 608                 netdev_err(netdev, "MACsec offload: TX sa 0x%x doesn't exist\n", assoc_num);
 609                 err = -EEXIST;
 610                 goto out;
 611         }
 612
 613         if (tx_sa->next_pn != ctx_tx_sa->next_pn_halves.lower) {
 614                 netdev_err(netdev, "MACsec offload: update TX sa %d PN isn't supported\n",
 615                            assoc_num);
 616                 err = -EINVAL;
 617                 goto out;
 618         }
 619
 620         if (tx_sa->active == ctx_tx_sa->active)
 621                 goto out;
 622
 623         if (tx_sa->assoc_num != tx_sc->encoding_sa)
 624                 goto out;
 625
 626         if (ctx_tx_sa->active) {
 627                 err = mlx5e_macsec_init_sa(ctx, tx_sa, tx_sc->encrypt, true);
 628                 if (err)
 629                         goto out;
 630         } else {
 631                 if (!tx_sa->macsec_rule) {
 632                         err = -EINVAL;
 633                         goto out;
 634                 }
 635
 636                 mlx5e_macsec_cleanup_sa(macsec, tx_sa, true);
 637         }
 638
 639         tx_sa->active = ctx_tx_sa->active;
 640 out:
 641         mutex_unlock(&macsec->lock);
 642
 643         return err;
 644 }
 645
 646 static int mlx5e_macsec_del_txsa(struct macsec_context *ctx)
 647 {
 648         struct mlx5e_priv *priv = netdev_priv(ctx->netdev);
 649         struct mlx5e_macsec_device *macsec_device;
 650         u8 assoc_num = ctx->sa.assoc_num;
 651         struct mlx5e_macsec_sa *tx_sa;
 652         struct mlx5e_macsec *macsec;
 653         int err = 0;
 654
 655         mutex_lock(&priv->macsec->lock);
 656         macsec = priv->macsec;
 657         macsec_device = mlx5e_macsec_get_macsec_device_context(macsec, ctx);
 658         if (!macsec_device) {
 659                 netdev_err(ctx->netdev, "MACsec offload: Failed to find device context\n");
 660                 err = -EINVAL;
 661                 goto out;
 662         }
 663
 664         tx_sa = macsec_device->tx_sa[assoc_num];
 665         if (!tx_sa) {
 666                 netdev_err(ctx->netdev, "MACsec offload: TX sa 0x%x doesn't exist\n", assoc_num);
 667                 err = -EEXIST;
 668                 goto out;
 669         }
 670
 671         mlx5e_macsec_cleanup_sa(macsec, tx_sa, true);
 672         mlx5_destroy_encryption_key(macsec->mdev, tx_sa->enc_key_id);
 673         kfree_rcu(tx_sa);
 674         macsec_device->tx_sa[assoc_num] = NULL;
 675
 676 out:
 677         mutex_unlock(&macsec->lock);
 678
 679         return err;
 680 }
 681
 682 static u32 mlx5e_macsec_get_sa_from_hashtable(struct rhashtable *sci_hash, sci_t *sci)
 683 {
 684         struct mlx5e_macsec_sa *macsec_sa;
 685         u32 fs_id = 0;
 686
 687         rcu_read_lock();
 688         macsec_sa = rhashtable_lookup(sci_hash, sci, rhash_sci);
 689         if (macsec_sa)
 690                 fs_id = macsec_sa->fs_id;
 691         rcu_read_unlock();
 692
 693         return fs_id;
 694 }
 695
 696 static int mlx5e_macsec_add_rxsc(struct macsec_context *ctx)
 697 {
 698         struct mlx5e_macsec_rx_sc_xarray_element *sc_xarray_element;
 699         struct mlx5e_priv *priv = netdev_priv(ctx->netdev);
 700         const struct macsec_rx_sc *ctx_rx_sc = ctx->rx_sc;
 701         struct mlx5e_macsec_device *macsec_device;
 702         struct mlx5e_macsec_rx_sc *rx_sc;
 703         struct list_head *rx_sc_list;
 704         struct mlx5e_macsec *macsec;
 705         int err = 0;
 706
 707         mutex_lock(&priv->macsec->lock);
 708         macsec = priv->macsec;
 709         macsec_device = mlx5e_macsec_get_macsec_device_context(macsec, ctx);
 710         if (!macsec_device) {
 711                 netdev_err(ctx->netdev, "MACsec offload: Failed to find device context\n");
 712                 err = -EINVAL;
 713                 goto out;
 714         }
 715
 716         rx_sc_list = &macsec_device->macsec_rx_sc_list_head;
 717         rx_sc = mlx5e_macsec_get_rx_sc_from_sc_list(rx_sc_list, ctx_rx_sc->sci);
 718         if (rx_sc) {
 719                 netdev_err(ctx->netdev, "MACsec offload: rx_sc (sci %lld) already exists\n",
 720                            ctx_rx_sc->sci);
 721                 err = -EEXIST;
 722                 goto out;
 723         }
 724
 725         rx_sc = kzalloc(sizeof(*rx_sc), GFP_KERNEL);
 726         if (!rx_sc) {
 727                 err = -ENOMEM;
 728                 goto out;
 729         }
 730
 731         sc_xarray_element = kzalloc(sizeof(*sc_xarray_element), GFP_KERNEL);
 732         if (!sc_xarray_element) {
 733                 err = -ENOMEM;
 734                 goto destroy_rx_sc;
 735         }
 736
 737         sc_xarray_element->rx_sc = rx_sc;
 738         err = xa_alloc(&macsec->sc_xarray, &sc_xarray_element->fs_id, sc_xarray_element,
 739                        XA_LIMIT(1, USHRT_MAX), GFP_KERNEL);
 740         if (err)
 741                 goto destroy_sc_xarray_elemenet;
 742
 743         rx_sc->md_dst = metadata_dst_alloc(0, METADATA_MACSEC, GFP_KERNEL);
 744         if (!rx_sc->md_dst) {
 745                 err = -ENOMEM;
 746                 goto erase_xa_alloc;
 747         }
 748
 749         rx_sc->sci = ctx_rx_sc->sci;
 750         rx_sc->active = ctx_rx_sc->active;
 751         list_add_rcu(&rx_sc->rx_sc_list_element, rx_sc_list);
 752
 753         rx_sc->sc_xarray_element = sc_xarray_element;
 754         rx_sc->md_dst->u.macsec_info.sci = rx_sc->sci;
 755         mutex_unlock(&macsec->lock);
 756
 757         return 0;
 758
 759 erase_xa_alloc:
 760         xa_erase(&macsec->sc_xarray, sc_xarray_element->fs_id);
 761 destroy_sc_xarray_elemenet:
 762         kfree(sc_xarray_element);
 763 destroy_rx_sc:
 764         kfree(rx_sc);
 765
 766 out:
 767         mutex_unlock(&macsec->lock);
 768
 769         return err;
 770 }
 771
 772 static int mlx5e_macsec_upd_rxsc(struct macsec_context *ctx)
 773 {
 774         struct mlx5e_priv *priv = netdev_priv(ctx->netdev);
 775         const struct macsec_rx_sc *ctx_rx_sc = ctx->rx_sc;
 776         struct mlx5e_macsec_device *macsec_device;
 777         struct mlx5e_macsec_rx_sc *rx_sc;
 778         struct mlx5e_macsec_sa *rx_sa;
 779         struct mlx5e_macsec *macsec;
 780         struct list_head *list;
 781         int i;
 782         int err = 0;
 783
 784         mutex_lock(&priv->macsec->lock);
 785
 786         macsec = priv->macsec;
 787         macsec_device = mlx5e_macsec_get_macsec_device_context(macsec, ctx);
 788         if (!macsec_device) {
 789                 netdev_err(ctx->netdev, "MACsec offload: Failed to find device context\n");
 790                 err = -EINVAL;
 791                 goto out;
 792         }
 793
 794         list = &macsec_device->macsec_rx_sc_list_head;
 795         rx_sc = mlx5e_macsec_get_rx_sc_from_sc_list(list, ctx_rx_sc->sci);
 796         if (!rx_sc) {
 797                 err = -EINVAL;
 798                 goto out;
 799         }
 800
 801         rx_sc->active = ctx_rx_sc->active;
 802         if (rx_sc->active == ctx_rx_sc->active)
 803                 goto out;
 804
 805         for (i = 0; i < MACSEC_NUM_AN; ++i) {
 806                 rx_sa = rx_sc->rx_sa[i];
 807                 if (!rx_sa)
 808                         continue;
 809
 810                 err = mlx5e_macsec_update_rx_sa(macsec, rx_sa, rx_sa->active && ctx_rx_sc->active);
 811                 if (err)
 812                         goto out;
 813         }
 814
 815 out:
 816         mutex_unlock(&macsec->lock);
 817
 818         return err;
 819 }
 820
 821 static int mlx5e_macsec_del_rxsc(struct macsec_context *ctx)
 822 {
 823         struct mlx5e_priv *priv = netdev_priv(ctx->netdev);
 824         struct mlx5e_macsec_device *macsec_device;
 825         struct mlx5e_macsec_rx_sc *rx_sc;
 826         struct mlx5e_macsec_sa *rx_sa;
 827         struct mlx5e_macsec *macsec;
 828         struct list_head *list;
 829         int err = 0;
 830         int i;
 831
 832         mutex_lock(&priv->macsec->lock);
 833
 834         macsec = priv->macsec;
 835         macsec_device = mlx5e_macsec_get_macsec_device_context(macsec, ctx);
 836         if (!macsec_device) {
 837                 netdev_err(ctx->netdev, "MACsec offload: Failed to find device context\n");
 838                 err = -EINVAL;
 839                 goto out;
 840         }
 841
 842         list = &macsec_device->macsec_rx_sc_list_head;
 843         rx_sc = mlx5e_macsec_get_rx_sc_from_sc_list(list, ctx->rx_sc->sci);
 844         if (!rx_sc) {
 845                 netdev_err(ctx->netdev,
 846                            "MACsec offload rx_sc sci %lld doesn't exist\n",
 847                            ctx->sa.rx_sa->sc->sci);
 848                 err = -EINVAL;
 849                 goto out;
 850         }
 851
 852         for (i = 0; i < MACSEC_NUM_AN; ++i) {
 853                 rx_sa = rx_sc->rx_sa[i];
 854                 if (!rx_sa)
 855                         continue;
 856
 857                 mlx5e_macsec_cleanup_sa(macsec, rx_sa, false);
 858                 mlx5_destroy_encryption_key(macsec->mdev, rx_sa->enc_key_id);
 859
 860                 kfree(rx_sa);
 861                 rx_sc->rx_sa[i] = NULL;
 862         }
 863
 864 /*
 865  * At this point the relevant MACsec offload Rx rule already removed at
 866  * mlx5e_macsec_cleanup_sa need to wait for datapath to finish current
 867  * Rx related data propagating using xa_erase which uses rcu to sync,
 868  * once fs_id is erased then this rx_sc is hidden from datapath.
 869  */
 870         list_del_rcu(&rx_sc->rx_sc_list_element);
 871         xa_erase(&macsec->sc_xarray, rx_sc->sc_xarray_element->fs_id);
 872         metadata_dst_free(rx_sc->md_dst);
 873         kfree(rx_sc->sc_xarray_element);
 874
 875         kfree_rcu(rx_sc);
 876
 877 out:
 878         mutex_unlock(&macsec->lock);
 879
 880         return err;
 881 }
 882
 883 static int mlx5e_macsec_add_rxsa(struct macsec_context *ctx)
 884 {
 885         const struct macsec_rx_sa *ctx_rx_sa = ctx->sa.rx_sa;
 886         struct mlx5e_priv *priv = netdev_priv(ctx->netdev);
 887         struct mlx5e_macsec_device *macsec_device;
 888         struct mlx5_core_dev *mdev = priv->mdev;
 889         u8 assoc_num = ctx->sa.assoc_num;
 890         struct mlx5e_macsec_rx_sc *rx_sc;
 891         sci_t sci = ctx_rx_sa->sc->sci;
 892         struct mlx5e_macsec_sa *rx_sa;
 893         struct mlx5e_macsec *macsec;
 894         struct list_head *list;
 895         int err = 0;
 896
 897         mutex_lock(&priv->macsec->lock);
 898
 899         macsec = priv->macsec;
 900         macsec_device = mlx5e_macsec_get_macsec_device_context(macsec, ctx);
 901         if (!macsec_device) {
 902                 netdev_err(ctx->netdev, "MACsec offload: Failed to find device context\n");
 903                 err = -EINVAL;
 904                 goto out;
 905         }
 906
 907         list = &macsec_device->macsec_rx_sc_list_head;
 908         rx_sc = mlx5e_macsec_get_rx_sc_from_sc_list(list, sci);
 909         if (!rx_sc) {
 910                 netdev_err(ctx->netdev,
 911                            "MACsec offload rx_sc sci %lld doesn't exist\n",
 912                            ctx->sa.rx_sa->sc->sci);
 913                 err = -EINVAL;
 914                 goto out;
 915         }
 916
 917         if (rx_sc->rx_sa[assoc_num]) {
 918                 netdev_err(ctx->netdev,
 919                            "MACsec offload rx_sc sci %lld rx_sa %d already exist\n",
 920                            sci, assoc_num);
 921                 err = -EEXIST;
 922                 goto out;
 923         }
 924
 925         rx_sa = kzalloc(sizeof(*rx_sa), GFP_KERNEL);
 926         if (!rx_sa) {
 927                 err = -ENOMEM;
 928                 goto out;
 929         }
 930
 931         rx_sa->active = ctx_rx_sa->active;
 932         rx_sa->next_pn = ctx_rx_sa->next_pn;
 933         rx_sa->sci = sci;
 934         rx_sa->assoc_num = assoc_num;
 935         rx_sa->fs_id = rx_sc->sc_xarray_element->fs_id;
 936
 937         if (ctx->secy->xpn)
 938                 update_macsec_epn(rx_sa, &ctx_rx_sa->key, &ctx_rx_sa->next_pn_halves);
 939
 940         err = mlx5_create_encryption_key(mdev, ctx->sa.key, ctx->secy->key_len,
 941                                          MLX5_ACCEL_OBJ_MACSEC_KEY,
 942                                          &rx_sa->enc_key_id);
 943         if (err)
 944                 goto destroy_sa;
 945
 946         rx_sc->rx_sa[assoc_num] = rx_sa;
 947         if (!rx_sa->active)
 948                 goto out;
 949
 950         //TODO - add support for both authentication and encryption flows
 951         err = mlx5e_macsec_init_sa(ctx, rx_sa, true, false);
 952         if (err)
 953                 goto destroy_encryption_key;
 954
 955         goto out;
 956
 957 destroy_encryption_key:
 958         rx_sc->rx_sa[assoc_num] = NULL;
 959         mlx5_destroy_encryption_key(mdev, rx_sa->enc_key_id);
 960 destroy_sa:
 961         kfree(rx_sa);
 962 out:
 963         mutex_unlock(&macsec->lock);
 964
 965         return err;
 966 }
 967
 968 static int mlx5e_macsec_upd_rxsa(struct macsec_context *ctx)
 969 {
 970         const struct macsec_rx_sa *ctx_rx_sa = ctx->sa.rx_sa;
 971         struct mlx5e_priv *priv = netdev_priv(ctx->netdev);
 972         struct mlx5e_macsec_device *macsec_device;
 973         u8 assoc_num = ctx->sa.assoc_num;
 974         struct mlx5e_macsec_rx_sc *rx_sc;
 975         sci_t sci = ctx_rx_sa->sc->sci;
 976         struct mlx5e_macsec_sa *rx_sa;
 977         struct mlx5e_macsec *macsec;
 978         struct list_head *list;
 979         int err = 0;
 980
 981         mutex_lock(&priv->macsec->lock);
 982
 983         macsec = priv->macsec;
 984         macsec_device = mlx5e_macsec_get_macsec_device_context(macsec, ctx);
 985         if (!macsec_device) {
 986                 netdev_err(ctx->netdev, "MACsec offload: Failed to find device context\n");
 987                 err = -EINVAL;
 988                 goto out;
 989         }
 990
 991         list = &macsec_device->macsec_rx_sc_list_head;
 992         rx_sc = mlx5e_macsec_get_rx_sc_from_sc_list(list, sci);
 993         if (!rx_sc) {
 994                 netdev_err(ctx->netdev,
 995                            "MACsec offload rx_sc sci %lld doesn't exist\n",
 996                            ctx->sa.rx_sa->sc->sci);
 997                 err = -EINVAL;
 998                 goto out;
 999         }
1000
1001         rx_sa = rx_sc->rx_sa[assoc_num];
1002         if (rx_sa) {
1003                 netdev_err(ctx->netdev,
1004                            "MACsec offload rx_sc sci %lld rx_sa %d already exist\n",
1005                            sci, assoc_num);
1006                 err = -EEXIST;
1007                 goto out;
1008         }
1009
1010         if (rx_sa->next_pn != ctx_rx_sa->next_pn_halves.lower) {
1011                 netdev_err(ctx->netdev,
1012                            "MACsec offload update RX sa %d PN isn't supported\n",
1013                            assoc_num);
1014                 err = -EINVAL;
1015                 goto out;
1016         }
1017
1018         err = mlx5e_macsec_update_rx_sa(macsec, rx_sa, ctx_rx_sa->active);
1019 out:
1020         mutex_unlock(&macsec->lock);
1021
1022         return err;
1023 }
1024
1025 static int mlx5e_macsec_del_rxsa(struct macsec_context *ctx)
1026 {
1027         struct mlx5e_priv *priv = netdev_priv(ctx->netdev);
1028         struct mlx5e_macsec_device *macsec_device;
1029         sci_t sci = ctx->sa.rx_sa->sc->sci;
1030         struct mlx5e_macsec_rx_sc *rx_sc;
1031         u8 assoc_num = ctx->sa.assoc_num;
1032         struct mlx5e_macsec_sa *rx_sa;
1033         struct mlx5e_macsec *macsec;
1034         struct list_head *list;
1035         int err = 0;
1036
1037         mutex_lock(&priv->macsec->lock);
1038
1039         macsec = priv->macsec;
1040         macsec_device = mlx5e_macsec_get_macsec_device_context(macsec, ctx);
1041         if (!macsec_device) {
1042                 netdev_err(ctx->netdev, "MACsec offload: Failed to find device context\n");
1043                 err = -EINVAL;
1044                 goto out;
1045         }
1046
1047         list = &macsec_device->macsec_rx_sc_list_head;
1048         rx_sc = mlx5e_macsec_get_rx_sc_from_sc_list(list, sci);
1049         if (!rx_sc) {
1050                 netdev_err(ctx->netdev,
1051                            "MACsec offload rx_sc sci %lld doesn't exist\n",
1052                            ctx->sa.rx_sa->sc->sci);
1053                 err = -EINVAL;
1054                 goto out;
1055         }
1056
1057         rx_sa = rx_sc->rx_sa[assoc_num];
1058         if (rx_sa) {
1059                 netdev_err(ctx->netdev,
1060                            "MACsec offload rx_sc sci %lld rx_sa %d already exist\n",
1061                            sci, assoc_num);
1062                 err = -EEXIST;
1063                 goto out;
1064         }
1065
1066         mlx5e_macsec_cleanup_sa(macsec, rx_sa, false);
1067         mlx5_destroy_encryption_key(macsec->mdev, rx_sa->enc_key_id);
1068         kfree(rx_sa);
1069         rx_sc->rx_sa[assoc_num] = NULL;
1070
1071 out:
1072         mutex_unlock(&macsec->lock);
1073
1074         return err;
1075 }
1076
1077 static int mlx5e_macsec_add_secy(struct macsec_context *ctx)
1078 {
1079         struct mlx5e_priv *priv = netdev_priv(ctx->netdev);
1080         const struct net_device *dev = ctx->secy->netdev;
1081         const struct net_device *netdev = ctx->netdev;
1082         struct mlx5e_macsec_device *macsec_device;
1083         struct mlx5e_macsec *macsec;
1084         int err = 0;
1085
1086         if (!mlx5e_macsec_secy_features_validate(ctx))
1087                 return -EINVAL;
1088
1089         mutex_lock(&priv->macsec->lock);
1090         macsec = priv->macsec;
1091         if (mlx5e_macsec_get_macsec_device_context(macsec, ctx)) {
1092                 netdev_err(netdev, "MACsec offload: MACsec net_device already exist\n");
1093                 goto out;
1094         }
1095
1096         if (macsec->num_of_devices >= MLX5_MACSEC_NUM_OF_SUPPORTED_INTERFACES) {
1097                 netdev_err(netdev, "Currently, only %d MACsec offload devices can be set\n",
1098                            MLX5_MACSEC_NUM_OF_SUPPORTED_INTERFACES);
1099                 err = -EBUSY;
1100                 goto out;
1101         }
1102
1103         macsec_device = kzalloc(sizeof(*macsec_device), GFP_KERNEL);
1104         if (!macsec_device) {
1105                 err = -ENOMEM;
1106                 goto out;
1107         }
1108
1109         macsec_device->dev_addr = kmemdup(dev->dev_addr, dev->addr_len, GFP_KERNEL);
1110         if (!macsec_device->dev_addr) {
1111                 kfree(macsec_device);
1112                 err = -ENOMEM;
1113                 goto out;
1114         }
1115
1116         macsec_device->netdev = dev;
1117
1118         INIT_LIST_HEAD_RCU(&macsec_device->macsec_rx_sc_list_head);
1119         list_add_rcu(&macsec_device->macsec_device_list_element, &macsec->macsec_device_list_head);
1120
1121         ++macsec->num_of_devices;
1122 out:
1123         mutex_unlock(&macsec->lock);
1124
1125         return err;
1126 }
1127
1128 static int macsec_upd_secy_hw_address(struct macsec_context *ctx,
1129                                       struct mlx5e_macsec_device *macsec_device)
1130 {
1131         struct mlx5e_priv *priv = netdev_priv(ctx->netdev);
1132         const struct net_device *dev = ctx->secy->netdev;
1133         struct mlx5e_macsec *macsec = priv->macsec;
1134         struct mlx5e_macsec_rx_sc *rx_sc, *tmp;
1135         struct mlx5e_macsec_sa *rx_sa;
1136         struct list_head *list;
1137         int i, err = 0;
1138
1139
1140         list = &macsec_device->macsec_rx_sc_list_head;
1141         list_for_each_entry_safe(rx_sc, tmp, list, rx_sc_list_element) {
1142                 for (i = 0; i < MACSEC_NUM_AN; ++i) {
1143                         rx_sa = rx_sc->rx_sa[i];
1144                         if (!rx_sa || !rx_sa->macsec_rule)
1145                                 continue;
1146
1147                         mlx5e_macsec_cleanup_sa(macsec, rx_sa, false);
1148                 }
1149         }
1150
1151         list_for_each_entry_safe(rx_sc, tmp, list, rx_sc_list_element) {
1152                 for (i = 0; i < MACSEC_NUM_AN; ++i) {
1153                         rx_sa = rx_sc->rx_sa[i];
1154                         if (!rx_sa)
1155                                 continue;
1156
1157                         if (rx_sa->active) {
1158                                 err = mlx5e_macsec_init_sa(ctx, rx_sa, false, false);
1159                                 if (err)
1160                                         goto out;
1161                         }
1162                 }
1163         }
1164
1165         memcpy(macsec_device->dev_addr, dev->dev_addr, dev->addr_len);
1166 out:
1167         return err;
1168 }
1169
1170 /* this function is called from 2 macsec ops functions:
1171  *  macsec_set_mac_address – MAC address was changed, therefore we need to destroy
1172  *  and create new Tx contexts(macsec object + steering).
1173  *  macsec_changelink – in this case the tx SC or SecY may be changed, therefore need to
1174  *  destroy Tx and Rx contexts(macsec object + steering)
1175  */
1176 static int mlx5e_macsec_upd_secy(struct macsec_context *ctx)
1177 {
1178         const struct macsec_tx_sc *tx_sc = &ctx->secy->tx_sc;
1179         struct mlx5e_priv *priv = netdev_priv(ctx->netdev);
1180         const struct net_device *dev = ctx->secy->netdev;
1181         struct mlx5e_macsec_device *macsec_device;
1182         struct mlx5e_macsec_sa *tx_sa;
1183         struct mlx5e_macsec *macsec;
1184         int i, err = 0;
1185
1186         if (!mlx5e_macsec_secy_features_validate(ctx))
1187                 return -EINVAL;
1188
1189         mutex_lock(&priv->macsec->lock);
1190
1191         macsec = priv->macsec;
1192         macsec_device = mlx5e_macsec_get_macsec_device_context(macsec, ctx);
1193         if (!macsec_device) {
1194                 netdev_err(ctx->netdev, "MACsec offload: Failed to find device context\n");
1195                 err = -EINVAL;
1196                 goto out;
1197         }
1198
1199         /* if the dev_addr hasn't change, it mean the callback is from macsec_changelink */
1200         if (!memcmp(macsec_device->dev_addr, dev->dev_addr, dev->addr_len)) {
1201                 err = macsec_upd_secy_hw_address(ctx, macsec_device);
1202                 if (err)
1203                         goto out;
1204         }
1205
1206         for (i = 0; i < MACSEC_NUM_AN; ++i) {
1207                 tx_sa = macsec_device->tx_sa[i];
1208                 if (!tx_sa)
1209                         continue;
1210
1211                 mlx5e_macsec_cleanup_sa(macsec, tx_sa, true);
1212         }
1213
1214         for (i = 0; i < MACSEC_NUM_AN; ++i) {
1215                 tx_sa = macsec_device->tx_sa[i];
1216                 if (!tx_sa)
1217                         continue;
1218
1219                 if (tx_sa->assoc_num == tx_sc->encoding_sa && tx_sa->active) {
1220                         err = mlx5e_macsec_init_sa(ctx, tx_sa, tx_sc->encrypt, true);
1221                         if (err)
1222                                 goto out;
1223                 }
1224         }
1225
1226 out:
1227         mutex_unlock(&macsec->lock);
1228
1229         return err;
1230 }
1231
1232 static int mlx5e_macsec_del_secy(struct macsec_context *ctx)
1233 {
1234         struct mlx5e_priv *priv = netdev_priv(ctx->netdev);
1235         struct mlx5e_macsec_device *macsec_device;
1236         struct mlx5e_macsec_rx_sc *rx_sc, *tmp;
1237         struct mlx5e_macsec_sa *rx_sa;
1238         struct mlx5e_macsec_sa *tx_sa;
1239         struct mlx5e_macsec *macsec;
1240         struct list_head *list;
1241         int err = 0;
1242         int i;
1243
1244         mutex_lock(&priv->macsec->lock);
1245         macsec = priv->macsec;
1246         macsec_device = mlx5e_macsec_get_macsec_device_context(macsec, ctx);
1247         if (!macsec_device) {
1248                 netdev_err(ctx->netdev, "MACsec offload: Failed to find device context\n");
1249                 err = -EINVAL;
1250
1251                 goto out;
1252         }
1253
1254         for (i = 0; i < MACSEC_NUM_AN; ++i) {
1255                 tx_sa = macsec_device->tx_sa[i];
1256                 if (!tx_sa)
1257                         continue;
1258
1259                 mlx5e_macsec_cleanup_sa(macsec, tx_sa, true);
1260                 mlx5_destroy_encryption_key(macsec->mdev, tx_sa->enc_key_id);
1261                 kfree(tx_sa);
1262                 macsec_device->tx_sa[i] = NULL;
1263         }
1264
1265         list = &macsec_device->macsec_rx_sc_list_head;
1266         list_for_each_entry_safe(rx_sc, tmp, list, rx_sc_list_element) {
1267                 for (i = 0; i < MACSEC_NUM_AN; ++i) {
1268                         rx_sa = rx_sc->rx_sa[i];
1269                         if (!rx_sa)
1270                                 continue;
1271
1272                         mlx5e_macsec_cleanup_sa(macsec, rx_sa, false);
1273                         mlx5_destroy_encryption_key(macsec->mdev, rx_sa->enc_key_id);
1274                         kfree(rx_sa);
1275                         rx_sc->rx_sa[i] = NULL;
1276                 }
1277
1278                 list_del_rcu(&rx_sc->rx_sc_list_element);
1279
1280                 kfree_rcu(rx_sc);
1281         }
1282
1283         kfree(macsec_device->dev_addr);
1284         macsec_device->dev_addr = NULL;
1285
1286         list_del_rcu(&macsec_device->macsec_device_list_element);
1287         --macsec->num_of_devices;
1288
1289 out:
1290         mutex_unlock(&macsec->lock);
1291
1292         return err;
1293 }
1294
1295 static void macsec_build_accel_attrs(struct mlx5e_macsec_sa *sa,
1296                                      struct mlx5_macsec_obj_attrs *attrs)
1297 {
1298         attrs->epn_state.epn_msb = sa->epn_state.epn_msb;
1299         attrs->epn_state.overlap = sa->epn_state.overlap;
1300 }
1301
1302 static void macsec_aso_build_wqe_ctrl_seg(struct mlx5e_macsec_aso *macsec_aso,
1303                                           struct mlx5_wqe_aso_ctrl_seg *aso_ctrl,
1304                                           struct mlx5_aso_ctrl_param *param)
1305 {
1306         memset(aso_ctrl, 0, sizeof(*aso_ctrl));
1307         if (macsec_aso->umr->dma_addr) {
1308                 aso_ctrl->va_l  = cpu_to_be32(macsec_aso->umr->dma_addr | ASO_CTRL_READ_EN);
1309                 aso_ctrl->va_h  = cpu_to_be32((u64)macsec_aso->umr->dma_addr >> 32);
1310                 aso_ctrl->l_key = cpu_to_be32(macsec_aso->umr->mkey);
1311         }
1312
1313         if (!param)
1314                 return;
1315
1316         aso_ctrl->data_mask_mode = param->data_mask_mode << 6;
1317         aso_ctrl->condition_1_0_operand = param->condition_1_operand |
1318                                                 param->condition_0_operand << 4;
1319         aso_ctrl->condition_1_0_offset = param->condition_1_offset |
1320                                                 param->condition_0_offset << 4;
1321         aso_ctrl->data_offset_condition_operand = param->data_offset |
1322                                                 param->condition_operand << 6;
1323         aso_ctrl->condition_0_data = cpu_to_be32(param->condition_0_data);
1324         aso_ctrl->condition_0_mask = cpu_to_be32(param->condition_0_mask);
1325         aso_ctrl->condition_1_data = cpu_to_be32(param->condition_1_data);
1326         aso_ctrl->condition_1_mask = cpu_to_be32(param->condition_1_mask);
1327         aso_ctrl->bitwise_data = cpu_to_be64(param->bitwise_data);
1328         aso_ctrl->data_mask = cpu_to_be64(param->data_mask);
1329 }
1330
1331 static int mlx5e_macsec_modify_obj(struct mlx5_core_dev *mdev, struct mlx5_macsec_obj_attrs *attrs,
1332                                    u32 macsec_id)
1333 {
1334         u32 in[MLX5_ST_SZ_DW(modify_macsec_obj_in)] = {};
1335         u32 out[MLX5_ST_SZ_DW(query_macsec_obj_out)];
1336         u64 modify_field_select = 0;
1337         void *obj;
1338         int err;
1339
1340         /* General object fields set */
1341         MLX5_SET(general_obj_in_cmd_hdr, in, opcode, MLX5_CMD_OP_QUERY_GENERAL_OBJECT);
1342         MLX5_SET(general_obj_in_cmd_hdr, in, obj_type, MLX5_GENERAL_OBJECT_TYPES_MACSEC);
1343         MLX5_SET(general_obj_in_cmd_hdr, in, obj_id, macsec_id);
1344         err = mlx5_cmd_exec(mdev, in, sizeof(in), out, sizeof(out));
1345         if (err) {
1346                 mlx5_core_err(mdev, "Query MACsec object failed (Object id %d), err = %d\n",
1347                               macsec_id, err);
1348                 return err;
1349         }
1350
1351         obj = MLX5_ADDR_OF(query_macsec_obj_out, out, macsec_object);
1352         modify_field_select = MLX5_GET64(macsec_offload_obj, obj, modify_field_select);
1353
1354         /* EPN */
1355         if (!(modify_field_select & MLX5_MODIFY_MACSEC_BITMASK_EPN_OVERLAP) ||
1356             !(modify_field_select & MLX5_MODIFY_MACSEC_BITMASK_EPN_MSB)) {
1357                 mlx5_core_dbg(mdev, "MACsec object field is not modifiable (Object id %d)\n",
1358                               macsec_id);
1359                 return -EOPNOTSUPP;
1360         }
1361
1362         obj = MLX5_ADDR_OF(modify_macsec_obj_in, in, macsec_object);
1363         MLX5_SET64(macsec_offload_obj, obj, modify_field_select,
1364                    MLX5_MODIFY_MACSEC_BITMASK_EPN_OVERLAP | MLX5_MODIFY_MACSEC_BITMASK_EPN_MSB);
1365         MLX5_SET(macsec_offload_obj, obj, epn_msb, attrs->epn_state.epn_msb);
1366         MLX5_SET(macsec_offload_obj, obj, epn_overlap, attrs->epn_state.overlap);
1367
1368         /* General object fields set */
1369         MLX5_SET(general_obj_in_cmd_hdr, in, opcode, MLX5_CMD_OP_MODIFY_GENERAL_OBJECT);
1370
1371         return mlx5_cmd_exec(mdev, in, sizeof(in), out, sizeof(out));
1372 }
1373
1374 static void macsec_aso_build_ctrl(struct mlx5e_macsec_aso *aso,
1375                                   struct mlx5_wqe_aso_ctrl_seg *aso_ctrl,
1376                                   struct mlx5e_macsec_aso_in *in)
1377 {
1378         struct mlx5_aso_ctrl_param param = {};
1379
1380         param.data_mask_mode = MLX5_ASO_DATA_MASK_MODE_BITWISE_64BIT;
1381         param.condition_0_operand = MLX5_ASO_ALWAYS_TRUE;
1382         param.condition_1_operand = MLX5_ASO_ALWAYS_TRUE;
1383         if (in->mode == MLX5_MACSEC_EPN) {
1384                 param.data_offset = MLX5_MACSEC_ASO_REMOVE_FLOW_PKT_CNT_OFFSET;
1385                 param.bitwise_data = BIT_ULL(54);
1386                 param.data_mask = param.bitwise_data;
1387         }
1388         macsec_aso_build_wqe_ctrl_seg(aso, aso_ctrl, &param);
1389 }
1390
1391 static int macsec_aso_set_arm_event(struct mlx5_core_dev *mdev, struct mlx5e_macsec *macsec,
1392                                     struct mlx5e_macsec_aso_in *in)
1393 {
1394         struct mlx5e_macsec_aso *aso;
1395         struct mlx5_aso_wqe *aso_wqe;
1396         struct mlx5_aso *maso;
1397         int err;
1398
1399         aso = &macsec->aso;
1400         maso = aso->maso;
1401
1402         mutex_lock(&aso->aso_lock);
1403         aso_wqe = mlx5_aso_get_wqe(maso);
1404         mlx5_aso_build_wqe(maso, MLX5_MACSEC_ASO_DS_CNT, aso_wqe, in->obj_id,
1405                            MLX5_ACCESS_ASO_OPC_MOD_MACSEC);
1406         macsec_aso_build_ctrl(aso, &aso_wqe->aso_ctrl, in);
1407         mlx5_aso_post_wqe(maso, false, &aso_wqe->ctrl);
1408         err = mlx5_aso_poll_cq(maso, false, 10);
1409         mutex_unlock(&aso->aso_lock);
1410
1411         return err;
1412 }
1413
1414 static int macsec_aso_query(struct mlx5_core_dev *mdev, struct mlx5e_macsec *macsec,
1415                             struct mlx5e_macsec_aso_in *in, struct mlx5e_macsec_aso_out *out)
1416 {
1417         struct mlx5e_macsec_aso *aso;
1418         struct mlx5_aso_wqe *aso_wqe;
1419         struct mlx5_aso *maso;
1420         int err;
1421
1422         aso = &macsec->aso;
1423         maso = aso->maso;
1424
1425         mutex_lock(&aso->aso_lock);
1426
1427         aso_wqe = mlx5_aso_get_wqe(maso);
1428         mlx5_aso_build_wqe(maso, MLX5_MACSEC_ASO_DS_CNT, aso_wqe, in->obj_id,
1429                            MLX5_ACCESS_ASO_OPC_MOD_MACSEC);
1430         macsec_aso_build_wqe_ctrl_seg(aso, &aso_wqe->aso_ctrl, NULL);
1431
1432         mlx5_aso_post_wqe(maso, false, &aso_wqe->ctrl);
1433         err = mlx5_aso_poll_cq(maso, false, 10);
1434         if (err)
1435                 goto err_out;
1436
1437         if (MLX5_GET(macsec_aso, aso->umr->ctx, epn_event_arm))
1438                 out->event_arm |= MLX5E_ASO_EPN_ARM;
1439
1440         out->mode_param = MLX5_GET(macsec_aso, aso->umr->ctx, mode_parameter);
1441
1442 err_out:
1443         mutex_unlock(&aso->aso_lock);
1444         return err;
1445 }
1446
1447 static struct mlx5e_macsec_sa *get_macsec_tx_sa_from_obj_id(const struct mlx5e_macsec *macsec,
1448                                                             const u32 obj_id)
1449 {
1450         const struct list_head *device_list;
1451         struct mlx5e_macsec_sa *macsec_sa;
1452         struct mlx5e_macsec_device *iter;
1453         int i;
1454
1455         device_list = &macsec->macsec_device_list_head;
1456
1457         list_for_each_entry(iter, device_list, macsec_device_list_element) {
1458                 for (i = 0; i < MACSEC_NUM_AN; ++i) {
1459                         macsec_sa = iter->tx_sa[i];
1460                         if (!macsec_sa || !macsec_sa->active)
1461                                 continue;
1462                         if (macsec_sa->macsec_obj_id == obj_id)
1463                                 return macsec_sa;
1464                 }
1465         }
1466
1467         return NULL;
1468 }
1469
1470 static struct mlx5e_macsec_sa *get_macsec_rx_sa_from_obj_id(const struct mlx5e_macsec *macsec,
1471                                                             const u32 obj_id)
1472 {
1473         const struct list_head *device_list, *sc_list;
1474         struct mlx5e_macsec_rx_sc *mlx5e_rx_sc;
1475         struct mlx5e_macsec_sa *macsec_sa;
1476         struct mlx5e_macsec_device *iter;
1477         int i;
1478
1479         device_list = &macsec->macsec_device_list_head;
1480
1481         list_for_each_entry(iter, device_list, macsec_device_list_element) {
1482                 sc_list = &iter->macsec_rx_sc_list_head;
1483                 list_for_each_entry(mlx5e_rx_sc, sc_list, rx_sc_list_element) {
1484                         for (i = 0; i < MACSEC_NUM_AN; ++i) {
1485                                 macsec_sa = mlx5e_rx_sc->rx_sa[i];
1486                                 if (!macsec_sa || !macsec_sa->active)
1487                                         continue;
1488                                 if (macsec_sa->macsec_obj_id == obj_id)
1489                                         return macsec_sa;
1490                         }
1491                 }
1492         }
1493
1494         return NULL;
1495 }
1496
1497 static void macsec_epn_update(struct mlx5e_macsec *macsec, struct mlx5_core_dev *mdev,
1498                               struct mlx5e_macsec_sa *sa, u32 obj_id, u32 mode_param)
1499 {
1500         struct mlx5_macsec_obj_attrs attrs = {};
1501         struct mlx5e_macsec_aso_in in = {};
1502
1503         /* When the bottom of the replay protection window (mode_param) crosses 2^31 (half sequence
1504          * number wraparound) hence mode_param > MLX5_MACSEC_EPN_SCOPE_MID the SW should update the
1505          * esn_overlap to OLD (1).
1506          * When the bottom of the replay protection window (mode_param) crosses 2^32 (full sequence
1507          * number wraparound) hence mode_param < MLX5_MACSEC_EPN_SCOPE_MID since it did a
1508          * wraparound, the SW should update the esn_overlap to NEW (0), and increment the esn_msb.
1509          */
1510
1511         if (mode_param < MLX5_MACSEC_EPN_SCOPE_MID) {
1512                 sa->epn_state.epn_msb++;
1513                 sa->epn_state.overlap = 0;
1514         } else {
1515                 sa->epn_state.overlap = 1;
1516         }
1517
1518         macsec_build_accel_attrs(sa, &attrs);
1519         mlx5e_macsec_modify_obj(mdev, &attrs, obj_id);
1520
1521         /* Re-set EPN arm event */
1522         in.obj_id = obj_id;
1523         in.mode = MLX5_MACSEC_EPN;
1524         macsec_aso_set_arm_event(mdev, macsec, &in);
1525 }
1526
1527 static void macsec_async_event(struct work_struct *work)
1528 {
1529         struct mlx5e_macsec_async_work *async_work;
1530         struct mlx5e_macsec_aso_out out = {};
1531         struct mlx5e_macsec_aso_in in = {};
1532         struct mlx5e_macsec_sa *macsec_sa;
1533         struct mlx5e_macsec *macsec;
1534         struct mlx5_core_dev *mdev;
1535         u32 obj_id;
1536
1537         async_work = container_of(work, struct mlx5e_macsec_async_work, work);
1538         macsec = async_work->macsec;
1539         mdev = async_work->mdev;
1540         obj_id = async_work->obj_id;
1541         macsec_sa = get_macsec_tx_sa_from_obj_id(macsec, obj_id);
1542         if (!macsec_sa) {
1543                 macsec_sa = get_macsec_rx_sa_from_obj_id(macsec, obj_id);
1544                 if (!macsec_sa) {
1545                         mlx5_core_dbg(mdev, "MACsec SA is not found (SA object id %d)\n", obj_id);
1546                         goto out_async_work;
1547                 }
1548         }
1549
1550         /* Query MACsec ASO context */
1551         in.obj_id = obj_id;
1552         macsec_aso_query(mdev, macsec, &in, &out);
1553
1554         /* EPN case */
1555         if (macsec_sa->epn_state.epn_enabled && !(out.event_arm & MLX5E_ASO_EPN_ARM))
1556                 macsec_epn_update(macsec, mdev, macsec_sa, obj_id, out.mode_param);
1557
1558 out_async_work:
1559         kfree(async_work);
1560 }
1561
1562 static int macsec_obj_change_event(struct notifier_block *nb, unsigned long event, void *data)
1563 {
1564         struct mlx5e_macsec *macsec = container_of(nb, struct mlx5e_macsec, nb);
1565         struct mlx5e_macsec_async_work *async_work;
1566         struct mlx5_eqe_obj_change *obj_change;
1567         struct mlx5_eqe *eqe = data;
1568         u16 obj_type;
1569         u32 obj_id;
1570
1571         if (event != MLX5_EVENT_TYPE_OBJECT_CHANGE)
1572                 return NOTIFY_DONE;
1573
1574         obj_change = &eqe->data.obj_change;
1575         obj_type = be16_to_cpu(obj_change->obj_type);
1576         obj_id = be32_to_cpu(obj_change->obj_id);
1577
1578         if (obj_type != MLX5_GENERAL_OBJECT_TYPES_MACSEC)
1579                 return NOTIFY_DONE;
1580
1581         async_work = kzalloc(sizeof(*async_work), GFP_ATOMIC);
1582         if (!async_work)
1583                 return NOTIFY_DONE;
1584
1585         async_work->macsec = macsec;
1586         async_work->mdev = macsec->mdev;
1587         async_work->obj_id = obj_id;
1588
1589         INIT_WORK(&async_work->work, macsec_async_event);
1590
1591         WARN_ON(!queue_work(macsec->wq, &async_work->work));
1592
1593         return NOTIFY_OK;
1594 }
1595
1596 static int mlx5e_macsec_aso_init(struct mlx5e_macsec_aso *aso, struct mlx5_core_dev *mdev)
1597 {
1598         struct mlx5_aso *maso;
1599         int err;
1600
1601         err = mlx5_core_alloc_pd(mdev, &aso->pdn);
1602         if (err) {
1603                 mlx5_core_err(mdev,
1604                               "MACsec offload: Failed to alloc pd for MACsec ASO, err=%d\n",
1605                               err);
1606                 return err;
1607         }
1608
1609         maso = mlx5_aso_create(mdev, aso->pdn);
1610         if (IS_ERR(maso)) {
1611                 err = PTR_ERR(maso);
1612                 goto err_aso;
1613         }
1614
1615         err = mlx5e_macsec_aso_reg_mr(mdev, aso);
1616         if (err)
1617                 goto err_aso_reg;
1618
1619         mutex_init(&aso->aso_lock);
1620
1621         aso->maso = maso;
1622
1623         return 0;
1624
1625 err_aso_reg:
1626         mlx5_aso_destroy(maso);
1627 err_aso:
1628         mlx5_core_dealloc_pd(mdev, aso->pdn);
1629         return err;
1630 }
1631
1632 static void mlx5e_macsec_aso_cleanup(struct mlx5e_macsec_aso *aso, struct mlx5_core_dev *mdev)
1633 {
1634         if (!aso)
1635                 return;
1636
1637         mlx5e_macsec_aso_dereg_mr(mdev, aso);
1638
1639         mlx5_aso_destroy(aso->maso);
1640
1641         mlx5_core_dealloc_pd(mdev, aso->pdn);
1642 }
1643
1644 bool mlx5e_is_macsec_device(const struct mlx5_core_dev *mdev)
1645 {
1646         if (!(MLX5_CAP_GEN_64(mdev, general_obj_types) &
1647             MLX5_GENERAL_OBJ_TYPES_CAP_MACSEC_OFFLOAD))
1648                 return false;
1649
1650         if (!MLX5_CAP_GEN(mdev, log_max_dek))
1651                 return false;
1652
1653         if (!MLX5_CAP_MACSEC(mdev, log_max_macsec_offload))
1654                 return false;
1655
1656         if (!MLX5_CAP_FLOWTABLE_NIC_RX(mdev, macsec_decrypt) ||
1657             !MLX5_CAP_FLOWTABLE_NIC_RX(mdev, reformat_remove_macsec))
1658                 return false;
1659
1660         if (!MLX5_CAP_FLOWTABLE_NIC_TX(mdev, macsec_encrypt) ||
1661             !MLX5_CAP_FLOWTABLE_NIC_TX(mdev, reformat_add_macsec))
1662                 return false;
1663
1664         if (!MLX5_CAP_MACSEC(mdev, macsec_crypto_esp_aes_gcm_128_encrypt) &&
1665             !MLX5_CAP_MACSEC(mdev, macsec_crypto_esp_aes_gcm_256_encrypt))
1666                 return false;
1667
1668         if (!MLX5_CAP_MACSEC(mdev, macsec_crypto_esp_aes_gcm_128_decrypt) &&
1669             !MLX5_CAP_MACSEC(mdev, macsec_crypto_esp_aes_gcm_256_decrypt))
1670                 return false;
1671
1672         return true;
1673 }
1674
1675 void mlx5e_macsec_get_stats_fill(struct mlx5e_macsec *macsec, void *macsec_stats)
1676 {
1677         mlx5e_macsec_fs_get_stats_fill(macsec->macsec_fs, macsec_stats);
1678 }
1679
1680 struct mlx5e_macsec_stats *mlx5e_macsec_get_stats(struct mlx5e_macsec *macsec)
1681 {
1682         if (!macsec)
1683                 return NULL;
1684
1685         return &macsec->stats;
1686 }
1687
1688 static const struct macsec_ops macsec_offload_ops = {
1689         .mdo_add_txsa = mlx5e_macsec_add_txsa,
1690         .mdo_upd_txsa = mlx5e_macsec_upd_txsa,
1691         .mdo_del_txsa = mlx5e_macsec_del_txsa,
1692         .mdo_add_rxsc = mlx5e_macsec_add_rxsc,
1693         .mdo_upd_rxsc = mlx5e_macsec_upd_rxsc,
1694         .mdo_del_rxsc = mlx5e_macsec_del_rxsc,
1695         .mdo_add_rxsa = mlx5e_macsec_add_rxsa,
1696         .mdo_upd_rxsa = mlx5e_macsec_upd_rxsa,
1697         .mdo_del_rxsa = mlx5e_macsec_del_rxsa,
1698         .mdo_add_secy = mlx5e_macsec_add_secy,
1699         .mdo_upd_secy = mlx5e_macsec_upd_secy,
1700         .mdo_del_secy = mlx5e_macsec_del_secy,
1701 };
1702
1703 bool mlx5e_macsec_handle_tx_skb(struct mlx5e_macsec *macsec, struct sk_buff *skb)
1704 {
1705         struct metadata_dst *md_dst = skb_metadata_dst(skb);
1706         u32 fs_id;
1707
1708         fs_id = mlx5e_macsec_get_sa_from_hashtable(&macsec->sci_hash, &md_dst->u.macsec_info.sci);
1709         if (!fs_id)
1710                 goto err_out;
1711
1712         return true;
1713
1714 err_out:
1715         dev_kfree_skb_any(skb);
1716         return false;
1717 }
1718
1719 void mlx5e_macsec_tx_build_eseg(struct mlx5e_macsec *macsec,
1720                                 struct sk_buff *skb,
1721                                 struct mlx5_wqe_eth_seg *eseg)
1722 {
1723         struct metadata_dst *md_dst = skb_metadata_dst(skb);
1724         u32 fs_id;
1725
1726         fs_id = mlx5e_macsec_get_sa_from_hashtable(&macsec->sci_hash, &md_dst->u.macsec_info.sci);
1727         if (!fs_id)
1728                 return;
1729
1730         eseg->flow_table_metadata = cpu_to_be32(MLX5_ETH_WQE_FT_META_MACSEC | fs_id << 2);
1731 }
1732
1733 void mlx5e_macsec_offload_handle_rx_skb(struct net_device *netdev,
1734                                         struct sk_buff *skb,
1735                                         struct mlx5_cqe64 *cqe)
1736 {
1737         struct mlx5e_macsec_rx_sc_xarray_element *sc_xarray_element;
1738         u32 macsec_meta_data = be32_to_cpu(cqe->ft_metadata);
1739         struct mlx5e_priv *priv = netdev_priv(netdev);
1740         struct mlx5e_macsec_rx_sc *rx_sc;
1741         struct mlx5e_macsec *macsec;
1742         u32  fs_id;
1743
1744         macsec = priv->macsec;
1745         if (!macsec)
1746                 return;
1747
1748         fs_id = MLX5_MACSEC_METADATA_HANDLE(macsec_meta_data);
1749
1750         rcu_read_lock();
1751         sc_xarray_element = xa_load(&macsec->sc_xarray, fs_id);
1752         rx_sc = sc_xarray_element->rx_sc;
1753         if (rx_sc) {
1754                 dst_hold(&rx_sc->md_dst->dst);
1755                 skb_dst_set(skb, &rx_sc->md_dst->dst);
1756         }
1757
1758         rcu_read_unlock();
1759 }
1760
1761 void mlx5e_macsec_build_netdev(struct mlx5e_priv *priv)
1762 {
1763         struct net_device *netdev = priv->netdev;
1764
1765         if (!mlx5e_is_macsec_device(priv->mdev))
1766                 return;
1767
1768         /* Enable MACsec */
1769         mlx5_core_dbg(priv->mdev, "mlx5e: MACsec acceleration enabled\n");
1770         netdev->macsec_ops = &macsec_offload_ops;
1771         netdev->features |= NETIF_F_HW_MACSEC;
1772         netif_keep_dst(netdev);
1773 }
1774
1775 int mlx5e_macsec_init(struct mlx5e_priv *priv)
1776 {
1777         struct mlx5_core_dev *mdev = priv->mdev;
1778         struct mlx5e_macsec *macsec = NULL;
1779         struct mlx5e_macsec_fs *macsec_fs;
1780         int err;
1781
1782         if (!mlx5e_is_macsec_device(priv->mdev)) {
1783                 mlx5_core_dbg(mdev, "Not a MACsec offload device\n");
1784                 return 0;
1785         }
1786
1787         macsec = kzalloc(sizeof(*macsec), GFP_KERNEL);
1788         if (!macsec)
1789                 return -ENOMEM;
1790
1791         INIT_LIST_HEAD(&macsec->macsec_device_list_head);
1792         mutex_init(&macsec->lock);
1793
1794         err = rhashtable_init(&macsec->sci_hash, &rhash_sci);
1795         if (err) {
1796                 mlx5_core_err(mdev, "MACsec offload: Failed to init SCI hash table, err=%d\n",
1797                               err);
1798                 goto err_hash;
1799         }
1800
1801         err = mlx5e_macsec_aso_init(&macsec->aso, priv->mdev);
1802         if (err) {
1803                 mlx5_core_err(mdev, "MACsec offload: Failed to init aso, err=%d\n", err);
1804                 goto err_aso;
1805         }
1806
1807         macsec->wq = alloc_ordered_workqueue("mlx5e_macsec_%s", 0, priv->netdev->name);
1808         if (!macsec->wq) {
1809                 err = -ENOMEM;
1810                 goto err_wq;
1811         }
1812
1813         xa_init_flags(&macsec->sc_xarray, XA_FLAGS_ALLOC1);
1814
1815         priv->macsec = macsec;
1816
1817         macsec->mdev = mdev;
1818
1819         macsec_fs = mlx5e_macsec_fs_init(mdev, priv->netdev);
1820         if (!macsec_fs) {
1821                 err = -ENOMEM;
1822                 goto err_out;
1823         }
1824
1825         macsec->macsec_fs = macsec_fs;
1826
1827         macsec->nb.notifier_call = macsec_obj_change_event;
1828         mlx5_notifier_register(mdev, &macsec->nb);
1829
1830         mlx5_core_dbg(mdev, "MACsec attached to netdevice\n");
1831
1832         return 0;
1833
1834 err_out:
1835         destroy_workqueue(macsec->wq);
1836 err_wq:
1837         mlx5e_macsec_aso_cleanup(&macsec->aso, priv->mdev);
1838 err_aso:
1839         rhashtable_destroy(&macsec->sci_hash);
1840 err_hash:
1841         kfree(macsec);
1842         priv->macsec = NULL;
1843         return err;
1844 }
1845
1846 void mlx5e_macsec_cleanup(struct mlx5e_priv *priv)
1847 {
1848         struct mlx5e_macsec *macsec = priv->macsec;
1849         struct mlx5_core_dev *mdev = macsec->mdev;
1850
1851         if (!macsec)
1852                 return;
1853
1854         mlx5_notifier_unregister(mdev, &macsec->nb);
1855
1856         mlx5e_macsec_fs_cleanup(macsec->macsec_fs);
1857
1858         /* Cleanup workqueue */
1859         destroy_workqueue(macsec->wq);
1860
1861         mlx5e_macsec_aso_cleanup(&macsec->aso, mdev);
1862
1863         priv->macsec = NULL;
1864
1865         rhashtable_destroy(&macsec->sci_hash);
1866
1867         mutex_destroy(&macsec->lock);
1868
1869         kfree(macsec);
1870 }