drivers/net/ethernet/mellanox/mlx5/core/devlink.c

   1 // SPDX-License-Identifier: GPL-2.0 OR Linux-OpenIB
   2 /* Copyright (c) 2019 Mellanox Technologies */
   3
   4 #include <devlink.h>
   5
   6 #include "mlx5_core.h"
   7 #include "fw_reset.h"
   8 #include "fs_core.h"
   9 #include "eswitch.h"
  10 #include "sf/dev/dev.h"
  11 #include "sf/sf.h"
  12
  13 static int mlx5_devlink_flash_update(struct devlink *devlink,
  14                                      struct devlink_flash_update_params *params,
  15                                      struct netlink_ext_ack *extack)
  16 {
  17         struct mlx5_core_dev *dev = devlink_priv(devlink);
  18
  19         return mlx5_firmware_flash(dev, params->fw, extack);
  20 }
  21
  22 static u8 mlx5_fw_ver_major(u32 version)
  23 {
  24         return (version >> 24) & 0xff;
  25 }
  26
  27 static u8 mlx5_fw_ver_minor(u32 version)
  28 {
  29         return (version >> 16) & 0xff;
  30 }
  31
  32 static u16 mlx5_fw_ver_subminor(u32 version)
  33 {
  34         return version & 0xffff;
  35 }
  36
  37 #define DEVLINK_FW_STRING_LEN 32
  38
  39 static int
  40 mlx5_devlink_info_get(struct devlink *devlink, struct devlink_info_req *req,
  41                       struct netlink_ext_ack *extack)
  42 {
  43         struct mlx5_core_dev *dev = devlink_priv(devlink);
  44         char version_str[DEVLINK_FW_STRING_LEN];
  45         u32 running_fw, stored_fw;
  46         int err;
  47
  48         err = devlink_info_driver_name_put(req, KBUILD_MODNAME);
  49         if (err)
  50                 return err;
  51
  52         err = devlink_info_version_fixed_put(req, "fw.psid", dev->board_id);
  53         if (err)
  54                 return err;
  55
  56         err = mlx5_fw_version_query(dev, &running_fw, &stored_fw);
  57         if (err)
  58                 return err;
  59
  60         snprintf(version_str, sizeof(version_str), "%d.%d.%04d",
  61                  mlx5_fw_ver_major(running_fw), mlx5_fw_ver_minor(running_fw),
  62                  mlx5_fw_ver_subminor(running_fw));
  63         err = devlink_info_version_running_put(req, "fw.version", version_str);
  64         if (err)
  65                 return err;
  66
  67         /* no pending version, return running (stored) version */
  68         if (stored_fw == 0)
  69                 stored_fw = running_fw;
  70
  71         snprintf(version_str, sizeof(version_str), "%d.%d.%04d",
  72                  mlx5_fw_ver_major(stored_fw), mlx5_fw_ver_minor(stored_fw),
  73                  mlx5_fw_ver_subminor(stored_fw));
  74         err = devlink_info_version_stored_put(req, "fw.version", version_str);
  75         if (err)
  76                 return err;
  77
  78         return 0;
  79 }
  80
  81 static int mlx5_devlink_reload_fw_activate(struct devlink *devlink, struct netlink_ext_ack *extack)
  82 {
  83         struct mlx5_core_dev *dev = devlink_priv(devlink);
  84         u8 reset_level, reset_type, net_port_alive;
  85         int err;
  86
  87         err = mlx5_fw_reset_query(dev, &reset_level, &reset_type);
  88         if (err)
  89                 return err;
  90         if (!(reset_level & MLX5_MFRL_REG_RESET_LEVEL3)) {
  91                 NL_SET_ERR_MSG_MOD(extack, "FW activate requires reboot");
  92                 return -EINVAL;
  93         }
  94
  95         net_port_alive = !!(reset_type & MLX5_MFRL_REG_RESET_TYPE_NET_PORT_ALIVE);
  96         err = mlx5_fw_reset_set_reset_sync(dev, net_port_alive);
  97         if (err)
  98                 goto out;
  99
 100         err = mlx5_fw_reset_wait_reset_done(dev);
 101 out:
 102         if (err)
 103                 NL_SET_ERR_MSG_MOD(extack, "FW activate command failed");
 104         return err;
 105 }
 106
 107 static int mlx5_devlink_trigger_fw_live_patch(struct devlink *devlink,
 108                                               struct netlink_ext_ack *extack)
 109 {
 110         struct mlx5_core_dev *dev = devlink_priv(devlink);
 111         u8 reset_level;
 112         int err;
 113
 114         err = mlx5_fw_reset_query(dev, &reset_level, NULL);
 115         if (err)
 116                 return err;
 117         if (!(reset_level & MLX5_MFRL_REG_RESET_LEVEL0)) {
 118                 NL_SET_ERR_MSG_MOD(extack,
 119                                    "FW upgrade to the stored FW can't be done by FW live patching");
 120                 return -EINVAL;
 121         }
 122
 123         return mlx5_fw_reset_set_live_patch(dev);
 124 }
 125
 126 static int mlx5_devlink_reload_down(struct devlink *devlink, bool netns_change,
 127                                     enum devlink_reload_action action,
 128                                     enum devlink_reload_limit limit,
 129                                     struct netlink_ext_ack *extack)
 130 {
 131         struct mlx5_core_dev *dev = devlink_priv(devlink);
 132         bool sf_dev_allocated;
 133
 134         sf_dev_allocated = mlx5_sf_dev_allocated(dev);
 135         if (sf_dev_allocated) {
 136                 /* Reload results in deleting SF device which further results in
 137                  * unregistering devlink instance while holding devlink_mutext.
 138                  * Hence, do not support reload.
 139                  */
 140                 NL_SET_ERR_MSG_MOD(extack, "reload is unsupported when SFs are allocated");
 141                 return -EOPNOTSUPP;
 142         }
 143
 144         if (mlx5_lag_is_active(dev)) {
 145                 NL_SET_ERR_MSG_MOD(extack, "reload is unsupported in Lag mode");
 146                 return -EOPNOTSUPP;
 147         }
 148
 149         switch (action) {
 150         case DEVLINK_RELOAD_ACTION_DRIVER_REINIT:
 151                 mlx5_unload_one(dev);
 152                 return 0;
 153         case DEVLINK_RELOAD_ACTION_FW_ACTIVATE:
 154                 if (limit == DEVLINK_RELOAD_LIMIT_NO_RESET)
 155                         return mlx5_devlink_trigger_fw_live_patch(devlink, extack);
 156                 return mlx5_devlink_reload_fw_activate(devlink, extack);
 157         default:
 158                 /* Unsupported action should not get to this function */
 159                 WARN_ON(1);
 160                 return -EOPNOTSUPP;
 161         }
 162 }
 163
 164 static int mlx5_devlink_reload_up(struct devlink *devlink, enum devlink_reload_action action,
 165                                   enum devlink_reload_limit limit, u32 *actions_performed,
 166                                   struct netlink_ext_ack *extack)
 167 {
 168         struct mlx5_core_dev *dev = devlink_priv(devlink);
 169
 170         *actions_performed = BIT(action);
 171         switch (action) {
 172         case DEVLINK_RELOAD_ACTION_DRIVER_REINIT:
 173                 return mlx5_load_one(dev);
 174         case DEVLINK_RELOAD_ACTION_FW_ACTIVATE:
 175                 if (limit == DEVLINK_RELOAD_LIMIT_NO_RESET)
 176                         break;
 177                 /* On fw_activate action, also driver is reloaded and reinit performed */
 178                 *actions_performed |= BIT(DEVLINK_RELOAD_ACTION_DRIVER_REINIT);
 179                 return mlx5_load_one(dev);
 180         default:
 181                 /* Unsupported action should not get to this function */
 182                 WARN_ON(1);
 183                 return -EOPNOTSUPP;
 184         }
 185
 186         return 0;
 187 }
 188
 189 static struct mlx5_devlink_trap *mlx5_find_trap_by_id(struct mlx5_core_dev *dev, int trap_id)
 190 {
 191         struct mlx5_devlink_trap *dl_trap;
 192
 193         list_for_each_entry(dl_trap, &dev->priv.traps, list)
 194                 if (dl_trap->trap.id == trap_id)
 195                         return dl_trap;
 196
 197         return NULL;
 198 }
 199
 200 static int mlx5_devlink_trap_init(struct devlink *devlink, const struct devlink_trap *trap,
 201                                   void *trap_ctx)
 202 {
 203         struct mlx5_core_dev *dev = devlink_priv(devlink);
 204         struct mlx5_devlink_trap *dl_trap;
 205
 206         dl_trap = kzalloc(sizeof(*dl_trap), GFP_KERNEL);
 207         if (!dl_trap)
 208                 return -ENOMEM;
 209
 210         dl_trap->trap.id = trap->id;
 211         dl_trap->trap.action = DEVLINK_TRAP_ACTION_DROP;
 212         dl_trap->item = trap_ctx;
 213
 214         if (mlx5_find_trap_by_id(dev, trap->id)) {
 215                 kfree(dl_trap);
 216                 mlx5_core_err(dev, "Devlink trap: Trap 0x%x already found", trap->id);
 217                 return -EEXIST;
 218         }
 219
 220         list_add_tail(&dl_trap->list, &dev->priv.traps);
 221         return 0;
 222 }
 223
 224 static void mlx5_devlink_trap_fini(struct devlink *devlink, const struct devlink_trap *trap,
 225                                    void *trap_ctx)
 226 {
 227         struct mlx5_core_dev *dev = devlink_priv(devlink);
 228         struct mlx5_devlink_trap *dl_trap;
 229
 230         dl_trap = mlx5_find_trap_by_id(dev, trap->id);
 231         if (!dl_trap) {
 232                 mlx5_core_err(dev, "Devlink trap: Missing trap id 0x%x", trap->id);
 233                 return;
 234         }
 235         list_del(&dl_trap->list);
 236         kfree(dl_trap);
 237 }
 238
 239 static int mlx5_devlink_trap_action_set(struct devlink *devlink,
 240                                         const struct devlink_trap *trap,
 241                                         enum devlink_trap_action action,
 242                                         struct netlink_ext_ack *extack)
 243 {
 244         struct mlx5_core_dev *dev = devlink_priv(devlink);
 245         enum devlink_trap_action action_orig;
 246         struct mlx5_devlink_trap *dl_trap;
 247         int err = 0;
 248
 249         if (is_mdev_switchdev_mode(dev)) {
 250                 NL_SET_ERR_MSG_MOD(extack, "Devlink traps can't be set in switchdev mode");
 251                 return -EOPNOTSUPP;
 252         }
 253
 254         dl_trap = mlx5_find_trap_by_id(dev, trap->id);
 255         if (!dl_trap) {
 256                 mlx5_core_err(dev, "Devlink trap: Set action on invalid trap id 0x%x", trap->id);
 257                 err = -EINVAL;
 258                 goto out;
 259         }
 260
 261         if (action != DEVLINK_TRAP_ACTION_DROP && action != DEVLINK_TRAP_ACTION_TRAP) {
 262                 err = -EOPNOTSUPP;
 263                 goto out;
 264         }
 265
 266         if (action == dl_trap->trap.action)
 267                 goto out;
 268
 269         action_orig = dl_trap->trap.action;
 270         dl_trap->trap.action = action;
 271         err = mlx5_blocking_notifier_call_chain(dev, MLX5_DRIVER_EVENT_TYPE_TRAP,
 272                                                 &dl_trap->trap);
 273         if (err)
 274                 dl_trap->trap.action = action_orig;
 275 out:
 276         return err;
 277 }
 278
 279 static const struct devlink_ops mlx5_devlink_ops = {
 280 #ifdef CONFIG_MLX5_ESWITCH
 281         .eswitch_mode_set = mlx5_devlink_eswitch_mode_set,
 282         .eswitch_mode_get = mlx5_devlink_eswitch_mode_get,
 283         .eswitch_inline_mode_set = mlx5_devlink_eswitch_inline_mode_set,
 284         .eswitch_inline_mode_get = mlx5_devlink_eswitch_inline_mode_get,
 285         .eswitch_encap_mode_set = mlx5_devlink_eswitch_encap_mode_set,
 286         .eswitch_encap_mode_get = mlx5_devlink_eswitch_encap_mode_get,
 287         .port_function_hw_addr_get = mlx5_devlink_port_function_hw_addr_get,
 288         .port_function_hw_addr_set = mlx5_devlink_port_function_hw_addr_set,
 289 #endif
 290 #ifdef CONFIG_MLX5_SF_MANAGER
 291         .port_new = mlx5_devlink_sf_port_new,
 292         .port_del = mlx5_devlink_sf_port_del,
 293         .port_fn_state_get = mlx5_devlink_sf_port_fn_state_get,
 294         .port_fn_state_set = mlx5_devlink_sf_port_fn_state_set,
 295 #endif
 296         .flash_update = mlx5_devlink_flash_update,
 297         .info_get = mlx5_devlink_info_get,
 298         .reload_actions = BIT(DEVLINK_RELOAD_ACTION_DRIVER_REINIT) |
 299                           BIT(DEVLINK_RELOAD_ACTION_FW_ACTIVATE),
 300         .reload_limits = BIT(DEVLINK_RELOAD_LIMIT_NO_RESET),
 301         .reload_down = mlx5_devlink_reload_down,
 302         .reload_up = mlx5_devlink_reload_up,
 303         .trap_init = mlx5_devlink_trap_init,
 304         .trap_fini = mlx5_devlink_trap_fini,
 305         .trap_action_set = mlx5_devlink_trap_action_set,
 306 };
 307
 308 void mlx5_devlink_trap_report(struct mlx5_core_dev *dev, int trap_id, struct sk_buff *skb,
 309                               struct devlink_port *dl_port)
 310 {
 311         struct devlink *devlink = priv_to_devlink(dev);
 312         struct mlx5_devlink_trap *dl_trap;
 313
 314         dl_trap = mlx5_find_trap_by_id(dev, trap_id);
 315         if (!dl_trap) {
 316                 mlx5_core_err(dev, "Devlink trap: Report on invalid trap id 0x%x", trap_id);
 317                 return;
 318         }
 319
 320         if (dl_trap->trap.action != DEVLINK_TRAP_ACTION_TRAP) {
 321                 mlx5_core_dbg(dev, "Devlink trap: Trap id %d has action %d", trap_id,
 322                               dl_trap->trap.action);
 323                 return;
 324         }
 325         devlink_trap_report(devlink, skb, dl_trap->item, dl_port, NULL);
 326 }
 327
 328 int mlx5_devlink_trap_get_num_active(struct mlx5_core_dev *dev)
 329 {
 330         struct mlx5_devlink_trap *dl_trap;
 331         int count = 0;
 332
 333         list_for_each_entry(dl_trap, &dev->priv.traps, list)
 334                 if (dl_trap->trap.action == DEVLINK_TRAP_ACTION_TRAP)
 335                         count++;
 336
 337         return count;
 338 }
 339
 340 int mlx5_devlink_traps_get_action(struct mlx5_core_dev *dev, int trap_id,
 341                                   enum devlink_trap_action *action)
 342 {
 343         struct mlx5_devlink_trap *dl_trap;
 344
 345         dl_trap = mlx5_find_trap_by_id(dev, trap_id);
 346         if (!dl_trap) {
 347                 mlx5_core_err(dev, "Devlink trap: Get action on invalid trap id 0x%x",
 348                               trap_id);
 349                 return -EINVAL;
 350         }
 351
 352         *action = dl_trap->trap.action;
 353         return 0;
 354 }
 355
 356 struct devlink *mlx5_devlink_alloc(void)
 357 {
 358         return devlink_alloc(&mlx5_devlink_ops, sizeof(struct mlx5_core_dev));
 359 }
 360
 361 void mlx5_devlink_free(struct devlink *devlink)
 362 {
 363         devlink_free(devlink);
 364 }
 365
 366 static int mlx5_devlink_fs_mode_validate(struct devlink *devlink, u32 id,
 367                                          union devlink_param_value val,
 368                                          struct netlink_ext_ack *extack)
 369 {
 370         struct mlx5_core_dev *dev = devlink_priv(devlink);
 371         char *value = val.vstr;
 372         int err = 0;
 373
 374         if (!strcmp(value, "dmfs")) {
 375                 return 0;
 376         } else if (!strcmp(value, "smfs")) {
 377                 u8 eswitch_mode;
 378                 bool smfs_cap;
 379
 380                 eswitch_mode = mlx5_eswitch_mode(dev);
 381                 smfs_cap = mlx5_fs_dr_is_supported(dev);
 382
 383                 if (!smfs_cap) {
 384                         err = -EOPNOTSUPP;
 385                         NL_SET_ERR_MSG_MOD(extack,
 386                                            "Software managed steering is not supported by current device");
 387                 }
 388
 389                 else if (eswitch_mode == MLX5_ESWITCH_OFFLOADS) {
 390                         NL_SET_ERR_MSG_MOD(extack,
 391                                            "Software managed steering is not supported when eswitch offloads enabled.");
 392                         err = -EOPNOTSUPP;
 393                 }
 394         } else {
 395                 NL_SET_ERR_MSG_MOD(extack,
 396                                    "Bad parameter: supported values are [\"dmfs\", \"smfs\"]");
 397                 err = -EINVAL;
 398         }
 399
 400         return err;
 401 }
 402
 403 static int mlx5_devlink_fs_mode_set(struct devlink *devlink, u32 id,
 404                                     struct devlink_param_gset_ctx *ctx)
 405 {
 406         struct mlx5_core_dev *dev = devlink_priv(devlink);
 407         enum mlx5_flow_steering_mode mode;
 408
 409         if (!strcmp(ctx->val.vstr, "smfs"))
 410                 mode = MLX5_FLOW_STEERING_MODE_SMFS;
 411         else
 412                 mode = MLX5_FLOW_STEERING_MODE_DMFS;
 413         dev->priv.steering->mode = mode;
 414
 415         return 0;
 416 }
 417
 418 static int mlx5_devlink_fs_mode_get(struct devlink *devlink, u32 id,
 419                                     struct devlink_param_gset_ctx *ctx)
 420 {
 421         struct mlx5_core_dev *dev = devlink_priv(devlink);
 422
 423         if (dev->priv.steering->mode == MLX5_FLOW_STEERING_MODE_SMFS)
 424                 strcpy(ctx->val.vstr, "smfs");
 425         else
 426                 strcpy(ctx->val.vstr, "dmfs");
 427         return 0;
 428 }
 429
 430 static int mlx5_devlink_enable_roce_validate(struct devlink *devlink, u32 id,
 431                                              union devlink_param_value val,
 432                                              struct netlink_ext_ack *extack)
 433 {
 434         struct mlx5_core_dev *dev = devlink_priv(devlink);
 435         bool new_state = val.vbool;
 436
 437         if (new_state && !MLX5_CAP_GEN(dev, roce)) {
 438                 NL_SET_ERR_MSG_MOD(extack, "Device doesn't support RoCE");
 439                 return -EOPNOTSUPP;
 440         }
 441         if (mlx5_core_is_mp_slave(dev) || mlx5_lag_is_active(dev)) {
 442                 NL_SET_ERR_MSG_MOD(extack, "Multi port slave/Lag device can't configure RoCE");
 443                 return -EOPNOTSUPP;
 444         }
 445
 446         return 0;
 447 }
 448
 449 #ifdef CONFIG_MLX5_ESWITCH
 450 static int mlx5_devlink_large_group_num_validate(struct devlink *devlink, u32 id,
 451                                                  union devlink_param_value val,
 452                                                  struct netlink_ext_ack *extack)
 453 {
 454         int group_num = val.vu32;
 455
 456         if (group_num < 1 || group_num > 1024) {
 457                 NL_SET_ERR_MSG_MOD(extack,
 458                                    "Unsupported group number, supported range is 1-1024");
 459                 return -EOPNOTSUPP;
 460         }
 461
 462         return 0;
 463 }
 464
 465 static int mlx5_devlink_esw_port_metadata_set(struct devlink *devlink, u32 id,
 466                                               struct devlink_param_gset_ctx *ctx)
 467 {
 468         struct mlx5_core_dev *dev = devlink_priv(devlink);
 469
 470         if (!MLX5_ESWITCH_MANAGER(dev))
 471                 return -EOPNOTSUPP;
 472
 473         return mlx5_esw_offloads_vport_metadata_set(dev->priv.eswitch, ctx->val.vbool);
 474 }
 475
 476 static int mlx5_devlink_esw_port_metadata_get(struct devlink *devlink, u32 id,
 477                                               struct devlink_param_gset_ctx *ctx)
 478 {
 479         struct mlx5_core_dev *dev = devlink_priv(devlink);
 480
 481         if (!MLX5_ESWITCH_MANAGER(dev))
 482                 return -EOPNOTSUPP;
 483
 484         ctx->val.vbool = mlx5_eswitch_vport_match_metadata_enabled(dev->priv.eswitch);
 485         return 0;
 486 }
 487
 488 static int mlx5_devlink_esw_port_metadata_validate(struct devlink *devlink, u32 id,
 489                                                    union devlink_param_value val,
 490                                                    struct netlink_ext_ack *extack)
 491 {
 492         struct mlx5_core_dev *dev = devlink_priv(devlink);
 493         u8 esw_mode;
 494
 495         if (!MLX5_ESWITCH_MANAGER(dev)) {
 496                 NL_SET_ERR_MSG_MOD(extack, "E-Switch is unsupported");
 497                 return -EOPNOTSUPP;
 498         }
 499         esw_mode = mlx5_eswitch_mode(dev);
 500         if (esw_mode == MLX5_ESWITCH_OFFLOADS) {
 501                 NL_SET_ERR_MSG_MOD(extack,
 502                                    "E-Switch must either disabled or non switchdev mode");
 503                 return -EBUSY;
 504         }
 505         return 0;
 506 }
 507
 508 #endif
 509
 510 static int mlx5_devlink_enable_remote_dev_reset_set(struct devlink *devlink, u32 id,
 511                                                     struct devlink_param_gset_ctx *ctx)
 512 {
 513         struct mlx5_core_dev *dev = devlink_priv(devlink);
 514
 515         mlx5_fw_reset_enable_remote_dev_reset_set(dev, ctx->val.vbool);
 516         return 0;
 517 }
 518
 519 static int mlx5_devlink_enable_remote_dev_reset_get(struct devlink *devlink, u32 id,
 520                                                     struct devlink_param_gset_ctx *ctx)
 521 {
 522         struct mlx5_core_dev *dev = devlink_priv(devlink);
 523
 524         ctx->val.vbool = mlx5_fw_reset_enable_remote_dev_reset_get(dev);
 525         return 0;
 526 }
 527
 528 static const struct devlink_param mlx5_devlink_params[] = {
 529         DEVLINK_PARAM_DRIVER(MLX5_DEVLINK_PARAM_ID_FLOW_STEERING_MODE,
 530                              "flow_steering_mode", DEVLINK_PARAM_TYPE_STRING,
 531                              BIT(DEVLINK_PARAM_CMODE_RUNTIME),
 532                              mlx5_devlink_fs_mode_get, mlx5_devlink_fs_mode_set,
 533                              mlx5_devlink_fs_mode_validate),
 534         DEVLINK_PARAM_GENERIC(ENABLE_ROCE, BIT(DEVLINK_PARAM_CMODE_DRIVERINIT),
 535                               NULL, NULL, mlx5_devlink_enable_roce_validate),
 536 #ifdef CONFIG_MLX5_ESWITCH
 537         DEVLINK_PARAM_DRIVER(MLX5_DEVLINK_PARAM_ID_ESW_LARGE_GROUP_NUM,
 538                              "fdb_large_groups", DEVLINK_PARAM_TYPE_U32,
 539                              BIT(DEVLINK_PARAM_CMODE_DRIVERINIT),
 540                              NULL, NULL,
 541                              mlx5_devlink_large_group_num_validate),
 542         DEVLINK_PARAM_DRIVER(MLX5_DEVLINK_PARAM_ID_ESW_PORT_METADATA,
 543                              "esw_port_metadata", DEVLINK_PARAM_TYPE_BOOL,
 544                              BIT(DEVLINK_PARAM_CMODE_RUNTIME),
 545                              mlx5_devlink_esw_port_metadata_get,
 546                              mlx5_devlink_esw_port_metadata_set,
 547                              mlx5_devlink_esw_port_metadata_validate),
 548 #endif
 549         DEVLINK_PARAM_GENERIC(ENABLE_REMOTE_DEV_RESET, BIT(DEVLINK_PARAM_CMODE_RUNTIME),
 550                               mlx5_devlink_enable_remote_dev_reset_get,
 551                               mlx5_devlink_enable_remote_dev_reset_set, NULL),
 552 };
 553
 554 static void mlx5_devlink_set_params_init_values(struct devlink *devlink)
 555 {
 556         struct mlx5_core_dev *dev = devlink_priv(devlink);
 557         union devlink_param_value value;
 558
 559         if (dev->priv.steering->mode == MLX5_FLOW_STEERING_MODE_DMFS)
 560                 strcpy(value.vstr, "dmfs");
 561         else
 562                 strcpy(value.vstr, "smfs");
 563         devlink_param_driverinit_value_set(devlink,
 564                                            MLX5_DEVLINK_PARAM_ID_FLOW_STEERING_MODE,
 565                                            value);
 566
 567         value.vbool = MLX5_CAP_GEN(dev, roce);
 568         devlink_param_driverinit_value_set(devlink,
 569                                            DEVLINK_PARAM_GENERIC_ID_ENABLE_ROCE,
 570                                            value);
 571
 572 #ifdef CONFIG_MLX5_ESWITCH
 573         value.vu32 = ESW_OFFLOADS_DEFAULT_NUM_GROUPS;
 574         devlink_param_driverinit_value_set(devlink,
 575                                            MLX5_DEVLINK_PARAM_ID_ESW_LARGE_GROUP_NUM,
 576                                            value);
 577
 578         if (MLX5_ESWITCH_MANAGER(dev)) {
 579                 if (mlx5_esw_vport_match_metadata_supported(dev->priv.eswitch)) {
 580                         dev->priv.eswitch->flags |= MLX5_ESWITCH_VPORT_MATCH_METADATA;
 581                         value.vbool = true;
 582                 } else {
 583                         value.vbool = false;
 584                 }
 585                 devlink_param_driverinit_value_set(devlink,
 586                                                    MLX5_DEVLINK_PARAM_ID_ESW_PORT_METADATA,
 587                                                    value);
 588         }
 589 #endif
 590 }
 591
 592 #define MLX5_TRAP_DROP(_id, _group_id)                                  \
 593         DEVLINK_TRAP_GENERIC(DROP, DROP, _id,                           \
 594                              DEVLINK_TRAP_GROUP_GENERIC_ID_##_group_id, \
 595                              DEVLINK_TRAP_METADATA_TYPE_F_IN_PORT)
 596
 597 static const struct devlink_trap mlx5_traps_arr[] = {
 598         MLX5_TRAP_DROP(INGRESS_VLAN_FILTER, L2_DROPS),
 599         MLX5_TRAP_DROP(DMAC_FILTER, L2_DROPS),
 600 };
 601
 602 static const struct devlink_trap_group mlx5_trap_groups_arr[] = {
 603         DEVLINK_TRAP_GROUP_GENERIC(L2_DROPS, 0),
 604 };
 605
 606 static int mlx5_devlink_traps_register(struct devlink *devlink)
 607 {
 608         struct mlx5_core_dev *core_dev = devlink_priv(devlink);
 609         int err;
 610
 611         err = devlink_trap_groups_register(devlink, mlx5_trap_groups_arr,
 612                                            ARRAY_SIZE(mlx5_trap_groups_arr));
 613         if (err)
 614                 return err;
 615
 616         err = devlink_traps_register(devlink, mlx5_traps_arr, ARRAY_SIZE(mlx5_traps_arr),
 617                                      &core_dev->priv);
 618         if (err)
 619                 goto err_trap_group;
 620         return 0;
 621
 622 err_trap_group:
 623         devlink_trap_groups_unregister(devlink, mlx5_trap_groups_arr,
 624                                        ARRAY_SIZE(mlx5_trap_groups_arr));
 625         return err;
 626 }
 627
 628 static void mlx5_devlink_traps_unregister(struct devlink *devlink)
 629 {
 630         devlink_traps_unregister(devlink, mlx5_traps_arr, ARRAY_SIZE(mlx5_traps_arr));
 631         devlink_trap_groups_unregister(devlink, mlx5_trap_groups_arr,
 632                                        ARRAY_SIZE(mlx5_trap_groups_arr));
 633 }
 634
 635 int mlx5_devlink_register(struct devlink *devlink, struct device *dev)
 636 {
 637         int err;
 638
 639         err = devlink_register(devlink, dev);
 640         if (err)
 641                 return err;
 642
 643         err = devlink_params_register(devlink, mlx5_devlink_params,
 644                                       ARRAY_SIZE(mlx5_devlink_params));
 645         if (err)
 646                 goto params_reg_err;
 647         mlx5_devlink_set_params_init_values(devlink);
 648         devlink_params_publish(devlink);
 649
 650         err = mlx5_devlink_traps_register(devlink);
 651         if (err)
 652                 goto traps_reg_err;
 653
 654         return 0;
 655
 656 traps_reg_err:
 657         devlink_params_unregister(devlink, mlx5_devlink_params,
 658                                   ARRAY_SIZE(mlx5_devlink_params));
 659 params_reg_err:
 660         devlink_unregister(devlink);
 661         return err;
 662 }
 663
 664 void mlx5_devlink_unregister(struct devlink *devlink)
 665 {
 666         mlx5_devlink_traps_unregister(devlink);
 667         devlink_params_unregister(devlink, mlx5_devlink_params,
 668                                   ARRAY_SIZE(mlx5_devlink_params));
 669         devlink_unregister(devlink);
 670 }