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 "esw/qos.h"
  11 #include "sf/dev/dev.h"
  12 #include "sf/sf.h"
  13
  14 static int mlx5_devlink_flash_update(struct devlink *devlink,
  15                                      struct devlink_flash_update_params *params,
  16                                      struct netlink_ext_ack *extack)
  17 {
  18         struct mlx5_core_dev *dev = devlink_priv(devlink);
  19
  20         return mlx5_firmware_flash(dev, params->fw, extack);
  21 }
  22
  23 static u8 mlx5_fw_ver_major(u32 version)
  24 {
  25         return (version >> 24) & 0xff;
  26 }
  27
  28 static u8 mlx5_fw_ver_minor(u32 version)
  29 {
  30         return (version >> 16) & 0xff;
  31 }
  32
  33 static u16 mlx5_fw_ver_subminor(u32 version)
  34 {
  35         return version & 0xffff;
  36 }
  37
  38 #define DEVLINK_FW_STRING_LEN 32
  39
  40 static int
  41 mlx5_devlink_info_get(struct devlink *devlink, struct devlink_info_req *req,
  42                       struct netlink_ext_ack *extack)
  43 {
  44         struct mlx5_core_dev *dev = devlink_priv(devlink);
  45         char version_str[DEVLINK_FW_STRING_LEN];
  46         u32 running_fw, stored_fw;
  47         int err;
  48
  49         err = devlink_info_version_fixed_put(req, "fw.psid", dev->board_id);
  50         if (err)
  51                 return err;
  52
  53         err = mlx5_fw_version_query(dev, &running_fw, &stored_fw);
  54         if (err)
  55                 return err;
  56
  57         snprintf(version_str, sizeof(version_str), "%d.%d.%04d",
  58                  mlx5_fw_ver_major(running_fw), mlx5_fw_ver_minor(running_fw),
  59                  mlx5_fw_ver_subminor(running_fw));
  60         err = devlink_info_version_running_put(req, "fw.version", version_str);
  61         if (err)
  62                 return err;
  63         err = devlink_info_version_running_put(req,
  64                                                DEVLINK_INFO_VERSION_GENERIC_FW,
  65                                                version_str);
  66         if (err)
  67                 return err;
  68
  69         /* no pending version, return running (stored) version */
  70         if (stored_fw == 0)
  71                 stored_fw = running_fw;
  72
  73         snprintf(version_str, sizeof(version_str), "%d.%d.%04d",
  74                  mlx5_fw_ver_major(stored_fw), mlx5_fw_ver_minor(stored_fw),
  75                  mlx5_fw_ver_subminor(stored_fw));
  76         err = devlink_info_version_stored_put(req, "fw.version", version_str);
  77         if (err)
  78                 return err;
  79         return devlink_info_version_stored_put(req,
  80                                                DEVLINK_INFO_VERSION_GENERIC_FW,
  81                                                version_str);
  82 }
  83
  84 static int mlx5_devlink_reload_fw_activate(struct devlink *devlink, struct netlink_ext_ack *extack)
  85 {
  86         struct mlx5_core_dev *dev = devlink_priv(devlink);
  87         u8 reset_level, reset_type, net_port_alive;
  88         int err;
  89
  90         err = mlx5_fw_reset_query(dev, &reset_level, &reset_type);
  91         if (err)
  92                 return err;
  93         if (!(reset_level & MLX5_MFRL_REG_RESET_LEVEL3)) {
  94                 NL_SET_ERR_MSG_MOD(extack, "FW activate requires reboot");
  95                 return -EINVAL;
  96         }
  97
  98         net_port_alive = !!(reset_type & MLX5_MFRL_REG_RESET_TYPE_NET_PORT_ALIVE);
  99         err = mlx5_fw_reset_set_reset_sync(dev, net_port_alive, extack);
 100         if (err)
 101                 return err;
 102
 103         err = mlx5_fw_reset_wait_reset_done(dev);
 104         if (err)
 105                 return err;
 106
 107         mlx5_unload_one_devl_locked(dev, true);
 108         err = mlx5_health_wait_pci_up(dev);
 109         if (err)
 110                 NL_SET_ERR_MSG_MOD(extack, "FW activate aborted, PCI reads fail after reset");
 111
 112         return err;
 113 }
 114
 115 static int mlx5_devlink_trigger_fw_live_patch(struct devlink *devlink,
 116                                               struct netlink_ext_ack *extack)
 117 {
 118         struct mlx5_core_dev *dev = devlink_priv(devlink);
 119         u8 reset_level;
 120         int err;
 121
 122         err = mlx5_fw_reset_query(dev, &reset_level, NULL);
 123         if (err)
 124                 return err;
 125         if (!(reset_level & MLX5_MFRL_REG_RESET_LEVEL0)) {
 126                 NL_SET_ERR_MSG_MOD(extack,
 127                                    "FW upgrade to the stored FW can't be done by FW live patching");
 128                 return -EINVAL;
 129         }
 130
 131         return mlx5_fw_reset_set_live_patch(dev);
 132 }
 133
 134 static int mlx5_devlink_reload_down(struct devlink *devlink, bool netns_change,
 135                                     enum devlink_reload_action action,
 136                                     enum devlink_reload_limit limit,
 137                                     struct netlink_ext_ack *extack)
 138 {
 139         struct mlx5_core_dev *dev = devlink_priv(devlink);
 140         struct pci_dev *pdev = dev->pdev;
 141         int ret = 0;
 142
 143         if (mlx5_dev_is_lightweight(dev)) {
 144                 if (action != DEVLINK_RELOAD_ACTION_DRIVER_REINIT)
 145                         return -EOPNOTSUPP;
 146                 mlx5_unload_one_light(dev);
 147                 return 0;
 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         if (mlx5_core_is_mp_slave(dev)) {
 156                 NL_SET_ERR_MSG_MOD(extack, "reload is unsupported for multi port slave");
 157                 return -EOPNOTSUPP;
 158         }
 159
 160         if (action == DEVLINK_RELOAD_ACTION_FW_ACTIVATE &&
 161             !dev->priv.fw_reset) {
 162                 NL_SET_ERR_MSG_MOD(extack, "FW activate is unsupported for this function");
 163                 return -EOPNOTSUPP;
 164         }
 165
 166         if (mlx5_core_is_pf(dev) && pci_num_vf(pdev))
 167                 NL_SET_ERR_MSG_MOD(extack, "reload while VFs are present is unfavorable");
 168
 169         switch (action) {
 170         case DEVLINK_RELOAD_ACTION_DRIVER_REINIT:
 171                 mlx5_unload_one_devl_locked(dev, false);
 172                 break;
 173         case DEVLINK_RELOAD_ACTION_FW_ACTIVATE:
 174                 if (limit == DEVLINK_RELOAD_LIMIT_NO_RESET)
 175                         ret = mlx5_devlink_trigger_fw_live_patch(devlink, extack);
 176                 else
 177                         ret = mlx5_devlink_reload_fw_activate(devlink, extack);
 178                 break;
 179         default:
 180                 /* Unsupported action should not get to this function */
 181                 WARN_ON(1);
 182                 ret = -EOPNOTSUPP;
 183         }
 184
 185         return ret;
 186 }
 187
 188 static int mlx5_devlink_reload_up(struct devlink *devlink, enum devlink_reload_action action,
 189                                   enum devlink_reload_limit limit, u32 *actions_performed,
 190                                   struct netlink_ext_ack *extack)
 191 {
 192         struct mlx5_core_dev *dev = devlink_priv(devlink);
 193         int ret = 0;
 194
 195         *actions_performed = BIT(action);
 196         switch (action) {
 197         case DEVLINK_RELOAD_ACTION_DRIVER_REINIT:
 198                 if (mlx5_dev_is_lightweight(dev)) {
 199                         mlx5_fw_reporters_create(dev);
 200                         return mlx5_init_one_devl_locked(dev);
 201                 }
 202                 ret = mlx5_load_one_devl_locked(dev, false);
 203                 break;
 204         case DEVLINK_RELOAD_ACTION_FW_ACTIVATE:
 205                 if (limit == DEVLINK_RELOAD_LIMIT_NO_RESET)
 206                         break;
 207                 /* On fw_activate action, also driver is reloaded and reinit performed */
 208                 *actions_performed |= BIT(DEVLINK_RELOAD_ACTION_DRIVER_REINIT);
 209                 ret = mlx5_load_one_devl_locked(dev, true);
 210                 if (ret)
 211                         return ret;
 212                 ret = mlx5_fw_reset_verify_fw_complete(dev, extack);
 213                 break;
 214         default:
 215                 /* Unsupported action should not get to this function */
 216                 WARN_ON(1);
 217                 ret = -EOPNOTSUPP;
 218         }
 219
 220         return ret;
 221 }
 222
 223 static struct mlx5_devlink_trap *mlx5_find_trap_by_id(struct mlx5_core_dev *dev, int trap_id)
 224 {
 225         struct mlx5_devlink_trap *dl_trap;
 226
 227         list_for_each_entry(dl_trap, &dev->priv.traps, list)
 228                 if (dl_trap->trap.id == trap_id)
 229                         return dl_trap;
 230
 231         return NULL;
 232 }
 233
 234 static int mlx5_devlink_trap_init(struct devlink *devlink, const struct devlink_trap *trap,
 235                                   void *trap_ctx)
 236 {
 237         struct mlx5_core_dev *dev = devlink_priv(devlink);
 238         struct mlx5_devlink_trap *dl_trap;
 239
 240         dl_trap = kzalloc(sizeof(*dl_trap), GFP_KERNEL);
 241         if (!dl_trap)
 242                 return -ENOMEM;
 243
 244         dl_trap->trap.id = trap->id;
 245         dl_trap->trap.action = DEVLINK_TRAP_ACTION_DROP;
 246         dl_trap->item = trap_ctx;
 247
 248         if (mlx5_find_trap_by_id(dev, trap->id)) {
 249                 kfree(dl_trap);
 250                 mlx5_core_err(dev, "Devlink trap: Trap 0x%x already found", trap->id);
 251                 return -EEXIST;
 252         }
 253
 254         list_add_tail(&dl_trap->list, &dev->priv.traps);
 255         return 0;
 256 }
 257
 258 static void mlx5_devlink_trap_fini(struct devlink *devlink, const struct devlink_trap *trap,
 259                                    void *trap_ctx)
 260 {
 261         struct mlx5_core_dev *dev = devlink_priv(devlink);
 262         struct mlx5_devlink_trap *dl_trap;
 263
 264         dl_trap = mlx5_find_trap_by_id(dev, trap->id);
 265         if (!dl_trap) {
 266                 mlx5_core_err(dev, "Devlink trap: Missing trap id 0x%x", trap->id);
 267                 return;
 268         }
 269         list_del(&dl_trap->list);
 270         kfree(dl_trap);
 271 }
 272
 273 static int mlx5_devlink_trap_action_set(struct devlink *devlink,
 274                                         const struct devlink_trap *trap,
 275                                         enum devlink_trap_action action,
 276                                         struct netlink_ext_ack *extack)
 277 {
 278         struct mlx5_core_dev *dev = devlink_priv(devlink);
 279         struct mlx5_devlink_trap_event_ctx trap_event_ctx;
 280         enum devlink_trap_action action_orig;
 281         struct mlx5_devlink_trap *dl_trap;
 282         int err;
 283
 284         if (is_mdev_switchdev_mode(dev)) {
 285                 NL_SET_ERR_MSG_MOD(extack, "Devlink traps can't be set in switchdev mode");
 286                 return -EOPNOTSUPP;
 287         }
 288
 289         dl_trap = mlx5_find_trap_by_id(dev, trap->id);
 290         if (!dl_trap) {
 291                 mlx5_core_err(dev, "Devlink trap: Set action on invalid trap id 0x%x", trap->id);
 292                 return -EINVAL;
 293         }
 294
 295         if (action != DEVLINK_TRAP_ACTION_DROP && action != DEVLINK_TRAP_ACTION_TRAP)
 296                 return -EOPNOTSUPP;
 297
 298         if (action == dl_trap->trap.action)
 299                 return 0;
 300
 301         action_orig = dl_trap->trap.action;
 302         dl_trap->trap.action = action;
 303         trap_event_ctx.trap = &dl_trap->trap;
 304         trap_event_ctx.err = 0;
 305         err = mlx5_blocking_notifier_call_chain(dev, MLX5_DRIVER_EVENT_TYPE_TRAP,
 306                                                 &trap_event_ctx);
 307         if (err == NOTIFY_BAD)
 308                 dl_trap->trap.action = action_orig;
 309
 310         return trap_event_ctx.err;
 311 }
 312
 313 static const struct devlink_ops mlx5_devlink_ops = {
 314 #ifdef CONFIG_MLX5_ESWITCH
 315         .eswitch_mode_set = mlx5_devlink_eswitch_mode_set,
 316         .eswitch_mode_get = mlx5_devlink_eswitch_mode_get,
 317         .eswitch_inline_mode_set = mlx5_devlink_eswitch_inline_mode_set,
 318         .eswitch_inline_mode_get = mlx5_devlink_eswitch_inline_mode_get,
 319         .eswitch_encap_mode_set = mlx5_devlink_eswitch_encap_mode_set,
 320         .eswitch_encap_mode_get = mlx5_devlink_eswitch_encap_mode_get,
 321         .rate_leaf_tx_share_set = mlx5_esw_devlink_rate_leaf_tx_share_set,
 322         .rate_leaf_tx_max_set = mlx5_esw_devlink_rate_leaf_tx_max_set,
 323         .rate_node_tx_share_set = mlx5_esw_devlink_rate_node_tx_share_set,
 324         .rate_node_tx_max_set = mlx5_esw_devlink_rate_node_tx_max_set,
 325         .rate_node_new = mlx5_esw_devlink_rate_node_new,
 326         .rate_node_del = mlx5_esw_devlink_rate_node_del,
 327         .rate_leaf_parent_set = mlx5_esw_devlink_rate_parent_set,
 328 #endif
 329 #ifdef CONFIG_MLX5_SF_MANAGER
 330         .port_new = mlx5_devlink_sf_port_new,
 331 #endif
 332         .flash_update = mlx5_devlink_flash_update,
 333         .info_get = mlx5_devlink_info_get,
 334         .reload_actions = BIT(DEVLINK_RELOAD_ACTION_DRIVER_REINIT) |
 335                           BIT(DEVLINK_RELOAD_ACTION_FW_ACTIVATE),
 336         .reload_limits = BIT(DEVLINK_RELOAD_LIMIT_NO_RESET),
 337         .reload_down = mlx5_devlink_reload_down,
 338         .reload_up = mlx5_devlink_reload_up,
 339         .trap_init = mlx5_devlink_trap_init,
 340         .trap_fini = mlx5_devlink_trap_fini,
 341         .trap_action_set = mlx5_devlink_trap_action_set,
 342 };
 343
 344 void mlx5_devlink_trap_report(struct mlx5_core_dev *dev, int trap_id, struct sk_buff *skb,
 345                               struct devlink_port *dl_port)
 346 {
 347         struct devlink *devlink = priv_to_devlink(dev);
 348         struct mlx5_devlink_trap *dl_trap;
 349
 350         dl_trap = mlx5_find_trap_by_id(dev, trap_id);
 351         if (!dl_trap) {
 352                 mlx5_core_err(dev, "Devlink trap: Report on invalid trap id 0x%x", trap_id);
 353                 return;
 354         }
 355
 356         if (dl_trap->trap.action != DEVLINK_TRAP_ACTION_TRAP) {
 357                 mlx5_core_dbg(dev, "Devlink trap: Trap id %d has action %d", trap_id,
 358                               dl_trap->trap.action);
 359                 return;
 360         }
 361         devlink_trap_report(devlink, skb, dl_trap->item, dl_port, NULL);
 362 }
 363
 364 int mlx5_devlink_trap_get_num_active(struct mlx5_core_dev *dev)
 365 {
 366         struct mlx5_devlink_trap *dl_trap;
 367         int count = 0;
 368
 369         list_for_each_entry(dl_trap, &dev->priv.traps, list)
 370                 if (dl_trap->trap.action == DEVLINK_TRAP_ACTION_TRAP)
 371                         count++;
 372
 373         return count;
 374 }
 375
 376 int mlx5_devlink_traps_get_action(struct mlx5_core_dev *dev, int trap_id,
 377                                   enum devlink_trap_action *action)
 378 {
 379         struct mlx5_devlink_trap *dl_trap;
 380
 381         dl_trap = mlx5_find_trap_by_id(dev, trap_id);
 382         if (!dl_trap) {
 383                 mlx5_core_err(dev, "Devlink trap: Get action on invalid trap id 0x%x",
 384                               trap_id);
 385                 return -EINVAL;
 386         }
 387
 388         *action = dl_trap->trap.action;
 389         return 0;
 390 }
 391
 392 struct devlink *mlx5_devlink_alloc(struct device *dev)
 393 {
 394         return devlink_alloc(&mlx5_devlink_ops, sizeof(struct mlx5_core_dev),
 395                              dev);
 396 }
 397
 398 void mlx5_devlink_free(struct devlink *devlink)
 399 {
 400         devlink_free(devlink);
 401 }
 402
 403 static int mlx5_devlink_enable_roce_validate(struct devlink *devlink, u32 id,
 404                                              union devlink_param_value val,
 405                                              struct netlink_ext_ack *extack)
 406 {
 407         struct mlx5_core_dev *dev = devlink_priv(devlink);
 408         bool new_state = val.vbool;
 409
 410         if (new_state && !MLX5_CAP_GEN(dev, roce) &&
 411             !(MLX5_CAP_GEN(dev, roce_rw_supported) && MLX5_CAP_GEN_MAX(dev, roce))) {
 412                 NL_SET_ERR_MSG_MOD(extack, "Device doesn't support RoCE");
 413                 return -EOPNOTSUPP;
 414         }
 415         if (mlx5_core_is_mp_slave(dev) || mlx5_lag_is_active(dev)) {
 416                 NL_SET_ERR_MSG_MOD(extack, "Multi port slave/Lag device can't configure RoCE");
 417                 return -EOPNOTSUPP;
 418         }
 419
 420         return 0;
 421 }
 422
 423 #ifdef CONFIG_MLX5_ESWITCH
 424 static int mlx5_devlink_large_group_num_validate(struct devlink *devlink, u32 id,
 425                                                  union devlink_param_value val,
 426                                                  struct netlink_ext_ack *extack)
 427 {
 428         int group_num = val.vu32;
 429
 430         if (group_num < 1 || group_num > 1024) {
 431                 NL_SET_ERR_MSG_MOD(extack,
 432                                    "Unsupported group number, supported range is 1-1024");
 433                 return -EOPNOTSUPP;
 434         }
 435
 436         return 0;
 437 }
 438 #endif
 439
 440 static int mlx5_devlink_eq_depth_validate(struct devlink *devlink, u32 id,
 441                                           union devlink_param_value val,
 442                                           struct netlink_ext_ack *extack)
 443 {
 444         return (val.vu32 >= 64 && val.vu32 <= 4096) ? 0 : -EINVAL;
 445 }
 446
 447 static int
 448 mlx5_devlink_hairpin_num_queues_validate(struct devlink *devlink, u32 id,
 449                                          union devlink_param_value val,
 450                                          struct netlink_ext_ack *extack)
 451 {
 452         return val.vu32 ? 0 : -EINVAL;
 453 }
 454
 455 static int
 456 mlx5_devlink_hairpin_queue_size_validate(struct devlink *devlink, u32 id,
 457                                          union devlink_param_value val,
 458                                          struct netlink_ext_ack *extack)
 459 {
 460         struct mlx5_core_dev *dev = devlink_priv(devlink);
 461         u32 val32 = val.vu32;
 462
 463         if (!is_power_of_2(val32)) {
 464                 NL_SET_ERR_MSG_MOD(extack, "Value is not power of two");
 465                 return -EINVAL;
 466         }
 467
 468         if (val32 > BIT(MLX5_CAP_GEN(dev, log_max_hairpin_num_packets))) {
 469                 NL_SET_ERR_MSG_FMT_MOD(
 470                         extack, "Maximum hairpin queue size is %lu",
 471                         BIT(MLX5_CAP_GEN(dev, log_max_hairpin_num_packets)));
 472                 return -EINVAL;
 473         }
 474
 475         return 0;
 476 }
 477
 478 static void mlx5_devlink_hairpin_params_init_values(struct devlink *devlink)
 479 {
 480         struct mlx5_core_dev *dev = devlink_priv(devlink);
 481         union devlink_param_value value;
 482         u32 link_speed = 0;
 483         u64 link_speed64;
 484
 485         /* set hairpin pair per each 50Gbs share of the link */
 486         mlx5_port_max_linkspeed(dev, &link_speed);
 487         link_speed = max_t(u32, link_speed, 50000);
 488         link_speed64 = link_speed;
 489         do_div(link_speed64, 50000);
 490
 491         value.vu32 = link_speed64;
 492         devl_param_driverinit_value_set(
 493                 devlink, MLX5_DEVLINK_PARAM_ID_HAIRPIN_NUM_QUEUES, value);
 494
 495         value.vu32 =
 496                 BIT(min_t(u32, 16 - MLX5_MPWRQ_MIN_LOG_STRIDE_SZ(dev),
 497                           MLX5_CAP_GEN(dev, log_max_hairpin_num_packets)));
 498         devl_param_driverinit_value_set(
 499                 devlink, MLX5_DEVLINK_PARAM_ID_HAIRPIN_QUEUE_SIZE, value);
 500 }
 501
 502 static const struct devlink_param mlx5_devlink_params[] = {
 503         DEVLINK_PARAM_GENERIC(ENABLE_ROCE, BIT(DEVLINK_PARAM_CMODE_DRIVERINIT),
 504                               NULL, NULL, mlx5_devlink_enable_roce_validate),
 505 #ifdef CONFIG_MLX5_ESWITCH
 506         DEVLINK_PARAM_DRIVER(MLX5_DEVLINK_PARAM_ID_ESW_LARGE_GROUP_NUM,
 507                              "fdb_large_groups", DEVLINK_PARAM_TYPE_U32,
 508                              BIT(DEVLINK_PARAM_CMODE_DRIVERINIT),
 509                              NULL, NULL,
 510                              mlx5_devlink_large_group_num_validate),
 511 #endif
 512         DEVLINK_PARAM_GENERIC(IO_EQ_SIZE, BIT(DEVLINK_PARAM_CMODE_DRIVERINIT),
 513                               NULL, NULL, mlx5_devlink_eq_depth_validate),
 514         DEVLINK_PARAM_GENERIC(EVENT_EQ_SIZE, BIT(DEVLINK_PARAM_CMODE_DRIVERINIT),
 515                               NULL, NULL, mlx5_devlink_eq_depth_validate),
 516 };
 517
 518 static void mlx5_devlink_set_params_init_values(struct devlink *devlink)
 519 {
 520         struct mlx5_core_dev *dev = devlink_priv(devlink);
 521         union devlink_param_value value;
 522
 523         value.vbool = MLX5_CAP_GEN(dev, roce) && !mlx5_dev_is_lightweight(dev);
 524         devl_param_driverinit_value_set(devlink,
 525                                         DEVLINK_PARAM_GENERIC_ID_ENABLE_ROCE,
 526                                         value);
 527
 528 #ifdef CONFIG_MLX5_ESWITCH
 529         value.vu32 = ESW_OFFLOADS_DEFAULT_NUM_GROUPS;
 530         devl_param_driverinit_value_set(devlink,
 531                                         MLX5_DEVLINK_PARAM_ID_ESW_LARGE_GROUP_NUM,
 532                                         value);
 533 #endif
 534
 535         value.vu32 = MLX5_COMP_EQ_SIZE;
 536         devl_param_driverinit_value_set(devlink,
 537                                         DEVLINK_PARAM_GENERIC_ID_IO_EQ_SIZE,
 538                                         value);
 539
 540         value.vu32 = MLX5_NUM_ASYNC_EQE;
 541         devl_param_driverinit_value_set(devlink,
 542                                         DEVLINK_PARAM_GENERIC_ID_EVENT_EQ_SIZE,
 543                                         value);
 544 }
 545
 546 static const struct devlink_param mlx5_devlink_eth_params[] = {
 547         DEVLINK_PARAM_GENERIC(ENABLE_ETH, BIT(DEVLINK_PARAM_CMODE_DRIVERINIT),
 548                               NULL, NULL, NULL),
 549         DEVLINK_PARAM_DRIVER(MLX5_DEVLINK_PARAM_ID_HAIRPIN_NUM_QUEUES,
 550                              "hairpin_num_queues", DEVLINK_PARAM_TYPE_U32,
 551                              BIT(DEVLINK_PARAM_CMODE_DRIVERINIT), NULL, NULL,
 552                              mlx5_devlink_hairpin_num_queues_validate),
 553         DEVLINK_PARAM_DRIVER(MLX5_DEVLINK_PARAM_ID_HAIRPIN_QUEUE_SIZE,
 554                              "hairpin_queue_size", DEVLINK_PARAM_TYPE_U32,
 555                              BIT(DEVLINK_PARAM_CMODE_DRIVERINIT), NULL, NULL,
 556                              mlx5_devlink_hairpin_queue_size_validate),
 557 };
 558
 559 static int mlx5_devlink_eth_params_register(struct devlink *devlink)
 560 {
 561         struct mlx5_core_dev *dev = devlink_priv(devlink);
 562         union devlink_param_value value;
 563         int err;
 564
 565         if (!mlx5_eth_supported(dev))
 566                 return 0;
 567
 568         err = devl_params_register(devlink, mlx5_devlink_eth_params,
 569                                    ARRAY_SIZE(mlx5_devlink_eth_params));
 570         if (err)
 571                 return err;
 572
 573         value.vbool = !mlx5_dev_is_lightweight(dev);
 574         devl_param_driverinit_value_set(devlink,
 575                                         DEVLINK_PARAM_GENERIC_ID_ENABLE_ETH,
 576                                         value);
 577
 578         mlx5_devlink_hairpin_params_init_values(devlink);
 579
 580         return 0;
 581 }
 582
 583 static void mlx5_devlink_eth_params_unregister(struct devlink *devlink)
 584 {
 585         struct mlx5_core_dev *dev = devlink_priv(devlink);
 586
 587         if (!mlx5_eth_supported(dev))
 588                 return;
 589
 590         devl_params_unregister(devlink, mlx5_devlink_eth_params,
 591                                ARRAY_SIZE(mlx5_devlink_eth_params));
 592 }
 593
 594 static int mlx5_devlink_enable_rdma_validate(struct devlink *devlink, u32 id,
 595                                              union devlink_param_value val,
 596                                              struct netlink_ext_ack *extack)
 597 {
 598         struct mlx5_core_dev *dev = devlink_priv(devlink);
 599         bool new_state = val.vbool;
 600
 601         if (new_state && !mlx5_rdma_supported(dev))
 602                 return -EOPNOTSUPP;
 603         return 0;
 604 }
 605
 606 static const struct devlink_param mlx5_devlink_rdma_params[] = {
 607         DEVLINK_PARAM_GENERIC(ENABLE_RDMA, BIT(DEVLINK_PARAM_CMODE_DRIVERINIT),
 608                               NULL, NULL, mlx5_devlink_enable_rdma_validate),
 609 };
 610
 611 static int mlx5_devlink_rdma_params_register(struct devlink *devlink)
 612 {
 613         struct mlx5_core_dev *dev = devlink_priv(devlink);
 614         union devlink_param_value value;
 615         int err;
 616
 617         if (!IS_ENABLED(CONFIG_MLX5_INFINIBAND))
 618                 return 0;
 619
 620         err = devl_params_register(devlink, mlx5_devlink_rdma_params,
 621                                    ARRAY_SIZE(mlx5_devlink_rdma_params));
 622         if (err)
 623                 return err;
 624
 625         value.vbool = !mlx5_dev_is_lightweight(dev);
 626         devl_param_driverinit_value_set(devlink,
 627                                         DEVLINK_PARAM_GENERIC_ID_ENABLE_RDMA,
 628                                         value);
 629         return 0;
 630 }
 631
 632 static void mlx5_devlink_rdma_params_unregister(struct devlink *devlink)
 633 {
 634         if (!IS_ENABLED(CONFIG_MLX5_INFINIBAND))
 635                 return;
 636
 637         devl_params_unregister(devlink, mlx5_devlink_rdma_params,
 638                                ARRAY_SIZE(mlx5_devlink_rdma_params));
 639 }
 640
 641 static const struct devlink_param mlx5_devlink_vnet_params[] = {
 642         DEVLINK_PARAM_GENERIC(ENABLE_VNET, BIT(DEVLINK_PARAM_CMODE_DRIVERINIT),
 643                               NULL, NULL, NULL),
 644 };
 645
 646 static int mlx5_devlink_vnet_params_register(struct devlink *devlink)
 647 {
 648         struct mlx5_core_dev *dev = devlink_priv(devlink);
 649         union devlink_param_value value;
 650         int err;
 651
 652         if (!mlx5_vnet_supported(dev))
 653                 return 0;
 654
 655         err = devl_params_register(devlink, mlx5_devlink_vnet_params,
 656                                    ARRAY_SIZE(mlx5_devlink_vnet_params));
 657         if (err)
 658                 return err;
 659
 660         value.vbool = !mlx5_dev_is_lightweight(dev);
 661         devl_param_driverinit_value_set(devlink,
 662                                         DEVLINK_PARAM_GENERIC_ID_ENABLE_VNET,
 663                                         value);
 664         return 0;
 665 }
 666
 667 static void mlx5_devlink_vnet_params_unregister(struct devlink *devlink)
 668 {
 669         struct mlx5_core_dev *dev = devlink_priv(devlink);
 670
 671         if (!mlx5_vnet_supported(dev))
 672                 return;
 673
 674         devl_params_unregister(devlink, mlx5_devlink_vnet_params,
 675                                ARRAY_SIZE(mlx5_devlink_vnet_params));
 676 }
 677
 678 static int mlx5_devlink_auxdev_params_register(struct devlink *devlink)
 679 {
 680         int err;
 681
 682         err = mlx5_devlink_eth_params_register(devlink);
 683         if (err)
 684                 return err;
 685
 686         err = mlx5_devlink_rdma_params_register(devlink);
 687         if (err)
 688                 goto rdma_err;
 689
 690         err = mlx5_devlink_vnet_params_register(devlink);
 691         if (err)
 692                 goto vnet_err;
 693         return 0;
 694
 695 vnet_err:
 696         mlx5_devlink_rdma_params_unregister(devlink);
 697 rdma_err:
 698         mlx5_devlink_eth_params_unregister(devlink);
 699         return err;
 700 }
 701
 702 static void mlx5_devlink_auxdev_params_unregister(struct devlink *devlink)
 703 {
 704         mlx5_devlink_vnet_params_unregister(devlink);
 705         mlx5_devlink_rdma_params_unregister(devlink);
 706         mlx5_devlink_eth_params_unregister(devlink);
 707 }
 708
 709 static int mlx5_devlink_max_uc_list_validate(struct devlink *devlink, u32 id,
 710                                              union devlink_param_value val,
 711                                              struct netlink_ext_ack *extack)
 712 {
 713         struct mlx5_core_dev *dev = devlink_priv(devlink);
 714
 715         if (val.vu32 == 0) {
 716                 NL_SET_ERR_MSG_MOD(extack, "max_macs value must be greater than 0");
 717                 return -EINVAL;
 718         }
 719
 720         if (!is_power_of_2(val.vu32)) {
 721                 NL_SET_ERR_MSG_MOD(extack, "Only power of 2 values are supported for max_macs");
 722                 return -EINVAL;
 723         }
 724
 725         if (ilog2(val.vu32) >
 726             MLX5_CAP_GEN_MAX(dev, log_max_current_uc_list)) {
 727                 NL_SET_ERR_MSG_MOD(extack, "max_macs value is out of the supported range");
 728                 return -EINVAL;
 729         }
 730
 731         return 0;
 732 }
 733
 734 static const struct devlink_param mlx5_devlink_max_uc_list_params[] = {
 735         DEVLINK_PARAM_GENERIC(MAX_MACS, BIT(DEVLINK_PARAM_CMODE_DRIVERINIT),
 736                               NULL, NULL, mlx5_devlink_max_uc_list_validate),
 737 };
 738
 739 static int mlx5_devlink_max_uc_list_params_register(struct devlink *devlink)
 740 {
 741         struct mlx5_core_dev *dev = devlink_priv(devlink);
 742         union devlink_param_value value;
 743         int err;
 744
 745         if (!MLX5_CAP_GEN_MAX(dev, log_max_current_uc_list_wr_supported))
 746                 return 0;
 747
 748         err = devl_params_register(devlink, mlx5_devlink_max_uc_list_params,
 749                                    ARRAY_SIZE(mlx5_devlink_max_uc_list_params));
 750         if (err)
 751                 return err;
 752
 753         value.vu32 = 1 << MLX5_CAP_GEN(dev, log_max_current_uc_list);
 754         devl_param_driverinit_value_set(devlink,
 755                                         DEVLINK_PARAM_GENERIC_ID_MAX_MACS,
 756                                         value);
 757         return 0;
 758 }
 759
 760 static void
 761 mlx5_devlink_max_uc_list_params_unregister(struct devlink *devlink)
 762 {
 763         struct mlx5_core_dev *dev = devlink_priv(devlink);
 764
 765         if (!MLX5_CAP_GEN_MAX(dev, log_max_current_uc_list_wr_supported))
 766                 return;
 767
 768         devl_params_unregister(devlink, mlx5_devlink_max_uc_list_params,
 769                                ARRAY_SIZE(mlx5_devlink_max_uc_list_params));
 770 }
 771
 772 #define MLX5_TRAP_DROP(_id, _group_id)                                  \
 773         DEVLINK_TRAP_GENERIC(DROP, DROP, _id,                           \
 774                              DEVLINK_TRAP_GROUP_GENERIC_ID_##_group_id, \
 775                              DEVLINK_TRAP_METADATA_TYPE_F_IN_PORT)
 776
 777 static const struct devlink_trap mlx5_traps_arr[] = {
 778         MLX5_TRAP_DROP(INGRESS_VLAN_FILTER, L2_DROPS),
 779         MLX5_TRAP_DROP(DMAC_FILTER, L2_DROPS),
 780 };
 781
 782 static const struct devlink_trap_group mlx5_trap_groups_arr[] = {
 783         DEVLINK_TRAP_GROUP_GENERIC(L2_DROPS, 0),
 784 };
 785
 786 int mlx5_devlink_traps_register(struct devlink *devlink)
 787 {
 788         struct mlx5_core_dev *core_dev = devlink_priv(devlink);
 789         int err;
 790
 791         err = devl_trap_groups_register(devlink, mlx5_trap_groups_arr,
 792                                         ARRAY_SIZE(mlx5_trap_groups_arr));
 793         if (err)
 794                 return err;
 795
 796         err = devl_traps_register(devlink, mlx5_traps_arr, ARRAY_SIZE(mlx5_traps_arr),
 797                                   &core_dev->priv);
 798         if (err)
 799                 goto err_trap_group;
 800         return 0;
 801
 802 err_trap_group:
 803         devl_trap_groups_unregister(devlink, mlx5_trap_groups_arr,
 804                                     ARRAY_SIZE(mlx5_trap_groups_arr));
 805         return err;
 806 }
 807
 808 void mlx5_devlink_traps_unregister(struct devlink *devlink)
 809 {
 810         devl_traps_unregister(devlink, mlx5_traps_arr, ARRAY_SIZE(mlx5_traps_arr));
 811         devl_trap_groups_unregister(devlink, mlx5_trap_groups_arr,
 812                                     ARRAY_SIZE(mlx5_trap_groups_arr));
 813 }
 814
 815 int mlx5_devlink_params_register(struct devlink *devlink)
 816 {
 817         int err;
 818
 819         /* Here only the driver init params should be registered.
 820          * Runtime params should be registered by the code which
 821          * behaviour they configure.
 822          */
 823
 824         err = devl_params_register(devlink, mlx5_devlink_params,
 825                                    ARRAY_SIZE(mlx5_devlink_params));
 826         if (err)
 827                 return err;
 828
 829         mlx5_devlink_set_params_init_values(devlink);
 830
 831         err = mlx5_devlink_auxdev_params_register(devlink);
 832         if (err)
 833                 goto auxdev_reg_err;
 834
 835         err = mlx5_devlink_max_uc_list_params_register(devlink);
 836         if (err)
 837                 goto max_uc_list_err;
 838
 839         return 0;
 840
 841 max_uc_list_err:
 842         mlx5_devlink_auxdev_params_unregister(devlink);
 843 auxdev_reg_err:
 844         devl_params_unregister(devlink, mlx5_devlink_params,
 845                                ARRAY_SIZE(mlx5_devlink_params));
 846         return err;
 847 }
 848
 849 void mlx5_devlink_params_unregister(struct devlink *devlink)
 850 {
 851         mlx5_devlink_max_uc_list_params_unregister(devlink);
 852         mlx5_devlink_auxdev_params_unregister(devlink);
 853         devl_params_unregister(devlink, mlx5_devlink_params,
 854                                ARRAY_SIZE(mlx5_devlink_params));
 855 }