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