drivers/net/ice/base/ice_common.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2001-2021 Intel Corporation
   3  */
   4
   5 #include "ice_common.h"
   6 #include "ice_sched.h"
   7 #include "ice_adminq_cmd.h"
   8
   9 #include "ice_flow.h"
  10 #include "ice_switch.h"
  11
  12 #define ICE_PF_RESET_WAIT_COUNT 300
  13
  14 /**
  15  * dump_phy_type - helper function that prints PHY type strings
  16  * @hw: pointer to the HW structure
  17  * @phy: 64 bit PHY type to decipher
  18  * @i: bit index within phy
  19  * @phy_string: string corresponding to bit i in phy
  20  * @prefix: prefix string to differentiate multiple dumps
  21  */
  22 static void
  23 dump_phy_type(struct ice_hw *hw, u64 phy, u8 i, const char *phy_string,
  24               const char *prefix)
  25 {
  26         if (phy & BIT_ULL(i))
  27                 ice_debug(hw, ICE_DBG_PHY, "%s: bit(%d): %s\n", prefix, i,
  28                           phy_string);
  29 }
  30
  31 /**
  32  * ice_dump_phy_type_low - helper function to dump phy_type_low
  33  * @hw: pointer to the HW structure
  34  * @low: 64 bit value for phy_type_low
  35  * @prefix: prefix string to differentiate multiple dumps
  36  */
  37 static void
  38 ice_dump_phy_type_low(struct ice_hw *hw, u64 low, const char *prefix)
  39 {
  40         ice_debug(hw, ICE_DBG_PHY, "%s: phy_type_low: 0x%016llx\n", prefix,
  41                   (unsigned long long)low);
  42
  43         dump_phy_type(hw, low, 0, "100BASE_TX", prefix);
  44         dump_phy_type(hw, low, 1, "100M_SGMII", prefix);
  45         dump_phy_type(hw, low, 2, "1000BASE_T", prefix);
  46         dump_phy_type(hw, low, 3, "1000BASE_SX", prefix);
  47         dump_phy_type(hw, low, 4, "1000BASE_LX", prefix);
  48         dump_phy_type(hw, low, 5, "1000BASE_KX", prefix);
  49         dump_phy_type(hw, low, 6, "1G_SGMII", prefix);
  50         dump_phy_type(hw, low, 7, "2500BASE_T", prefix);
  51         dump_phy_type(hw, low, 8, "2500BASE_X", prefix);
  52         dump_phy_type(hw, low, 9, "2500BASE_KX", prefix);
  53         dump_phy_type(hw, low, 10, "5GBASE_T", prefix);
  54         dump_phy_type(hw, low, 11, "5GBASE_KR", prefix);
  55         dump_phy_type(hw, low, 12, "10GBASE_T", prefix);
  56         dump_phy_type(hw, low, 13, "10G_SFI_DA", prefix);
  57         dump_phy_type(hw, low, 14, "10GBASE_SR", prefix);
  58         dump_phy_type(hw, low, 15, "10GBASE_LR", prefix);
  59         dump_phy_type(hw, low, 16, "10GBASE_KR_CR1", prefix);
  60         dump_phy_type(hw, low, 17, "10G_SFI_AOC_ACC", prefix);
  61         dump_phy_type(hw, low, 18, "10G_SFI_C2C", prefix);
  62         dump_phy_type(hw, low, 19, "25GBASE_T", prefix);
  63         dump_phy_type(hw, low, 20, "25GBASE_CR", prefix);
  64         dump_phy_type(hw, low, 21, "25GBASE_CR_S", prefix);
  65         dump_phy_type(hw, low, 22, "25GBASE_CR1", prefix);
  66         dump_phy_type(hw, low, 23, "25GBASE_SR", prefix);
  67         dump_phy_type(hw, low, 24, "25GBASE_LR", prefix);
  68         dump_phy_type(hw, low, 25, "25GBASE_KR", prefix);
  69         dump_phy_type(hw, low, 26, "25GBASE_KR_S", prefix);
  70         dump_phy_type(hw, low, 27, "25GBASE_KR1", prefix);
  71         dump_phy_type(hw, low, 28, "25G_AUI_AOC_ACC", prefix);
  72         dump_phy_type(hw, low, 29, "25G_AUI_C2C", prefix);
  73         dump_phy_type(hw, low, 30, "40GBASE_CR4", prefix);
  74         dump_phy_type(hw, low, 31, "40GBASE_SR4", prefix);
  75         dump_phy_type(hw, low, 32, "40GBASE_LR4", prefix);
  76         dump_phy_type(hw, low, 33, "40GBASE_KR4", prefix);
  77         dump_phy_type(hw, low, 34, "40G_XLAUI_AOC_ACC", prefix);
  78         dump_phy_type(hw, low, 35, "40G_XLAUI", prefix);
  79         dump_phy_type(hw, low, 36, "50GBASE_CR2", prefix);
  80         dump_phy_type(hw, low, 37, "50GBASE_SR2", prefix);
  81         dump_phy_type(hw, low, 38, "50GBASE_LR2", prefix);
  82         dump_phy_type(hw, low, 39, "50GBASE_KR2", prefix);
  83         dump_phy_type(hw, low, 40, "50G_LAUI2_AOC_ACC", prefix);
  84         dump_phy_type(hw, low, 41, "50G_LAUI2", prefix);
  85         dump_phy_type(hw, low, 42, "50G_AUI2_AOC_ACC", prefix);
  86         dump_phy_type(hw, low, 43, "50G_AUI2", prefix);
  87         dump_phy_type(hw, low, 44, "50GBASE_CP", prefix);
  88         dump_phy_type(hw, low, 45, "50GBASE_SR", prefix);
  89         dump_phy_type(hw, low, 46, "50GBASE_FR", prefix);
  90         dump_phy_type(hw, low, 47, "50GBASE_LR", prefix);
  91         dump_phy_type(hw, low, 48, "50GBASE_KR_PAM4", prefix);
  92         dump_phy_type(hw, low, 49, "50G_AUI1_AOC_ACC", prefix);
  93         dump_phy_type(hw, low, 50, "50G_AUI1", prefix);
  94         dump_phy_type(hw, low, 51, "100GBASE_CR4", prefix);
  95         dump_phy_type(hw, low, 52, "100GBASE_SR4", prefix);
  96         dump_phy_type(hw, low, 53, "100GBASE_LR4", prefix);
  97         dump_phy_type(hw, low, 54, "100GBASE_KR4", prefix);
  98         dump_phy_type(hw, low, 55, "100G_CAUI4_AOC_ACC", prefix);
  99         dump_phy_type(hw, low, 56, "100G_CAUI4", prefix);
 100         dump_phy_type(hw, low, 57, "100G_AUI4_AOC_ACC", prefix);
 101         dump_phy_type(hw, low, 58, "100G_AUI4", prefix);
 102         dump_phy_type(hw, low, 59, "100GBASE_CR_PAM4", prefix);
 103         dump_phy_type(hw, low, 60, "100GBASE_KR_PAM4", prefix);
 104         dump_phy_type(hw, low, 61, "100GBASE_CP2", prefix);
 105         dump_phy_type(hw, low, 62, "100GBASE_SR2", prefix);
 106         dump_phy_type(hw, low, 63, "100GBASE_DR", prefix);
 107 }
 108
 109 /**
 110  * ice_dump_phy_type_high - helper function to dump phy_type_high
 111  * @hw: pointer to the HW structure
 112  * @high: 64 bit value for phy_type_high
 113  * @prefix: prefix string to differentiate multiple dumps
 114  */
 115 static void
 116 ice_dump_phy_type_high(struct ice_hw *hw, u64 high, const char *prefix)
 117 {
 118         ice_debug(hw, ICE_DBG_PHY, "%s: phy_type_high: 0x%016llx\n", prefix,
 119                   (unsigned long long)high);
 120
 121         dump_phy_type(hw, high, 0, "100GBASE_KR2_PAM4", prefix);
 122         dump_phy_type(hw, high, 1, "100G_CAUI2_AOC_ACC", prefix);
 123         dump_phy_type(hw, high, 2, "100G_CAUI2", prefix);
 124         dump_phy_type(hw, high, 3, "100G_AUI2_AOC_ACC", prefix);
 125         dump_phy_type(hw, high, 4, "100G_AUI2", prefix);
 126 }
 127
 128 /**
 129  * ice_set_mac_type - Sets MAC type
 130  * @hw: pointer to the HW structure
 131  *
 132  * This function sets the MAC type of the adapter based on the
 133  * vendor ID and device ID stored in the HW structure.
 134  */
 135 static enum ice_status ice_set_mac_type(struct ice_hw *hw)
 136 {
 137         ice_debug(hw, ICE_DBG_TRACE, "%s\n", __func__);
 138
 139         if (hw->vendor_id != ICE_INTEL_VENDOR_ID)
 140                 return ICE_ERR_DEVICE_NOT_SUPPORTED;
 141
 142         switch (hw->device_id) {
 143         case ICE_DEV_ID_E810C_BACKPLANE:
 144         case ICE_DEV_ID_E810C_QSFP:
 145         case ICE_DEV_ID_E810C_SFP:
 146         case ICE_DEV_ID_E810_XXV_BACKPLANE:
 147         case ICE_DEV_ID_E810_XXV_QSFP:
 148         case ICE_DEV_ID_E810_XXV_SFP:
 149                 hw->mac_type = ICE_MAC_E810;
 150                 break;
 151         case ICE_DEV_ID_E822C_10G_BASE_T:
 152         case ICE_DEV_ID_E822C_BACKPLANE:
 153         case ICE_DEV_ID_E822C_QSFP:
 154         case ICE_DEV_ID_E822C_SFP:
 155         case ICE_DEV_ID_E822C_SGMII:
 156         case ICE_DEV_ID_E822L_10G_BASE_T:
 157         case ICE_DEV_ID_E822L_BACKPLANE:
 158         case ICE_DEV_ID_E822L_SFP:
 159         case ICE_DEV_ID_E822L_SGMII:
 160         case ICE_DEV_ID_E823L_10G_BASE_T:
 161         case ICE_DEV_ID_E823L_1GBE:
 162         case ICE_DEV_ID_E823L_BACKPLANE:
 163         case ICE_DEV_ID_E823L_QSFP:
 164         case ICE_DEV_ID_E823L_SFP:
 165         case ICE_DEV_ID_E823C_10G_BASE_T:
 166         case ICE_DEV_ID_E823C_BACKPLANE:
 167         case ICE_DEV_ID_E823C_QSFP:
 168         case ICE_DEV_ID_E823C_SFP:
 169         case ICE_DEV_ID_E823C_SGMII:
 170                 hw->mac_type = ICE_MAC_GENERIC;
 171                 break;
 172         default:
 173                 hw->mac_type = ICE_MAC_UNKNOWN;
 174                 break;
 175         }
 176
 177         ice_debug(hw, ICE_DBG_INIT, "mac_type: %d\n", hw->mac_type);
 178         return ICE_SUCCESS;
 179 }
 180
 181 /**
 182  * ice_is_generic_mac
 183  * @hw: pointer to the hardware structure
 184  *
 185  * returns true if mac_type is ICE_MAC_GENERIC, false if not
 186  */
 187 bool ice_is_generic_mac(struct ice_hw *hw)
 188 {
 189         return hw->mac_type == ICE_MAC_GENERIC;
 190 }
 191
 192 /**
 193  * ice_is_e810
 194  * @hw: pointer to the hardware structure
 195  *
 196  * returns true if the device is E810 based, false if not.
 197  */
 198 bool ice_is_e810(struct ice_hw *hw)
 199 {
 200         return hw->mac_type == ICE_MAC_E810;
 201 }
 202
 203 /**
 204  * ice_clear_pf_cfg - Clear PF configuration
 205  * @hw: pointer to the hardware structure
 206  *
 207  * Clears any existing PF configuration (VSIs, VSI lists, switch rules, port
 208  * configuration, flow director filters, etc.).
 209  */
 210 enum ice_status ice_clear_pf_cfg(struct ice_hw *hw)
 211 {
 212         struct ice_aq_desc desc;
 213
 214         ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_clear_pf_cfg);
 215
 216         return ice_aq_send_cmd(hw, &desc, NULL, 0, NULL);
 217 }
 218
 219 /**
 220  * ice_aq_manage_mac_read - manage MAC address read command
 221  * @hw: pointer to the HW struct
 222  * @buf: a virtual buffer to hold the manage MAC read response
 223  * @buf_size: Size of the virtual buffer
 224  * @cd: pointer to command details structure or NULL
 225  *
 226  * This function is used to return per PF station MAC address (0x0107).
 227  * NOTE: Upon successful completion of this command, MAC address information
 228  * is returned in user specified buffer. Please interpret user specified
 229  * buffer as "manage_mac_read" response.
 230  * Response such as various MAC addresses are stored in HW struct (port.mac)
 231  * ice_discover_dev_caps is expected to be called before this function is
 232  * called.
 233  */
 234 static enum ice_status
 235 ice_aq_manage_mac_read(struct ice_hw *hw, void *buf, u16 buf_size,
 236                        struct ice_sq_cd *cd)
 237 {
 238         struct ice_aqc_manage_mac_read_resp *resp;
 239         struct ice_aqc_manage_mac_read *cmd;
 240         struct ice_aq_desc desc;
 241         enum ice_status status;
 242         u16 flags;
 243         u8 i;
 244
 245         cmd = &desc.params.mac_read;
 246
 247         if (buf_size < sizeof(*resp))
 248                 return ICE_ERR_BUF_TOO_SHORT;
 249
 250         ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_manage_mac_read);
 251
 252         status = ice_aq_send_cmd(hw, &desc, buf, buf_size, cd);
 253         if (status)
 254                 return status;
 255
 256         resp = (struct ice_aqc_manage_mac_read_resp *)buf;
 257         flags = LE16_TO_CPU(cmd->flags) & ICE_AQC_MAN_MAC_READ_M;
 258
 259         if (!(flags & ICE_AQC_MAN_MAC_LAN_ADDR_VALID)) {
 260                 ice_debug(hw, ICE_DBG_LAN, "got invalid MAC address\n");
 261                 return ICE_ERR_CFG;
 262         }
 263
 264         /* A single port can report up to two (LAN and WoL) addresses */
 265         for (i = 0; i < cmd->num_addr; i++)
 266                 if (resp[i].addr_type == ICE_AQC_MAN_MAC_ADDR_TYPE_LAN) {
 267                         ice_memcpy(hw->port_info->mac.lan_addr,
 268                                    resp[i].mac_addr, ETH_ALEN,
 269                                    ICE_DMA_TO_NONDMA);
 270                         ice_memcpy(hw->port_info->mac.perm_addr,
 271                                    resp[i].mac_addr,
 272                                    ETH_ALEN, ICE_DMA_TO_NONDMA);
 273                         break;
 274                 }
 275         return ICE_SUCCESS;
 276 }
 277
 278 /**
 279  * ice_aq_get_phy_caps - returns PHY capabilities
 280  * @pi: port information structure
 281  * @qual_mods: report qualified modules
 282  * @report_mode: report mode capabilities
 283  * @pcaps: structure for PHY capabilities to be filled
 284  * @cd: pointer to command details structure or NULL
 285  *
 286  * Returns the various PHY capabilities supported on the Port (0x0600)
 287  */
 288 enum ice_status
 289 ice_aq_get_phy_caps(struct ice_port_info *pi, bool qual_mods, u8 report_mode,
 290                     struct ice_aqc_get_phy_caps_data *pcaps,
 291                     struct ice_sq_cd *cd)
 292 {
 293         struct ice_aqc_get_phy_caps *cmd;
 294         u16 pcaps_size = sizeof(*pcaps);
 295         struct ice_aq_desc desc;
 296         enum ice_status status;
 297         const char *prefix;
 298         struct ice_hw *hw;
 299
 300         cmd = &desc.params.get_phy;
 301
 302         if (!pcaps || (report_mode & ~ICE_AQC_REPORT_MODE_M) || !pi)
 303                 return ICE_ERR_PARAM;
 304         hw = pi->hw;
 305
 306         if (report_mode == ICE_AQC_REPORT_DFLT_CFG &&
 307             !ice_fw_supports_report_dflt_cfg(hw))
 308                 return ICE_ERR_PARAM;
 309
 310         ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_get_phy_caps);
 311
 312         if (qual_mods)
 313                 cmd->param0 |= CPU_TO_LE16(ICE_AQC_GET_PHY_RQM);
 314
 315         cmd->param0 |= CPU_TO_LE16(report_mode);
 316         status = ice_aq_send_cmd(hw, &desc, pcaps, pcaps_size, cd);
 317
 318         ice_debug(hw, ICE_DBG_LINK, "get phy caps dump\n");
 319
 320         if (report_mode == ICE_AQC_REPORT_TOPO_CAP_MEDIA)
 321                 prefix = "phy_caps_media";
 322         else if (report_mode == ICE_AQC_REPORT_TOPO_CAP_NO_MEDIA)
 323                 prefix = "phy_caps_no_media";
 324         else if (report_mode == ICE_AQC_REPORT_ACTIVE_CFG)
 325                 prefix = "phy_caps_active";
 326         else if (report_mode == ICE_AQC_REPORT_DFLT_CFG)
 327                 prefix = "phy_caps_default";
 328         else
 329                 prefix = "phy_caps_invalid";
 330
 331         ice_dump_phy_type_low(hw, LE64_TO_CPU(pcaps->phy_type_low), prefix);
 332         ice_dump_phy_type_high(hw, LE64_TO_CPU(pcaps->phy_type_high), prefix);
 333
 334         ice_debug(hw, ICE_DBG_LINK, "%s: report_mode = 0x%x\n",
 335                   prefix, report_mode);
 336         ice_debug(hw, ICE_DBG_LINK, "%s: caps = 0x%x\n", prefix, pcaps->caps);
 337         ice_debug(hw, ICE_DBG_LINK, "%s: low_power_ctrl_an = 0x%x\n", prefix,
 338                   pcaps->low_power_ctrl_an);
 339         ice_debug(hw, ICE_DBG_LINK, "%s: eee_cap = 0x%x\n", prefix,
 340                   pcaps->eee_cap);
 341         ice_debug(hw, ICE_DBG_LINK, "%s: eeer_value = 0x%x\n", prefix,
 342                   pcaps->eeer_value);
 343         ice_debug(hw, ICE_DBG_LINK, "%s: link_fec_options = 0x%x\n", prefix,
 344                   pcaps->link_fec_options);
 345         ice_debug(hw, ICE_DBG_LINK, "%s: module_compliance_enforcement = 0x%x\n",
 346                   prefix, pcaps->module_compliance_enforcement);
 347         ice_debug(hw, ICE_DBG_LINK, "%s: extended_compliance_code = 0x%x\n",
 348                   prefix, pcaps->extended_compliance_code);
 349         ice_debug(hw, ICE_DBG_LINK, "%s: module_type[0] = 0x%x\n", prefix,
 350                   pcaps->module_type[0]);
 351         ice_debug(hw, ICE_DBG_LINK, "%s: module_type[1] = 0x%x\n", prefix,
 352                   pcaps->module_type[1]);
 353         ice_debug(hw, ICE_DBG_LINK, "%s: module_type[2] = 0x%x\n", prefix,
 354                   pcaps->module_type[2]);
 355
 356         if (status == ICE_SUCCESS && report_mode == ICE_AQC_REPORT_TOPO_CAP_MEDIA) {
 357                 pi->phy.phy_type_low = LE64_TO_CPU(pcaps->phy_type_low);
 358                 pi->phy.phy_type_high = LE64_TO_CPU(pcaps->phy_type_high);
 359                 ice_memcpy(pi->phy.link_info.module_type, &pcaps->module_type,
 360                            sizeof(pi->phy.link_info.module_type),
 361                            ICE_NONDMA_TO_NONDMA);
 362         }
 363
 364         return status;
 365 }
 366
 367 /**
 368  * ice_aq_get_link_topo_handle - get link topology node return status
 369  * @pi: port information structure
 370  * @node_type: requested node type
 371  * @cd: pointer to command details structure or NULL
 372  *
 373  * Get link topology node return status for specified node type (0x06E0)
 374  *
 375  * Node type cage can be used to determine if cage is present. If AQC
 376  * returns error (ENOENT), then no cage present. If no cage present, then
 377  * connection type is backplane or BASE-T.
 378  */
 379 static enum ice_status
 380 ice_aq_get_link_topo_handle(struct ice_port_info *pi, u8 node_type,
 381                             struct ice_sq_cd *cd)
 382 {
 383         struct ice_aqc_get_link_topo *cmd;
 384         struct ice_aq_desc desc;
 385
 386         cmd = &desc.params.get_link_topo;
 387
 388         ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_get_link_topo);
 389
 390         cmd->addr.topo_params.node_type_ctx =
 391                 (ICE_AQC_LINK_TOPO_NODE_CTX_PORT <<
 392                  ICE_AQC_LINK_TOPO_NODE_CTX_S);
 393
 394         /* set node type */
 395         cmd->addr.topo_params.node_type_ctx |=
 396                 (ICE_AQC_LINK_TOPO_NODE_TYPE_M & node_type);
 397
 398         return ice_aq_send_cmd(pi->hw, &desc, NULL, 0, cd);
 399 }
 400
 401 /**
 402  * ice_is_media_cage_present
 403  * @pi: port information structure
 404  *
 405  * Returns true if media cage is present, else false. If no cage, then
 406  * media type is backplane or BASE-T.
 407  */
 408 static bool ice_is_media_cage_present(struct ice_port_info *pi)
 409 {
 410         /* Node type cage can be used to determine if cage is present. If AQC
 411          * returns error (ENOENT), then no cage present. If no cage present then
 412          * connection type is backplane or BASE-T.
 413          */
 414         return !ice_aq_get_link_topo_handle(pi,
 415                                             ICE_AQC_LINK_TOPO_NODE_TYPE_CAGE,
 416                                             NULL);
 417 }
 418
 419 /**
 420  * ice_get_media_type - Gets media type
 421  * @pi: port information structure
 422  */
 423 static enum ice_media_type ice_get_media_type(struct ice_port_info *pi)
 424 {
 425         struct ice_link_status *hw_link_info;
 426
 427         if (!pi)
 428                 return ICE_MEDIA_UNKNOWN;
 429
 430         hw_link_info = &pi->phy.link_info;
 431         if (hw_link_info->phy_type_low && hw_link_info->phy_type_high)
 432                 /* If more than one media type is selected, report unknown */
 433                 return ICE_MEDIA_UNKNOWN;
 434
 435         if (hw_link_info->phy_type_low) {
 436                 /* 1G SGMII is a special case where some DA cable PHYs
 437                  * may show this as an option when it really shouldn't
 438                  * be since SGMII is meant to be between a MAC and a PHY
 439                  * in a backplane. Try to detect this case and handle it
 440                  */
 441                 if (hw_link_info->phy_type_low == ICE_PHY_TYPE_LOW_1G_SGMII &&
 442                     (hw_link_info->module_type[ICE_AQC_MOD_TYPE_IDENT] ==
 443                     ICE_AQC_MOD_TYPE_BYTE1_SFP_PLUS_CU_ACTIVE ||
 444                     hw_link_info->module_type[ICE_AQC_MOD_TYPE_IDENT] ==
 445                     ICE_AQC_MOD_TYPE_BYTE1_SFP_PLUS_CU_PASSIVE))
 446                         return ICE_MEDIA_DA;
 447
 448                 switch (hw_link_info->phy_type_low) {
 449                 case ICE_PHY_TYPE_LOW_1000BASE_SX:
 450                 case ICE_PHY_TYPE_LOW_1000BASE_LX:
 451                 case ICE_PHY_TYPE_LOW_10GBASE_SR:
 452                 case ICE_PHY_TYPE_LOW_10GBASE_LR:
 453                 case ICE_PHY_TYPE_LOW_10G_SFI_C2C:
 454                 case ICE_PHY_TYPE_LOW_25GBASE_SR:
 455                 case ICE_PHY_TYPE_LOW_25GBASE_LR:
 456                 case ICE_PHY_TYPE_LOW_40GBASE_SR4:
 457                 case ICE_PHY_TYPE_LOW_40GBASE_LR4:
 458                 case ICE_PHY_TYPE_LOW_50GBASE_SR2:
 459                 case ICE_PHY_TYPE_LOW_50GBASE_LR2:
 460                 case ICE_PHY_TYPE_LOW_50GBASE_SR:
 461                 case ICE_PHY_TYPE_LOW_50GBASE_FR:
 462                 case ICE_PHY_TYPE_LOW_50GBASE_LR:
 463                 case ICE_PHY_TYPE_LOW_100GBASE_SR4:
 464                 case ICE_PHY_TYPE_LOW_100GBASE_LR4:
 465                 case ICE_PHY_TYPE_LOW_100GBASE_SR2:
 466                 case ICE_PHY_TYPE_LOW_100GBASE_DR:
 467                         return ICE_MEDIA_FIBER;
 468                 case ICE_PHY_TYPE_LOW_10G_SFI_AOC_ACC:
 469                 case ICE_PHY_TYPE_LOW_25G_AUI_AOC_ACC:
 470                 case ICE_PHY_TYPE_LOW_40G_XLAUI_AOC_ACC:
 471                 case ICE_PHY_TYPE_LOW_50G_LAUI2_AOC_ACC:
 472                 case ICE_PHY_TYPE_LOW_50G_AUI2_AOC_ACC:
 473                 case ICE_PHY_TYPE_LOW_50G_AUI1_AOC_ACC:
 474                 case ICE_PHY_TYPE_LOW_100G_CAUI4_AOC_ACC:
 475                 case ICE_PHY_TYPE_LOW_100G_AUI4_AOC_ACC:
 476                         return ICE_MEDIA_FIBER;
 477                 case ICE_PHY_TYPE_LOW_100BASE_TX:
 478                 case ICE_PHY_TYPE_LOW_1000BASE_T:
 479                 case ICE_PHY_TYPE_LOW_2500BASE_T:
 480                 case ICE_PHY_TYPE_LOW_5GBASE_T:
 481                 case ICE_PHY_TYPE_LOW_10GBASE_T:
 482                 case ICE_PHY_TYPE_LOW_25GBASE_T:
 483                         return ICE_MEDIA_BASET;
 484                 case ICE_PHY_TYPE_LOW_10G_SFI_DA:
 485                 case ICE_PHY_TYPE_LOW_25GBASE_CR:
 486                 case ICE_PHY_TYPE_LOW_25GBASE_CR_S:
 487                 case ICE_PHY_TYPE_LOW_25GBASE_CR1:
 488                 case ICE_PHY_TYPE_LOW_40GBASE_CR4:
 489                 case ICE_PHY_TYPE_LOW_50GBASE_CR2:
 490                 case ICE_PHY_TYPE_LOW_50GBASE_CP:
 491                 case ICE_PHY_TYPE_LOW_100GBASE_CR4:
 492                 case ICE_PHY_TYPE_LOW_100GBASE_CR_PAM4:
 493                 case ICE_PHY_TYPE_LOW_100GBASE_CP2:
 494                         return ICE_MEDIA_DA;
 495                 case ICE_PHY_TYPE_LOW_25G_AUI_C2C:
 496                 case ICE_PHY_TYPE_LOW_40G_XLAUI:
 497                 case ICE_PHY_TYPE_LOW_50G_LAUI2:
 498                 case ICE_PHY_TYPE_LOW_50G_AUI2:
 499                 case ICE_PHY_TYPE_LOW_50G_AUI1:
 500                 case ICE_PHY_TYPE_LOW_100G_AUI4:
 501                 case ICE_PHY_TYPE_LOW_100G_CAUI4:
 502                         if (ice_is_media_cage_present(pi))
 503                                 return ICE_MEDIA_AUI;
 504                         /* fall-through */
 505                 case ICE_PHY_TYPE_LOW_1000BASE_KX:
 506                 case ICE_PHY_TYPE_LOW_2500BASE_KX:
 507                 case ICE_PHY_TYPE_LOW_2500BASE_X:
 508                 case ICE_PHY_TYPE_LOW_5GBASE_KR:
 509                 case ICE_PHY_TYPE_LOW_10GBASE_KR_CR1:
 510                 case ICE_PHY_TYPE_LOW_25GBASE_KR:
 511                 case ICE_PHY_TYPE_LOW_25GBASE_KR1:
 512                 case ICE_PHY_TYPE_LOW_25GBASE_KR_S:
 513                 case ICE_PHY_TYPE_LOW_40GBASE_KR4:
 514                 case ICE_PHY_TYPE_LOW_50GBASE_KR_PAM4:
 515                 case ICE_PHY_TYPE_LOW_50GBASE_KR2:
 516                 case ICE_PHY_TYPE_LOW_100GBASE_KR4:
 517                 case ICE_PHY_TYPE_LOW_100GBASE_KR_PAM4:
 518                         return ICE_MEDIA_BACKPLANE;
 519                 }
 520         } else {
 521                 switch (hw_link_info->phy_type_high) {
 522                 case ICE_PHY_TYPE_HIGH_100G_AUI2:
 523                 case ICE_PHY_TYPE_HIGH_100G_CAUI2:
 524                         if (ice_is_media_cage_present(pi))
 525                                 return ICE_MEDIA_AUI;
 526                         /* fall-through */
 527                 case ICE_PHY_TYPE_HIGH_100GBASE_KR2_PAM4:
 528                         return ICE_MEDIA_BACKPLANE;
 529                 case ICE_PHY_TYPE_HIGH_100G_CAUI2_AOC_ACC:
 530                 case ICE_PHY_TYPE_HIGH_100G_AUI2_AOC_ACC:
 531                         return ICE_MEDIA_FIBER;
 532                 }
 533         }
 534         return ICE_MEDIA_UNKNOWN;
 535 }
 536
 537 /**
 538  * ice_aq_get_link_info
 539  * @pi: port information structure
 540  * @ena_lse: enable/disable LinkStatusEvent reporting
 541  * @link: pointer to link status structure - optional
 542  * @cd: pointer to command details structure or NULL
 543  *
 544  * Get Link Status (0x607). Returns the link status of the adapter.
 545  */
 546 enum ice_status
 547 ice_aq_get_link_info(struct ice_port_info *pi, bool ena_lse,
 548                      struct ice_link_status *link, struct ice_sq_cd *cd)
 549 {
 550         struct ice_aqc_get_link_status_data link_data = { 0 };
 551         struct ice_aqc_get_link_status *resp;
 552         struct ice_link_status *li_old, *li;
 553         enum ice_media_type *hw_media_type;
 554         struct ice_fc_info *hw_fc_info;
 555         bool tx_pause, rx_pause;
 556         struct ice_aq_desc desc;
 557         enum ice_status status;
 558         struct ice_hw *hw;
 559         u16 cmd_flags;
 560
 561         if (!pi)
 562                 return ICE_ERR_PARAM;
 563         hw = pi->hw;
 564         li_old = &pi->phy.link_info_old;
 565         hw_media_type = &pi->phy.media_type;
 566         li = &pi->phy.link_info;
 567         hw_fc_info = &pi->fc;
 568
 569         ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_get_link_status);
 570         cmd_flags = (ena_lse) ? ICE_AQ_LSE_ENA : ICE_AQ_LSE_DIS;
 571         resp = &desc.params.get_link_status;
 572         resp->cmd_flags = CPU_TO_LE16(cmd_flags);
 573         resp->lport_num = pi->lport;
 574
 575         status = ice_aq_send_cmd(hw, &desc, &link_data, sizeof(link_data), cd);
 576
 577         if (status != ICE_SUCCESS)
 578                 return status;
 579
 580         /* save off old link status information */
 581         *li_old = *li;
 582
 583         /* update current link status information */
 584         li->link_speed = LE16_TO_CPU(link_data.link_speed);
 585         li->phy_type_low = LE64_TO_CPU(link_data.phy_type_low);
 586         li->phy_type_high = LE64_TO_CPU(link_data.phy_type_high);
 587         *hw_media_type = ice_get_media_type(pi);
 588         li->link_info = link_data.link_info;
 589         li->link_cfg_err = link_data.link_cfg_err;
 590         li->an_info = link_data.an_info;
 591         li->ext_info = link_data.ext_info;
 592         li->max_frame_size = LE16_TO_CPU(link_data.max_frame_size);
 593         li->fec_info = link_data.cfg & ICE_AQ_FEC_MASK;
 594         li->topo_media_conflict = link_data.topo_media_conflict;
 595         li->pacing = link_data.cfg & (ICE_AQ_CFG_PACING_M |
 596                                       ICE_AQ_CFG_PACING_TYPE_M);
 597
 598         /* update fc info */
 599         tx_pause = !!(link_data.an_info & ICE_AQ_LINK_PAUSE_TX);
 600         rx_pause = !!(link_data.an_info & ICE_AQ_LINK_PAUSE_RX);
 601         if (tx_pause && rx_pause)
 602                 hw_fc_info->current_mode = ICE_FC_FULL;
 603         else if (tx_pause)
 604                 hw_fc_info->current_mode = ICE_FC_TX_PAUSE;
 605         else if (rx_pause)
 606                 hw_fc_info->current_mode = ICE_FC_RX_PAUSE;
 607         else
 608                 hw_fc_info->current_mode = ICE_FC_NONE;
 609
 610         li->lse_ena = !!(resp->cmd_flags & CPU_TO_LE16(ICE_AQ_LSE_IS_ENABLED));
 611
 612         ice_debug(hw, ICE_DBG_LINK, "get link info\n");
 613         ice_debug(hw, ICE_DBG_LINK, "   link_speed = 0x%x\n", li->link_speed);
 614         ice_debug(hw, ICE_DBG_LINK, "   phy_type_low = 0x%llx\n",
 615                   (unsigned long long)li->phy_type_low);
 616         ice_debug(hw, ICE_DBG_LINK, "   phy_type_high = 0x%llx\n",
 617                   (unsigned long long)li->phy_type_high);
 618         ice_debug(hw, ICE_DBG_LINK, "   media_type = 0x%x\n", *hw_media_type);
 619         ice_debug(hw, ICE_DBG_LINK, "   link_info = 0x%x\n", li->link_info);
 620         ice_debug(hw, ICE_DBG_LINK, "   link_cfg_err = 0x%x\n", li->link_cfg_err);
 621         ice_debug(hw, ICE_DBG_LINK, "   an_info = 0x%x\n", li->an_info);
 622         ice_debug(hw, ICE_DBG_LINK, "   ext_info = 0x%x\n", li->ext_info);
 623         ice_debug(hw, ICE_DBG_LINK, "   fec_info = 0x%x\n", li->fec_info);
 624         ice_debug(hw, ICE_DBG_LINK, "   lse_ena = 0x%x\n", li->lse_ena);
 625         ice_debug(hw, ICE_DBG_LINK, "   max_frame = 0x%x\n",
 626                   li->max_frame_size);
 627         ice_debug(hw, ICE_DBG_LINK, "   pacing = 0x%x\n", li->pacing);
 628
 629         /* save link status information */
 630         if (link)
 631                 *link = *li;
 632
 633         /* flag cleared so calling functions don't call AQ again */
 634         pi->phy.get_link_info = false;
 635
 636         return ICE_SUCCESS;
 637 }
 638
 639 /**
 640  * ice_fill_tx_timer_and_fc_thresh
 641  * @hw: pointer to the HW struct
 642  * @cmd: pointer to MAC cfg structure
 643  *
 644  * Add Tx timer and FC refresh threshold info to Set MAC Config AQ command
 645  * descriptor
 646  */
 647 static void
 648 ice_fill_tx_timer_and_fc_thresh(struct ice_hw *hw,
 649                                 struct ice_aqc_set_mac_cfg *cmd)
 650 {
 651         u16 fc_thres_val, tx_timer_val;
 652         u32 val;
 653
 654         /* We read back the transmit timer and fc threshold value of
 655          * LFC. Thus, we will use index =
 656          * PRTMAC_HSEC_CTL_TX_PAUSE_QUANTA_MAX_INDEX.
 657          *
 658          * Also, because we are opearating on transmit timer and fc
 659          * threshold of LFC, we don't turn on any bit in tx_tmr_priority
 660          */
 661 #define IDX_OF_LFC PRTMAC_HSEC_CTL_TX_PAUSE_QUANTA_MAX_INDEX
 662
 663         /* Retrieve the transmit timer */
 664         val = rd32(hw, PRTMAC_HSEC_CTL_TX_PAUSE_QUANTA(IDX_OF_LFC));
 665         tx_timer_val = val &
 666                 PRTMAC_HSEC_CTL_TX_PAUSE_QUANTA_HSEC_CTL_TX_PAUSE_QUANTA_M;
 667         cmd->tx_tmr_value = CPU_TO_LE16(tx_timer_val);
 668
 669         /* Retrieve the fc threshold */
 670         val = rd32(hw, PRTMAC_HSEC_CTL_TX_PAUSE_REFRESH_TIMER(IDX_OF_LFC));
 671         fc_thres_val = val & PRTMAC_HSEC_CTL_TX_PAUSE_REFRESH_TIMER_M;
 672
 673         cmd->fc_refresh_threshold = CPU_TO_LE16(fc_thres_val);
 674 }
 675
 676 /**
 677  * ice_aq_set_mac_cfg
 678  * @hw: pointer to the HW struct
 679  * @max_frame_size: Maximum Frame Size to be supported
 680  * @cd: pointer to command details structure or NULL
 681  *
 682  * Set MAC configuration (0x0603)
 683  */
 684 enum ice_status
 685 ice_aq_set_mac_cfg(struct ice_hw *hw, u16 max_frame_size, struct ice_sq_cd *cd)
 686 {
 687         struct ice_aqc_set_mac_cfg *cmd;
 688         struct ice_aq_desc desc;
 689
 690         cmd = &desc.params.set_mac_cfg;
 691
 692         if (max_frame_size == 0)
 693                 return ICE_ERR_PARAM;
 694
 695         ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_set_mac_cfg);
 696
 697         cmd->max_frame_size = CPU_TO_LE16(max_frame_size);
 698
 699         ice_fill_tx_timer_and_fc_thresh(hw, cmd);
 700
 701         return ice_aq_send_cmd(hw, &desc, NULL, 0, cd);
 702 }
 703
 704 /**
 705  * ice_init_fltr_mgmt_struct - initializes filter management list and locks
 706  * @hw: pointer to the HW struct
 707  */
 708 enum ice_status ice_init_fltr_mgmt_struct(struct ice_hw *hw)
 709 {
 710         struct ice_switch_info *sw;
 711         enum ice_status status;
 712
 713         hw->switch_info = (struct ice_switch_info *)
 714                           ice_malloc(hw, sizeof(*hw->switch_info));
 715
 716         sw = hw->switch_info;
 717
 718         if (!sw)
 719                 return ICE_ERR_NO_MEMORY;
 720
 721         INIT_LIST_HEAD(&sw->vsi_list_map_head);
 722         sw->prof_res_bm_init = 0;
 723
 724         status = ice_init_def_sw_recp(hw, &hw->switch_info->recp_list);
 725         if (status) {
 726                 ice_free(hw, hw->switch_info);
 727                 return status;
 728         }
 729         return ICE_SUCCESS;
 730 }
 731
 732 /**
 733  * ice_cleanup_fltr_mgmt_single - clears single filter mngt struct
 734  * @hw: pointer to the HW struct
 735  * @sw: pointer to switch info struct for which function clears filters
 736  */
 737 static void
 738 ice_cleanup_fltr_mgmt_single(struct ice_hw *hw, struct ice_switch_info *sw)
 739 {
 740         struct ice_vsi_list_map_info *v_pos_map;
 741         struct ice_vsi_list_map_info *v_tmp_map;
 742         struct ice_sw_recipe *recps;
 743         u8 i;
 744
 745         if (!sw)
 746                 return;
 747
 748         LIST_FOR_EACH_ENTRY_SAFE(v_pos_map, v_tmp_map, &sw->vsi_list_map_head,
 749                                  ice_vsi_list_map_info, list_entry) {
 750                 LIST_DEL(&v_pos_map->list_entry);
 751                 ice_free(hw, v_pos_map);
 752         }
 753         recps = sw->recp_list;
 754         for (i = 0; i < ICE_MAX_NUM_RECIPES; i++) {
 755                 struct ice_recp_grp_entry *rg_entry, *tmprg_entry;
 756
 757                 recps[i].root_rid = i;
 758                 LIST_FOR_EACH_ENTRY_SAFE(rg_entry, tmprg_entry,
 759                                          &recps[i].rg_list, ice_recp_grp_entry,
 760                                          l_entry) {
 761                         LIST_DEL(&rg_entry->l_entry);
 762                         ice_free(hw, rg_entry);
 763                 }
 764
 765                 if (recps[i].adv_rule) {
 766                         struct ice_adv_fltr_mgmt_list_entry *tmp_entry;
 767                         struct ice_adv_fltr_mgmt_list_entry *lst_itr;
 768
 769                         ice_destroy_lock(&recps[i].filt_rule_lock);
 770                         LIST_FOR_EACH_ENTRY_SAFE(lst_itr, tmp_entry,
 771                                                  &recps[i].filt_rules,
 772                                                  ice_adv_fltr_mgmt_list_entry,
 773                                                  list_entry) {
 774                                 LIST_DEL(&lst_itr->list_entry);
 775                                 ice_free(hw, lst_itr->lkups);
 776                                 ice_free(hw, lst_itr);
 777                         }
 778                 } else {
 779                         struct ice_fltr_mgmt_list_entry *lst_itr, *tmp_entry;
 780
 781                         ice_destroy_lock(&recps[i].filt_rule_lock);
 782                         LIST_FOR_EACH_ENTRY_SAFE(lst_itr, tmp_entry,
 783                                                  &recps[i].filt_rules,
 784                                                  ice_fltr_mgmt_list_entry,
 785                                                  list_entry) {
 786                                 LIST_DEL(&lst_itr->list_entry);
 787                                 ice_free(hw, lst_itr);
 788                         }
 789                 }
 790                 if (recps[i].root_buf)
 791                         ice_free(hw, recps[i].root_buf);
 792         }
 793         ice_rm_sw_replay_rule_info(hw, sw);
 794         ice_free(hw, sw->recp_list);
 795         ice_free(hw, sw);
 796 }
 797
 798 /**
 799  * ice_cleanup_fltr_mgmt_struct - cleanup filter management list and locks
 800  * @hw: pointer to the HW struct
 801  */
 802 void ice_cleanup_fltr_mgmt_struct(struct ice_hw *hw)
 803 {
 804         ice_cleanup_fltr_mgmt_single(hw, hw->switch_info);
 805 }
 806
 807 /**
 808  * ice_get_itr_intrl_gran
 809  * @hw: pointer to the HW struct
 810  *
 811  * Determines the ITR/INTRL granularities based on the maximum aggregate
 812  * bandwidth according to the device's configuration during power-on.
 813  */
 814 static void ice_get_itr_intrl_gran(struct ice_hw *hw)
 815 {
 816         u8 max_agg_bw = (rd32(hw, GL_PWR_MODE_CTL) &
 817                          GL_PWR_MODE_CTL_CAR_MAX_BW_M) >>
 818                         GL_PWR_MODE_CTL_CAR_MAX_BW_S;
 819
 820         switch (max_agg_bw) {
 821         case ICE_MAX_AGG_BW_200G:
 822         case ICE_MAX_AGG_BW_100G:
 823         case ICE_MAX_AGG_BW_50G:
 824                 hw->itr_gran = ICE_ITR_GRAN_ABOVE_25;
 825                 hw->intrl_gran = ICE_INTRL_GRAN_ABOVE_25;
 826                 break;
 827         case ICE_MAX_AGG_BW_25G:
 828                 hw->itr_gran = ICE_ITR_GRAN_MAX_25;
 829                 hw->intrl_gran = ICE_INTRL_GRAN_MAX_25;
 830                 break;
 831         }
 832 }
 833
 834 /**
 835  * ice_print_rollback_msg - print FW rollback message
 836  * @hw: pointer to the hardware structure
 837  */
 838 void ice_print_rollback_msg(struct ice_hw *hw)
 839 {
 840         char nvm_str[ICE_NVM_VER_LEN] = { 0 };
 841         struct ice_orom_info *orom;
 842         struct ice_nvm_info *nvm;
 843
 844         orom = &hw->flash.orom;
 845         nvm = &hw->flash.nvm;
 846
 847         SNPRINTF(nvm_str, sizeof(nvm_str), "%x.%02x 0x%x %d.%d.%d",
 848                  nvm->major, nvm->minor, nvm->eetrack, orom->major,
 849                  orom->build, orom->patch);
 850         ice_warn(hw,
 851                  "Firmware rollback mode detected. Current version is NVM: %s, FW: %d.%d. Device may exhibit limited functionality. Refer to the Intel(R) Ethernet Adapters and Devices User Guide for details on firmware rollback mode\n",
 852                  nvm_str, hw->fw_maj_ver, hw->fw_min_ver);
 853 }
 854
 855 /**
 856  * ice_init_hw - main hardware initialization routine
 857  * @hw: pointer to the hardware structure
 858  */
 859 enum ice_status ice_init_hw(struct ice_hw *hw)
 860 {
 861         struct ice_aqc_get_phy_caps_data *pcaps;
 862         enum ice_status status;
 863         u16 mac_buf_len;
 864         void *mac_buf;
 865
 866         ice_debug(hw, ICE_DBG_TRACE, "%s\n", __func__);
 867
 868         /* Set MAC type based on DeviceID */
 869         status = ice_set_mac_type(hw);
 870         if (status)
 871                 return status;
 872
 873         hw->pf_id = (u8)(rd32(hw, PF_FUNC_RID) &
 874                          PF_FUNC_RID_FUNCTION_NUMBER_M) >>
 875                 PF_FUNC_RID_FUNCTION_NUMBER_S;
 876
 877         status = ice_reset(hw, ICE_RESET_PFR);
 878         if (status)
 879                 return status;
 880
 881         ice_get_itr_intrl_gran(hw);
 882
 883         status = ice_create_all_ctrlq(hw);
 884         if (status)
 885                 goto err_unroll_cqinit;
 886
 887         status = ice_init_nvm(hw);
 888         if (status)
 889                 goto err_unroll_cqinit;
 890
 891         if (ice_get_fw_mode(hw) == ICE_FW_MODE_ROLLBACK)
 892                 ice_print_rollback_msg(hw);
 893
 894         status = ice_clear_pf_cfg(hw);
 895         if (status)
 896                 goto err_unroll_cqinit;
 897
 898         /* Set bit to enable Flow Director filters */
 899         wr32(hw, PFQF_FD_ENA, PFQF_FD_ENA_FD_ENA_M);
 900         INIT_LIST_HEAD(&hw->fdir_list_head);
 901
 902         ice_clear_pxe_mode(hw);
 903
 904         status = ice_get_caps(hw);
 905         if (status)
 906                 goto err_unroll_cqinit;
 907
 908         hw->port_info = (struct ice_port_info *)
 909                         ice_malloc(hw, sizeof(*hw->port_info));
 910         if (!hw->port_info) {
 911                 status = ICE_ERR_NO_MEMORY;
 912                 goto err_unroll_cqinit;
 913         }
 914
 915         /* set the back pointer to HW */
 916         hw->port_info->hw = hw;
 917
 918         /* Initialize port_info struct with switch configuration data */
 919         status = ice_get_initial_sw_cfg(hw);
 920         if (status)
 921                 goto err_unroll_alloc;
 922
 923         hw->evb_veb = true;
 924         /* Query the allocated resources for Tx scheduler */
 925         status = ice_sched_query_res_alloc(hw);
 926         if (status) {
 927                 ice_debug(hw, ICE_DBG_SCHED, "Failed to get scheduler allocated resources\n");
 928                 goto err_unroll_alloc;
 929         }
 930         ice_sched_get_psm_clk_freq(hw);
 931
 932         /* Initialize port_info struct with scheduler data */
 933         status = ice_sched_init_port(hw->port_info);
 934         if (status)
 935                 goto err_unroll_sched;
 936         pcaps = (struct ice_aqc_get_phy_caps_data *)
 937                 ice_malloc(hw, sizeof(*pcaps));
 938         if (!pcaps) {
 939                 status = ICE_ERR_NO_MEMORY;
 940                 goto err_unroll_sched;
 941         }
 942
 943         /* Initialize port_info struct with PHY capabilities */
 944         status = ice_aq_get_phy_caps(hw->port_info, false,
 945                                      ICE_AQC_REPORT_TOPO_CAP_MEDIA, pcaps, NULL);
 946         ice_free(hw, pcaps);
 947         if (status)
 948                 ice_warn(hw, "Get PHY capabilities failed status = %d, continuing anyway\n",
 949                          status);
 950
 951         /* Initialize port_info struct with link information */
 952         status = ice_aq_get_link_info(hw->port_info, false, NULL, NULL);
 953         if (status)
 954                 goto err_unroll_sched;
 955         /* need a valid SW entry point to build a Tx tree */
 956         if (!hw->sw_entry_point_layer) {
 957                 ice_debug(hw, ICE_DBG_SCHED, "invalid sw entry point\n");
 958                 status = ICE_ERR_CFG;
 959                 goto err_unroll_sched;
 960         }
 961         INIT_LIST_HEAD(&hw->agg_list);
 962         /* Initialize max burst size */
 963         if (!hw->max_burst_size)
 964                 ice_cfg_rl_burst_size(hw, ICE_SCHED_DFLT_BURST_SIZE);
 965         status = ice_init_fltr_mgmt_struct(hw);
 966         if (status)
 967                 goto err_unroll_sched;
 968
 969         /* Get MAC information */
 970         /* A single port can report up to two (LAN and WoL) addresses */
 971         mac_buf = ice_calloc(hw, 2,
 972                              sizeof(struct ice_aqc_manage_mac_read_resp));
 973         mac_buf_len = 2 * sizeof(struct ice_aqc_manage_mac_read_resp);
 974
 975         if (!mac_buf) {
 976                 status = ICE_ERR_NO_MEMORY;
 977                 goto err_unroll_fltr_mgmt_struct;
 978         }
 979
 980         status = ice_aq_manage_mac_read(hw, mac_buf, mac_buf_len, NULL);
 981         ice_free(hw, mac_buf);
 982
 983         if (status)
 984                 goto err_unroll_fltr_mgmt_struct;
 985         /* Obtain counter base index which would be used by flow director */
 986         status = ice_alloc_fd_res_cntr(hw, &hw->fd_ctr_base);
 987         if (status)
 988                 goto err_unroll_fltr_mgmt_struct;
 989         status = ice_init_hw_tbls(hw);
 990         if (status)
 991                 goto err_unroll_fltr_mgmt_struct;
 992         ice_init_lock(&hw->tnl_lock);
 993
 994         return ICE_SUCCESS;
 995
 996 err_unroll_fltr_mgmt_struct:
 997         ice_cleanup_fltr_mgmt_struct(hw);
 998 err_unroll_sched:
 999         ice_sched_cleanup_all(hw);
1000 err_unroll_alloc:
1001         ice_free(hw, hw->port_info);
1002         hw->port_info = NULL;
1003 err_unroll_cqinit:
1004         ice_destroy_all_ctrlq(hw);
1005         return status;
1006 }
1007
1008 /**
1009  * ice_deinit_hw - unroll initialization operations done by ice_init_hw
1010  * @hw: pointer to the hardware structure
1011  *
1012  * This should be called only during nominal operation, not as a result of
1013  * ice_init_hw() failing since ice_init_hw() will take care of unrolling
1014  * applicable initializations if it fails for any reason.
1015  */
1016 void ice_deinit_hw(struct ice_hw *hw)
1017 {
1018         ice_free_fd_res_cntr(hw, hw->fd_ctr_base);
1019         ice_cleanup_fltr_mgmt_struct(hw);
1020
1021         ice_sched_cleanup_all(hw);
1022         ice_sched_clear_agg(hw);
1023         ice_free_seg(hw);
1024         ice_free_hw_tbls(hw);
1025         ice_destroy_lock(&hw->tnl_lock);
1026
1027         if (hw->port_info) {
1028                 ice_free(hw, hw->port_info);
1029                 hw->port_info = NULL;
1030         }
1031
1032         ice_destroy_all_ctrlq(hw);
1033
1034         /* Clear VSI contexts if not already cleared */
1035         ice_clear_all_vsi_ctx(hw);
1036 }
1037
1038 /**
1039  * ice_check_reset - Check to see if a global reset is complete
1040  * @hw: pointer to the hardware structure
1041  */
1042 enum ice_status ice_check_reset(struct ice_hw *hw)
1043 {
1044         u32 cnt, reg = 0, grst_timeout, uld_mask;
1045
1046         /* Poll for Device Active state in case a recent CORER, GLOBR,
1047          * or EMPR has occurred. The grst delay value is in 100ms units.
1048          * Add 1sec for outstanding AQ commands that can take a long time.
1049          */
1050         grst_timeout = ((rd32(hw, GLGEN_RSTCTL) & GLGEN_RSTCTL_GRSTDEL_M) >>
1051                         GLGEN_RSTCTL_GRSTDEL_S) + 10;
1052
1053         for (cnt = 0; cnt < grst_timeout; cnt++) {
1054                 ice_msec_delay(100, true);
1055                 reg = rd32(hw, GLGEN_RSTAT);
1056                 if (!(reg & GLGEN_RSTAT_DEVSTATE_M))
1057                         break;
1058         }
1059
1060         if (cnt == grst_timeout) {
1061                 ice_debug(hw, ICE_DBG_INIT, "Global reset polling failed to complete.\n");
1062                 return ICE_ERR_RESET_FAILED;
1063         }
1064
1065 #define ICE_RESET_DONE_MASK     (GLNVM_ULD_PCIER_DONE_M |\
1066                                  GLNVM_ULD_PCIER_DONE_1_M |\
1067                                  GLNVM_ULD_CORER_DONE_M |\
1068                                  GLNVM_ULD_GLOBR_DONE_M |\
1069                                  GLNVM_ULD_POR_DONE_M |\
1070                                  GLNVM_ULD_POR_DONE_1_M |\
1071                                  GLNVM_ULD_PCIER_DONE_2_M)
1072
1073         uld_mask = ICE_RESET_DONE_MASK;
1074
1075         /* Device is Active; check Global Reset processes are done */
1076         for (cnt = 0; cnt < ICE_PF_RESET_WAIT_COUNT; cnt++) {
1077                 reg = rd32(hw, GLNVM_ULD) & uld_mask;
1078                 if (reg == uld_mask) {
1079                         ice_debug(hw, ICE_DBG_INIT, "Global reset processes done. %d\n", cnt);
1080                         break;
1081                 }
1082                 ice_msec_delay(10, true);
1083         }
1084
1085         if (cnt == ICE_PF_RESET_WAIT_COUNT) {
1086                 ice_debug(hw, ICE_DBG_INIT, "Wait for Reset Done timed out. GLNVM_ULD = 0x%x\n",
1087                           reg);
1088                 return ICE_ERR_RESET_FAILED;
1089         }
1090
1091         return ICE_SUCCESS;
1092 }
1093
1094 /**
1095  * ice_pf_reset - Reset the PF
1096  * @hw: pointer to the hardware structure
1097  *
1098  * If a global reset has been triggered, this function checks
1099  * for its completion and then issues the PF reset
1100  */
1101 static enum ice_status ice_pf_reset(struct ice_hw *hw)
1102 {
1103         u32 cnt, reg;
1104
1105         /* If at function entry a global reset was already in progress, i.e.
1106          * state is not 'device active' or any of the reset done bits are not
1107          * set in GLNVM_ULD, there is no need for a PF Reset; poll until the
1108          * global reset is done.
1109          */
1110         if ((rd32(hw, GLGEN_RSTAT) & GLGEN_RSTAT_DEVSTATE_M) ||
1111             (rd32(hw, GLNVM_ULD) & ICE_RESET_DONE_MASK) ^ ICE_RESET_DONE_MASK) {
1112                 /* poll on global reset currently in progress until done */
1113                 if (ice_check_reset(hw))
1114                         return ICE_ERR_RESET_FAILED;
1115
1116                 return ICE_SUCCESS;
1117         }
1118
1119         /* Reset the PF */
1120         reg = rd32(hw, PFGEN_CTRL);
1121
1122         wr32(hw, PFGEN_CTRL, (reg | PFGEN_CTRL_PFSWR_M));
1123
1124         /* Wait for the PFR to complete. The wait time is the global config lock
1125          * timeout plus the PFR timeout which will account for a possible reset
1126          * that is occurring during a download package operation.
1127          */
1128         for (cnt = 0; cnt < ICE_GLOBAL_CFG_LOCK_TIMEOUT +
1129              ICE_PF_RESET_WAIT_COUNT; cnt++) {
1130                 reg = rd32(hw, PFGEN_CTRL);
1131                 if (!(reg & PFGEN_CTRL_PFSWR_M))
1132                         break;
1133
1134                 ice_msec_delay(1, true);
1135         }
1136
1137         if (cnt == ICE_PF_RESET_WAIT_COUNT) {
1138                 ice_debug(hw, ICE_DBG_INIT, "PF reset polling failed to complete.\n");
1139                 return ICE_ERR_RESET_FAILED;
1140         }
1141
1142         return ICE_SUCCESS;
1143 }
1144
1145 /**
1146  * ice_reset - Perform different types of reset
1147  * @hw: pointer to the hardware structure
1148  * @req: reset request
1149  *
1150  * This function triggers a reset as specified by the req parameter.
1151  *
1152  * Note:
1153  * If anything other than a PF reset is triggered, PXE mode is restored.
1154  * This has to be cleared using ice_clear_pxe_mode again, once the AQ
1155  * interface has been restored in the rebuild flow.
1156  */
1157 enum ice_status ice_reset(struct ice_hw *hw, enum ice_reset_req req)
1158 {
1159         u32 val = 0;
1160
1161         switch (req) {
1162         case ICE_RESET_PFR:
1163                 return ice_pf_reset(hw);
1164         case ICE_RESET_CORER:
1165                 ice_debug(hw, ICE_DBG_INIT, "CoreR requested\n");
1166                 val = GLGEN_RTRIG_CORER_M;
1167                 break;
1168         case ICE_RESET_GLOBR:
1169                 ice_debug(hw, ICE_DBG_INIT, "GlobalR requested\n");
1170                 val = GLGEN_RTRIG_GLOBR_M;
1171                 break;
1172         default:
1173                 return ICE_ERR_PARAM;
1174         }
1175
1176         val |= rd32(hw, GLGEN_RTRIG);
1177         wr32(hw, GLGEN_RTRIG, val);
1178         ice_flush(hw);
1179
1180         /* wait for the FW to be ready */
1181         return ice_check_reset(hw);
1182 }
1183
1184 /**
1185  * ice_copy_rxq_ctx_to_hw
1186  * @hw: pointer to the hardware structure
1187  * @ice_rxq_ctx: pointer to the rxq context
1188  * @rxq_index: the index of the Rx queue
1189  *
1190  * Copies rxq context from dense structure to HW register space
1191  */
1192 static enum ice_status
1193 ice_copy_rxq_ctx_to_hw(struct ice_hw *hw, u8 *ice_rxq_ctx, u32 rxq_index)
1194 {
1195         u8 i;
1196
1197         if (!ice_rxq_ctx)
1198                 return ICE_ERR_BAD_PTR;
1199
1200         if (rxq_index > QRX_CTRL_MAX_INDEX)
1201                 return ICE_ERR_PARAM;
1202
1203         /* Copy each dword separately to HW */
1204         for (i = 0; i < ICE_RXQ_CTX_SIZE_DWORDS; i++) {
1205                 wr32(hw, QRX_CONTEXT(i, rxq_index),
1206                      *((u32 *)(ice_rxq_ctx + (i * sizeof(u32)))));
1207
1208                 ice_debug(hw, ICE_DBG_QCTX, "qrxdata[%d]: %08X\n", i,
1209                           *((u32 *)(ice_rxq_ctx + (i * sizeof(u32)))));
1210         }
1211
1212         return ICE_SUCCESS;
1213 }
1214
1215 /* LAN Rx Queue Context */
1216 static const struct ice_ctx_ele ice_rlan_ctx_info[] = {
1217         /* Field                Width   LSB */
1218         ICE_CTX_STORE(ice_rlan_ctx, head,               13,     0),
1219         ICE_CTX_STORE(ice_rlan_ctx, cpuid,              8,      13),
1220         ICE_CTX_STORE(ice_rlan_ctx, base,               57,     32),
1221         ICE_CTX_STORE(ice_rlan_ctx, qlen,               13,     89),
1222         ICE_CTX_STORE(ice_rlan_ctx, dbuf,               7,      102),
1223         ICE_CTX_STORE(ice_rlan_ctx, hbuf,               5,      109),
1224         ICE_CTX_STORE(ice_rlan_ctx, dtype,              2,      114),
1225         ICE_CTX_STORE(ice_rlan_ctx, dsize,              1,      116),
1226         ICE_CTX_STORE(ice_rlan_ctx, crcstrip,           1,      117),
1227         ICE_CTX_STORE(ice_rlan_ctx, l2tsel,             1,      119),
1228         ICE_CTX_STORE(ice_rlan_ctx, hsplit_0,           4,      120),
1229         ICE_CTX_STORE(ice_rlan_ctx, hsplit_1,           2,      124),
1230         ICE_CTX_STORE(ice_rlan_ctx, showiv,             1,      127),
1231         ICE_CTX_STORE(ice_rlan_ctx, rxmax,              14,     174),
1232         ICE_CTX_STORE(ice_rlan_ctx, tphrdesc_ena,       1,      193),
1233         ICE_CTX_STORE(ice_rlan_ctx, tphwdesc_ena,       1,      194),
1234         ICE_CTX_STORE(ice_rlan_ctx, tphdata_ena,        1,      195),
1235         ICE_CTX_STORE(ice_rlan_ctx, tphhead_ena,        1,      196),
1236         ICE_CTX_STORE(ice_rlan_ctx, lrxqthresh,         3,      198),
1237         ICE_CTX_STORE(ice_rlan_ctx, prefena,            1,      201),
1238         { 0 }
1239 };
1240
1241 /**
1242  * ice_write_rxq_ctx
1243  * @hw: pointer to the hardware structure
1244  * @rlan_ctx: pointer to the rxq context
1245  * @rxq_index: the index of the Rx queue
1246  *
1247  * Converts rxq context from sparse to dense structure and then writes
1248  * it to HW register space and enables the hardware to prefetch descriptors
1249  * instead of only fetching them on demand
1250  */
1251 enum ice_status
1252 ice_write_rxq_ctx(struct ice_hw *hw, struct ice_rlan_ctx *rlan_ctx,
1253                   u32 rxq_index)
1254 {
1255         u8 ctx_buf[ICE_RXQ_CTX_SZ] = { 0 };
1256
1257         if (!rlan_ctx)
1258                 return ICE_ERR_BAD_PTR;
1259
1260         rlan_ctx->prefena = 1;
1261
1262         ice_set_ctx(hw, (u8 *)rlan_ctx, ctx_buf, ice_rlan_ctx_info);
1263         return ice_copy_rxq_ctx_to_hw(hw, ctx_buf, rxq_index);
1264 }
1265
1266 /**
1267  * ice_clear_rxq_ctx
1268  * @hw: pointer to the hardware structure
1269  * @rxq_index: the index of the Rx queue to clear
1270  *
1271  * Clears rxq context in HW register space
1272  */
1273 enum ice_status ice_clear_rxq_ctx(struct ice_hw *hw, u32 rxq_index)
1274 {
1275         u8 i;
1276
1277         if (rxq_index > QRX_CTRL_MAX_INDEX)
1278                 return ICE_ERR_PARAM;
1279
1280         /* Clear each dword register separately */
1281         for (i = 0; i < ICE_RXQ_CTX_SIZE_DWORDS; i++)
1282                 wr32(hw, QRX_CONTEXT(i, rxq_index), 0);
1283
1284         return ICE_SUCCESS;
1285 }
1286
1287 /* LAN Tx Queue Context */
1288 const struct ice_ctx_ele ice_tlan_ctx_info[] = {
1289                                     /* Field                    Width   LSB */
1290         ICE_CTX_STORE(ice_tlan_ctx, base,                       57,     0),
1291         ICE_CTX_STORE(ice_tlan_ctx, port_num,                   3,      57),
1292         ICE_CTX_STORE(ice_tlan_ctx, cgd_num,                    5,      60),
1293         ICE_CTX_STORE(ice_tlan_ctx, pf_num,                     3,      65),
1294         ICE_CTX_STORE(ice_tlan_ctx, vmvf_num,                   10,     68),
1295         ICE_CTX_STORE(ice_tlan_ctx, vmvf_type,                  2,      78),
1296         ICE_CTX_STORE(ice_tlan_ctx, src_vsi,                    10,     80),
1297         ICE_CTX_STORE(ice_tlan_ctx, tsyn_ena,                   1,      90),
1298         ICE_CTX_STORE(ice_tlan_ctx, internal_usage_flag,        1,      91),
1299         ICE_CTX_STORE(ice_tlan_ctx, alt_vlan,                   1,      92),
1300         ICE_CTX_STORE(ice_tlan_ctx, cpuid,                      8,      93),
1301         ICE_CTX_STORE(ice_tlan_ctx, wb_mode,                    1,      101),
1302         ICE_CTX_STORE(ice_tlan_ctx, tphrd_desc,                 1,      102),
1303         ICE_CTX_STORE(ice_tlan_ctx, tphrd,                      1,      103),
1304         ICE_CTX_STORE(ice_tlan_ctx, tphwr_desc,                 1,      104),
1305         ICE_CTX_STORE(ice_tlan_ctx, cmpq_id,                    9,      105),
1306         ICE_CTX_STORE(ice_tlan_ctx, qnum_in_func,               14,     114),
1307         ICE_CTX_STORE(ice_tlan_ctx, itr_notification_mode,      1,      128),
1308         ICE_CTX_STORE(ice_tlan_ctx, adjust_prof_id,             6,      129),
1309         ICE_CTX_STORE(ice_tlan_ctx, qlen,                       13,     135),
1310         ICE_CTX_STORE(ice_tlan_ctx, quanta_prof_idx,            4,      148),
1311         ICE_CTX_STORE(ice_tlan_ctx, tso_ena,                    1,      152),
1312         ICE_CTX_STORE(ice_tlan_ctx, tso_qnum,                   11,     153),
1313         ICE_CTX_STORE(ice_tlan_ctx, legacy_int,                 1,      164),
1314         ICE_CTX_STORE(ice_tlan_ctx, drop_ena,                   1,      165),
1315         ICE_CTX_STORE(ice_tlan_ctx, cache_prof_idx,             2,      166),
1316         ICE_CTX_STORE(ice_tlan_ctx, pkt_shaper_prof_idx,        3,      168),
1317         ICE_CTX_STORE(ice_tlan_ctx, int_q_state,                122,    171),
1318         { 0 }
1319 };
1320
1321 /**
1322  * ice_copy_tx_cmpltnq_ctx_to_hw
1323  * @hw: pointer to the hardware structure
1324  * @ice_tx_cmpltnq_ctx: pointer to the Tx completion queue context
1325  * @tx_cmpltnq_index: the index of the completion queue
1326  *
1327  * Copies Tx completion queue context from dense structure to HW register space
1328  */
1329 static enum ice_status
1330 ice_copy_tx_cmpltnq_ctx_to_hw(struct ice_hw *hw, u8 *ice_tx_cmpltnq_ctx,
1331                               u32 tx_cmpltnq_index)
1332 {
1333         u8 i;
1334
1335         if (!ice_tx_cmpltnq_ctx)
1336                 return ICE_ERR_BAD_PTR;
1337
1338         if (tx_cmpltnq_index > GLTCLAN_CQ_CNTX0_MAX_INDEX)
1339                 return ICE_ERR_PARAM;
1340
1341         /* Copy each dword separately to HW */
1342         for (i = 0; i < ICE_TX_CMPLTNQ_CTX_SIZE_DWORDS; i++) {
1343                 wr32(hw, GLTCLAN_CQ_CNTX(i, tx_cmpltnq_index),
1344                      *((u32 *)(ice_tx_cmpltnq_ctx + (i * sizeof(u32)))));
1345
1346                 ice_debug(hw, ICE_DBG_QCTX, "cmpltnqdata[%d]: %08X\n", i,
1347                           *((u32 *)(ice_tx_cmpltnq_ctx + (i * sizeof(u32)))));
1348         }
1349
1350         return ICE_SUCCESS;
1351 }
1352
1353 /* LAN Tx Completion Queue Context */
1354 static const struct ice_ctx_ele ice_tx_cmpltnq_ctx_info[] = {
1355                                        /* Field                 Width   LSB */
1356         ICE_CTX_STORE(ice_tx_cmpltnq_ctx, base,                 57,     0),
1357         ICE_CTX_STORE(ice_tx_cmpltnq_ctx, q_len,                18,     64),
1358         ICE_CTX_STORE(ice_tx_cmpltnq_ctx, generation,           1,      96),
1359         ICE_CTX_STORE(ice_tx_cmpltnq_ctx, wrt_ptr,              22,     97),
1360         ICE_CTX_STORE(ice_tx_cmpltnq_ctx, pf_num,               3,      128),
1361         ICE_CTX_STORE(ice_tx_cmpltnq_ctx, vmvf_num,             10,     131),
1362         ICE_CTX_STORE(ice_tx_cmpltnq_ctx, vmvf_type,            2,      141),
1363         ICE_CTX_STORE(ice_tx_cmpltnq_ctx, tph_desc_wr,          1,      160),
1364         ICE_CTX_STORE(ice_tx_cmpltnq_ctx, cpuid,                8,      161),
1365         ICE_CTX_STORE(ice_tx_cmpltnq_ctx, cmpltn_cache,         512,    192),
1366         { 0 }
1367 };
1368
1369 /**
1370  * ice_write_tx_cmpltnq_ctx
1371  * @hw: pointer to the hardware structure
1372  * @tx_cmpltnq_ctx: pointer to the completion queue context
1373  * @tx_cmpltnq_index: the index of the completion queue
1374  *
1375  * Converts completion queue context from sparse to dense structure and then
1376  * writes it to HW register space
1377  */
1378 enum ice_status
1379 ice_write_tx_cmpltnq_ctx(struct ice_hw *hw,
1380                          struct ice_tx_cmpltnq_ctx *tx_cmpltnq_ctx,
1381                          u32 tx_cmpltnq_index)
1382 {
1383         u8 ctx_buf[ICE_TX_CMPLTNQ_CTX_SIZE_DWORDS * sizeof(u32)] = { 0 };
1384
1385         ice_set_ctx(hw, (u8 *)tx_cmpltnq_ctx, ctx_buf, ice_tx_cmpltnq_ctx_info);
1386         return ice_copy_tx_cmpltnq_ctx_to_hw(hw, ctx_buf, tx_cmpltnq_index);
1387 }
1388
1389 /**
1390  * ice_clear_tx_cmpltnq_ctx
1391  * @hw: pointer to the hardware structure
1392  * @tx_cmpltnq_index: the index of the completion queue to clear
1393  *
1394  * Clears Tx completion queue context in HW register space
1395  */
1396 enum ice_status
1397 ice_clear_tx_cmpltnq_ctx(struct ice_hw *hw, u32 tx_cmpltnq_index)
1398 {
1399         u8 i;
1400
1401         if (tx_cmpltnq_index > GLTCLAN_CQ_CNTX0_MAX_INDEX)
1402                 return ICE_ERR_PARAM;
1403
1404         /* Clear each dword register separately */
1405         for (i = 0; i < ICE_TX_CMPLTNQ_CTX_SIZE_DWORDS; i++)
1406                 wr32(hw, GLTCLAN_CQ_CNTX(i, tx_cmpltnq_index), 0);
1407
1408         return ICE_SUCCESS;
1409 }
1410
1411 /**
1412  * ice_copy_tx_drbell_q_ctx_to_hw
1413  * @hw: pointer to the hardware structure
1414  * @ice_tx_drbell_q_ctx: pointer to the doorbell queue context
1415  * @tx_drbell_q_index: the index of the doorbell queue
1416  *
1417  * Copies doorbell queue context from dense structure to HW register space
1418  */
1419 static enum ice_status
1420 ice_copy_tx_drbell_q_ctx_to_hw(struct ice_hw *hw, u8 *ice_tx_drbell_q_ctx,
1421                                u32 tx_drbell_q_index)
1422 {
1423         u8 i;
1424
1425         if (!ice_tx_drbell_q_ctx)
1426                 return ICE_ERR_BAD_PTR;
1427
1428         if (tx_drbell_q_index > QTX_COMM_DBLQ_DBELL_MAX_INDEX)
1429                 return ICE_ERR_PARAM;
1430
1431         /* Copy each dword separately to HW */
1432         for (i = 0; i < ICE_TX_DRBELL_Q_CTX_SIZE_DWORDS; i++) {
1433                 wr32(hw, QTX_COMM_DBLQ_CNTX(i, tx_drbell_q_index),
1434                      *((u32 *)(ice_tx_drbell_q_ctx + (i * sizeof(u32)))));
1435
1436                 ice_debug(hw, ICE_DBG_QCTX, "tx_drbell_qdata[%d]: %08X\n", i,
1437                           *((u32 *)(ice_tx_drbell_q_ctx + (i * sizeof(u32)))));
1438         }
1439
1440         return ICE_SUCCESS;
1441 }
1442
1443 /* LAN Tx Doorbell Queue Context info */
1444 static const struct ice_ctx_ele ice_tx_drbell_q_ctx_info[] = {
1445                                         /* Field                Width   LSB */
1446         ICE_CTX_STORE(ice_tx_drbell_q_ctx, base,                57,     0),
1447         ICE_CTX_STORE(ice_tx_drbell_q_ctx, ring_len,            13,     64),
1448         ICE_CTX_STORE(ice_tx_drbell_q_ctx, pf_num,              3,      80),
1449         ICE_CTX_STORE(ice_tx_drbell_q_ctx, vf_num,              8,      84),
1450         ICE_CTX_STORE(ice_tx_drbell_q_ctx, vmvf_type,           2,      94),
1451         ICE_CTX_STORE(ice_tx_drbell_q_ctx, cpuid,               8,      96),
1452         ICE_CTX_STORE(ice_tx_drbell_q_ctx, tph_desc_rd,         1,      104),
1453         ICE_CTX_STORE(ice_tx_drbell_q_ctx, tph_desc_wr,         1,      108),
1454         ICE_CTX_STORE(ice_tx_drbell_q_ctx, db_q_en,             1,      112),
1455         ICE_CTX_STORE(ice_tx_drbell_q_ctx, rd_head,             13,     128),
1456         ICE_CTX_STORE(ice_tx_drbell_q_ctx, rd_tail,             13,     144),
1457         { 0 }
1458 };
1459
1460 /**
1461  * ice_write_tx_drbell_q_ctx
1462  * @hw: pointer to the hardware structure
1463  * @tx_drbell_q_ctx: pointer to the doorbell queue context
1464  * @tx_drbell_q_index: the index of the doorbell queue
1465  *
1466  * Converts doorbell queue context from sparse to dense structure and then
1467  * writes it to HW register space
1468  */
1469 enum ice_status
1470 ice_write_tx_drbell_q_ctx(struct ice_hw *hw,
1471                           struct ice_tx_drbell_q_ctx *tx_drbell_q_ctx,
1472                           u32 tx_drbell_q_index)
1473 {
1474         u8 ctx_buf[ICE_TX_DRBELL_Q_CTX_SIZE_DWORDS * sizeof(u32)] = { 0 };
1475
1476         ice_set_ctx(hw, (u8 *)tx_drbell_q_ctx, ctx_buf,
1477                     ice_tx_drbell_q_ctx_info);
1478         return ice_copy_tx_drbell_q_ctx_to_hw(hw, ctx_buf, tx_drbell_q_index);
1479 }
1480
1481 /**
1482  * ice_clear_tx_drbell_q_ctx
1483  * @hw: pointer to the hardware structure
1484  * @tx_drbell_q_index: the index of the doorbell queue to clear
1485  *
1486  * Clears doorbell queue context in HW register space
1487  */
1488 enum ice_status
1489 ice_clear_tx_drbell_q_ctx(struct ice_hw *hw, u32 tx_drbell_q_index)
1490 {
1491         u8 i;
1492
1493         if (tx_drbell_q_index > QTX_COMM_DBLQ_DBELL_MAX_INDEX)
1494                 return ICE_ERR_PARAM;
1495
1496         /* Clear each dword register separately */
1497         for (i = 0; i < ICE_TX_DRBELL_Q_CTX_SIZE_DWORDS; i++)
1498                 wr32(hw, QTX_COMM_DBLQ_CNTX(i, tx_drbell_q_index), 0);
1499
1500         return ICE_SUCCESS;
1501 }
1502
1503 /* Sideband Queue command wrappers */
1504
1505 /**
1506  * ice_get_sbq - returns the right control queue to use for sideband
1507  * @hw: pointer to the hardware structure
1508  */
1509 static struct ice_ctl_q_info *ice_get_sbq(struct ice_hw *hw)
1510 {
1511         if (!ice_is_generic_mac(hw))
1512                 return &hw->adminq;
1513         return &hw->sbq;
1514 }
1515
1516 /**
1517  * ice_sbq_send_cmd - send Sideband Queue command to Sideband Queue
1518  * @hw: pointer to the HW struct
1519  * @desc: descriptor describing the command
1520  * @buf: buffer to use for indirect commands (NULL for direct commands)
1521  * @buf_size: size of buffer for indirect commands (0 for direct commands)
1522  * @cd: pointer to command details structure
1523  */
1524 static enum ice_status
1525 ice_sbq_send_cmd(struct ice_hw *hw, struct ice_sbq_cmd_desc *desc,
1526                  void *buf, u16 buf_size, struct ice_sq_cd *cd)
1527 {
1528         return ice_sq_send_cmd(hw, ice_get_sbq(hw), (struct ice_aq_desc *)desc,
1529                                buf, buf_size, cd);
1530 }
1531
1532 /**
1533  * ice_sbq_send_cmd_nolock - send Sideband Queue command to Sideband Queue
1534  *                           but do not lock sq_lock
1535  * @hw: pointer to the HW struct
1536  * @desc: descriptor describing the command
1537  * @buf: buffer to use for indirect commands (NULL for direct commands)
1538  * @buf_size: size of buffer for indirect commands (0 for direct commands)
1539  * @cd: pointer to command details structure
1540  */
1541 static enum ice_status
1542 ice_sbq_send_cmd_nolock(struct ice_hw *hw, struct ice_sbq_cmd_desc *desc,
1543                         void *buf, u16 buf_size, struct ice_sq_cd *cd)
1544 {
1545         return ice_sq_send_cmd_nolock(hw, ice_get_sbq(hw),
1546                                       (struct ice_aq_desc *)desc, buf,
1547                                       buf_size, cd);
1548 }
1549
1550 /**
1551  * ice_sbq_rw_reg_lp - Fill Sideband Queue command, with lock parameter
1552  * @hw: pointer to the HW struct
1553  * @in: message info to be filled in descriptor
1554  * @lock: true to lock the sq_lock (the usual case); false if the sq_lock has
1555  *        already been locked at a higher level
1556  */
1557 enum ice_status ice_sbq_rw_reg_lp(struct ice_hw *hw,
1558                                   struct ice_sbq_msg_input *in, bool lock)
1559 {
1560         struct ice_sbq_cmd_desc desc = {0};
1561         struct ice_sbq_msg_req msg = {0};
1562         enum ice_status status;
1563         u16 msg_len;
1564
1565         msg_len = sizeof(msg);
1566
1567         msg.dest_dev = in->dest_dev;
1568         msg.opcode = in->opcode;
1569         msg.flags = ICE_SBQ_MSG_FLAGS;
1570         msg.sbe_fbe = ICE_SBQ_MSG_SBE_FBE;
1571         msg.msg_addr_low = CPU_TO_LE16(in->msg_addr_low);
1572         msg.msg_addr_high = CPU_TO_LE32(in->msg_addr_high);
1573
1574         if (in->opcode)
1575                 msg.data = CPU_TO_LE32(in->data);
1576         else
1577                 /* data read comes back in completion, so shorten the struct by
1578                  * sizeof(msg.data)
1579                  */
1580                 msg_len -= sizeof(msg.data);
1581
1582         desc.flags = CPU_TO_LE16(ICE_AQ_FLAG_RD);
1583         desc.opcode = CPU_TO_LE16(ice_sbq_opc_neigh_dev_req);
1584         desc.param0.cmd_len = CPU_TO_LE16(msg_len);
1585         if (lock)
1586                 status = ice_sbq_send_cmd(hw, &desc, &msg, msg_len, NULL);
1587         else
1588                 status = ice_sbq_send_cmd_nolock(hw, &desc, &msg, msg_len,
1589                                                  NULL);
1590         if (!status && !in->opcode)
1591                 in->data = LE32_TO_CPU
1592                         (((struct ice_sbq_msg_cmpl *)&msg)->data);
1593         return status;
1594 }
1595
1596 /**
1597  * ice_sbq_rw_reg - Fill Sideband Queue command
1598  * @hw: pointer to the HW struct
1599  * @in: message info to be filled in descriptor
1600  */
1601 enum ice_status ice_sbq_rw_reg(struct ice_hw *hw, struct ice_sbq_msg_input *in)
1602 {
1603         return ice_sbq_rw_reg_lp(hw, in, true);
1604 }
1605
1606 /**
1607  * ice_sbq_lock - Lock the sideband queue's sq_lock
1608  * @hw: pointer to the HW struct
1609  */
1610 void ice_sbq_lock(struct ice_hw *hw)
1611 {
1612         ice_acquire_lock(&ice_get_sbq(hw)->sq_lock);
1613 }
1614
1615 /**
1616  * ice_sbq_unlock - Unlock the sideband queue's sq_lock
1617  * @hw: pointer to the HW struct
1618  */
1619 void ice_sbq_unlock(struct ice_hw *hw)
1620 {
1621         ice_release_lock(&ice_get_sbq(hw)->sq_lock);
1622 }
1623
1624 /* FW Admin Queue command wrappers */
1625
1626 /**
1627  * ice_should_retry_sq_send_cmd
1628  * @opcode: AQ opcode
1629  *
1630  * Decide if we should retry the send command routine for the ATQ, depending
1631  * on the opcode.
1632  */
1633 static bool ice_should_retry_sq_send_cmd(u16 opcode)
1634 {
1635         switch (opcode) {
1636         case ice_aqc_opc_get_link_topo:
1637         case ice_aqc_opc_lldp_stop:
1638         case ice_aqc_opc_lldp_start:
1639         case ice_aqc_opc_lldp_filter_ctrl:
1640                 return true;
1641         }
1642
1643         return false;
1644 }
1645
1646 /**
1647  * ice_sq_send_cmd_retry - send command to Control Queue (ATQ)
1648  * @hw: pointer to the HW struct
1649  * @cq: pointer to the specific Control queue
1650  * @desc: prefilled descriptor describing the command
1651  * @buf: buffer to use for indirect commands (or NULL for direct commands)
1652  * @buf_size: size of buffer for indirect commands (or 0 for direct commands)
1653  * @cd: pointer to command details structure
1654  *
1655  * Retry sending the FW Admin Queue command, multiple times, to the FW Admin
1656  * Queue if the EBUSY AQ error is returned.
1657  */
1658 static enum ice_status
1659 ice_sq_send_cmd_retry(struct ice_hw *hw, struct ice_ctl_q_info *cq,
1660                       struct ice_aq_desc *desc, void *buf, u16 buf_size,
1661                       struct ice_sq_cd *cd)
1662 {
1663         struct ice_aq_desc desc_cpy;
1664         enum ice_status status;
1665         bool is_cmd_for_retry;
1666         u8 *buf_cpy = NULL;
1667         u8 idx = 0;
1668         u16 opcode;
1669
1670         opcode = LE16_TO_CPU(desc->opcode);
1671         is_cmd_for_retry = ice_should_retry_sq_send_cmd(opcode);
1672         ice_memset(&desc_cpy, 0, sizeof(desc_cpy), ICE_NONDMA_MEM);
1673
1674         if (is_cmd_for_retry) {
1675                 if (buf) {
1676                         buf_cpy = (u8 *)ice_malloc(hw, buf_size);
1677                         if (!buf_cpy)
1678                                 return ICE_ERR_NO_MEMORY;
1679                 }
1680
1681                 ice_memcpy(&desc_cpy, desc, sizeof(desc_cpy),
1682                            ICE_NONDMA_TO_NONDMA);
1683         }
1684
1685         do {
1686                 status = ice_sq_send_cmd(hw, cq, desc, buf, buf_size, cd);
1687
1688                 if (!is_cmd_for_retry || status == ICE_SUCCESS ||
1689                     hw->adminq.sq_last_status != ICE_AQ_RC_EBUSY)
1690                         break;
1691
1692                 if (buf_cpy)
1693                         ice_memcpy(buf, buf_cpy, buf_size,
1694                                    ICE_NONDMA_TO_NONDMA);
1695
1696                 ice_memcpy(desc, &desc_cpy, sizeof(desc_cpy),
1697                            ICE_NONDMA_TO_NONDMA);
1698
1699                 ice_msec_delay(ICE_SQ_SEND_DELAY_TIME_MS, false);
1700
1701         } while (++idx < ICE_SQ_SEND_MAX_EXECUTE);
1702
1703         if (buf_cpy)
1704                 ice_free(hw, buf_cpy);
1705
1706         return status;
1707 }
1708
1709 /**
1710  * ice_aq_send_cmd - send FW Admin Queue command to FW Admin Queue
1711  * @hw: pointer to the HW struct
1712  * @desc: descriptor describing the command
1713  * @buf: buffer to use for indirect commands (NULL for direct commands)
1714  * @buf_size: size of buffer for indirect commands (0 for direct commands)
1715  * @cd: pointer to command details structure
1716  *
1717  * Helper function to send FW Admin Queue commands to the FW Admin Queue.
1718  */
1719 enum ice_status
1720 ice_aq_send_cmd(struct ice_hw *hw, struct ice_aq_desc *desc, void *buf,
1721                 u16 buf_size, struct ice_sq_cd *cd)
1722 {
1723         if (hw->aq_send_cmd_fn) {
1724                 enum ice_status status = ICE_ERR_NOT_READY;
1725                 u16 retval = ICE_AQ_RC_OK;
1726
1727                 ice_acquire_lock(&hw->adminq.sq_lock);
1728                 if (!hw->aq_send_cmd_fn(hw->aq_send_cmd_param, desc,
1729                                         buf, buf_size)) {
1730                         retval = LE16_TO_CPU(desc->retval);
1731                         /* strip off FW internal code */
1732                         if (retval)
1733                                 retval &= 0xff;
1734                         if (retval == ICE_AQ_RC_OK)
1735                                 status = ICE_SUCCESS;
1736                         else
1737                                 status = ICE_ERR_AQ_ERROR;
1738                 }
1739
1740                 hw->adminq.sq_last_status = (enum ice_aq_err)retval;
1741                 ice_release_lock(&hw->adminq.sq_lock);
1742
1743                 return status;
1744         }
1745         return ice_sq_send_cmd_retry(hw, &hw->adminq, desc, buf, buf_size, cd);
1746 }
1747
1748 /**
1749  * ice_aq_get_fw_ver
1750  * @hw: pointer to the HW struct
1751  * @cd: pointer to command details structure or NULL
1752  *
1753  * Get the firmware version (0x0001) from the admin queue commands
1754  */
1755 enum ice_status ice_aq_get_fw_ver(struct ice_hw *hw, struct ice_sq_cd *cd)
1756 {
1757         struct ice_aqc_get_ver *resp;
1758         struct ice_aq_desc desc;
1759         enum ice_status status;
1760
1761         resp = &desc.params.get_ver;
1762
1763         ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_get_ver);
1764
1765         status = ice_aq_send_cmd(hw, &desc, NULL, 0, cd);
1766
1767         if (!status) {
1768                 hw->fw_branch = resp->fw_branch;
1769                 hw->fw_maj_ver = resp->fw_major;
1770                 hw->fw_min_ver = resp->fw_minor;
1771                 hw->fw_patch = resp->fw_patch;
1772                 hw->fw_build = LE32_TO_CPU(resp->fw_build);
1773                 hw->api_branch = resp->api_branch;
1774                 hw->api_maj_ver = resp->api_major;
1775                 hw->api_min_ver = resp->api_minor;
1776                 hw->api_patch = resp->api_patch;
1777         }
1778
1779         return status;
1780 }
1781
1782 /**
1783  * ice_aq_send_driver_ver
1784  * @hw: pointer to the HW struct
1785  * @dv: driver's major, minor version
1786  * @cd: pointer to command details structure or NULL
1787  *
1788  * Send the driver version (0x0002) to the firmware
1789  */
1790 enum ice_status
1791 ice_aq_send_driver_ver(struct ice_hw *hw, struct ice_driver_ver *dv,
1792                        struct ice_sq_cd *cd)
1793 {
1794         struct ice_aqc_driver_ver *cmd;
1795         struct ice_aq_desc desc;
1796         u16 len;
1797
1798         cmd = &desc.params.driver_ver;
1799
1800         if (!dv)
1801                 return ICE_ERR_PARAM;
1802
1803         ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_driver_ver);
1804
1805         desc.flags |= CPU_TO_LE16(ICE_AQ_FLAG_RD);
1806         cmd->major_ver = dv->major_ver;
1807         cmd->minor_ver = dv->minor_ver;
1808         cmd->build_ver = dv->build_ver;
1809         cmd->subbuild_ver = dv->subbuild_ver;
1810
1811         len = 0;
1812         while (len < sizeof(dv->driver_string) &&
1813                IS_ASCII(dv->driver_string[len]) && dv->driver_string[len])
1814                 len++;
1815
1816         return ice_aq_send_cmd(hw, &desc, dv->driver_string, len, cd);
1817 }
1818
1819 /**
1820  * ice_aq_q_shutdown
1821  * @hw: pointer to the HW struct
1822  * @unloading: is the driver unloading itself
1823  *
1824  * Tell the Firmware that we're shutting down the AdminQ and whether
1825  * or not the driver is unloading as well (0x0003).
1826  */
1827 enum ice_status ice_aq_q_shutdown(struct ice_hw *hw, bool unloading)
1828 {
1829         struct ice_aqc_q_shutdown *cmd;
1830         struct ice_aq_desc desc;
1831
1832         cmd = &desc.params.q_shutdown;
1833
1834         ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_q_shutdown);
1835
1836         if (unloading)
1837                 cmd->driver_unloading = ICE_AQC_DRIVER_UNLOADING;
1838
1839         return ice_aq_send_cmd(hw, &desc, NULL, 0, NULL);
1840 }
1841
1842 /**
1843  * ice_aq_req_res
1844  * @hw: pointer to the HW struct
1845  * @res: resource ID
1846  * @access: access type
1847  * @sdp_number: resource number
1848  * @timeout: the maximum time in ms that the driver may hold the resource
1849  * @cd: pointer to command details structure or NULL
1850  *
1851  * Requests common resource using the admin queue commands (0x0008).
1852  * When attempting to acquire the Global Config Lock, the driver can
1853  * learn of three states:
1854  *  1) ICE_SUCCESS -        acquired lock, and can perform download package
1855  *  2) ICE_ERR_AQ_ERROR -   did not get lock, driver should fail to load
1856  *  3) ICE_ERR_AQ_NO_WORK - did not get lock, but another driver has
1857  *                          successfully downloaded the package; the driver does
1858  *                          not have to download the package and can continue
1859  *                          loading
1860  *
1861  * Note that if the caller is in an acquire lock, perform action, release lock
1862  * phase of operation, it is possible that the FW may detect a timeout and issue
1863  * a CORER. In this case, the driver will receive a CORER interrupt and will
1864  * have to determine its cause. The calling thread that is handling this flow
1865  * will likely get an error propagated back to it indicating the Download
1866  * Package, Update Package or the Release Resource AQ commands timed out.
1867  */
1868 static enum ice_status
1869 ice_aq_req_res(struct ice_hw *hw, enum ice_aq_res_ids res,
1870                enum ice_aq_res_access_type access, u8 sdp_number, u32 *timeout,
1871                struct ice_sq_cd *cd)
1872 {
1873         struct ice_aqc_req_res *cmd_resp;
1874         struct ice_aq_desc desc;
1875         enum ice_status status;
1876
1877         ice_debug(hw, ICE_DBG_TRACE, "%s\n", __func__);
1878
1879         cmd_resp = &desc.params.res_owner;
1880
1881         ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_req_res);
1882
1883         cmd_resp->res_id = CPU_TO_LE16(res);
1884         cmd_resp->access_type = CPU_TO_LE16(access);
1885         cmd_resp->res_number = CPU_TO_LE32(sdp_number);
1886         cmd_resp->timeout = CPU_TO_LE32(*timeout);
1887         *timeout = 0;
1888
1889         status = ice_aq_send_cmd(hw, &desc, NULL, 0, cd);
1890
1891         /* The completion specifies the maximum time in ms that the driver
1892          * may hold the resource in the Timeout field.
1893          */
1894
1895         /* Global config lock response utilizes an additional status field.
1896          *
1897          * If the Global config lock resource is held by some other driver, the
1898          * command completes with ICE_AQ_RES_GLBL_IN_PROG in the status field
1899          * and the timeout field indicates the maximum time the current owner
1900          * of the resource has to free it.
1901          */
1902         if (res == ICE_GLOBAL_CFG_LOCK_RES_ID) {
1903                 if (LE16_TO_CPU(cmd_resp->status) == ICE_AQ_RES_GLBL_SUCCESS) {
1904                         *timeout = LE32_TO_CPU(cmd_resp->timeout);
1905                         return ICE_SUCCESS;
1906                 } else if (LE16_TO_CPU(cmd_resp->status) ==
1907                            ICE_AQ_RES_GLBL_IN_PROG) {
1908                         *timeout = LE32_TO_CPU(cmd_resp->timeout);
1909                         return ICE_ERR_AQ_ERROR;
1910                 } else if (LE16_TO_CPU(cmd_resp->status) ==
1911                            ICE_AQ_RES_GLBL_DONE) {
1912                         return ICE_ERR_AQ_NO_WORK;
1913                 }
1914
1915                 /* invalid FW response, force a timeout immediately */
1916                 *timeout = 0;
1917                 return ICE_ERR_AQ_ERROR;
1918         }
1919
1920         /* If the resource is held by some other driver, the command completes
1921          * with a busy return value and the timeout field indicates the maximum
1922          * time the current owner of the resource has to free it.
1923          */
1924         if (!status || hw->adminq.sq_last_status == ICE_AQ_RC_EBUSY)
1925                 *timeout = LE32_TO_CPU(cmd_resp->timeout);
1926
1927         return status;
1928 }
1929
1930 /**
1931  * ice_aq_release_res
1932  * @hw: pointer to the HW struct
1933  * @res: resource ID
1934  * @sdp_number: resource number
1935  * @cd: pointer to command details structure or NULL
1936  *
1937  * release common resource using the admin queue commands (0x0009)
1938  */
1939 static enum ice_status
1940 ice_aq_release_res(struct ice_hw *hw, enum ice_aq_res_ids res, u8 sdp_number,
1941                    struct ice_sq_cd *cd)
1942 {
1943         struct ice_aqc_req_res *cmd;
1944         struct ice_aq_desc desc;
1945
1946         ice_debug(hw, ICE_DBG_TRACE, "%s\n", __func__);
1947
1948         cmd = &desc.params.res_owner;
1949
1950         ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_release_res);
1951
1952         cmd->res_id = CPU_TO_LE16(res);
1953         cmd->res_number = CPU_TO_LE32(sdp_number);
1954
1955         return ice_aq_send_cmd(hw, &desc, NULL, 0, cd);
1956 }
1957
1958 /**
1959  * ice_acquire_res
1960  * @hw: pointer to the HW structure
1961  * @res: resource ID
1962  * @access: access type (read or write)
1963  * @timeout: timeout in milliseconds
1964  *
1965  * This function will attempt to acquire the ownership of a resource.
1966  */
1967 enum ice_status
1968 ice_acquire_res(struct ice_hw *hw, enum ice_aq_res_ids res,
1969                 enum ice_aq_res_access_type access, u32 timeout)
1970 {
1971 #define ICE_RES_POLLING_DELAY_MS        10
1972         u32 delay = ICE_RES_POLLING_DELAY_MS;
1973         u32 time_left = timeout;
1974         enum ice_status status;
1975
1976         ice_debug(hw, ICE_DBG_TRACE, "%s\n", __func__);
1977
1978         status = ice_aq_req_res(hw, res, access, 0, &time_left, NULL);
1979
1980         /* A return code of ICE_ERR_AQ_NO_WORK means that another driver has
1981          * previously acquired the resource and performed any necessary updates;
1982          * in this case the caller does not obtain the resource and has no
1983          * further work to do.
1984          */
1985         if (status == ICE_ERR_AQ_NO_WORK)
1986                 goto ice_acquire_res_exit;
1987
1988         if (status)
1989                 ice_debug(hw, ICE_DBG_RES, "resource %d acquire type %d failed.\n", res, access);
1990
1991         /* If necessary, poll until the current lock owner timeouts */
1992         timeout = time_left;
1993         while (status && timeout && time_left) {
1994                 ice_msec_delay(delay, true);
1995                 timeout = (timeout > delay) ? timeout - delay : 0;
1996                 status = ice_aq_req_res(hw, res, access, 0, &time_left, NULL);
1997
1998                 if (status == ICE_ERR_AQ_NO_WORK)
1999                         /* lock free, but no work to do */
2000                         break;
2001
2002                 if (!status)
2003                         /* lock acquired */
2004                         break;
2005         }
2006         if (status && status != ICE_ERR_AQ_NO_WORK)
2007                 ice_debug(hw, ICE_DBG_RES, "resource acquire timed out.\n");
2008
2009 ice_acquire_res_exit:
2010         if (status == ICE_ERR_AQ_NO_WORK) {
2011                 if (access == ICE_RES_WRITE)
2012                         ice_debug(hw, ICE_DBG_RES, "resource indicates no work to do.\n");
2013                 else
2014                         ice_debug(hw, ICE_DBG_RES, "Warning: ICE_ERR_AQ_NO_WORK not expected\n");
2015         }
2016         return status;
2017 }
2018
2019 /**
2020  * ice_release_res
2021  * @hw: pointer to the HW structure
2022  * @res: resource ID
2023  *
2024  * This function will release a resource using the proper Admin Command.
2025  */
2026 void ice_release_res(struct ice_hw *hw, enum ice_aq_res_ids res)
2027 {
2028         enum ice_status status;
2029         u32 total_delay = 0;
2030
2031         ice_debug(hw, ICE_DBG_TRACE, "%s\n", __func__);
2032
2033         status = ice_aq_release_res(hw, res, 0, NULL);
2034
2035         /* there are some rare cases when trying to release the resource
2036          * results in an admin queue timeout, so handle them correctly
2037          */
2038         while ((status == ICE_ERR_AQ_TIMEOUT) &&
2039                (total_delay < hw->adminq.sq_cmd_timeout)) {
2040                 ice_msec_delay(1, true);
2041                 status = ice_aq_release_res(hw, res, 0, NULL);
2042                 total_delay++;
2043         }
2044 }
2045
2046 /**
2047  * ice_aq_alloc_free_res - command to allocate/free resources
2048  * @hw: pointer to the HW struct
2049  * @num_entries: number of resource entries in buffer
2050  * @buf: Indirect buffer to hold data parameters and response
2051  * @buf_size: size of buffer for indirect commands
2052  * @opc: pass in the command opcode
2053  * @cd: pointer to command details structure or NULL
2054  *
2055  * Helper function to allocate/free resources using the admin queue commands
2056  */
2057 enum ice_status
2058 ice_aq_alloc_free_res(struct ice_hw *hw, u16 num_entries,
2059                       struct ice_aqc_alloc_free_res_elem *buf, u16 buf_size,
2060                       enum ice_adminq_opc opc, struct ice_sq_cd *cd)
2061 {
2062         struct ice_aqc_alloc_free_res_cmd *cmd;
2063         struct ice_aq_desc desc;
2064
2065         ice_debug(hw, ICE_DBG_TRACE, "%s\n", __func__);
2066
2067         cmd = &desc.params.sw_res_ctrl;
2068
2069         if (!buf)
2070                 return ICE_ERR_PARAM;
2071
2072         if (buf_size < FLEX_ARRAY_SIZE(buf, elem, num_entries))
2073                 return ICE_ERR_PARAM;
2074
2075         ice_fill_dflt_direct_cmd_desc(&desc, opc);
2076
2077         desc.flags |= CPU_TO_LE16(ICE_AQ_FLAG_RD);
2078
2079         cmd->num_entries = CPU_TO_LE16(num_entries);
2080
2081         return ice_aq_send_cmd(hw, &desc, buf, buf_size, cd);
2082 }
2083
2084 /**
2085  * ice_alloc_hw_res - allocate resource
2086  * @hw: pointer to the HW struct
2087  * @type: type of resource
2088  * @num: number of resources to allocate
2089  * @btm: allocate from bottom
2090  * @res: pointer to array that will receive the resources
2091  */
2092 enum ice_status
2093 ice_alloc_hw_res(struct ice_hw *hw, u16 type, u16 num, bool btm, u16 *res)
2094 {
2095         struct ice_aqc_alloc_free_res_elem *buf;
2096         enum ice_status status;
2097         u16 buf_len;
2098
2099         buf_len = ice_struct_size(buf, elem, num);
2100         buf = (struct ice_aqc_alloc_free_res_elem *)ice_malloc(hw, buf_len);
2101         if (!buf)
2102                 return ICE_ERR_NO_MEMORY;
2103
2104         /* Prepare buffer to allocate resource. */
2105         buf->num_elems = CPU_TO_LE16(num);
2106         buf->res_type = CPU_TO_LE16(type | ICE_AQC_RES_TYPE_FLAG_DEDICATED |
2107                                     ICE_AQC_RES_TYPE_FLAG_IGNORE_INDEX);
2108         if (btm)
2109                 buf->res_type |= CPU_TO_LE16(ICE_AQC_RES_TYPE_FLAG_SCAN_BOTTOM);
2110
2111         status = ice_aq_alloc_free_res(hw, 1, buf, buf_len,
2112                                        ice_aqc_opc_alloc_res, NULL);
2113         if (status)
2114                 goto ice_alloc_res_exit;
2115
2116         ice_memcpy(res, buf->elem, sizeof(*buf->elem) * num,
2117                    ICE_NONDMA_TO_NONDMA);
2118
2119 ice_alloc_res_exit:
2120         ice_free(hw, buf);
2121         return status;
2122 }
2123
2124 /**
2125  * ice_free_hw_res - free allocated HW resource
2126  * @hw: pointer to the HW struct
2127  * @type: type of resource to free
2128  * @num: number of resources
2129  * @res: pointer to array that contains the resources to free
2130  */
2131 enum ice_status ice_free_hw_res(struct ice_hw *hw, u16 type, u16 num, u16 *res)
2132 {
2133         struct ice_aqc_alloc_free_res_elem *buf;
2134         enum ice_status status;
2135         u16 buf_len;
2136
2137         buf_len = ice_struct_size(buf, elem, num);
2138         buf = (struct ice_aqc_alloc_free_res_elem *)ice_malloc(hw, buf_len);
2139         if (!buf)
2140                 return ICE_ERR_NO_MEMORY;
2141
2142         /* Prepare buffer to free resource. */
2143         buf->num_elems = CPU_TO_LE16(num);
2144         buf->res_type = CPU_TO_LE16(type);
2145         ice_memcpy(buf->elem, res, sizeof(*buf->elem) * num,
2146                    ICE_NONDMA_TO_NONDMA);
2147
2148         status = ice_aq_alloc_free_res(hw, num, buf, buf_len,
2149                                        ice_aqc_opc_free_res, NULL);
2150         if (status)
2151                 ice_debug(hw, ICE_DBG_SW, "CQ CMD Buffer:\n");
2152
2153         ice_free(hw, buf);
2154         return status;
2155 }
2156
2157 /**
2158  * ice_get_num_per_func - determine number of resources per PF
2159  * @hw: pointer to the HW structure
2160  * @max: value to be evenly split between each PF
2161  *
2162  * Determine the number of valid functions by going through the bitmap returned
2163  * from parsing capabilities and use this to calculate the number of resources
2164  * per PF based on the max value passed in.
2165  */
2166 static u32 ice_get_num_per_func(struct ice_hw *hw, u32 max)
2167 {
2168         u8 funcs;
2169
2170 #define ICE_CAPS_VALID_FUNCS_M  0xFF
2171         funcs = ice_hweight8(hw->dev_caps.common_cap.valid_functions &
2172                              ICE_CAPS_VALID_FUNCS_M);
2173
2174         if (!funcs)
2175                 return 0;
2176
2177         return max / funcs;
2178 }
2179
2180 /**
2181  * ice_parse_common_caps - parse common device/function capabilities
2182  * @hw: pointer to the HW struct
2183  * @caps: pointer to common capabilities structure
2184  * @elem: the capability element to parse
2185  * @prefix: message prefix for tracing capabilities
2186  *
2187  * Given a capability element, extract relevant details into the common
2188  * capability structure.
2189  *
2190  * Returns: true if the capability matches one of the common capability ids,
2191  * false otherwise.
2192  */
2193 static bool
2194 ice_parse_common_caps(struct ice_hw *hw, struct ice_hw_common_caps *caps,
2195                       struct ice_aqc_list_caps_elem *elem, const char *prefix)
2196 {
2197         u32 logical_id = LE32_TO_CPU(elem->logical_id);
2198         u32 phys_id = LE32_TO_CPU(elem->phys_id);
2199         u32 number = LE32_TO_CPU(elem->number);
2200         u16 cap = LE16_TO_CPU(elem->cap);
2201         bool found = true;
2202
2203         switch (cap) {
2204         case ICE_AQC_CAPS_VALID_FUNCTIONS:
2205                 caps->valid_functions = number;
2206                 ice_debug(hw, ICE_DBG_INIT, "%s: valid_functions (bitmap) = %d\n", prefix,
2207                           caps->valid_functions);
2208                 break;
2209         case ICE_AQC_CAPS_DCB:
2210                 caps->dcb = (number == 1);
2211                 caps->active_tc_bitmap = logical_id;
2212                 caps->maxtc = phys_id;
2213                 ice_debug(hw, ICE_DBG_INIT, "%s: dcb = %d\n", prefix, caps->dcb);
2214                 ice_debug(hw, ICE_DBG_INIT, "%s: active_tc_bitmap = %d\n", prefix,
2215                           caps->active_tc_bitmap);
2216                 ice_debug(hw, ICE_DBG_INIT, "%s: maxtc = %d\n", prefix, caps->maxtc);
2217                 break;
2218         case ICE_AQC_CAPS_RSS:
2219                 caps->rss_table_size = number;
2220                 caps->rss_table_entry_width = logical_id;
2221                 ice_debug(hw, ICE_DBG_INIT, "%s: rss_table_size = %d\n", prefix,
2222                           caps->rss_table_size);
2223                 ice_debug(hw, ICE_DBG_INIT, "%s: rss_table_entry_width = %d\n", prefix,
2224                           caps->rss_table_entry_width);
2225                 break;
2226         case ICE_AQC_CAPS_RXQS:
2227                 caps->num_rxq = number;
2228                 caps->rxq_first_id = phys_id;
2229                 ice_debug(hw, ICE_DBG_INIT, "%s: num_rxq = %d\n", prefix,
2230                           caps->num_rxq);
2231                 ice_debug(hw, ICE_DBG_INIT, "%s: rxq_first_id = %d\n", prefix,
2232                           caps->rxq_first_id);
2233                 break;
2234         case ICE_AQC_CAPS_TXQS:
2235                 caps->num_txq = number;
2236                 caps->txq_first_id = phys_id;
2237                 ice_debug(hw, ICE_DBG_INIT, "%s: num_txq = %d\n", prefix,
2238                           caps->num_txq);
2239                 ice_debug(hw, ICE_DBG_INIT, "%s: txq_first_id = %d\n", prefix,
2240                           caps->txq_first_id);
2241                 break;
2242         case ICE_AQC_CAPS_MSIX:
2243                 caps->num_msix_vectors = number;
2244                 caps->msix_vector_first_id = phys_id;
2245                 ice_debug(hw, ICE_DBG_INIT, "%s: num_msix_vectors = %d\n", prefix,
2246                           caps->num_msix_vectors);
2247                 ice_debug(hw, ICE_DBG_INIT, "%s: msix_vector_first_id = %d\n", prefix,
2248                           caps->msix_vector_first_id);
2249                 break;
2250         case ICE_AQC_CAPS_NVM_MGMT:
2251                 caps->sec_rev_disabled =
2252                         (number & ICE_NVM_MGMT_SEC_REV_DISABLED) ?
2253                         true : false;
2254                 ice_debug(hw, ICE_DBG_INIT, "%s: sec_rev_disabled = %d\n", prefix,
2255                           caps->sec_rev_disabled);
2256                 caps->update_disabled =
2257                         (number & ICE_NVM_MGMT_UPDATE_DISABLED) ?
2258                         true : false;
2259                 ice_debug(hw, ICE_DBG_INIT, "%s: update_disabled = %d\n", prefix,
2260                           caps->update_disabled);
2261                 caps->nvm_unified_update =
2262                         (number & ICE_NVM_MGMT_UNIFIED_UPD_SUPPORT) ?
2263                         true : false;
2264                 ice_debug(hw, ICE_DBG_INIT, "%s: nvm_unified_update = %d\n", prefix,
2265                           caps->nvm_unified_update);
2266                 break;
2267         case ICE_AQC_CAPS_MAX_MTU:
2268                 caps->max_mtu = number;
2269                 ice_debug(hw, ICE_DBG_INIT, "%s: max_mtu = %d\n",
2270                           prefix, caps->max_mtu);
2271                 break;
2272         case ICE_AQC_CAPS_EXT_TOPO_DEV_IMG0:
2273         case ICE_AQC_CAPS_EXT_TOPO_DEV_IMG1:
2274         case ICE_AQC_CAPS_EXT_TOPO_DEV_IMG2:
2275         case ICE_AQC_CAPS_EXT_TOPO_DEV_IMG3:
2276         {
2277                 u8 index = cap - ICE_AQC_CAPS_EXT_TOPO_DEV_IMG0;
2278
2279                 caps->ext_topo_dev_img_ver_high[index] = number;
2280                 caps->ext_topo_dev_img_ver_low[index] = logical_id;
2281                 caps->ext_topo_dev_img_part_num[index] =
2282                         (phys_id & ICE_EXT_TOPO_DEV_IMG_PART_NUM_M) >>
2283                         ICE_EXT_TOPO_DEV_IMG_PART_NUM_S;
2284                 caps->ext_topo_dev_img_load_en[index] =
2285                         (phys_id & ICE_EXT_TOPO_DEV_IMG_LOAD_EN) != 0;
2286                 caps->ext_topo_dev_img_prog_en[index] =
2287                         (phys_id & ICE_EXT_TOPO_DEV_IMG_PROG_EN) != 0;
2288                 ice_debug(hw, ICE_DBG_INIT,
2289                           "%s: ext_topo_dev_img_ver_high[%d] = %d\n",
2290                           prefix, index,
2291                           caps->ext_topo_dev_img_ver_high[index]);
2292                 ice_debug(hw, ICE_DBG_INIT,
2293                           "%s: ext_topo_dev_img_ver_low[%d] = %d\n",
2294                           prefix, index,
2295                           caps->ext_topo_dev_img_ver_low[index]);
2296                 ice_debug(hw, ICE_DBG_INIT,
2297                           "%s: ext_topo_dev_img_part_num[%d] = %d\n",
2298                           prefix, index,
2299                           caps->ext_topo_dev_img_part_num[index]);
2300                 ice_debug(hw, ICE_DBG_INIT,
2301                           "%s: ext_topo_dev_img_load_en[%d] = %d\n",
2302                           prefix, index,
2303                           caps->ext_topo_dev_img_load_en[index]);
2304                 ice_debug(hw, ICE_DBG_INIT,
2305                           "%s: ext_topo_dev_img_prog_en[%d] = %d\n",
2306                           prefix, index,
2307                           caps->ext_topo_dev_img_prog_en[index]);
2308                 break;
2309         }
2310         default:
2311                 /* Not one of the recognized common capabilities */
2312                 found = false;
2313         }
2314
2315         return found;
2316 }
2317
2318 /**
2319  * ice_recalc_port_limited_caps - Recalculate port limited capabilities
2320  * @hw: pointer to the HW structure
2321  * @caps: pointer to capabilities structure to fix
2322  *
2323  * Re-calculate the capabilities that are dependent on the number of physical
2324  * ports; i.e. some features are not supported or function differently on
2325  * devices with more than 4 ports.
2326  */
2327 static void
2328 ice_recalc_port_limited_caps(struct ice_hw *hw, struct ice_hw_common_caps *caps)
2329 {
2330         /* This assumes device capabilities are always scanned before function
2331          * capabilities during the initialization flow.
2332          */
2333         if (hw->dev_caps.num_funcs > 4) {
2334                 /* Max 4 TCs per port */
2335                 caps->maxtc = 4;
2336                 ice_debug(hw, ICE_DBG_INIT, "reducing maxtc to %d (based on #ports)\n",
2337                           caps->maxtc);
2338         }
2339 }
2340
2341 /**
2342  * ice_parse_vsi_func_caps - Parse ICE_AQC_CAPS_VSI function caps
2343  * @hw: pointer to the HW struct
2344  * @func_p: pointer to function capabilities structure
2345  * @cap: pointer to the capability element to parse
2346  *
2347  * Extract function capabilities for ICE_AQC_CAPS_VSI.
2348  */
2349 static void
2350 ice_parse_vsi_func_caps(struct ice_hw *hw, struct ice_hw_func_caps *func_p,
2351                         struct ice_aqc_list_caps_elem *cap)
2352 {
2353         func_p->guar_num_vsi = ice_get_num_per_func(hw, ICE_MAX_VSI);
2354         ice_debug(hw, ICE_DBG_INIT, "func caps: guar_num_vsi (fw) = %d\n",
2355                   LE32_TO_CPU(cap->number));
2356         ice_debug(hw, ICE_DBG_INIT, "func caps: guar_num_vsi = %d\n",
2357                   func_p->guar_num_vsi);
2358 }
2359
2360 /**
2361  * ice_parse_1588_func_caps - Parse ICE_AQC_CAPS_1588 function caps
2362  * @hw: pointer to the HW struct
2363  * @func_p: pointer to function capabilities structure
2364  * @cap: pointer to the capability element to parse
2365  *
2366  * Extract function capabilities for ICE_AQC_CAPS_1588.
2367  */
2368 static void
2369 ice_parse_1588_func_caps(struct ice_hw *hw, struct ice_hw_func_caps *func_p,
2370                          struct ice_aqc_list_caps_elem *cap)
2371 {
2372         struct ice_ts_func_info *info = &func_p->ts_func_info;
2373         u32 number = LE32_TO_CPU(cap->number);
2374
2375         info->ena = ((number & ICE_TS_FUNC_ENA_M) != 0);
2376         func_p->common_cap.ieee_1588 = info->ena;
2377
2378         info->src_tmr_owned = ((number & ICE_TS_SRC_TMR_OWND_M) != 0);
2379         info->tmr_ena = ((number & ICE_TS_TMR_ENA_M) != 0);
2380         info->tmr_index_owned = ((number & ICE_TS_TMR_IDX_OWND_M) != 0);
2381         info->tmr_index_assoc = ((number & ICE_TS_TMR_IDX_ASSOC_M) != 0);
2382
2383         info->clk_freq = (number & ICE_TS_CLK_FREQ_M) >> ICE_TS_CLK_FREQ_S;
2384         info->clk_src = ((number & ICE_TS_CLK_SRC_M) != 0);
2385
2386         if (info->clk_freq < NUM_ICE_TIME_REF_FREQ) {
2387                 info->time_ref = (enum ice_time_ref_freq)info->clk_freq;
2388         } else {
2389                 /* Unknown clock frequency, so assume a (probably incorrect)
2390                  * default to avoid out-of-bounds look ups of frequency
2391                  * related information.
2392                  */
2393                 ice_debug(hw, ICE_DBG_INIT, "1588 func caps: unknown clock frequency %u\n",
2394                           info->clk_freq);
2395                 info->time_ref = ICE_TIME_REF_FREQ_25_000;
2396         }
2397
2398         ice_debug(hw, ICE_DBG_INIT, "func caps: ieee_1588 = %u\n",
2399                   func_p->common_cap.ieee_1588);
2400         ice_debug(hw, ICE_DBG_INIT, "func caps: src_tmr_owned = %u\n",
2401                   info->src_tmr_owned);
2402         ice_debug(hw, ICE_DBG_INIT, "func caps: tmr_ena = %u\n",
2403                   info->tmr_ena);
2404         ice_debug(hw, ICE_DBG_INIT, "func caps: tmr_index_owned = %u\n",
2405                   info->tmr_index_owned);
2406         ice_debug(hw, ICE_DBG_INIT, "func caps: tmr_index_assoc = %u\n",
2407                   info->tmr_index_assoc);
2408         ice_debug(hw, ICE_DBG_INIT, "func caps: clk_freq = %u\n",
2409                   info->clk_freq);
2410         ice_debug(hw, ICE_DBG_INIT, "func caps: clk_src = %u\n",
2411                   info->clk_src);
2412 }
2413
2414 /**
2415  * ice_parse_fdir_func_caps - Parse ICE_AQC_CAPS_FD function caps
2416  * @hw: pointer to the HW struct
2417  * @func_p: pointer to function capabilities structure
2418  *
2419  * Extract function capabilities for ICE_AQC_CAPS_FD.
2420  */
2421 static void
2422 ice_parse_fdir_func_caps(struct ice_hw *hw, struct ice_hw_func_caps *func_p)
2423 {
2424         u32 reg_val, val;
2425
2426         if (hw->dcf_enabled)
2427                 return;
2428         reg_val = rd32(hw, GLQF_FD_SIZE);
2429         val = (reg_val & GLQF_FD_SIZE_FD_GSIZE_M) >>
2430                 GLQF_FD_SIZE_FD_GSIZE_S;
2431         func_p->fd_fltr_guar =
2432                 ice_get_num_per_func(hw, val);
2433         val = (reg_val & GLQF_FD_SIZE_FD_BSIZE_M) >>
2434                 GLQF_FD_SIZE_FD_BSIZE_S;
2435         func_p->fd_fltr_best_effort = val;
2436
2437         ice_debug(hw, ICE_DBG_INIT, "func caps: fd_fltr_guar = %d\n",
2438                   func_p->fd_fltr_guar);
2439         ice_debug(hw, ICE_DBG_INIT, "func caps: fd_fltr_best_effort = %d\n",
2440                   func_p->fd_fltr_best_effort);
2441 }
2442
2443 /**
2444  * ice_parse_func_caps - Parse function capabilities
2445  * @hw: pointer to the HW struct
2446  * @func_p: pointer to function capabilities structure
2447  * @buf: buffer containing the function capability records
2448  * @cap_count: the number of capabilities
2449  *
2450  * Helper function to parse function (0x000A) capabilities list. For
2451  * capabilities shared between device and function, this relies on
2452  * ice_parse_common_caps.
2453  *
2454  * Loop through the list of provided capabilities and extract the relevant
2455  * data into the function capabilities structured.
2456  */
2457 static void
2458 ice_parse_func_caps(struct ice_hw *hw, struct ice_hw_func_caps *func_p,
2459                     void *buf, u32 cap_count)
2460 {
2461         struct ice_aqc_list_caps_elem *cap_resp;
2462         u32 i;
2463
2464         cap_resp = (struct ice_aqc_list_caps_elem *)buf;
2465
2466         ice_memset(func_p, 0, sizeof(*func_p), ICE_NONDMA_MEM);
2467
2468         for (i = 0; i < cap_count; i++) {
2469                 u16 cap = LE16_TO_CPU(cap_resp[i].cap);
2470                 bool found;
2471
2472                 found = ice_parse_common_caps(hw, &func_p->common_cap,
2473                                               &cap_resp[i], "func caps");
2474
2475                 switch (cap) {
2476                 case ICE_AQC_CAPS_VSI:
2477                         ice_parse_vsi_func_caps(hw, func_p, &cap_resp[i]);
2478                         break;
2479                 case ICE_AQC_CAPS_1588:
2480                         ice_parse_1588_func_caps(hw, func_p, &cap_resp[i]);
2481                         break;
2482                 case ICE_AQC_CAPS_FD:
2483                         ice_parse_fdir_func_caps(hw, func_p);
2484                         break;
2485                 default:
2486                         /* Don't list common capabilities as unknown */
2487                         if (!found)
2488                                 ice_debug(hw, ICE_DBG_INIT, "func caps: unknown capability[%d]: 0x%x\n",
2489                                           i, cap);
2490                         break;
2491                 }
2492         }
2493
2494         ice_recalc_port_limited_caps(hw, &func_p->common_cap);
2495 }
2496
2497 /**
2498  * ice_parse_valid_functions_cap - Parse ICE_AQC_CAPS_VALID_FUNCTIONS caps
2499  * @hw: pointer to the HW struct
2500  * @dev_p: pointer to device capabilities structure
2501  * @cap: capability element to parse
2502  *
2503  * Parse ICE_AQC_CAPS_VALID_FUNCTIONS for device capabilities.
2504  */
2505 static void
2506 ice_parse_valid_functions_cap(struct ice_hw *hw, struct ice_hw_dev_caps *dev_p,
2507                               struct ice_aqc_list_caps_elem *cap)
2508 {
2509         u32 number = LE32_TO_CPU(cap->number);
2510
2511         dev_p->num_funcs = ice_hweight32(number);
2512         ice_debug(hw, ICE_DBG_INIT, "dev caps: num_funcs = %d\n",
2513                   dev_p->num_funcs);
2514 }
2515
2516 /**
2517  * ice_parse_vsi_dev_caps - Parse ICE_AQC_CAPS_VSI device caps
2518  * @hw: pointer to the HW struct
2519  * @dev_p: pointer to device capabilities structure
2520  * @cap: capability element to parse
2521  *
2522  * Parse ICE_AQC_CAPS_VSI for device capabilities.
2523  */
2524 static void
2525 ice_parse_vsi_dev_caps(struct ice_hw *hw, struct ice_hw_dev_caps *dev_p,
2526                        struct ice_aqc_list_caps_elem *cap)
2527 {
2528         u32 number = LE32_TO_CPU(cap->number);
2529
2530         dev_p->num_vsi_allocd_to_host = number;
2531         ice_debug(hw, ICE_DBG_INIT, "dev caps: num_vsi_allocd_to_host = %d\n",
2532                   dev_p->num_vsi_allocd_to_host);
2533 }
2534
2535 /**
2536  * ice_parse_1588_dev_caps - Parse ICE_AQC_CAPS_1588 device caps
2537  * @hw: pointer to the HW struct
2538  * @dev_p: pointer to device capabilities structure
2539  * @cap: capability element to parse
2540  *
2541  * Parse ICE_AQC_CAPS_1588 for device capabilities.
2542  */
2543 static void
2544 ice_parse_1588_dev_caps(struct ice_hw *hw, struct ice_hw_dev_caps *dev_p,
2545                         struct ice_aqc_list_caps_elem *cap)
2546 {
2547         struct ice_ts_dev_info *info = &dev_p->ts_dev_info;
2548         u32 logical_id = LE32_TO_CPU(cap->logical_id);
2549         u32 phys_id = LE32_TO_CPU(cap->phys_id);
2550         u32 number = LE32_TO_CPU(cap->number);
2551
2552         info->ena = ((number & ICE_TS_DEV_ENA_M) != 0);
2553         dev_p->common_cap.ieee_1588 = info->ena;
2554
2555         info->tmr0_owner = number & ICE_TS_TMR0_OWNR_M;
2556         info->tmr0_owned = ((number & ICE_TS_TMR0_OWND_M) != 0);
2557         info->tmr0_ena = ((number & ICE_TS_TMR0_ENA_M) != 0);
2558
2559         info->tmr1_owner = (number & ICE_TS_TMR1_OWNR_M) >> ICE_TS_TMR1_OWNR_S;
2560         info->tmr1_owned = ((number & ICE_TS_TMR1_OWND_M) != 0);
2561         info->tmr1_ena = ((number & ICE_TS_TMR1_ENA_M) != 0);
2562
2563         info->ena_ports = logical_id;
2564         info->tmr_own_map = phys_id;
2565
2566         ice_debug(hw, ICE_DBG_INIT, "dev caps: ieee_1588 = %u\n",
2567                   dev_p->common_cap.ieee_1588);
2568         ice_debug(hw, ICE_DBG_INIT, "dev caps: tmr0_owner = %u\n",
2569                   info->tmr0_owner);
2570         ice_debug(hw, ICE_DBG_INIT, "dev caps: tmr0_owned = %u\n",
2571                   info->tmr0_owned);
2572         ice_debug(hw, ICE_DBG_INIT, "dev caps: tmr0_ena = %u\n",
2573                   info->tmr0_ena);
2574         ice_debug(hw, ICE_DBG_INIT, "dev caps: tmr1_owner = %u\n",
2575                   info->tmr1_owner);
2576         ice_debug(hw, ICE_DBG_INIT, "dev caps: tmr1_owned = %u\n",
2577                   info->tmr1_owned);
2578         ice_debug(hw, ICE_DBG_INIT, "dev caps: tmr1_ena = %u\n",
2579                   info->tmr1_ena);
2580         ice_debug(hw, ICE_DBG_INIT, "dev caps: ieee_1588 ena_ports = %u\n",
2581                   info->ena_ports);
2582         ice_debug(hw, ICE_DBG_INIT, "dev caps: tmr_own_map = %u\n",
2583                   info->tmr_own_map);
2584 }
2585
2586 /**
2587  * ice_parse_fdir_dev_caps - Parse ICE_AQC_CAPS_FD device caps
2588  * @hw: pointer to the HW struct
2589  * @dev_p: pointer to device capabilities structure
2590  * @cap: capability element to parse
2591  *
2592  * Parse ICE_AQC_CAPS_FD for device capabilities.
2593  */
2594 static void
2595 ice_parse_fdir_dev_caps(struct ice_hw *hw, struct ice_hw_dev_caps *dev_p,
2596                         struct ice_aqc_list_caps_elem *cap)
2597 {
2598         u32 number = LE32_TO_CPU(cap->number);
2599
2600         dev_p->num_flow_director_fltr = number;
2601         ice_debug(hw, ICE_DBG_INIT, "dev caps: num_flow_director_fltr = %d\n",
2602                   dev_p->num_flow_director_fltr);
2603 }
2604
2605 /**
2606  * ice_parse_dev_caps - Parse device capabilities
2607  * @hw: pointer to the HW struct
2608  * @dev_p: pointer to device capabilities structure
2609  * @buf: buffer containing the device capability records
2610  * @cap_count: the number of capabilities
2611  *
2612  * Helper device to parse device (0x000B) capabilities list. For
2613  * capabilities shared between device and function, this relies on
2614  * ice_parse_common_caps.
2615  *
2616  * Loop through the list of provided capabilities and extract the relevant
2617  * data into the device capabilities structured.
2618  */
2619 static void
2620 ice_parse_dev_caps(struct ice_hw *hw, struct ice_hw_dev_caps *dev_p,
2621                    void *buf, u32 cap_count)
2622 {
2623         struct ice_aqc_list_caps_elem *cap_resp;
2624         u32 i;
2625
2626         cap_resp = (struct ice_aqc_list_caps_elem *)buf;
2627
2628         ice_memset(dev_p, 0, sizeof(*dev_p), ICE_NONDMA_MEM);
2629
2630         for (i = 0; i < cap_count; i++) {
2631                 u16 cap = LE16_TO_CPU(cap_resp[i].cap);
2632                 bool found;
2633
2634                 found = ice_parse_common_caps(hw, &dev_p->common_cap,
2635                                               &cap_resp[i], "dev caps");
2636
2637                 switch (cap) {
2638                 case ICE_AQC_CAPS_VALID_FUNCTIONS:
2639                         ice_parse_valid_functions_cap(hw, dev_p, &cap_resp[i]);
2640                         break;
2641                 case ICE_AQC_CAPS_VSI:
2642                         ice_parse_vsi_dev_caps(hw, dev_p, &cap_resp[i]);
2643                         break;
2644                 case ICE_AQC_CAPS_1588:
2645                         ice_parse_1588_dev_caps(hw, dev_p, &cap_resp[i]);
2646                         break;
2647                 case  ICE_AQC_CAPS_FD:
2648                         ice_parse_fdir_dev_caps(hw, dev_p, &cap_resp[i]);
2649                         break;
2650                 default:
2651                         /* Don't list common capabilities as unknown */
2652                         if (!found)
2653                                 ice_debug(hw, ICE_DBG_INIT, "dev caps: unknown capability[%d]: 0x%x\n",
2654                                           i, cap);
2655                         break;
2656                 }
2657         }
2658
2659         ice_recalc_port_limited_caps(hw, &dev_p->common_cap);
2660 }
2661
2662 /**
2663  * ice_aq_list_caps - query function/device capabilities
2664  * @hw: pointer to the HW struct
2665  * @buf: a buffer to hold the capabilities
2666  * @buf_size: size of the buffer
2667  * @cap_count: if not NULL, set to the number of capabilities reported
2668  * @opc: capabilities type to discover, device or function
2669  * @cd: pointer to command details structure or NULL
2670  *
2671  * Get the function (0x000A) or device (0x000B) capabilities description from
2672  * firmware and store it in the buffer.
2673  *
2674  * If the cap_count pointer is not NULL, then it is set to the number of
2675  * capabilities firmware will report. Note that if the buffer size is too
2676  * small, it is possible the command will return ICE_AQ_ERR_ENOMEM. The
2677  * cap_count will still be updated in this case. It is recommended that the
2678  * buffer size be set to ICE_AQ_MAX_BUF_LEN (the largest possible buffer that
2679  * firmware could return) to avoid this.
2680  */
2681 static enum ice_status
2682 ice_aq_list_caps(struct ice_hw *hw, void *buf, u16 buf_size, u32 *cap_count,
2683                  enum ice_adminq_opc opc, struct ice_sq_cd *cd)
2684 {
2685         struct ice_aqc_list_caps *cmd;
2686         struct ice_aq_desc desc;
2687         enum ice_status status;
2688
2689         cmd = &desc.params.get_cap;
2690
2691         if (opc != ice_aqc_opc_list_func_caps &&
2692             opc != ice_aqc_opc_list_dev_caps)
2693                 return ICE_ERR_PARAM;
2694
2695         ice_fill_dflt_direct_cmd_desc(&desc, opc);
2696         status = ice_aq_send_cmd(hw, &desc, buf, buf_size, cd);
2697
2698         if (cap_count)
2699                 *cap_count = LE32_TO_CPU(cmd->count);
2700
2701         return status;
2702 }
2703
2704 /**
2705  * ice_discover_dev_caps - Read and extract device capabilities
2706  * @hw: pointer to the hardware structure
2707  * @dev_caps: pointer to device capabilities structure
2708  *
2709  * Read the device capabilities and extract them into the dev_caps structure
2710  * for later use.
2711  */
2712 static enum ice_status
2713 ice_discover_dev_caps(struct ice_hw *hw, struct ice_hw_dev_caps *dev_caps)
2714 {
2715         enum ice_status status;
2716         u32 cap_count = 0;
2717         void *cbuf;
2718
2719         cbuf = ice_malloc(hw, ICE_AQ_MAX_BUF_LEN);
2720         if (!cbuf)
2721                 return ICE_ERR_NO_MEMORY;
2722
2723         /* Although the driver doesn't know the number of capabilities the
2724          * device will return, we can simply send a 4KB buffer, the maximum
2725          * possible size that firmware can return.
2726          */
2727         cap_count = ICE_AQ_MAX_BUF_LEN / sizeof(struct ice_aqc_list_caps_elem);
2728
2729         status = ice_aq_list_caps(hw, cbuf, ICE_AQ_MAX_BUF_LEN, &cap_count,
2730                                   ice_aqc_opc_list_dev_caps, NULL);
2731         if (!status)
2732                 ice_parse_dev_caps(hw, dev_caps, cbuf, cap_count);
2733         ice_free(hw, cbuf);
2734
2735         return status;
2736 }
2737
2738 /**
2739  * ice_discover_func_caps - Read and extract function capabilities
2740  * @hw: pointer to the hardware structure
2741  * @func_caps: pointer to function capabilities structure
2742  *
2743  * Read the function capabilities and extract them into the func_caps structure
2744  * for later use.
2745  */
2746 static enum ice_status
2747 ice_discover_func_caps(struct ice_hw *hw, struct ice_hw_func_caps *func_caps)
2748 {
2749         enum ice_status status;
2750         u32 cap_count = 0;
2751         void *cbuf;
2752
2753         cbuf = ice_malloc(hw, ICE_AQ_MAX_BUF_LEN);
2754         if (!cbuf)
2755                 return ICE_ERR_NO_MEMORY;
2756
2757         /* Although the driver doesn't know the number of capabilities the
2758          * device will return, we can simply send a 4KB buffer, the maximum
2759          * possible size that firmware can return.
2760          */
2761         cap_count = ICE_AQ_MAX_BUF_LEN / sizeof(struct ice_aqc_list_caps_elem);
2762
2763         status = ice_aq_list_caps(hw, cbuf, ICE_AQ_MAX_BUF_LEN, &cap_count,
2764                                   ice_aqc_opc_list_func_caps, NULL);
2765         if (!status)
2766                 ice_parse_func_caps(hw, func_caps, cbuf, cap_count);
2767         ice_free(hw, cbuf);
2768
2769         return status;
2770 }
2771
2772 /**
2773  * ice_set_safe_mode_caps - Override dev/func capabilities when in safe mode
2774  * @hw: pointer to the hardware structure
2775  */
2776 void ice_set_safe_mode_caps(struct ice_hw *hw)
2777 {
2778         struct ice_hw_func_caps *func_caps = &hw->func_caps;
2779         struct ice_hw_dev_caps *dev_caps = &hw->dev_caps;
2780         struct ice_hw_common_caps cached_caps;
2781         u32 num_funcs;
2782
2783         /* cache some func_caps values that should be restored after memset */
2784         cached_caps = func_caps->common_cap;
2785
2786         /* unset func capabilities */
2787         memset(func_caps, 0, sizeof(*func_caps));
2788
2789 #define ICE_RESTORE_FUNC_CAP(name) \
2790         func_caps->common_cap.name = cached_caps.name
2791
2792         /* restore cached values */
2793         ICE_RESTORE_FUNC_CAP(valid_functions);
2794         ICE_RESTORE_FUNC_CAP(txq_first_id);
2795         ICE_RESTORE_FUNC_CAP(rxq_first_id);
2796         ICE_RESTORE_FUNC_CAP(msix_vector_first_id);
2797         ICE_RESTORE_FUNC_CAP(max_mtu);
2798         ICE_RESTORE_FUNC_CAP(nvm_unified_update);
2799
2800         /* one Tx and one Rx queue in safe mode */
2801         func_caps->common_cap.num_rxq = 1;
2802         func_caps->common_cap.num_txq = 1;
2803
2804         /* two MSIX vectors, one for traffic and one for misc causes */
2805         func_caps->common_cap.num_msix_vectors = 2;
2806         func_caps->guar_num_vsi = 1;
2807
2808         /* cache some dev_caps values that should be restored after memset */
2809         cached_caps = dev_caps->common_cap;
2810         num_funcs = dev_caps->num_funcs;
2811
2812         /* unset dev capabilities */
2813         memset(dev_caps, 0, sizeof(*dev_caps));
2814
2815 #define ICE_RESTORE_DEV_CAP(name) \
2816         dev_caps->common_cap.name = cached_caps.name
2817
2818         /* restore cached values */
2819         ICE_RESTORE_DEV_CAP(valid_functions);
2820         ICE_RESTORE_DEV_CAP(txq_first_id);
2821         ICE_RESTORE_DEV_CAP(rxq_first_id);
2822         ICE_RESTORE_DEV_CAP(msix_vector_first_id);
2823         ICE_RESTORE_DEV_CAP(max_mtu);
2824         ICE_RESTORE_DEV_CAP(nvm_unified_update);
2825         dev_caps->num_funcs = num_funcs;
2826
2827         /* one Tx and one Rx queue per function in safe mode */
2828         dev_caps->common_cap.num_rxq = num_funcs;
2829         dev_caps->common_cap.num_txq = num_funcs;
2830
2831         /* two MSIX vectors per function */
2832         dev_caps->common_cap.num_msix_vectors = 2 * num_funcs;
2833 }
2834
2835 /**
2836  * ice_get_caps - get info about the HW
2837  * @hw: pointer to the hardware structure
2838  */
2839 enum ice_status ice_get_caps(struct ice_hw *hw)
2840 {
2841         enum ice_status status;
2842
2843         status = ice_discover_dev_caps(hw, &hw->dev_caps);
2844         if (status)
2845                 return status;
2846
2847         return ice_discover_func_caps(hw, &hw->func_caps);
2848 }
2849
2850 /**
2851  * ice_aq_manage_mac_write - manage MAC address write command
2852  * @hw: pointer to the HW struct
2853  * @mac_addr: MAC address to be written as LAA/LAA+WoL/Port address
2854  * @flags: flags to control write behavior
2855  * @cd: pointer to command details structure or NULL
2856  *
2857  * This function is used to write MAC address to the NVM (0x0108).
2858  */
2859 enum ice_status
2860 ice_aq_manage_mac_write(struct ice_hw *hw, const u8 *mac_addr, u8 flags,
2861                         struct ice_sq_cd *cd)
2862 {
2863         struct ice_aqc_manage_mac_write *cmd;
2864         struct ice_aq_desc desc;
2865
2866         cmd = &desc.params.mac_write;
2867         ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_manage_mac_write);
2868
2869         cmd->flags = flags;
2870         ice_memcpy(cmd->mac_addr, mac_addr, ETH_ALEN, ICE_NONDMA_TO_NONDMA);
2871
2872         return ice_aq_send_cmd(hw, &desc, NULL, 0, cd);
2873 }
2874
2875 /**
2876  * ice_aq_clear_pxe_mode
2877  * @hw: pointer to the HW struct
2878  *
2879  * Tell the firmware that the driver is taking over from PXE (0x0110).
2880  */
2881 static enum ice_status ice_aq_clear_pxe_mode(struct ice_hw *hw)
2882 {
2883         struct ice_aq_desc desc;
2884
2885         ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_clear_pxe_mode);
2886         desc.params.clear_pxe.rx_cnt = ICE_AQC_CLEAR_PXE_RX_CNT;
2887
2888         return ice_aq_send_cmd(hw, &desc, NULL, 0, NULL);
2889 }
2890
2891 /**
2892  * ice_clear_pxe_mode - clear pxe operations mode
2893  * @hw: pointer to the HW struct
2894  *
2895  * Make sure all PXE mode settings are cleared, including things
2896  * like descriptor fetch/write-back mode.
2897  */
2898 void ice_clear_pxe_mode(struct ice_hw *hw)
2899 {
2900         if (ice_check_sq_alive(hw, &hw->adminq))
2901                 ice_aq_clear_pxe_mode(hw);
2902 }
2903
2904 /**
2905  * ice_aq_set_port_params - set physical port parameters.
2906  * @pi: pointer to the port info struct
2907  * @bad_frame_vsi: defines the VSI to which bad frames are forwarded
2908  * @save_bad_pac: if set packets with errors are forwarded to the bad frames VSI
2909  * @pad_short_pac: if set transmit packets smaller than 60 bytes are padded
2910  * @double_vlan: if set double VLAN is enabled
2911  * @cd: pointer to command details structure or NULL
2912  *
2913  * Set Physical port parameters (0x0203)
2914  */
2915 enum ice_status
2916 ice_aq_set_port_params(struct ice_port_info *pi, u16 bad_frame_vsi,
2917                        bool save_bad_pac, bool pad_short_pac, bool double_vlan,
2918                        struct ice_sq_cd *cd)
2919
2920 {
2921         struct ice_aqc_set_port_params *cmd;
2922         struct ice_hw *hw = pi->hw;
2923         struct ice_aq_desc desc;
2924         u16 cmd_flags = 0;
2925
2926         cmd = &desc.params.set_port_params;
2927
2928         ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_set_port_params);
2929         cmd->bad_frame_vsi = CPU_TO_LE16(bad_frame_vsi);
2930         if (save_bad_pac)
2931                 cmd_flags |= ICE_AQC_SET_P_PARAMS_SAVE_BAD_PACKETS;
2932         if (pad_short_pac)
2933                 cmd_flags |= ICE_AQC_SET_P_PARAMS_PAD_SHORT_PACKETS;
2934         if (double_vlan)
2935                 cmd_flags |= ICE_AQC_SET_P_PARAMS_DOUBLE_VLAN_ENA;
2936         cmd->cmd_flags = CPU_TO_LE16(cmd_flags);
2937
2938         return ice_aq_send_cmd(hw, &desc, NULL, 0, cd);
2939 }
2940
2941 /**
2942  * ice_get_link_speed_based_on_phy_type - returns link speed
2943  * @phy_type_low: lower part of phy_type
2944  * @phy_type_high: higher part of phy_type
2945  *
2946  * This helper function will convert an entry in PHY type structure
2947  * [phy_type_low, phy_type_high] to its corresponding link speed.
2948  * Note: In the structure of [phy_type_low, phy_type_high], there should
2949  * be one bit set, as this function will convert one PHY type to its
2950  * speed.
2951  * If no bit gets set, ICE_LINK_SPEED_UNKNOWN will be returned
2952  * If more than one bit gets set, ICE_LINK_SPEED_UNKNOWN will be returned
2953  */
2954 static u16
2955 ice_get_link_speed_based_on_phy_type(u64 phy_type_low, u64 phy_type_high)
2956 {
2957         u16 speed_phy_type_high = ICE_AQ_LINK_SPEED_UNKNOWN;
2958         u16 speed_phy_type_low = ICE_AQ_LINK_SPEED_UNKNOWN;
2959
2960         switch (phy_type_low) {
2961         case ICE_PHY_TYPE_LOW_100BASE_TX:
2962         case ICE_PHY_TYPE_LOW_100M_SGMII:
2963                 speed_phy_type_low = ICE_AQ_LINK_SPEED_100MB;
2964                 break;
2965         case ICE_PHY_TYPE_LOW_1000BASE_T:
2966         case ICE_PHY_TYPE_LOW_1000BASE_SX:
2967         case ICE_PHY_TYPE_LOW_1000BASE_LX:
2968         case ICE_PHY_TYPE_LOW_1000BASE_KX:
2969         case ICE_PHY_TYPE_LOW_1G_SGMII:
2970                 speed_phy_type_low = ICE_AQ_LINK_SPEED_1000MB;
2971                 break;
2972         case ICE_PHY_TYPE_LOW_2500BASE_T:
2973         case ICE_PHY_TYPE_LOW_2500BASE_X:
2974         case ICE_PHY_TYPE_LOW_2500BASE_KX:
2975                 speed_phy_type_low = ICE_AQ_LINK_SPEED_2500MB;
2976                 break;
2977         case ICE_PHY_TYPE_LOW_5GBASE_T:
2978         case ICE_PHY_TYPE_LOW_5GBASE_KR:
2979                 speed_phy_type_low = ICE_AQ_LINK_SPEED_5GB;
2980                 break;
2981         case ICE_PHY_TYPE_LOW_10GBASE_T:
2982         case ICE_PHY_TYPE_LOW_10G_SFI_DA:
2983         case ICE_PHY_TYPE_LOW_10GBASE_SR:
2984         case ICE_PHY_TYPE_LOW_10GBASE_LR:
2985         case ICE_PHY_TYPE_LOW_10GBASE_KR_CR1:
2986         case ICE_PHY_TYPE_LOW_10G_SFI_AOC_ACC:
2987         case ICE_PHY_TYPE_LOW_10G_SFI_C2C:
2988                 speed_phy_type_low = ICE_AQ_LINK_SPEED_10GB;
2989                 break;
2990         case ICE_PHY_TYPE_LOW_25GBASE_T:
2991         case ICE_PHY_TYPE_LOW_25GBASE_CR:
2992         case ICE_PHY_TYPE_LOW_25GBASE_CR_S:
2993         case ICE_PHY_TYPE_LOW_25GBASE_CR1:
2994         case ICE_PHY_TYPE_LOW_25GBASE_SR:
2995         case ICE_PHY_TYPE_LOW_25GBASE_LR:
2996         case ICE_PHY_TYPE_LOW_25GBASE_KR:
2997         case ICE_PHY_TYPE_LOW_25GBASE_KR_S:
2998         case ICE_PHY_TYPE_LOW_25GBASE_KR1:
2999         case ICE_PHY_TYPE_LOW_25G_AUI_AOC_ACC:
3000         case ICE_PHY_TYPE_LOW_25G_AUI_C2C:
3001                 speed_phy_type_low = ICE_AQ_LINK_SPEED_25GB;
3002                 break;
3003         case ICE_PHY_TYPE_LOW_40GBASE_CR4:
3004         case ICE_PHY_TYPE_LOW_40GBASE_SR4:
3005         case ICE_PHY_TYPE_LOW_40GBASE_LR4:
3006         case ICE_PHY_TYPE_LOW_40GBASE_KR4:
3007         case ICE_PHY_TYPE_LOW_40G_XLAUI_AOC_ACC:
3008         case ICE_PHY_TYPE_LOW_40G_XLAUI:
3009                 speed_phy_type_low = ICE_AQ_LINK_SPEED_40GB;
3010                 break;
3011         case ICE_PHY_TYPE_LOW_50GBASE_CR2:
3012         case ICE_PHY_TYPE_LOW_50GBASE_SR2:
3013         case ICE_PHY_TYPE_LOW_50GBASE_LR2:
3014         case ICE_PHY_TYPE_LOW_50GBASE_KR2:
3015         case ICE_PHY_TYPE_LOW_50G_LAUI2_AOC_ACC:
3016         case ICE_PHY_TYPE_LOW_50G_LAUI2:
3017         case ICE_PHY_TYPE_LOW_50G_AUI2_AOC_ACC:
3018         case ICE_PHY_TYPE_LOW_50G_AUI2:
3019         case ICE_PHY_TYPE_LOW_50GBASE_CP:
3020         case ICE_PHY_TYPE_LOW_50GBASE_SR:
3021         case ICE_PHY_TYPE_LOW_50GBASE_FR:
3022         case ICE_PHY_TYPE_LOW_50GBASE_LR:
3023         case ICE_PHY_TYPE_LOW_50GBASE_KR_PAM4:
3024         case ICE_PHY_TYPE_LOW_50G_AUI1_AOC_ACC:
3025         case ICE_PHY_TYPE_LOW_50G_AUI1:
3026                 speed_phy_type_low = ICE_AQ_LINK_SPEED_50GB;
3027                 break;
3028         case ICE_PHY_TYPE_LOW_100GBASE_CR4:
3029         case ICE_PHY_TYPE_LOW_100GBASE_SR4:
3030         case ICE_PHY_TYPE_LOW_100GBASE_LR4:
3031         case ICE_PHY_TYPE_LOW_100GBASE_KR4:
3032         case ICE_PHY_TYPE_LOW_100G_CAUI4_AOC_ACC:
3033         case ICE_PHY_TYPE_LOW_100G_CAUI4:
3034         case ICE_PHY_TYPE_LOW_100G_AUI4_AOC_ACC:
3035         case ICE_PHY_TYPE_LOW_100G_AUI4:
3036         case ICE_PHY_TYPE_LOW_100GBASE_CR_PAM4:
3037         case ICE_PHY_TYPE_LOW_100GBASE_KR_PAM4:
3038         case ICE_PHY_TYPE_LOW_100GBASE_CP2:
3039         case ICE_PHY_TYPE_LOW_100GBASE_SR2:
3040         case ICE_PHY_TYPE_LOW_100GBASE_DR:
3041                 speed_phy_type_low = ICE_AQ_LINK_SPEED_100GB;
3042                 break;
3043         default:
3044                 speed_phy_type_low = ICE_AQ_LINK_SPEED_UNKNOWN;
3045                 break;
3046         }
3047
3048         switch (phy_type_high) {
3049         case ICE_PHY_TYPE_HIGH_100GBASE_KR2_PAM4:
3050         case ICE_PHY_TYPE_HIGH_100G_CAUI2_AOC_ACC:
3051         case ICE_PHY_TYPE_HIGH_100G_CAUI2:
3052         case ICE_PHY_TYPE_HIGH_100G_AUI2_AOC_ACC:
3053         case ICE_PHY_TYPE_HIGH_100G_AUI2:
3054                 speed_phy_type_high = ICE_AQ_LINK_SPEED_100GB;
3055                 break;
3056         default:
3057                 speed_phy_type_high = ICE_AQ_LINK_SPEED_UNKNOWN;
3058                 break;
3059         }
3060
3061         if (speed_phy_type_low == ICE_AQ_LINK_SPEED_UNKNOWN &&
3062             speed_phy_type_high == ICE_AQ_LINK_SPEED_UNKNOWN)
3063                 return ICE_AQ_LINK_SPEED_UNKNOWN;
3064         else if (speed_phy_type_low != ICE_AQ_LINK_SPEED_UNKNOWN &&
3065                  speed_phy_type_high != ICE_AQ_LINK_SPEED_UNKNOWN)
3066                 return ICE_AQ_LINK_SPEED_UNKNOWN;
3067         else if (speed_phy_type_low != ICE_AQ_LINK_SPEED_UNKNOWN &&
3068                  speed_phy_type_high == ICE_AQ_LINK_SPEED_UNKNOWN)
3069                 return speed_phy_type_low;
3070         else
3071                 return speed_phy_type_high;
3072 }
3073
3074 /**
3075  * ice_update_phy_type
3076  * @phy_type_low: pointer to the lower part of phy_type
3077  * @phy_type_high: pointer to the higher part of phy_type
3078  * @link_speeds_bitmap: targeted link speeds bitmap
3079  *
3080  * Note: For the link_speeds_bitmap structure, you can check it at
3081  * [ice_aqc_get_link_status->link_speed]. Caller can pass in
3082  * link_speeds_bitmap include multiple speeds.
3083  *
3084  * Each entry in this [phy_type_low, phy_type_high] structure will
3085  * present a certain link speed. This helper function will turn on bits
3086  * in [phy_type_low, phy_type_high] structure based on the value of
3087  * link_speeds_bitmap input parameter.
3088  */
3089 void
3090 ice_update_phy_type(u64 *phy_type_low, u64 *phy_type_high,
3091                     u16 link_speeds_bitmap)
3092 {
3093         u64 pt_high;
3094         u64 pt_low;
3095         int index;
3096         u16 speed;
3097
3098         /* We first check with low part of phy_type */
3099         for (index = 0; index <= ICE_PHY_TYPE_LOW_MAX_INDEX; index++) {
3100                 pt_low = BIT_ULL(index);
3101                 speed = ice_get_link_speed_based_on_phy_type(pt_low, 0);
3102
3103                 if (link_speeds_bitmap & speed)
3104                         *phy_type_low |= BIT_ULL(index);
3105         }
3106
3107         /* We then check with high part of phy_type */
3108         for (index = 0; index <= ICE_PHY_TYPE_HIGH_MAX_INDEX; index++) {
3109                 pt_high = BIT_ULL(index);
3110                 speed = ice_get_link_speed_based_on_phy_type(0, pt_high);
3111
3112                 if (link_speeds_bitmap & speed)
3113                         *phy_type_high |= BIT_ULL(index);
3114         }
3115 }
3116
3117 /**
3118  * ice_aq_set_phy_cfg
3119  * @hw: pointer to the HW struct
3120  * @pi: port info structure of the interested logical port
3121  * @cfg: structure with PHY configuration data to be set
3122  * @cd: pointer to command details structure or NULL
3123  *
3124  * Set the various PHY configuration parameters supported on the Port.
3125  * One or more of the Set PHY config parameters may be ignored in an MFP
3126  * mode as the PF may not have the privilege to set some of the PHY Config
3127  * parameters. This status will be indicated by the command response (0x0601).
3128  */
3129 enum ice_status
3130 ice_aq_set_phy_cfg(struct ice_hw *hw, struct ice_port_info *pi,
3131                    struct ice_aqc_set_phy_cfg_data *cfg, struct ice_sq_cd *cd)
3132 {
3133         struct ice_aq_desc desc;
3134         enum ice_status status;
3135
3136         if (!cfg)
3137                 return ICE_ERR_PARAM;
3138
3139         /* Ensure that only valid bits of cfg->caps can be turned on. */
3140         if (cfg->caps & ~ICE_AQ_PHY_ENA_VALID_MASK) {
3141                 ice_debug(hw, ICE_DBG_PHY, "Invalid bit is set in ice_aqc_set_phy_cfg_data->caps : 0x%x\n",
3142                           cfg->caps);
3143
3144                 cfg->caps &= ICE_AQ_PHY_ENA_VALID_MASK;
3145         }
3146
3147         ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_set_phy_cfg);
3148         desc.params.set_phy.lport_num = pi->lport;
3149         desc.flags |= CPU_TO_LE16(ICE_AQ_FLAG_RD);
3150
3151         ice_debug(hw, ICE_DBG_LINK, "set phy cfg\n");
3152         ice_debug(hw, ICE_DBG_LINK, "   phy_type_low = 0x%llx\n",
3153                   (unsigned long long)LE64_TO_CPU(cfg->phy_type_low));
3154         ice_debug(hw, ICE_DBG_LINK, "   phy_type_high = 0x%llx\n",
3155                   (unsigned long long)LE64_TO_CPU(cfg->phy_type_high));
3156         ice_debug(hw, ICE_DBG_LINK, "   caps = 0x%x\n", cfg->caps);
3157         ice_debug(hw, ICE_DBG_LINK, "   low_power_ctrl_an = 0x%x\n",
3158                   cfg->low_power_ctrl_an);
3159         ice_debug(hw, ICE_DBG_LINK, "   eee_cap = 0x%x\n", cfg->eee_cap);
3160         ice_debug(hw, ICE_DBG_LINK, "   eeer_value = 0x%x\n", cfg->eeer_value);
3161         ice_debug(hw, ICE_DBG_LINK, "   link_fec_opt = 0x%x\n",
3162                   cfg->link_fec_opt);
3163
3164         status = ice_aq_send_cmd(hw, &desc, cfg, sizeof(*cfg), cd);
3165
3166         if (hw->adminq.sq_last_status == ICE_AQ_RC_EMODE)
3167                 status = ICE_SUCCESS;
3168
3169         if (!status)
3170                 pi->phy.curr_user_phy_cfg = *cfg;
3171
3172         return status;
3173 }
3174
3175 /**
3176  * ice_update_link_info - update status of the HW network link
3177  * @pi: port info structure of the interested logical port
3178  */
3179 enum ice_status ice_update_link_info(struct ice_port_info *pi)
3180 {
3181         struct ice_link_status *li;
3182         enum ice_status status;
3183
3184         if (!pi)
3185                 return ICE_ERR_PARAM;
3186
3187         li = &pi->phy.link_info;
3188
3189         status = ice_aq_get_link_info(pi, true, NULL, NULL);
3190         if (status)
3191                 return status;
3192
3193         if (li->link_info & ICE_AQ_MEDIA_AVAILABLE) {
3194                 struct ice_aqc_get_phy_caps_data *pcaps;
3195                 struct ice_hw *hw;
3196
3197                 hw = pi->hw;
3198                 pcaps = (struct ice_aqc_get_phy_caps_data *)
3199                         ice_malloc(hw, sizeof(*pcaps));
3200                 if (!pcaps)
3201                         return ICE_ERR_NO_MEMORY;
3202
3203                 status = ice_aq_get_phy_caps(pi, false, ICE_AQC_REPORT_TOPO_CAP_MEDIA,
3204                                              pcaps, NULL);
3205
3206                 if (status == ICE_SUCCESS)
3207                         ice_memcpy(li->module_type, &pcaps->module_type,
3208                                    sizeof(li->module_type),
3209                                    ICE_NONDMA_TO_NONDMA);
3210
3211                 ice_free(hw, pcaps);
3212         }
3213
3214         return status;
3215 }
3216
3217 /**
3218  * ice_cache_phy_user_req
3219  * @pi: port information structure
3220  * @cache_data: PHY logging data
3221  * @cache_mode: PHY logging mode
3222  *
3223  * Log the user request on (FC, FEC, SPEED) for later user.
3224  */
3225 static void
3226 ice_cache_phy_user_req(struct ice_port_info *pi,
3227                        struct ice_phy_cache_mode_data cache_data,
3228                        enum ice_phy_cache_mode cache_mode)
3229 {
3230         if (!pi)
3231                 return;
3232
3233         switch (cache_mode) {
3234         case ICE_FC_MODE:
3235                 pi->phy.curr_user_fc_req = cache_data.data.curr_user_fc_req;
3236                 break;
3237         case ICE_SPEED_MODE:
3238                 pi->phy.curr_user_speed_req =
3239                         cache_data.data.curr_user_speed_req;
3240                 break;
3241         case ICE_FEC_MODE:
3242                 pi->phy.curr_user_fec_req = cache_data.data.curr_user_fec_req;
3243                 break;
3244         default:
3245                 break;
3246         }
3247 }
3248
3249 /**
3250  * ice_caps_to_fc_mode
3251  * @caps: PHY capabilities
3252  *
3253  * Convert PHY FC capabilities to ice FC mode
3254  */
3255 enum ice_fc_mode ice_caps_to_fc_mode(u8 caps)
3256 {
3257         if (caps & ICE_AQC_PHY_EN_TX_LINK_PAUSE &&
3258             caps & ICE_AQC_PHY_EN_RX_LINK_PAUSE)
3259                 return ICE_FC_FULL;
3260
3261         if (caps & ICE_AQC_PHY_EN_TX_LINK_PAUSE)
3262                 return ICE_FC_TX_PAUSE;
3263
3264         if (caps & ICE_AQC_PHY_EN_RX_LINK_PAUSE)
3265                 return ICE_FC_RX_PAUSE;
3266
3267         return ICE_FC_NONE;
3268 }
3269
3270 /**
3271  * ice_caps_to_fec_mode
3272  * @caps: PHY capabilities
3273  * @fec_options: Link FEC options
3274  *
3275  * Convert PHY FEC capabilities to ice FEC mode
3276  */
3277 enum ice_fec_mode ice_caps_to_fec_mode(u8 caps, u8 fec_options)
3278 {
3279         if (caps & ICE_AQC_PHY_EN_AUTO_FEC)
3280                 return ICE_FEC_AUTO;
3281
3282         if (fec_options & (ICE_AQC_PHY_FEC_10G_KR_40G_KR4_EN |
3283                            ICE_AQC_PHY_FEC_10G_KR_40G_KR4_REQ |
3284                            ICE_AQC_PHY_FEC_25G_KR_CLAUSE74_EN |
3285                            ICE_AQC_PHY_FEC_25G_KR_REQ))
3286                 return ICE_FEC_BASER;
3287
3288         if (fec_options & (ICE_AQC_PHY_FEC_25G_RS_528_REQ |
3289                            ICE_AQC_PHY_FEC_25G_RS_544_REQ |
3290                            ICE_AQC_PHY_FEC_25G_RS_CLAUSE91_EN))
3291                 return ICE_FEC_RS;
3292
3293         return ICE_FEC_NONE;
3294 }
3295
3296 /**
3297  * ice_cfg_phy_fc - Configure PHY FC data based on FC mode
3298  * @pi: port information structure
3299  * @cfg: PHY configuration data to set FC mode
3300  * @req_mode: FC mode to configure
3301  */
3302 static enum ice_status
3303 ice_cfg_phy_fc(struct ice_port_info *pi, struct ice_aqc_set_phy_cfg_data *cfg,
3304                enum ice_fc_mode req_mode)
3305 {
3306         struct ice_phy_cache_mode_data cache_data;
3307         u8 pause_mask = 0x0;
3308
3309         if (!pi || !cfg)
3310                 return ICE_ERR_BAD_PTR;
3311
3312         switch (req_mode) {
3313         case ICE_FC_AUTO:
3314         {
3315                 struct ice_aqc_get_phy_caps_data *pcaps;
3316                 enum ice_status status;
3317
3318                 pcaps = (struct ice_aqc_get_phy_caps_data *)
3319                         ice_malloc(pi->hw, sizeof(*pcaps));
3320                 if (!pcaps)
3321                         return ICE_ERR_NO_MEMORY;
3322
3323                 /* Query the value of FC that both the NIC and attached media
3324                  * can do.
3325                  */
3326                 status = ice_aq_get_phy_caps(pi, false, ICE_AQC_REPORT_TOPO_CAP_MEDIA,
3327                                              pcaps, NULL);
3328                 if (status) {
3329                         ice_free(pi->hw, pcaps);
3330                         return status;
3331                 }
3332
3333                 pause_mask |= pcaps->caps & ICE_AQC_PHY_EN_TX_LINK_PAUSE;
3334                 pause_mask |= pcaps->caps & ICE_AQC_PHY_EN_RX_LINK_PAUSE;
3335
3336                 ice_free(pi->hw, pcaps);
3337                 break;
3338         }
3339         case ICE_FC_FULL:
3340                 pause_mask |= ICE_AQC_PHY_EN_TX_LINK_PAUSE;
3341                 pause_mask |= ICE_AQC_PHY_EN_RX_LINK_PAUSE;
3342                 break;
3343         case ICE_FC_RX_PAUSE:
3344                 pause_mask |= ICE_AQC_PHY_EN_RX_LINK_PAUSE;
3345                 break;
3346         case ICE_FC_TX_PAUSE:
3347                 pause_mask |= ICE_AQC_PHY_EN_TX_LINK_PAUSE;
3348                 break;
3349         default:
3350                 break;
3351         }
3352
3353         /* clear the old pause settings */
3354         cfg->caps &= ~(ICE_AQC_PHY_EN_TX_LINK_PAUSE |
3355                 ICE_AQC_PHY_EN_RX_LINK_PAUSE);
3356
3357         /* set the new capabilities */
3358         cfg->caps |= pause_mask;
3359
3360         /* Cache user FC request */
3361         cache_data.data.curr_user_fc_req = req_mode;
3362         ice_cache_phy_user_req(pi, cache_data, ICE_FC_MODE);
3363
3364         return ICE_SUCCESS;
3365 }
3366
3367 /**
3368  * ice_set_fc
3369  * @pi: port information structure
3370  * @aq_failures: pointer to status code, specific to ice_set_fc routine
3371  * @ena_auto_link_update: enable automatic link update
3372  *
3373  * Set the requested flow control mode.
3374  */
3375 enum ice_status
3376 ice_set_fc(struct ice_port_info *pi, u8 *aq_failures, bool ena_auto_link_update)
3377 {
3378         struct ice_aqc_set_phy_cfg_data  cfg = { 0 };
3379         struct ice_aqc_get_phy_caps_data *pcaps;
3380         enum ice_status status;
3381         struct ice_hw *hw;
3382
3383         if (!pi || !aq_failures)
3384                 return ICE_ERR_BAD_PTR;
3385
3386         *aq_failures = 0;
3387         hw = pi->hw;
3388
3389         pcaps = (struct ice_aqc_get_phy_caps_data *)
3390                 ice_malloc(hw, sizeof(*pcaps));
3391         if (!pcaps)
3392                 return ICE_ERR_NO_MEMORY;
3393
3394         /* Get the current PHY config */
3395         status = ice_aq_get_phy_caps(pi, false, ICE_AQC_REPORT_ACTIVE_CFG,
3396                                      pcaps, NULL);
3397
3398         if (status) {
3399                 *aq_failures = ICE_SET_FC_AQ_FAIL_GET;
3400                 goto out;
3401         }
3402
3403         ice_copy_phy_caps_to_cfg(pi, pcaps, &cfg);
3404
3405         /* Configure the set PHY data */
3406         status = ice_cfg_phy_fc(pi, &cfg, pi->fc.req_mode);
3407         if (status) {
3408                 if (status != ICE_ERR_BAD_PTR)
3409                         *aq_failures = ICE_SET_FC_AQ_FAIL_GET;
3410
3411                 goto out;
3412         }
3413
3414         /* If the capabilities have changed, then set the new config */
3415         if (cfg.caps != pcaps->caps) {
3416                 int retry_count, retry_max = 10;
3417
3418                 /* Auto restart link so settings take effect */
3419                 if (ena_auto_link_update)
3420                         cfg.caps |= ICE_AQ_PHY_ENA_AUTO_LINK_UPDT;
3421
3422                 status = ice_aq_set_phy_cfg(hw, pi, &cfg, NULL);
3423                 if (status) {
3424                         *aq_failures = ICE_SET_FC_AQ_FAIL_SET;
3425                         goto out;
3426                 }
3427
3428                 /* Update the link info
3429                  * It sometimes takes a really long time for link to
3430                  * come back from the atomic reset. Thus, we wait a
3431                  * little bit.
3432                  */
3433                 for (retry_count = 0; retry_count < retry_max; retry_count++) {
3434                         status = ice_update_link_info(pi);
3435
3436                         if (status == ICE_SUCCESS)
3437                                 break;
3438
3439                         ice_msec_delay(100, true);
3440                 }
3441
3442                 if (status)
3443                         *aq_failures = ICE_SET_FC_AQ_FAIL_UPDATE;
3444         }
3445
3446 out:
3447         ice_free(hw, pcaps);
3448         return status;
3449 }
3450
3451 /**
3452  * ice_phy_caps_equals_cfg
3453  * @phy_caps: PHY capabilities
3454  * @phy_cfg: PHY configuration
3455  *
3456  * Helper function to determine if PHY capabilities matches PHY
3457  * configuration
3458  */
3459 bool
3460 ice_phy_caps_equals_cfg(struct ice_aqc_get_phy_caps_data *phy_caps,
3461                         struct ice_aqc_set_phy_cfg_data *phy_cfg)
3462 {
3463         u8 caps_mask, cfg_mask;
3464
3465         if (!phy_caps || !phy_cfg)
3466                 return false;
3467
3468         /* These bits are not common between capabilities and configuration.
3469          * Do not use them to determine equality.
3470          */
3471         caps_mask = ICE_AQC_PHY_CAPS_MASK & ~(ICE_AQC_PHY_AN_MODE |
3472                                               ICE_AQC_PHY_EN_MOD_QUAL);
3473         cfg_mask = ICE_AQ_PHY_ENA_VALID_MASK & ~ICE_AQ_PHY_ENA_AUTO_LINK_UPDT;
3474
3475         if (phy_caps->phy_type_low != phy_cfg->phy_type_low ||
3476             phy_caps->phy_type_high != phy_cfg->phy_type_high ||
3477             ((phy_caps->caps & caps_mask) != (phy_cfg->caps & cfg_mask)) ||
3478             phy_caps->low_power_ctrl_an != phy_cfg->low_power_ctrl_an ||
3479             phy_caps->eee_cap != phy_cfg->eee_cap ||
3480             phy_caps->eeer_value != phy_cfg->eeer_value ||
3481             phy_caps->link_fec_options != phy_cfg->link_fec_opt)
3482                 return false;
3483
3484         return true;
3485 }
3486
3487 /**
3488  * ice_copy_phy_caps_to_cfg - Copy PHY ability data to configuration data
3489  * @pi: port information structure
3490  * @caps: PHY ability structure to copy date from
3491  * @cfg: PHY configuration structure to copy data to
3492  *
3493  * Helper function to copy AQC PHY get ability data to PHY set configuration
3494  * data structure
3495  */
3496 void
3497 ice_copy_phy_caps_to_cfg(struct ice_port_info *pi,
3498                          struct ice_aqc_get_phy_caps_data *caps,
3499                          struct ice_aqc_set_phy_cfg_data *cfg)
3500 {
3501         if (!pi || !caps || !cfg)
3502                 return;
3503
3504         ice_memset(cfg, 0, sizeof(*cfg), ICE_NONDMA_MEM);
3505         cfg->phy_type_low = caps->phy_type_low;
3506         cfg->phy_type_high = caps->phy_type_high;
3507         cfg->caps = caps->caps;
3508         cfg->low_power_ctrl_an = caps->low_power_ctrl_an;
3509         cfg->eee_cap = caps->eee_cap;
3510         cfg->eeer_value = caps->eeer_value;
3511         cfg->link_fec_opt = caps->link_fec_options;
3512         cfg->module_compliance_enforcement =
3513                 caps->module_compliance_enforcement;
3514 }
3515
3516 /**
3517  * ice_cfg_phy_fec - Configure PHY FEC data based on FEC mode
3518  * @pi: port information structure
3519  * @cfg: PHY configuration data to set FEC mode
3520  * @fec: FEC mode to configure
3521  */
3522 enum ice_status
3523 ice_cfg_phy_fec(struct ice_port_info *pi, struct ice_aqc_set_phy_cfg_data *cfg,
3524                 enum ice_fec_mode fec)
3525 {
3526         struct ice_aqc_get_phy_caps_data *pcaps;
3527         enum ice_status status = ICE_SUCCESS;
3528         struct ice_hw *hw;
3529
3530         if (!pi || !cfg)
3531                 return ICE_ERR_BAD_PTR;
3532
3533         hw = pi->hw;
3534
3535         pcaps = (struct ice_aqc_get_phy_caps_data *)
3536                 ice_malloc(hw, sizeof(*pcaps));
3537         if (!pcaps)
3538                 return ICE_ERR_NO_MEMORY;
3539
3540         status = ice_aq_get_phy_caps(pi, false,
3541                                      (ice_fw_supports_report_dflt_cfg(hw) ?
3542                                       ICE_AQC_REPORT_DFLT_CFG :
3543                                       ICE_AQC_REPORT_TOPO_CAP_MEDIA), pcaps, NULL);
3544
3545         if (status)
3546                 goto out;
3547
3548         cfg->caps |= (pcaps->caps & ICE_AQC_PHY_EN_AUTO_FEC);
3549         cfg->link_fec_opt = pcaps->link_fec_options;
3550
3551         switch (fec) {
3552         case ICE_FEC_BASER:
3553                 /* Clear RS bits, and AND BASE-R ability
3554                  * bits and OR request bits.
3555                  */
3556                 cfg->link_fec_opt &= ICE_AQC_PHY_FEC_10G_KR_40G_KR4_EN |
3557                         ICE_AQC_PHY_FEC_25G_KR_CLAUSE74_EN;
3558                 cfg->link_fec_opt |= ICE_AQC_PHY_FEC_10G_KR_40G_KR4_REQ |
3559                         ICE_AQC_PHY_FEC_25G_KR_REQ;
3560                 break;
3561         case ICE_FEC_RS:
3562                 /* Clear BASE-R bits, and AND RS ability
3563                  * bits and OR request bits.
3564                  */
3565                 cfg->link_fec_opt &= ICE_AQC_PHY_FEC_25G_RS_CLAUSE91_EN;
3566                 cfg->link_fec_opt |= ICE_AQC_PHY_FEC_25G_RS_528_REQ |
3567                         ICE_AQC_PHY_FEC_25G_RS_544_REQ;
3568                 break;
3569         case ICE_FEC_NONE:
3570                 /* Clear all FEC option bits. */
3571                 cfg->link_fec_opt &= ~ICE_AQC_PHY_FEC_MASK;
3572                 break;
3573         case ICE_FEC_AUTO:
3574                 /* AND auto FEC bit, and all caps bits. */
3575                 cfg->caps &= ICE_AQC_PHY_CAPS_MASK;
3576                 cfg->link_fec_opt |= pcaps->link_fec_options;
3577                 break;
3578         default:
3579                 status = ICE_ERR_PARAM;
3580                 break;
3581         }
3582
3583         if (fec == ICE_FEC_AUTO && ice_fw_supports_link_override(pi->hw) &&
3584             !ice_fw_supports_report_dflt_cfg(pi->hw)) {
3585                 struct ice_link_default_override_tlv tlv;
3586
3587                 if (ice_get_link_default_override(&tlv, pi))
3588                         goto out;
3589
3590                 if (!(tlv.options & ICE_LINK_OVERRIDE_STRICT_MODE) &&
3591                     (tlv.options & ICE_LINK_OVERRIDE_EN))
3592                         cfg->link_fec_opt = tlv.fec_options;
3593         }
3594
3595 out:
3596         ice_free(hw, pcaps);
3597
3598         return status;
3599 }
3600
3601 /**
3602  * ice_get_link_status - get status of the HW network link
3603  * @pi: port information structure
3604  * @link_up: pointer to bool (true/false = linkup/linkdown)
3605  *
3606  * Variable link_up is true if link is up, false if link is down.
3607  * The variable link_up is invalid if status is non zero. As a
3608  * result of this call, link status reporting becomes enabled
3609  */
3610 enum ice_status ice_get_link_status(struct ice_port_info *pi, bool *link_up)
3611 {
3612         struct ice_phy_info *phy_info;
3613         enum ice_status status = ICE_SUCCESS;
3614
3615         if (!pi || !link_up)
3616                 return ICE_ERR_PARAM;
3617
3618         phy_info = &pi->phy;
3619
3620         if (phy_info->get_link_info) {
3621                 status = ice_update_link_info(pi);
3622
3623                 if (status)
3624                         ice_debug(pi->hw, ICE_DBG_LINK, "get link status error, status = %d\n",
3625                                   status);
3626         }
3627
3628         *link_up = phy_info->link_info.link_info & ICE_AQ_LINK_UP;
3629
3630         return status;
3631 }
3632
3633 /**
3634  * ice_aq_set_link_restart_an
3635  * @pi: pointer to the port information structure
3636  * @ena_link: if true: enable link, if false: disable link
3637  * @cd: pointer to command details structure or NULL
3638  *
3639  * Sets up the link and restarts the Auto-Negotiation over the link.
3640  */
3641 enum ice_status
3642 ice_aq_set_link_restart_an(struct ice_port_info *pi, bool ena_link,
3643                            struct ice_sq_cd *cd)
3644 {
3645         struct ice_aqc_restart_an *cmd;
3646         struct ice_aq_desc desc;
3647
3648         cmd = &desc.params.restart_an;
3649
3650         ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_restart_an);
3651
3652         cmd->cmd_flags = ICE_AQC_RESTART_AN_LINK_RESTART;
3653         cmd->lport_num = pi->lport;
3654         if (ena_link)
3655                 cmd->cmd_flags |= ICE_AQC_RESTART_AN_LINK_ENABLE;
3656         else
3657                 cmd->cmd_flags &= ~ICE_AQC_RESTART_AN_LINK_ENABLE;
3658
3659         return ice_aq_send_cmd(pi->hw, &desc, NULL, 0, cd);
3660 }
3661
3662 /**
3663  * ice_aq_set_event_mask
3664  * @hw: pointer to the HW struct
3665  * @port_num: port number of the physical function
3666  * @mask: event mask to be set
3667  * @cd: pointer to command details structure or NULL
3668  *
3669  * Set event mask (0x0613)
3670  */
3671 enum ice_status
3672 ice_aq_set_event_mask(struct ice_hw *hw, u8 port_num, u16 mask,
3673                       struct ice_sq_cd *cd)
3674 {
3675         struct ice_aqc_set_event_mask *cmd;
3676         struct ice_aq_desc desc;
3677
3678         cmd = &desc.params.set_event_mask;
3679
3680         ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_set_event_mask);
3681
3682         cmd->lport_num = port_num;
3683
3684         cmd->event_mask = CPU_TO_LE16(mask);
3685         return ice_aq_send_cmd(hw, &desc, NULL, 0, cd);
3686 }
3687
3688 /**
3689  * ice_aq_set_mac_loopback
3690  * @hw: pointer to the HW struct
3691  * @ena_lpbk: Enable or Disable loopback
3692  * @cd: pointer to command details structure or NULL
3693  *
3694  * Enable/disable loopback on a given port
3695  */
3696 enum ice_status
3697 ice_aq_set_mac_loopback(struct ice_hw *hw, bool ena_lpbk, struct ice_sq_cd *cd)
3698 {
3699         struct ice_aqc_set_mac_lb *cmd;
3700         struct ice_aq_desc desc;
3701
3702         cmd = &desc.params.set_mac_lb;
3703
3704         ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_set_mac_lb);
3705         if (ena_lpbk)
3706                 cmd->lb_mode = ICE_AQ_MAC_LB_EN;
3707
3708         return ice_aq_send_cmd(hw, &desc, NULL, 0, cd);
3709 }
3710
3711 /**
3712  * ice_aq_set_port_id_led
3713  * @pi: pointer to the port information
3714  * @is_orig_mode: is this LED set to original mode (by the net-list)
3715  * @cd: pointer to command details structure or NULL
3716  *
3717  * Set LED value for the given port (0x06e9)
3718  */
3719 enum ice_status
3720 ice_aq_set_port_id_led(struct ice_port_info *pi, bool is_orig_mode,
3721                        struct ice_sq_cd *cd)
3722 {
3723         struct ice_aqc_set_port_id_led *cmd;
3724         struct ice_hw *hw = pi->hw;
3725         struct ice_aq_desc desc;
3726
3727         cmd = &desc.params.set_port_id_led;
3728
3729         ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_set_port_id_led);
3730
3731         if (is_orig_mode)
3732                 cmd->ident_mode = ICE_AQC_PORT_IDENT_LED_ORIG;
3733         else
3734                 cmd->ident_mode = ICE_AQC_PORT_IDENT_LED_BLINK;
3735
3736         return ice_aq_send_cmd(hw, &desc, NULL, 0, cd);
3737 }
3738
3739 /**
3740  * ice_aq_sff_eeprom
3741  * @hw: pointer to the HW struct
3742  * @lport: bits [7:0] = logical port, bit [8] = logical port valid
3743  * @bus_addr: I2C bus address of the eeprom (typically 0xA0, 0=topo default)
3744  * @mem_addr: I2C offset. lower 8 bits for address, 8 upper bits zero padding.
3745  * @page: QSFP page
3746  * @set_page: set or ignore the page
3747  * @data: pointer to data buffer to be read/written to the I2C device.
3748  * @length: 1-16 for read, 1 for write.
3749  * @write: 0 read, 1 for write.
3750  * @cd: pointer to command details structure or NULL
3751  *
3752  * Read/Write SFF EEPROM (0x06EE)
3753  */
3754 enum ice_status
3755 ice_aq_sff_eeprom(struct ice_hw *hw, u16 lport, u8 bus_addr,
3756                   u16 mem_addr, u8 page, u8 set_page, u8 *data, u8 length,
3757                   bool write, struct ice_sq_cd *cd)
3758 {
3759         struct ice_aqc_sff_eeprom *cmd;
3760         struct ice_aq_desc desc;
3761         enum ice_status status;
3762
3763         if (!data || (mem_addr & 0xff00))
3764                 return ICE_ERR_PARAM;
3765
3766         ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_sff_eeprom);
3767         cmd = &desc.params.read_write_sff_param;
3768         desc.flags = CPU_TO_LE16(ICE_AQ_FLAG_RD);
3769         cmd->lport_num = (u8)(lport & 0xff);
3770         cmd->lport_num_valid = (u8)((lport >> 8) & 0x01);
3771         cmd->i2c_bus_addr = CPU_TO_LE16(((bus_addr >> 1) &
3772                                          ICE_AQC_SFF_I2CBUS_7BIT_M) |
3773                                         ((set_page <<
3774                                           ICE_AQC_SFF_SET_EEPROM_PAGE_S) &
3775                                          ICE_AQC_SFF_SET_EEPROM_PAGE_M));
3776         cmd->i2c_mem_addr = CPU_TO_LE16(mem_addr & 0xff);
3777         cmd->eeprom_page = CPU_TO_LE16((u16)page << ICE_AQC_SFF_EEPROM_PAGE_S);
3778         if (write)
3779                 cmd->i2c_bus_addr |= CPU_TO_LE16(ICE_AQC_SFF_IS_WRITE);
3780
3781         status = ice_aq_send_cmd(hw, &desc, data, length, cd);
3782         return status;
3783 }
3784
3785 /**
3786  * ice_aq_prog_topo_dev_nvm
3787  * @hw: pointer to the hardware structure
3788  * @topo_params: pointer to structure storing topology parameters for a device
3789  * @cd: pointer to command details structure or NULL
3790  *
3791  * Program Topology Device NVM (0x06F2)
3792  *
3793  */
3794 enum ice_status
3795 ice_aq_prog_topo_dev_nvm(struct ice_hw *hw,
3796                          struct ice_aqc_link_topo_params *topo_params,
3797                          struct ice_sq_cd *cd)
3798 {
3799         struct ice_aqc_prog_topo_dev_nvm *cmd;
3800         struct ice_aq_desc desc;
3801
3802         cmd = &desc.params.prog_topo_dev_nvm;
3803
3804         ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_prog_topo_dev_nvm);
3805
3806         ice_memcpy(&cmd->topo_params, topo_params, sizeof(*topo_params),
3807                    ICE_NONDMA_TO_NONDMA);
3808
3809         return ice_aq_send_cmd(hw, &desc, NULL, 0, cd);
3810 }
3811
3812 /**
3813  * ice_aq_read_topo_dev_nvm
3814  * @hw: pointer to the hardware structure
3815  * @topo_params: pointer to structure storing topology parameters for a device
3816  * @start_address: byte offset in the topology device NVM
3817  * @data: pointer to data buffer
3818  * @data_size: number of bytes to be read from the topology device NVM
3819  * @cd: pointer to command details structure or NULL
3820  * Read Topology Device NVM (0x06F3)
3821  *
3822  */
3823 enum ice_status
3824 ice_aq_read_topo_dev_nvm(struct ice_hw *hw,
3825                          struct ice_aqc_link_topo_params *topo_params,
3826                          u32 start_address, u8 *data, u8 data_size,
3827                          struct ice_sq_cd *cd)
3828 {
3829         struct ice_aqc_read_topo_dev_nvm *cmd;
3830         struct ice_aq_desc desc;
3831         enum ice_status status;
3832
3833         if (!data || data_size == 0 ||
3834             data_size > ICE_AQC_READ_TOPO_DEV_NVM_DATA_READ_SIZE)
3835                 return ICE_ERR_PARAM;
3836
3837         cmd = &desc.params.read_topo_dev_nvm;
3838
3839         ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_read_topo_dev_nvm);
3840
3841         desc.datalen = data_size;
3842         ice_memcpy(&cmd->topo_params, topo_params, sizeof(*topo_params),
3843                    ICE_NONDMA_TO_NONDMA);
3844         cmd->start_address = CPU_TO_LE32(start_address);
3845
3846         status = ice_aq_send_cmd(hw, &desc, NULL, 0, cd);
3847         if (status)
3848                 return status;
3849
3850         ice_memcpy(data, cmd->data_read, data_size, ICE_NONDMA_TO_NONDMA);
3851
3852         return ICE_SUCCESS;
3853 }
3854
3855 /**
3856  * __ice_aq_get_set_rss_lut
3857  * @hw: pointer to the hardware structure
3858  * @params: RSS LUT parameters
3859  * @set: set true to set the table, false to get the table
3860  *
3861  * Internal function to get (0x0B05) or set (0x0B03) RSS look up table
3862  */
3863 static enum ice_status
3864 __ice_aq_get_set_rss_lut(struct ice_hw *hw, struct ice_aq_get_set_rss_lut_params *params, bool set)
3865 {
3866         u16 flags = 0, vsi_id, lut_type, lut_size, glob_lut_idx, vsi_handle;
3867         struct ice_aqc_get_set_rss_lut *cmd_resp;
3868         struct ice_aq_desc desc;
3869         enum ice_status status;
3870         u8 *lut;
3871
3872         if (!params)
3873                 return ICE_ERR_PARAM;
3874
3875         vsi_handle = params->vsi_handle;
3876         lut = params->lut;
3877
3878         if (!ice_is_vsi_valid(hw, vsi_handle) || !lut)
3879                 return ICE_ERR_PARAM;
3880
3881         lut_size = params->lut_size;
3882         lut_type = params->lut_type;
3883         glob_lut_idx = params->global_lut_id;
3884         vsi_id = ice_get_hw_vsi_num(hw, vsi_handle);
3885
3886         cmd_resp = &desc.params.get_set_rss_lut;
3887
3888         if (set) {
3889                 ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_set_rss_lut);
3890                 desc.flags |= CPU_TO_LE16(ICE_AQ_FLAG_RD);
3891         } else {
3892                 ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_get_rss_lut);
3893         }
3894
3895         cmd_resp->vsi_id = CPU_TO_LE16(((vsi_id <<
3896                                          ICE_AQC_GSET_RSS_LUT_VSI_ID_S) &
3897                                         ICE_AQC_GSET_RSS_LUT_VSI_ID_M) |
3898                                        ICE_AQC_GSET_RSS_LUT_VSI_VALID);
3899
3900         switch (lut_type) {
3901         case ICE_AQC_GSET_RSS_LUT_TABLE_TYPE_VSI:
3902         case ICE_AQC_GSET_RSS_LUT_TABLE_TYPE_PF:
3903         case ICE_AQC_GSET_RSS_LUT_TABLE_TYPE_GLOBAL:
3904                 flags |= ((lut_type << ICE_AQC_GSET_RSS_LUT_TABLE_TYPE_S) &
3905                           ICE_AQC_GSET_RSS_LUT_TABLE_TYPE_M);
3906                 break;
3907         default:
3908                 status = ICE_ERR_PARAM;
3909                 goto ice_aq_get_set_rss_lut_exit;
3910         }
3911
3912         if (lut_type == ICE_AQC_GSET_RSS_LUT_TABLE_TYPE_GLOBAL) {
3913                 flags |= ((glob_lut_idx << ICE_AQC_GSET_RSS_LUT_GLOBAL_IDX_S) &
3914                           ICE_AQC_GSET_RSS_LUT_GLOBAL_IDX_M);
3915
3916                 if (!set)
3917                         goto ice_aq_get_set_rss_lut_send;
3918         } else if (lut_type == ICE_AQC_GSET_RSS_LUT_TABLE_TYPE_PF) {
3919                 if (!set)
3920                         goto ice_aq_get_set_rss_lut_send;
3921         } else {
3922                 goto ice_aq_get_set_rss_lut_send;
3923         }
3924
3925         /* LUT size is only valid for Global and PF table types */
3926         switch (lut_size) {
3927         case ICE_AQC_GSET_RSS_LUT_TABLE_SIZE_128:
3928                 flags |= (ICE_AQC_GSET_RSS_LUT_TABLE_SIZE_128_FLAG <<
3929                           ICE_AQC_GSET_RSS_LUT_TABLE_SIZE_S) &
3930                          ICE_AQC_GSET_RSS_LUT_TABLE_SIZE_M;
3931                 break;
3932         case ICE_AQC_GSET_RSS_LUT_TABLE_SIZE_512:
3933                 flags |= (ICE_AQC_GSET_RSS_LUT_TABLE_SIZE_512_FLAG <<
3934                           ICE_AQC_GSET_RSS_LUT_TABLE_SIZE_S) &
3935                          ICE_AQC_GSET_RSS_LUT_TABLE_SIZE_M;
3936                 break;
3937         case ICE_AQC_GSET_RSS_LUT_TABLE_SIZE_2K:
3938                 if (lut_type == ICE_AQC_GSET_RSS_LUT_TABLE_TYPE_PF) {
3939                         flags |= (ICE_AQC_GSET_RSS_LUT_TABLE_SIZE_2K_FLAG <<
3940                                   ICE_AQC_GSET_RSS_LUT_TABLE_SIZE_S) &
3941                                  ICE_AQC_GSET_RSS_LUT_TABLE_SIZE_M;
3942                         break;
3943                 }
3944                 /* fall-through */
3945         default:
3946                 status = ICE_ERR_PARAM;
3947                 goto ice_aq_get_set_rss_lut_exit;
3948         }
3949
3950 ice_aq_get_set_rss_lut_send:
3951         cmd_resp->flags = CPU_TO_LE16(flags);
3952         status = ice_aq_send_cmd(hw, &desc, lut, lut_size, NULL);
3953
3954 ice_aq_get_set_rss_lut_exit:
3955         return status;
3956 }
3957
3958 /**
3959  * ice_aq_get_rss_lut
3960  * @hw: pointer to the hardware structure
3961  * @get_params: RSS LUT parameters used to specify which RSS LUT to get
3962  *
3963  * get the RSS lookup table, PF or VSI type
3964  */
3965 enum ice_status
3966 ice_aq_get_rss_lut(struct ice_hw *hw, struct ice_aq_get_set_rss_lut_params *get_params)
3967 {
3968         return __ice_aq_get_set_rss_lut(hw, get_params, false);
3969 }
3970
3971 /**
3972  * ice_aq_set_rss_lut
3973  * @hw: pointer to the hardware structure
3974  * @set_params: RSS LUT parameters used to specify how to set the RSS LUT
3975  *
3976  * set the RSS lookup table, PF or VSI type
3977  */
3978 enum ice_status
3979 ice_aq_set_rss_lut(struct ice_hw *hw, struct ice_aq_get_set_rss_lut_params *set_params)
3980 {
3981         return __ice_aq_get_set_rss_lut(hw, set_params, true);
3982 }
3983
3984 /**
3985  * __ice_aq_get_set_rss_key
3986  * @hw: pointer to the HW struct
3987  * @vsi_id: VSI FW index
3988  * @key: pointer to key info struct
3989  * @set: set true to set the key, false to get the key
3990  *
3991  * get (0x0B04) or set (0x0B02) the RSS key per VSI
3992  */
3993 static enum
3994 ice_status __ice_aq_get_set_rss_key(struct ice_hw *hw, u16 vsi_id,
3995                                     struct ice_aqc_get_set_rss_keys *key,
3996                                     bool set)
3997 {
3998         struct ice_aqc_get_set_rss_key *cmd_resp;
3999         u16 key_size = sizeof(*key);
4000         struct ice_aq_desc desc;
4001
4002         cmd_resp = &desc.params.get_set_rss_key;
4003
4004         if (set) {
4005                 ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_set_rss_key);
4006                 desc.flags |= CPU_TO_LE16(ICE_AQ_FLAG_RD);
4007         } else {
4008                 ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_get_rss_key);
4009         }
4010
4011         cmd_resp->vsi_id = CPU_TO_LE16(((vsi_id <<
4012                                          ICE_AQC_GSET_RSS_KEY_VSI_ID_S) &
4013                                         ICE_AQC_GSET_RSS_KEY_VSI_ID_M) |
4014                                        ICE_AQC_GSET_RSS_KEY_VSI_VALID);
4015
4016         return ice_aq_send_cmd(hw, &desc, key, key_size, NULL);
4017 }
4018
4019 /**
4020  * ice_aq_get_rss_key
4021  * @hw: pointer to the HW struct
4022  * @vsi_handle: software VSI handle
4023  * @key: pointer to key info struct
4024  *
4025  * get the RSS key per VSI
4026  */
4027 enum ice_status
4028 ice_aq_get_rss_key(struct ice_hw *hw, u16 vsi_handle,
4029                    struct ice_aqc_get_set_rss_keys *key)
4030 {
4031         if (!ice_is_vsi_valid(hw, vsi_handle) || !key)
4032                 return ICE_ERR_PARAM;
4033
4034         return __ice_aq_get_set_rss_key(hw, ice_get_hw_vsi_num(hw, vsi_handle),
4035                                         key, false);
4036 }
4037
4038 /**
4039  * ice_aq_set_rss_key
4040  * @hw: pointer to the HW struct
4041  * @vsi_handle: software VSI handle
4042  * @keys: pointer to key info struct
4043  *
4044  * set the RSS key per VSI
4045  */
4046 enum ice_status
4047 ice_aq_set_rss_key(struct ice_hw *hw, u16 vsi_handle,
4048                    struct ice_aqc_get_set_rss_keys *keys)
4049 {
4050         if (!ice_is_vsi_valid(hw, vsi_handle) || !keys)
4051                 return ICE_ERR_PARAM;
4052
4053         return __ice_aq_get_set_rss_key(hw, ice_get_hw_vsi_num(hw, vsi_handle),
4054                                         keys, true);
4055 }
4056
4057 /**
4058  * ice_aq_add_lan_txq
4059  * @hw: pointer to the hardware structure
4060  * @num_qgrps: Number of added queue groups
4061  * @qg_list: list of queue groups to be added
4062  * @buf_size: size of buffer for indirect command
4063  * @cd: pointer to command details structure or NULL
4064  *
4065  * Add Tx LAN queue (0x0C30)
4066  *
4067  * NOTE:
4068  * Prior to calling add Tx LAN queue:
4069  * Initialize the following as part of the Tx queue context:
4070  * Completion queue ID if the queue uses Completion queue, Quanta profile,
4071  * Cache profile and Packet shaper profile.
4072  *
4073  * After add Tx LAN queue AQ command is completed:
4074  * Interrupts should be associated with specific queues,
4075  * Association of Tx queue to Doorbell queue is not part of Add LAN Tx queue
4076  * flow.
4077  */
4078 enum ice_status
4079 ice_aq_add_lan_txq(struct ice_hw *hw, u8 num_qgrps,
4080                    struct ice_aqc_add_tx_qgrp *qg_list, u16 buf_size,
4081                    struct ice_sq_cd *cd)
4082 {
4083         struct ice_aqc_add_tx_qgrp *list;
4084         struct ice_aqc_add_txqs *cmd;
4085         struct ice_aq_desc desc;
4086         u16 i, sum_size = 0;
4087
4088         ice_debug(hw, ICE_DBG_TRACE, "%s\n", __func__);
4089
4090         cmd = &desc.params.add_txqs;
4091
4092         ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_add_txqs);
4093
4094         if (!qg_list)
4095                 return ICE_ERR_PARAM;
4096
4097         if (num_qgrps > ICE_LAN_TXQ_MAX_QGRPS)
4098                 return ICE_ERR_PARAM;
4099
4100         for (i = 0, list = qg_list; i < num_qgrps; i++) {
4101                 sum_size += ice_struct_size(list, txqs, list->num_txqs);
4102                 list = (struct ice_aqc_add_tx_qgrp *)(list->txqs +
4103                                                       list->num_txqs);
4104         }
4105
4106         if (buf_size != sum_size)
4107                 return ICE_ERR_PARAM;
4108
4109         desc.flags |= CPU_TO_LE16(ICE_AQ_FLAG_RD);
4110
4111         cmd->num_qgrps = num_qgrps;
4112
4113         return ice_aq_send_cmd(hw, &desc, qg_list, buf_size, cd);
4114 }
4115
4116 /**
4117  * ice_aq_dis_lan_txq
4118  * @hw: pointer to the hardware structure
4119  * @num_qgrps: number of groups in the list
4120  * @qg_list: the list of groups to disable
4121  * @buf_size: the total size of the qg_list buffer in bytes
4122  * @rst_src: if called due to reset, specifies the reset source
4123  * @vmvf_num: the relative VM or VF number that is undergoing the reset
4124  * @cd: pointer to command details structure or NULL
4125  *
4126  * Disable LAN Tx queue (0x0C31)
4127  */
4128 static enum ice_status
4129 ice_aq_dis_lan_txq(struct ice_hw *hw, u8 num_qgrps,
4130                    struct ice_aqc_dis_txq_item *qg_list, u16 buf_size,
4131                    enum ice_disq_rst_src rst_src, u16 vmvf_num,
4132                    struct ice_sq_cd *cd)
4133 {
4134         struct ice_aqc_dis_txq_item *item;
4135         struct ice_aqc_dis_txqs *cmd;
4136         struct ice_aq_desc desc;
4137         enum ice_status status;
4138         u16 i, sz = 0;
4139
4140         ice_debug(hw, ICE_DBG_TRACE, "%s\n", __func__);
4141         cmd = &desc.params.dis_txqs;
4142         ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_dis_txqs);
4143
4144         /* qg_list can be NULL only in VM/VF reset flow */
4145         if (!qg_list && !rst_src)
4146                 return ICE_ERR_PARAM;
4147
4148         if (num_qgrps > ICE_LAN_TXQ_MAX_QGRPS)
4149                 return ICE_ERR_PARAM;
4150
4151         cmd->num_entries = num_qgrps;
4152
4153         cmd->vmvf_and_timeout = CPU_TO_LE16((5 << ICE_AQC_Q_DIS_TIMEOUT_S) &
4154                                             ICE_AQC_Q_DIS_TIMEOUT_M);
4155
4156         switch (rst_src) {
4157         case ICE_VM_RESET:
4158                 cmd->cmd_type = ICE_AQC_Q_DIS_CMD_VM_RESET;
4159                 cmd->vmvf_and_timeout |=
4160                         CPU_TO_LE16(vmvf_num & ICE_AQC_Q_DIS_VMVF_NUM_M);
4161                 break;
4162         case ICE_NO_RESET:
4163         default:
4164                 break;
4165         }
4166
4167         /* flush pipe on time out */
4168         cmd->cmd_type |= ICE_AQC_Q_DIS_CMD_FLUSH_PIPE;
4169         /* If no queue group info, we are in a reset flow. Issue the AQ */
4170         if (!qg_list)
4171                 goto do_aq;
4172
4173         /* set RD bit to indicate that command buffer is provided by the driver
4174          * and it needs to be read by the firmware
4175          */
4176         desc.flags |= CPU_TO_LE16(ICE_AQ_FLAG_RD);
4177
4178         for (i = 0, item = qg_list; i < num_qgrps; i++) {
4179                 u16 item_size = ice_struct_size(item, q_id, item->num_qs);
4180
4181                 /* If the num of queues is even, add 2 bytes of padding */
4182                 if ((item->num_qs % 2) == 0)
4183                         item_size += 2;
4184
4185                 sz += item_size;
4186
4187                 item = (struct ice_aqc_dis_txq_item *)((u8 *)item + item_size);
4188         }
4189
4190         if (buf_size != sz)
4191                 return ICE_ERR_PARAM;
4192
4193 do_aq:
4194         status = ice_aq_send_cmd(hw, &desc, qg_list, buf_size, cd);
4195         if (status) {
4196                 if (!qg_list)
4197                         ice_debug(hw, ICE_DBG_SCHED, "VM%d disable failed %d\n",
4198                                   vmvf_num, hw->adminq.sq_last_status);
4199                 else
4200                         ice_debug(hw, ICE_DBG_SCHED, "disable queue %d failed %d\n",
4201                                   LE16_TO_CPU(qg_list[0].q_id[0]),
4202                                   hw->adminq.sq_last_status);
4203         }
4204         return status;
4205 }
4206
4207 /**
4208  * ice_aq_move_recfg_lan_txq
4209  * @hw: pointer to the hardware structure
4210  * @num_qs: number of queues to move/reconfigure
4211  * @is_move: true if this operation involves node movement
4212  * @is_tc_change: true if this operation involves a TC change
4213  * @subseq_call: true if this operation is a subsequent call
4214  * @flush_pipe: on timeout, true to flush pipe, false to return EAGAIN
4215  * @timeout: timeout in units of 100 usec (valid values 0-50)
4216  * @blocked_cgds: out param, bitmap of CGDs that timed out if returning EAGAIN
4217  * @buf: struct containing src/dest TEID and per-queue info
4218  * @buf_size: size of buffer for indirect command
4219  * @txqs_moved: out param, number of queues successfully moved
4220  * @cd: pointer to command details structure or NULL
4221  *
4222  * Move / Reconfigure Tx LAN queues (0x0C32)
4223  */
4224 enum ice_status
4225 ice_aq_move_recfg_lan_txq(struct ice_hw *hw, u8 num_qs, bool is_move,
4226                           bool is_tc_change, bool subseq_call, bool flush_pipe,
4227                           u8 timeout, u32 *blocked_cgds,
4228                           struct ice_aqc_move_txqs_data *buf, u16 buf_size,
4229                           u8 *txqs_moved, struct ice_sq_cd *cd)
4230 {
4231         struct ice_aqc_move_txqs *cmd;
4232         struct ice_aq_desc desc;
4233         enum ice_status status;
4234
4235         cmd = &desc.params.move_txqs;
4236         ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_move_recfg_txqs);
4237
4238 #define ICE_LAN_TXQ_MOVE_TIMEOUT_MAX 50
4239         if (timeout > ICE_LAN_TXQ_MOVE_TIMEOUT_MAX)
4240                 return ICE_ERR_PARAM;
4241
4242         if (is_tc_change && !flush_pipe && !blocked_cgds)
4243                 return ICE_ERR_PARAM;
4244
4245         if (!is_move && !is_tc_change)
4246                 return ICE_ERR_PARAM;
4247
4248         desc.flags |= CPU_TO_LE16(ICE_AQ_FLAG_RD);
4249
4250         if (is_move)
4251                 cmd->cmd_type |= ICE_AQC_Q_CMD_TYPE_MOVE;
4252
4253         if (is_tc_change)
4254                 cmd->cmd_type |= ICE_AQC_Q_CMD_TYPE_TC_CHANGE;
4255
4256         if (subseq_call)
4257                 cmd->cmd_type |= ICE_AQC_Q_CMD_SUBSEQ_CALL;
4258
4259         if (flush_pipe)
4260                 cmd->cmd_type |= ICE_AQC_Q_CMD_FLUSH_PIPE;
4261
4262         cmd->num_qs = num_qs;
4263         cmd->timeout = ((timeout << ICE_AQC_Q_CMD_TIMEOUT_S) &
4264                         ICE_AQC_Q_CMD_TIMEOUT_M);
4265
4266         status = ice_aq_send_cmd(hw, &desc, buf, buf_size, cd);
4267
4268         if (!status && txqs_moved)
4269                 *txqs_moved = cmd->num_qs;
4270
4271         if (hw->adminq.sq_last_status == ICE_AQ_RC_EAGAIN &&
4272             is_tc_change && !flush_pipe)
4273                 *blocked_cgds = LE32_TO_CPU(cmd->blocked_cgds);
4274
4275         return status;
4276 }
4277
4278 /* End of FW Admin Queue command wrappers */
4279
4280 /**
4281  * ice_write_byte - write a byte to a packed context structure
4282  * @src_ctx:  the context structure to read from
4283  * @dest_ctx: the context to be written to
4284  * @ce_info:  a description of the struct to be filled
4285  */
4286 static void
4287 ice_write_byte(u8 *src_ctx, u8 *dest_ctx, const struct ice_ctx_ele *ce_info)
4288 {
4289         u8 src_byte, dest_byte, mask;
4290         u8 *from, *dest;
4291         u16 shift_width;
4292
4293         /* copy from the next struct field */
4294         from = src_ctx + ce_info->offset;
4295
4296         /* prepare the bits and mask */
4297         shift_width = ce_info->lsb % 8;
4298         mask = (u8)(BIT(ce_info->width) - 1);
4299
4300         src_byte = *from;
4301         src_byte &= mask;
4302
4303         /* shift to correct alignment */
4304         mask <<= shift_width;
4305         src_byte <<= shift_width;
4306
4307         /* get the current bits from the target bit string */
4308         dest = dest_ctx + (ce_info->lsb / 8);
4309
4310         ice_memcpy(&dest_byte, dest, sizeof(dest_byte), ICE_DMA_TO_NONDMA);
4311
4312         dest_byte &= ~mask;     /* get the bits not changing */
4313         dest_byte |= src_byte;  /* add in the new bits */
4314
4315         /* put it all back */
4316         ice_memcpy(dest, &dest_byte, sizeof(dest_byte), ICE_NONDMA_TO_DMA);
4317 }
4318
4319 /**
4320  * ice_write_word - write a word to a packed context structure
4321  * @src_ctx:  the context structure to read from
4322  * @dest_ctx: the context to be written to
4323  * @ce_info:  a description of the struct to be filled
4324  */
4325 static void
4326 ice_write_word(u8 *src_ctx, u8 *dest_ctx, const struct ice_ctx_ele *ce_info)
4327 {
4328         u16 src_word, mask;
4329         __le16 dest_word;
4330         u8 *from, *dest;
4331         u16 shift_width;
4332
4333         /* copy from the next struct field */
4334         from = src_ctx + ce_info->offset;
4335
4336         /* prepare the bits and mask */
4337         shift_width = ce_info->lsb % 8;
4338         mask = BIT(ce_info->width) - 1;
4339
4340         /* don't swizzle the bits until after the mask because the mask bits
4341          * will be in a different bit position on big endian machines
4342          */
4343         src_word = *(u16 *)from;
4344         src_word &= mask;
4345
4346         /* shift to correct alignment */
4347         mask <<= shift_width;
4348         src_word <<= shift_width;
4349
4350         /* get the current bits from the target bit string */
4351         dest = dest_ctx + (ce_info->lsb / 8);
4352
4353         ice_memcpy(&dest_word, dest, sizeof(dest_word), ICE_DMA_TO_NONDMA);
4354
4355         dest_word &= ~(CPU_TO_LE16(mask));      /* get the bits not changing */
4356         dest_word |= CPU_TO_LE16(src_word);     /* add in the new bits */
4357
4358         /* put it all back */
4359         ice_memcpy(dest, &dest_word, sizeof(dest_word), ICE_NONDMA_TO_DMA);
4360 }
4361
4362 /**
4363  * ice_write_dword - write a dword to a packed context structure
4364  * @src_ctx:  the context structure to read from
4365  * @dest_ctx: the context to be written to
4366  * @ce_info:  a description of the struct to be filled
4367  */
4368 static void
4369 ice_write_dword(u8 *src_ctx, u8 *dest_ctx, const struct ice_ctx_ele *ce_info)
4370 {
4371         u32 src_dword, mask;
4372         __le32 dest_dword;
4373         u8 *from, *dest;
4374         u16 shift_width;
4375
4376         /* copy from the next struct field */
4377         from = src_ctx + ce_info->offset;
4378
4379         /* prepare the bits and mask */
4380         shift_width = ce_info->lsb % 8;
4381
4382         /* if the field width is exactly 32 on an x86 machine, then the shift
4383          * operation will not work because the SHL instructions count is masked
4384          * to 5 bits so the shift will do nothing
4385          */
4386         if (ce_info->width < 32)
4387                 mask = BIT(ce_info->width) - 1;
4388         else
4389                 mask = (u32)~0;
4390
4391         /* don't swizzle the bits until after the mask because the mask bits
4392          * will be in a different bit position on big endian machines
4393          */
4394         src_dword = *(u32 *)from;
4395         src_dword &= mask;
4396
4397         /* shift to correct alignment */
4398         mask <<= shift_width;
4399         src_dword <<= shift_width;
4400
4401         /* get the current bits from the target bit string */
4402         dest = dest_ctx + (ce_info->lsb / 8);
4403
4404         ice_memcpy(&dest_dword, dest, sizeof(dest_dword), ICE_DMA_TO_NONDMA);
4405
4406         dest_dword &= ~(CPU_TO_LE32(mask));     /* get the bits not changing */
4407         dest_dword |= CPU_TO_LE32(src_dword);   /* add in the new bits */
4408
4409         /* put it all back */
4410         ice_memcpy(dest, &dest_dword, sizeof(dest_dword), ICE_NONDMA_TO_DMA);
4411 }
4412
4413 /**
4414  * ice_write_qword - write a qword to a packed context structure
4415  * @src_ctx:  the context structure to read from
4416  * @dest_ctx: the context to be written to
4417  * @ce_info:  a description of the struct to be filled
4418  */
4419 static void
4420 ice_write_qword(u8 *src_ctx, u8 *dest_ctx, const struct ice_ctx_ele *ce_info)
4421 {
4422         u64 src_qword, mask;
4423         __le64 dest_qword;
4424         u8 *from, *dest;
4425         u16 shift_width;
4426
4427         /* copy from the next struct field */
4428         from = src_ctx + ce_info->offset;
4429
4430         /* prepare the bits and mask */
4431         shift_width = ce_info->lsb % 8;
4432
4433         /* if the field width is exactly 64 on an x86 machine, then the shift
4434          * operation will not work because the SHL instructions count is masked
4435          * to 6 bits so the shift will do nothing
4436          */
4437         if (ce_info->width < 64)
4438                 mask = BIT_ULL(ce_info->width) - 1;
4439         else
4440                 mask = (u64)~0;
4441
4442         /* don't swizzle the bits until after the mask because the mask bits
4443          * will be in a different bit position on big endian machines
4444          */
4445         src_qword = *(u64 *)from;
4446         src_qword &= mask;
4447
4448         /* shift to correct alignment */
4449         mask <<= shift_width;
4450         src_qword <<= shift_width;
4451
4452         /* get the current bits from the target bit string */
4453         dest = dest_ctx + (ce_info->lsb / 8);
4454
4455         ice_memcpy(&dest_qword, dest, sizeof(dest_qword), ICE_DMA_TO_NONDMA);
4456
4457         dest_qword &= ~(CPU_TO_LE64(mask));     /* get the bits not changing */
4458         dest_qword |= CPU_TO_LE64(src_qword);   /* add in the new bits */
4459
4460         /* put it all back */
4461         ice_memcpy(dest, &dest_qword, sizeof(dest_qword), ICE_NONDMA_TO_DMA);
4462 }
4463
4464 /**
4465  * ice_set_ctx - set context bits in packed structure
4466  * @hw: pointer to the hardware structure
4467  * @src_ctx:  pointer to a generic non-packed context structure
4468  * @dest_ctx: pointer to memory for the packed structure
4469  * @ce_info:  a description of the structure to be transformed
4470  */
4471 enum ice_status
4472 ice_set_ctx(struct ice_hw *hw, u8 *src_ctx, u8 *dest_ctx,
4473             const struct ice_ctx_ele *ce_info)
4474 {
4475         int f;
4476
4477         for (f = 0; ce_info[f].width; f++) {
4478                 /* We have to deal with each element of the FW response
4479                  * using the correct size so that we are correct regardless
4480                  * of the endianness of the machine.
4481                  */
4482                 if (ce_info[f].width > (ce_info[f].size_of * BITS_PER_BYTE)) {
4483                         ice_debug(hw, ICE_DBG_QCTX, "Field %d width of %d bits larger than size of %d byte(s) ... skipping write\n",
4484                                   f, ce_info[f].width, ce_info[f].size_of);
4485                         continue;
4486                 }
4487                 switch (ce_info[f].size_of) {
4488                 case sizeof(u8):
4489                         ice_write_byte(src_ctx, dest_ctx, &ce_info[f]);
4490                         break;
4491                 case sizeof(u16):
4492                         ice_write_word(src_ctx, dest_ctx, &ce_info[f]);
4493                         break;
4494                 case sizeof(u32):
4495                         ice_write_dword(src_ctx, dest_ctx, &ce_info[f]);
4496                         break;
4497                 case sizeof(u64):
4498                         ice_write_qword(src_ctx, dest_ctx, &ce_info[f]);
4499                         break;
4500                 default:
4501                         return ICE_ERR_INVAL_SIZE;
4502                 }
4503         }
4504
4505         return ICE_SUCCESS;
4506 }
4507
4508 /**
4509  * ice_read_byte - read context byte into struct
4510  * @src_ctx:  the context structure to read from
4511  * @dest_ctx: the context to be written to
4512  * @ce_info:  a description of the struct to be filled
4513  */
4514 static void
4515 ice_read_byte(u8 *src_ctx, u8 *dest_ctx, struct ice_ctx_ele *ce_info)
4516 {
4517         u8 dest_byte, mask;
4518         u8 *src, *target;
4519         u16 shift_width;
4520
4521         /* prepare the bits and mask */
4522         shift_width = ce_info->lsb % 8;
4523         mask = (u8)(BIT(ce_info->width) - 1);
4524
4525         /* shift to correct alignment */
4526         mask <<= shift_width;
4527
4528         /* get the current bits from the src bit string */
4529         src = src_ctx + (ce_info->lsb / 8);
4530
4531         ice_memcpy(&dest_byte, src, sizeof(dest_byte), ICE_DMA_TO_NONDMA);
4532
4533         dest_byte &= ~(mask);
4534
4535         dest_byte >>= shift_width;
4536
4537         /* get the address from the struct field */
4538         target = dest_ctx + ce_info->offset;
4539
4540         /* put it back in the struct */
4541         ice_memcpy(target, &dest_byte, sizeof(dest_byte), ICE_NONDMA_TO_DMA);
4542 }
4543
4544 /**
4545  * ice_read_word - read context word into struct
4546  * @src_ctx:  the context structure to read from
4547  * @dest_ctx: the context to be written to
4548  * @ce_info:  a description of the struct to be filled
4549  */
4550 static void
4551 ice_read_word(u8 *src_ctx, u8 *dest_ctx, struct ice_ctx_ele *ce_info)
4552 {
4553         u16 dest_word, mask;
4554         u8 *src, *target;
4555         __le16 src_word;
4556         u16 shift_width;
4557
4558         /* prepare the bits and mask */
4559         shift_width = ce_info->lsb % 8;
4560         mask = BIT(ce_info->width) - 1;
4561
4562         /* shift to correct alignment */
4563         mask <<= shift_width;
4564
4565         /* get the current bits from the src bit string */
4566         src = src_ctx + (ce_info->lsb / 8);
4567
4568         ice_memcpy(&src_word, src, sizeof(src_word), ICE_DMA_TO_NONDMA);
4569
4570         /* the data in the memory is stored as little endian so mask it
4571          * correctly
4572          */
4573         src_word &= ~(CPU_TO_LE16(mask));
4574
4575         /* get the data back into host order before shifting */
4576         dest_word = LE16_TO_CPU(src_word);
4577
4578         dest_word >>= shift_width;
4579
4580         /* get the address from the struct field */
4581         target = dest_ctx + ce_info->offset;
4582
4583         /* put it back in the struct */
4584         ice_memcpy(target, &dest_word, sizeof(dest_word), ICE_NONDMA_TO_DMA);
4585 }
4586
4587 /**
4588  * ice_read_dword - read context dword into struct
4589  * @src_ctx:  the context structure to read from
4590  * @dest_ctx: the context to be written to
4591  * @ce_info:  a description of the struct to be filled
4592  */
4593 static void
4594 ice_read_dword(u8 *src_ctx, u8 *dest_ctx, struct ice_ctx_ele *ce_info)
4595 {
4596         u32 dest_dword, mask;
4597         __le32 src_dword;
4598         u8 *src, *target;
4599         u16 shift_width;
4600
4601         /* prepare the bits and mask */
4602         shift_width = ce_info->lsb % 8;
4603
4604         /* if the field width is exactly 32 on an x86 machine, then the shift
4605          * operation will not work because the SHL instructions count is masked
4606          * to 5 bits so the shift will do nothing
4607          */
4608         if (ce_info->width < 32)
4609                 mask = BIT(ce_info->width) - 1;
4610         else
4611                 mask = (u32)~0;
4612
4613         /* shift to correct alignment */
4614         mask <<= shift_width;
4615
4616         /* get the current bits from the src bit string */
4617         src = src_ctx + (ce_info->lsb / 8);
4618
4619         ice_memcpy(&src_dword, src, sizeof(src_dword), ICE_DMA_TO_NONDMA);
4620
4621         /* the data in the memory is stored as little endian so mask it
4622          * correctly
4623          */
4624         src_dword &= ~(CPU_TO_LE32(mask));
4625
4626         /* get the data back into host order before shifting */
4627         dest_dword = LE32_TO_CPU(src_dword);
4628
4629         dest_dword >>= shift_width;
4630
4631         /* get the address from the struct field */
4632         target = dest_ctx + ce_info->offset;
4633
4634         /* put it back in the struct */
4635         ice_memcpy(target, &dest_dword, sizeof(dest_dword), ICE_NONDMA_TO_DMA);
4636 }
4637
4638 /**
4639  * ice_read_qword - read context qword into struct
4640  * @src_ctx:  the context structure to read from
4641  * @dest_ctx: the context to be written to
4642  * @ce_info:  a description of the struct to be filled
4643  */
4644 static void
4645 ice_read_qword(u8 *src_ctx, u8 *dest_ctx, struct ice_ctx_ele *ce_info)
4646 {
4647         u64 dest_qword, mask;
4648         __le64 src_qword;
4649         u8 *src, *target;
4650         u16 shift_width;
4651
4652         /* prepare the bits and mask */
4653         shift_width = ce_info->lsb % 8;
4654
4655         /* if the field width is exactly 64 on an x86 machine, then the shift
4656          * operation will not work because the SHL instructions count is masked
4657          * to 6 bits so the shift will do nothing
4658          */
4659         if (ce_info->width < 64)
4660                 mask = BIT_ULL(ce_info->width) - 1;
4661         else
4662                 mask = (u64)~0;
4663
4664         /* shift to correct alignment */
4665         mask <<= shift_width;
4666
4667         /* get the current bits from the src bit string */
4668         src = src_ctx + (ce_info->lsb / 8);
4669
4670         ice_memcpy(&src_qword, src, sizeof(src_qword), ICE_DMA_TO_NONDMA);
4671
4672         /* the data in the memory is stored as little endian so mask it
4673          * correctly
4674          */
4675         src_qword &= ~(CPU_TO_LE64(mask));
4676
4677         /* get the data back into host order before shifting */
4678         dest_qword = LE64_TO_CPU(src_qword);
4679
4680         dest_qword >>= shift_width;
4681
4682         /* get the address from the struct field */
4683         target = dest_ctx + ce_info->offset;
4684
4685         /* put it back in the struct */
4686         ice_memcpy(target, &dest_qword, sizeof(dest_qword), ICE_NONDMA_TO_DMA);
4687 }
4688
4689 /**
4690  * ice_get_ctx - extract context bits from a packed structure
4691  * @src_ctx:  pointer to a generic packed context structure
4692  * @dest_ctx: pointer to a generic non-packed context structure
4693  * @ce_info:  a description of the structure to be read from
4694  */
4695 enum ice_status
4696 ice_get_ctx(u8 *src_ctx, u8 *dest_ctx, struct ice_ctx_ele *ce_info)
4697 {
4698         int f;
4699
4700         for (f = 0; ce_info[f].width; f++) {
4701                 switch (ce_info[f].size_of) {
4702                 case 1:
4703                         ice_read_byte(src_ctx, dest_ctx, &ce_info[f]);
4704                         break;
4705                 case 2:
4706                         ice_read_word(src_ctx, dest_ctx, &ce_info[f]);
4707                         break;
4708                 case 4:
4709                         ice_read_dword(src_ctx, dest_ctx, &ce_info[f]);
4710                         break;
4711                 case 8:
4712                         ice_read_qword(src_ctx, dest_ctx, &ce_info[f]);
4713                         break;
4714                 default:
4715                         /* nothing to do, just keep going */
4716                         break;
4717                 }
4718         }
4719
4720         return ICE_SUCCESS;
4721 }
4722
4723 /**
4724  * ice_get_lan_q_ctx - get the LAN queue context for the given VSI and TC
4725  * @hw: pointer to the HW struct
4726  * @vsi_handle: software VSI handle
4727  * @tc: TC number
4728  * @q_handle: software queue handle
4729  */
4730 struct ice_q_ctx *
4731 ice_get_lan_q_ctx(struct ice_hw *hw, u16 vsi_handle, u8 tc, u16 q_handle)
4732 {
4733         struct ice_vsi_ctx *vsi;
4734         struct ice_q_ctx *q_ctx;
4735
4736         vsi = ice_get_vsi_ctx(hw, vsi_handle);
4737         if (!vsi)
4738                 return NULL;
4739         if (q_handle >= vsi->num_lan_q_entries[tc])
4740                 return NULL;
4741         if (!vsi->lan_q_ctx[tc])
4742                 return NULL;
4743         q_ctx = vsi->lan_q_ctx[tc];
4744         return &q_ctx[q_handle];
4745 }
4746
4747 /**
4748  * ice_ena_vsi_txq
4749  * @pi: port information structure
4750  * @vsi_handle: software VSI handle
4751  * @tc: TC number
4752  * @q_handle: software queue handle
4753  * @num_qgrps: Number of added queue groups
4754  * @buf: list of queue groups to be added
4755  * @buf_size: size of buffer for indirect command
4756  * @cd: pointer to command details structure or NULL
4757  *
4758  * This function adds one LAN queue
4759  */
4760 enum ice_status
4761 ice_ena_vsi_txq(struct ice_port_info *pi, u16 vsi_handle, u8 tc, u16 q_handle,
4762                 u8 num_qgrps, struct ice_aqc_add_tx_qgrp *buf, u16 buf_size,
4763                 struct ice_sq_cd *cd)
4764 {
4765         struct ice_aqc_txsched_elem_data node = { 0 };
4766         struct ice_sched_node *parent;
4767         struct ice_q_ctx *q_ctx;
4768         enum ice_status status;
4769         struct ice_hw *hw;
4770
4771         if (!pi || pi->port_state != ICE_SCHED_PORT_STATE_READY)
4772                 return ICE_ERR_CFG;
4773
4774         if (num_qgrps > 1 || buf->num_txqs > 1)
4775                 return ICE_ERR_MAX_LIMIT;
4776
4777         hw = pi->hw;
4778
4779         if (!ice_is_vsi_valid(hw, vsi_handle))
4780                 return ICE_ERR_PARAM;
4781
4782         ice_acquire_lock(&pi->sched_lock);
4783
4784         q_ctx = ice_get_lan_q_ctx(hw, vsi_handle, tc, q_handle);
4785         if (!q_ctx) {
4786                 ice_debug(hw, ICE_DBG_SCHED, "Enaq: invalid queue handle %d\n",
4787                           q_handle);
4788                 status = ICE_ERR_PARAM;
4789                 goto ena_txq_exit;
4790         }
4791
4792         /* find a parent node */
4793         parent = ice_sched_get_free_qparent(pi, vsi_handle, tc,
4794                                             ICE_SCHED_NODE_OWNER_LAN);
4795         if (!parent) {
4796                 status = ICE_ERR_PARAM;
4797                 goto ena_txq_exit;
4798         }
4799
4800         buf->parent_teid = parent->info.node_teid;
4801         node.parent_teid = parent->info.node_teid;
4802         /* Mark that the values in the "generic" section as valid. The default
4803          * value in the "generic" section is zero. This means that :
4804          * - Scheduling mode is Bytes Per Second (BPS), indicated by Bit 0.
4805          * - 0 priority among siblings, indicated by Bit 1-3.
4806          * - WFQ, indicated by Bit 4.
4807          * - 0 Adjustment value is used in PSM credit update flow, indicated by
4808          * Bit 5-6.
4809          * - Bit 7 is reserved.
4810          * Without setting the generic section as valid in valid_sections, the
4811          * Admin queue command will fail with error code ICE_AQ_RC_EINVAL.
4812          */
4813         buf->txqs[0].info.valid_sections =
4814                 ICE_AQC_ELEM_VALID_GENERIC | ICE_AQC_ELEM_VALID_CIR |
4815                 ICE_AQC_ELEM_VALID_EIR;
4816         buf->txqs[0].info.generic = 0;
4817         buf->txqs[0].info.cir_bw.bw_profile_idx =
4818                 CPU_TO_LE16(ICE_SCHED_DFLT_RL_PROF_ID);
4819         buf->txqs[0].info.cir_bw.bw_alloc =
4820                 CPU_TO_LE16(ICE_SCHED_DFLT_BW_WT);
4821         buf->txqs[0].info.eir_bw.bw_profile_idx =
4822                 CPU_TO_LE16(ICE_SCHED_DFLT_RL_PROF_ID);
4823         buf->txqs[0].info.eir_bw.bw_alloc =
4824                 CPU_TO_LE16(ICE_SCHED_DFLT_BW_WT);
4825
4826         /* add the LAN queue */
4827         status = ice_aq_add_lan_txq(hw, num_qgrps, buf, buf_size, cd);
4828         if (status != ICE_SUCCESS) {
4829                 ice_debug(hw, ICE_DBG_SCHED, "enable queue %d failed %d\n",
4830                           LE16_TO_CPU(buf->txqs[0].txq_id),
4831                           hw->adminq.sq_last_status);
4832                 goto ena_txq_exit;
4833         }
4834
4835         node.node_teid = buf->txqs[0].q_teid;
4836         node.data.elem_type = ICE_AQC_ELEM_TYPE_LEAF;
4837         q_ctx->q_handle = q_handle;
4838         q_ctx->q_teid = LE32_TO_CPU(node.node_teid);
4839
4840         /* add a leaf node into scheduler tree queue layer */
4841         status = ice_sched_add_node(pi, hw->num_tx_sched_layers - 1, &node);
4842         if (!status)
4843                 status = ice_sched_replay_q_bw(pi, q_ctx);
4844
4845 ena_txq_exit:
4846         ice_release_lock(&pi->sched_lock);
4847         return status;
4848 }
4849
4850 /**
4851  * ice_dis_vsi_txq
4852  * @pi: port information structure
4853  * @vsi_handle: software VSI handle
4854  * @tc: TC number
4855  * @num_queues: number of queues
4856  * @q_handles: pointer to software queue handle array
4857  * @q_ids: pointer to the q_id array
4858  * @q_teids: pointer to queue node teids
4859  * @rst_src: if called due to reset, specifies the reset source
4860  * @vmvf_num: the relative VM or VF number that is undergoing the reset
4861  * @cd: pointer to command details structure or NULL
4862  *
4863  * This function removes queues and their corresponding nodes in SW DB
4864  */
4865 enum ice_status
4866 ice_dis_vsi_txq(struct ice_port_info *pi, u16 vsi_handle, u8 tc, u8 num_queues,
4867                 u16 *q_handles, u16 *q_ids, u32 *q_teids,
4868                 enum ice_disq_rst_src rst_src, u16 vmvf_num,
4869                 struct ice_sq_cd *cd)
4870 {
4871         enum ice_status status = ICE_ERR_DOES_NOT_EXIST;
4872         struct ice_aqc_dis_txq_item *qg_list;
4873         struct ice_q_ctx *q_ctx;
4874         struct ice_hw *hw;
4875         u16 i, buf_size;
4876
4877         if (!pi || pi->port_state != ICE_SCHED_PORT_STATE_READY)
4878                 return ICE_ERR_CFG;
4879
4880         hw = pi->hw;
4881
4882         if (!num_queues) {
4883                 /* if queue is disabled already yet the disable queue command
4884                  * has to be sent to complete the VF reset, then call
4885                  * ice_aq_dis_lan_txq without any queue information
4886                  */
4887                 if (rst_src)
4888                         return ice_aq_dis_lan_txq(hw, 0, NULL, 0, rst_src,
4889                                                   vmvf_num, NULL);
4890                 return ICE_ERR_CFG;
4891         }
4892
4893         buf_size = ice_struct_size(qg_list, q_id, 1);
4894         qg_list = (struct ice_aqc_dis_txq_item *)ice_malloc(hw, buf_size);
4895         if (!qg_list)
4896                 return ICE_ERR_NO_MEMORY;
4897
4898         ice_acquire_lock(&pi->sched_lock);
4899
4900         for (i = 0; i < num_queues; i++) {
4901                 struct ice_sched_node *node;
4902
4903                 node = ice_sched_find_node_by_teid(pi->root, q_teids[i]);
4904                 if (!node)
4905                         continue;
4906                 q_ctx = ice_get_lan_q_ctx(hw, vsi_handle, tc, q_handles[i]);
4907                 if (!q_ctx) {
4908                         ice_debug(hw, ICE_DBG_SCHED, "invalid queue handle%d\n",
4909                                   q_handles[i]);
4910                         continue;
4911                 }
4912                 if (q_ctx->q_handle != q_handles[i]) {
4913                         ice_debug(hw, ICE_DBG_SCHED, "Err:handles %d %d\n",
4914                                   q_ctx->q_handle, q_handles[i]);
4915                         continue;
4916                 }
4917                 qg_list->parent_teid = node->info.parent_teid;
4918                 qg_list->num_qs = 1;
4919                 qg_list->q_id[0] = CPU_TO_LE16(q_ids[i]);
4920                 status = ice_aq_dis_lan_txq(hw, 1, qg_list, buf_size, rst_src,
4921                                             vmvf_num, cd);
4922
4923                 if (status != ICE_SUCCESS)
4924                         break;
4925                 ice_free_sched_node(pi, node);
4926                 q_ctx->q_handle = ICE_INVAL_Q_HANDLE;
4927         }
4928         ice_release_lock(&pi->sched_lock);
4929         ice_free(hw, qg_list);
4930         return status;
4931 }
4932
4933 /**
4934  * ice_cfg_vsi_qs - configure the new/existing VSI queues
4935  * @pi: port information structure
4936  * @vsi_handle: software VSI handle
4937  * @tc_bitmap: TC bitmap
4938  * @maxqs: max queues array per TC
4939  * @owner: LAN or RDMA
4940  *
4941  * This function adds/updates the VSI queues per TC.
4942  */
4943 static enum ice_status
4944 ice_cfg_vsi_qs(struct ice_port_info *pi, u16 vsi_handle, u16 tc_bitmap,
4945                u16 *maxqs, u8 owner)
4946 {
4947         enum ice_status status = ICE_SUCCESS;
4948         u8 i;
4949
4950         if (!pi || pi->port_state != ICE_SCHED_PORT_STATE_READY)
4951                 return ICE_ERR_CFG;
4952
4953         if (!ice_is_vsi_valid(pi->hw, vsi_handle))
4954                 return ICE_ERR_PARAM;
4955
4956         ice_acquire_lock(&pi->sched_lock);
4957
4958         ice_for_each_traffic_class(i) {
4959                 /* configuration is possible only if TC node is present */
4960                 if (!ice_sched_get_tc_node(pi, i))
4961                         continue;
4962
4963                 status = ice_sched_cfg_vsi(pi, vsi_handle, i, maxqs[i], owner,
4964                                            ice_is_tc_ena(tc_bitmap, i));
4965                 if (status)
4966                         break;
4967         }
4968
4969         ice_release_lock(&pi->sched_lock);
4970         return status;
4971 }
4972
4973 /**
4974  * ice_cfg_vsi_lan - configure VSI LAN queues
4975  * @pi: port information structure
4976  * @vsi_handle: software VSI handle
4977  * @tc_bitmap: TC bitmap
4978  * @max_lanqs: max LAN queues array per TC
4979  *
4980  * This function adds/updates the VSI LAN queues per TC.
4981  */
4982 enum ice_status
4983 ice_cfg_vsi_lan(struct ice_port_info *pi, u16 vsi_handle, u16 tc_bitmap,
4984                 u16 *max_lanqs)
4985 {
4986         return ice_cfg_vsi_qs(pi, vsi_handle, tc_bitmap, max_lanqs,
4987                               ICE_SCHED_NODE_OWNER_LAN);
4988 }
4989
4990 /**
4991  * ice_is_main_vsi - checks whether the VSI is main VSI
4992  * @hw: pointer to the HW struct
4993  * @vsi_handle: VSI handle
4994  *
4995  * Checks whether the VSI is the main VSI (the first PF VSI created on
4996  * given PF).
4997  */
4998 static bool ice_is_main_vsi(struct ice_hw *hw, u16 vsi_handle)
4999 {
5000         return vsi_handle == ICE_MAIN_VSI_HANDLE && hw->vsi_ctx[vsi_handle];
5001 }
5002
5003 /**
5004  * ice_replay_pre_init - replay pre initialization
5005  * @hw: pointer to the HW struct
5006  * @sw: pointer to switch info struct for which function initializes filters
5007  *
5008  * Initializes required config data for VSI, FD, ACL, and RSS before replay.
5009  */
5010 static enum ice_status
5011 ice_replay_pre_init(struct ice_hw *hw, struct ice_switch_info *sw)
5012 {
5013         enum ice_status status;
5014         u8 i;
5015
5016         /* Delete old entries from replay filter list head if there is any */
5017         ice_rm_sw_replay_rule_info(hw, sw);
5018         /* In start of replay, move entries into replay_rules list, it
5019          * will allow adding rules entries back to filt_rules list,
5020          * which is operational list.
5021          */
5022         for (i = 0; i < ICE_MAX_NUM_RECIPES; i++)
5023                 LIST_REPLACE_INIT(&sw->recp_list[i].filt_rules,
5024                                   &sw->recp_list[i].filt_replay_rules);
5025         ice_sched_replay_agg_vsi_preinit(hw);
5026
5027         status = ice_sched_replay_root_node_bw(hw->port_info);
5028         if (status)
5029                 return status;
5030
5031         return ice_sched_replay_tc_node_bw(hw->port_info);
5032 }
5033
5034 /**
5035  * ice_replay_vsi - replay VSI configuration
5036  * @hw: pointer to the HW struct
5037  * @vsi_handle: driver VSI handle
5038  *
5039  * Restore all VSI configuration after reset. It is required to call this
5040  * function with main VSI first.
5041  */
5042 enum ice_status ice_replay_vsi(struct ice_hw *hw, u16 vsi_handle)
5043 {
5044         struct ice_switch_info *sw = hw->switch_info;
5045         struct ice_port_info *pi = hw->port_info;
5046         enum ice_status status;
5047
5048         if (!ice_is_vsi_valid(hw, vsi_handle))
5049                 return ICE_ERR_PARAM;
5050
5051         /* Replay pre-initialization if there is any */
5052         if (ice_is_main_vsi(hw, vsi_handle)) {
5053                 status = ice_replay_pre_init(hw, sw);
5054                 if (status)
5055                         return status;
5056         }
5057         /* Replay per VSI all RSS configurations */
5058         status = ice_replay_rss_cfg(hw, vsi_handle);
5059         if (status)
5060                 return status;
5061         /* Replay per VSI all filters */
5062         status = ice_replay_vsi_all_fltr(hw, pi, vsi_handle);
5063         if (!status)
5064                 status = ice_replay_vsi_agg(hw, vsi_handle);
5065         return status;
5066 }
5067
5068 /**
5069  * ice_replay_post - post replay configuration cleanup
5070  * @hw: pointer to the HW struct
5071  *
5072  * Post replay cleanup.
5073  */
5074 void ice_replay_post(struct ice_hw *hw)
5075 {
5076         /* Delete old entries from replay filter list head */
5077         ice_rm_all_sw_replay_rule_info(hw);
5078         ice_sched_replay_agg(hw);
5079 }
5080
5081 /**
5082  * ice_stat_update40 - read 40 bit stat from the chip and update stat values
5083  * @hw: ptr to the hardware info
5084  * @reg: offset of 64 bit HW register to read from
5085  * @prev_stat_loaded: bool to specify if previous stats are loaded
5086  * @prev_stat: ptr to previous loaded stat value
5087  * @cur_stat: ptr to current stat value
5088  */
5089 void
5090 ice_stat_update40(struct ice_hw *hw, u32 reg, bool prev_stat_loaded,
5091                   u64 *prev_stat, u64 *cur_stat)
5092 {
5093         u64 new_data = rd64(hw, reg) & (BIT_ULL(40) - 1);
5094
5095         /* device stats are not reset at PFR, they likely will not be zeroed
5096          * when the driver starts. Thus, save the value from the first read
5097          * without adding to the statistic value so that we report stats which
5098          * count up from zero.
5099          */
5100         if (!prev_stat_loaded) {
5101                 *prev_stat = new_data;
5102                 return;
5103         }
5104
5105         /* Calculate the difference between the new and old values, and then
5106          * add it to the software stat value.
5107          */
5108         if (new_data >= *prev_stat)
5109                 *cur_stat += new_data - *prev_stat;
5110         else
5111                 /* to manage the potential roll-over */
5112                 *cur_stat += (new_data + BIT_ULL(40)) - *prev_stat;
5113
5114         /* Update the previously stored value to prepare for next read */
5115         *prev_stat = new_data;
5116 }
5117
5118 /**
5119  * ice_stat_update32 - read 32 bit stat from the chip and update stat values
5120  * @hw: ptr to the hardware info
5121  * @reg: offset of HW register to read from
5122  * @prev_stat_loaded: bool to specify if previous stats are loaded
5123  * @prev_stat: ptr to previous loaded stat value
5124  * @cur_stat: ptr to current stat value
5125  */
5126 void
5127 ice_stat_update32(struct ice_hw *hw, u32 reg, bool prev_stat_loaded,
5128                   u64 *prev_stat, u64 *cur_stat)
5129 {
5130         u32 new_data;
5131
5132         new_data = rd32(hw, reg);
5133
5134         /* device stats are not reset at PFR, they likely will not be zeroed
5135          * when the driver starts. Thus, save the value from the first read
5136          * without adding to the statistic value so that we report stats which
5137          * count up from zero.
5138          */
5139         if (!prev_stat_loaded) {
5140                 *prev_stat = new_data;
5141                 return;
5142         }
5143
5144         /* Calculate the difference between the new and old values, and then
5145          * add it to the software stat value.
5146          */
5147         if (new_data >= *prev_stat)
5148                 *cur_stat += new_data - *prev_stat;
5149         else
5150                 /* to manage the potential roll-over */
5151                 *cur_stat += (new_data + BIT_ULL(32)) - *prev_stat;
5152
5153         /* Update the previously stored value to prepare for next read */
5154         *prev_stat = new_data;
5155 }
5156
5157 /**
5158  * ice_stat_update_repc - read GLV_REPC stats from chip and update stat values
5159  * @hw: ptr to the hardware info
5160  * @vsi_handle: VSI handle
5161  * @prev_stat_loaded: bool to specify if the previous stat values are loaded
5162  * @cur_stats: ptr to current stats structure
5163  *
5164  * The GLV_REPC statistic register actually tracks two 16bit statistics, and
5165  * thus cannot be read using the normal ice_stat_update32 function.
5166  *
5167  * Read the GLV_REPC register associated with the given VSI, and update the
5168  * rx_no_desc and rx_error values in the ice_eth_stats structure.
5169  *
5170  * Because the statistics in GLV_REPC stick at 0xFFFF, the register must be
5171  * cleared each time it's read.
5172  *
5173  * Note that the GLV_RDPC register also counts the causes that would trigger
5174  * GLV_REPC. However, it does not give the finer grained detail about why the
5175  * packets are being dropped. The GLV_REPC values can be used to distinguish
5176  * whether Rx packets are dropped due to errors or due to no available
5177  * descriptors.
5178  */
5179 void
5180 ice_stat_update_repc(struct ice_hw *hw, u16 vsi_handle, bool prev_stat_loaded,
5181                      struct ice_eth_stats *cur_stats)
5182 {
5183         u16 vsi_num, no_desc, error_cnt;
5184         u32 repc;
5185
5186         if (!ice_is_vsi_valid(hw, vsi_handle))
5187                 return;
5188
5189         vsi_num = ice_get_hw_vsi_num(hw, vsi_handle);
5190
5191         /* If we haven't loaded stats yet, just clear the current value */
5192         if (!prev_stat_loaded) {
5193                 wr32(hw, GLV_REPC(vsi_num), 0);
5194                 return;
5195         }
5196
5197         repc = rd32(hw, GLV_REPC(vsi_num));
5198         no_desc = (repc & GLV_REPC_NO_DESC_CNT_M) >> GLV_REPC_NO_DESC_CNT_S;
5199         error_cnt = (repc & GLV_REPC_ERROR_CNT_M) >> GLV_REPC_ERROR_CNT_S;
5200
5201         /* Clear the count by writing to the stats register */
5202         wr32(hw, GLV_REPC(vsi_num), 0);
5203
5204         cur_stats->rx_no_desc += no_desc;
5205         cur_stats->rx_errors += error_cnt;
5206 }
5207
5208 /**
5209  * ice_sched_query_elem - query element information from HW
5210  * @hw: pointer to the HW struct
5211  * @node_teid: node TEID to be queried
5212  * @buf: buffer to element information
5213  *
5214  * This function queries HW element information
5215  */
5216 enum ice_status
5217 ice_sched_query_elem(struct ice_hw *hw, u32 node_teid,
5218                      struct ice_aqc_txsched_elem_data *buf)
5219 {
5220         u16 buf_size, num_elem_ret = 0;
5221         enum ice_status status;
5222
5223         buf_size = sizeof(*buf);
5224         ice_memset(buf, 0, buf_size, ICE_NONDMA_MEM);
5225         buf->node_teid = CPU_TO_LE32(node_teid);
5226         status = ice_aq_query_sched_elems(hw, 1, buf, buf_size, &num_elem_ret,
5227                                           NULL);
5228         if (status != ICE_SUCCESS || num_elem_ret != 1)
5229                 ice_debug(hw, ICE_DBG_SCHED, "query element failed\n");
5230         return status;
5231 }
5232
5233 /**
5234  * ice_get_fw_mode - returns FW mode
5235  * @hw: pointer to the HW struct
5236  */
5237 enum ice_fw_modes ice_get_fw_mode(struct ice_hw *hw)
5238 {
5239 #define ICE_FW_MODE_DBG_M BIT(0)
5240 #define ICE_FW_MODE_REC_M BIT(1)
5241 #define ICE_FW_MODE_ROLLBACK_M BIT(2)
5242         u32 fw_mode;
5243
5244         /* check the current FW mode */
5245         fw_mode = rd32(hw, GL_MNG_FWSM) & GL_MNG_FWSM_FW_MODES_M;
5246
5247         if (fw_mode & ICE_FW_MODE_DBG_M)
5248                 return ICE_FW_MODE_DBG;
5249         else if (fw_mode & ICE_FW_MODE_REC_M)
5250                 return ICE_FW_MODE_REC;
5251         else if (fw_mode & ICE_FW_MODE_ROLLBACK_M)
5252                 return ICE_FW_MODE_ROLLBACK;
5253         else
5254                 return ICE_FW_MODE_NORMAL;
5255 }
5256
5257 /**
5258  * ice_aq_read_i2c
5259  * @hw: pointer to the hw struct
5260  * @topo_addr: topology address for a device to communicate with
5261  * @bus_addr: 7-bit I2C bus address
5262  * @addr: I2C memory address (I2C offset) with up to 16 bits
5263  * @params: I2C parameters: bit [7] - Repeated start, bits [6:5] data offset size,
5264  *                          bit [4] - I2C address type, bits [3:0] - data size to read (0-16 bytes)
5265  * @data: pointer to data (0 to 16 bytes) to be read from the I2C device
5266  * @cd: pointer to command details structure or NULL
5267  *
5268  * Read I2C (0x06E2)
5269  */
5270 enum ice_status
5271 ice_aq_read_i2c(struct ice_hw *hw, struct ice_aqc_link_topo_addr topo_addr,
5272                 u16 bus_addr, __le16 addr, u8 params, u8 *data,
5273                 struct ice_sq_cd *cd)
5274 {
5275         struct ice_aq_desc desc = { 0 };
5276         struct ice_aqc_i2c *cmd;
5277         enum ice_status status;
5278         u8 data_size;
5279
5280         ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_read_i2c);
5281         cmd = &desc.params.read_write_i2c;
5282
5283         if (!data)
5284                 return ICE_ERR_PARAM;
5285
5286         data_size = (params & ICE_AQC_I2C_DATA_SIZE_M) >> ICE_AQC_I2C_DATA_SIZE_S;
5287
5288         cmd->i2c_bus_addr = CPU_TO_LE16(bus_addr);
5289         cmd->topo_addr = topo_addr;
5290         cmd->i2c_params = params;
5291         cmd->i2c_addr = addr;
5292
5293         status = ice_aq_send_cmd(hw, &desc, NULL, 0, cd);
5294         if (!status) {
5295                 struct ice_aqc_read_i2c_resp *resp;
5296                 u8 i;
5297
5298                 resp = &desc.params.read_i2c_resp;
5299                 for (i = 0; i < data_size; i++) {
5300                         *data = resp->i2c_data[i];
5301                         data++;
5302                 }
5303         }
5304
5305         return status;
5306 }
5307
5308 /**
5309  * ice_aq_write_i2c
5310  * @hw: pointer to the hw struct
5311  * @topo_addr: topology address for a device to communicate with
5312  * @bus_addr: 7-bit I2C bus address
5313  * @addr: I2C memory address (I2C offset) with up to 16 bits
5314  * @params: I2C parameters: bit [4] - I2C address type, bits [3:0] - data size to write (0-7 bytes)
5315  * @data: pointer to data (0 to 4 bytes) to be written to the I2C device
5316  * @cd: pointer to command details structure or NULL
5317  *
5318  * Write I2C (0x06E3)
5319  */
5320 enum ice_status
5321 ice_aq_write_i2c(struct ice_hw *hw, struct ice_aqc_link_topo_addr topo_addr,
5322                  u16 bus_addr, __le16 addr, u8 params, u8 *data,
5323                  struct ice_sq_cd *cd)
5324 {
5325         struct ice_aq_desc desc = { 0 };
5326         struct ice_aqc_i2c *cmd;
5327         u8 i, data_size;
5328
5329         ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_write_i2c);
5330         cmd = &desc.params.read_write_i2c;
5331
5332         data_size = (params & ICE_AQC_I2C_DATA_SIZE_M) >> ICE_AQC_I2C_DATA_SIZE_S;
5333
5334         /* data_size limited to 4 */
5335         if (data_size > 4)
5336                 return ICE_ERR_PARAM;
5337
5338         cmd->i2c_bus_addr = CPU_TO_LE16(bus_addr);
5339         cmd->topo_addr = topo_addr;
5340         cmd->i2c_params = params;
5341         cmd->i2c_addr = addr;
5342
5343         for (i = 0; i < data_size; i++) {
5344                 cmd->i2c_data[i] = *data;
5345                 data++;
5346         }
5347
5348         return ice_aq_send_cmd(hw, &desc, NULL, 0, cd);
5349 }
5350
5351 /**
5352  * ice_aq_set_gpio
5353  * @hw: pointer to the hw struct
5354  * @gpio_ctrl_handle: GPIO controller node handle
5355  * @pin_idx: IO Number of the GPIO that needs to be set
5356  * @value: SW provide IO value to set in the LSB
5357  * @cd: pointer to command details structure or NULL
5358  *
5359  * Sends 0x06EC AQ command to set the GPIO pin state that's part of the topology
5360  */
5361 enum ice_status
5362 ice_aq_set_gpio(struct ice_hw *hw, u16 gpio_ctrl_handle, u8 pin_idx, bool value,
5363                 struct ice_sq_cd *cd)
5364 {
5365         struct ice_aqc_gpio *cmd;
5366         struct ice_aq_desc desc;
5367
5368         ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_set_gpio);
5369         cmd = &desc.params.read_write_gpio;
5370         cmd->gpio_ctrl_handle = gpio_ctrl_handle;
5371         cmd->gpio_num = pin_idx;
5372         cmd->gpio_val = value ? 1 : 0;
5373
5374         return ice_aq_send_cmd(hw, &desc, NULL, 0, cd);
5375 }
5376
5377 /**
5378  * ice_aq_get_gpio
5379  * @hw: pointer to the hw struct
5380  * @gpio_ctrl_handle: GPIO controller node handle
5381  * @pin_idx: IO Number of the GPIO that needs to be set
5382  * @value: IO value read
5383  * @cd: pointer to command details structure or NULL
5384  *
5385  * Sends 0x06ED AQ command to get the value of a GPIO signal which is part of
5386  * the topology
5387  */
5388 enum ice_status
5389 ice_aq_get_gpio(struct ice_hw *hw, u16 gpio_ctrl_handle, u8 pin_idx,
5390                 bool *value, struct ice_sq_cd *cd)
5391 {
5392         struct ice_aqc_gpio *cmd;
5393         struct ice_aq_desc desc;
5394         enum ice_status status;
5395
5396         ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_get_gpio);
5397         cmd = &desc.params.read_write_gpio;
5398         cmd->gpio_ctrl_handle = gpio_ctrl_handle;
5399         cmd->gpio_num = pin_idx;
5400
5401         status = ice_aq_send_cmd(hw, &desc, NULL, 0, cd);
5402         if (status)
5403                 return status;
5404
5405         *value = !!cmd->gpio_val;
5406         return ICE_SUCCESS;
5407 }
5408
5409 /**
5410  * ice_fw_supports_link_override
5411  * @hw: pointer to the hardware structure
5412  *
5413  * Checks if the firmware supports link override
5414  */
5415 bool ice_fw_supports_link_override(struct ice_hw *hw)
5416 {
5417         if (hw->api_maj_ver == ICE_FW_API_LINK_OVERRIDE_MAJ) {
5418                 if (hw->api_min_ver > ICE_FW_API_LINK_OVERRIDE_MIN)
5419                         return true;
5420                 if (hw->api_min_ver == ICE_FW_API_LINK_OVERRIDE_MIN &&
5421                     hw->api_patch >= ICE_FW_API_LINK_OVERRIDE_PATCH)
5422                         return true;
5423         } else if (hw->api_maj_ver > ICE_FW_API_LINK_OVERRIDE_MAJ) {
5424                 return true;
5425         }
5426
5427         return false;
5428 }
5429
5430 /**
5431  * ice_get_link_default_override
5432  * @ldo: pointer to the link default override struct
5433  * @pi: pointer to the port info struct
5434  *
5435  * Gets the link default override for a port
5436  */
5437 enum ice_status
5438 ice_get_link_default_override(struct ice_link_default_override_tlv *ldo,
5439                               struct ice_port_info *pi)
5440 {
5441         u16 i, tlv, tlv_len, tlv_start, buf, offset;
5442         struct ice_hw *hw = pi->hw;
5443         enum ice_status status;
5444
5445         status = ice_get_pfa_module_tlv(hw, &tlv, &tlv_len,
5446                                         ICE_SR_LINK_DEFAULT_OVERRIDE_PTR);
5447         if (status) {
5448                 ice_debug(hw, ICE_DBG_INIT, "Failed to read link override TLV.\n");
5449                 return status;
5450         }
5451
5452         /* Each port has its own config; calculate for our port */
5453         tlv_start = tlv + pi->lport * ICE_SR_PFA_LINK_OVERRIDE_WORDS +
5454                 ICE_SR_PFA_LINK_OVERRIDE_OFFSET;
5455
5456         /* link options first */
5457         status = ice_read_sr_word(hw, tlv_start, &buf);
5458         if (status) {
5459                 ice_debug(hw, ICE_DBG_INIT, "Failed to read override link options.\n");
5460                 return status;
5461         }
5462         ldo->options = buf & ICE_LINK_OVERRIDE_OPT_M;
5463         ldo->phy_config = (buf & ICE_LINK_OVERRIDE_PHY_CFG_M) >>
5464                 ICE_LINK_OVERRIDE_PHY_CFG_S;
5465
5466         /* link PHY config */
5467         offset = tlv_start + ICE_SR_PFA_LINK_OVERRIDE_FEC_OFFSET;
5468         status = ice_read_sr_word(hw, offset, &buf);
5469         if (status) {
5470                 ice_debug(hw, ICE_DBG_INIT, "Failed to read override phy config.\n");
5471                 return status;
5472         }
5473         ldo->fec_options = buf & ICE_LINK_OVERRIDE_FEC_OPT_M;
5474
5475         /* PHY types low */
5476         offset = tlv_start + ICE_SR_PFA_LINK_OVERRIDE_PHY_OFFSET;
5477         for (i = 0; i < ICE_SR_PFA_LINK_OVERRIDE_PHY_WORDS; i++) {
5478                 status = ice_read_sr_word(hw, (offset + i), &buf);
5479                 if (status) {
5480                         ice_debug(hw, ICE_DBG_INIT, "Failed to read override link options.\n");
5481                         return status;
5482                 }
5483                 /* shift 16 bits at a time to fill 64 bits */
5484                 ldo->phy_type_low |= ((u64)buf << (i * 16));
5485         }
5486
5487         /* PHY types high */
5488         offset = tlv_start + ICE_SR_PFA_LINK_OVERRIDE_PHY_OFFSET +
5489                 ICE_SR_PFA_LINK_OVERRIDE_PHY_WORDS;
5490         for (i = 0; i < ICE_SR_PFA_LINK_OVERRIDE_PHY_WORDS; i++) {
5491                 status = ice_read_sr_word(hw, (offset + i), &buf);
5492                 if (status) {
5493                         ice_debug(hw, ICE_DBG_INIT, "Failed to read override link options.\n");
5494                         return status;
5495                 }
5496                 /* shift 16 bits at a time to fill 64 bits */
5497                 ldo->phy_type_high |= ((u64)buf << (i * 16));
5498         }
5499
5500         return status;
5501 }
5502
5503 /**
5504  * ice_is_phy_caps_an_enabled - check if PHY capabilities autoneg is enabled
5505  * @caps: get PHY capability data
5506  */
5507 bool ice_is_phy_caps_an_enabled(struct ice_aqc_get_phy_caps_data *caps)
5508 {
5509         if (caps->caps & ICE_AQC_PHY_AN_MODE ||
5510             caps->low_power_ctrl_an & (ICE_AQC_PHY_AN_EN_CLAUSE28 |
5511                                        ICE_AQC_PHY_AN_EN_CLAUSE73 |
5512                                        ICE_AQC_PHY_AN_EN_CLAUSE37))
5513                 return true;
5514
5515         return false;
5516 }
5517
5518 /**
5519  * ice_aq_set_lldp_mib - Set the LLDP MIB
5520  * @hw: pointer to the HW struct
5521  * @mib_type: Local, Remote or both Local and Remote MIBs
5522  * @buf: pointer to the caller-supplied buffer to store the MIB block
5523  * @buf_size: size of the buffer (in bytes)
5524  * @cd: pointer to command details structure or NULL
5525  *
5526  * Set the LLDP MIB. (0x0A08)
5527  */
5528 enum ice_status
5529 ice_aq_set_lldp_mib(struct ice_hw *hw, u8 mib_type, void *buf, u16 buf_size,
5530                     struct ice_sq_cd *cd)
5531 {
5532         struct ice_aqc_lldp_set_local_mib *cmd;
5533         struct ice_aq_desc desc;
5534
5535         cmd = &desc.params.lldp_set_mib;
5536
5537         if (buf_size == 0 || !buf)
5538                 return ICE_ERR_PARAM;
5539
5540         ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_lldp_set_local_mib);
5541
5542         desc.flags |= CPU_TO_LE16((u16)ICE_AQ_FLAG_RD);
5543         desc.datalen = CPU_TO_LE16(buf_size);
5544
5545         cmd->type = mib_type;
5546         cmd->length = CPU_TO_LE16(buf_size);
5547
5548         return ice_aq_send_cmd(hw, &desc, buf, buf_size, cd);
5549 }
5550
5551 /**
5552  * ice_fw_supports_lldp_fltr_ctrl - check NVM version supports lldp_fltr_ctrl
5553  * @hw: pointer to HW struct
5554  */
5555 bool ice_fw_supports_lldp_fltr_ctrl(struct ice_hw *hw)
5556 {
5557         if (hw->mac_type != ICE_MAC_E810)
5558                 return false;
5559
5560         if (hw->api_maj_ver == ICE_FW_API_LLDP_FLTR_MAJ) {
5561                 if (hw->api_min_ver > ICE_FW_API_LLDP_FLTR_MIN)
5562                         return true;
5563                 if (hw->api_min_ver == ICE_FW_API_LLDP_FLTR_MIN &&
5564                     hw->api_patch >= ICE_FW_API_LLDP_FLTR_PATCH)
5565                         return true;
5566         } else if (hw->api_maj_ver > ICE_FW_API_LLDP_FLTR_MAJ) {
5567                 return true;
5568         }
5569         return false;
5570 }
5571
5572 /**
5573  * ice_lldp_fltr_add_remove - add or remove a LLDP Rx switch filter
5574  * @hw: pointer to HW struct
5575  * @vsi_num: absolute HW index for VSI
5576  * @add: boolean for if adding or removing a filter
5577  */
5578 enum ice_status
5579 ice_lldp_fltr_add_remove(struct ice_hw *hw, u16 vsi_num, bool add)
5580 {
5581         struct ice_aqc_lldp_filter_ctrl *cmd;
5582         struct ice_aq_desc desc;
5583
5584         cmd = &desc.params.lldp_filter_ctrl;
5585
5586         ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_lldp_filter_ctrl);
5587
5588         if (add)
5589                 cmd->cmd_flags = ICE_AQC_LLDP_FILTER_ACTION_ADD;
5590         else
5591                 cmd->cmd_flags = ICE_AQC_LLDP_FILTER_ACTION_DELETE;
5592
5593         cmd->vsi_num = CPU_TO_LE16(vsi_num);
5594
5595         return ice_aq_send_cmd(hw, &desc, NULL, 0, NULL);
5596 }
5597
5598 /**
5599  * ice_fw_supports_report_dflt_cfg
5600  * @hw: pointer to the hardware structure
5601  *
5602  * Checks if the firmware supports report default configuration
5603  */
5604 bool ice_fw_supports_report_dflt_cfg(struct ice_hw *hw)
5605 {
5606         if (hw->api_maj_ver == ICE_FW_API_REPORT_DFLT_CFG_MAJ) {
5607                 if (hw->api_min_ver > ICE_FW_API_REPORT_DFLT_CFG_MIN)
5608                         return true;
5609                 if (hw->api_min_ver == ICE_FW_API_REPORT_DFLT_CFG_MIN &&
5610                     hw->api_patch >= ICE_FW_API_REPORT_DFLT_CFG_PATCH)
5611                         return true;
5612         } else if (hw->api_maj_ver > ICE_FW_API_REPORT_DFLT_CFG_MAJ) {
5613                 return true;
5614         }
5615         return false;
5616 }