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 #include "ice_dcb_lib.h"
  12
  13 static int ice_active_port_option = -1;
  14
  15 /* context for devlink info version reporting */
  16 struct ice_info_ctx {
  17         char buf[128];
  18         struct ice_orom_info pending_orom;
  19         struct ice_nvm_info pending_nvm;
  20         struct ice_netlist_info pending_netlist;
  21         struct ice_hw_dev_caps dev_caps;
  22 };
  23
  24 /* The following functions are used to format specific strings for various
  25  * devlink info versions. The ctx parameter is used to provide the storage
  26  * buffer, as well as any ancillary information calculated when the info
  27  * request was made.
  28  *
  29  * If a version does not exist, for example when attempting to get the
  30  * inactive version of flash when there is no pending update, the function
  31  * should leave the buffer in the ctx structure empty.
  32  */
  33
  34 static void ice_info_get_dsn(struct ice_pf *pf, struct ice_info_ctx *ctx)
  35 {
  36         u8 dsn[8];
  37
  38         /* Copy the DSN into an array in Big Endian format */
  39         put_unaligned_be64(pci_get_dsn(pf->pdev), dsn);
  40
  41         snprintf(ctx->buf, sizeof(ctx->buf), "%8phD", dsn);
  42 }
  43
  44 static void ice_info_pba(struct ice_pf *pf, struct ice_info_ctx *ctx)
  45 {
  46         struct ice_hw *hw = &pf->hw;
  47         int status;
  48
  49         status = ice_read_pba_string(hw, (u8 *)ctx->buf, sizeof(ctx->buf));
  50         if (status)
  51                 /* We failed to locate the PBA, so just skip this entry */
  52                 dev_dbg(ice_pf_to_dev(pf), "Failed to read Product Board Assembly string, status %d\n",
  53                         status);
  54 }
  55
  56 static void ice_info_fw_mgmt(struct ice_pf *pf, struct ice_info_ctx *ctx)
  57 {
  58         struct ice_hw *hw = &pf->hw;
  59
  60         snprintf(ctx->buf, sizeof(ctx->buf), "%u.%u.%u",
  61                  hw->fw_maj_ver, hw->fw_min_ver, hw->fw_patch);
  62 }
  63
  64 static void ice_info_fw_api(struct ice_pf *pf, struct ice_info_ctx *ctx)
  65 {
  66         struct ice_hw *hw = &pf->hw;
  67
  68         snprintf(ctx->buf, sizeof(ctx->buf), "%u.%u.%u", hw->api_maj_ver,
  69                  hw->api_min_ver, hw->api_patch);
  70 }
  71
  72 static void ice_info_fw_build(struct ice_pf *pf, struct ice_info_ctx *ctx)
  73 {
  74         struct ice_hw *hw = &pf->hw;
  75
  76         snprintf(ctx->buf, sizeof(ctx->buf), "0x%08x", hw->fw_build);
  77 }
  78
  79 static void ice_info_orom_ver(struct ice_pf *pf, struct ice_info_ctx *ctx)
  80 {
  81         struct ice_orom_info *orom = &pf->hw.flash.orom;
  82
  83         snprintf(ctx->buf, sizeof(ctx->buf), "%u.%u.%u",
  84                  orom->major, orom->build, orom->patch);
  85 }
  86
  87 static void
  88 ice_info_pending_orom_ver(struct ice_pf __always_unused *pf,
  89                           struct ice_info_ctx *ctx)
  90 {
  91         struct ice_orom_info *orom = &ctx->pending_orom;
  92
  93         if (ctx->dev_caps.common_cap.nvm_update_pending_orom)
  94                 snprintf(ctx->buf, sizeof(ctx->buf), "%u.%u.%u",
  95                          orom->major, orom->build, orom->patch);
  96 }
  97
  98 static void ice_info_nvm_ver(struct ice_pf *pf, struct ice_info_ctx *ctx)
  99 {
 100         struct ice_nvm_info *nvm = &pf->hw.flash.nvm;
 101
 102         snprintf(ctx->buf, sizeof(ctx->buf), "%x.%02x", nvm->major, nvm->minor);
 103 }
 104
 105 static void
 106 ice_info_pending_nvm_ver(struct ice_pf __always_unused *pf,
 107                          struct ice_info_ctx *ctx)
 108 {
 109         struct ice_nvm_info *nvm = &ctx->pending_nvm;
 110
 111         if (ctx->dev_caps.common_cap.nvm_update_pending_nvm)
 112                 snprintf(ctx->buf, sizeof(ctx->buf), "%x.%02x",
 113                          nvm->major, nvm->minor);
 114 }
 115
 116 static void ice_info_eetrack(struct ice_pf *pf, struct ice_info_ctx *ctx)
 117 {
 118         struct ice_nvm_info *nvm = &pf->hw.flash.nvm;
 119
 120         snprintf(ctx->buf, sizeof(ctx->buf), "0x%08x", nvm->eetrack);
 121 }
 122
 123 static void
 124 ice_info_pending_eetrack(struct ice_pf *pf, struct ice_info_ctx *ctx)
 125 {
 126         struct ice_nvm_info *nvm = &ctx->pending_nvm;
 127
 128         if (ctx->dev_caps.common_cap.nvm_update_pending_nvm)
 129                 snprintf(ctx->buf, sizeof(ctx->buf), "0x%08x", nvm->eetrack);
 130 }
 131
 132 static void ice_info_ddp_pkg_name(struct ice_pf *pf, struct ice_info_ctx *ctx)
 133 {
 134         struct ice_hw *hw = &pf->hw;
 135
 136         snprintf(ctx->buf, sizeof(ctx->buf), "%s", hw->active_pkg_name);
 137 }
 138
 139 static void
 140 ice_info_ddp_pkg_version(struct ice_pf *pf, struct ice_info_ctx *ctx)
 141 {
 142         struct ice_pkg_ver *pkg = &pf->hw.active_pkg_ver;
 143
 144         snprintf(ctx->buf, sizeof(ctx->buf), "%u.%u.%u.%u",
 145                  pkg->major, pkg->minor, pkg->update, pkg->draft);
 146 }
 147
 148 static void
 149 ice_info_ddp_pkg_bundle_id(struct ice_pf *pf, struct ice_info_ctx *ctx)
 150 {
 151         snprintf(ctx->buf, sizeof(ctx->buf), "0x%08x", pf->hw.active_track_id);
 152 }
 153
 154 static void ice_info_netlist_ver(struct ice_pf *pf, struct ice_info_ctx *ctx)
 155 {
 156         struct ice_netlist_info *netlist = &pf->hw.flash.netlist;
 157
 158         /* The netlist version fields are BCD formatted */
 159         snprintf(ctx->buf, sizeof(ctx->buf), "%x.%x.%x-%x.%x.%x",
 160                  netlist->major, netlist->minor,
 161                  netlist->type >> 16, netlist->type & 0xFFFF,
 162                  netlist->rev, netlist->cust_ver);
 163 }
 164
 165 static void ice_info_netlist_build(struct ice_pf *pf, struct ice_info_ctx *ctx)
 166 {
 167         struct ice_netlist_info *netlist = &pf->hw.flash.netlist;
 168
 169         snprintf(ctx->buf, sizeof(ctx->buf), "0x%08x", netlist->hash);
 170 }
 171
 172 static void
 173 ice_info_pending_netlist_ver(struct ice_pf __always_unused *pf,
 174                              struct ice_info_ctx *ctx)
 175 {
 176         struct ice_netlist_info *netlist = &ctx->pending_netlist;
 177
 178         /* The netlist version fields are BCD formatted */
 179         if (ctx->dev_caps.common_cap.nvm_update_pending_netlist)
 180                 snprintf(ctx->buf, sizeof(ctx->buf), "%x.%x.%x-%x.%x.%x",
 181                          netlist->major, netlist->minor,
 182                          netlist->type >> 16, netlist->type & 0xFFFF,
 183                          netlist->rev, netlist->cust_ver);
 184 }
 185
 186 static void
 187 ice_info_pending_netlist_build(struct ice_pf __always_unused *pf,
 188                                struct ice_info_ctx *ctx)
 189 {
 190         struct ice_netlist_info *netlist = &ctx->pending_netlist;
 191
 192         if (ctx->dev_caps.common_cap.nvm_update_pending_netlist)
 193                 snprintf(ctx->buf, sizeof(ctx->buf), "0x%08x", netlist->hash);
 194 }
 195
 196 static void ice_info_cgu_fw_build(struct ice_pf *pf, struct ice_info_ctx *ctx)
 197 {
 198         u32 id, cfg_ver, fw_ver;
 199
 200         if (!ice_is_feature_supported(pf, ICE_F_CGU))
 201                 return;
 202         if (ice_aq_get_cgu_info(&pf->hw, &id, &cfg_ver, &fw_ver))
 203                 return;
 204         snprintf(ctx->buf, sizeof(ctx->buf), "%u.%u.%u", id, cfg_ver, fw_ver);
 205 }
 206
 207 static void ice_info_cgu_id(struct ice_pf *pf, struct ice_info_ctx *ctx)
 208 {
 209         if (!ice_is_feature_supported(pf, ICE_F_CGU))
 210                 return;
 211         snprintf(ctx->buf, sizeof(ctx->buf), "%u", pf->hw.cgu_part_number);
 212 }
 213
 214 #define fixed(key, getter) { ICE_VERSION_FIXED, key, getter, NULL }
 215 #define running(key, getter) { ICE_VERSION_RUNNING, key, getter, NULL }
 216 #define stored(key, getter, fallback) { ICE_VERSION_STORED, key, getter, fallback }
 217
 218 /* The combined() macro inserts both the running entry as well as a stored
 219  * entry. The running entry will always report the version from the active
 220  * handler. The stored entry will first try the pending handler, and fallback
 221  * to the active handler if the pending function does not report a version.
 222  * The pending handler should check the status of a pending update for the
 223  * relevant flash component. It should only fill in the buffer in the case
 224  * where a valid pending version is available. This ensures that the related
 225  * stored and running versions remain in sync, and that stored versions are
 226  * correctly reported as expected.
 227  */
 228 #define combined(key, active, pending) \
 229         running(key, active), \
 230         stored(key, pending, active)
 231
 232 enum ice_version_type {
 233         ICE_VERSION_FIXED,
 234         ICE_VERSION_RUNNING,
 235         ICE_VERSION_STORED,
 236 };
 237
 238 static const struct ice_devlink_version {
 239         enum ice_version_type type;
 240         const char *key;
 241         void (*getter)(struct ice_pf *pf, struct ice_info_ctx *ctx);
 242         void (*fallback)(struct ice_pf *pf, struct ice_info_ctx *ctx);
 243 } ice_devlink_versions[] = {
 244         fixed(DEVLINK_INFO_VERSION_GENERIC_BOARD_ID, ice_info_pba),
 245         running(DEVLINK_INFO_VERSION_GENERIC_FW_MGMT, ice_info_fw_mgmt),
 246         running("fw.mgmt.api", ice_info_fw_api),
 247         running("fw.mgmt.build", ice_info_fw_build),
 248         combined(DEVLINK_INFO_VERSION_GENERIC_FW_UNDI, ice_info_orom_ver, ice_info_pending_orom_ver),
 249         combined("fw.psid.api", ice_info_nvm_ver, ice_info_pending_nvm_ver),
 250         combined(DEVLINK_INFO_VERSION_GENERIC_FW_BUNDLE_ID, ice_info_eetrack, ice_info_pending_eetrack),
 251         running("fw.app.name", ice_info_ddp_pkg_name),
 252         running(DEVLINK_INFO_VERSION_GENERIC_FW_APP, ice_info_ddp_pkg_version),
 253         running("fw.app.bundle_id", ice_info_ddp_pkg_bundle_id),
 254         combined("fw.netlist", ice_info_netlist_ver, ice_info_pending_netlist_ver),
 255         combined("fw.netlist.build", ice_info_netlist_build, ice_info_pending_netlist_build),
 256         fixed("cgu.id", ice_info_cgu_id),
 257         running("fw.cgu", ice_info_cgu_fw_build),
 258 };
 259
 260 /**
 261  * ice_devlink_info_get - .info_get devlink handler
 262  * @devlink: devlink instance structure
 263  * @req: the devlink info request
 264  * @extack: extended netdev ack structure
 265  *
 266  * Callback for the devlink .info_get operation. Reports information about the
 267  * device.
 268  *
 269  * Return: zero on success or an error code on failure.
 270  */
 271 static int ice_devlink_info_get(struct devlink *devlink,
 272                                 struct devlink_info_req *req,
 273                                 struct netlink_ext_ack *extack)
 274 {
 275         struct ice_pf *pf = devlink_priv(devlink);
 276         struct device *dev = ice_pf_to_dev(pf);
 277         struct ice_hw *hw = &pf->hw;
 278         struct ice_info_ctx *ctx;
 279         size_t i;
 280         int err;
 281
 282         err = ice_wait_for_reset(pf, 10 * HZ);
 283         if (err) {
 284                 NL_SET_ERR_MSG_MOD(extack, "Device is busy resetting");
 285                 return err;
 286         }
 287
 288         ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
 289         if (!ctx)
 290                 return -ENOMEM;
 291
 292         /* discover capabilities first */
 293         err = ice_discover_dev_caps(hw, &ctx->dev_caps);
 294         if (err) {
 295                 dev_dbg(dev, "Failed to discover device capabilities, status %d aq_err %s\n",
 296                         err, ice_aq_str(hw->adminq.sq_last_status));
 297                 NL_SET_ERR_MSG_MOD(extack, "Unable to discover device capabilities");
 298                 goto out_free_ctx;
 299         }
 300
 301         if (ctx->dev_caps.common_cap.nvm_update_pending_orom) {
 302                 err = ice_get_inactive_orom_ver(hw, &ctx->pending_orom);
 303                 if (err) {
 304                         dev_dbg(dev, "Unable to read inactive Option ROM version data, status %d aq_err %s\n",
 305                                 err, ice_aq_str(hw->adminq.sq_last_status));
 306
 307                         /* disable display of pending Option ROM */
 308                         ctx->dev_caps.common_cap.nvm_update_pending_orom = false;
 309                 }
 310         }
 311
 312         if (ctx->dev_caps.common_cap.nvm_update_pending_nvm) {
 313                 err = ice_get_inactive_nvm_ver(hw, &ctx->pending_nvm);
 314                 if (err) {
 315                         dev_dbg(dev, "Unable to read inactive NVM version data, status %d aq_err %s\n",
 316                                 err, ice_aq_str(hw->adminq.sq_last_status));
 317
 318                         /* disable display of pending Option ROM */
 319                         ctx->dev_caps.common_cap.nvm_update_pending_nvm = false;
 320                 }
 321         }
 322
 323         if (ctx->dev_caps.common_cap.nvm_update_pending_netlist) {
 324                 err = ice_get_inactive_netlist_ver(hw, &ctx->pending_netlist);
 325                 if (err) {
 326                         dev_dbg(dev, "Unable to read inactive Netlist version data, status %d aq_err %s\n",
 327                                 err, ice_aq_str(hw->adminq.sq_last_status));
 328
 329                         /* disable display of pending Option ROM */
 330                         ctx->dev_caps.common_cap.nvm_update_pending_netlist = false;
 331                 }
 332         }
 333
 334         ice_info_get_dsn(pf, ctx);
 335
 336         err = devlink_info_serial_number_put(req, ctx->buf);
 337         if (err) {
 338                 NL_SET_ERR_MSG_MOD(extack, "Unable to set serial number");
 339                 goto out_free_ctx;
 340         }
 341
 342         for (i = 0; i < ARRAY_SIZE(ice_devlink_versions); i++) {
 343                 enum ice_version_type type = ice_devlink_versions[i].type;
 344                 const char *key = ice_devlink_versions[i].key;
 345
 346                 memset(ctx->buf, 0, sizeof(ctx->buf));
 347
 348                 ice_devlink_versions[i].getter(pf, ctx);
 349
 350                 /* If the default getter doesn't report a version, use the
 351                  * fallback function. This is primarily useful in the case of
 352                  * "stored" versions that want to report the same value as the
 353                  * running version in the normal case of no pending update.
 354                  */
 355                 if (ctx->buf[0] == '\0' && ice_devlink_versions[i].fallback)
 356                         ice_devlink_versions[i].fallback(pf, ctx);
 357
 358                 /* Do not report missing versions */
 359                 if (ctx->buf[0] == '\0')
 360                         continue;
 361
 362                 switch (type) {
 363                 case ICE_VERSION_FIXED:
 364                         err = devlink_info_version_fixed_put(req, key, ctx->buf);
 365                         if (err) {
 366                                 NL_SET_ERR_MSG_MOD(extack, "Unable to set fixed version");
 367                                 goto out_free_ctx;
 368                         }
 369                         break;
 370                 case ICE_VERSION_RUNNING:
 371                         err = devlink_info_version_running_put(req, key, ctx->buf);
 372                         if (err) {
 373                                 NL_SET_ERR_MSG_MOD(extack, "Unable to set running version");
 374                                 goto out_free_ctx;
 375                         }
 376                         break;
 377                 case ICE_VERSION_STORED:
 378                         err = devlink_info_version_stored_put(req, key, ctx->buf);
 379                         if (err) {
 380                                 NL_SET_ERR_MSG_MOD(extack, "Unable to set stored version");
 381                                 goto out_free_ctx;
 382                         }
 383                         break;
 384                 }
 385         }
 386
 387 out_free_ctx:
 388         kfree(ctx);
 389         return err;
 390 }
 391
 392 /**
 393  * ice_devlink_reload_empr_start - Start EMP reset to activate new firmware
 394  * @pf: pointer to the pf instance
 395  * @extack: netlink extended ACK structure
 396  *
 397  * Allow user to activate new Embedded Management Processor firmware by
 398  * issuing device specific EMP reset. Called in response to
 399  * a DEVLINK_CMD_RELOAD with the DEVLINK_RELOAD_ACTION_FW_ACTIVATE.
 400  *
 401  * Note that teardown and rebuild of the driver state happens automatically as
 402  * part of an interrupt and watchdog task. This is because all physical
 403  * functions on the device must be able to reset when an EMP reset occurs from
 404  * any source.
 405  */
 406 static int
 407 ice_devlink_reload_empr_start(struct ice_pf *pf,
 408                               struct netlink_ext_ack *extack)
 409 {
 410         struct device *dev = ice_pf_to_dev(pf);
 411         struct ice_hw *hw = &pf->hw;
 412         u8 pending;
 413         int err;
 414
 415         err = ice_get_pending_updates(pf, &pending, extack);
 416         if (err)
 417                 return err;
 418
 419         /* pending is a bitmask of which flash banks have a pending update,
 420          * including the main NVM bank, the Option ROM bank, and the netlist
 421          * bank. If any of these bits are set, then there is a pending update
 422          * waiting to be activated.
 423          */
 424         if (!pending) {
 425                 NL_SET_ERR_MSG_MOD(extack, "No pending firmware update");
 426                 return -ECANCELED;
 427         }
 428
 429         if (pf->fw_emp_reset_disabled) {
 430                 NL_SET_ERR_MSG_MOD(extack, "EMP reset is not available. To activate firmware, a reboot or power cycle is needed");
 431                 return -ECANCELED;
 432         }
 433
 434         dev_dbg(dev, "Issuing device EMP reset to activate firmware\n");
 435
 436         err = ice_aq_nvm_update_empr(hw);
 437         if (err) {
 438                 dev_err(dev, "Failed to trigger EMP device reset to reload firmware, err %d aq_err %s\n",
 439                         err, ice_aq_str(hw->adminq.sq_last_status));
 440                 NL_SET_ERR_MSG_MOD(extack, "Failed to trigger EMP device reset to reload firmware");
 441                 return err;
 442         }
 443
 444         return 0;
 445 }
 446
 447 /**
 448  * ice_devlink_reload_down - prepare for reload
 449  * @devlink: pointer to the devlink instance to reload
 450  * @netns_change: if true, the network namespace is changing
 451  * @action: the action to perform
 452  * @limit: limits on what reload should do, such as not resetting
 453  * @extack: netlink extended ACK structure
 454  */
 455 static int
 456 ice_devlink_reload_down(struct devlink *devlink, bool netns_change,
 457                         enum devlink_reload_action action,
 458                         enum devlink_reload_limit limit,
 459                         struct netlink_ext_ack *extack)
 460 {
 461         struct ice_pf *pf = devlink_priv(devlink);
 462
 463         switch (action) {
 464         case DEVLINK_RELOAD_ACTION_DRIVER_REINIT:
 465                 if (ice_is_eswitch_mode_switchdev(pf)) {
 466                         NL_SET_ERR_MSG_MOD(extack,
 467                                            "Go to legacy mode before doing reinit\n");
 468                         return -EOPNOTSUPP;
 469                 }
 470                 if (ice_is_adq_active(pf)) {
 471                         NL_SET_ERR_MSG_MOD(extack,
 472                                            "Turn off ADQ before doing reinit\n");
 473                         return -EOPNOTSUPP;
 474                 }
 475                 if (ice_has_vfs(pf)) {
 476                         NL_SET_ERR_MSG_MOD(extack,
 477                                            "Remove all VFs before doing reinit\n");
 478                         return -EOPNOTSUPP;
 479                 }
 480                 ice_unload(pf);
 481                 return 0;
 482         case DEVLINK_RELOAD_ACTION_FW_ACTIVATE:
 483                 return ice_devlink_reload_empr_start(pf, extack);
 484         default:
 485                 WARN_ON(1);
 486                 return -EOPNOTSUPP;
 487         }
 488 }
 489
 490 /**
 491  * ice_devlink_reload_empr_finish - Wait for EMP reset to finish
 492  * @pf: pointer to the pf instance
 493  * @extack: netlink extended ACK structure
 494  *
 495  * Wait for driver to finish rebuilding after EMP reset is completed. This
 496  * includes time to wait for both the actual device reset as well as the time
 497  * for the driver's rebuild to complete.
 498  */
 499 static int
 500 ice_devlink_reload_empr_finish(struct ice_pf *pf,
 501                                struct netlink_ext_ack *extack)
 502 {
 503         int err;
 504
 505         err = ice_wait_for_reset(pf, 60 * HZ);
 506         if (err) {
 507                 NL_SET_ERR_MSG_MOD(extack, "Device still resetting after 1 minute");
 508                 return err;
 509         }
 510
 511         return 0;
 512 }
 513
 514 /**
 515  * ice_devlink_port_opt_speed_str - convert speed to a string
 516  * @speed: speed value
 517  */
 518 static const char *ice_devlink_port_opt_speed_str(u8 speed)
 519 {
 520         switch (speed & ICE_AQC_PORT_OPT_MAX_LANE_M) {
 521         case ICE_AQC_PORT_OPT_MAX_LANE_100M:
 522                 return "0.1";
 523         case ICE_AQC_PORT_OPT_MAX_LANE_1G:
 524                 return "1";
 525         case ICE_AQC_PORT_OPT_MAX_LANE_2500M:
 526                 return "2.5";
 527         case ICE_AQC_PORT_OPT_MAX_LANE_5G:
 528                 return "5";
 529         case ICE_AQC_PORT_OPT_MAX_LANE_10G:
 530                 return "10";
 531         case ICE_AQC_PORT_OPT_MAX_LANE_25G:
 532                 return "25";
 533         case ICE_AQC_PORT_OPT_MAX_LANE_50G:
 534                 return "50";
 535         case ICE_AQC_PORT_OPT_MAX_LANE_100G:
 536                 return "100";
 537         }
 538
 539         return "-";
 540 }
 541
 542 #define ICE_PORT_OPT_DESC_LEN   50
 543 /**
 544  * ice_devlink_port_options_print - Print available port split options
 545  * @pf: the PF to print split port options
 546  *
 547  * Prints a table with available port split options and max port speeds
 548  */
 549 static void ice_devlink_port_options_print(struct ice_pf *pf)
 550 {
 551         u8 i, j, options_count, cnt, speed, pending_idx, active_idx;
 552         struct ice_aqc_get_port_options_elem *options, *opt;
 553         struct device *dev = ice_pf_to_dev(pf);
 554         bool active_valid, pending_valid;
 555         char desc[ICE_PORT_OPT_DESC_LEN];
 556         const char *str;
 557         int status;
 558
 559         options = kcalloc(ICE_AQC_PORT_OPT_MAX * ICE_MAX_PORT_PER_PCI_DEV,
 560                           sizeof(*options), GFP_KERNEL);
 561         if (!options)
 562                 return;
 563
 564         for (i = 0; i < ICE_MAX_PORT_PER_PCI_DEV; i++) {
 565                 opt = options + i * ICE_AQC_PORT_OPT_MAX;
 566                 options_count = ICE_AQC_PORT_OPT_MAX;
 567                 active_valid = 0;
 568
 569                 status = ice_aq_get_port_options(&pf->hw, opt, &options_count,
 570                                                  i, true, &active_idx,
 571                                                  &active_valid, &pending_idx,
 572                                                  &pending_valid);
 573                 if (status) {
 574                         dev_dbg(dev, "Couldn't read port option for port %d, err %d\n",
 575                                 i, status);
 576                         goto err;
 577                 }
 578         }
 579
 580         dev_dbg(dev, "Available port split options and max port speeds (Gbps):\n");
 581         dev_dbg(dev, "Status  Split      Quad 0          Quad 1\n");
 582         dev_dbg(dev, "        count  L0  L1  L2  L3  L4  L5  L6  L7\n");
 583
 584         for (i = 0; i < options_count; i++) {
 585                 cnt = 0;
 586
 587                 if (i == ice_active_port_option)
 588                         str = "Active";
 589                 else if ((i == pending_idx) && pending_valid)
 590                         str = "Pending";
 591                 else
 592                         str = "";
 593
 594                 cnt += snprintf(&desc[cnt], ICE_PORT_OPT_DESC_LEN - cnt,
 595                                 "%-8s", str);
 596
 597                 cnt += snprintf(&desc[cnt], ICE_PORT_OPT_DESC_LEN - cnt,
 598                                 "%-6u", options[i].pmd);
 599
 600                 for (j = 0; j < ICE_MAX_PORT_PER_PCI_DEV; ++j) {
 601                         speed = options[i + j * ICE_AQC_PORT_OPT_MAX].max_lane_speed;
 602                         str = ice_devlink_port_opt_speed_str(speed);
 603                         cnt += snprintf(&desc[cnt], ICE_PORT_OPT_DESC_LEN - cnt,
 604                                         "%3s ", str);
 605                 }
 606
 607                 dev_dbg(dev, "%s\n", desc);
 608         }
 609
 610 err:
 611         kfree(options);
 612 }
 613
 614 /**
 615  * ice_devlink_aq_set_port_option - Send set port option admin queue command
 616  * @pf: the PF to print split port options
 617  * @option_idx: selected port option
 618  * @extack: extended netdev ack structure
 619  *
 620  * Sends set port option admin queue command with selected port option and
 621  * calls NVM write activate.
 622  */
 623 static int
 624 ice_devlink_aq_set_port_option(struct ice_pf *pf, u8 option_idx,
 625                                struct netlink_ext_ack *extack)
 626 {
 627         struct device *dev = ice_pf_to_dev(pf);
 628         int status;
 629
 630         status = ice_aq_set_port_option(&pf->hw, 0, true, option_idx);
 631         if (status) {
 632                 dev_dbg(dev, "ice_aq_set_port_option, err %d aq_err %d\n",
 633                         status, pf->hw.adminq.sq_last_status);
 634                 NL_SET_ERR_MSG_MOD(extack, "Port split request failed");
 635                 return -EIO;
 636         }
 637
 638         status = ice_acquire_nvm(&pf->hw, ICE_RES_WRITE);
 639         if (status) {
 640                 dev_dbg(dev, "ice_acquire_nvm failed, err %d aq_err %d\n",
 641                         status, pf->hw.adminq.sq_last_status);
 642                 NL_SET_ERR_MSG_MOD(extack, "Failed to acquire NVM semaphore");
 643                 return -EIO;
 644         }
 645
 646         status = ice_nvm_write_activate(&pf->hw, ICE_AQC_NVM_ACTIV_REQ_EMPR, NULL);
 647         if (status) {
 648                 dev_dbg(dev, "ice_nvm_write_activate failed, err %d aq_err %d\n",
 649                         status, pf->hw.adminq.sq_last_status);
 650                 NL_SET_ERR_MSG_MOD(extack, "Port split request failed to save data");
 651                 ice_release_nvm(&pf->hw);
 652                 return -EIO;
 653         }
 654
 655         ice_release_nvm(&pf->hw);
 656
 657         NL_SET_ERR_MSG_MOD(extack, "Reboot required to finish port split");
 658         return 0;
 659 }
 660
 661 /**
 662  * ice_devlink_port_split - .port_split devlink handler
 663  * @devlink: devlink instance structure
 664  * @port: devlink port structure
 665  * @count: number of ports to split to
 666  * @extack: extended netdev ack structure
 667  *
 668  * Callback for the devlink .port_split operation.
 669  *
 670  * Unfortunately, the devlink expression of available options is limited
 671  * to just a number, so search for an FW port option which supports
 672  * the specified number. As there could be multiple FW port options with
 673  * the same port split count, allow switching between them. When the same
 674  * port split count request is issued again, switch to the next FW port
 675  * option with the same port split count.
 676  *
 677  * Return: zero on success or an error code on failure.
 678  */
 679 static int
 680 ice_devlink_port_split(struct devlink *devlink, struct devlink_port *port,
 681                        unsigned int count, struct netlink_ext_ack *extack)
 682 {
 683         struct ice_aqc_get_port_options_elem options[ICE_AQC_PORT_OPT_MAX];
 684         u8 i, j, active_idx, pending_idx, new_option;
 685         struct ice_pf *pf = devlink_priv(devlink);
 686         u8 option_count = ICE_AQC_PORT_OPT_MAX;
 687         struct device *dev = ice_pf_to_dev(pf);
 688         bool active_valid, pending_valid;
 689         int status;
 690
 691         status = ice_aq_get_port_options(&pf->hw, options, &option_count,
 692                                          0, true, &active_idx, &active_valid,
 693                                          &pending_idx, &pending_valid);
 694         if (status) {
 695                 dev_dbg(dev, "Couldn't read port split options, err = %d\n",
 696                         status);
 697                 NL_SET_ERR_MSG_MOD(extack, "Failed to get available port split options");
 698                 return -EIO;
 699         }
 700
 701         new_option = ICE_AQC_PORT_OPT_MAX;
 702         active_idx = pending_valid ? pending_idx : active_idx;
 703         for (i = 1; i <= option_count; i++) {
 704                 /* In order to allow switching between FW port options with
 705                  * the same port split count, search for a new option starting
 706                  * from the active/pending option (with array wrap around).
 707                  */
 708                 j = (active_idx + i) % option_count;
 709
 710                 if (count == options[j].pmd) {
 711                         new_option = j;
 712                         break;
 713                 }
 714         }
 715
 716         if (new_option == active_idx) {
 717                 dev_dbg(dev, "request to split: count: %u is already set and there are no other options\n",
 718                         count);
 719                 NL_SET_ERR_MSG_MOD(extack, "Requested split count is already set");
 720                 ice_devlink_port_options_print(pf);
 721                 return -EINVAL;
 722         }
 723
 724         if (new_option == ICE_AQC_PORT_OPT_MAX) {
 725                 dev_dbg(dev, "request to split: count: %u not found\n", count);
 726                 NL_SET_ERR_MSG_MOD(extack, "Port split requested unsupported port config");
 727                 ice_devlink_port_options_print(pf);
 728                 return -EINVAL;
 729         }
 730
 731         status = ice_devlink_aq_set_port_option(pf, new_option, extack);
 732         if (status)
 733                 return status;
 734
 735         ice_devlink_port_options_print(pf);
 736
 737         return 0;
 738 }
 739
 740 /**
 741  * ice_devlink_port_unsplit - .port_unsplit devlink handler
 742  * @devlink: devlink instance structure
 743  * @port: devlink port structure
 744  * @extack: extended netdev ack structure
 745  *
 746  * Callback for the devlink .port_unsplit operation.
 747  * Calls ice_devlink_port_split with split count set to 1.
 748  * There could be no FW option available with split count 1.
 749  *
 750  * Return: zero on success or an error code on failure.
 751  */
 752 static int
 753 ice_devlink_port_unsplit(struct devlink *devlink, struct devlink_port *port,
 754                          struct netlink_ext_ack *extack)
 755 {
 756         return ice_devlink_port_split(devlink, port, 1, extack);
 757 }
 758
 759 /**
 760  * ice_tear_down_devlink_rate_tree - removes devlink-rate exported tree
 761  * @pf: pf struct
 762  *
 763  * This function tears down tree exported during VF's creation.
 764  */
 765 void ice_tear_down_devlink_rate_tree(struct ice_pf *pf)
 766 {
 767         struct devlink *devlink;
 768         struct ice_vf *vf;
 769         unsigned int bkt;
 770
 771         devlink = priv_to_devlink(pf);
 772
 773         devl_lock(devlink);
 774         mutex_lock(&pf->vfs.table_lock);
 775         ice_for_each_vf(pf, bkt, vf) {
 776                 if (vf->devlink_port.devlink_rate)
 777                         devl_rate_leaf_destroy(&vf->devlink_port);
 778         }
 779         mutex_unlock(&pf->vfs.table_lock);
 780
 781         devl_rate_nodes_destroy(devlink);
 782         devl_unlock(devlink);
 783 }
 784
 785 /**
 786  * ice_enable_custom_tx - try to enable custom Tx feature
 787  * @pf: pf struct
 788  *
 789  * This function tries to enable custom Tx feature,
 790  * it's not possible to enable it, if DCB or ADQ is active.
 791  */
 792 static bool ice_enable_custom_tx(struct ice_pf *pf)
 793 {
 794         struct ice_port_info *pi = ice_get_main_vsi(pf)->port_info;
 795         struct device *dev = ice_pf_to_dev(pf);
 796
 797         if (pi->is_custom_tx_enabled)
 798                 /* already enabled, return true */
 799                 return true;
 800
 801         if (ice_is_adq_active(pf)) {
 802                 dev_err(dev, "ADQ active, can't modify Tx scheduler tree\n");
 803                 return false;
 804         }
 805
 806         if (ice_is_dcb_active(pf)) {
 807                 dev_err(dev, "DCB active, can't modify Tx scheduler tree\n");
 808                 return false;
 809         }
 810
 811         pi->is_custom_tx_enabled = true;
 812
 813         return true;
 814 }
 815
 816 /**
 817  * ice_traverse_tx_tree - traverse Tx scheduler tree
 818  * @devlink: devlink struct
 819  * @node: current node, used for recursion
 820  * @tc_node: tc_node struct, that is treated as a root
 821  * @pf: pf struct
 822  *
 823  * This function traverses Tx scheduler tree and exports
 824  * entire structure to the devlink-rate.
 825  */
 826 static void ice_traverse_tx_tree(struct devlink *devlink, struct ice_sched_node *node,
 827                                  struct ice_sched_node *tc_node, struct ice_pf *pf)
 828 {
 829         struct devlink_rate *rate_node = NULL;
 830         struct ice_vf *vf;
 831         int i;
 832
 833         if (node->rate_node)
 834                 /* already added, skip to the next */
 835                 goto traverse_children;
 836
 837         if (node->parent == tc_node) {
 838                 /* create root node */
 839                 rate_node = devl_rate_node_create(devlink, node, node->name, NULL);
 840         } else if (node->vsi_handle &&
 841                    pf->vsi[node->vsi_handle]->vf) {
 842                 vf = pf->vsi[node->vsi_handle]->vf;
 843                 if (!vf->devlink_port.devlink_rate)
 844                         /* leaf nodes doesn't have children
 845                          * so we don't set rate_node
 846                          */
 847                         devl_rate_leaf_create(&vf->devlink_port, node,
 848                                               node->parent->rate_node);
 849         } else if (node->info.data.elem_type != ICE_AQC_ELEM_TYPE_LEAF &&
 850                    node->parent->rate_node) {
 851                 rate_node = devl_rate_node_create(devlink, node, node->name,
 852                                                   node->parent->rate_node);
 853         }
 854
 855         if (rate_node && !IS_ERR(rate_node))
 856                 node->rate_node = rate_node;
 857
 858 traverse_children:
 859         for (i = 0; i < node->num_children; i++)
 860                 ice_traverse_tx_tree(devlink, node->children[i], tc_node, pf);
 861 }
 862
 863 /**
 864  * ice_devlink_rate_init_tx_topology - export Tx scheduler tree to devlink rate
 865  * @devlink: devlink struct
 866  * @vsi: main vsi struct
 867  *
 868  * This function finds a root node, then calls ice_traverse_tx tree, which
 869  * traverses the tree and exports it's contents to devlink rate.
 870  */
 871 int ice_devlink_rate_init_tx_topology(struct devlink *devlink, struct ice_vsi *vsi)
 872 {
 873         struct ice_port_info *pi = vsi->port_info;
 874         struct ice_sched_node *tc_node;
 875         struct ice_pf *pf = vsi->back;
 876         int i;
 877
 878         tc_node = pi->root->children[0];
 879         mutex_lock(&pi->sched_lock);
 880         devl_lock(devlink);
 881         for (i = 0; i < tc_node->num_children; i++)
 882                 ice_traverse_tx_tree(devlink, tc_node->children[i], tc_node, pf);
 883         devl_unlock(devlink);
 884         mutex_unlock(&pi->sched_lock);
 885
 886         return 0;
 887 }
 888
 889 static void ice_clear_rate_nodes(struct ice_sched_node *node)
 890 {
 891         node->rate_node = NULL;
 892
 893         for (int i = 0; i < node->num_children; i++)
 894                 ice_clear_rate_nodes(node->children[i]);
 895 }
 896
 897 /**
 898  * ice_devlink_rate_clear_tx_topology - clear node->rate_node
 899  * @vsi: main vsi struct
 900  *
 901  * Clear rate_node to cleanup creation of Tx topology.
 902  *
 903  */
 904 void ice_devlink_rate_clear_tx_topology(struct ice_vsi *vsi)
 905 {
 906         struct ice_port_info *pi = vsi->port_info;
 907
 908         mutex_lock(&pi->sched_lock);
 909         ice_clear_rate_nodes(pi->root->children[0]);
 910         mutex_unlock(&pi->sched_lock);
 911 }
 912
 913 /**
 914  * ice_set_object_tx_share - sets node scheduling parameter
 915  * @pi: devlink struct instance
 916  * @node: node struct instance
 917  * @bw: bandwidth in bytes per second
 918  * @extack: extended netdev ack structure
 919  *
 920  * This function sets ICE_MIN_BW scheduling BW limit.
 921  */
 922 static int ice_set_object_tx_share(struct ice_port_info *pi, struct ice_sched_node *node,
 923                                    u64 bw, struct netlink_ext_ack *extack)
 924 {
 925         int status;
 926
 927         mutex_lock(&pi->sched_lock);
 928         /* converts bytes per second to kilo bits per second */
 929         node->tx_share = div_u64(bw, 125);
 930         status = ice_sched_set_node_bw_lmt(pi, node, ICE_MIN_BW, node->tx_share);
 931         mutex_unlock(&pi->sched_lock);
 932
 933         if (status)
 934                 NL_SET_ERR_MSG_MOD(extack, "Can't set scheduling node tx_share");
 935
 936         return status;
 937 }
 938
 939 /**
 940  * ice_set_object_tx_max - sets node scheduling parameter
 941  * @pi: devlink struct instance
 942  * @node: node struct instance
 943  * @bw: bandwidth in bytes per second
 944  * @extack: extended netdev ack structure
 945  *
 946  * This function sets ICE_MAX_BW scheduling BW limit.
 947  */
 948 static int ice_set_object_tx_max(struct ice_port_info *pi, struct ice_sched_node *node,
 949                                  u64 bw, struct netlink_ext_ack *extack)
 950 {
 951         int status;
 952
 953         mutex_lock(&pi->sched_lock);
 954         /* converts bytes per second value to kilo bits per second */
 955         node->tx_max = div_u64(bw, 125);
 956         status = ice_sched_set_node_bw_lmt(pi, node, ICE_MAX_BW, node->tx_max);
 957         mutex_unlock(&pi->sched_lock);
 958
 959         if (status)
 960                 NL_SET_ERR_MSG_MOD(extack, "Can't set scheduling node tx_max");
 961
 962         return status;
 963 }
 964
 965 /**
 966  * ice_set_object_tx_priority - sets node scheduling parameter
 967  * @pi: devlink struct instance
 968  * @node: node struct instance
 969  * @priority: value representing priority for strict priority arbitration
 970  * @extack: extended netdev ack structure
 971  *
 972  * This function sets priority of node among siblings.
 973  */
 974 static int ice_set_object_tx_priority(struct ice_port_info *pi, struct ice_sched_node *node,
 975                                       u32 priority, struct netlink_ext_ack *extack)
 976 {
 977         int status;
 978
 979         if (priority >= 8) {
 980                 NL_SET_ERR_MSG_MOD(extack, "Priority should be less than 8");
 981                 return -EINVAL;
 982         }
 983
 984         mutex_lock(&pi->sched_lock);
 985         node->tx_priority = priority;
 986         status = ice_sched_set_node_priority(pi, node, node->tx_priority);
 987         mutex_unlock(&pi->sched_lock);
 988
 989         if (status)
 990                 NL_SET_ERR_MSG_MOD(extack, "Can't set scheduling node tx_priority");
 991
 992         return status;
 993 }
 994
 995 /**
 996  * ice_set_object_tx_weight - sets node scheduling parameter
 997  * @pi: devlink struct instance
 998  * @node: node struct instance
 999  * @weight: value represeting relative weight for WFQ arbitration
1000  * @extack: extended netdev ack structure
1001  *
1002  * This function sets node weight for WFQ algorithm.
1003  */
1004 static int ice_set_object_tx_weight(struct ice_port_info *pi, struct ice_sched_node *node,
1005                                     u32 weight, struct netlink_ext_ack *extack)
1006 {
1007         int status;
1008
1009         if (weight > 200 || weight < 1) {
1010                 NL_SET_ERR_MSG_MOD(extack, "Weight must be between 1 and 200");
1011                 return -EINVAL;
1012         }
1013
1014         mutex_lock(&pi->sched_lock);
1015         node->tx_weight = weight;
1016         status = ice_sched_set_node_weight(pi, node, node->tx_weight);
1017         mutex_unlock(&pi->sched_lock);
1018
1019         if (status)
1020                 NL_SET_ERR_MSG_MOD(extack, "Can't set scheduling node tx_weight");
1021
1022         return status;
1023 }
1024
1025 /**
1026  * ice_get_pi_from_dev_rate - get port info from devlink_rate
1027  * @rate_node: devlink struct instance
1028  *
1029  * This function returns corresponding port_info struct of devlink_rate
1030  */
1031 static struct ice_port_info *ice_get_pi_from_dev_rate(struct devlink_rate *rate_node)
1032 {
1033         struct ice_pf *pf = devlink_priv(rate_node->devlink);
1034
1035         return ice_get_main_vsi(pf)->port_info;
1036 }
1037
1038 static int ice_devlink_rate_node_new(struct devlink_rate *rate_node, void **priv,
1039                                      struct netlink_ext_ack *extack)
1040 {
1041         struct ice_sched_node *node;
1042         struct ice_port_info *pi;
1043
1044         pi = ice_get_pi_from_dev_rate(rate_node);
1045
1046         if (!ice_enable_custom_tx(devlink_priv(rate_node->devlink)))
1047                 return -EBUSY;
1048
1049         /* preallocate memory for ice_sched_node */
1050         node = devm_kzalloc(ice_hw_to_dev(pi->hw), sizeof(*node), GFP_KERNEL);
1051         *priv = node;
1052
1053         return 0;
1054 }
1055
1056 static int ice_devlink_rate_node_del(struct devlink_rate *rate_node, void *priv,
1057                                      struct netlink_ext_ack *extack)
1058 {
1059         struct ice_sched_node *node, *tc_node;
1060         struct ice_port_info *pi;
1061
1062         pi = ice_get_pi_from_dev_rate(rate_node);
1063         tc_node = pi->root->children[0];
1064         node = priv;
1065
1066         if (!rate_node->parent || !node || tc_node == node || !extack)
1067                 return 0;
1068
1069         if (!ice_enable_custom_tx(devlink_priv(rate_node->devlink)))
1070                 return -EBUSY;
1071
1072         /* can't allow to delete a node with children */
1073         if (node->num_children)
1074                 return -EINVAL;
1075
1076         mutex_lock(&pi->sched_lock);
1077         ice_free_sched_node(pi, node);
1078         mutex_unlock(&pi->sched_lock);
1079
1080         return 0;
1081 }
1082
1083 static int ice_devlink_rate_leaf_tx_max_set(struct devlink_rate *rate_leaf, void *priv,
1084                                             u64 tx_max, struct netlink_ext_ack *extack)
1085 {
1086         struct ice_sched_node *node = priv;
1087
1088         if (!ice_enable_custom_tx(devlink_priv(rate_leaf->devlink)))
1089                 return -EBUSY;
1090
1091         if (!node)
1092                 return 0;
1093
1094         return ice_set_object_tx_max(ice_get_pi_from_dev_rate(rate_leaf),
1095                                      node, tx_max, extack);
1096 }
1097
1098 static int ice_devlink_rate_leaf_tx_share_set(struct devlink_rate *rate_leaf, void *priv,
1099                                               u64 tx_share, struct netlink_ext_ack *extack)
1100 {
1101         struct ice_sched_node *node = priv;
1102
1103         if (!ice_enable_custom_tx(devlink_priv(rate_leaf->devlink)))
1104                 return -EBUSY;
1105
1106         if (!node)
1107                 return 0;
1108
1109         return ice_set_object_tx_share(ice_get_pi_from_dev_rate(rate_leaf), node,
1110                                        tx_share, extack);
1111 }
1112
1113 static int ice_devlink_rate_leaf_tx_priority_set(struct devlink_rate *rate_leaf, void *priv,
1114                                                  u32 tx_priority, struct netlink_ext_ack *extack)
1115 {
1116         struct ice_sched_node *node = priv;
1117
1118         if (!ice_enable_custom_tx(devlink_priv(rate_leaf->devlink)))
1119                 return -EBUSY;
1120
1121         if (!node)
1122                 return 0;
1123
1124         return ice_set_object_tx_priority(ice_get_pi_from_dev_rate(rate_leaf), node,
1125                                           tx_priority, extack);
1126 }
1127
1128 static int ice_devlink_rate_leaf_tx_weight_set(struct devlink_rate *rate_leaf, void *priv,
1129                                                u32 tx_weight, struct netlink_ext_ack *extack)
1130 {
1131         struct ice_sched_node *node = priv;
1132
1133         if (!ice_enable_custom_tx(devlink_priv(rate_leaf->devlink)))
1134                 return -EBUSY;
1135
1136         if (!node)
1137                 return 0;
1138
1139         return ice_set_object_tx_weight(ice_get_pi_from_dev_rate(rate_leaf), node,
1140                                         tx_weight, extack);
1141 }
1142
1143 static int ice_devlink_rate_node_tx_max_set(struct devlink_rate *rate_node, void *priv,
1144                                             u64 tx_max, struct netlink_ext_ack *extack)
1145 {
1146         struct ice_sched_node *node = priv;
1147
1148         if (!ice_enable_custom_tx(devlink_priv(rate_node->devlink)))
1149                 return -EBUSY;
1150
1151         if (!node)
1152                 return 0;
1153
1154         return ice_set_object_tx_max(ice_get_pi_from_dev_rate(rate_node),
1155                                      node, tx_max, extack);
1156 }
1157
1158 static int ice_devlink_rate_node_tx_share_set(struct devlink_rate *rate_node, void *priv,
1159                                               u64 tx_share, struct netlink_ext_ack *extack)
1160 {
1161         struct ice_sched_node *node = priv;
1162
1163         if (!ice_enable_custom_tx(devlink_priv(rate_node->devlink)))
1164                 return -EBUSY;
1165
1166         if (!node)
1167                 return 0;
1168
1169         return ice_set_object_tx_share(ice_get_pi_from_dev_rate(rate_node),
1170                                        node, tx_share, extack);
1171 }
1172
1173 static int ice_devlink_rate_node_tx_priority_set(struct devlink_rate *rate_node, void *priv,
1174                                                  u32 tx_priority, struct netlink_ext_ack *extack)
1175 {
1176         struct ice_sched_node *node = priv;
1177
1178         if (!ice_enable_custom_tx(devlink_priv(rate_node->devlink)))
1179                 return -EBUSY;
1180
1181         if (!node)
1182                 return 0;
1183
1184         return ice_set_object_tx_priority(ice_get_pi_from_dev_rate(rate_node),
1185                                           node, tx_priority, extack);
1186 }
1187
1188 static int ice_devlink_rate_node_tx_weight_set(struct devlink_rate *rate_node, void *priv,
1189                                                u32 tx_weight, struct netlink_ext_ack *extack)
1190 {
1191         struct ice_sched_node *node = priv;
1192
1193         if (!ice_enable_custom_tx(devlink_priv(rate_node->devlink)))
1194                 return -EBUSY;
1195
1196         if (!node)
1197                 return 0;
1198
1199         return ice_set_object_tx_weight(ice_get_pi_from_dev_rate(rate_node),
1200                                         node, tx_weight, extack);
1201 }
1202
1203 static int ice_devlink_set_parent(struct devlink_rate *devlink_rate,
1204                                   struct devlink_rate *parent,
1205                                   void *priv, void *parent_priv,
1206                                   struct netlink_ext_ack *extack)
1207 {
1208         struct ice_port_info *pi = ice_get_pi_from_dev_rate(devlink_rate);
1209         struct ice_sched_node *tc_node, *node, *parent_node;
1210         u16 num_nodes_added;
1211         u32 first_node_teid;
1212         u32 node_teid;
1213         int status;
1214
1215         tc_node = pi->root->children[0];
1216         node = priv;
1217
1218         if (!extack)
1219                 return 0;
1220
1221         if (!ice_enable_custom_tx(devlink_priv(devlink_rate->devlink)))
1222                 return -EBUSY;
1223
1224         if (!parent) {
1225                 if (!node || tc_node == node || node->num_children)
1226                         return -EINVAL;
1227
1228                 mutex_lock(&pi->sched_lock);
1229                 ice_free_sched_node(pi, node);
1230                 mutex_unlock(&pi->sched_lock);
1231
1232                 return 0;
1233         }
1234
1235         parent_node = parent_priv;
1236
1237         /* if the node doesn't exist, create it */
1238         if (!node->parent) {
1239                 mutex_lock(&pi->sched_lock);
1240                 status = ice_sched_add_elems(pi, tc_node, parent_node,
1241                                              parent_node->tx_sched_layer + 1,
1242                                              1, &num_nodes_added, &first_node_teid,
1243                                              &node);
1244                 mutex_unlock(&pi->sched_lock);
1245
1246                 if (status) {
1247                         NL_SET_ERR_MSG_MOD(extack, "Can't add a new node");
1248                         return status;
1249                 }
1250
1251                 if (devlink_rate->tx_share)
1252                         ice_set_object_tx_share(pi, node, devlink_rate->tx_share, extack);
1253                 if (devlink_rate->tx_max)
1254                         ice_set_object_tx_max(pi, node, devlink_rate->tx_max, extack);
1255                 if (devlink_rate->tx_priority)
1256                         ice_set_object_tx_priority(pi, node, devlink_rate->tx_priority, extack);
1257                 if (devlink_rate->tx_weight)
1258                         ice_set_object_tx_weight(pi, node, devlink_rate->tx_weight, extack);
1259         } else {
1260                 node_teid = le32_to_cpu(node->info.node_teid);
1261                 mutex_lock(&pi->sched_lock);
1262                 status = ice_sched_move_nodes(pi, parent_node, 1, &node_teid);
1263                 mutex_unlock(&pi->sched_lock);
1264
1265                 if (status)
1266                         NL_SET_ERR_MSG_MOD(extack, "Can't move existing node to a new parent");
1267         }
1268
1269         return status;
1270 }
1271
1272 /**
1273  * ice_devlink_reload_up - do reload up after reinit
1274  * @devlink: pointer to the devlink instance reloading
1275  * @action: the action requested
1276  * @limit: limits imposed by userspace, such as not resetting
1277  * @actions_performed: on return, indicate what actions actually performed
1278  * @extack: netlink extended ACK structure
1279  */
1280 static int
1281 ice_devlink_reload_up(struct devlink *devlink,
1282                       enum devlink_reload_action action,
1283                       enum devlink_reload_limit limit,
1284                       u32 *actions_performed,
1285                       struct netlink_ext_ack *extack)
1286 {
1287         struct ice_pf *pf = devlink_priv(devlink);
1288
1289         switch (action) {
1290         case DEVLINK_RELOAD_ACTION_DRIVER_REINIT:
1291                 *actions_performed = BIT(DEVLINK_RELOAD_ACTION_DRIVER_REINIT);
1292                 return ice_load(pf);
1293         case DEVLINK_RELOAD_ACTION_FW_ACTIVATE:
1294                 *actions_performed = BIT(DEVLINK_RELOAD_ACTION_FW_ACTIVATE);
1295                 return ice_devlink_reload_empr_finish(pf, extack);
1296         default:
1297                 WARN_ON(1);
1298                 return -EOPNOTSUPP;
1299         }
1300 }
1301
1302 static const struct devlink_ops ice_devlink_ops = {
1303         .supported_flash_update_params = DEVLINK_SUPPORT_FLASH_UPDATE_OVERWRITE_MASK,
1304         .reload_actions = BIT(DEVLINK_RELOAD_ACTION_DRIVER_REINIT) |
1305                           BIT(DEVLINK_RELOAD_ACTION_FW_ACTIVATE),
1306         .reload_down = ice_devlink_reload_down,
1307         .reload_up = ice_devlink_reload_up,
1308         .eswitch_mode_get = ice_eswitch_mode_get,
1309         .eswitch_mode_set = ice_eswitch_mode_set,
1310         .info_get = ice_devlink_info_get,
1311         .flash_update = ice_devlink_flash_update,
1312
1313         .rate_node_new = ice_devlink_rate_node_new,
1314         .rate_node_del = ice_devlink_rate_node_del,
1315
1316         .rate_leaf_tx_max_set = ice_devlink_rate_leaf_tx_max_set,
1317         .rate_leaf_tx_share_set = ice_devlink_rate_leaf_tx_share_set,
1318         .rate_leaf_tx_priority_set = ice_devlink_rate_leaf_tx_priority_set,
1319         .rate_leaf_tx_weight_set = ice_devlink_rate_leaf_tx_weight_set,
1320
1321         .rate_node_tx_max_set = ice_devlink_rate_node_tx_max_set,
1322         .rate_node_tx_share_set = ice_devlink_rate_node_tx_share_set,
1323         .rate_node_tx_priority_set = ice_devlink_rate_node_tx_priority_set,
1324         .rate_node_tx_weight_set = ice_devlink_rate_node_tx_weight_set,
1325
1326         .rate_leaf_parent_set = ice_devlink_set_parent,
1327         .rate_node_parent_set = ice_devlink_set_parent,
1328 };
1329
1330 static int
1331 ice_devlink_enable_roce_get(struct devlink *devlink, u32 id,
1332                             struct devlink_param_gset_ctx *ctx)
1333 {
1334         struct ice_pf *pf = devlink_priv(devlink);
1335
1336         ctx->val.vbool = pf->rdma_mode & IIDC_RDMA_PROTOCOL_ROCEV2 ? true : false;
1337
1338         return 0;
1339 }
1340
1341 static int
1342 ice_devlink_enable_roce_set(struct devlink *devlink, u32 id,
1343                             struct devlink_param_gset_ctx *ctx)
1344 {
1345         struct ice_pf *pf = devlink_priv(devlink);
1346         bool roce_ena = ctx->val.vbool;
1347         int ret;
1348
1349         if (!roce_ena) {
1350                 ice_unplug_aux_dev(pf);
1351                 pf->rdma_mode &= ~IIDC_RDMA_PROTOCOL_ROCEV2;
1352                 return 0;
1353         }
1354
1355         pf->rdma_mode |= IIDC_RDMA_PROTOCOL_ROCEV2;
1356         ret = ice_plug_aux_dev(pf);
1357         if (ret)
1358                 pf->rdma_mode &= ~IIDC_RDMA_PROTOCOL_ROCEV2;
1359
1360         return ret;
1361 }
1362
1363 static int
1364 ice_devlink_enable_roce_validate(struct devlink *devlink, u32 id,
1365                                  union devlink_param_value val,
1366                                  struct netlink_ext_ack *extack)
1367 {
1368         struct ice_pf *pf = devlink_priv(devlink);
1369
1370         if (!test_bit(ICE_FLAG_RDMA_ENA, pf->flags))
1371                 return -EOPNOTSUPP;
1372
1373         if (pf->rdma_mode & IIDC_RDMA_PROTOCOL_IWARP) {
1374                 NL_SET_ERR_MSG_MOD(extack, "iWARP is currently enabled. This device cannot enable iWARP and RoCEv2 simultaneously");
1375                 return -EOPNOTSUPP;
1376         }
1377
1378         return 0;
1379 }
1380
1381 static int
1382 ice_devlink_enable_iw_get(struct devlink *devlink, u32 id,
1383                           struct devlink_param_gset_ctx *ctx)
1384 {
1385         struct ice_pf *pf = devlink_priv(devlink);
1386
1387         ctx->val.vbool = pf->rdma_mode & IIDC_RDMA_PROTOCOL_IWARP;
1388
1389         return 0;
1390 }
1391
1392 static int
1393 ice_devlink_enable_iw_set(struct devlink *devlink, u32 id,
1394                           struct devlink_param_gset_ctx *ctx)
1395 {
1396         struct ice_pf *pf = devlink_priv(devlink);
1397         bool iw_ena = ctx->val.vbool;
1398         int ret;
1399
1400         if (!iw_ena) {
1401                 ice_unplug_aux_dev(pf);
1402                 pf->rdma_mode &= ~IIDC_RDMA_PROTOCOL_IWARP;
1403                 return 0;
1404         }
1405
1406         pf->rdma_mode |= IIDC_RDMA_PROTOCOL_IWARP;
1407         ret = ice_plug_aux_dev(pf);
1408         if (ret)
1409                 pf->rdma_mode &= ~IIDC_RDMA_PROTOCOL_IWARP;
1410
1411         return ret;
1412 }
1413
1414 static int
1415 ice_devlink_enable_iw_validate(struct devlink *devlink, u32 id,
1416                                union devlink_param_value val,
1417                                struct netlink_ext_ack *extack)
1418 {
1419         struct ice_pf *pf = devlink_priv(devlink);
1420
1421         if (!test_bit(ICE_FLAG_RDMA_ENA, pf->flags))
1422                 return -EOPNOTSUPP;
1423
1424         if (pf->rdma_mode & IIDC_RDMA_PROTOCOL_ROCEV2) {
1425                 NL_SET_ERR_MSG_MOD(extack, "RoCEv2 is currently enabled. This device cannot enable iWARP and RoCEv2 simultaneously");
1426                 return -EOPNOTSUPP;
1427         }
1428
1429         return 0;
1430 }
1431
1432 static const struct devlink_param ice_devlink_params[] = {
1433         DEVLINK_PARAM_GENERIC(ENABLE_ROCE, BIT(DEVLINK_PARAM_CMODE_RUNTIME),
1434                               ice_devlink_enable_roce_get,
1435                               ice_devlink_enable_roce_set,
1436                               ice_devlink_enable_roce_validate),
1437         DEVLINK_PARAM_GENERIC(ENABLE_IWARP, BIT(DEVLINK_PARAM_CMODE_RUNTIME),
1438                               ice_devlink_enable_iw_get,
1439                               ice_devlink_enable_iw_set,
1440                               ice_devlink_enable_iw_validate),
1441
1442 };
1443
1444 static void ice_devlink_free(void *devlink_ptr)
1445 {
1446         devlink_free((struct devlink *)devlink_ptr);
1447 }
1448
1449 /**
1450  * ice_allocate_pf - Allocate devlink and return PF structure pointer
1451  * @dev: the device to allocate for
1452  *
1453  * Allocate a devlink instance for this device and return the private area as
1454  * the PF structure. The devlink memory is kept track of through devres by
1455  * adding an action to remove it when unwinding.
1456  */
1457 struct ice_pf *ice_allocate_pf(struct device *dev)
1458 {
1459         struct devlink *devlink;
1460
1461         devlink = devlink_alloc(&ice_devlink_ops, sizeof(struct ice_pf), dev);
1462         if (!devlink)
1463                 return NULL;
1464
1465         /* Add an action to teardown the devlink when unwinding the driver */
1466         if (devm_add_action_or_reset(dev, ice_devlink_free, devlink))
1467                 return NULL;
1468
1469         return devlink_priv(devlink);
1470 }
1471
1472 /**
1473  * ice_devlink_register - Register devlink interface for this PF
1474  * @pf: the PF to register the devlink for.
1475  *
1476  * Register the devlink instance associated with this physical function.
1477  *
1478  * Return: zero on success or an error code on failure.
1479  */
1480 void ice_devlink_register(struct ice_pf *pf)
1481 {
1482         struct devlink *devlink = priv_to_devlink(pf);
1483
1484         devlink_register(devlink);
1485 }
1486
1487 /**
1488  * ice_devlink_unregister - Unregister devlink resources for this PF.
1489  * @pf: the PF structure to cleanup
1490  *
1491  * Releases resources used by devlink and cleans up associated memory.
1492  */
1493 void ice_devlink_unregister(struct ice_pf *pf)
1494 {
1495         devlink_unregister(priv_to_devlink(pf));
1496 }
1497
1498 /**
1499  * ice_devlink_set_switch_id - Set unique switch id based on pci dsn
1500  * @pf: the PF to create a devlink port for
1501  * @ppid: struct with switch id information
1502  */
1503 static void
1504 ice_devlink_set_switch_id(struct ice_pf *pf, struct netdev_phys_item_id *ppid)
1505 {
1506         struct pci_dev *pdev = pf->pdev;
1507         u64 id;
1508
1509         id = pci_get_dsn(pdev);
1510
1511         ppid->id_len = sizeof(id);
1512         put_unaligned_be64(id, &ppid->id);
1513 }
1514
1515 int ice_devlink_register_params(struct ice_pf *pf)
1516 {
1517         struct devlink *devlink = priv_to_devlink(pf);
1518
1519         return devlink_params_register(devlink, ice_devlink_params,
1520                                        ARRAY_SIZE(ice_devlink_params));
1521 }
1522
1523 void ice_devlink_unregister_params(struct ice_pf *pf)
1524 {
1525         devlink_params_unregister(priv_to_devlink(pf), ice_devlink_params,
1526                                   ARRAY_SIZE(ice_devlink_params));
1527 }
1528
1529 /**
1530  * ice_devlink_set_port_split_options - Set port split options
1531  * @pf: the PF to set port split options
1532  * @attrs: devlink attributes
1533  *
1534  * Sets devlink port split options based on available FW port options
1535  */
1536 static void
1537 ice_devlink_set_port_split_options(struct ice_pf *pf,
1538                                    struct devlink_port_attrs *attrs)
1539 {
1540         struct ice_aqc_get_port_options_elem options[ICE_AQC_PORT_OPT_MAX];
1541         u8 i, active_idx, pending_idx, option_count = ICE_AQC_PORT_OPT_MAX;
1542         bool active_valid, pending_valid;
1543         int status;
1544
1545         status = ice_aq_get_port_options(&pf->hw, options, &option_count,
1546                                          0, true, &active_idx, &active_valid,
1547                                          &pending_idx, &pending_valid);
1548         if (status) {
1549                 dev_dbg(ice_pf_to_dev(pf), "Couldn't read port split options, err = %d\n",
1550                         status);
1551                 return;
1552         }
1553
1554         /* find the biggest available port split count */
1555         for (i = 0; i < option_count; i++)
1556                 attrs->lanes = max_t(int, attrs->lanes, options[i].pmd);
1557
1558         attrs->splittable = attrs->lanes ? 1 : 0;
1559         ice_active_port_option = active_idx;
1560 }
1561
1562 static const struct devlink_port_ops ice_devlink_port_ops = {
1563         .port_split = ice_devlink_port_split,
1564         .port_unsplit = ice_devlink_port_unsplit,
1565 };
1566
1567 /**
1568  * ice_devlink_create_pf_port - Create a devlink port for this PF
1569  * @pf: the PF to create a devlink port for
1570  *
1571  * Create and register a devlink_port for this PF.
1572  *
1573  * Return: zero on success or an error code on failure.
1574  */
1575 int ice_devlink_create_pf_port(struct ice_pf *pf)
1576 {
1577         struct devlink_port_attrs attrs = {};
1578         struct devlink_port *devlink_port;
1579         struct devlink *devlink;
1580         struct ice_vsi *vsi;
1581         struct device *dev;
1582         int err;
1583
1584         dev = ice_pf_to_dev(pf);
1585
1586         devlink_port = &pf->devlink_port;
1587
1588         vsi = ice_get_main_vsi(pf);
1589         if (!vsi)
1590                 return -EIO;
1591
1592         attrs.flavour = DEVLINK_PORT_FLAVOUR_PHYSICAL;
1593         attrs.phys.port_number = pf->hw.bus.func;
1594
1595         /* As FW supports only port split options for whole device,
1596          * set port split options only for first PF.
1597          */
1598         if (pf->hw.pf_id == 0)
1599                 ice_devlink_set_port_split_options(pf, &attrs);
1600
1601         ice_devlink_set_switch_id(pf, &attrs.switch_id);
1602
1603         devlink_port_attrs_set(devlink_port, &attrs);
1604         devlink = priv_to_devlink(pf);
1605
1606         err = devlink_port_register_with_ops(devlink, devlink_port, vsi->idx,
1607                                              &ice_devlink_port_ops);
1608         if (err) {
1609                 dev_err(dev, "Failed to create devlink port for PF %d, error %d\n",
1610                         pf->hw.pf_id, err);
1611                 return err;
1612         }
1613
1614         return 0;
1615 }
1616
1617 /**
1618  * ice_devlink_destroy_pf_port - Destroy the devlink_port for this PF
1619  * @pf: the PF to cleanup
1620  *
1621  * Unregisters the devlink_port structure associated with this PF.
1622  */
1623 void ice_devlink_destroy_pf_port(struct ice_pf *pf)
1624 {
1625         devlink_port_unregister(&pf->devlink_port);
1626 }
1627
1628 /**
1629  * ice_devlink_create_vf_port - Create a devlink port for this VF
1630  * @vf: the VF to create a port for
1631  *
1632  * Create and register a devlink_port for this VF.
1633  *
1634  * Return: zero on success or an error code on failure.
1635  */
1636 int ice_devlink_create_vf_port(struct ice_vf *vf)
1637 {
1638         struct devlink_port_attrs attrs = {};
1639         struct devlink_port *devlink_port;
1640         struct devlink *devlink;
1641         struct ice_vsi *vsi;
1642         struct device *dev;
1643         struct ice_pf *pf;
1644         int err;
1645
1646         pf = vf->pf;
1647         dev = ice_pf_to_dev(pf);
1648         devlink_port = &vf->devlink_port;
1649
1650         vsi = ice_get_vf_vsi(vf);
1651         if (!vsi)
1652                 return -EINVAL;
1653
1654         attrs.flavour = DEVLINK_PORT_FLAVOUR_PCI_VF;
1655         attrs.pci_vf.pf = pf->hw.bus.func;
1656         attrs.pci_vf.vf = vf->vf_id;
1657
1658         ice_devlink_set_switch_id(pf, &attrs.switch_id);
1659
1660         devlink_port_attrs_set(devlink_port, &attrs);
1661         devlink = priv_to_devlink(pf);
1662
1663         err = devlink_port_register(devlink, devlink_port, vsi->idx);
1664         if (err) {
1665                 dev_err(dev, "Failed to create devlink port for VF %d, error %d\n",
1666                         vf->vf_id, err);
1667                 return err;
1668         }
1669
1670         return 0;
1671 }
1672
1673 /**
1674  * ice_devlink_destroy_vf_port - Destroy the devlink_port for this VF
1675  * @vf: the VF to cleanup
1676  *
1677  * Unregisters the devlink_port structure associated with this VF.
1678  */
1679 void ice_devlink_destroy_vf_port(struct ice_vf *vf)
1680 {
1681         devl_rate_leaf_destroy(&vf->devlink_port);
1682         devlink_port_unregister(&vf->devlink_port);
1683 }
1684
1685 #define ICE_DEVLINK_READ_BLK_SIZE (1024 * 1024)
1686
1687 static const struct devlink_region_ops ice_nvm_region_ops;
1688 static const struct devlink_region_ops ice_sram_region_ops;
1689
1690 /**
1691  * ice_devlink_nvm_snapshot - Capture a snapshot of the NVM flash contents
1692  * @devlink: the devlink instance
1693  * @ops: the devlink region to snapshot
1694  * @extack: extended ACK response structure
1695  * @data: on exit points to snapshot data buffer
1696  *
1697  * This function is called in response to a DEVLINK_CMD_REGION_NEW for either
1698  * the nvm-flash or shadow-ram region.
1699  *
1700  * It captures a snapshot of the NVM or Shadow RAM flash contents. This
1701  * snapshot can then later be viewed via the DEVLINK_CMD_REGION_READ netlink
1702  * interface.
1703  *
1704  * @returns zero on success, and updates the data pointer. Returns a non-zero
1705  * error code on failure.
1706  */
1707 static int ice_devlink_nvm_snapshot(struct devlink *devlink,
1708                                     const struct devlink_region_ops *ops,
1709                                     struct netlink_ext_ack *extack, u8 **data)
1710 {
1711         struct ice_pf *pf = devlink_priv(devlink);
1712         struct device *dev = ice_pf_to_dev(pf);
1713         struct ice_hw *hw = &pf->hw;
1714         bool read_shadow_ram;
1715         u8 *nvm_data, *tmp, i;
1716         u32 nvm_size, left;
1717         s8 num_blks;
1718         int status;
1719
1720         if (ops == &ice_nvm_region_ops) {
1721                 read_shadow_ram = false;
1722                 nvm_size = hw->flash.flash_size;
1723         } else if (ops == &ice_sram_region_ops) {
1724                 read_shadow_ram = true;
1725                 nvm_size = hw->flash.sr_words * 2u;
1726         } else {
1727                 NL_SET_ERR_MSG_MOD(extack, "Unexpected region in snapshot function");
1728                 return -EOPNOTSUPP;
1729         }
1730
1731         nvm_data = vzalloc(nvm_size);
1732         if (!nvm_data)
1733                 return -ENOMEM;
1734
1735         num_blks = DIV_ROUND_UP(nvm_size, ICE_DEVLINK_READ_BLK_SIZE);
1736         tmp = nvm_data;
1737         left = nvm_size;
1738
1739         /* Some systems take longer to read the NVM than others which causes the
1740          * FW to reclaim the NVM lock before the entire NVM has been read. Fix
1741          * this by breaking the reads of the NVM into smaller chunks that will
1742          * probably not take as long. This has some overhead since we are
1743          * increasing the number of AQ commands, but it should always work
1744          */
1745         for (i = 0; i < num_blks; i++) {
1746                 u32 read_sz = min_t(u32, ICE_DEVLINK_READ_BLK_SIZE, left);
1747
1748                 status = ice_acquire_nvm(hw, ICE_RES_READ);
1749                 if (status) {
1750                         dev_dbg(dev, "ice_acquire_nvm failed, err %d aq_err %d\n",
1751                                 status, hw->adminq.sq_last_status);
1752                         NL_SET_ERR_MSG_MOD(extack, "Failed to acquire NVM semaphore");
1753                         vfree(nvm_data);
1754                         return -EIO;
1755                 }
1756
1757                 status = ice_read_flat_nvm(hw, i * ICE_DEVLINK_READ_BLK_SIZE,
1758                                            &read_sz, tmp, read_shadow_ram);
1759                 if (status) {
1760                         dev_dbg(dev, "ice_read_flat_nvm failed after reading %u bytes, err %d aq_err %d\n",
1761                                 read_sz, status, hw->adminq.sq_last_status);
1762                         NL_SET_ERR_MSG_MOD(extack, "Failed to read NVM contents");
1763                         ice_release_nvm(hw);
1764                         vfree(nvm_data);
1765                         return -EIO;
1766                 }
1767                 ice_release_nvm(hw);
1768
1769                 tmp += read_sz;
1770                 left -= read_sz;
1771         }
1772
1773         *data = nvm_data;
1774
1775         return 0;
1776 }
1777
1778 /**
1779  * ice_devlink_nvm_read - Read a portion of NVM flash contents
1780  * @devlink: the devlink instance
1781  * @ops: the devlink region to snapshot
1782  * @extack: extended ACK response structure
1783  * @offset: the offset to start at
1784  * @size: the amount to read
1785  * @data: the data buffer to read into
1786  *
1787  * This function is called in response to DEVLINK_CMD_REGION_READ to directly
1788  * read a section of the NVM contents.
1789  *
1790  * It reads from either the nvm-flash or shadow-ram region contents.
1791  *
1792  * @returns zero on success, and updates the data pointer. Returns a non-zero
1793  * error code on failure.
1794  */
1795 static int ice_devlink_nvm_read(struct devlink *devlink,
1796                                 const struct devlink_region_ops *ops,
1797                                 struct netlink_ext_ack *extack,
1798                                 u64 offset, u32 size, u8 *data)
1799 {
1800         struct ice_pf *pf = devlink_priv(devlink);
1801         struct device *dev = ice_pf_to_dev(pf);
1802         struct ice_hw *hw = &pf->hw;
1803         bool read_shadow_ram;
1804         u64 nvm_size;
1805         int status;
1806
1807         if (ops == &ice_nvm_region_ops) {
1808                 read_shadow_ram = false;
1809                 nvm_size = hw->flash.flash_size;
1810         } else if (ops == &ice_sram_region_ops) {
1811                 read_shadow_ram = true;
1812                 nvm_size = hw->flash.sr_words * 2u;
1813         } else {
1814                 NL_SET_ERR_MSG_MOD(extack, "Unexpected region in snapshot function");
1815                 return -EOPNOTSUPP;
1816         }
1817
1818         if (offset + size >= nvm_size) {
1819                 NL_SET_ERR_MSG_MOD(extack, "Cannot read beyond the region size");
1820                 return -ERANGE;
1821         }
1822
1823         status = ice_acquire_nvm(hw, ICE_RES_READ);
1824         if (status) {
1825                 dev_dbg(dev, "ice_acquire_nvm failed, err %d aq_err %d\n",
1826                         status, hw->adminq.sq_last_status);
1827                 NL_SET_ERR_MSG_MOD(extack, "Failed to acquire NVM semaphore");
1828                 return -EIO;
1829         }
1830
1831         status = ice_read_flat_nvm(hw, (u32)offset, &size, data,
1832                                    read_shadow_ram);
1833         if (status) {
1834                 dev_dbg(dev, "ice_read_flat_nvm failed after reading %u bytes, err %d aq_err %d\n",
1835                         size, status, hw->adminq.sq_last_status);
1836                 NL_SET_ERR_MSG_MOD(extack, "Failed to read NVM contents");
1837                 ice_release_nvm(hw);
1838                 return -EIO;
1839         }
1840         ice_release_nvm(hw);
1841
1842         return 0;
1843 }
1844
1845 /**
1846  * ice_devlink_devcaps_snapshot - Capture snapshot of device capabilities
1847  * @devlink: the devlink instance
1848  * @ops: the devlink region being snapshotted
1849  * @extack: extended ACK response structure
1850  * @data: on exit points to snapshot data buffer
1851  *
1852  * This function is called in response to the DEVLINK_CMD_REGION_TRIGGER for
1853  * the device-caps devlink region. It captures a snapshot of the device
1854  * capabilities reported by firmware.
1855  *
1856  * @returns zero on success, and updates the data pointer. Returns a non-zero
1857  * error code on failure.
1858  */
1859 static int
1860 ice_devlink_devcaps_snapshot(struct devlink *devlink,
1861                              const struct devlink_region_ops *ops,
1862                              struct netlink_ext_ack *extack, u8 **data)
1863 {
1864         struct ice_pf *pf = devlink_priv(devlink);
1865         struct device *dev = ice_pf_to_dev(pf);
1866         struct ice_hw *hw = &pf->hw;
1867         void *devcaps;
1868         int status;
1869
1870         devcaps = vzalloc(ICE_AQ_MAX_BUF_LEN);
1871         if (!devcaps)
1872                 return -ENOMEM;
1873
1874         status = ice_aq_list_caps(hw, devcaps, ICE_AQ_MAX_BUF_LEN, NULL,
1875                                   ice_aqc_opc_list_dev_caps, NULL);
1876         if (status) {
1877                 dev_dbg(dev, "ice_aq_list_caps: failed to read device capabilities, err %d aq_err %d\n",
1878                         status, hw->adminq.sq_last_status);
1879                 NL_SET_ERR_MSG_MOD(extack, "Failed to read device capabilities");
1880                 vfree(devcaps);
1881                 return status;
1882         }
1883
1884         *data = (u8 *)devcaps;
1885
1886         return 0;
1887 }
1888
1889 static const struct devlink_region_ops ice_nvm_region_ops = {
1890         .name = "nvm-flash",
1891         .destructor = vfree,
1892         .snapshot = ice_devlink_nvm_snapshot,
1893         .read = ice_devlink_nvm_read,
1894 };
1895
1896 static const struct devlink_region_ops ice_sram_region_ops = {
1897         .name = "shadow-ram",
1898         .destructor = vfree,
1899         .snapshot = ice_devlink_nvm_snapshot,
1900         .read = ice_devlink_nvm_read,
1901 };
1902
1903 static const struct devlink_region_ops ice_devcaps_region_ops = {
1904         .name = "device-caps",
1905         .destructor = vfree,
1906         .snapshot = ice_devlink_devcaps_snapshot,
1907 };
1908
1909 /**
1910  * ice_devlink_init_regions - Initialize devlink regions
1911  * @pf: the PF device structure
1912  *
1913  * Create devlink regions used to enable access to dump the contents of the
1914  * flash memory on the device.
1915  */
1916 void ice_devlink_init_regions(struct ice_pf *pf)
1917 {
1918         struct devlink *devlink = priv_to_devlink(pf);
1919         struct device *dev = ice_pf_to_dev(pf);
1920         u64 nvm_size, sram_size;
1921
1922         nvm_size = pf->hw.flash.flash_size;
1923         pf->nvm_region = devlink_region_create(devlink, &ice_nvm_region_ops, 1,
1924                                                nvm_size);
1925         if (IS_ERR(pf->nvm_region)) {
1926                 dev_err(dev, "failed to create NVM devlink region, err %ld\n",
1927                         PTR_ERR(pf->nvm_region));
1928                 pf->nvm_region = NULL;
1929         }
1930
1931         sram_size = pf->hw.flash.sr_words * 2u;
1932         pf->sram_region = devlink_region_create(devlink, &ice_sram_region_ops,
1933                                                 1, sram_size);
1934         if (IS_ERR(pf->sram_region)) {
1935                 dev_err(dev, "failed to create shadow-ram devlink region, err %ld\n",
1936                         PTR_ERR(pf->sram_region));
1937                 pf->sram_region = NULL;
1938         }
1939
1940         pf->devcaps_region = devlink_region_create(devlink,
1941                                                    &ice_devcaps_region_ops, 10,
1942                                                    ICE_AQ_MAX_BUF_LEN);
1943         if (IS_ERR(pf->devcaps_region)) {
1944                 dev_err(dev, "failed to create device-caps devlink region, err %ld\n",
1945                         PTR_ERR(pf->devcaps_region));
1946                 pf->devcaps_region = NULL;
1947         }
1948 }
1949
1950 /**
1951  * ice_devlink_destroy_regions - Destroy devlink regions
1952  * @pf: the PF device structure
1953  *
1954  * Remove previously created regions for this PF.
1955  */
1956 void ice_devlink_destroy_regions(struct ice_pf *pf)
1957 {
1958         if (pf->nvm_region)
1959                 devlink_region_destroy(pf->nvm_region);
1960
1961         if (pf->sram_region)
1962                 devlink_region_destroy(pf->sram_region);
1963
1964         if (pf->devcaps_region)
1965                 devlink_region_destroy(pf->devcaps_region);
1966 }