drivers/net/ethernet/intel/ice/devlink/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 "devlink.h"
   9 #include "port.h"
  10 #include "ice_eswitch.h"
  11 #include "ice_fw_update.h"
  12 #include "ice_dcb_lib.h"
  13 #include "ice_sf_eth.h"
  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_ext(req, key,
 372                                                                    ctx->buf,
 373                                                                    DEVLINK_INFO_VERSION_TYPE_COMPONENT);
 374                         if (err) {
 375                                 NL_SET_ERR_MSG_MOD(extack, "Unable to set running version");
 376                                 goto out_free_ctx;
 377                         }
 378                         break;
 379                 case ICE_VERSION_STORED:
 380                         err = devlink_info_version_stored_put_ext(req, key,
 381                                                                   ctx->buf,
 382                                                                   DEVLINK_INFO_VERSION_TYPE_COMPONENT);
 383                         if (err) {
 384                                 NL_SET_ERR_MSG_MOD(extack, "Unable to set stored version");
 385                                 goto out_free_ctx;
 386                         }
 387                         break;
 388                 }
 389         }
 390
 391 out_free_ctx:
 392         kfree(ctx);
 393         return err;
 394 }
 395
 396 /**
 397  * ice_devlink_reload_empr_start - Start EMP reset to activate new firmware
 398  * @pf: pointer to the pf instance
 399  * @extack: netlink extended ACK structure
 400  *
 401  * Allow user to activate new Embedded Management Processor firmware by
 402  * issuing device specific EMP reset. Called in response to
 403  * a DEVLINK_CMD_RELOAD with the DEVLINK_RELOAD_ACTION_FW_ACTIVATE.
 404  *
 405  * Note that teardown and rebuild of the driver state happens automatically as
 406  * part of an interrupt and watchdog task. This is because all physical
 407  * functions on the device must be able to reset when an EMP reset occurs from
 408  * any source.
 409  */
 410 static int
 411 ice_devlink_reload_empr_start(struct ice_pf *pf,
 412                               struct netlink_ext_ack *extack)
 413 {
 414         struct device *dev = ice_pf_to_dev(pf);
 415         struct ice_hw *hw = &pf->hw;
 416         u8 pending;
 417         int err;
 418
 419         err = ice_get_pending_updates(pf, &pending, extack);
 420         if (err)
 421                 return err;
 422
 423         /* pending is a bitmask of which flash banks have a pending update,
 424          * including the main NVM bank, the Option ROM bank, and the netlist
 425          * bank. If any of these bits are set, then there is a pending update
 426          * waiting to be activated.
 427          */
 428         if (!pending) {
 429                 NL_SET_ERR_MSG_MOD(extack, "No pending firmware update");
 430                 return -ECANCELED;
 431         }
 432
 433         if (pf->fw_emp_reset_disabled) {
 434                 NL_SET_ERR_MSG_MOD(extack, "EMP reset is not available. To activate firmware, a reboot or power cycle is needed");
 435                 return -ECANCELED;
 436         }
 437
 438         dev_dbg(dev, "Issuing device EMP reset to activate firmware\n");
 439
 440         err = ice_aq_nvm_update_empr(hw);
 441         if (err) {
 442                 dev_err(dev, "Failed to trigger EMP device reset to reload firmware, err %d aq_err %s\n",
 443                         err, ice_aq_str(hw->adminq.sq_last_status));
 444                 NL_SET_ERR_MSG_MOD(extack, "Failed to trigger EMP device reset to reload firmware");
 445                 return err;
 446         }
 447
 448         return 0;
 449 }
 450
 451 /**
 452  * ice_devlink_reinit_down - unload given PF
 453  * @pf: pointer to the PF struct
 454  */
 455 static void ice_devlink_reinit_down(struct ice_pf *pf)
 456 {
 457         /* No need to take devl_lock, it's already taken by devlink API */
 458         ice_unload(pf);
 459         rtnl_lock();
 460         ice_vsi_decfg(ice_get_main_vsi(pf));
 461         rtnl_unlock();
 462         ice_deinit_dev(pf);
 463 }
 464
 465 /**
 466  * ice_devlink_reload_down - prepare for reload
 467  * @devlink: pointer to the devlink instance to reload
 468  * @netns_change: if true, the network namespace is changing
 469  * @action: the action to perform
 470  * @limit: limits on what reload should do, such as not resetting
 471  * @extack: netlink extended ACK structure
 472  */
 473 static int
 474 ice_devlink_reload_down(struct devlink *devlink, bool netns_change,
 475                         enum devlink_reload_action action,
 476                         enum devlink_reload_limit limit,
 477                         struct netlink_ext_ack *extack)
 478 {
 479         struct ice_pf *pf = devlink_priv(devlink);
 480
 481         switch (action) {
 482         case DEVLINK_RELOAD_ACTION_DRIVER_REINIT:
 483                 if (ice_is_eswitch_mode_switchdev(pf)) {
 484                         NL_SET_ERR_MSG_MOD(extack,
 485                                            "Go to legacy mode before doing reinit");
 486                         return -EOPNOTSUPP;
 487                 }
 488                 if (ice_is_adq_active(pf)) {
 489                         NL_SET_ERR_MSG_MOD(extack,
 490                                            "Turn off ADQ before doing reinit");
 491                         return -EOPNOTSUPP;
 492                 }
 493                 if (ice_has_vfs(pf)) {
 494                         NL_SET_ERR_MSG_MOD(extack,
 495                                            "Remove all VFs before doing reinit");
 496                         return -EOPNOTSUPP;
 497                 }
 498                 ice_devlink_reinit_down(pf);
 499                 return 0;
 500         case DEVLINK_RELOAD_ACTION_FW_ACTIVATE:
 501                 return ice_devlink_reload_empr_start(pf, extack);
 502         default:
 503                 WARN_ON(1);
 504                 return -EOPNOTSUPP;
 505         }
 506 }
 507
 508 /**
 509  * ice_devlink_reload_empr_finish - Wait for EMP reset to finish
 510  * @pf: pointer to the pf instance
 511  * @extack: netlink extended ACK structure
 512  *
 513  * Wait for driver to finish rebuilding after EMP reset is completed. This
 514  * includes time to wait for both the actual device reset as well as the time
 515  * for the driver's rebuild to complete.
 516  */
 517 static int
 518 ice_devlink_reload_empr_finish(struct ice_pf *pf,
 519                                struct netlink_ext_ack *extack)
 520 {
 521         int err;
 522
 523         err = ice_wait_for_reset(pf, 60 * HZ);
 524         if (err) {
 525                 NL_SET_ERR_MSG_MOD(extack, "Device still resetting after 1 minute");
 526                 return err;
 527         }
 528
 529         return 0;
 530 }
 531
 532 /**
 533  * ice_get_tx_topo_user_sel - Read user's choice from flash
 534  * @pf: pointer to pf structure
 535  * @layers: value read from flash will be saved here
 536  *
 537  * Reads user's preference for Tx Scheduler Topology Tree from PFA TLV.
 538  *
 539  * Return: zero when read was successful, negative values otherwise.
 540  */
 541 static int ice_get_tx_topo_user_sel(struct ice_pf *pf, uint8_t *layers)
 542 {
 543         struct ice_aqc_nvm_tx_topo_user_sel usr_sel = {};
 544         struct ice_hw *hw = &pf->hw;
 545         int err;
 546
 547         err = ice_acquire_nvm(hw, ICE_RES_READ);
 548         if (err)
 549                 return err;
 550
 551         err = ice_aq_read_nvm(hw, ICE_AQC_NVM_TX_TOPO_MOD_ID, 0,
 552                               sizeof(usr_sel), &usr_sel, true, true, NULL);
 553         if (err)
 554                 goto exit_release_res;
 555
 556         if (usr_sel.data & ICE_AQC_NVM_TX_TOPO_USER_SEL)
 557                 *layers = ICE_SCHED_5_LAYERS;
 558         else
 559                 *layers = ICE_SCHED_9_LAYERS;
 560
 561 exit_release_res:
 562         ice_release_nvm(hw);
 563
 564         return err;
 565 }
 566
 567 /**
 568  * ice_update_tx_topo_user_sel - Save user's preference in flash
 569  * @pf: pointer to pf structure
 570  * @layers: value to be saved in flash
 571  *
 572  * Variable "layers" defines user's preference about number of layers in Tx
 573  * Scheduler Topology Tree. This choice should be stored in PFA TLV field
 574  * and be picked up by driver, next time during init.
 575  *
 576  * Return: zero when save was successful, negative values otherwise.
 577  */
 578 static int ice_update_tx_topo_user_sel(struct ice_pf *pf, int layers)
 579 {
 580         struct ice_aqc_nvm_tx_topo_user_sel usr_sel = {};
 581         struct ice_hw *hw = &pf->hw;
 582         int err;
 583
 584         err = ice_acquire_nvm(hw, ICE_RES_WRITE);
 585         if (err)
 586                 return err;
 587
 588         err = ice_aq_read_nvm(hw, ICE_AQC_NVM_TX_TOPO_MOD_ID, 0,
 589                               sizeof(usr_sel), &usr_sel, true, true, NULL);
 590         if (err)
 591                 goto exit_release_res;
 592
 593         if (layers == ICE_SCHED_5_LAYERS)
 594                 usr_sel.data |= ICE_AQC_NVM_TX_TOPO_USER_SEL;
 595         else
 596                 usr_sel.data &= ~ICE_AQC_NVM_TX_TOPO_USER_SEL;
 597
 598         err = ice_write_one_nvm_block(pf, ICE_AQC_NVM_TX_TOPO_MOD_ID, 2,
 599                                       sizeof(usr_sel.data), &usr_sel.data,
 600                                       true, NULL, NULL);
 601 exit_release_res:
 602         ice_release_nvm(hw);
 603
 604         return err;
 605 }
 606
 607 /**
 608  * ice_devlink_tx_sched_layers_get - Get tx_scheduling_layers parameter
 609  * @devlink: pointer to the devlink instance
 610  * @id: the parameter ID to set
 611  * @ctx: context to store the parameter value
 612  *
 613  * Return: zero on success and negative value on failure.
 614  */
 615 static int ice_devlink_tx_sched_layers_get(struct devlink *devlink, u32 id,
 616                                            struct devlink_param_gset_ctx *ctx)
 617 {
 618         struct ice_pf *pf = devlink_priv(devlink);
 619         int err;
 620
 621         err = ice_get_tx_topo_user_sel(pf, &ctx->val.vu8);
 622         if (err)
 623                 return err;
 624
 625         return 0;
 626 }
 627
 628 /**
 629  * ice_devlink_tx_sched_layers_set - Set tx_scheduling_layers parameter
 630  * @devlink: pointer to the devlink instance
 631  * @id: the parameter ID to set
 632  * @ctx: context to get the parameter value
 633  * @extack: netlink extended ACK structure
 634  *
 635  * Return: zero on success and negative value on failure.
 636  */
 637 static int ice_devlink_tx_sched_layers_set(struct devlink *devlink, u32 id,
 638                                            struct devlink_param_gset_ctx *ctx,
 639                                            struct netlink_ext_ack *extack)
 640 {
 641         struct ice_pf *pf = devlink_priv(devlink);
 642         int err;
 643
 644         err = ice_update_tx_topo_user_sel(pf, ctx->val.vu8);
 645         if (err)
 646                 return err;
 647
 648         NL_SET_ERR_MSG_MOD(extack,
 649                            "Tx scheduling layers have been changed on this device. You must do the PCI slot powercycle for the change to take effect.");
 650
 651         return 0;
 652 }
 653
 654 /**
 655  * ice_devlink_tx_sched_layers_validate - Validate passed tx_scheduling_layers
 656  *                                        parameter value
 657  * @devlink: unused pointer to devlink instance
 658  * @id: the parameter ID to validate
 659  * @val: value to validate
 660  * @extack: netlink extended ACK structure
 661  *
 662  * Supported values are:
 663  * - 5 - five layers Tx Scheduler Topology Tree
 664  * - 9 - nine layers Tx Scheduler Topology Tree
 665  *
 666  * Return: zero when passed parameter value is supported. Negative value on
 667  * error.
 668  */
 669 static int ice_devlink_tx_sched_layers_validate(struct devlink *devlink, u32 id,
 670                                                 union devlink_param_value val,
 671                                                 struct netlink_ext_ack *extack)
 672 {
 673         if (val.vu8 != ICE_SCHED_5_LAYERS && val.vu8 != ICE_SCHED_9_LAYERS) {
 674                 NL_SET_ERR_MSG_MOD(extack,
 675                                    "Wrong number of tx scheduler layers provided.");
 676                 return -EINVAL;
 677         }
 678
 679         return 0;
 680 }
 681
 682 /**
 683  * ice_tear_down_devlink_rate_tree - removes devlink-rate exported tree
 684  * @pf: pf struct
 685  *
 686  * This function tears down tree exported during VF's creation.
 687  */
 688 void ice_tear_down_devlink_rate_tree(struct ice_pf *pf)
 689 {
 690         struct devlink *devlink;
 691         struct ice_vf *vf;
 692         unsigned int bkt;
 693
 694         devlink = priv_to_devlink(pf);
 695
 696         devl_lock(devlink);
 697         mutex_lock(&pf->vfs.table_lock);
 698         ice_for_each_vf(pf, bkt, vf) {
 699                 if (vf->devlink_port.devlink_rate)
 700                         devl_rate_leaf_destroy(&vf->devlink_port);
 701         }
 702         mutex_unlock(&pf->vfs.table_lock);
 703
 704         devl_rate_nodes_destroy(devlink);
 705         devl_unlock(devlink);
 706 }
 707
 708 /**
 709  * ice_enable_custom_tx - try to enable custom Tx feature
 710  * @pf: pf struct
 711  *
 712  * This function tries to enable custom Tx feature,
 713  * it's not possible to enable it, if DCB or ADQ is active.
 714  */
 715 static bool ice_enable_custom_tx(struct ice_pf *pf)
 716 {
 717         struct ice_port_info *pi = ice_get_main_vsi(pf)->port_info;
 718         struct device *dev = ice_pf_to_dev(pf);
 719
 720         if (pi->is_custom_tx_enabled)
 721                 /* already enabled, return true */
 722                 return true;
 723
 724         if (ice_is_adq_active(pf)) {
 725                 dev_err(dev, "ADQ active, can't modify Tx scheduler tree\n");
 726                 return false;
 727         }
 728
 729         if (ice_is_dcb_active(pf)) {
 730                 dev_err(dev, "DCB active, can't modify Tx scheduler tree\n");
 731                 return false;
 732         }
 733
 734         pi->is_custom_tx_enabled = true;
 735
 736         return true;
 737 }
 738
 739 /**
 740  * ice_traverse_tx_tree - traverse Tx scheduler tree
 741  * @devlink: devlink struct
 742  * @node: current node, used for recursion
 743  * @tc_node: tc_node struct, that is treated as a root
 744  * @pf: pf struct
 745  *
 746  * This function traverses Tx scheduler tree and exports
 747  * entire structure to the devlink-rate.
 748  */
 749 static void ice_traverse_tx_tree(struct devlink *devlink, struct ice_sched_node *node,
 750                                  struct ice_sched_node *tc_node, struct ice_pf *pf)
 751 {
 752         struct devlink_rate *rate_node = NULL;
 753         struct ice_dynamic_port *sf;
 754         struct ice_vf *vf;
 755         int i;
 756
 757         if (node->rate_node)
 758                 /* already added, skip to the next */
 759                 goto traverse_children;
 760
 761         if (node->parent == tc_node) {
 762                 /* create root node */
 763                 rate_node = devl_rate_node_create(devlink, node, node->name, NULL);
 764         } else if (node->vsi_handle &&
 765                    pf->vsi[node->vsi_handle]->type == ICE_VSI_VF &&
 766                    pf->vsi[node->vsi_handle]->vf) {
 767                 vf = pf->vsi[node->vsi_handle]->vf;
 768                 if (!vf->devlink_port.devlink_rate)
 769                         /* leaf nodes doesn't have children
 770                          * so we don't set rate_node
 771                          */
 772                         devl_rate_leaf_create(&vf->devlink_port, node,
 773                                               node->parent->rate_node);
 774         } else if (node->vsi_handle &&
 775                    pf->vsi[node->vsi_handle]->type == ICE_VSI_SF &&
 776                    pf->vsi[node->vsi_handle]->sf) {
 777                 sf = pf->vsi[node->vsi_handle]->sf;
 778                 if (!sf->devlink_port.devlink_rate)
 779                         /* leaf nodes doesn't have children
 780                          * so we don't set rate_node
 781                          */
 782                         devl_rate_leaf_create(&sf->devlink_port, node,
 783                                               node->parent->rate_node);
 784         } else if (node->info.data.elem_type != ICE_AQC_ELEM_TYPE_LEAF &&
 785                    node->parent->rate_node) {
 786                 rate_node = devl_rate_node_create(devlink, node, node->name,
 787                                                   node->parent->rate_node);
 788         }
 789
 790         if (rate_node && !IS_ERR(rate_node))
 791                 node->rate_node = rate_node;
 792
 793 traverse_children:
 794         for (i = 0; i < node->num_children; i++)
 795                 ice_traverse_tx_tree(devlink, node->children[i], tc_node, pf);
 796 }
 797
 798 /**
 799  * ice_devlink_rate_init_tx_topology - export Tx scheduler tree to devlink rate
 800  * @devlink: devlink struct
 801  * @vsi: main vsi struct
 802  *
 803  * This function finds a root node, then calls ice_traverse_tx tree, which
 804  * traverses the tree and exports it's contents to devlink rate.
 805  */
 806 int ice_devlink_rate_init_tx_topology(struct devlink *devlink, struct ice_vsi *vsi)
 807 {
 808         struct ice_port_info *pi = vsi->port_info;
 809         struct ice_sched_node *tc_node;
 810         struct ice_pf *pf = vsi->back;
 811         int i;
 812
 813         tc_node = pi->root->children[0];
 814         mutex_lock(&pi->sched_lock);
 815         for (i = 0; i < tc_node->num_children; i++)
 816                 ice_traverse_tx_tree(devlink, tc_node->children[i], tc_node, pf);
 817         mutex_unlock(&pi->sched_lock);
 818
 819         return 0;
 820 }
 821
 822 static void ice_clear_rate_nodes(struct ice_sched_node *node)
 823 {
 824         node->rate_node = NULL;
 825
 826         for (int i = 0; i < node->num_children; i++)
 827                 ice_clear_rate_nodes(node->children[i]);
 828 }
 829
 830 /**
 831  * ice_devlink_rate_clear_tx_topology - clear node->rate_node
 832  * @vsi: main vsi struct
 833  *
 834  * Clear rate_node to cleanup creation of Tx topology.
 835  *
 836  */
 837 void ice_devlink_rate_clear_tx_topology(struct ice_vsi *vsi)
 838 {
 839         struct ice_port_info *pi = vsi->port_info;
 840
 841         mutex_lock(&pi->sched_lock);
 842         ice_clear_rate_nodes(pi->root->children[0]);
 843         mutex_unlock(&pi->sched_lock);
 844 }
 845
 846 /**
 847  * ice_set_object_tx_share - sets node scheduling parameter
 848  * @pi: devlink struct instance
 849  * @node: node struct instance
 850  * @bw: bandwidth in bytes per second
 851  * @extack: extended netdev ack structure
 852  *
 853  * This function sets ICE_MIN_BW scheduling BW limit.
 854  */
 855 static int ice_set_object_tx_share(struct ice_port_info *pi, struct ice_sched_node *node,
 856                                    u64 bw, struct netlink_ext_ack *extack)
 857 {
 858         int status;
 859
 860         mutex_lock(&pi->sched_lock);
 861         /* converts bytes per second to kilo bits per second */
 862         node->tx_share = div_u64(bw, 125);
 863         status = ice_sched_set_node_bw_lmt(pi, node, ICE_MIN_BW, node->tx_share);
 864         mutex_unlock(&pi->sched_lock);
 865
 866         if (status)
 867                 NL_SET_ERR_MSG_MOD(extack, "Can't set scheduling node tx_share");
 868
 869         return status;
 870 }
 871
 872 /**
 873  * ice_set_object_tx_max - sets node scheduling parameter
 874  * @pi: devlink struct instance
 875  * @node: node struct instance
 876  * @bw: bandwidth in bytes per second
 877  * @extack: extended netdev ack structure
 878  *
 879  * This function sets ICE_MAX_BW scheduling BW limit.
 880  */
 881 static int ice_set_object_tx_max(struct ice_port_info *pi, struct ice_sched_node *node,
 882                                  u64 bw, struct netlink_ext_ack *extack)
 883 {
 884         int status;
 885
 886         mutex_lock(&pi->sched_lock);
 887         /* converts bytes per second value to kilo bits per second */
 888         node->tx_max = div_u64(bw, 125);
 889         status = ice_sched_set_node_bw_lmt(pi, node, ICE_MAX_BW, node->tx_max);
 890         mutex_unlock(&pi->sched_lock);
 891
 892         if (status)
 893                 NL_SET_ERR_MSG_MOD(extack, "Can't set scheduling node tx_max");
 894
 895         return status;
 896 }
 897
 898 /**
 899  * ice_set_object_tx_priority - sets node scheduling parameter
 900  * @pi: devlink struct instance
 901  * @node: node struct instance
 902  * @priority: value representing priority for strict priority arbitration
 903  * @extack: extended netdev ack structure
 904  *
 905  * This function sets priority of node among siblings.
 906  */
 907 static int ice_set_object_tx_priority(struct ice_port_info *pi, struct ice_sched_node *node,
 908                                       u32 priority, struct netlink_ext_ack *extack)
 909 {
 910         int status;
 911
 912         if (priority >= 8) {
 913                 NL_SET_ERR_MSG_MOD(extack, "Priority should be less than 8");
 914                 return -EINVAL;
 915         }
 916
 917         mutex_lock(&pi->sched_lock);
 918         node->tx_priority = priority;
 919         status = ice_sched_set_node_priority(pi, node, node->tx_priority);
 920         mutex_unlock(&pi->sched_lock);
 921
 922         if (status)
 923                 NL_SET_ERR_MSG_MOD(extack, "Can't set scheduling node tx_priority");
 924
 925         return status;
 926 }
 927
 928 /**
 929  * ice_set_object_tx_weight - sets node scheduling parameter
 930  * @pi: devlink struct instance
 931  * @node: node struct instance
 932  * @weight: value represeting relative weight for WFQ arbitration
 933  * @extack: extended netdev ack structure
 934  *
 935  * This function sets node weight for WFQ algorithm.
 936  */
 937 static int ice_set_object_tx_weight(struct ice_port_info *pi, struct ice_sched_node *node,
 938                                     u32 weight, struct netlink_ext_ack *extack)
 939 {
 940         int status;
 941
 942         if (weight > 200 || weight < 1) {
 943                 NL_SET_ERR_MSG_MOD(extack, "Weight must be between 1 and 200");
 944                 return -EINVAL;
 945         }
 946
 947         mutex_lock(&pi->sched_lock);
 948         node->tx_weight = weight;
 949         status = ice_sched_set_node_weight(pi, node, node->tx_weight);
 950         mutex_unlock(&pi->sched_lock);
 951
 952         if (status)
 953                 NL_SET_ERR_MSG_MOD(extack, "Can't set scheduling node tx_weight");
 954
 955         return status;
 956 }
 957
 958 /**
 959  * ice_get_pi_from_dev_rate - get port info from devlink_rate
 960  * @rate_node: devlink struct instance
 961  *
 962  * This function returns corresponding port_info struct of devlink_rate
 963  */
 964 static struct ice_port_info *ice_get_pi_from_dev_rate(struct devlink_rate *rate_node)
 965 {
 966         struct ice_pf *pf = devlink_priv(rate_node->devlink);
 967
 968         return ice_get_main_vsi(pf)->port_info;
 969 }
 970
 971 static int ice_devlink_rate_node_new(struct devlink_rate *rate_node, void **priv,
 972                                      struct netlink_ext_ack *extack)
 973 {
 974         struct ice_sched_node *node;
 975         struct ice_port_info *pi;
 976
 977         pi = ice_get_pi_from_dev_rate(rate_node);
 978
 979         if (!ice_enable_custom_tx(devlink_priv(rate_node->devlink)))
 980                 return -EBUSY;
 981
 982         /* preallocate memory for ice_sched_node */
 983         node = devm_kzalloc(ice_hw_to_dev(pi->hw), sizeof(*node), GFP_KERNEL);
 984         if (!node)
 985                 return -ENOMEM;
 986
 987         *priv = node;
 988
 989         return 0;
 990 }
 991
 992 static int ice_devlink_rate_node_del(struct devlink_rate *rate_node, void *priv,
 993                                      struct netlink_ext_ack *extack)
 994 {
 995         struct ice_sched_node *node, *tc_node;
 996         struct ice_port_info *pi;
 997
 998         pi = ice_get_pi_from_dev_rate(rate_node);
 999         tc_node = pi->root->children[0];
1000         node = priv;
1001
1002         if (!rate_node->parent || !node || tc_node == node || !extack)
1003                 return 0;
1004
1005         if (!ice_enable_custom_tx(devlink_priv(rate_node->devlink)))
1006                 return -EBUSY;
1007
1008         /* can't allow to delete a node with children */
1009         if (node->num_children)
1010                 return -EINVAL;
1011
1012         mutex_lock(&pi->sched_lock);
1013         ice_free_sched_node(pi, node);
1014         mutex_unlock(&pi->sched_lock);
1015
1016         return 0;
1017 }
1018
1019 static int ice_devlink_rate_leaf_tx_max_set(struct devlink_rate *rate_leaf, void *priv,
1020                                             u64 tx_max, struct netlink_ext_ack *extack)
1021 {
1022         struct ice_sched_node *node = priv;
1023
1024         if (!ice_enable_custom_tx(devlink_priv(rate_leaf->devlink)))
1025                 return -EBUSY;
1026
1027         if (!node)
1028                 return 0;
1029
1030         return ice_set_object_tx_max(ice_get_pi_from_dev_rate(rate_leaf),
1031                                      node, tx_max, extack);
1032 }
1033
1034 static int ice_devlink_rate_leaf_tx_share_set(struct devlink_rate *rate_leaf, void *priv,
1035                                               u64 tx_share, struct netlink_ext_ack *extack)
1036 {
1037         struct ice_sched_node *node = priv;
1038
1039         if (!ice_enable_custom_tx(devlink_priv(rate_leaf->devlink)))
1040                 return -EBUSY;
1041
1042         if (!node)
1043                 return 0;
1044
1045         return ice_set_object_tx_share(ice_get_pi_from_dev_rate(rate_leaf), node,
1046                                        tx_share, extack);
1047 }
1048
1049 static int ice_devlink_rate_leaf_tx_priority_set(struct devlink_rate *rate_leaf, void *priv,
1050                                                  u32 tx_priority, struct netlink_ext_ack *extack)
1051 {
1052         struct ice_sched_node *node = priv;
1053
1054         if (!ice_enable_custom_tx(devlink_priv(rate_leaf->devlink)))
1055                 return -EBUSY;
1056
1057         if (!node)
1058                 return 0;
1059
1060         return ice_set_object_tx_priority(ice_get_pi_from_dev_rate(rate_leaf), node,
1061                                           tx_priority, extack);
1062 }
1063
1064 static int ice_devlink_rate_leaf_tx_weight_set(struct devlink_rate *rate_leaf, void *priv,
1065                                                u32 tx_weight, struct netlink_ext_ack *extack)
1066 {
1067         struct ice_sched_node *node = priv;
1068
1069         if (!ice_enable_custom_tx(devlink_priv(rate_leaf->devlink)))
1070                 return -EBUSY;
1071
1072         if (!node)
1073                 return 0;
1074
1075         return ice_set_object_tx_weight(ice_get_pi_from_dev_rate(rate_leaf), node,
1076                                         tx_weight, extack);
1077 }
1078
1079 static int ice_devlink_rate_node_tx_max_set(struct devlink_rate *rate_node, void *priv,
1080                                             u64 tx_max, struct netlink_ext_ack *extack)
1081 {
1082         struct ice_sched_node *node = priv;
1083
1084         if (!ice_enable_custom_tx(devlink_priv(rate_node->devlink)))
1085                 return -EBUSY;
1086
1087         if (!node)
1088                 return 0;
1089
1090         return ice_set_object_tx_max(ice_get_pi_from_dev_rate(rate_node),
1091                                      node, tx_max, extack);
1092 }
1093
1094 static int ice_devlink_rate_node_tx_share_set(struct devlink_rate *rate_node, void *priv,
1095                                               u64 tx_share, struct netlink_ext_ack *extack)
1096 {
1097         struct ice_sched_node *node = priv;
1098
1099         if (!ice_enable_custom_tx(devlink_priv(rate_node->devlink)))
1100                 return -EBUSY;
1101
1102         if (!node)
1103                 return 0;
1104
1105         return ice_set_object_tx_share(ice_get_pi_from_dev_rate(rate_node),
1106                                        node, tx_share, extack);
1107 }
1108
1109 static int ice_devlink_rate_node_tx_priority_set(struct devlink_rate *rate_node, void *priv,
1110                                                  u32 tx_priority, struct netlink_ext_ack *extack)
1111 {
1112         struct ice_sched_node *node = priv;
1113
1114         if (!ice_enable_custom_tx(devlink_priv(rate_node->devlink)))
1115                 return -EBUSY;
1116
1117         if (!node)
1118                 return 0;
1119
1120         return ice_set_object_tx_priority(ice_get_pi_from_dev_rate(rate_node),
1121                                           node, tx_priority, extack);
1122 }
1123
1124 static int ice_devlink_rate_node_tx_weight_set(struct devlink_rate *rate_node, void *priv,
1125                                                u32 tx_weight, struct netlink_ext_ack *extack)
1126 {
1127         struct ice_sched_node *node = priv;
1128
1129         if (!ice_enable_custom_tx(devlink_priv(rate_node->devlink)))
1130                 return -EBUSY;
1131
1132         if (!node)
1133                 return 0;
1134
1135         return ice_set_object_tx_weight(ice_get_pi_from_dev_rate(rate_node),
1136                                         node, tx_weight, extack);
1137 }
1138
1139 static int ice_devlink_set_parent(struct devlink_rate *devlink_rate,
1140                                   struct devlink_rate *parent,
1141                                   void *priv, void *parent_priv,
1142                                   struct netlink_ext_ack *extack)
1143 {
1144         struct ice_port_info *pi = ice_get_pi_from_dev_rate(devlink_rate);
1145         struct ice_sched_node *tc_node, *node, *parent_node;
1146         u16 num_nodes_added;
1147         u32 first_node_teid;
1148         u32 node_teid;
1149         int status;
1150
1151         tc_node = pi->root->children[0];
1152         node = priv;
1153
1154         if (!extack)
1155                 return 0;
1156
1157         if (!ice_enable_custom_tx(devlink_priv(devlink_rate->devlink)))
1158                 return -EBUSY;
1159
1160         if (!parent) {
1161                 if (!node || tc_node == node || node->num_children)
1162                         return -EINVAL;
1163
1164                 mutex_lock(&pi->sched_lock);
1165                 ice_free_sched_node(pi, node);
1166                 mutex_unlock(&pi->sched_lock);
1167
1168                 return 0;
1169         }
1170
1171         parent_node = parent_priv;
1172
1173         /* if the node doesn't exist, create it */
1174         if (!node->parent) {
1175                 mutex_lock(&pi->sched_lock);
1176                 status = ice_sched_add_elems(pi, tc_node, parent_node,
1177                                              parent_node->tx_sched_layer + 1,
1178                                              1, &num_nodes_added, &first_node_teid,
1179                                              &node);
1180                 mutex_unlock(&pi->sched_lock);
1181
1182                 if (status) {
1183                         NL_SET_ERR_MSG_MOD(extack, "Can't add a new node");
1184                         return status;
1185                 }
1186
1187                 if (devlink_rate->tx_share)
1188                         ice_set_object_tx_share(pi, node, devlink_rate->tx_share, extack);
1189                 if (devlink_rate->tx_max)
1190                         ice_set_object_tx_max(pi, node, devlink_rate->tx_max, extack);
1191                 if (devlink_rate->tx_priority)
1192                         ice_set_object_tx_priority(pi, node, devlink_rate->tx_priority, extack);
1193                 if (devlink_rate->tx_weight)
1194                         ice_set_object_tx_weight(pi, node, devlink_rate->tx_weight, extack);
1195         } else {
1196                 node_teid = le32_to_cpu(node->info.node_teid);
1197                 mutex_lock(&pi->sched_lock);
1198                 status = ice_sched_move_nodes(pi, parent_node, 1, &node_teid);
1199                 mutex_unlock(&pi->sched_lock);
1200
1201                 if (status)
1202                         NL_SET_ERR_MSG_MOD(extack, "Can't move existing node to a new parent");
1203         }
1204
1205         return status;
1206 }
1207
1208 /**
1209  * ice_devlink_reinit_up - do reinit of the given PF
1210  * @pf: pointer to the PF struct
1211  */
1212 static int ice_devlink_reinit_up(struct ice_pf *pf)
1213 {
1214         struct ice_vsi *vsi = ice_get_main_vsi(pf);
1215         int err;
1216
1217         err = ice_init_hw(&pf->hw);
1218         if (err) {
1219                 dev_err(ice_pf_to_dev(pf), "ice_init_hw failed: %d\n", err);
1220                 return err;
1221         }
1222
1223         err = ice_init_dev(pf);
1224         if (err)
1225                 goto unroll_hw_init;
1226
1227         vsi->flags = ICE_VSI_FLAG_INIT;
1228
1229         rtnl_lock();
1230         err = ice_vsi_cfg(vsi);
1231         rtnl_unlock();
1232         if (err)
1233                 goto err_vsi_cfg;
1234
1235         /* No need to take devl_lock, it's already taken by devlink API */
1236         err = ice_load(pf);
1237         if (err)
1238                 goto err_load;
1239
1240         return 0;
1241
1242 err_load:
1243         rtnl_lock();
1244         ice_vsi_decfg(vsi);
1245         rtnl_unlock();
1246 err_vsi_cfg:
1247         ice_deinit_dev(pf);
1248 unroll_hw_init:
1249         ice_deinit_hw(&pf->hw);
1250         return err;
1251 }
1252
1253 /**
1254  * ice_devlink_reload_up - do reload up after reinit
1255  * @devlink: pointer to the devlink instance reloading
1256  * @action: the action requested
1257  * @limit: limits imposed by userspace, such as not resetting
1258  * @actions_performed: on return, indicate what actions actually performed
1259  * @extack: netlink extended ACK structure
1260  */
1261 static int
1262 ice_devlink_reload_up(struct devlink *devlink,
1263                       enum devlink_reload_action action,
1264                       enum devlink_reload_limit limit,
1265                       u32 *actions_performed,
1266                       struct netlink_ext_ack *extack)
1267 {
1268         struct ice_pf *pf = devlink_priv(devlink);
1269
1270         switch (action) {
1271         case DEVLINK_RELOAD_ACTION_DRIVER_REINIT:
1272                 *actions_performed = BIT(DEVLINK_RELOAD_ACTION_DRIVER_REINIT);
1273                 return ice_devlink_reinit_up(pf);
1274         case DEVLINK_RELOAD_ACTION_FW_ACTIVATE:
1275                 *actions_performed = BIT(DEVLINK_RELOAD_ACTION_FW_ACTIVATE);
1276                 return ice_devlink_reload_empr_finish(pf, extack);
1277         default:
1278                 WARN_ON(1);
1279                 return -EOPNOTSUPP;
1280         }
1281 }
1282
1283 static const struct devlink_ops ice_devlink_ops = {
1284         .supported_flash_update_params = DEVLINK_SUPPORT_FLASH_UPDATE_OVERWRITE_MASK,
1285         .reload_actions = BIT(DEVLINK_RELOAD_ACTION_DRIVER_REINIT) |
1286                           BIT(DEVLINK_RELOAD_ACTION_FW_ACTIVATE),
1287         .reload_down = ice_devlink_reload_down,
1288         .reload_up = ice_devlink_reload_up,
1289         .eswitch_mode_get = ice_eswitch_mode_get,
1290         .eswitch_mode_set = ice_eswitch_mode_set,
1291         .info_get = ice_devlink_info_get,
1292         .flash_update = ice_devlink_flash_update,
1293
1294         .rate_node_new = ice_devlink_rate_node_new,
1295         .rate_node_del = ice_devlink_rate_node_del,
1296
1297         .rate_leaf_tx_max_set = ice_devlink_rate_leaf_tx_max_set,
1298         .rate_leaf_tx_share_set = ice_devlink_rate_leaf_tx_share_set,
1299         .rate_leaf_tx_priority_set = ice_devlink_rate_leaf_tx_priority_set,
1300         .rate_leaf_tx_weight_set = ice_devlink_rate_leaf_tx_weight_set,
1301
1302         .rate_node_tx_max_set = ice_devlink_rate_node_tx_max_set,
1303         .rate_node_tx_share_set = ice_devlink_rate_node_tx_share_set,
1304         .rate_node_tx_priority_set = ice_devlink_rate_node_tx_priority_set,
1305         .rate_node_tx_weight_set = ice_devlink_rate_node_tx_weight_set,
1306
1307         .rate_leaf_parent_set = ice_devlink_set_parent,
1308         .rate_node_parent_set = ice_devlink_set_parent,
1309
1310         .port_new = ice_devlink_port_new,
1311 };
1312
1313 static const struct devlink_ops ice_sf_devlink_ops;
1314
1315 static int
1316 ice_devlink_enable_roce_get(struct devlink *devlink, u32 id,
1317                             struct devlink_param_gset_ctx *ctx)
1318 {
1319         struct ice_pf *pf = devlink_priv(devlink);
1320
1321         ctx->val.vbool = pf->rdma_mode & IIDC_RDMA_PROTOCOL_ROCEV2 ? true : false;
1322
1323         return 0;
1324 }
1325
1326 static int ice_devlink_enable_roce_set(struct devlink *devlink, u32 id,
1327                                        struct devlink_param_gset_ctx *ctx,
1328                                        struct netlink_ext_ack *extack)
1329 {
1330         struct ice_pf *pf = devlink_priv(devlink);
1331         bool roce_ena = ctx->val.vbool;
1332         int ret;
1333
1334         if (!roce_ena) {
1335                 ice_unplug_aux_dev(pf);
1336                 pf->rdma_mode &= ~IIDC_RDMA_PROTOCOL_ROCEV2;
1337                 return 0;
1338         }
1339
1340         pf->rdma_mode |= IIDC_RDMA_PROTOCOL_ROCEV2;
1341         ret = ice_plug_aux_dev(pf);
1342         if (ret)
1343                 pf->rdma_mode &= ~IIDC_RDMA_PROTOCOL_ROCEV2;
1344
1345         return ret;
1346 }
1347
1348 static int
1349 ice_devlink_enable_roce_validate(struct devlink *devlink, u32 id,
1350                                  union devlink_param_value val,
1351                                  struct netlink_ext_ack *extack)
1352 {
1353         struct ice_pf *pf = devlink_priv(devlink);
1354
1355         if (!test_bit(ICE_FLAG_RDMA_ENA, pf->flags))
1356                 return -EOPNOTSUPP;
1357
1358         if (pf->rdma_mode & IIDC_RDMA_PROTOCOL_IWARP) {
1359                 NL_SET_ERR_MSG_MOD(extack, "iWARP is currently enabled. This device cannot enable iWARP and RoCEv2 simultaneously");
1360                 return -EOPNOTSUPP;
1361         }
1362
1363         return 0;
1364 }
1365
1366 static int
1367 ice_devlink_enable_iw_get(struct devlink *devlink, u32 id,
1368                           struct devlink_param_gset_ctx *ctx)
1369 {
1370         struct ice_pf *pf = devlink_priv(devlink);
1371
1372         ctx->val.vbool = pf->rdma_mode & IIDC_RDMA_PROTOCOL_IWARP;
1373
1374         return 0;
1375 }
1376
1377 static int ice_devlink_enable_iw_set(struct devlink *devlink, u32 id,
1378                                      struct devlink_param_gset_ctx *ctx,
1379                                      struct netlink_ext_ack *extack)
1380 {
1381         struct ice_pf *pf = devlink_priv(devlink);
1382         bool iw_ena = ctx->val.vbool;
1383         int ret;
1384
1385         if (!iw_ena) {
1386                 ice_unplug_aux_dev(pf);
1387                 pf->rdma_mode &= ~IIDC_RDMA_PROTOCOL_IWARP;
1388                 return 0;
1389         }
1390
1391         pf->rdma_mode |= IIDC_RDMA_PROTOCOL_IWARP;
1392         ret = ice_plug_aux_dev(pf);
1393         if (ret)
1394                 pf->rdma_mode &= ~IIDC_RDMA_PROTOCOL_IWARP;
1395
1396         return ret;
1397 }
1398
1399 static int
1400 ice_devlink_enable_iw_validate(struct devlink *devlink, u32 id,
1401                                union devlink_param_value val,
1402                                struct netlink_ext_ack *extack)
1403 {
1404         struct ice_pf *pf = devlink_priv(devlink);
1405
1406         if (!test_bit(ICE_FLAG_RDMA_ENA, pf->flags))
1407                 return -EOPNOTSUPP;
1408
1409         if (pf->rdma_mode & IIDC_RDMA_PROTOCOL_ROCEV2) {
1410                 NL_SET_ERR_MSG_MOD(extack, "RoCEv2 is currently enabled. This device cannot enable iWARP and RoCEv2 simultaneously");
1411                 return -EOPNOTSUPP;
1412         }
1413
1414         return 0;
1415 }
1416
1417 #define DEVLINK_LOCAL_FWD_DISABLED_STR "disabled"
1418 #define DEVLINK_LOCAL_FWD_ENABLED_STR "enabled"
1419 #define DEVLINK_LOCAL_FWD_PRIORITIZED_STR "prioritized"
1420
1421 /**
1422  * ice_devlink_local_fwd_mode_to_str - Get string for local_fwd mode.
1423  * @mode: local forwarding for mode used in port_info struct.
1424  *
1425  * Return: Mode respective string or "Invalid".
1426  */
1427 static const char *
1428 ice_devlink_local_fwd_mode_to_str(enum ice_local_fwd_mode mode)
1429 {
1430         switch (mode) {
1431         case ICE_LOCAL_FWD_MODE_ENABLED:
1432                 return DEVLINK_LOCAL_FWD_ENABLED_STR;
1433         case ICE_LOCAL_FWD_MODE_PRIORITIZED:
1434                 return DEVLINK_LOCAL_FWD_PRIORITIZED_STR;
1435         case ICE_LOCAL_FWD_MODE_DISABLED:
1436                 return DEVLINK_LOCAL_FWD_DISABLED_STR;
1437         }
1438
1439         return "Invalid";
1440 }
1441
1442 /**
1443  * ice_devlink_local_fwd_str_to_mode - Get local_fwd mode from string name.
1444  * @mode_str: local forwarding mode string.
1445  *
1446  * Return: Mode value or negative number if invalid.
1447  */
1448 static int ice_devlink_local_fwd_str_to_mode(const char *mode_str)
1449 {
1450         if (!strcmp(mode_str, DEVLINK_LOCAL_FWD_ENABLED_STR))
1451                 return ICE_LOCAL_FWD_MODE_ENABLED;
1452         else if (!strcmp(mode_str, DEVLINK_LOCAL_FWD_PRIORITIZED_STR))
1453                 return ICE_LOCAL_FWD_MODE_PRIORITIZED;
1454         else if (!strcmp(mode_str, DEVLINK_LOCAL_FWD_DISABLED_STR))
1455                 return ICE_LOCAL_FWD_MODE_DISABLED;
1456
1457         return -EINVAL;
1458 }
1459
1460 /**
1461  * ice_devlink_local_fwd_get - Get local_fwd parameter.
1462  * @devlink: Pointer to the devlink instance.
1463  * @id: The parameter ID to set.
1464  * @ctx: Context to store the parameter value.
1465  *
1466  * Return: Zero.
1467  */
1468 static int ice_devlink_local_fwd_get(struct devlink *devlink, u32 id,
1469                                      struct devlink_param_gset_ctx *ctx)
1470 {
1471         struct ice_pf *pf = devlink_priv(devlink);
1472         struct ice_port_info *pi;
1473         const char *mode_str;
1474
1475         pi = pf->hw.port_info;
1476         mode_str = ice_devlink_local_fwd_mode_to_str(pi->local_fwd_mode);
1477         snprintf(ctx->val.vstr, sizeof(ctx->val.vstr), "%s", mode_str);
1478
1479         return 0;
1480 }
1481
1482 /**
1483  * ice_devlink_local_fwd_set - Set local_fwd parameter.
1484  * @devlink: Pointer to the devlink instance.
1485  * @id: The parameter ID to set.
1486  * @ctx: Context to get the parameter value.
1487  * @extack: Netlink extended ACK structure.
1488  *
1489  * Return: Zero.
1490  */
1491 static int ice_devlink_local_fwd_set(struct devlink *devlink, u32 id,
1492                                      struct devlink_param_gset_ctx *ctx,
1493                                      struct netlink_ext_ack *extack)
1494 {
1495         int new_local_fwd_mode = ice_devlink_local_fwd_str_to_mode(ctx->val.vstr);
1496         struct ice_pf *pf = devlink_priv(devlink);
1497         struct device *dev = ice_pf_to_dev(pf);
1498         struct ice_port_info *pi;
1499
1500         pi = pf->hw.port_info;
1501         if (pi->local_fwd_mode != new_local_fwd_mode) {
1502                 pi->local_fwd_mode = new_local_fwd_mode;
1503                 dev_info(dev, "Setting local_fwd to %s\n", ctx->val.vstr);
1504                 ice_schedule_reset(pf, ICE_RESET_CORER);
1505         }
1506
1507         return 0;
1508 }
1509
1510 /**
1511  * ice_devlink_local_fwd_validate - Validate passed local_fwd parameter value.
1512  * @devlink: Unused pointer to devlink instance.
1513  * @id: The parameter ID to validate.
1514  * @val: Value to validate.
1515  * @extack: Netlink extended ACK structure.
1516  *
1517  * Supported values are:
1518  * "enabled" - local_fwd is enabled, "disabled" - local_fwd is disabled
1519  * "prioritized" - local_fwd traffic is prioritized in scheduling.
1520  *
1521  * Return: Zero when passed parameter value is supported. Negative value on
1522  * error.
1523  */
1524 static int ice_devlink_local_fwd_validate(struct devlink *devlink, u32 id,
1525                                           union devlink_param_value val,
1526                                           struct netlink_ext_ack *extack)
1527 {
1528         if (ice_devlink_local_fwd_str_to_mode(val.vstr) < 0) {
1529                 NL_SET_ERR_MSG_MOD(extack, "Error: Requested value is not supported.");
1530                 return -EINVAL;
1531         }
1532
1533         return 0;
1534 }
1535
1536 enum ice_param_id {
1537         ICE_DEVLINK_PARAM_ID_BASE = DEVLINK_PARAM_GENERIC_ID_MAX,
1538         ICE_DEVLINK_PARAM_ID_TX_SCHED_LAYERS,
1539         ICE_DEVLINK_PARAM_ID_LOCAL_FWD,
1540 };
1541
1542 static const struct devlink_param ice_dvl_rdma_params[] = {
1543         DEVLINK_PARAM_GENERIC(ENABLE_ROCE, BIT(DEVLINK_PARAM_CMODE_RUNTIME),
1544                               ice_devlink_enable_roce_get,
1545                               ice_devlink_enable_roce_set,
1546                               ice_devlink_enable_roce_validate),
1547         DEVLINK_PARAM_GENERIC(ENABLE_IWARP, BIT(DEVLINK_PARAM_CMODE_RUNTIME),
1548                               ice_devlink_enable_iw_get,
1549                               ice_devlink_enable_iw_set,
1550                               ice_devlink_enable_iw_validate),
1551 };
1552
1553 static const struct devlink_param ice_dvl_sched_params[] = {
1554         DEVLINK_PARAM_DRIVER(ICE_DEVLINK_PARAM_ID_TX_SCHED_LAYERS,
1555                              "tx_scheduling_layers",
1556                              DEVLINK_PARAM_TYPE_U8,
1557                              BIT(DEVLINK_PARAM_CMODE_PERMANENT),
1558                              ice_devlink_tx_sched_layers_get,
1559                              ice_devlink_tx_sched_layers_set,
1560                              ice_devlink_tx_sched_layers_validate),
1561         DEVLINK_PARAM_DRIVER(ICE_DEVLINK_PARAM_ID_LOCAL_FWD,
1562                              "local_forwarding", DEVLINK_PARAM_TYPE_STRING,
1563                              BIT(DEVLINK_PARAM_CMODE_RUNTIME),
1564                              ice_devlink_local_fwd_get,
1565                              ice_devlink_local_fwd_set,
1566                              ice_devlink_local_fwd_validate),
1567 };
1568
1569 static void ice_devlink_free(void *devlink_ptr)
1570 {
1571         devlink_free((struct devlink *)devlink_ptr);
1572 }
1573
1574 /**
1575  * ice_allocate_pf - Allocate devlink and return PF structure pointer
1576  * @dev: the device to allocate for
1577  *
1578  * Allocate a devlink instance for this device and return the private area as
1579  * the PF structure. The devlink memory is kept track of through devres by
1580  * adding an action to remove it when unwinding.
1581  */
1582 struct ice_pf *ice_allocate_pf(struct device *dev)
1583 {
1584         struct devlink *devlink;
1585
1586         devlink = devlink_alloc(&ice_devlink_ops, sizeof(struct ice_pf), dev);
1587         if (!devlink)
1588                 return NULL;
1589
1590         /* Add an action to teardown the devlink when unwinding the driver */
1591         if (devm_add_action_or_reset(dev, ice_devlink_free, devlink))
1592                 return NULL;
1593
1594         return devlink_priv(devlink);
1595 }
1596
1597 /**
1598  * ice_allocate_sf - Allocate devlink and return SF structure pointer
1599  * @dev: the device to allocate for
1600  * @pf: pointer to the PF structure
1601  *
1602  * Allocate a devlink instance for SF.
1603  *
1604  * Return: ice_sf_priv pointer to allocated memory or ERR_PTR in case of error
1605  */
1606 struct ice_sf_priv *ice_allocate_sf(struct device *dev, struct ice_pf *pf)
1607 {
1608         struct devlink *devlink;
1609         int err;
1610
1611         devlink = devlink_alloc(&ice_sf_devlink_ops, sizeof(struct ice_sf_priv),
1612                                 dev);
1613         if (!devlink)
1614                 return ERR_PTR(-ENOMEM);
1615
1616         err = devl_nested_devlink_set(priv_to_devlink(pf), devlink);
1617         if (err) {
1618                 devlink_free(devlink);
1619                 return ERR_PTR(err);
1620         }
1621
1622         return devlink_priv(devlink);
1623 }
1624
1625 /**
1626  * ice_devlink_register - Register devlink interface for this PF
1627  * @pf: the PF to register the devlink for.
1628  *
1629  * Register the devlink instance associated with this physical function.
1630  *
1631  * Return: zero on success or an error code on failure.
1632  */
1633 void ice_devlink_register(struct ice_pf *pf)
1634 {
1635         struct devlink *devlink = priv_to_devlink(pf);
1636
1637         devl_register(devlink);
1638 }
1639
1640 /**
1641  * ice_devlink_unregister - Unregister devlink resources for this PF.
1642  * @pf: the PF structure to cleanup
1643  *
1644  * Releases resources used by devlink and cleans up associated memory.
1645  */
1646 void ice_devlink_unregister(struct ice_pf *pf)
1647 {
1648         devl_unregister(priv_to_devlink(pf));
1649 }
1650
1651 int ice_devlink_register_params(struct ice_pf *pf)
1652 {
1653         struct devlink *devlink = priv_to_devlink(pf);
1654         struct ice_hw *hw = &pf->hw;
1655         int status;
1656
1657         status = devl_params_register(devlink, ice_dvl_rdma_params,
1658                                       ARRAY_SIZE(ice_dvl_rdma_params));
1659         if (status)
1660                 return status;
1661
1662         if (hw->func_caps.common_cap.tx_sched_topo_comp_mode_en)
1663                 status = devl_params_register(devlink, ice_dvl_sched_params,
1664                                               ARRAY_SIZE(ice_dvl_sched_params));
1665
1666         return status;
1667 }
1668
1669 void ice_devlink_unregister_params(struct ice_pf *pf)
1670 {
1671         struct devlink *devlink = priv_to_devlink(pf);
1672         struct ice_hw *hw = &pf->hw;
1673
1674         devl_params_unregister(devlink, ice_dvl_rdma_params,
1675                                ARRAY_SIZE(ice_dvl_rdma_params));
1676
1677         if (hw->func_caps.common_cap.tx_sched_topo_comp_mode_en)
1678                 devl_params_unregister(devlink, ice_dvl_sched_params,
1679                                        ARRAY_SIZE(ice_dvl_sched_params));
1680 }
1681
1682 #define ICE_DEVLINK_READ_BLK_SIZE (1024 * 1024)
1683
1684 static const struct devlink_region_ops ice_nvm_region_ops;
1685 static const struct devlink_region_ops ice_sram_region_ops;
1686
1687 /**
1688  * ice_devlink_nvm_snapshot - Capture a snapshot of the NVM flash contents
1689  * @devlink: the devlink instance
1690  * @ops: the devlink region to snapshot
1691  * @extack: extended ACK response structure
1692  * @data: on exit points to snapshot data buffer
1693  *
1694  * This function is called in response to a DEVLINK_CMD_REGION_NEW for either
1695  * the nvm-flash or shadow-ram region.
1696  *
1697  * It captures a snapshot of the NVM or Shadow RAM flash contents. This
1698  * snapshot can then later be viewed via the DEVLINK_CMD_REGION_READ netlink
1699  * interface.
1700  *
1701  * @returns zero on success, and updates the data pointer. Returns a non-zero
1702  * error code on failure.
1703  */
1704 static int ice_devlink_nvm_snapshot(struct devlink *devlink,
1705                                     const struct devlink_region_ops *ops,
1706                                     struct netlink_ext_ack *extack, u8 **data)
1707 {
1708         struct ice_pf *pf = devlink_priv(devlink);
1709         struct device *dev = ice_pf_to_dev(pf);
1710         struct ice_hw *hw = &pf->hw;
1711         bool read_shadow_ram;
1712         u8 *nvm_data, *tmp, i;
1713         u32 nvm_size, left;
1714         s8 num_blks;
1715         int status;
1716
1717         if (ops == &ice_nvm_region_ops) {
1718                 read_shadow_ram = false;
1719                 nvm_size = hw->flash.flash_size;
1720         } else if (ops == &ice_sram_region_ops) {
1721                 read_shadow_ram = true;
1722                 nvm_size = hw->flash.sr_words * 2u;
1723         } else {
1724                 NL_SET_ERR_MSG_MOD(extack, "Unexpected region in snapshot function");
1725                 return -EOPNOTSUPP;
1726         }
1727
1728         nvm_data = vzalloc(nvm_size);
1729         if (!nvm_data)
1730                 return -ENOMEM;
1731
1732         num_blks = DIV_ROUND_UP(nvm_size, ICE_DEVLINK_READ_BLK_SIZE);
1733         tmp = nvm_data;
1734         left = nvm_size;
1735
1736         /* Some systems take longer to read the NVM than others which causes the
1737          * FW to reclaim the NVM lock before the entire NVM has been read. Fix
1738          * this by breaking the reads of the NVM into smaller chunks that will
1739          * probably not take as long. This has some overhead since we are
1740          * increasing the number of AQ commands, but it should always work
1741          */
1742         for (i = 0; i < num_blks; i++) {
1743                 u32 read_sz = min_t(u32, ICE_DEVLINK_READ_BLK_SIZE, left);
1744
1745                 status = ice_acquire_nvm(hw, ICE_RES_READ);
1746                 if (status) {
1747                         dev_dbg(dev, "ice_acquire_nvm failed, err %d aq_err %d\n",
1748                                 status, hw->adminq.sq_last_status);
1749                         NL_SET_ERR_MSG_MOD(extack, "Failed to acquire NVM semaphore");
1750                         vfree(nvm_data);
1751                         return -EIO;
1752                 }
1753
1754                 status = ice_read_flat_nvm(hw, i * ICE_DEVLINK_READ_BLK_SIZE,
1755                                            &read_sz, tmp, read_shadow_ram);
1756                 if (status) {
1757                         dev_dbg(dev, "ice_read_flat_nvm failed after reading %u bytes, err %d aq_err %d\n",
1758                                 read_sz, status, hw->adminq.sq_last_status);
1759                         NL_SET_ERR_MSG_MOD(extack, "Failed to read NVM contents");
1760                         ice_release_nvm(hw);
1761                         vfree(nvm_data);
1762                         return -EIO;
1763                 }
1764                 ice_release_nvm(hw);
1765
1766                 tmp += read_sz;
1767                 left -= read_sz;
1768         }
1769
1770         *data = nvm_data;
1771
1772         return 0;
1773 }
1774
1775 /**
1776  * ice_devlink_nvm_read - Read a portion of NVM flash contents
1777  * @devlink: the devlink instance
1778  * @ops: the devlink region to snapshot
1779  * @extack: extended ACK response structure
1780  * @offset: the offset to start at
1781  * @size: the amount to read
1782  * @data: the data buffer to read into
1783  *
1784  * This function is called in response to DEVLINK_CMD_REGION_READ to directly
1785  * read a section of the NVM contents.
1786  *
1787  * It reads from either the nvm-flash or shadow-ram region contents.
1788  *
1789  * @returns zero on success, and updates the data pointer. Returns a non-zero
1790  * error code on failure.
1791  */
1792 static int ice_devlink_nvm_read(struct devlink *devlink,
1793                                 const struct devlink_region_ops *ops,
1794                                 struct netlink_ext_ack *extack,
1795                                 u64 offset, u32 size, u8 *data)
1796 {
1797         struct ice_pf *pf = devlink_priv(devlink);
1798         struct device *dev = ice_pf_to_dev(pf);
1799         struct ice_hw *hw = &pf->hw;
1800         bool read_shadow_ram;
1801         u64 nvm_size;
1802         int status;
1803
1804         if (ops == &ice_nvm_region_ops) {
1805                 read_shadow_ram = false;
1806                 nvm_size = hw->flash.flash_size;
1807         } else if (ops == &ice_sram_region_ops) {
1808                 read_shadow_ram = true;
1809                 nvm_size = hw->flash.sr_words * 2u;
1810         } else {
1811                 NL_SET_ERR_MSG_MOD(extack, "Unexpected region in snapshot function");
1812                 return -EOPNOTSUPP;
1813         }
1814
1815         if (offset + size >= nvm_size) {
1816                 NL_SET_ERR_MSG_MOD(extack, "Cannot read beyond the region size");
1817                 return -ERANGE;
1818         }
1819
1820         status = ice_acquire_nvm(hw, ICE_RES_READ);
1821         if (status) {
1822                 dev_dbg(dev, "ice_acquire_nvm failed, err %d aq_err %d\n",
1823                         status, hw->adminq.sq_last_status);
1824                 NL_SET_ERR_MSG_MOD(extack, "Failed to acquire NVM semaphore");
1825                 return -EIO;
1826         }
1827
1828         status = ice_read_flat_nvm(hw, (u32)offset, &size, data,
1829                                    read_shadow_ram);
1830         if (status) {
1831                 dev_dbg(dev, "ice_read_flat_nvm failed after reading %u bytes, err %d aq_err %d\n",
1832                         size, status, hw->adminq.sq_last_status);
1833                 NL_SET_ERR_MSG_MOD(extack, "Failed to read NVM contents");
1834                 ice_release_nvm(hw);
1835                 return -EIO;
1836         }
1837         ice_release_nvm(hw);
1838
1839         return 0;
1840 }
1841
1842 /**
1843  * ice_devlink_devcaps_snapshot - Capture snapshot of device capabilities
1844  * @devlink: the devlink instance
1845  * @ops: the devlink region being snapshotted
1846  * @extack: extended ACK response structure
1847  * @data: on exit points to snapshot data buffer
1848  *
1849  * This function is called in response to the DEVLINK_CMD_REGION_TRIGGER for
1850  * the device-caps devlink region. It captures a snapshot of the device
1851  * capabilities reported by firmware.
1852  *
1853  * @returns zero on success, and updates the data pointer. Returns a non-zero
1854  * error code on failure.
1855  */
1856 static int
1857 ice_devlink_devcaps_snapshot(struct devlink *devlink,
1858                              const struct devlink_region_ops *ops,
1859                              struct netlink_ext_ack *extack, u8 **data)
1860 {
1861         struct ice_pf *pf = devlink_priv(devlink);
1862         struct device *dev = ice_pf_to_dev(pf);
1863         struct ice_hw *hw = &pf->hw;
1864         void *devcaps;
1865         int status;
1866
1867         devcaps = vzalloc(ICE_AQ_MAX_BUF_LEN);
1868         if (!devcaps)
1869                 return -ENOMEM;
1870
1871         status = ice_aq_list_caps(hw, devcaps, ICE_AQ_MAX_BUF_LEN, NULL,
1872                                   ice_aqc_opc_list_dev_caps, NULL);
1873         if (status) {
1874                 dev_dbg(dev, "ice_aq_list_caps: failed to read device capabilities, err %d aq_err %d\n",
1875                         status, hw->adminq.sq_last_status);
1876                 NL_SET_ERR_MSG_MOD(extack, "Failed to read device capabilities");
1877                 vfree(devcaps);
1878                 return status;
1879         }
1880
1881         *data = (u8 *)devcaps;
1882
1883         return 0;
1884 }
1885
1886 static const struct devlink_region_ops ice_nvm_region_ops = {
1887         .name = "nvm-flash",
1888         .destructor = vfree,
1889         .snapshot = ice_devlink_nvm_snapshot,
1890         .read = ice_devlink_nvm_read,
1891 };
1892
1893 static const struct devlink_region_ops ice_sram_region_ops = {
1894         .name = "shadow-ram",
1895         .destructor = vfree,
1896         .snapshot = ice_devlink_nvm_snapshot,
1897         .read = ice_devlink_nvm_read,
1898 };
1899
1900 static const struct devlink_region_ops ice_devcaps_region_ops = {
1901         .name = "device-caps",
1902         .destructor = vfree,
1903         .snapshot = ice_devlink_devcaps_snapshot,
1904 };
1905
1906 /**
1907  * ice_devlink_init_regions - Initialize devlink regions
1908  * @pf: the PF device structure
1909  *
1910  * Create devlink regions used to enable access to dump the contents of the
1911  * flash memory on the device.
1912  */
1913 void ice_devlink_init_regions(struct ice_pf *pf)
1914 {
1915         struct devlink *devlink = priv_to_devlink(pf);
1916         struct device *dev = ice_pf_to_dev(pf);
1917         u64 nvm_size, sram_size;
1918
1919         nvm_size = pf->hw.flash.flash_size;
1920         pf->nvm_region = devl_region_create(devlink, &ice_nvm_region_ops, 1,
1921                                             nvm_size);
1922         if (IS_ERR(pf->nvm_region)) {
1923                 dev_err(dev, "failed to create NVM devlink region, err %ld\n",
1924                         PTR_ERR(pf->nvm_region));
1925                 pf->nvm_region = NULL;
1926         }
1927
1928         sram_size = pf->hw.flash.sr_words * 2u;
1929         pf->sram_region = devl_region_create(devlink, &ice_sram_region_ops,
1930                                              1, sram_size);
1931         if (IS_ERR(pf->sram_region)) {
1932                 dev_err(dev, "failed to create shadow-ram devlink region, err %ld\n",
1933                         PTR_ERR(pf->sram_region));
1934                 pf->sram_region = NULL;
1935         }
1936
1937         pf->devcaps_region = devl_region_create(devlink,
1938                                                 &ice_devcaps_region_ops, 10,
1939                                                 ICE_AQ_MAX_BUF_LEN);
1940         if (IS_ERR(pf->devcaps_region)) {
1941                 dev_err(dev, "failed to create device-caps devlink region, err %ld\n",
1942                         PTR_ERR(pf->devcaps_region));
1943                 pf->devcaps_region = NULL;
1944         }
1945 }
1946
1947 /**
1948  * ice_devlink_destroy_regions - Destroy devlink regions
1949  * @pf: the PF device structure
1950  *
1951  * Remove previously created regions for this PF.
1952  */
1953 void ice_devlink_destroy_regions(struct ice_pf *pf)
1954 {
1955         if (pf->nvm_region)
1956                 devl_region_destroy(pf->nvm_region);
1957
1958         if (pf->sram_region)
1959                 devl_region_destroy(pf->sram_region);
1960
1961         if (pf->devcaps_region)
1962                 devl_region_destroy(pf->devcaps_region);
1963 }