drivers/net/ethernet/broadcom/bnxt/bnxt_devlink.c

   1 /* Broadcom NetXtreme-C/E network driver.
   2  *
   3  * Copyright (c) 2017 Broadcom Limited
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation.
   8  */
   9
  10 #include <linux/pci.h>
  11 #include <linux/netdevice.h>
  12 #include <linux/vmalloc.h>
  13 #include <net/devlink.h>
  14 #include "bnxt_hsi.h"
  15 #include "bnxt.h"
  16 #include "bnxt_hwrm.h"
  17 #include "bnxt_vfr.h"
  18 #include "bnxt_devlink.h"
  19 #include "bnxt_ethtool.h"
  20 #include "bnxt_ulp.h"
  21 #include "bnxt_ptp.h"
  22 #include "bnxt_coredump.h"
  23
  24 static void __bnxt_fw_recover(struct bnxt *bp)
  25 {
  26         if (test_bit(BNXT_STATE_FW_FATAL_COND, &bp->state) ||
  27             test_bit(BNXT_STATE_FW_NON_FATAL_COND, &bp->state))
  28                 bnxt_fw_reset(bp);
  29         else
  30                 bnxt_fw_exception(bp);
  31 }
  32
  33 static int
  34 bnxt_dl_flash_update(struct devlink *dl,
  35                      struct devlink_flash_update_params *params,
  36                      struct netlink_ext_ack *extack)
  37 {
  38         struct bnxt *bp = bnxt_get_bp_from_dl(dl);
  39         int rc;
  40
  41         if (!BNXT_PF(bp)) {
  42                 NL_SET_ERR_MSG_MOD(extack,
  43                                    "flash update not supported from a VF");
  44                 return -EPERM;
  45         }
  46
  47         devlink_flash_update_status_notify(dl, "Preparing to flash", NULL, 0, 0);
  48         rc = bnxt_flash_package_from_fw_obj(bp->dev, params->fw, 0, extack);
  49         if (!rc)
  50                 devlink_flash_update_status_notify(dl, "Flashing done", NULL, 0, 0);
  51         else
  52                 devlink_flash_update_status_notify(dl, "Flashing failed", NULL, 0, 0);
  53         return rc;
  54 }
  55
  56 static int bnxt_hwrm_remote_dev_reset_set(struct bnxt *bp, bool remote_reset)
  57 {
  58         struct hwrm_func_cfg_input *req;
  59         int rc;
  60
  61         if (~bp->fw_cap & BNXT_FW_CAP_HOT_RESET_IF)
  62                 return -EOPNOTSUPP;
  63
  64         rc = hwrm_req_init(bp, req, HWRM_FUNC_CFG);
  65         if (rc)
  66                 return rc;
  67
  68         req->fid = cpu_to_le16(0xffff);
  69         req->enables = cpu_to_le32(FUNC_CFG_REQ_ENABLES_HOT_RESET_IF_SUPPORT);
  70         if (remote_reset)
  71                 req->flags = cpu_to_le32(FUNC_CFG_REQ_FLAGS_HOT_RESET_IF_EN_DIS);
  72
  73         return hwrm_req_send(bp, req);
  74 }
  75
  76 static char *bnxt_health_severity_str(enum bnxt_health_severity severity)
  77 {
  78         switch (severity) {
  79         case SEVERITY_NORMAL: return "normal";
  80         case SEVERITY_WARNING: return "warning";
  81         case SEVERITY_RECOVERABLE: return "recoverable";
  82         case SEVERITY_FATAL: return "fatal";
  83         default: return "unknown";
  84         }
  85 }
  86
  87 static char *bnxt_health_remedy_str(enum bnxt_health_remedy remedy)
  88 {
  89         switch (remedy) {
  90         case REMEDY_DEVLINK_RECOVER: return "devlink recover";
  91         case REMEDY_POWER_CYCLE_DEVICE: return "device power cycle";
  92         case REMEDY_POWER_CYCLE_HOST: return "host power cycle";
  93         case REMEDY_FW_UPDATE: return "update firmware";
  94         case REMEDY_HW_REPLACE: return "replace hardware";
  95         default: return "unknown";
  96         }
  97 }
  98
  99 static int bnxt_fw_diagnose(struct devlink_health_reporter *reporter,
 100                             struct devlink_fmsg *fmsg,
 101                             struct netlink_ext_ack *extack)
 102 {
 103         struct bnxt *bp = devlink_health_reporter_priv(reporter);
 104         struct bnxt_fw_health *h = bp->fw_health;
 105         u32 fw_status, fw_resets;
 106         int rc;
 107
 108         if (test_bit(BNXT_STATE_IN_FW_RESET, &bp->state))
 109                 return devlink_fmsg_string_pair_put(fmsg, "Status", "recovering");
 110
 111         if (!h->status_reliable)
 112                 return devlink_fmsg_string_pair_put(fmsg, "Status", "unknown");
 113
 114         mutex_lock(&h->lock);
 115         fw_status = bnxt_fw_health_readl(bp, BNXT_FW_HEALTH_REG);
 116         if (BNXT_FW_IS_BOOTING(fw_status)) {
 117                 rc = devlink_fmsg_string_pair_put(fmsg, "Status", "initializing");
 118                 if (rc)
 119                         goto unlock;
 120         } else if (h->severity || fw_status != BNXT_FW_STATUS_HEALTHY) {
 121                 if (!h->severity) {
 122                         h->severity = SEVERITY_FATAL;
 123                         h->remedy = REMEDY_POWER_CYCLE_DEVICE;
 124                         h->diagnoses++;
 125                         devlink_health_report(h->fw_reporter,
 126                                               "FW error diagnosed", h);
 127                 }
 128                 rc = devlink_fmsg_string_pair_put(fmsg, "Status", "error");
 129                 if (rc)
 130                         goto unlock;
 131                 rc = devlink_fmsg_u32_pair_put(fmsg, "Syndrome", fw_status);
 132                 if (rc)
 133                         goto unlock;
 134         } else {
 135                 rc = devlink_fmsg_string_pair_put(fmsg, "Status", "healthy");
 136                 if (rc)
 137                         goto unlock;
 138         }
 139
 140         rc = devlink_fmsg_string_pair_put(fmsg, "Severity",
 141                                           bnxt_health_severity_str(h->severity));
 142         if (rc)
 143                 goto unlock;
 144
 145         if (h->severity) {
 146                 rc = devlink_fmsg_string_pair_put(fmsg, "Remedy",
 147                                                   bnxt_health_remedy_str(h->remedy));
 148                 if (rc)
 149                         goto unlock;
 150                 if (h->remedy == REMEDY_DEVLINK_RECOVER) {
 151                         rc = devlink_fmsg_string_pair_put(fmsg, "Impact",
 152                                                           "traffic+ntuple_cfg");
 153                         if (rc)
 154                                 goto unlock;
 155                 }
 156         }
 157
 158 unlock:
 159         mutex_unlock(&h->lock);
 160         if (rc || !h->resets_reliable)
 161                 return rc;
 162
 163         fw_resets = bnxt_fw_health_readl(bp, BNXT_FW_RESET_CNT_REG);
 164         rc = devlink_fmsg_u32_pair_put(fmsg, "Resets", fw_resets);
 165         if (rc)
 166                 return rc;
 167         rc = devlink_fmsg_u32_pair_put(fmsg, "Arrests", h->arrests);
 168         if (rc)
 169                 return rc;
 170         rc = devlink_fmsg_u32_pair_put(fmsg, "Survivals", h->survivals);
 171         if (rc)
 172                 return rc;
 173         rc = devlink_fmsg_u32_pair_put(fmsg, "Discoveries", h->discoveries);
 174         if (rc)
 175                 return rc;
 176         rc = devlink_fmsg_u32_pair_put(fmsg, "Fatalities", h->fatalities);
 177         if (rc)
 178                 return rc;
 179         return devlink_fmsg_u32_pair_put(fmsg, "Diagnoses", h->diagnoses);
 180 }
 181
 182 static int bnxt_fw_dump(struct devlink_health_reporter *reporter,
 183                         struct devlink_fmsg *fmsg, void *priv_ctx,
 184                         struct netlink_ext_ack *extack)
 185 {
 186         struct bnxt *bp = devlink_health_reporter_priv(reporter);
 187         u32 dump_len;
 188         void *data;
 189         int rc;
 190
 191         /* TODO: no firmware dump support in devlink_health_report() context */
 192         if (priv_ctx)
 193                 return -EOPNOTSUPP;
 194
 195         dump_len = bnxt_get_coredump_length(bp, BNXT_DUMP_LIVE);
 196         if (!dump_len)
 197                 return -EIO;
 198
 199         data = vmalloc(dump_len);
 200         if (!data)
 201                 return -ENOMEM;
 202
 203         rc = bnxt_get_coredump(bp, BNXT_DUMP_LIVE, data, &dump_len);
 204         if (!rc) {
 205                 rc = devlink_fmsg_pair_nest_start(fmsg, "core");
 206                 if (rc)
 207                         goto exit;
 208                 rc = devlink_fmsg_binary_pair_put(fmsg, "data", data, dump_len);
 209                 if (rc)
 210                         goto exit;
 211                 rc = devlink_fmsg_u32_pair_put(fmsg, "size", dump_len);
 212                 if (rc)
 213                         goto exit;
 214                 rc = devlink_fmsg_pair_nest_end(fmsg);
 215         }
 216
 217 exit:
 218         vfree(data);
 219         return rc;
 220 }
 221
 222 static int bnxt_fw_recover(struct devlink_health_reporter *reporter,
 223                            void *priv_ctx,
 224                            struct netlink_ext_ack *extack)
 225 {
 226         struct bnxt *bp = devlink_health_reporter_priv(reporter);
 227
 228         if (bp->fw_health->severity == SEVERITY_FATAL)
 229                 return -ENODEV;
 230
 231         set_bit(BNXT_STATE_RECOVER, &bp->state);
 232         __bnxt_fw_recover(bp);
 233
 234         return -EINPROGRESS;
 235 }
 236
 237 static const struct devlink_health_reporter_ops bnxt_dl_fw_reporter_ops = {
 238         .name = "fw",
 239         .diagnose = bnxt_fw_diagnose,
 240         .dump = bnxt_fw_dump,
 241         .recover = bnxt_fw_recover,
 242 };
 243
 244 static struct devlink_health_reporter *
 245 __bnxt_dl_reporter_create(struct bnxt *bp,
 246                           const struct devlink_health_reporter_ops *ops)
 247 {
 248         struct devlink_health_reporter *reporter;
 249
 250         reporter = devlink_health_reporter_create(bp->dl, ops, 0, bp);
 251         if (IS_ERR(reporter)) {
 252                 netdev_warn(bp->dev, "Failed to create %s health reporter, rc = %ld\n",
 253                             ops->name, PTR_ERR(reporter));
 254                 return NULL;
 255         }
 256
 257         return reporter;
 258 }
 259
 260 void bnxt_dl_fw_reporters_create(struct bnxt *bp)
 261 {
 262         struct bnxt_fw_health *fw_health = bp->fw_health;
 263
 264         if (fw_health && !fw_health->fw_reporter)
 265                 fw_health->fw_reporter = __bnxt_dl_reporter_create(bp, &bnxt_dl_fw_reporter_ops);
 266 }
 267
 268 void bnxt_dl_fw_reporters_destroy(struct bnxt *bp)
 269 {
 270         struct bnxt_fw_health *fw_health = bp->fw_health;
 271
 272         if (fw_health && fw_health->fw_reporter) {
 273                 devlink_health_reporter_destroy(fw_health->fw_reporter);
 274                 fw_health->fw_reporter = NULL;
 275         }
 276 }
 277
 278 void bnxt_devlink_health_fw_report(struct bnxt *bp)
 279 {
 280         struct bnxt_fw_health *fw_health = bp->fw_health;
 281         int rc;
 282
 283         if (!fw_health)
 284                 return;
 285
 286         if (!fw_health->fw_reporter) {
 287                 __bnxt_fw_recover(bp);
 288                 return;
 289         }
 290
 291         mutex_lock(&fw_health->lock);
 292         fw_health->severity = SEVERITY_RECOVERABLE;
 293         fw_health->remedy = REMEDY_DEVLINK_RECOVER;
 294         mutex_unlock(&fw_health->lock);
 295         rc = devlink_health_report(fw_health->fw_reporter, "FW error reported",
 296                                    fw_health);
 297         if (rc == -ECANCELED)
 298                 __bnxt_fw_recover(bp);
 299 }
 300
 301 void bnxt_dl_health_fw_status_update(struct bnxt *bp, bool healthy)
 302 {
 303         struct bnxt_fw_health *fw_health = bp->fw_health;
 304         u8 state;
 305
 306         mutex_lock(&fw_health->lock);
 307         if (healthy) {
 308                 fw_health->severity = SEVERITY_NORMAL;
 309                 state = DEVLINK_HEALTH_REPORTER_STATE_HEALTHY;
 310         } else {
 311                 fw_health->severity = SEVERITY_FATAL;
 312                 fw_health->remedy = REMEDY_POWER_CYCLE_DEVICE;
 313                 state = DEVLINK_HEALTH_REPORTER_STATE_ERROR;
 314         }
 315         mutex_unlock(&fw_health->lock);
 316         devlink_health_reporter_state_update(fw_health->fw_reporter, state);
 317 }
 318
 319 void bnxt_dl_health_fw_recovery_done(struct bnxt *bp)
 320 {
 321         struct bnxt_dl *dl = devlink_priv(bp->dl);
 322
 323         devlink_health_reporter_recovery_done(bp->fw_health->fw_reporter);
 324         bnxt_hwrm_remote_dev_reset_set(bp, dl->remote_reset);
 325 }
 326
 327 static int bnxt_dl_info_get(struct devlink *dl, struct devlink_info_req *req,
 328                             struct netlink_ext_ack *extack);
 329
 330 static void
 331 bnxt_dl_livepatch_report_err(struct bnxt *bp, struct netlink_ext_ack *extack,
 332                              struct hwrm_fw_livepatch_output *resp)
 333 {
 334         int err = ((struct hwrm_err_output *)resp)->cmd_err;
 335
 336         switch (err) {
 337         case FW_LIVEPATCH_CMD_ERR_CODE_INVALID_OPCODE:
 338                 netdev_err(bp->dev, "Illegal live patch opcode");
 339                 NL_SET_ERR_MSG_MOD(extack, "Invalid opcode");
 340                 break;
 341         case FW_LIVEPATCH_CMD_ERR_CODE_NOT_SUPPORTED:
 342                 NL_SET_ERR_MSG_MOD(extack, "Live patch operation not supported");
 343                 break;
 344         case FW_LIVEPATCH_CMD_ERR_CODE_NOT_INSTALLED:
 345                 NL_SET_ERR_MSG_MOD(extack, "Live patch not found");
 346                 break;
 347         case FW_LIVEPATCH_CMD_ERR_CODE_NOT_PATCHED:
 348                 NL_SET_ERR_MSG_MOD(extack,
 349                                    "Live patch deactivation failed. Firmware not patched.");
 350                 break;
 351         case FW_LIVEPATCH_CMD_ERR_CODE_AUTH_FAIL:
 352                 NL_SET_ERR_MSG_MOD(extack, "Live patch not authenticated");
 353                 break;
 354         case FW_LIVEPATCH_CMD_ERR_CODE_INVALID_HEADER:
 355                 NL_SET_ERR_MSG_MOD(extack, "Incompatible live patch");
 356                 break;
 357         case FW_LIVEPATCH_CMD_ERR_CODE_INVALID_SIZE:
 358                 NL_SET_ERR_MSG_MOD(extack, "Live patch has invalid size");
 359                 break;
 360         case FW_LIVEPATCH_CMD_ERR_CODE_ALREADY_PATCHED:
 361                 NL_SET_ERR_MSG_MOD(extack, "Live patch already applied");
 362                 break;
 363         default:
 364                 netdev_err(bp->dev, "Unexpected live patch error: %d\n", err);
 365                 NL_SET_ERR_MSG_MOD(extack, "Failed to activate live patch");
 366                 break;
 367         }
 368 }
 369
 370 /* Live patch status in NVM */
 371 #define BNXT_LIVEPATCH_NOT_INSTALLED    0
 372 #define BNXT_LIVEPATCH_INSTALLED        FW_LIVEPATCH_QUERY_RESP_STATUS_FLAGS_INSTALL
 373 #define BNXT_LIVEPATCH_REMOVED          FW_LIVEPATCH_QUERY_RESP_STATUS_FLAGS_ACTIVE
 374 #define BNXT_LIVEPATCH_MASK             (FW_LIVEPATCH_QUERY_RESP_STATUS_FLAGS_INSTALL | \
 375                                          FW_LIVEPATCH_QUERY_RESP_STATUS_FLAGS_ACTIVE)
 376 #define BNXT_LIVEPATCH_ACTIVATED        BNXT_LIVEPATCH_MASK
 377
 378 #define BNXT_LIVEPATCH_STATE(flags)     ((flags) & BNXT_LIVEPATCH_MASK)
 379
 380 static int
 381 bnxt_dl_livepatch_activate(struct bnxt *bp, struct netlink_ext_ack *extack)
 382 {
 383         struct hwrm_fw_livepatch_query_output *query_resp;
 384         struct hwrm_fw_livepatch_query_input *query_req;
 385         struct hwrm_fw_livepatch_output *patch_resp;
 386         struct hwrm_fw_livepatch_input *patch_req;
 387         u16 flags, live_patch_state;
 388         bool activated = false;
 389         u32 installed = 0;
 390         u8 target;
 391         int rc;
 392
 393         if (~bp->fw_cap & BNXT_FW_CAP_LIVEPATCH) {
 394                 NL_SET_ERR_MSG_MOD(extack, "Device does not support live patch");
 395                 return -EOPNOTSUPP;
 396         }
 397
 398         rc = hwrm_req_init(bp, query_req, HWRM_FW_LIVEPATCH_QUERY);
 399         if (rc)
 400                 return rc;
 401         query_resp = hwrm_req_hold(bp, query_req);
 402
 403         rc = hwrm_req_init(bp, patch_req, HWRM_FW_LIVEPATCH);
 404         if (rc) {
 405                 hwrm_req_drop(bp, query_req);
 406                 return rc;
 407         }
 408         patch_req->loadtype = FW_LIVEPATCH_REQ_LOADTYPE_NVM_INSTALL;
 409         patch_resp = hwrm_req_hold(bp, patch_req);
 410
 411         for (target = 1; target <= FW_LIVEPATCH_REQ_FW_TARGET_LAST; target++) {
 412                 query_req->fw_target = target;
 413                 rc = hwrm_req_send(bp, query_req);
 414                 if (rc) {
 415                         NL_SET_ERR_MSG_MOD(extack, "Failed to query packages");
 416                         break;
 417                 }
 418
 419                 flags = le16_to_cpu(query_resp->status_flags);
 420                 live_patch_state = BNXT_LIVEPATCH_STATE(flags);
 421
 422                 if (live_patch_state == BNXT_LIVEPATCH_NOT_INSTALLED)
 423                         continue;
 424
 425                 if (live_patch_state == BNXT_LIVEPATCH_ACTIVATED) {
 426                         activated = true;
 427                         continue;
 428                 }
 429
 430                 if (live_patch_state == BNXT_LIVEPATCH_INSTALLED)
 431                         patch_req->opcode = FW_LIVEPATCH_REQ_OPCODE_ACTIVATE;
 432                 else if (live_patch_state == BNXT_LIVEPATCH_REMOVED)
 433                         patch_req->opcode = FW_LIVEPATCH_REQ_OPCODE_DEACTIVATE;
 434
 435                 patch_req->fw_target = target;
 436                 rc = hwrm_req_send(bp, patch_req);
 437                 if (rc) {
 438                         bnxt_dl_livepatch_report_err(bp, extack, patch_resp);
 439                         break;
 440                 }
 441                 installed++;
 442         }
 443
 444         if (!rc && !installed) {
 445                 if (activated) {
 446                         NL_SET_ERR_MSG_MOD(extack, "Live patch already activated");
 447                         rc = -EEXIST;
 448                 } else {
 449                         NL_SET_ERR_MSG_MOD(extack, "No live patches found");
 450                         rc = -ENOENT;
 451                 }
 452         }
 453         hwrm_req_drop(bp, query_req);
 454         hwrm_req_drop(bp, patch_req);
 455         return rc;
 456 }
 457
 458 static int bnxt_dl_reload_down(struct devlink *dl, bool netns_change,
 459                                enum devlink_reload_action action,
 460                                enum devlink_reload_limit limit,
 461                                struct netlink_ext_ack *extack)
 462 {
 463         struct bnxt *bp = bnxt_get_bp_from_dl(dl);
 464         int rc = 0;
 465
 466         switch (action) {
 467         case DEVLINK_RELOAD_ACTION_DRIVER_REINIT: {
 468                 rtnl_lock();
 469                 if (bnxt_sriov_cfg(bp)) {
 470                         NL_SET_ERR_MSG_MOD(extack,
 471                                            "reload is unsupported while VFs are allocated or being configured");
 472                         rtnl_unlock();
 473                         return -EOPNOTSUPP;
 474                 }
 475                 if (bp->dev->reg_state == NETREG_UNREGISTERED) {
 476                         rtnl_unlock();
 477                         return -ENODEV;
 478                 }
 479                 bnxt_ulp_stop(bp);
 480                 if (netif_running(bp->dev)) {
 481                         rc = bnxt_close_nic(bp, true, true);
 482                         if (rc) {
 483                                 NL_SET_ERR_MSG_MOD(extack, "Failed to close");
 484                                 dev_close(bp->dev);
 485                                 rtnl_unlock();
 486                                 break;
 487                         }
 488                 }
 489                 bnxt_vf_reps_free(bp);
 490                 rc = bnxt_hwrm_func_drv_unrgtr(bp);
 491                 if (rc) {
 492                         NL_SET_ERR_MSG_MOD(extack, "Failed to deregister");
 493                         if (netif_running(bp->dev))
 494                                 dev_close(bp->dev);
 495                         rtnl_unlock();
 496                         break;
 497                 }
 498                 bnxt_cancel_reservations(bp, false);
 499                 bnxt_free_ctx_mem(bp);
 500                 kfree(bp->ctx);
 501                 bp->ctx = NULL;
 502                 break;
 503         }
 504         case DEVLINK_RELOAD_ACTION_FW_ACTIVATE: {
 505                 if (limit == DEVLINK_RELOAD_LIMIT_NO_RESET)
 506                         return bnxt_dl_livepatch_activate(bp, extack);
 507                 if (~bp->fw_cap & BNXT_FW_CAP_HOT_RESET) {
 508                         NL_SET_ERR_MSG_MOD(extack, "Device not capable, requires reboot");
 509                         return -EOPNOTSUPP;
 510                 }
 511                 if (!bnxt_hwrm_reset_permitted(bp)) {
 512                         NL_SET_ERR_MSG_MOD(extack,
 513                                            "Reset denied by firmware, it may be inhibited by remote driver");
 514                         return -EPERM;
 515                 }
 516                 rtnl_lock();
 517                 if (bp->dev->reg_state == NETREG_UNREGISTERED) {
 518                         rtnl_unlock();
 519                         return -ENODEV;
 520                 }
 521                 if (netif_running(bp->dev))
 522                         set_bit(BNXT_STATE_FW_ACTIVATE, &bp->state);
 523                 rc = bnxt_hwrm_firmware_reset(bp->dev,
 524                                               FW_RESET_REQ_EMBEDDED_PROC_TYPE_CHIP,
 525                                               FW_RESET_REQ_SELFRST_STATUS_SELFRSTASAP,
 526                                               FW_RESET_REQ_FLAGS_RESET_GRACEFUL |
 527                                               FW_RESET_REQ_FLAGS_FW_ACTIVATION);
 528                 if (rc) {
 529                         NL_SET_ERR_MSG_MOD(extack, "Failed to activate firmware");
 530                         clear_bit(BNXT_STATE_FW_ACTIVATE, &bp->state);
 531                         rtnl_unlock();
 532                 }
 533                 break;
 534         }
 535         default:
 536                 rc = -EOPNOTSUPP;
 537         }
 538
 539         return rc;
 540 }
 541
 542 static int bnxt_dl_reload_up(struct devlink *dl, enum devlink_reload_action action,
 543                              enum devlink_reload_limit limit, u32 *actions_performed,
 544                              struct netlink_ext_ack *extack)
 545 {
 546         struct bnxt *bp = bnxt_get_bp_from_dl(dl);
 547         int rc = 0;
 548
 549         *actions_performed = 0;
 550         switch (action) {
 551         case DEVLINK_RELOAD_ACTION_DRIVER_REINIT: {
 552                 bnxt_fw_init_one(bp);
 553                 bnxt_vf_reps_alloc(bp);
 554                 if (netif_running(bp->dev))
 555                         rc = bnxt_open_nic(bp, true, true);
 556                 bnxt_ulp_start(bp, rc);
 557                 if (!rc) {
 558                         bnxt_reenable_sriov(bp);
 559                         bnxt_ptp_reapply_pps(bp);
 560                 }
 561                 break;
 562         }
 563         case DEVLINK_RELOAD_ACTION_FW_ACTIVATE: {
 564                 unsigned long start = jiffies;
 565                 unsigned long timeout = start + BNXT_DFLT_FW_RST_MAX_DSECS * HZ / 10;
 566
 567                 if (limit == DEVLINK_RELOAD_LIMIT_NO_RESET)
 568                         break;
 569                 if (bp->fw_cap & BNXT_FW_CAP_ERROR_RECOVERY)
 570                         timeout = start + bp->fw_health->normal_func_wait_dsecs * HZ / 10;
 571                 if (!netif_running(bp->dev))
 572                         NL_SET_ERR_MSG_MOD(extack,
 573                                            "Device is closed, not waiting for reset notice that will never come");
 574                 rtnl_unlock();
 575                 while (test_bit(BNXT_STATE_FW_ACTIVATE, &bp->state)) {
 576                         if (time_after(jiffies, timeout)) {
 577                                 NL_SET_ERR_MSG_MOD(extack, "Activation incomplete");
 578                                 rc = -ETIMEDOUT;
 579                                 break;
 580                         }
 581                         if (test_bit(BNXT_STATE_ABORT_ERR, &bp->state)) {
 582                                 NL_SET_ERR_MSG_MOD(extack, "Activation aborted");
 583                                 rc = -ENODEV;
 584                                 break;
 585                         }
 586                         msleep(50);
 587                 }
 588                 rtnl_lock();
 589                 if (!rc)
 590                         *actions_performed |= BIT(DEVLINK_RELOAD_ACTION_DRIVER_REINIT);
 591                 clear_bit(BNXT_STATE_FW_ACTIVATE, &bp->state);
 592                 break;
 593         }
 594         default:
 595                 return -EOPNOTSUPP;
 596         }
 597
 598         if (!rc) {
 599                 bnxt_print_device_info(bp);
 600                 if (netif_running(bp->dev)) {
 601                         mutex_lock(&bp->link_lock);
 602                         bnxt_report_link(bp);
 603                         mutex_unlock(&bp->link_lock);
 604                 }
 605                 *actions_performed |= BIT(action);
 606         } else if (netif_running(bp->dev)) {
 607                 dev_close(bp->dev);
 608         }
 609         rtnl_unlock();
 610         return rc;
 611 }
 612
 613 static const struct devlink_ops bnxt_dl_ops = {
 614 #ifdef CONFIG_BNXT_SRIOV
 615         .eswitch_mode_set = bnxt_dl_eswitch_mode_set,
 616         .eswitch_mode_get = bnxt_dl_eswitch_mode_get,
 617 #endif /* CONFIG_BNXT_SRIOV */
 618         .info_get         = bnxt_dl_info_get,
 619         .flash_update     = bnxt_dl_flash_update,
 620         .reload_actions   = BIT(DEVLINK_RELOAD_ACTION_DRIVER_REINIT) |
 621                             BIT(DEVLINK_RELOAD_ACTION_FW_ACTIVATE),
 622         .reload_limits    = BIT(DEVLINK_RELOAD_LIMIT_NO_RESET),
 623         .reload_down      = bnxt_dl_reload_down,
 624         .reload_up        = bnxt_dl_reload_up,
 625 };
 626
 627 static const struct devlink_ops bnxt_vf_dl_ops;
 628
 629 enum bnxt_dl_param_id {
 630         BNXT_DEVLINK_PARAM_ID_BASE = DEVLINK_PARAM_GENERIC_ID_MAX,
 631         BNXT_DEVLINK_PARAM_ID_GRE_VER_CHECK,
 632 };
 633
 634 static const struct bnxt_dl_nvm_param nvm_params[] = {
 635         {DEVLINK_PARAM_GENERIC_ID_ENABLE_SRIOV, NVM_OFF_ENABLE_SRIOV,
 636          BNXT_NVM_SHARED_CFG, 1, 1},
 637         {DEVLINK_PARAM_GENERIC_ID_IGNORE_ARI, NVM_OFF_IGNORE_ARI,
 638          BNXT_NVM_SHARED_CFG, 1, 1},
 639         {DEVLINK_PARAM_GENERIC_ID_MSIX_VEC_PER_PF_MAX,
 640          NVM_OFF_MSIX_VEC_PER_PF_MAX, BNXT_NVM_SHARED_CFG, 10, 4},
 641         {DEVLINK_PARAM_GENERIC_ID_MSIX_VEC_PER_PF_MIN,
 642          NVM_OFF_MSIX_VEC_PER_PF_MIN, BNXT_NVM_SHARED_CFG, 7, 4},
 643         {BNXT_DEVLINK_PARAM_ID_GRE_VER_CHECK, NVM_OFF_DIS_GRE_VER_CHECK,
 644          BNXT_NVM_SHARED_CFG, 1, 1},
 645 };
 646
 647 union bnxt_nvm_data {
 648         u8      val8;
 649         __le32  val32;
 650 };
 651
 652 static void bnxt_copy_to_nvm_data(union bnxt_nvm_data *dst,
 653                                   union devlink_param_value *src,
 654                                   int nvm_num_bits, int dl_num_bytes)
 655 {
 656         u32 val32 = 0;
 657
 658         if (nvm_num_bits == 1) {
 659                 dst->val8 = src->vbool;
 660                 return;
 661         }
 662         if (dl_num_bytes == 4)
 663                 val32 = src->vu32;
 664         else if (dl_num_bytes == 2)
 665                 val32 = (u32)src->vu16;
 666         else if (dl_num_bytes == 1)
 667                 val32 = (u32)src->vu8;
 668         dst->val32 = cpu_to_le32(val32);
 669 }
 670
 671 static void bnxt_copy_from_nvm_data(union devlink_param_value *dst,
 672                                     union bnxt_nvm_data *src,
 673                                     int nvm_num_bits, int dl_num_bytes)
 674 {
 675         u32 val32;
 676
 677         if (nvm_num_bits == 1) {
 678                 dst->vbool = src->val8;
 679                 return;
 680         }
 681         val32 = le32_to_cpu(src->val32);
 682         if (dl_num_bytes == 4)
 683                 dst->vu32 = val32;
 684         else if (dl_num_bytes == 2)
 685                 dst->vu16 = (u16)val32;
 686         else if (dl_num_bytes == 1)
 687                 dst->vu8 = (u8)val32;
 688 }
 689
 690 static int bnxt_hwrm_get_nvm_cfg_ver(struct bnxt *bp, u32 *nvm_cfg_ver)
 691 {
 692         struct hwrm_nvm_get_variable_input *req;
 693         u16 bytes = BNXT_NVM_CFG_VER_BYTES;
 694         u16 bits = BNXT_NVM_CFG_VER_BITS;
 695         union devlink_param_value ver;
 696         union bnxt_nvm_data *data;
 697         dma_addr_t data_dma_addr;
 698         int rc, i = 2;
 699         u16 dim = 1;
 700
 701         rc = hwrm_req_init(bp, req, HWRM_NVM_GET_VARIABLE);
 702         if (rc)
 703                 return rc;
 704
 705         data = hwrm_req_dma_slice(bp, req, sizeof(*data), &data_dma_addr);
 706         if (!data) {
 707                 rc = -ENOMEM;
 708                 goto exit;
 709         }
 710
 711         /* earlier devices present as an array of raw bytes */
 712         if (!BNXT_CHIP_P5(bp)) {
 713                 dim = 0;
 714                 i = 0;
 715                 bits *= 3;  /* array of 3 version components */
 716                 bytes *= 4; /* copy whole word */
 717         }
 718
 719         hwrm_req_hold(bp, req);
 720         req->dest_data_addr = cpu_to_le64(data_dma_addr);
 721         req->data_len = cpu_to_le16(bits);
 722         req->option_num = cpu_to_le16(NVM_OFF_NVM_CFG_VER);
 723         req->dimensions = cpu_to_le16(dim);
 724
 725         while (i >= 0) {
 726                 req->index_0 = cpu_to_le16(i--);
 727                 rc = hwrm_req_send_silent(bp, req);
 728                 if (rc)
 729                         goto exit;
 730                 bnxt_copy_from_nvm_data(&ver, data, bits, bytes);
 731
 732                 if (BNXT_CHIP_P5(bp)) {
 733                         *nvm_cfg_ver <<= 8;
 734                         *nvm_cfg_ver |= ver.vu8;
 735                 } else {
 736                         *nvm_cfg_ver = ver.vu32;
 737                 }
 738         }
 739
 740 exit:
 741         hwrm_req_drop(bp, req);
 742         return rc;
 743 }
 744
 745 static int bnxt_dl_info_put(struct bnxt *bp, struct devlink_info_req *req,
 746                             enum bnxt_dl_version_type type, const char *key,
 747                             char *buf)
 748 {
 749         if (!strlen(buf))
 750                 return 0;
 751
 752         if ((bp->flags & BNXT_FLAG_CHIP_P5) &&
 753             (!strcmp(key, DEVLINK_INFO_VERSION_GENERIC_FW_NCSI) ||
 754              !strcmp(key, DEVLINK_INFO_VERSION_GENERIC_FW_ROCE)))
 755                 return 0;
 756
 757         switch (type) {
 758         case BNXT_VERSION_FIXED:
 759                 return devlink_info_version_fixed_put(req, key, buf);
 760         case BNXT_VERSION_RUNNING:
 761                 return devlink_info_version_running_put(req, key, buf);
 762         case BNXT_VERSION_STORED:
 763                 return devlink_info_version_stored_put(req, key, buf);
 764         }
 765         return 0;
 766 }
 767
 768 #define BNXT_FW_SRT_PATCH       "fw.srt.patch"
 769 #define BNXT_FW_CRT_PATCH       "fw.crt.patch"
 770
 771 static int bnxt_dl_livepatch_info_put(struct bnxt *bp,
 772                                       struct devlink_info_req *req,
 773                                       const char *key)
 774 {
 775         struct hwrm_fw_livepatch_query_input *query;
 776         struct hwrm_fw_livepatch_query_output *resp;
 777         u16 flags;
 778         int rc;
 779
 780         if (~bp->fw_cap & BNXT_FW_CAP_LIVEPATCH)
 781                 return 0;
 782
 783         rc = hwrm_req_init(bp, query, HWRM_FW_LIVEPATCH_QUERY);
 784         if (rc)
 785                 return rc;
 786
 787         if (!strcmp(key, BNXT_FW_SRT_PATCH))
 788                 query->fw_target = FW_LIVEPATCH_QUERY_REQ_FW_TARGET_SECURE_FW;
 789         else if (!strcmp(key, BNXT_FW_CRT_PATCH))
 790                 query->fw_target = FW_LIVEPATCH_QUERY_REQ_FW_TARGET_COMMON_FW;
 791         else
 792                 goto exit;
 793
 794         resp = hwrm_req_hold(bp, query);
 795         rc = hwrm_req_send(bp, query);
 796         if (rc)
 797                 goto exit;
 798
 799         flags = le16_to_cpu(resp->status_flags);
 800         if (flags & FW_LIVEPATCH_QUERY_RESP_STATUS_FLAGS_ACTIVE) {
 801                 resp->active_ver[sizeof(resp->active_ver) - 1] = '\0';
 802                 rc = devlink_info_version_running_put(req, key, resp->active_ver);
 803                 if (rc)
 804                         goto exit;
 805         }
 806
 807         if (flags & FW_LIVEPATCH_QUERY_RESP_STATUS_FLAGS_INSTALL) {
 808                 resp->install_ver[sizeof(resp->install_ver) - 1] = '\0';
 809                 rc = devlink_info_version_stored_put(req, key, resp->install_ver);
 810                 if (rc)
 811                         goto exit;
 812         }
 813
 814 exit:
 815         hwrm_req_drop(bp, query);
 816         return rc;
 817 }
 818
 819 #define HWRM_FW_VER_STR_LEN     16
 820
 821 static int bnxt_dl_info_get(struct devlink *dl, struct devlink_info_req *req,
 822                             struct netlink_ext_ack *extack)
 823 {
 824         struct hwrm_nvm_get_dev_info_output nvm_dev_info;
 825         struct bnxt *bp = bnxt_get_bp_from_dl(dl);
 826         struct hwrm_ver_get_output *ver_resp;
 827         char mgmt_ver[FW_VER_STR_LEN];
 828         char roce_ver[FW_VER_STR_LEN];
 829         char ncsi_ver[FW_VER_STR_LEN];
 830         char buf[32];
 831         u32 ver = 0;
 832         int rc;
 833
 834         rc = devlink_info_driver_name_put(req, DRV_MODULE_NAME);
 835         if (rc)
 836                 return rc;
 837
 838         if (BNXT_PF(bp) && (bp->flags & BNXT_FLAG_DSN_VALID)) {
 839                 sprintf(buf, "%02X-%02X-%02X-%02X-%02X-%02X-%02X-%02X",
 840                         bp->dsn[7], bp->dsn[6], bp->dsn[5], bp->dsn[4],
 841                         bp->dsn[3], bp->dsn[2], bp->dsn[1], bp->dsn[0]);
 842                 rc = devlink_info_serial_number_put(req, buf);
 843                 if (rc)
 844                         return rc;
 845         }
 846
 847         if (strlen(bp->board_serialno)) {
 848                 rc = devlink_info_board_serial_number_put(req, bp->board_serialno);
 849                 if (rc)
 850                         return rc;
 851         }
 852
 853         rc = bnxt_dl_info_put(bp, req, BNXT_VERSION_FIXED,
 854                               DEVLINK_INFO_VERSION_GENERIC_BOARD_ID,
 855                               bp->board_partno);
 856         if (rc)
 857                 return rc;
 858
 859         sprintf(buf, "%X", bp->chip_num);
 860         rc = bnxt_dl_info_put(bp, req, BNXT_VERSION_FIXED,
 861                               DEVLINK_INFO_VERSION_GENERIC_ASIC_ID, buf);
 862         if (rc)
 863                 return rc;
 864
 865         ver_resp = &bp->ver_resp;
 866         sprintf(buf, "%c%d", 'A' + ver_resp->chip_rev, ver_resp->chip_metal);
 867         rc = bnxt_dl_info_put(bp, req, BNXT_VERSION_FIXED,
 868                               DEVLINK_INFO_VERSION_GENERIC_ASIC_REV, buf);
 869         if (rc)
 870                 return rc;
 871
 872         rc = bnxt_dl_info_put(bp, req, BNXT_VERSION_RUNNING,
 873                               DEVLINK_INFO_VERSION_GENERIC_FW_PSID,
 874                               bp->nvm_cfg_ver);
 875         if (rc)
 876                 return rc;
 877
 878         buf[0] = 0;
 879         strncat(buf, ver_resp->active_pkg_name, HWRM_FW_VER_STR_LEN);
 880         rc = bnxt_dl_info_put(bp, req, BNXT_VERSION_RUNNING,
 881                               DEVLINK_INFO_VERSION_GENERIC_FW, buf);
 882         if (rc)
 883                 return rc;
 884
 885         if (BNXT_PF(bp) && !bnxt_hwrm_get_nvm_cfg_ver(bp, &ver)) {
 886                 sprintf(buf, "%d.%d.%d", (ver >> 16) & 0xff, (ver >> 8) & 0xff,
 887                         ver & 0xff);
 888                 rc = bnxt_dl_info_put(bp, req, BNXT_VERSION_STORED,
 889                                       DEVLINK_INFO_VERSION_GENERIC_FW_PSID,
 890                                       buf);
 891                 if (rc)
 892                         return rc;
 893         }
 894
 895         if (ver_resp->flags & VER_GET_RESP_FLAGS_EXT_VER_AVAIL) {
 896                 snprintf(mgmt_ver, FW_VER_STR_LEN, "%d.%d.%d.%d",
 897                          ver_resp->hwrm_fw_major, ver_resp->hwrm_fw_minor,
 898                          ver_resp->hwrm_fw_build, ver_resp->hwrm_fw_patch);
 899
 900                 snprintf(ncsi_ver, FW_VER_STR_LEN, "%d.%d.%d.%d",
 901                          ver_resp->mgmt_fw_major, ver_resp->mgmt_fw_minor,
 902                          ver_resp->mgmt_fw_build, ver_resp->mgmt_fw_patch);
 903
 904                 snprintf(roce_ver, FW_VER_STR_LEN, "%d.%d.%d.%d",
 905                          ver_resp->roce_fw_major, ver_resp->roce_fw_minor,
 906                          ver_resp->roce_fw_build, ver_resp->roce_fw_patch);
 907         } else {
 908                 snprintf(mgmt_ver, FW_VER_STR_LEN, "%d.%d.%d.%d",
 909                          ver_resp->hwrm_fw_maj_8b, ver_resp->hwrm_fw_min_8b,
 910                          ver_resp->hwrm_fw_bld_8b, ver_resp->hwrm_fw_rsvd_8b);
 911
 912                 snprintf(ncsi_ver, FW_VER_STR_LEN, "%d.%d.%d.%d",
 913                          ver_resp->mgmt_fw_maj_8b, ver_resp->mgmt_fw_min_8b,
 914                          ver_resp->mgmt_fw_bld_8b, ver_resp->mgmt_fw_rsvd_8b);
 915
 916                 snprintf(roce_ver, FW_VER_STR_LEN, "%d.%d.%d.%d",
 917                          ver_resp->roce_fw_maj_8b, ver_resp->roce_fw_min_8b,
 918                          ver_resp->roce_fw_bld_8b, ver_resp->roce_fw_rsvd_8b);
 919         }
 920         rc = bnxt_dl_info_put(bp, req, BNXT_VERSION_RUNNING,
 921                               DEVLINK_INFO_VERSION_GENERIC_FW_MGMT, mgmt_ver);
 922         if (rc)
 923                 return rc;
 924
 925         rc = bnxt_dl_info_put(bp, req, BNXT_VERSION_RUNNING,
 926                               DEVLINK_INFO_VERSION_GENERIC_FW_MGMT_API,
 927                               bp->hwrm_ver_supp);
 928         if (rc)
 929                 return rc;
 930
 931         rc = bnxt_dl_info_put(bp, req, BNXT_VERSION_RUNNING,
 932                               DEVLINK_INFO_VERSION_GENERIC_FW_NCSI, ncsi_ver);
 933         if (rc)
 934                 return rc;
 935
 936         rc = bnxt_dl_info_put(bp, req, BNXT_VERSION_RUNNING,
 937                               DEVLINK_INFO_VERSION_GENERIC_FW_ROCE, roce_ver);
 938         if (rc)
 939                 return rc;
 940
 941         rc = bnxt_hwrm_nvm_get_dev_info(bp, &nvm_dev_info);
 942         if (rc ||
 943             !(nvm_dev_info.flags & NVM_GET_DEV_INFO_RESP_FLAGS_FW_VER_VALID)) {
 944                 if (!bnxt_get_pkginfo(bp->dev, buf, sizeof(buf)))
 945                         return bnxt_dl_info_put(bp, req, BNXT_VERSION_STORED,
 946                                                 DEVLINK_INFO_VERSION_GENERIC_FW,
 947                                                 buf);
 948                 return 0;
 949         }
 950
 951         buf[0] = 0;
 952         strncat(buf, nvm_dev_info.pkg_name, HWRM_FW_VER_STR_LEN);
 953         rc = bnxt_dl_info_put(bp, req, BNXT_VERSION_STORED,
 954                               DEVLINK_INFO_VERSION_GENERIC_FW, buf);
 955         if (rc)
 956                 return rc;
 957
 958         snprintf(mgmt_ver, FW_VER_STR_LEN, "%d.%d.%d.%d",
 959                  nvm_dev_info.hwrm_fw_major, nvm_dev_info.hwrm_fw_minor,
 960                  nvm_dev_info.hwrm_fw_build, nvm_dev_info.hwrm_fw_patch);
 961         rc = bnxt_dl_info_put(bp, req, BNXT_VERSION_STORED,
 962                               DEVLINK_INFO_VERSION_GENERIC_FW_MGMT, mgmt_ver);
 963         if (rc)
 964                 return rc;
 965
 966         snprintf(ncsi_ver, FW_VER_STR_LEN, "%d.%d.%d.%d",
 967                  nvm_dev_info.mgmt_fw_major, nvm_dev_info.mgmt_fw_minor,
 968                  nvm_dev_info.mgmt_fw_build, nvm_dev_info.mgmt_fw_patch);
 969         rc = bnxt_dl_info_put(bp, req, BNXT_VERSION_STORED,
 970                               DEVLINK_INFO_VERSION_GENERIC_FW_NCSI, ncsi_ver);
 971         if (rc)
 972                 return rc;
 973
 974         snprintf(roce_ver, FW_VER_STR_LEN, "%d.%d.%d.%d",
 975                  nvm_dev_info.roce_fw_major, nvm_dev_info.roce_fw_minor,
 976                  nvm_dev_info.roce_fw_build, nvm_dev_info.roce_fw_patch);
 977         rc = bnxt_dl_info_put(bp, req, BNXT_VERSION_STORED,
 978                               DEVLINK_INFO_VERSION_GENERIC_FW_ROCE, roce_ver);
 979         if (rc)
 980                 return rc;
 981
 982         rc = bnxt_dl_livepatch_info_put(bp, req, BNXT_FW_SRT_PATCH);
 983         if (rc)
 984                 return rc;
 985         return bnxt_dl_livepatch_info_put(bp, req, BNXT_FW_CRT_PATCH);
 986
 987 }
 988
 989 static int bnxt_hwrm_nvm_req(struct bnxt *bp, u32 param_id, void *msg,
 990                              union devlink_param_value *val)
 991 {
 992         struct hwrm_nvm_get_variable_input *req = msg;
 993         struct bnxt_dl_nvm_param nvm_param;
 994         struct hwrm_err_output *resp;
 995         union bnxt_nvm_data *data;
 996         dma_addr_t data_dma_addr;
 997         int idx = 0, rc, i;
 998
 999         /* Get/Set NVM CFG parameter is supported only on PFs */
1000         if (BNXT_VF(bp)) {
1001                 hwrm_req_drop(bp, req);
1002                 return -EPERM;
1003         }
1004
1005         for (i = 0; i < ARRAY_SIZE(nvm_params); i++) {
1006                 if (nvm_params[i].id == param_id) {
1007                         nvm_param = nvm_params[i];
1008                         break;
1009                 }
1010         }
1011
1012         if (i == ARRAY_SIZE(nvm_params)) {
1013                 hwrm_req_drop(bp, req);
1014                 return -EOPNOTSUPP;
1015         }
1016
1017         if (nvm_param.dir_type == BNXT_NVM_PORT_CFG)
1018                 idx = bp->pf.port_id;
1019         else if (nvm_param.dir_type == BNXT_NVM_FUNC_CFG)
1020                 idx = bp->pf.fw_fid - BNXT_FIRST_PF_FID;
1021
1022         data = hwrm_req_dma_slice(bp, req, sizeof(*data), &data_dma_addr);
1023
1024         if (!data) {
1025                 hwrm_req_drop(bp, req);
1026                 return -ENOMEM;
1027         }
1028
1029         req->dest_data_addr = cpu_to_le64(data_dma_addr);
1030         req->data_len = cpu_to_le16(nvm_param.nvm_num_bits);
1031         req->option_num = cpu_to_le16(nvm_param.offset);
1032         req->index_0 = cpu_to_le16(idx);
1033         if (idx)
1034                 req->dimensions = cpu_to_le16(1);
1035
1036         resp = hwrm_req_hold(bp, req);
1037         if (req->req_type == cpu_to_le16(HWRM_NVM_SET_VARIABLE)) {
1038                 bnxt_copy_to_nvm_data(data, val, nvm_param.nvm_num_bits,
1039                                       nvm_param.dl_num_bytes);
1040                 rc = hwrm_req_send(bp, msg);
1041         } else {
1042                 rc = hwrm_req_send_silent(bp, msg);
1043                 if (!rc) {
1044                         bnxt_copy_from_nvm_data(val, data,
1045                                                 nvm_param.nvm_num_bits,
1046                                                 nvm_param.dl_num_bytes);
1047                 } else {
1048                         if (resp->cmd_err ==
1049                                 NVM_GET_VARIABLE_CMD_ERR_CODE_VAR_NOT_EXIST)
1050                                 rc = -EOPNOTSUPP;
1051                 }
1052         }
1053         hwrm_req_drop(bp, req);
1054         if (rc == -EACCES)
1055                 netdev_err(bp->dev, "PF does not have admin privileges to modify NVM config\n");
1056         return rc;
1057 }
1058
1059 static int bnxt_dl_nvm_param_get(struct devlink *dl, u32 id,
1060                                  struct devlink_param_gset_ctx *ctx)
1061 {
1062         struct bnxt *bp = bnxt_get_bp_from_dl(dl);
1063         struct hwrm_nvm_get_variable_input *req;
1064         int rc;
1065
1066         rc = hwrm_req_init(bp, req, HWRM_NVM_GET_VARIABLE);
1067         if (rc)
1068                 return rc;
1069
1070         rc = bnxt_hwrm_nvm_req(bp, id, req, &ctx->val);
1071         if (!rc && id == BNXT_DEVLINK_PARAM_ID_GRE_VER_CHECK)
1072                 ctx->val.vbool = !ctx->val.vbool;
1073
1074         return rc;
1075 }
1076
1077 static int bnxt_dl_nvm_param_set(struct devlink *dl, u32 id,
1078                                  struct devlink_param_gset_ctx *ctx)
1079 {
1080         struct bnxt *bp = bnxt_get_bp_from_dl(dl);
1081         struct hwrm_nvm_set_variable_input *req;
1082         int rc;
1083
1084         rc = hwrm_req_init(bp, req, HWRM_NVM_SET_VARIABLE);
1085         if (rc)
1086                 return rc;
1087
1088         if (id == BNXT_DEVLINK_PARAM_ID_GRE_VER_CHECK)
1089                 ctx->val.vbool = !ctx->val.vbool;
1090
1091         return bnxt_hwrm_nvm_req(bp, id, req, &ctx->val);
1092 }
1093
1094 static int bnxt_dl_msix_validate(struct devlink *dl, u32 id,
1095                                  union devlink_param_value val,
1096                                  struct netlink_ext_ack *extack)
1097 {
1098         int max_val = -1;
1099
1100         if (id == DEVLINK_PARAM_GENERIC_ID_MSIX_VEC_PER_PF_MAX)
1101                 max_val = BNXT_MSIX_VEC_MAX;
1102
1103         if (id == DEVLINK_PARAM_GENERIC_ID_MSIX_VEC_PER_PF_MIN)
1104                 max_val = BNXT_MSIX_VEC_MIN_MAX;
1105
1106         if (val.vu32 > max_val) {
1107                 NL_SET_ERR_MSG_MOD(extack, "MSIX value is exceeding the range");
1108                 return -EINVAL;
1109         }
1110
1111         return 0;
1112 }
1113
1114 static int bnxt_remote_dev_reset_get(struct devlink *dl, u32 id,
1115                                      struct devlink_param_gset_ctx *ctx)
1116 {
1117         struct bnxt *bp = bnxt_get_bp_from_dl(dl);
1118
1119         if (~bp->fw_cap & BNXT_FW_CAP_HOT_RESET_IF)
1120                 return -EOPNOTSUPP;
1121
1122         ctx->val.vbool = bnxt_dl_get_remote_reset(dl);
1123         return 0;
1124 }
1125
1126 static int bnxt_remote_dev_reset_set(struct devlink *dl, u32 id,
1127                                      struct devlink_param_gset_ctx *ctx)
1128 {
1129         struct bnxt *bp = bnxt_get_bp_from_dl(dl);
1130         int rc;
1131
1132         rc = bnxt_hwrm_remote_dev_reset_set(bp, ctx->val.vbool);
1133         if (rc)
1134                 return rc;
1135
1136         bnxt_dl_set_remote_reset(dl, ctx->val.vbool);
1137         return rc;
1138 }
1139
1140 static const struct devlink_param bnxt_dl_params[] = {
1141         DEVLINK_PARAM_GENERIC(ENABLE_SRIOV,
1142                               BIT(DEVLINK_PARAM_CMODE_PERMANENT),
1143                               bnxt_dl_nvm_param_get, bnxt_dl_nvm_param_set,
1144                               NULL),
1145         DEVLINK_PARAM_GENERIC(IGNORE_ARI,
1146                               BIT(DEVLINK_PARAM_CMODE_PERMANENT),
1147                               bnxt_dl_nvm_param_get, bnxt_dl_nvm_param_set,
1148                               NULL),
1149         DEVLINK_PARAM_GENERIC(MSIX_VEC_PER_PF_MAX,
1150                               BIT(DEVLINK_PARAM_CMODE_PERMANENT),
1151                               bnxt_dl_nvm_param_get, bnxt_dl_nvm_param_set,
1152                               bnxt_dl_msix_validate),
1153         DEVLINK_PARAM_GENERIC(MSIX_VEC_PER_PF_MIN,
1154                               BIT(DEVLINK_PARAM_CMODE_PERMANENT),
1155                               bnxt_dl_nvm_param_get, bnxt_dl_nvm_param_set,
1156                               bnxt_dl_msix_validate),
1157         DEVLINK_PARAM_DRIVER(BNXT_DEVLINK_PARAM_ID_GRE_VER_CHECK,
1158                              "gre_ver_check", DEVLINK_PARAM_TYPE_BOOL,
1159                              BIT(DEVLINK_PARAM_CMODE_PERMANENT),
1160                              bnxt_dl_nvm_param_get, bnxt_dl_nvm_param_set,
1161                              NULL),
1162         /* keep REMOTE_DEV_RESET last, it is excluded based on caps */
1163         DEVLINK_PARAM_GENERIC(ENABLE_REMOTE_DEV_RESET,
1164                               BIT(DEVLINK_PARAM_CMODE_RUNTIME),
1165                               bnxt_remote_dev_reset_get,
1166                               bnxt_remote_dev_reset_set, NULL),
1167 };
1168
1169 static int bnxt_dl_params_register(struct bnxt *bp)
1170 {
1171         int num_params = ARRAY_SIZE(bnxt_dl_params);
1172         int rc;
1173
1174         if (bp->hwrm_spec_code < 0x10600)
1175                 return 0;
1176
1177         if (~bp->fw_cap & BNXT_FW_CAP_HOT_RESET_IF)
1178                 num_params--;
1179
1180         rc = devlink_params_register(bp->dl, bnxt_dl_params, num_params);
1181         if (rc)
1182                 netdev_warn(bp->dev, "devlink_params_register failed. rc=%d\n",
1183                             rc);
1184         return rc;
1185 }
1186
1187 static void bnxt_dl_params_unregister(struct bnxt *bp)
1188 {
1189         int num_params = ARRAY_SIZE(bnxt_dl_params);
1190
1191         if (bp->hwrm_spec_code < 0x10600)
1192                 return;
1193
1194         if (~bp->fw_cap & BNXT_FW_CAP_HOT_RESET_IF)
1195                 num_params--;
1196
1197         devlink_params_unregister(bp->dl, bnxt_dl_params, num_params);
1198 }
1199
1200 int bnxt_dl_register(struct bnxt *bp)
1201 {
1202         const struct devlink_ops *devlink_ops;
1203         struct devlink_port_attrs attrs = {};
1204         struct bnxt_dl *bp_dl;
1205         struct devlink *dl;
1206         int rc;
1207
1208         if (BNXT_PF(bp))
1209                 devlink_ops = &bnxt_dl_ops;
1210         else
1211                 devlink_ops = &bnxt_vf_dl_ops;
1212
1213         dl = devlink_alloc(devlink_ops, sizeof(struct bnxt_dl), &bp->pdev->dev);
1214         if (!dl) {
1215                 netdev_warn(bp->dev, "devlink_alloc failed\n");
1216                 return -ENOMEM;
1217         }
1218
1219         bp->dl = dl;
1220         bp_dl = devlink_priv(dl);
1221         bp_dl->bp = bp;
1222         bnxt_dl_set_remote_reset(dl, true);
1223
1224         /* Add switchdev eswitch mode setting, if SRIOV supported */
1225         if (pci_find_ext_capability(bp->pdev, PCI_EXT_CAP_ID_SRIOV) &&
1226             bp->hwrm_spec_code > 0x10803)
1227                 bp->eswitch_mode = DEVLINK_ESWITCH_MODE_LEGACY;
1228
1229         if (!BNXT_PF(bp))
1230                 goto out;
1231
1232         attrs.flavour = DEVLINK_PORT_FLAVOUR_PHYSICAL;
1233         attrs.phys.port_number = bp->pf.port_id;
1234         memcpy(attrs.switch_id.id, bp->dsn, sizeof(bp->dsn));
1235         attrs.switch_id.id_len = sizeof(bp->dsn);
1236         devlink_port_attrs_set(&bp->dl_port, &attrs);
1237         rc = devlink_port_register(dl, &bp->dl_port, bp->pf.port_id);
1238         if (rc) {
1239                 netdev_err(bp->dev, "devlink_port_register failed\n");
1240                 goto err_dl_free;
1241         }
1242
1243         rc = bnxt_dl_params_register(bp);
1244         if (rc)
1245                 goto err_dl_port_unreg;
1246
1247 out:
1248         devlink_register(dl);
1249         return 0;
1250
1251 err_dl_port_unreg:
1252         devlink_port_unregister(&bp->dl_port);
1253 err_dl_free:
1254         devlink_free(dl);
1255         return rc;
1256 }
1257
1258 void bnxt_dl_unregister(struct bnxt *bp)
1259 {
1260         struct devlink *dl = bp->dl;
1261
1262         devlink_unregister(dl);
1263         if (BNXT_PF(bp)) {
1264                 bnxt_dl_params_unregister(bp);
1265                 devlink_port_unregister(&bp->dl_port);
1266         }
1267         devlink_free(dl);
1268 }