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