drivers/net/ethernet/intel/ice/ice_devlink.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /* Copyright (c) 2020, Intel Corporation. */
   3
   4 #include <linux/vmalloc.h>
   5
   6 #include "ice.h"
   7 #include "ice_lib.h"
   8 #include "ice_devlink.h"
   9 #include "ice_eswitch.h"
  10 #include "ice_fw_update.h"
  11
  12 /* context for devlink info version reporting */
  13 struct ice_info_ctx {
  14         char buf[128];
  15         struct ice_orom_info pending_orom;
  16         struct ice_nvm_info pending_nvm;
  17         struct ice_netlist_info pending_netlist;
  18         struct ice_hw_dev_caps dev_caps;
  19 };
  20
  21 /* The following functions are used to format specific strings for various
  22  * devlink info versions. The ctx parameter is used to provide the storage
  23  * buffer, as well as any ancillary information calculated when the info
  24  * request was made.
  25  *
  26  * If a version does not exist, for example when attempting to get the
  27  * inactive version of flash when there is no pending update, the function
  28  * should leave the buffer in the ctx structure empty.
  29  */
  30
  31 static void ice_info_get_dsn(struct ice_pf *pf, struct ice_info_ctx *ctx)
  32 {
  33         u8 dsn[8];
  34
  35         /* Copy the DSN into an array in Big Endian format */
  36         put_unaligned_be64(pci_get_dsn(pf->pdev), dsn);
  37
  38         snprintf(ctx->buf, sizeof(ctx->buf), "%8phD", dsn);
  39 }
  40
  41 static void ice_info_pba(struct ice_pf *pf, struct ice_info_ctx *ctx)
  42 {
  43         struct ice_hw *hw = &pf->hw;
  44         int status;
  45
  46         status = ice_read_pba_string(hw, (u8 *)ctx->buf, sizeof(ctx->buf));
  47         if (status)
  48                 /* We failed to locate the PBA, so just skip this entry */
  49                 dev_dbg(ice_pf_to_dev(pf), "Failed to read Product Board Assembly string, status %d\n",
  50                         status);
  51 }
  52
  53 static void ice_info_fw_mgmt(struct ice_pf *pf, struct ice_info_ctx *ctx)
  54 {
  55         struct ice_hw *hw = &pf->hw;
  56
  57         snprintf(ctx->buf, sizeof(ctx->buf), "%u.%u.%u",
  58                  hw->fw_maj_ver, hw->fw_min_ver, hw->fw_patch);
  59 }
  60
  61 static void ice_info_fw_api(struct ice_pf *pf, struct ice_info_ctx *ctx)
  62 {
  63         struct ice_hw *hw = &pf->hw;
  64
  65         snprintf(ctx->buf, sizeof(ctx->buf), "%u.%u.%u", hw->api_maj_ver,
  66                  hw->api_min_ver, hw->api_patch);
  67 }
  68
  69 static void ice_info_fw_build(struct ice_pf *pf, struct ice_info_ctx *ctx)
  70 {
  71         struct ice_hw *hw = &pf->hw;
  72
  73         snprintf(ctx->buf, sizeof(ctx->buf), "0x%08x", hw->fw_build);
  74 }
  75
  76 static void ice_info_orom_ver(struct ice_pf *pf, struct ice_info_ctx *ctx)
  77 {
  78         struct ice_orom_info *orom = &pf->hw.flash.orom;
  79
  80         snprintf(ctx->buf, sizeof(ctx->buf), "%u.%u.%u",
  81                  orom->major, orom->build, orom->patch);
  82 }
  83
  84 static void
  85 ice_info_pending_orom_ver(struct ice_pf __always_unused *pf,
  86                           struct ice_info_ctx *ctx)
  87 {
  88         struct ice_orom_info *orom = &ctx->pending_orom;
  89
  90         if (ctx->dev_caps.common_cap.nvm_update_pending_orom)
  91                 snprintf(ctx->buf, sizeof(ctx->buf), "%u.%u.%u",
  92                          orom->major, orom->build, orom->patch);
  93 }
  94
  95 static void ice_info_nvm_ver(struct ice_pf *pf, struct ice_info_ctx *ctx)
  96 {
  97         struct ice_nvm_info *nvm = &pf->hw.flash.nvm;
  98
  99         snprintf(ctx->buf, sizeof(ctx->buf), "%x.%02x", nvm->major, nvm->minor);
 100 }
 101
 102 static void
 103 ice_info_pending_nvm_ver(struct ice_pf __always_unused *pf,
 104                          struct ice_info_ctx *ctx)
 105 {
 106         struct ice_nvm_info *nvm = &ctx->pending_nvm;
 107
 108         if (ctx->dev_caps.common_cap.nvm_update_pending_nvm)
 109                 snprintf(ctx->buf, sizeof(ctx->buf), "%x.%02x",
 110                          nvm->major, nvm->minor);
 111 }
 112
 113 static void ice_info_eetrack(struct ice_pf *pf, struct ice_info_ctx *ctx)
 114 {
 115         struct ice_nvm_info *nvm = &pf->hw.flash.nvm;
 116
 117         snprintf(ctx->buf, sizeof(ctx->buf), "0x%08x", nvm->eetrack);
 118 }
 119
 120 static void
 121 ice_info_pending_eetrack(struct ice_pf *pf, struct ice_info_ctx *ctx)
 122 {
 123         struct ice_nvm_info *nvm = &ctx->pending_nvm;
 124
 125         if (ctx->dev_caps.common_cap.nvm_update_pending_nvm)
 126                 snprintf(ctx->buf, sizeof(ctx->buf), "0x%08x", nvm->eetrack);
 127 }
 128
 129 static void ice_info_ddp_pkg_name(struct ice_pf *pf, struct ice_info_ctx *ctx)
 130 {
 131         struct ice_hw *hw = &pf->hw;
 132
 133         snprintf(ctx->buf, sizeof(ctx->buf), "%s", hw->active_pkg_name);
 134 }
 135
 136 static void
 137 ice_info_ddp_pkg_version(struct ice_pf *pf, struct ice_info_ctx *ctx)
 138 {
 139         struct ice_pkg_ver *pkg = &pf->hw.active_pkg_ver;
 140
 141         snprintf(ctx->buf, sizeof(ctx->buf), "%u.%u.%u.%u",
 142                  pkg->major, pkg->minor, pkg->update, pkg->draft);
 143 }
 144
 145 static void
 146 ice_info_ddp_pkg_bundle_id(struct ice_pf *pf, struct ice_info_ctx *ctx)
 147 {
 148         snprintf(ctx->buf, sizeof(ctx->buf), "0x%08x", pf->hw.active_track_id);
 149 }
 150
 151 static void ice_info_netlist_ver(struct ice_pf *pf, struct ice_info_ctx *ctx)
 152 {
 153         struct ice_netlist_info *netlist = &pf->hw.flash.netlist;
 154
 155         /* The netlist version fields are BCD formatted */
 156         snprintf(ctx->buf, sizeof(ctx->buf), "%x.%x.%x-%x.%x.%x",
 157                  netlist->major, netlist->minor,
 158                  netlist->type >> 16, netlist->type & 0xFFFF,
 159                  netlist->rev, netlist->cust_ver);
 160 }
 161
 162 static void ice_info_netlist_build(struct ice_pf *pf, struct ice_info_ctx *ctx)
 163 {
 164         struct ice_netlist_info *netlist = &pf->hw.flash.netlist;
 165
 166         snprintf(ctx->buf, sizeof(ctx->buf), "0x%08x", netlist->hash);
 167 }
 168
 169 static void
 170 ice_info_pending_netlist_ver(struct ice_pf __always_unused *pf,
 171                              struct ice_info_ctx *ctx)
 172 {
 173         struct ice_netlist_info *netlist = &ctx->pending_netlist;
 174
 175         /* The netlist version fields are BCD formatted */
 176         if (ctx->dev_caps.common_cap.nvm_update_pending_netlist)
 177                 snprintf(ctx->buf, sizeof(ctx->buf), "%x.%x.%x-%x.%x.%x",
 178                          netlist->major, netlist->minor,
 179                          netlist->type >> 16, netlist->type & 0xFFFF,
 180                          netlist->rev, netlist->cust_ver);
 181 }
 182
 183 static void
 184 ice_info_pending_netlist_build(struct ice_pf __always_unused *pf,
 185                                struct ice_info_ctx *ctx)
 186 {
 187         struct ice_netlist_info *netlist = &ctx->pending_netlist;
 188
 189         if (ctx->dev_caps.common_cap.nvm_update_pending_netlist)
 190                 snprintf(ctx->buf, sizeof(ctx->buf), "0x%08x", netlist->hash);
 191 }
 192
 193 #define fixed(key, getter) { ICE_VERSION_FIXED, key, getter, NULL }
 194 #define running(key, getter) { ICE_VERSION_RUNNING, key, getter, NULL }
 195 #define stored(key, getter, fallback) { ICE_VERSION_STORED, key, getter, fallback }
 196
 197 /* The combined() macro inserts both the running entry as well as a stored
 198  * entry. The running entry will always report the version from the active
 199  * handler. The stored entry will first try the pending handler, and fallback
 200  * to the active handler if the pending function does not report a version.
 201  * The pending handler should check the status of a pending update for the
 202  * relevant flash component. It should only fill in the buffer in the case
 203  * where a valid pending version is available. This ensures that the related
 204  * stored and running versions remain in sync, and that stored versions are
 205  * correctly reported as expected.
 206  */
 207 #define combined(key, active, pending) \
 208         running(key, active), \
 209         stored(key, pending, active)
 210
 211 enum ice_version_type {
 212         ICE_VERSION_FIXED,
 213         ICE_VERSION_RUNNING,
 214         ICE_VERSION_STORED,
 215 };
 216
 217 static const struct ice_devlink_version {
 218         enum ice_version_type type;
 219         const char *key;
 220         void (*getter)(struct ice_pf *pf, struct ice_info_ctx *ctx);
 221         void (*fallback)(struct ice_pf *pf, struct ice_info_ctx *ctx);
 222 } ice_devlink_versions[] = {
 223         fixed(DEVLINK_INFO_VERSION_GENERIC_BOARD_ID, ice_info_pba),
 224         running(DEVLINK_INFO_VERSION_GENERIC_FW_MGMT, ice_info_fw_mgmt),
 225         running("fw.mgmt.api", ice_info_fw_api),
 226         running("fw.mgmt.build", ice_info_fw_build),
 227         combined(DEVLINK_INFO_VERSION_GENERIC_FW_UNDI, ice_info_orom_ver, ice_info_pending_orom_ver),
 228         combined("fw.psid.api", ice_info_nvm_ver, ice_info_pending_nvm_ver),
 229         combined(DEVLINK_INFO_VERSION_GENERIC_FW_BUNDLE_ID, ice_info_eetrack, ice_info_pending_eetrack),
 230         running("fw.app.name", ice_info_ddp_pkg_name),
 231         running(DEVLINK_INFO_VERSION_GENERIC_FW_APP, ice_info_ddp_pkg_version),
 232         running("fw.app.bundle_id", ice_info_ddp_pkg_bundle_id),
 233         combined("fw.netlist", ice_info_netlist_ver, ice_info_pending_netlist_ver),
 234         combined("fw.netlist.build", ice_info_netlist_build, ice_info_pending_netlist_build),
 235 };
 236
 237 /**
 238  * ice_devlink_info_get - .info_get devlink handler
 239  * @devlink: devlink instance structure
 240  * @req: the devlink info request
 241  * @extack: extended netdev ack structure
 242  *
 243  * Callback for the devlink .info_get operation. Reports information about the
 244  * device.
 245  *
 246  * Return: zero on success or an error code on failure.
 247  */
 248 static int ice_devlink_info_get(struct devlink *devlink,
 249                                 struct devlink_info_req *req,
 250                                 struct netlink_ext_ack *extack)
 251 {
 252         struct ice_pf *pf = devlink_priv(devlink);
 253         struct device *dev = ice_pf_to_dev(pf);
 254         struct ice_hw *hw = &pf->hw;
 255         struct ice_info_ctx *ctx;
 256         size_t i;
 257         int err;
 258
 259         err = ice_wait_for_reset(pf, 10 * HZ);
 260         if (err) {
 261                 NL_SET_ERR_MSG_MOD(extack, "Device is busy resetting");
 262                 return err;
 263         }
 264
 265         ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
 266         if (!ctx)
 267                 return -ENOMEM;
 268
 269         /* discover capabilities first */
 270         err = ice_discover_dev_caps(hw, &ctx->dev_caps);
 271         if (err) {
 272                 dev_dbg(dev, "Failed to discover device capabilities, status %d aq_err %s\n",
 273                         err, ice_aq_str(hw->adminq.sq_last_status));
 274                 NL_SET_ERR_MSG_MOD(extack, "Unable to discover device capabilities");
 275                 goto out_free_ctx;
 276         }
 277
 278         if (ctx->dev_caps.common_cap.nvm_update_pending_orom) {
 279                 err = ice_get_inactive_orom_ver(hw, &ctx->pending_orom);
 280                 if (err) {
 281                         dev_dbg(dev, "Unable to read inactive Option ROM version data, status %d aq_err %s\n",
 282                                 err, ice_aq_str(hw->adminq.sq_last_status));
 283
 284                         /* disable display of pending Option ROM */
 285                         ctx->dev_caps.common_cap.nvm_update_pending_orom = false;
 286                 }
 287         }
 288
 289         if (ctx->dev_caps.common_cap.nvm_update_pending_nvm) {
 290                 err = ice_get_inactive_nvm_ver(hw, &ctx->pending_nvm);
 291                 if (err) {
 292                         dev_dbg(dev, "Unable to read inactive NVM version data, status %d aq_err %s\n",
 293                                 err, ice_aq_str(hw->adminq.sq_last_status));
 294
 295                         /* disable display of pending Option ROM */
 296                         ctx->dev_caps.common_cap.nvm_update_pending_nvm = false;
 297                 }
 298         }
 299
 300         if (ctx->dev_caps.common_cap.nvm_update_pending_netlist) {
 301                 err = ice_get_inactive_netlist_ver(hw, &ctx->pending_netlist);
 302                 if (err) {
 303                         dev_dbg(dev, "Unable to read inactive Netlist version data, status %d aq_err %s\n",
 304                                 err, ice_aq_str(hw->adminq.sq_last_status));
 305
 306                         /* disable display of pending Option ROM */
 307                         ctx->dev_caps.common_cap.nvm_update_pending_netlist = false;
 308                 }
 309         }
 310
 311         err = devlink_info_driver_name_put(req, KBUILD_MODNAME);
 312         if (err) {
 313                 NL_SET_ERR_MSG_MOD(extack, "Unable to set driver name");
 314                 goto out_free_ctx;
 315         }
 316
 317         ice_info_get_dsn(pf, ctx);
 318
 319         err = devlink_info_serial_number_put(req, ctx->buf);
 320         if (err) {
 321                 NL_SET_ERR_MSG_MOD(extack, "Unable to set serial number");
 322                 goto out_free_ctx;
 323         }
 324
 325         for (i = 0; i < ARRAY_SIZE(ice_devlink_versions); i++) {
 326                 enum ice_version_type type = ice_devlink_versions[i].type;
 327                 const char *key = ice_devlink_versions[i].key;
 328
 329                 memset(ctx->buf, 0, sizeof(ctx->buf));
 330
 331                 ice_devlink_versions[i].getter(pf, ctx);
 332
 333                 /* If the default getter doesn't report a version, use the
 334                  * fallback function. This is primarily useful in the case of
 335                  * "stored" versions that want to report the same value as the
 336                  * running version in the normal case of no pending update.
 337                  */
 338                 if (ctx->buf[0] == '\0' && ice_devlink_versions[i].fallback)
 339                         ice_devlink_versions[i].fallback(pf, ctx);
 340
 341                 /* Do not report missing versions */
 342                 if (ctx->buf[0] == '\0')
 343                         continue;
 344
 345                 switch (type) {
 346                 case ICE_VERSION_FIXED:
 347                         err = devlink_info_version_fixed_put(req, key, ctx->buf);
 348                         if (err) {
 349                                 NL_SET_ERR_MSG_MOD(extack, "Unable to set fixed version");
 350                                 goto out_free_ctx;
 351                         }
 352                         break;
 353                 case ICE_VERSION_RUNNING:
 354                         err = devlink_info_version_running_put(req, key, ctx->buf);
 355                         if (err) {
 356                                 NL_SET_ERR_MSG_MOD(extack, "Unable to set running version");
 357                                 goto out_free_ctx;
 358                         }
 359                         break;
 360                 case ICE_VERSION_STORED:
 361                         err = devlink_info_version_stored_put(req, key, ctx->buf);
 362                         if (err) {
 363                                 NL_SET_ERR_MSG_MOD(extack, "Unable to set stored version");
 364                                 goto out_free_ctx;
 365                         }
 366                         break;
 367                 }
 368         }
 369
 370 out_free_ctx:
 371         kfree(ctx);
 372         return err;
 373 }
 374
 375 /**
 376  * ice_devlink_reload_empr_start - Start EMP reset to activate new firmware
 377  * @devlink: pointer to the devlink instance to reload
 378  * @netns_change: if true, the network namespace is changing
 379  * @action: the action to perform. Must be DEVLINK_RELOAD_ACTION_FW_ACTIVATE
 380  * @limit: limits on what reload should do, such as not resetting
 381  * @extack: netlink extended ACK structure
 382  *
 383  * Allow user to activate new Embedded Management Processor firmware by
 384  * issuing device specific EMP reset. Called in response to
 385  * a DEVLINK_CMD_RELOAD with the DEVLINK_RELOAD_ACTION_FW_ACTIVATE.
 386  *
 387  * Note that teardown and rebuild of the driver state happens automatically as
 388  * part of an interrupt and watchdog task. This is because all physical
 389  * functions on the device must be able to reset when an EMP reset occurs from
 390  * any source.
 391  */
 392 static int
 393 ice_devlink_reload_empr_start(struct devlink *devlink, bool netns_change,
 394                               enum devlink_reload_action action,
 395                               enum devlink_reload_limit limit,
 396                               struct netlink_ext_ack *extack)
 397 {
 398         struct ice_pf *pf = devlink_priv(devlink);
 399         struct device *dev = ice_pf_to_dev(pf);
 400         struct ice_hw *hw = &pf->hw;
 401         u8 pending;
 402         int err;
 403
 404         err = ice_get_pending_updates(pf, &pending, extack);
 405         if (err)
 406                 return err;
 407
 408         /* pending is a bitmask of which flash banks have a pending update,
 409          * including the main NVM bank, the Option ROM bank, and the netlist
 410          * bank. If any of these bits are set, then there is a pending update
 411          * waiting to be activated.
 412          */
 413         if (!pending) {
 414                 NL_SET_ERR_MSG_MOD(extack, "No pending firmware update");
 415                 return -ECANCELED;
 416         }
 417
 418         if (pf->fw_emp_reset_disabled) {
 419                 NL_SET_ERR_MSG_MOD(extack, "EMP reset is not available. To activate firmware, a reboot or power cycle is needed");
 420                 return -ECANCELED;
 421         }
 422
 423         dev_dbg(dev, "Issuing device EMP reset to activate firmware\n");
 424
 425         err = ice_aq_nvm_update_empr(hw);
 426         if (err) {
 427                 dev_err(dev, "Failed to trigger EMP device reset to reload firmware, err %d aq_err %s\n",
 428                         err, ice_aq_str(hw->adminq.sq_last_status));
 429                 NL_SET_ERR_MSG_MOD(extack, "Failed to trigger EMP device reset to reload firmware");
 430                 return err;
 431         }
 432
 433         return 0;
 434 }
 435
 436 /**
 437  * ice_devlink_reload_empr_finish - Wait for EMP reset to finish
 438  * @devlink: pointer to the devlink instance reloading
 439  * @action: the action requested
 440  * @limit: limits imposed by userspace, such as not resetting
 441  * @actions_performed: on return, indicate what actions actually performed
 442  * @extack: netlink extended ACK structure
 443  *
 444  * Wait for driver to finish rebuilding after EMP reset is completed. This
 445  * includes time to wait for both the actual device reset as well as the time
 446  * for the driver's rebuild to complete.
 447  */
 448 static int
 449 ice_devlink_reload_empr_finish(struct devlink *devlink,
 450                                enum devlink_reload_action action,
 451                                enum devlink_reload_limit limit,
 452                                u32 *actions_performed,
 453                                struct netlink_ext_ack *extack)
 454 {
 455         struct ice_pf *pf = devlink_priv(devlink);
 456         int err;
 457
 458         *actions_performed = BIT(DEVLINK_RELOAD_ACTION_FW_ACTIVATE);
 459
 460         err = ice_wait_for_reset(pf, 60 * HZ);
 461         if (err) {
 462                 NL_SET_ERR_MSG_MOD(extack, "Device still resetting after 1 minute");
 463                 return err;
 464         }
 465
 466         return 0;
 467 }
 468
 469 static const struct devlink_ops ice_devlink_ops = {
 470         .supported_flash_update_params = DEVLINK_SUPPORT_FLASH_UPDATE_OVERWRITE_MASK,
 471         .reload_actions = BIT(DEVLINK_RELOAD_ACTION_FW_ACTIVATE),
 472         /* The ice driver currently does not support driver reinit */
 473         .reload_down = ice_devlink_reload_empr_start,
 474         .reload_up = ice_devlink_reload_empr_finish,
 475         .eswitch_mode_get = ice_eswitch_mode_get,
 476         .eswitch_mode_set = ice_eswitch_mode_set,
 477         .info_get = ice_devlink_info_get,
 478         .flash_update = ice_devlink_flash_update,
 479 };
 480
 481 static int
 482 ice_devlink_enable_roce_get(struct devlink *devlink, u32 id,
 483                             struct devlink_param_gset_ctx *ctx)
 484 {
 485         struct ice_pf *pf = devlink_priv(devlink);
 486
 487         ctx->val.vbool = pf->rdma_mode & IIDC_RDMA_PROTOCOL_ROCEV2 ? true : false;
 488
 489         return 0;
 490 }
 491
 492 static int
 493 ice_devlink_enable_roce_set(struct devlink *devlink, u32 id,
 494                             struct devlink_param_gset_ctx *ctx)
 495 {
 496         struct ice_pf *pf = devlink_priv(devlink);
 497         bool roce_ena = ctx->val.vbool;
 498         int ret;
 499
 500         if (!roce_ena) {
 501                 ice_unplug_aux_dev(pf);
 502                 pf->rdma_mode &= ~IIDC_RDMA_PROTOCOL_ROCEV2;
 503                 return 0;
 504         }
 505
 506         pf->rdma_mode |= IIDC_RDMA_PROTOCOL_ROCEV2;
 507         ret = ice_plug_aux_dev(pf);
 508         if (ret)
 509                 pf->rdma_mode &= ~IIDC_RDMA_PROTOCOL_ROCEV2;
 510
 511         return ret;
 512 }
 513
 514 static int
 515 ice_devlink_enable_roce_validate(struct devlink *devlink, u32 id,
 516                                  union devlink_param_value val,
 517                                  struct netlink_ext_ack *extack)
 518 {
 519         struct ice_pf *pf = devlink_priv(devlink);
 520
 521         if (!test_bit(ICE_FLAG_RDMA_ENA, pf->flags))
 522                 return -EOPNOTSUPP;
 523
 524         if (pf->rdma_mode & IIDC_RDMA_PROTOCOL_IWARP) {
 525                 NL_SET_ERR_MSG_MOD(extack, "iWARP is currently enabled. This device cannot enable iWARP and RoCEv2 simultaneously");
 526                 return -EOPNOTSUPP;
 527         }
 528
 529         return 0;
 530 }
 531
 532 static int
 533 ice_devlink_enable_iw_get(struct devlink *devlink, u32 id,
 534                           struct devlink_param_gset_ctx *ctx)
 535 {
 536         struct ice_pf *pf = devlink_priv(devlink);
 537
 538         ctx->val.vbool = pf->rdma_mode & IIDC_RDMA_PROTOCOL_IWARP;
 539
 540         return 0;
 541 }
 542
 543 static int
 544 ice_devlink_enable_iw_set(struct devlink *devlink, u32 id,
 545                           struct devlink_param_gset_ctx *ctx)
 546 {
 547         struct ice_pf *pf = devlink_priv(devlink);
 548         bool iw_ena = ctx->val.vbool;
 549         int ret;
 550
 551         if (!iw_ena) {
 552                 ice_unplug_aux_dev(pf);
 553                 pf->rdma_mode &= ~IIDC_RDMA_PROTOCOL_IWARP;
 554                 return 0;
 555         }
 556
 557         pf->rdma_mode |= IIDC_RDMA_PROTOCOL_IWARP;
 558         ret = ice_plug_aux_dev(pf);
 559         if (ret)
 560                 pf->rdma_mode &= ~IIDC_RDMA_PROTOCOL_IWARP;
 561
 562         return ret;
 563 }
 564
 565 static int
 566 ice_devlink_enable_iw_validate(struct devlink *devlink, u32 id,
 567                                union devlink_param_value val,
 568                                struct netlink_ext_ack *extack)
 569 {
 570         struct ice_pf *pf = devlink_priv(devlink);
 571
 572         if (!test_bit(ICE_FLAG_RDMA_ENA, pf->flags))
 573                 return -EOPNOTSUPP;
 574
 575         if (pf->rdma_mode & IIDC_RDMA_PROTOCOL_ROCEV2) {
 576                 NL_SET_ERR_MSG_MOD(extack, "RoCEv2 is currently enabled. This device cannot enable iWARP and RoCEv2 simultaneously");
 577                 return -EOPNOTSUPP;
 578         }
 579
 580         return 0;
 581 }
 582
 583 static const struct devlink_param ice_devlink_params[] = {
 584         DEVLINK_PARAM_GENERIC(ENABLE_ROCE, BIT(DEVLINK_PARAM_CMODE_RUNTIME),
 585                               ice_devlink_enable_roce_get,
 586                               ice_devlink_enable_roce_set,
 587                               ice_devlink_enable_roce_validate),
 588         DEVLINK_PARAM_GENERIC(ENABLE_IWARP, BIT(DEVLINK_PARAM_CMODE_RUNTIME),
 589                               ice_devlink_enable_iw_get,
 590                               ice_devlink_enable_iw_set,
 591                               ice_devlink_enable_iw_validate),
 592
 593 };
 594
 595 static void ice_devlink_free(void *devlink_ptr)
 596 {
 597         devlink_free((struct devlink *)devlink_ptr);
 598 }
 599
 600 /**
 601  * ice_allocate_pf - Allocate devlink and return PF structure pointer
 602  * @dev: the device to allocate for
 603  *
 604  * Allocate a devlink instance for this device and return the private area as
 605  * the PF structure. The devlink memory is kept track of through devres by
 606  * adding an action to remove it when unwinding.
 607  */
 608 struct ice_pf *ice_allocate_pf(struct device *dev)
 609 {
 610         struct devlink *devlink;
 611
 612         devlink = devlink_alloc(&ice_devlink_ops, sizeof(struct ice_pf), dev);
 613         if (!devlink)
 614                 return NULL;
 615
 616         /* Add an action to teardown the devlink when unwinding the driver */
 617         if (devm_add_action_or_reset(dev, ice_devlink_free, devlink))
 618                 return NULL;
 619
 620         return devlink_priv(devlink);
 621 }
 622
 623 /**
 624  * ice_devlink_register - Register devlink interface for this PF
 625  * @pf: the PF to register the devlink for.
 626  *
 627  * Register the devlink instance associated with this physical function.
 628  *
 629  * Return: zero on success or an error code on failure.
 630  */
 631 void ice_devlink_register(struct ice_pf *pf)
 632 {
 633         struct devlink *devlink = priv_to_devlink(pf);
 634
 635         devlink_set_features(devlink, DEVLINK_F_RELOAD);
 636         devlink_register(devlink);
 637 }
 638
 639 /**
 640  * ice_devlink_unregister - Unregister devlink resources for this PF.
 641  * @pf: the PF structure to cleanup
 642  *
 643  * Releases resources used by devlink and cleans up associated memory.
 644  */
 645 void ice_devlink_unregister(struct ice_pf *pf)
 646 {
 647         devlink_unregister(priv_to_devlink(pf));
 648 }
 649
 650 /**
 651  * ice_devlink_set_switch_id - Set unique switch id based on pci dsn
 652  * @pf: the PF to create a devlink port for
 653  * @ppid: struct with switch id information
 654  */
 655 static void
 656 ice_devlink_set_switch_id(struct ice_pf *pf, struct netdev_phys_item_id *ppid)
 657 {
 658         struct pci_dev *pdev = pf->pdev;
 659         u64 id;
 660
 661         id = pci_get_dsn(pdev);
 662
 663         ppid->id_len = sizeof(id);
 664         put_unaligned_be64(id, &ppid->id);
 665 }
 666
 667 int ice_devlink_register_params(struct ice_pf *pf)
 668 {
 669         struct devlink *devlink = priv_to_devlink(pf);
 670         union devlink_param_value value;
 671         int err;
 672
 673         err = devlink_params_register(devlink, ice_devlink_params,
 674                                       ARRAY_SIZE(ice_devlink_params));
 675         if (err)
 676                 return err;
 677
 678         value.vbool = false;
 679         devlink_param_driverinit_value_set(devlink,
 680                                            DEVLINK_PARAM_GENERIC_ID_ENABLE_IWARP,
 681                                            value);
 682
 683         value.vbool = test_bit(ICE_FLAG_RDMA_ENA, pf->flags) ? true : false;
 684         devlink_param_driverinit_value_set(devlink,
 685                                            DEVLINK_PARAM_GENERIC_ID_ENABLE_ROCE,
 686                                            value);
 687
 688         return 0;
 689 }
 690
 691 void ice_devlink_unregister_params(struct ice_pf *pf)
 692 {
 693         devlink_params_unregister(priv_to_devlink(pf), ice_devlink_params,
 694                                   ARRAY_SIZE(ice_devlink_params));
 695 }
 696
 697 /**
 698  * ice_devlink_create_pf_port - Create a devlink port for this PF
 699  * @pf: the PF to create a devlink port for
 700  *
 701  * Create and register a devlink_port for this PF.
 702  *
 703  * Return: zero on success or an error code on failure.
 704  */
 705 int ice_devlink_create_pf_port(struct ice_pf *pf)
 706 {
 707         struct devlink_port_attrs attrs = {};
 708         struct devlink_port *devlink_port;
 709         struct devlink *devlink;
 710         struct ice_vsi *vsi;
 711         struct device *dev;
 712         int err;
 713
 714         dev = ice_pf_to_dev(pf);
 715
 716         devlink_port = &pf->devlink_port;
 717
 718         vsi = ice_get_main_vsi(pf);
 719         if (!vsi)
 720                 return -EIO;
 721
 722         attrs.flavour = DEVLINK_PORT_FLAVOUR_PHYSICAL;
 723         attrs.phys.port_number = pf->hw.bus.func;
 724
 725         ice_devlink_set_switch_id(pf, &attrs.switch_id);
 726
 727         devlink_port_attrs_set(devlink_port, &attrs);
 728         devlink = priv_to_devlink(pf);
 729
 730         err = devlink_port_register(devlink, devlink_port, vsi->idx);
 731         if (err) {
 732                 dev_err(dev, "Failed to create devlink port for PF %d, error %d\n",
 733                         pf->hw.pf_id, err);
 734                 return err;
 735         }
 736
 737         return 0;
 738 }
 739
 740 /**
 741  * ice_devlink_destroy_pf_port - Destroy the devlink_port for this PF
 742  * @pf: the PF to cleanup
 743  *
 744  * Unregisters the devlink_port structure associated with this PF.
 745  */
 746 void ice_devlink_destroy_pf_port(struct ice_pf *pf)
 747 {
 748         struct devlink_port *devlink_port;
 749
 750         devlink_port = &pf->devlink_port;
 751
 752         devlink_port_type_clear(devlink_port);
 753         devlink_port_unregister(devlink_port);
 754 }
 755
 756 /**
 757  * ice_devlink_create_vf_port - Create a devlink port for this VF
 758  * @vf: the VF to create a port for
 759  *
 760  * Create and register a devlink_port for this VF.
 761  *
 762  * Return: zero on success or an error code on failure.
 763  */
 764 int ice_devlink_create_vf_port(struct ice_vf *vf)
 765 {
 766         struct devlink_port_attrs attrs = {};
 767         struct devlink_port *devlink_port;
 768         struct devlink *devlink;
 769         struct ice_vsi *vsi;
 770         struct device *dev;
 771         struct ice_pf *pf;
 772         int err;
 773
 774         pf = vf->pf;
 775         dev = ice_pf_to_dev(pf);
 776         devlink_port = &vf->devlink_port;
 777
 778         vsi = ice_get_vf_vsi(vf);
 779         if (!vsi)
 780                 return -EINVAL;
 781
 782         attrs.flavour = DEVLINK_PORT_FLAVOUR_PCI_VF;
 783         attrs.pci_vf.pf = pf->hw.bus.func;
 784         attrs.pci_vf.vf = vf->vf_id;
 785
 786         ice_devlink_set_switch_id(pf, &attrs.switch_id);
 787
 788         devlink_port_attrs_set(devlink_port, &attrs);
 789         devlink = priv_to_devlink(pf);
 790
 791         err = devlink_port_register(devlink, devlink_port, vsi->idx);
 792         if (err) {
 793                 dev_err(dev, "Failed to create devlink port for VF %d, error %d\n",
 794                         vf->vf_id, err);
 795                 return err;
 796         }
 797
 798         return 0;
 799 }
 800
 801 /**
 802  * ice_devlink_destroy_vf_port - Destroy the devlink_port for this VF
 803  * @vf: the VF to cleanup
 804  *
 805  * Unregisters the devlink_port structure associated with this VF.
 806  */
 807 void ice_devlink_destroy_vf_port(struct ice_vf *vf)
 808 {
 809         struct devlink_port *devlink_port;
 810
 811         devlink_port = &vf->devlink_port;
 812
 813         devlink_port_type_clear(devlink_port);
 814         devlink_port_unregister(devlink_port);
 815 }
 816
 817 /**
 818  * ice_devlink_nvm_snapshot - Capture a snapshot of the NVM flash contents
 819  * @devlink: the devlink instance
 820  * @ops: the devlink region being snapshotted
 821  * @extack: extended ACK response structure
 822  * @data: on exit points to snapshot data buffer
 823  *
 824  * This function is called in response to the DEVLINK_CMD_REGION_TRIGGER for
 825  * the nvm-flash devlink region. It captures a snapshot of the full NVM flash
 826  * contents, including both banks of flash. This snapshot can later be viewed
 827  * via the devlink-region interface.
 828  *
 829  * It captures the flash using the FLASH_ONLY bit set when reading via
 830  * firmware, so it does not read the current Shadow RAM contents. For that,
 831  * use the shadow-ram region.
 832  *
 833  * @returns zero on success, and updates the data pointer. Returns a non-zero
 834  * error code on failure.
 835  */
 836 static int ice_devlink_nvm_snapshot(struct devlink *devlink,
 837                                     const struct devlink_region_ops *ops,
 838                                     struct netlink_ext_ack *extack, u8 **data)
 839 {
 840         struct ice_pf *pf = devlink_priv(devlink);
 841         struct device *dev = ice_pf_to_dev(pf);
 842         struct ice_hw *hw = &pf->hw;
 843         void *nvm_data;
 844         u32 nvm_size;
 845         int status;
 846
 847         nvm_size = hw->flash.flash_size;
 848         nvm_data = vzalloc(nvm_size);
 849         if (!nvm_data)
 850                 return -ENOMEM;
 851
 852         status = ice_acquire_nvm(hw, ICE_RES_READ);
 853         if (status) {
 854                 dev_dbg(dev, "ice_acquire_nvm failed, err %d aq_err %d\n",
 855                         status, hw->adminq.sq_last_status);
 856                 NL_SET_ERR_MSG_MOD(extack, "Failed to acquire NVM semaphore");
 857                 vfree(nvm_data);
 858                 return status;
 859         }
 860
 861         status = ice_read_flat_nvm(hw, 0, &nvm_size, nvm_data, false);
 862         if (status) {
 863                 dev_dbg(dev, "ice_read_flat_nvm failed after reading %u bytes, err %d aq_err %d\n",
 864                         nvm_size, status, hw->adminq.sq_last_status);
 865                 NL_SET_ERR_MSG_MOD(extack, "Failed to read NVM contents");
 866                 ice_release_nvm(hw);
 867                 vfree(nvm_data);
 868                 return status;
 869         }
 870
 871         ice_release_nvm(hw);
 872
 873         *data = nvm_data;
 874
 875         return 0;
 876 }
 877
 878 /**
 879  * ice_devlink_sram_snapshot - Capture a snapshot of the Shadow RAM contents
 880  * @devlink: the devlink instance
 881  * @ops: the devlink region being snapshotted
 882  * @extack: extended ACK response structure
 883  * @data: on exit points to snapshot data buffer
 884  *
 885  * This function is called in response to the DEVLINK_CMD_REGION_TRIGGER for
 886  * the shadow-ram devlink region. It captures a snapshot of the shadow ram
 887  * contents. This snapshot can later be viewed via the devlink-region
 888  * interface.
 889  *
 890  * @returns zero on success, and updates the data pointer. Returns a non-zero
 891  * error code on failure.
 892  */
 893 static int
 894 ice_devlink_sram_snapshot(struct devlink *devlink,
 895                           const struct devlink_region_ops __always_unused *ops,
 896                           struct netlink_ext_ack *extack, u8 **data)
 897 {
 898         struct ice_pf *pf = devlink_priv(devlink);
 899         struct device *dev = ice_pf_to_dev(pf);
 900         struct ice_hw *hw = &pf->hw;
 901         u8 *sram_data;
 902         u32 sram_size;
 903         int err;
 904
 905         sram_size = hw->flash.sr_words * 2u;
 906         sram_data = vzalloc(sram_size);
 907         if (!sram_data)
 908                 return -ENOMEM;
 909
 910         err = ice_acquire_nvm(hw, ICE_RES_READ);
 911         if (err) {
 912                 dev_dbg(dev, "ice_acquire_nvm failed, err %d aq_err %d\n",
 913                         err, hw->adminq.sq_last_status);
 914                 NL_SET_ERR_MSG_MOD(extack, "Failed to acquire NVM semaphore");
 915                 vfree(sram_data);
 916                 return err;
 917         }
 918
 919         /* Read from the Shadow RAM, rather than directly from NVM */
 920         err = ice_read_flat_nvm(hw, 0, &sram_size, sram_data, true);
 921         if (err) {
 922                 dev_dbg(dev, "ice_read_flat_nvm failed after reading %u bytes, err %d aq_err %d\n",
 923                         sram_size, err, hw->adminq.sq_last_status);
 924                 NL_SET_ERR_MSG_MOD(extack,
 925                                    "Failed to read Shadow RAM contents");
 926                 ice_release_nvm(hw);
 927                 vfree(sram_data);
 928                 return err;
 929         }
 930
 931         ice_release_nvm(hw);
 932
 933         *data = sram_data;
 934
 935         return 0;
 936 }
 937
 938 /**
 939  * ice_devlink_devcaps_snapshot - Capture snapshot of device capabilities
 940  * @devlink: the devlink instance
 941  * @ops: the devlink region being snapshotted
 942  * @extack: extended ACK response structure
 943  * @data: on exit points to snapshot data buffer
 944  *
 945  * This function is called in response to the DEVLINK_CMD_REGION_TRIGGER for
 946  * the device-caps devlink region. It captures a snapshot of the device
 947  * capabilities reported by firmware.
 948  *
 949  * @returns zero on success, and updates the data pointer. Returns a non-zero
 950  * error code on failure.
 951  */
 952 static int
 953 ice_devlink_devcaps_snapshot(struct devlink *devlink,
 954                              const struct devlink_region_ops *ops,
 955                              struct netlink_ext_ack *extack, u8 **data)
 956 {
 957         struct ice_pf *pf = devlink_priv(devlink);
 958         struct device *dev = ice_pf_to_dev(pf);
 959         struct ice_hw *hw = &pf->hw;
 960         void *devcaps;
 961         int status;
 962
 963         devcaps = vzalloc(ICE_AQ_MAX_BUF_LEN);
 964         if (!devcaps)
 965                 return -ENOMEM;
 966
 967         status = ice_aq_list_caps(hw, devcaps, ICE_AQ_MAX_BUF_LEN, NULL,
 968                                   ice_aqc_opc_list_dev_caps, NULL);
 969         if (status) {
 970                 dev_dbg(dev, "ice_aq_list_caps: failed to read device capabilities, err %d aq_err %d\n",
 971                         status, hw->adminq.sq_last_status);
 972                 NL_SET_ERR_MSG_MOD(extack, "Failed to read device capabilities");
 973                 vfree(devcaps);
 974                 return status;
 975         }
 976
 977         *data = (u8 *)devcaps;
 978
 979         return 0;
 980 }
 981
 982 static const struct devlink_region_ops ice_nvm_region_ops = {
 983         .name = "nvm-flash",
 984         .destructor = vfree,
 985         .snapshot = ice_devlink_nvm_snapshot,
 986 };
 987
 988 static const struct devlink_region_ops ice_sram_region_ops = {
 989         .name = "shadow-ram",
 990         .destructor = vfree,
 991         .snapshot = ice_devlink_sram_snapshot,
 992 };
 993
 994 static const struct devlink_region_ops ice_devcaps_region_ops = {
 995         .name = "device-caps",
 996         .destructor = vfree,
 997         .snapshot = ice_devlink_devcaps_snapshot,
 998 };
 999
1000 /**
1001  * ice_devlink_init_regions - Initialize devlink regions
1002  * @pf: the PF device structure
1003  *
1004  * Create devlink regions used to enable access to dump the contents of the
1005  * flash memory on the device.
1006  */
1007 void ice_devlink_init_regions(struct ice_pf *pf)
1008 {
1009         struct devlink *devlink = priv_to_devlink(pf);
1010         struct device *dev = ice_pf_to_dev(pf);
1011         u64 nvm_size, sram_size;
1012
1013         nvm_size = pf->hw.flash.flash_size;
1014         pf->nvm_region = devlink_region_create(devlink, &ice_nvm_region_ops, 1,
1015                                                nvm_size);
1016         if (IS_ERR(pf->nvm_region)) {
1017                 dev_err(dev, "failed to create NVM devlink region, err %ld\n",
1018                         PTR_ERR(pf->nvm_region));
1019                 pf->nvm_region = NULL;
1020         }
1021
1022         sram_size = pf->hw.flash.sr_words * 2u;
1023         pf->sram_region = devlink_region_create(devlink, &ice_sram_region_ops,
1024                                                 1, sram_size);
1025         if (IS_ERR(pf->sram_region)) {
1026                 dev_err(dev, "failed to create shadow-ram devlink region, err %ld\n",
1027                         PTR_ERR(pf->sram_region));
1028                 pf->sram_region = NULL;
1029         }
1030
1031         pf->devcaps_region = devlink_region_create(devlink,
1032                                                    &ice_devcaps_region_ops, 10,
1033                                                    ICE_AQ_MAX_BUF_LEN);
1034         if (IS_ERR(pf->devcaps_region)) {
1035                 dev_err(dev, "failed to create device-caps devlink region, err %ld\n",
1036                         PTR_ERR(pf->devcaps_region));
1037                 pf->devcaps_region = NULL;
1038         }
1039 }
1040
1041 /**
1042  * ice_devlink_destroy_regions - Destroy devlink regions
1043  * @pf: the PF device structure
1044  *
1045  * Remove previously created regions for this PF.
1046  */
1047 void ice_devlink_destroy_regions(struct ice_pf *pf)
1048 {
1049         if (pf->nvm_region)
1050                 devlink_region_destroy(pf->nvm_region);
1051
1052         if (pf->sram_region)
1053                 devlink_region_destroy(pf->sram_region);
1054
1055         if (pf->devcaps_region)
1056                 devlink_region_destroy(pf->devcaps_region);
1057 }