LCOV - code coverage report
Current view: top level - drivers/net/ixgbe/base - ixgbe_api.c (source / functions) Hit Total Coverage
Test: Code coverage Lines: 0 333 0.0 %
Date: 2024-01-22 15:55:54 Functions: 0 107 0.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 232 0.0 %

           Branch data     Line data    Source code
       1                 :            : /* SPDX-License-Identifier: BSD-3-Clause
       2                 :            :  * Copyright(c) 2001-2020 Intel Corporation
       3                 :            :  */
       4                 :            : 
       5                 :            : #include "ixgbe_api.h"
       6                 :            : #include "ixgbe_common.h"
       7                 :            : 
       8                 :            : #define IXGBE_EMPTY_PARAM
       9                 :            : 
      10                 :            : static const u32 ixgbe_mvals_base[IXGBE_MVALS_IDX_LIMIT] = {
      11                 :            :         IXGBE_MVALS_INIT(IXGBE_EMPTY_PARAM)
      12                 :            : };
      13                 :            : 
      14                 :            : static const u32 ixgbe_mvals_X540[IXGBE_MVALS_IDX_LIMIT] = {
      15                 :            :         IXGBE_MVALS_INIT(_X540)
      16                 :            : };
      17                 :            : 
      18                 :            : static const u32 ixgbe_mvals_X550[IXGBE_MVALS_IDX_LIMIT] = {
      19                 :            :         IXGBE_MVALS_INIT(_X550)
      20                 :            : };
      21                 :            : 
      22                 :            : static const u32 ixgbe_mvals_X550EM_x[IXGBE_MVALS_IDX_LIMIT] = {
      23                 :            :         IXGBE_MVALS_INIT(_X550EM_x)
      24                 :            : };
      25                 :            : 
      26                 :            : static const u32 ixgbe_mvals_X550EM_a[IXGBE_MVALS_IDX_LIMIT] = {
      27                 :            :         IXGBE_MVALS_INIT(_X550EM_a)
      28                 :            : };
      29                 :            : 
      30                 :            : /**
      31                 :            :  * ixgbe_dcb_get_rtrup2tc - read rtrup2tc reg
      32                 :            :  * @hw: pointer to hardware structure
      33                 :            :  * @map: pointer to u8 arr for returning map
      34                 :            :  *
      35                 :            :  * Read the rtrup2tc HW register and resolve its content into map
      36                 :            :  **/
      37                 :          0 : void ixgbe_dcb_get_rtrup2tc(struct ixgbe_hw *hw, u8 *map)
      38                 :            : {
      39         [ #  # ]:          0 :         if (hw->mac.ops.get_rtrup2tc)
      40                 :          0 :                 hw->mac.ops.get_rtrup2tc(hw, map);
      41                 :          0 : }
      42                 :            : 
      43                 :            : /**
      44                 :            :  * ixgbe_init_shared_code - Initialize the shared code
      45                 :            :  * @hw: pointer to hardware structure
      46                 :            :  *
      47                 :            :  * This will assign function pointers and assign the MAC type and PHY code.
      48                 :            :  * Does not touch the hardware. This function must be called prior to any
      49                 :            :  * other function in the shared code. The ixgbe_hw structure should be
      50                 :            :  * memset to 0 prior to calling this function.  The following fields in
      51                 :            :  * hw structure should be filled in prior to calling this function:
      52                 :            :  * hw_addr, back, device_id, vendor_id, subsystem_device_id,
      53                 :            :  * subsystem_vendor_id, and revision_id
      54                 :            :  **/
      55                 :          0 : s32 ixgbe_init_shared_code(struct ixgbe_hw *hw)
      56                 :            : {
      57                 :            :         s32 status;
      58                 :            : 
      59                 :          0 :         DEBUGFUNC("ixgbe_init_shared_code");
      60                 :            : 
      61                 :            :         /*
      62                 :            :          * Set the mac type
      63                 :            :          */
      64                 :          0 :         ixgbe_set_mac_type(hw);
      65                 :            : 
      66   [ #  #  #  #  :          0 :         switch (hw->mac.type) {
             #  #  #  # ]
      67                 :          0 :         case ixgbe_mac_82598EB:
      68                 :          0 :                 status = ixgbe_init_ops_82598(hw);
      69                 :          0 :                 break;
      70                 :          0 :         case ixgbe_mac_82599EB:
      71                 :          0 :                 status = ixgbe_init_ops_82599(hw);
      72                 :          0 :                 break;
      73                 :          0 :         case ixgbe_mac_X540:
      74                 :          0 :                 status = ixgbe_init_ops_X540(hw);
      75                 :          0 :                 break;
      76                 :          0 :         case ixgbe_mac_X550:
      77                 :          0 :                 status = ixgbe_init_ops_X550(hw);
      78                 :          0 :                 break;
      79                 :          0 :         case ixgbe_mac_X550EM_x:
      80                 :          0 :                 status = ixgbe_init_ops_X550EM_x(hw);
      81                 :          0 :                 break;
      82                 :          0 :         case ixgbe_mac_X550EM_a:
      83                 :          0 :                 status = ixgbe_init_ops_X550EM_a(hw);
      84                 :          0 :                 break;
      85                 :          0 :         case ixgbe_mac_82599_vf:
      86                 :            :         case ixgbe_mac_X540_vf:
      87                 :            :         case ixgbe_mac_X550_vf:
      88                 :            :         case ixgbe_mac_X550EM_x_vf:
      89                 :            :         case ixgbe_mac_X550EM_a_vf:
      90                 :          0 :                 status = ixgbe_init_ops_vf(hw);
      91                 :          0 :                 break;
      92                 :            :         default:
      93                 :            :                 status = IXGBE_ERR_DEVICE_NOT_SUPPORTED;
      94                 :            :                 break;
      95                 :            :         }
      96                 :          0 :         hw->mac.max_link_up_time = IXGBE_LINK_UP_TIME;
      97                 :            : 
      98                 :          0 :         return status;
      99                 :            : }
     100                 :            : 
     101                 :            : /**
     102                 :            :  * ixgbe_set_mac_type - Sets MAC type
     103                 :            :  * @hw: pointer to the HW structure
     104                 :            :  *
     105                 :            :  * This function sets the mac type of the adapter based on the
     106                 :            :  * vendor ID and device ID stored in the hw structure.
     107                 :            :  **/
     108                 :          0 : s32 ixgbe_set_mac_type(struct ixgbe_hw *hw)
     109                 :            : {
     110                 :            :         s32 ret_val = IXGBE_SUCCESS;
     111                 :            : 
     112                 :          0 :         DEBUGFUNC("ixgbe_set_mac_type\n");
     113                 :            : 
     114         [ #  # ]:          0 :         if (hw->vendor_id != IXGBE_INTEL_VENDOR_ID) {
     115                 :          0 :                 ERROR_REPORT2(IXGBE_ERROR_UNSUPPORTED,
     116                 :            :                              "Unsupported vendor id: %x", hw->vendor_id);
     117                 :          0 :                 return IXGBE_ERR_DEVICE_NOT_SUPPORTED;
     118                 :            :         }
     119                 :            : 
     120                 :          0 :         hw->mvals = ixgbe_mvals_base;
     121                 :            : 
     122   [ #  #  #  #  :          0 :         switch (hw->device_id) {
          #  #  #  #  #  
                #  #  # ]
     123                 :          0 :         case IXGBE_DEV_ID_82598:
     124                 :            :         case IXGBE_DEV_ID_82598_BX:
     125                 :            :         case IXGBE_DEV_ID_82598AF_SINGLE_PORT:
     126                 :            :         case IXGBE_DEV_ID_82598AF_DUAL_PORT:
     127                 :            :         case IXGBE_DEV_ID_82598AT:
     128                 :            :         case IXGBE_DEV_ID_82598AT2:
     129                 :            :         case IXGBE_DEV_ID_82598EB_CX4:
     130                 :            :         case IXGBE_DEV_ID_82598_CX4_DUAL_PORT:
     131                 :            :         case IXGBE_DEV_ID_82598_DA_DUAL_PORT:
     132                 :            :         case IXGBE_DEV_ID_82598_SR_DUAL_PORT_EM:
     133                 :            :         case IXGBE_DEV_ID_82598EB_XF_LR:
     134                 :            :         case IXGBE_DEV_ID_82598EB_SFP_LOM:
     135                 :          0 :                 hw->mac.type = ixgbe_mac_82598EB;
     136                 :          0 :                 break;
     137                 :          0 :         case IXGBE_DEV_ID_82599_KX4:
     138                 :            :         case IXGBE_DEV_ID_82599_KX4_MEZZ:
     139                 :            :         case IXGBE_DEV_ID_82599_XAUI_LOM:
     140                 :            :         case IXGBE_DEV_ID_82599_COMBO_BACKPLANE:
     141                 :            :         case IXGBE_DEV_ID_82599_KR:
     142                 :            :         case IXGBE_DEV_ID_82599_SFP:
     143                 :            :         case IXGBE_DEV_ID_82599_BACKPLANE_FCOE:
     144                 :            :         case IXGBE_DEV_ID_82599_SFP_FCOE:
     145                 :            :         case IXGBE_DEV_ID_82599_SFP_EM:
     146                 :            :         case IXGBE_DEV_ID_82599_SFP_SF2:
     147                 :            :         case IXGBE_DEV_ID_82599_SFP_SF_QP:
     148                 :            :         case IXGBE_DEV_ID_82599_QSFP_SF_QP:
     149                 :            :         case IXGBE_DEV_ID_82599EN_SFP:
     150                 :            :         case IXGBE_DEV_ID_82599_CX4:
     151                 :            :         case IXGBE_DEV_ID_82599_T3_LOM:
     152                 :          0 :                 hw->mac.type = ixgbe_mac_82599EB;
     153                 :          0 :                 break;
     154                 :          0 :         case IXGBE_DEV_ID_82599_VF:
     155                 :            :         case IXGBE_DEV_ID_82599_VF_HV:
     156                 :          0 :                 hw->mac.type = ixgbe_mac_82599_vf;
     157                 :          0 :                 break;
     158                 :          0 :         case IXGBE_DEV_ID_X540_VF:
     159                 :            :         case IXGBE_DEV_ID_X540_VF_HV:
     160                 :          0 :                 hw->mac.type = ixgbe_mac_X540_vf;
     161                 :          0 :                 hw->mvals = ixgbe_mvals_X540;
     162                 :          0 :                 break;
     163                 :          0 :         case IXGBE_DEV_ID_X540T:
     164                 :            :         case IXGBE_DEV_ID_X540T1:
     165                 :          0 :                 hw->mac.type = ixgbe_mac_X540;
     166                 :          0 :                 hw->mvals = ixgbe_mvals_X540;
     167                 :          0 :                 break;
     168                 :          0 :         case IXGBE_DEV_ID_X550T:
     169                 :            :         case IXGBE_DEV_ID_X550T1:
     170                 :          0 :                 hw->mac.type = ixgbe_mac_X550;
     171                 :          0 :                 hw->mvals = ixgbe_mvals_X550;
     172                 :          0 :                 break;
     173                 :          0 :         case IXGBE_DEV_ID_X550EM_X_KX4:
     174                 :            :         case IXGBE_DEV_ID_X550EM_X_KR:
     175                 :            :         case IXGBE_DEV_ID_X550EM_X_10G_T:
     176                 :            :         case IXGBE_DEV_ID_X550EM_X_1G_T:
     177                 :            :         case IXGBE_DEV_ID_X550EM_X_SFP:
     178                 :            :         case IXGBE_DEV_ID_X550EM_X_XFI:
     179                 :          0 :                 hw->mac.type = ixgbe_mac_X550EM_x;
     180                 :          0 :                 hw->mvals = ixgbe_mvals_X550EM_x;
     181                 :          0 :                 break;
     182                 :          0 :         case IXGBE_DEV_ID_X550EM_A_KR:
     183                 :            :         case IXGBE_DEV_ID_X550EM_A_KR_L:
     184                 :            :         case IXGBE_DEV_ID_X550EM_A_SFP_N:
     185                 :            :         case IXGBE_DEV_ID_X550EM_A_SGMII:
     186                 :            :         case IXGBE_DEV_ID_X550EM_A_SGMII_L:
     187                 :            :         case IXGBE_DEV_ID_X550EM_A_1G_T:
     188                 :            :         case IXGBE_DEV_ID_X550EM_A_1G_T_L:
     189                 :            :         case IXGBE_DEV_ID_X550EM_A_10G_T:
     190                 :            :         case IXGBE_DEV_ID_X550EM_A_QSFP:
     191                 :            :         case IXGBE_DEV_ID_X550EM_A_QSFP_N:
     192                 :            :         case IXGBE_DEV_ID_X550EM_A_SFP:
     193                 :          0 :                 hw->mac.type = ixgbe_mac_X550EM_a;
     194                 :          0 :                 hw->mvals = ixgbe_mvals_X550EM_a;
     195                 :          0 :                 break;
     196                 :          0 :         case IXGBE_DEV_ID_X550_VF:
     197                 :            :         case IXGBE_DEV_ID_X550_VF_HV:
     198                 :          0 :                 hw->mac.type = ixgbe_mac_X550_vf;
     199                 :          0 :                 hw->mvals = ixgbe_mvals_X550;
     200                 :          0 :                 break;
     201                 :          0 :         case IXGBE_DEV_ID_X550EM_X_VF:
     202                 :            :         case IXGBE_DEV_ID_X550EM_X_VF_HV:
     203                 :          0 :                 hw->mac.type = ixgbe_mac_X550EM_x_vf;
     204                 :          0 :                 hw->mvals = ixgbe_mvals_X550EM_x;
     205                 :          0 :                 break;
     206                 :          0 :         case IXGBE_DEV_ID_X550EM_A_VF:
     207                 :            :         case IXGBE_DEV_ID_X550EM_A_VF_HV:
     208                 :          0 :                 hw->mac.type = ixgbe_mac_X550EM_a_vf;
     209                 :          0 :                 hw->mvals = ixgbe_mvals_X550EM_a;
     210                 :          0 :                 break;
     211                 :          0 :         default:
     212                 :            :                 ret_val = IXGBE_ERR_DEVICE_NOT_SUPPORTED;
     213                 :          0 :                 ERROR_REPORT2(IXGBE_ERROR_UNSUPPORTED,
     214                 :            :                              "Unsupported device id: %x",
     215                 :            :                              hw->device_id);
     216                 :          0 :                 break;
     217                 :            :         }
     218                 :            : 
     219                 :          0 :         DEBUGOUT2("ixgbe_set_mac_type found mac: %d, returns: %d\n",
     220                 :            :                   hw->mac.type, ret_val);
     221                 :          0 :         return ret_val;
     222                 :            : }
     223                 :            : 
     224                 :            : /**
     225                 :            :  * ixgbe_init_hw - Initialize the hardware
     226                 :            :  * @hw: pointer to hardware structure
     227                 :            :  *
     228                 :            :  * Initialize the hardware by resetting and then starting the hardware
     229                 :            :  **/
     230                 :          0 : s32 ixgbe_init_hw(struct ixgbe_hw *hw)
     231                 :            : {
     232         [ #  # ]:          0 :         return ixgbe_call_func(hw, hw->mac.ops.init_hw, (hw),
     233                 :            :                                IXGBE_NOT_IMPLEMENTED);
     234                 :            : }
     235                 :            : 
     236                 :            : /**
     237                 :            :  * ixgbe_reset_hw - Performs a hardware reset
     238                 :            :  * @hw: pointer to hardware structure
     239                 :            :  *
     240                 :            :  * Resets the hardware by resetting the transmit and receive units, masks and
     241                 :            :  * clears all interrupts, performs a PHY reset, and performs a MAC reset
     242                 :            :  **/
     243                 :          0 : s32 ixgbe_reset_hw(struct ixgbe_hw *hw)
     244                 :            : {
     245         [ #  # ]:          0 :         return ixgbe_call_func(hw, hw->mac.ops.reset_hw, (hw),
     246                 :            :                                IXGBE_NOT_IMPLEMENTED);
     247                 :            : }
     248                 :            : 
     249                 :            : /**
     250                 :            :  * ixgbe_start_hw - Prepares hardware for Rx/Tx
     251                 :            :  * @hw: pointer to hardware structure
     252                 :            :  *
     253                 :            :  * Starts the hardware by filling the bus info structure and media type,
     254                 :            :  * clears all on chip counters, initializes receive address registers,
     255                 :            :  * multicast table, VLAN filter table, calls routine to setup link and
     256                 :            :  * flow control settings, and leaves transmit and receive units disabled
     257                 :            :  * and uninitialized.
     258                 :            :  **/
     259                 :          0 : s32 ixgbe_start_hw(struct ixgbe_hw *hw)
     260                 :            : {
     261         [ #  # ]:          0 :         return ixgbe_call_func(hw, hw->mac.ops.start_hw, (hw),
     262                 :            :                                IXGBE_NOT_IMPLEMENTED);
     263                 :            : }
     264                 :            : 
     265                 :            : /**
     266                 :            :  * ixgbe_enable_relaxed_ordering - Enables tx relaxed ordering,
     267                 :            :  * which is disabled by default in ixgbe_start_hw();
     268                 :            :  *
     269                 :            :  * @hw: pointer to hardware structure
     270                 :            :  *
     271                 :            :  *  Enable relaxed ordering;
     272                 :            :  **/
     273                 :          0 : void ixgbe_enable_relaxed_ordering(struct ixgbe_hw *hw)
     274                 :            : {
     275         [ #  # ]:          0 :         if (hw->mac.ops.enable_relaxed_ordering)
     276                 :          0 :                 hw->mac.ops.enable_relaxed_ordering(hw);
     277                 :          0 : }
     278                 :            : 
     279                 :            : /**
     280                 :            :  * ixgbe_clear_hw_cntrs - Clear hardware counters
     281                 :            :  * @hw: pointer to hardware structure
     282                 :            :  *
     283                 :            :  * Clears all hardware statistics counters by reading them from the hardware
     284                 :            :  * Statistics counters are clear on read.
     285                 :            :  **/
     286                 :          0 : s32 ixgbe_clear_hw_cntrs(struct ixgbe_hw *hw)
     287                 :            : {
     288         [ #  # ]:          0 :         return ixgbe_call_func(hw, hw->mac.ops.clear_hw_cntrs, (hw),
     289                 :            :                                IXGBE_NOT_IMPLEMENTED);
     290                 :            : }
     291                 :            : 
     292                 :            : /**
     293                 :            :  * ixgbe_get_media_type - Get media type
     294                 :            :  * @hw: pointer to hardware structure
     295                 :            :  *
     296                 :            :  * Returns the media type (fiber, copper, backplane)
     297                 :            :  **/
     298                 :          0 : enum ixgbe_media_type ixgbe_get_media_type(struct ixgbe_hw *hw)
     299                 :            : {
     300         [ #  # ]:          0 :         return ixgbe_call_func(hw, hw->mac.ops.get_media_type, (hw),
     301                 :            :                                ixgbe_media_type_unknown);
     302                 :            : }
     303                 :            : 
     304                 :            : /**
     305                 :            :  * ixgbe_get_mac_addr - Get MAC address
     306                 :            :  * @hw: pointer to hardware structure
     307                 :            :  * @mac_addr: Adapter MAC address
     308                 :            :  *
     309                 :            :  * Reads the adapter's MAC address from the first Receive Address Register
     310                 :            :  * (RAR0) A reset of the adapter must have been performed prior to calling
     311                 :            :  * this function in order for the MAC address to have been loaded from the
     312                 :            :  * EEPROM into RAR0
     313                 :            :  **/
     314                 :          0 : s32 ixgbe_get_mac_addr(struct ixgbe_hw *hw, u8 *mac_addr)
     315                 :            : {
     316         [ #  # ]:          0 :         return ixgbe_call_func(hw, hw->mac.ops.get_mac_addr,
     317                 :            :                                (hw, mac_addr), IXGBE_NOT_IMPLEMENTED);
     318                 :            : }
     319                 :            : 
     320                 :            : /**
     321                 :            :  * ixgbe_get_san_mac_addr - Get SAN MAC address
     322                 :            :  * @hw: pointer to hardware structure
     323                 :            :  * @san_mac_addr: SAN MAC address
     324                 :            :  *
     325                 :            :  * Reads the SAN MAC address from the EEPROM, if it's available.  This is
     326                 :            :  * per-port, so set_lan_id() must be called before reading the addresses.
     327                 :            :  **/
     328                 :          0 : s32 ixgbe_get_san_mac_addr(struct ixgbe_hw *hw, u8 *san_mac_addr)
     329                 :            : {
     330         [ #  # ]:          0 :         return ixgbe_call_func(hw, hw->mac.ops.get_san_mac_addr,
     331                 :            :                                (hw, san_mac_addr), IXGBE_NOT_IMPLEMENTED);
     332                 :            : }
     333                 :            : 
     334                 :            : /**
     335                 :            :  * ixgbe_set_san_mac_addr - Write a SAN MAC address
     336                 :            :  * @hw: pointer to hardware structure
     337                 :            :  * @san_mac_addr: SAN MAC address
     338                 :            :  *
     339                 :            :  * Writes A SAN MAC address to the EEPROM.
     340                 :            :  **/
     341                 :          0 : s32 ixgbe_set_san_mac_addr(struct ixgbe_hw *hw, u8 *san_mac_addr)
     342                 :            : {
     343         [ #  # ]:          0 :         return ixgbe_call_func(hw, hw->mac.ops.set_san_mac_addr,
     344                 :            :                                (hw, san_mac_addr), IXGBE_NOT_IMPLEMENTED);
     345                 :            : }
     346                 :            : 
     347                 :            : /**
     348                 :            :  * ixgbe_get_device_caps - Get additional device capabilities
     349                 :            :  * @hw: pointer to hardware structure
     350                 :            :  * @device_caps: the EEPROM word for device capabilities
     351                 :            :  *
     352                 :            :  * Reads the extra device capabilities from the EEPROM
     353                 :            :  **/
     354                 :          0 : s32 ixgbe_get_device_caps(struct ixgbe_hw *hw, u16 *device_caps)
     355                 :            : {
     356         [ #  # ]:          0 :         return ixgbe_call_func(hw, hw->mac.ops.get_device_caps,
     357                 :            :                                (hw, device_caps), IXGBE_NOT_IMPLEMENTED);
     358                 :            : }
     359                 :            : 
     360                 :            : /**
     361                 :            :  * ixgbe_get_wwn_prefix - Get alternative WWNN/WWPN prefix from the EEPROM
     362                 :            :  * @hw: pointer to hardware structure
     363                 :            :  * @wwnn_prefix: the alternative WWNN prefix
     364                 :            :  * @wwpn_prefix: the alternative WWPN prefix
     365                 :            :  *
     366                 :            :  * This function will read the EEPROM from the alternative SAN MAC address
     367                 :            :  * block to check the support for the alternative WWNN/WWPN prefix support.
     368                 :            :  **/
     369                 :          0 : s32 ixgbe_get_wwn_prefix(struct ixgbe_hw *hw, u16 *wwnn_prefix,
     370                 :            :                          u16 *wwpn_prefix)
     371                 :            : {
     372         [ #  # ]:          0 :         return ixgbe_call_func(hw, hw->mac.ops.get_wwn_prefix,
     373                 :            :                                (hw, wwnn_prefix, wwpn_prefix),
     374                 :            :                                IXGBE_NOT_IMPLEMENTED);
     375                 :            : }
     376                 :            : 
     377                 :            : /**
     378                 :            :  * ixgbe_get_fcoe_boot_status -  Get FCOE boot status from EEPROM
     379                 :            :  * @hw: pointer to hardware structure
     380                 :            :  * @bs: the fcoe boot status
     381                 :            :  *
     382                 :            :  * This function will read the FCOE boot status from the iSCSI FCOE block
     383                 :            :  **/
     384                 :          0 : s32 ixgbe_get_fcoe_boot_status(struct ixgbe_hw *hw, u16 *bs)
     385                 :            : {
     386         [ #  # ]:          0 :         return ixgbe_call_func(hw, hw->mac.ops.get_fcoe_boot_status,
     387                 :            :                                (hw, bs),
     388                 :            :                                IXGBE_NOT_IMPLEMENTED);
     389                 :            : }
     390                 :            : 
     391                 :            : /**
     392                 :            :  * ixgbe_get_bus_info - Set PCI bus info
     393                 :            :  * @hw: pointer to hardware structure
     394                 :            :  *
     395                 :            :  * Sets the PCI bus info (speed, width, type) within the ixgbe_hw structure
     396                 :            :  **/
     397                 :          0 : s32 ixgbe_get_bus_info(struct ixgbe_hw *hw)
     398                 :            : {
     399         [ #  # ]:          0 :         return ixgbe_call_func(hw, hw->mac.ops.get_bus_info, (hw),
     400                 :            :                                IXGBE_NOT_IMPLEMENTED);
     401                 :            : }
     402                 :            : 
     403                 :            : /**
     404                 :            :  * ixgbe_get_num_of_tx_queues - Get Tx queues
     405                 :            :  * @hw: pointer to hardware structure
     406                 :            :  *
     407                 :            :  * Returns the number of transmit queues for the given adapter.
     408                 :            :  **/
     409                 :          0 : u32 ixgbe_get_num_of_tx_queues(struct ixgbe_hw *hw)
     410                 :            : {
     411                 :          0 :         return hw->mac.max_tx_queues;
     412                 :            : }
     413                 :            : 
     414                 :            : /**
     415                 :            :  * ixgbe_get_num_of_rx_queues - Get Rx queues
     416                 :            :  * @hw: pointer to hardware structure
     417                 :            :  *
     418                 :            :  * Returns the number of receive queues for the given adapter.
     419                 :            :  **/
     420                 :          0 : u32 ixgbe_get_num_of_rx_queues(struct ixgbe_hw *hw)
     421                 :            : {
     422                 :          0 :         return hw->mac.max_rx_queues;
     423                 :            : }
     424                 :            : 
     425                 :            : /**
     426                 :            :  * ixgbe_stop_adapter - Disable Rx/Tx units
     427                 :            :  * @hw: pointer to hardware structure
     428                 :            :  *
     429                 :            :  * Sets the adapter_stopped flag within ixgbe_hw struct. Clears interrupts,
     430                 :            :  * disables transmit and receive units. The adapter_stopped flag is used by
     431                 :            :  * the shared code and drivers to determine if the adapter is in a stopped
     432                 :            :  * state and should not touch the hardware.
     433                 :            :  **/
     434                 :          0 : s32 ixgbe_stop_adapter(struct ixgbe_hw *hw)
     435                 :            : {
     436         [ #  # ]:          0 :         return ixgbe_call_func(hw, hw->mac.ops.stop_adapter, (hw),
     437                 :            :                                IXGBE_NOT_IMPLEMENTED);
     438                 :            : }
     439                 :            : 
     440                 :            : /**
     441                 :            :  * ixgbe_read_pba_string - Reads part number string from EEPROM
     442                 :            :  * @hw: pointer to hardware structure
     443                 :            :  * @pba_num: stores the part number string from the EEPROM
     444                 :            :  * @pba_num_size: part number string buffer length
     445                 :            :  *
     446                 :            :  * Reads the part number string from the EEPROM.
     447                 :            :  **/
     448                 :          0 : s32 ixgbe_read_pba_string(struct ixgbe_hw *hw, u8 *pba_num, u32 pba_num_size)
     449                 :            : {
     450                 :          0 :         return ixgbe_read_pba_string_generic(hw, pba_num, pba_num_size);
     451                 :            : }
     452                 :            : 
     453                 :            : /**
     454                 :            :  * ixgbe_read_pba_num - Reads part number from EEPROM
     455                 :            :  * @hw: pointer to hardware structure
     456                 :            :  * @pba_num: stores the part number from the EEPROM
     457                 :            :  *
     458                 :            :  * Reads the part number from the EEPROM.
     459                 :            :  **/
     460                 :          0 : s32 ixgbe_read_pba_num(struct ixgbe_hw *hw, u32 *pba_num)
     461                 :            : {
     462                 :          0 :         return ixgbe_read_pba_num_generic(hw, pba_num);
     463                 :            : }
     464                 :            : 
     465                 :            : /**
     466                 :            :  * ixgbe_identify_phy - Get PHY type
     467                 :            :  * @hw: pointer to hardware structure
     468                 :            :  *
     469                 :            :  * Determines the physical layer module found on the current adapter.
     470                 :            :  **/
     471                 :          0 : s32 ixgbe_identify_phy(struct ixgbe_hw *hw)
     472                 :            : {
     473                 :            :         s32 status = IXGBE_SUCCESS;
     474                 :            : 
     475         [ #  # ]:          0 :         if (hw->phy.type == ixgbe_phy_unknown) {
     476         [ #  # ]:          0 :                 status = ixgbe_call_func(hw, hw->phy.ops.identify, (hw),
     477                 :            :                                          IXGBE_NOT_IMPLEMENTED);
     478                 :            :         }
     479                 :            : 
     480                 :          0 :         return status;
     481                 :            : }
     482                 :            : 
     483                 :            : /**
     484                 :            :  * ixgbe_reset_phy - Perform a PHY reset
     485                 :            :  * @hw: pointer to hardware structure
     486                 :            :  **/
     487                 :          0 : s32 ixgbe_reset_phy(struct ixgbe_hw *hw)
     488                 :            : {
     489                 :            :         s32 status = IXGBE_SUCCESS;
     490                 :            : 
     491         [ #  # ]:          0 :         if (hw->phy.type == ixgbe_phy_unknown) {
     492         [ #  # ]:          0 :                 if (ixgbe_identify_phy(hw) != IXGBE_SUCCESS)
     493                 :            :                         status = IXGBE_ERR_PHY;
     494                 :            :         }
     495                 :            : 
     496                 :            :         if (status == IXGBE_SUCCESS) {
     497         [ #  # ]:          0 :                 status = ixgbe_call_func(hw, hw->phy.ops.reset, (hw),
     498                 :            :                                          IXGBE_NOT_IMPLEMENTED);
     499                 :            :         }
     500                 :          0 :         return status;
     501                 :            : }
     502                 :            : 
     503                 :            : /**
     504                 :            :  * ixgbe_get_phy_firmware_version -
     505                 :            :  * @hw: pointer to hardware structure
     506                 :            :  * @firmware_version: pointer to firmware version
     507                 :            :  **/
     508                 :          0 : s32 ixgbe_get_phy_firmware_version(struct ixgbe_hw *hw, u16 *firmware_version)
     509                 :            : {
     510                 :            :         s32 status = IXGBE_SUCCESS;
     511                 :            : 
     512         [ #  # ]:          0 :         status = ixgbe_call_func(hw, hw->phy.ops.get_firmware_version,
     513                 :            :                                  (hw, firmware_version),
     514                 :            :                                  IXGBE_NOT_IMPLEMENTED);
     515                 :          0 :         return status;
     516                 :            : }
     517                 :            : 
     518                 :            : /**
     519                 :            :  * ixgbe_read_phy_reg - Read PHY register
     520                 :            :  * @hw: pointer to hardware structure
     521                 :            :  * @reg_addr: 32 bit address of PHY register to read
     522                 :            :  * @device_type: type of device you want to communicate with
     523                 :            :  * @phy_data: Pointer to read data from PHY register
     524                 :            :  *
     525                 :            :  * Reads a value from a specified PHY register
     526                 :            :  **/
     527                 :          0 : s32 ixgbe_read_phy_reg(struct ixgbe_hw *hw, u32 reg_addr, u32 device_type,
     528                 :            :                        u16 *phy_data)
     529                 :            : {
     530         [ #  # ]:          0 :         if (hw->phy.id == 0)
     531                 :          0 :                 ixgbe_identify_phy(hw);
     532                 :            : 
     533         [ #  # ]:          0 :         return ixgbe_call_func(hw, hw->phy.ops.read_reg, (hw, reg_addr,
     534                 :            :                                device_type, phy_data), IXGBE_NOT_IMPLEMENTED);
     535                 :            : }
     536                 :            : 
     537                 :            : /**
     538                 :            :  * ixgbe_write_phy_reg - Write PHY register
     539                 :            :  * @hw: pointer to hardware structure
     540                 :            :  * @reg_addr: 32 bit PHY register to write
     541                 :            :  * @device_type: type of device you want to communicate with
     542                 :            :  * @phy_data: Data to write to the PHY register
     543                 :            :  *
     544                 :            :  * Writes a value to specified PHY register
     545                 :            :  **/
     546                 :          0 : s32 ixgbe_write_phy_reg(struct ixgbe_hw *hw, u32 reg_addr, u32 device_type,
     547                 :            :                         u16 phy_data)
     548                 :            : {
     549         [ #  # ]:          0 :         if (hw->phy.id == 0)
     550                 :          0 :                 ixgbe_identify_phy(hw);
     551                 :            : 
     552         [ #  # ]:          0 :         return ixgbe_call_func(hw, hw->phy.ops.write_reg, (hw, reg_addr,
     553                 :            :                                device_type, phy_data), IXGBE_NOT_IMPLEMENTED);
     554                 :            : }
     555                 :            : 
     556                 :            : /**
     557                 :            :  * ixgbe_setup_phy_link - Restart PHY autoneg
     558                 :            :  * @hw: pointer to hardware structure
     559                 :            :  *
     560                 :            :  * Restart autonegotiation and PHY and waits for completion.
     561                 :            :  **/
     562                 :          0 : s32 ixgbe_setup_phy_link(struct ixgbe_hw *hw)
     563                 :            : {
     564         [ #  # ]:          0 :         return ixgbe_call_func(hw, hw->phy.ops.setup_link, (hw),
     565                 :            :                                IXGBE_NOT_IMPLEMENTED);
     566                 :            : }
     567                 :            : 
     568                 :            : /**
     569                 :            :  * ixgbe_setup_internal_phy - Configure integrated PHY
     570                 :            :  * @hw: pointer to hardware structure
     571                 :            :  *
     572                 :            :  * Reconfigure the integrated PHY in order to enable talk to the external PHY.
     573                 :            :  * Returns success if not implemented, since nothing needs to be done in this
     574                 :            :  * case.
     575                 :            :  */
     576                 :          0 : s32 ixgbe_setup_internal_phy(struct ixgbe_hw *hw)
     577                 :            : {
     578         [ #  # ]:          0 :         return ixgbe_call_func(hw, hw->phy.ops.setup_internal_link, (hw),
     579                 :            :                                IXGBE_SUCCESS);
     580                 :            : }
     581                 :            : 
     582                 :            : /**
     583                 :            :  * ixgbe_check_phy_link - Determine link and speed status
     584                 :            :  * @hw: pointer to hardware structure
     585                 :            :  * @speed: link speed
     586                 :            :  * @link_up: true when link is up
     587                 :            :  *
     588                 :            :  * Reads a PHY register to determine if link is up and the current speed for
     589                 :            :  * the PHY.
     590                 :            :  **/
     591                 :          0 : s32 ixgbe_check_phy_link(struct ixgbe_hw *hw, ixgbe_link_speed *speed,
     592                 :            :                          bool *link_up)
     593                 :            : {
     594         [ #  # ]:          0 :         return ixgbe_call_func(hw, hw->phy.ops.check_link, (hw, speed,
     595                 :            :                                link_up), IXGBE_NOT_IMPLEMENTED);
     596                 :            : }
     597                 :            : 
     598                 :            : /**
     599                 :            :  * ixgbe_setup_phy_link_speed - Set auto advertise
     600                 :            :  * @hw: pointer to hardware structure
     601                 :            :  * @speed: new link speed
     602                 :            :  * @autoneg_wait_to_complete: true when waiting for completion is needed
     603                 :            :  *
     604                 :            :  * Sets the auto advertised capabilities
     605                 :            :  **/
     606                 :          0 : s32 ixgbe_setup_phy_link_speed(struct ixgbe_hw *hw, ixgbe_link_speed speed,
     607                 :            :                                bool autoneg_wait_to_complete)
     608                 :            : {
     609         [ #  # ]:          0 :         return ixgbe_call_func(hw, hw->phy.ops.setup_link_speed, (hw, speed,
     610                 :            :                                autoneg_wait_to_complete),
     611                 :            :                                IXGBE_NOT_IMPLEMENTED);
     612                 :            : }
     613                 :            : 
     614                 :            : /**
     615                 :            :  * ixgbe_set_phy_power - Control the phy power state
     616                 :            :  * @hw: pointer to hardware structure
     617                 :            :  * @on: true for on, false for off
     618                 :            :  */
     619                 :          0 : s32 ixgbe_set_phy_power(struct ixgbe_hw *hw, bool on)
     620                 :            : {
     621         [ #  # ]:          0 :         return ixgbe_call_func(hw, hw->phy.ops.set_phy_power, (hw, on),
     622                 :            :                                IXGBE_NOT_IMPLEMENTED);
     623                 :            : }
     624                 :            : 
     625                 :            : /**
     626                 :            :  * ixgbe_check_link - Get link and speed status
     627                 :            :  * @hw: pointer to hardware structure
     628                 :            :  * @speed: pointer to link speed
     629                 :            :  * @link_up: true when link is up
     630                 :            :  * @link_up_wait_to_complete: bool used to wait for link up or not
     631                 :            :  *
     632                 :            :  * Reads the links register to determine if link is up and the current speed
     633                 :            :  **/
     634                 :          0 : s32 ixgbe_check_link(struct ixgbe_hw *hw, ixgbe_link_speed *speed,
     635                 :            :                      bool *link_up, bool link_up_wait_to_complete)
     636                 :            : {
     637         [ #  # ]:          0 :         return ixgbe_call_func(hw, hw->mac.ops.check_link, (hw, speed,
     638                 :            :                                link_up, link_up_wait_to_complete),
     639                 :            :                                IXGBE_NOT_IMPLEMENTED);
     640                 :            : }
     641                 :            : 
     642                 :            : /**
     643                 :            :  * ixgbe_disable_tx_laser - Disable Tx laser
     644                 :            :  * @hw: pointer to hardware structure
     645                 :            :  *
     646                 :            :  * If the driver needs to disable the laser on SFI optics.
     647                 :            :  **/
     648                 :          0 : void ixgbe_disable_tx_laser(struct ixgbe_hw *hw)
     649                 :            : {
     650         [ #  # ]:          0 :         if (hw->mac.ops.disable_tx_laser)
     651                 :          0 :                 hw->mac.ops.disable_tx_laser(hw);
     652                 :          0 : }
     653                 :            : 
     654                 :            : /**
     655                 :            :  * ixgbe_enable_tx_laser - Enable Tx laser
     656                 :            :  * @hw: pointer to hardware structure
     657                 :            :  *
     658                 :            :  * If the driver needs to enable the laser on SFI optics.
     659                 :            :  **/
     660                 :          0 : void ixgbe_enable_tx_laser(struct ixgbe_hw *hw)
     661                 :            : {
     662         [ #  # ]:          0 :         if (hw->mac.ops.enable_tx_laser)
     663                 :          0 :                 hw->mac.ops.enable_tx_laser(hw);
     664                 :          0 : }
     665                 :            : 
     666                 :            : /**
     667                 :            :  * ixgbe_flap_tx_laser - flap Tx laser to start autotry process
     668                 :            :  * @hw: pointer to hardware structure
     669                 :            :  *
     670                 :            :  * When the driver changes the link speeds that it can support then
     671                 :            :  * flap the tx laser to alert the link partner to start autotry
     672                 :            :  * process on its end.
     673                 :            :  **/
     674                 :          0 : void ixgbe_flap_tx_laser(struct ixgbe_hw *hw)
     675                 :            : {
     676         [ #  # ]:          0 :         if (hw->mac.ops.flap_tx_laser)
     677                 :          0 :                 hw->mac.ops.flap_tx_laser(hw);
     678                 :          0 : }
     679                 :            : 
     680                 :            : /**
     681                 :            :  * ixgbe_setup_link - Set link speed
     682                 :            :  * @hw: pointer to hardware structure
     683                 :            :  * @speed: new link speed
     684                 :            :  * @autoneg_wait_to_complete: true when waiting for completion is needed
     685                 :            :  *
     686                 :            :  * Configures link settings.  Restarts the link.
     687                 :            :  * Performs autonegotiation if needed.
     688                 :            :  **/
     689                 :          0 : s32 ixgbe_setup_link(struct ixgbe_hw *hw, ixgbe_link_speed speed,
     690                 :            :                      bool autoneg_wait_to_complete)
     691                 :            : {
     692         [ #  # ]:          0 :         return ixgbe_call_func(hw, hw->mac.ops.setup_link, (hw, speed,
     693                 :            :                                autoneg_wait_to_complete),
     694                 :            :                                IXGBE_NOT_IMPLEMENTED);
     695                 :            : }
     696                 :            : 
     697                 :            : /**
     698                 :            :  * ixgbe_setup_mac_link - Set link speed
     699                 :            :  * @hw: pointer to hardware structure
     700                 :            :  * @speed: new link speed
     701                 :            :  * @autoneg_wait_to_complete: true when waiting for completion is needed
     702                 :            :  *
     703                 :            :  * Configures link settings.  Restarts the link.
     704                 :            :  * Performs autonegotiation if needed.
     705                 :            :  **/
     706                 :          0 : s32 ixgbe_setup_mac_link(struct ixgbe_hw *hw, ixgbe_link_speed speed,
     707                 :            :                          bool autoneg_wait_to_complete)
     708                 :            : {
     709         [ #  # ]:          0 :         return ixgbe_call_func(hw, hw->mac.ops.setup_mac_link, (hw, speed,
     710                 :            :                                autoneg_wait_to_complete),
     711                 :            :                                IXGBE_NOT_IMPLEMENTED);
     712                 :            : }
     713                 :            : 
     714                 :            : /**
     715                 :            :  * ixgbe_get_link_capabilities - Returns link capabilities
     716                 :            :  * @hw: pointer to hardware structure
     717                 :            :  * @speed: link speed capabilities
     718                 :            :  * @autoneg: true when autoneg or autotry is enabled
     719                 :            :  *
     720                 :            :  * Determines the link capabilities of the current configuration.
     721                 :            :  **/
     722                 :          0 : s32 ixgbe_get_link_capabilities(struct ixgbe_hw *hw, ixgbe_link_speed *speed,
     723                 :            :                                 bool *autoneg)
     724                 :            : {
     725         [ #  # ]:          0 :         return ixgbe_call_func(hw, hw->mac.ops.get_link_capabilities, (hw,
     726                 :            :                                speed, autoneg), IXGBE_NOT_IMPLEMENTED);
     727                 :            : }
     728                 :            : 
     729                 :            : /**
     730                 :            :  * ixgbe_led_on - Turn on LEDs
     731                 :            :  * @hw: pointer to hardware structure
     732                 :            :  * @index: led number to turn on
     733                 :            :  *
     734                 :            :  * Turns on the software controllable LEDs.
     735                 :            :  **/
     736                 :          0 : s32 ixgbe_led_on(struct ixgbe_hw *hw, u32 index)
     737                 :            : {
     738         [ #  # ]:          0 :         return ixgbe_call_func(hw, hw->mac.ops.led_on, (hw, index),
     739                 :            :                                IXGBE_NOT_IMPLEMENTED);
     740                 :            : }
     741                 :            : 
     742                 :            : /**
     743                 :            :  * ixgbe_led_off - Turn off LEDs
     744                 :            :  * @hw: pointer to hardware structure
     745                 :            :  * @index: led number to turn off
     746                 :            :  *
     747                 :            :  * Turns off the software controllable LEDs.
     748                 :            :  **/
     749                 :          0 : s32 ixgbe_led_off(struct ixgbe_hw *hw, u32 index)
     750                 :            : {
     751         [ #  # ]:          0 :         return ixgbe_call_func(hw, hw->mac.ops.led_off, (hw, index),
     752                 :            :                                IXGBE_NOT_IMPLEMENTED);
     753                 :            : }
     754                 :            : 
     755                 :            : /**
     756                 :            :  * ixgbe_blink_led_start - Blink LEDs
     757                 :            :  * @hw: pointer to hardware structure
     758                 :            :  * @index: led number to blink
     759                 :            :  *
     760                 :            :  * Blink LED based on index.
     761                 :            :  **/
     762                 :          0 : s32 ixgbe_blink_led_start(struct ixgbe_hw *hw, u32 index)
     763                 :            : {
     764         [ #  # ]:          0 :         return ixgbe_call_func(hw, hw->mac.ops.blink_led_start, (hw, index),
     765                 :            :                                IXGBE_NOT_IMPLEMENTED);
     766                 :            : }
     767                 :            : 
     768                 :            : /**
     769                 :            :  * ixgbe_blink_led_stop - Stop blinking LEDs
     770                 :            :  * @hw: pointer to hardware structure
     771                 :            :  * @index: led number to stop
     772                 :            :  *
     773                 :            :  * Stop blinking LED based on index.
     774                 :            :  **/
     775                 :          0 : s32 ixgbe_blink_led_stop(struct ixgbe_hw *hw, u32 index)
     776                 :            : {
     777         [ #  # ]:          0 :         return ixgbe_call_func(hw, hw->mac.ops.blink_led_stop, (hw, index),
     778                 :            :                                IXGBE_NOT_IMPLEMENTED);
     779                 :            : }
     780                 :            : 
     781                 :            : /**
     782                 :            :  * ixgbe_init_eeprom_params - Initialize EEPROM parameters
     783                 :            :  * @hw: pointer to hardware structure
     784                 :            :  *
     785                 :            :  * Initializes the EEPROM parameters ixgbe_eeprom_info within the
     786                 :            :  * ixgbe_hw struct in order to set up EEPROM access.
     787                 :            :  **/
     788                 :          0 : s32 ixgbe_init_eeprom_params(struct ixgbe_hw *hw)
     789                 :            : {
     790         [ #  # ]:          0 :         return ixgbe_call_func(hw, hw->eeprom.ops.init_params, (hw),
     791                 :            :                                IXGBE_NOT_IMPLEMENTED);
     792                 :            : }
     793                 :            : 
     794                 :            : 
     795                 :            : /**
     796                 :            :  * ixgbe_write_eeprom - Write word to EEPROM
     797                 :            :  * @hw: pointer to hardware structure
     798                 :            :  * @offset: offset within the EEPROM to be written to
     799                 :            :  * @data: 16 bit word to be written to the EEPROM
     800                 :            :  *
     801                 :            :  * Writes 16 bit value to EEPROM. If ixgbe_eeprom_update_checksum is not
     802                 :            :  * called after this function, the EEPROM will most likely contain an
     803                 :            :  * invalid checksum.
     804                 :            :  **/
     805                 :          0 : s32 ixgbe_write_eeprom(struct ixgbe_hw *hw, u16 offset, u16 data)
     806                 :            : {
     807         [ #  # ]:          0 :         return ixgbe_call_func(hw, hw->eeprom.ops.write, (hw, offset, data),
     808                 :            :                                IXGBE_NOT_IMPLEMENTED);
     809                 :            : }
     810                 :            : 
     811                 :            : /**
     812                 :            :  * ixgbe_write_eeprom_buffer - Write word(s) to EEPROM
     813                 :            :  * @hw: pointer to hardware structure
     814                 :            :  * @offset: offset within the EEPROM to be written to
     815                 :            :  * @data: 16 bit word(s) to be written to the EEPROM
     816                 :            :  * @words: number of words
     817                 :            :  *
     818                 :            :  * Writes 16 bit word(s) to EEPROM. If ixgbe_eeprom_update_checksum is not
     819                 :            :  * called after this function, the EEPROM will most likely contain an
     820                 :            :  * invalid checksum.
     821                 :            :  **/
     822                 :          0 : s32 ixgbe_write_eeprom_buffer(struct ixgbe_hw *hw, u16 offset, u16 words,
     823                 :            :                               u16 *data)
     824                 :            : {
     825         [ #  # ]:          0 :         return ixgbe_call_func(hw, hw->eeprom.ops.write_buffer,
     826                 :            :                                (hw, offset, words, data),
     827                 :            :                                IXGBE_NOT_IMPLEMENTED);
     828                 :            : }
     829                 :            : 
     830                 :            : /**
     831                 :            :  * ixgbe_read_eeprom - Read word from EEPROM
     832                 :            :  * @hw: pointer to hardware structure
     833                 :            :  * @offset: offset within the EEPROM to be read
     834                 :            :  * @data: read 16 bit value from EEPROM
     835                 :            :  *
     836                 :            :  * Reads 16 bit value from EEPROM
     837                 :            :  **/
     838                 :          0 : s32 ixgbe_read_eeprom(struct ixgbe_hw *hw, u16 offset, u16 *data)
     839                 :            : {
     840         [ #  # ]:          0 :         return ixgbe_call_func(hw, hw->eeprom.ops.read, (hw, offset, data),
     841                 :            :                                IXGBE_NOT_IMPLEMENTED);
     842                 :            : }
     843                 :            : 
     844                 :            : /**
     845                 :            :  * ixgbe_read_eeprom_buffer - Read word(s) from EEPROM
     846                 :            :  * @hw: pointer to hardware structure
     847                 :            :  * @offset: offset within the EEPROM to be read
     848                 :            :  * @data: read 16 bit word(s) from EEPROM
     849                 :            :  * @words: number of words
     850                 :            :  *
     851                 :            :  * Reads 16 bit word(s) from EEPROM
     852                 :            :  **/
     853                 :          0 : s32 ixgbe_read_eeprom_buffer(struct ixgbe_hw *hw, u16 offset,
     854                 :            :                              u16 words, u16 *data)
     855                 :            : {
     856         [ #  # ]:          0 :         return ixgbe_call_func(hw, hw->eeprom.ops.read_buffer,
     857                 :            :                                (hw, offset, words, data),
     858                 :            :                                IXGBE_NOT_IMPLEMENTED);
     859                 :            : }
     860                 :            : 
     861                 :            : /**
     862                 :            :  * ixgbe_validate_eeprom_checksum - Validate EEPROM checksum
     863                 :            :  * @hw: pointer to hardware structure
     864                 :            :  * @checksum_val: calculated checksum
     865                 :            :  *
     866                 :            :  * Performs checksum calculation and validates the EEPROM checksum
     867                 :            :  **/
     868                 :          0 : s32 ixgbe_validate_eeprom_checksum(struct ixgbe_hw *hw, u16 *checksum_val)
     869                 :            : {
     870         [ #  # ]:          0 :         return ixgbe_call_func(hw, hw->eeprom.ops.validate_checksum,
     871                 :            :                                (hw, checksum_val), IXGBE_NOT_IMPLEMENTED);
     872                 :            : }
     873                 :            : 
     874                 :            : /**
     875                 :            :  * ixgbe_eeprom_update_checksum - Updates the EEPROM checksum
     876                 :            :  * @hw: pointer to hardware structure
     877                 :            :  **/
     878                 :          0 : s32 ixgbe_update_eeprom_checksum(struct ixgbe_hw *hw)
     879                 :            : {
     880         [ #  # ]:          0 :         return ixgbe_call_func(hw, hw->eeprom.ops.update_checksum, (hw),
     881                 :            :                                IXGBE_NOT_IMPLEMENTED);
     882                 :            : }
     883                 :            : 
     884                 :            : /**
     885                 :            :  * ixgbe_insert_mac_addr - Find a RAR for this mac address
     886                 :            :  * @hw: pointer to hardware structure
     887                 :            :  * @addr: Address to put into receive address register
     888                 :            :  * @vmdq: VMDq pool to assign
     889                 :            :  *
     890                 :            :  * Puts an ethernet address into a receive address register, or
     891                 :            :  * finds the rar that it is already in; adds to the pool list
     892                 :            :  **/
     893                 :          0 : s32 ixgbe_insert_mac_addr(struct ixgbe_hw *hw, u8 *addr, u32 vmdq)
     894                 :            : {
     895         [ #  # ]:          0 :         return ixgbe_call_func(hw, hw->mac.ops.insert_mac_addr,
     896                 :            :                                (hw, addr, vmdq),
     897                 :            :                                IXGBE_NOT_IMPLEMENTED);
     898                 :            : }
     899                 :            : 
     900                 :            : /**
     901                 :            :  * ixgbe_set_rar - Set Rx address register
     902                 :            :  * @hw: pointer to hardware structure
     903                 :            :  * @index: Receive address register to write
     904                 :            :  * @addr: Address to put into receive address register
     905                 :            :  * @vmdq: VMDq "set"
     906                 :            :  * @enable_addr: set flag that address is active
     907                 :            :  *
     908                 :            :  * Puts an ethernet address into a receive address register.
     909                 :            :  **/
     910                 :          0 : s32 ixgbe_set_rar(struct ixgbe_hw *hw, u32 index, u8 *addr, u32 vmdq,
     911                 :            :                   u32 enable_addr)
     912                 :            : {
     913         [ #  # ]:          0 :         return ixgbe_call_func(hw, hw->mac.ops.set_rar, (hw, index, addr, vmdq,
     914                 :            :                                enable_addr), IXGBE_NOT_IMPLEMENTED);
     915                 :            : }
     916                 :            : 
     917                 :            : /**
     918                 :            :  * ixgbe_clear_rar - Clear Rx address register
     919                 :            :  * @hw: pointer to hardware structure
     920                 :            :  * @index: Receive address register to write
     921                 :            :  *
     922                 :            :  * Puts an ethernet address into a receive address register.
     923                 :            :  **/
     924                 :          0 : s32 ixgbe_clear_rar(struct ixgbe_hw *hw, u32 index)
     925                 :            : {
     926         [ #  # ]:          0 :         return ixgbe_call_func(hw, hw->mac.ops.clear_rar, (hw, index),
     927                 :            :                                IXGBE_NOT_IMPLEMENTED);
     928                 :            : }
     929                 :            : 
     930                 :            : /**
     931                 :            :  * ixgbe_set_vmdq - Associate a VMDq index with a receive address
     932                 :            :  * @hw: pointer to hardware structure
     933                 :            :  * @rar: receive address register index to associate with VMDq index
     934                 :            :  * @vmdq: VMDq set or pool index
     935                 :            :  **/
     936                 :          0 : s32 ixgbe_set_vmdq(struct ixgbe_hw *hw, u32 rar, u32 vmdq)
     937                 :            : {
     938         [ #  # ]:          0 :         return ixgbe_call_func(hw, hw->mac.ops.set_vmdq, (hw, rar, vmdq),
     939                 :            :                                IXGBE_NOT_IMPLEMENTED);
     940                 :            : 
     941                 :            : }
     942                 :            : 
     943                 :            : /**
     944                 :            :  * ixgbe_set_vmdq_san_mac - Associate VMDq index 127 with a receive address
     945                 :            :  * @hw: pointer to hardware structure
     946                 :            :  * @vmdq: VMDq default pool index
     947                 :            :  **/
     948                 :          0 : s32 ixgbe_set_vmdq_san_mac(struct ixgbe_hw *hw, u32 vmdq)
     949                 :            : {
     950         [ #  # ]:          0 :         return ixgbe_call_func(hw, hw->mac.ops.set_vmdq_san_mac,
     951                 :            :                                (hw, vmdq), IXGBE_NOT_IMPLEMENTED);
     952                 :            : }
     953                 :            : 
     954                 :            : /**
     955                 :            :  * ixgbe_clear_vmdq - Disassociate a VMDq index from a receive address
     956                 :            :  * @hw: pointer to hardware structure
     957                 :            :  * @rar: receive address register index to disassociate with VMDq index
     958                 :            :  * @vmdq: VMDq set or pool index
     959                 :            :  **/
     960                 :          0 : s32 ixgbe_clear_vmdq(struct ixgbe_hw *hw, u32 rar, u32 vmdq)
     961                 :            : {
     962         [ #  # ]:          0 :         return ixgbe_call_func(hw, hw->mac.ops.clear_vmdq, (hw, rar, vmdq),
     963                 :            :                                IXGBE_NOT_IMPLEMENTED);
     964                 :            : }
     965                 :            : 
     966                 :            : /**
     967                 :            :  * ixgbe_init_rx_addrs - Initializes receive address filters.
     968                 :            :  * @hw: pointer to hardware structure
     969                 :            :  *
     970                 :            :  * Places the MAC address in receive address register 0 and clears the rest
     971                 :            :  * of the receive address registers. Clears the multicast table. Assumes
     972                 :            :  * the receiver is in reset when the routine is called.
     973                 :            :  **/
     974                 :          0 : s32 ixgbe_init_rx_addrs(struct ixgbe_hw *hw)
     975                 :            : {
     976         [ #  # ]:          0 :         return ixgbe_call_func(hw, hw->mac.ops.init_rx_addrs, (hw),
     977                 :            :                                IXGBE_NOT_IMPLEMENTED);
     978                 :            : }
     979                 :            : 
     980                 :            : /**
     981                 :            :  * ixgbe_get_num_rx_addrs - Returns the number of RAR entries.
     982                 :            :  * @hw: pointer to hardware structure
     983                 :            :  **/
     984                 :          0 : u32 ixgbe_get_num_rx_addrs(struct ixgbe_hw *hw)
     985                 :            : {
     986                 :          0 :         return hw->mac.num_rar_entries;
     987                 :            : }
     988                 :            : 
     989                 :            : /**
     990                 :            :  * ixgbe_update_uc_addr_list - Updates the MAC's list of secondary addresses
     991                 :            :  * @hw: pointer to hardware structure
     992                 :            :  * @addr_list: the list of new multicast addresses
     993                 :            :  * @addr_count: number of addresses
     994                 :            :  * @func: iterator function to walk the multicast address list
     995                 :            :  *
     996                 :            :  * The given list replaces any existing list. Clears the secondary addrs from
     997                 :            :  * receive address registers. Uses unused receive address registers for the
     998                 :            :  * first secondary addresses, and falls back to promiscuous mode as needed.
     999                 :            :  **/
    1000                 :          0 : s32 ixgbe_update_uc_addr_list(struct ixgbe_hw *hw, u8 *addr_list,
    1001                 :            :                               u32 addr_count, ixgbe_mc_addr_itr func)
    1002                 :            : {
    1003         [ #  # ]:          0 :         return ixgbe_call_func(hw, hw->mac.ops.update_uc_addr_list, (hw,
    1004                 :            :                                addr_list, addr_count, func),
    1005                 :            :                                IXGBE_NOT_IMPLEMENTED);
    1006                 :            : }
    1007                 :            : 
    1008                 :            : /**
    1009                 :            :  * ixgbe_update_mc_addr_list - Updates the MAC's list of multicast addresses
    1010                 :            :  * @hw: pointer to hardware structure
    1011                 :            :  * @mc_addr_list: the list of new multicast addresses
    1012                 :            :  * @mc_addr_count: number of addresses
    1013                 :            :  * @func: iterator function to walk the multicast address list
    1014                 :            :  * @clear: flag, when set clears the table beforehand
    1015                 :            :  *
    1016                 :            :  * The given list replaces any existing list. Clears the MC addrs from receive
    1017                 :            :  * address registers and the multicast table. Uses unused receive address
    1018                 :            :  * registers for the first multicast addresses, and hashes the rest into the
    1019                 :            :  * multicast table.
    1020                 :            :  **/
    1021                 :          0 : s32 ixgbe_update_mc_addr_list(struct ixgbe_hw *hw, u8 *mc_addr_list,
    1022                 :            :                               u32 mc_addr_count, ixgbe_mc_addr_itr func,
    1023                 :            :                               bool clear)
    1024                 :            : {
    1025         [ #  # ]:          0 :         return ixgbe_call_func(hw, hw->mac.ops.update_mc_addr_list, (hw,
    1026                 :            :                                mc_addr_list, mc_addr_count, func, clear),
    1027                 :            :                                IXGBE_NOT_IMPLEMENTED);
    1028                 :            : }
    1029                 :            : 
    1030                 :            : /**
    1031                 :            :  * ixgbe_enable_mc - Enable multicast address in RAR
    1032                 :            :  * @hw: pointer to hardware structure
    1033                 :            :  *
    1034                 :            :  * Enables multicast address in RAR and the use of the multicast hash table.
    1035                 :            :  **/
    1036                 :          0 : s32 ixgbe_enable_mc(struct ixgbe_hw *hw)
    1037                 :            : {
    1038         [ #  # ]:          0 :         return ixgbe_call_func(hw, hw->mac.ops.enable_mc, (hw),
    1039                 :            :                                IXGBE_NOT_IMPLEMENTED);
    1040                 :            : }
    1041                 :            : 
    1042                 :            : /**
    1043                 :            :  * ixgbe_disable_mc - Disable multicast address in RAR
    1044                 :            :  * @hw: pointer to hardware structure
    1045                 :            :  *
    1046                 :            :  * Disables multicast address in RAR and the use of the multicast hash table.
    1047                 :            :  **/
    1048                 :          0 : s32 ixgbe_disable_mc(struct ixgbe_hw *hw)
    1049                 :            : {
    1050         [ #  # ]:          0 :         return ixgbe_call_func(hw, hw->mac.ops.disable_mc, (hw),
    1051                 :            :                                IXGBE_NOT_IMPLEMENTED);
    1052                 :            : }
    1053                 :            : 
    1054                 :            : /**
    1055                 :            :  * ixgbe_clear_vfta - Clear VLAN filter table
    1056                 :            :  * @hw: pointer to hardware structure
    1057                 :            :  *
    1058                 :            :  * Clears the VLAN filer table, and the VMDq index associated with the filter
    1059                 :            :  **/
    1060                 :          0 : s32 ixgbe_clear_vfta(struct ixgbe_hw *hw)
    1061                 :            : {
    1062         [ #  # ]:          0 :         return ixgbe_call_func(hw, hw->mac.ops.clear_vfta, (hw),
    1063                 :            :                                IXGBE_NOT_IMPLEMENTED);
    1064                 :            : }
    1065                 :            : 
    1066                 :            : /**
    1067                 :            :  * ixgbe_set_vfta - Set VLAN filter table
    1068                 :            :  * @hw: pointer to hardware structure
    1069                 :            :  * @vlan: VLAN id to write to VLAN filter
    1070                 :            :  * @vind: VMDq output index that maps queue to VLAN id in VLVFB
    1071                 :            :  * @vlan_on: boolean flag to turn on/off VLAN
    1072                 :            :  * @vlvf_bypass: boolean flag indicating updating the default pool is okay
    1073                 :            :  *
    1074                 :            :  * Turn on/off specified VLAN in the VLAN filter table.
    1075                 :            :  **/
    1076                 :          0 : s32 ixgbe_set_vfta(struct ixgbe_hw *hw, u32 vlan, u32 vind, bool vlan_on,
    1077                 :            :                    bool vlvf_bypass)
    1078                 :            : {
    1079         [ #  # ]:          0 :         return ixgbe_call_func(hw, hw->mac.ops.set_vfta, (hw, vlan, vind,
    1080                 :            :                                vlan_on, vlvf_bypass), IXGBE_NOT_IMPLEMENTED);
    1081                 :            : }
    1082                 :            : 
    1083                 :            : /**
    1084                 :            :  * ixgbe_set_vlvf - Set VLAN Pool Filter
    1085                 :            :  * @hw: pointer to hardware structure
    1086                 :            :  * @vlan: VLAN id to write to VLAN filter
    1087                 :            :  * @vind: VMDq output index that maps queue to VLAN id in VLVFB
    1088                 :            :  * @vlan_on: boolean flag to turn on/off VLAN in VLVF
    1089                 :            :  * @vfta_delta: pointer to the difference between the current value of VFTA
    1090                 :            :  *               and the desired value
    1091                 :            :  * @vfta: the desired value of the VFTA
    1092                 :            :  * @vlvf_bypass: boolean flag indicating updating the default pool is okay
    1093                 :            :  *
    1094                 :            :  * Turn on/off specified bit in VLVF table.
    1095                 :            :  **/
    1096                 :          0 : s32 ixgbe_set_vlvf(struct ixgbe_hw *hw, u32 vlan, u32 vind, bool vlan_on,
    1097                 :            :                    u32 *vfta_delta, u32 vfta, bool vlvf_bypass)
    1098                 :            : {
    1099         [ #  # ]:          0 :         return ixgbe_call_func(hw, hw->mac.ops.set_vlvf, (hw, vlan, vind,
    1100                 :            :                                vlan_on, vfta_delta, vfta, vlvf_bypass),
    1101                 :            :                                IXGBE_NOT_IMPLEMENTED);
    1102                 :            : }
    1103                 :            : 
    1104                 :            : /**
    1105                 :            :  * ixgbe_fc_enable - Enable flow control
    1106                 :            :  * @hw: pointer to hardware structure
    1107                 :            :  *
    1108                 :            :  * Configures the flow control settings based on SW configuration.
    1109                 :            :  **/
    1110                 :          0 : s32 ixgbe_fc_enable(struct ixgbe_hw *hw)
    1111                 :            : {
    1112         [ #  # ]:          0 :         return ixgbe_call_func(hw, hw->mac.ops.fc_enable, (hw),
    1113                 :            :                                IXGBE_NOT_IMPLEMENTED);
    1114                 :            : }
    1115                 :            : 
    1116                 :            : /**
    1117                 :            :  * ixgbe_setup_fc - Set up flow control
    1118                 :            :  * @hw: pointer to hardware structure
    1119                 :            :  *
    1120                 :            :  * Called at init time to set up flow control.
    1121                 :            :  **/
    1122                 :          0 : s32 ixgbe_setup_fc(struct ixgbe_hw *hw)
    1123                 :            : {
    1124         [ #  # ]:          0 :         return ixgbe_call_func(hw, hw->mac.ops.setup_fc, (hw),
    1125                 :            :                 IXGBE_NOT_IMPLEMENTED);
    1126                 :            : }
    1127                 :            : 
    1128                 :            : /**
    1129                 :            :  * ixgbe_set_fw_drv_ver - Try to send the driver version number FW
    1130                 :            :  * @hw: pointer to hardware structure
    1131                 :            :  * @maj: driver major number to be sent to firmware
    1132                 :            :  * @min: driver minor number to be sent to firmware
    1133                 :            :  * @build: driver build number to be sent to firmware
    1134                 :            :  * @ver: driver version number to be sent to firmware
    1135                 :            :  * @len: length of driver_ver string
    1136                 :            :  * @driver_ver: driver string
    1137                 :            :  **/
    1138                 :          0 : s32 ixgbe_set_fw_drv_ver(struct ixgbe_hw *hw, u8 maj, u8 min, u8 build,
    1139                 :            :                          u8 ver, u16 len, char *driver_ver)
    1140                 :            : {
    1141         [ #  # ]:          0 :         return ixgbe_call_func(hw, hw->mac.ops.set_fw_drv_ver, (hw, maj, min,
    1142                 :            :                                build, ver, len, driver_ver),
    1143                 :            :                                IXGBE_NOT_IMPLEMENTED);
    1144                 :            : }
    1145                 :            : 
    1146                 :            : 
    1147                 :            : /**
    1148                 :            :  * ixgbe_get_thermal_sensor_data - Gathers thermal sensor data
    1149                 :            :  * @hw: pointer to hardware structure
    1150                 :            :  *
    1151                 :            :  * Updates the temperatures in mac.thermal_sensor_data
    1152                 :            :  **/
    1153                 :          0 : s32 ixgbe_get_thermal_sensor_data(struct ixgbe_hw *hw)
    1154                 :            : {
    1155         [ #  # ]:          0 :         return ixgbe_call_func(hw, hw->mac.ops.get_thermal_sensor_data, (hw),
    1156                 :            :                                 IXGBE_NOT_IMPLEMENTED);
    1157                 :            : }
    1158                 :            : 
    1159                 :            : /**
    1160                 :            :  * ixgbe_init_thermal_sensor_thresh - Inits thermal sensor thresholds
    1161                 :            :  * @hw: pointer to hardware structure
    1162                 :            :  *
    1163                 :            :  * Inits the thermal sensor thresholds according to the NVM map
    1164                 :            :  **/
    1165                 :          0 : s32 ixgbe_init_thermal_sensor_thresh(struct ixgbe_hw *hw)
    1166                 :            : {
    1167         [ #  # ]:          0 :         return ixgbe_call_func(hw, hw->mac.ops.init_thermal_sensor_thresh, (hw),
    1168                 :            :                                 IXGBE_NOT_IMPLEMENTED);
    1169                 :            : }
    1170                 :            : 
    1171                 :            : /**
    1172                 :            :  * ixgbe_dmac_config - Configure DMA Coalescing registers.
    1173                 :            :  * @hw: pointer to hardware structure
    1174                 :            :  *
    1175                 :            :  * Configure DMA coalescing. If enabling dmac, dmac is activated.
    1176                 :            :  * When disabling dmac, dmac enable dmac bit is cleared.
    1177                 :            :  **/
    1178                 :          0 : s32 ixgbe_dmac_config(struct ixgbe_hw *hw)
    1179                 :            : {
    1180         [ #  # ]:          0 :         return ixgbe_call_func(hw, hw->mac.ops.dmac_config, (hw),
    1181                 :            :                                 IXGBE_NOT_IMPLEMENTED);
    1182                 :            : }
    1183                 :            : 
    1184                 :            : /**
    1185                 :            :  * ixgbe_dmac_update_tcs - Configure DMA Coalescing registers.
    1186                 :            :  * @hw: pointer to hardware structure
    1187                 :            :  *
    1188                 :            :  * Disables dmac, updates per TC settings, and then enable dmac.
    1189                 :            :  **/
    1190                 :          0 : s32 ixgbe_dmac_update_tcs(struct ixgbe_hw *hw)
    1191                 :            : {
    1192         [ #  # ]:          0 :         return ixgbe_call_func(hw, hw->mac.ops.dmac_update_tcs, (hw),
    1193                 :            :                                 IXGBE_NOT_IMPLEMENTED);
    1194                 :            : }
    1195                 :            : 
    1196                 :            : /**
    1197                 :            :  * ixgbe_dmac_config_tcs - Configure DMA Coalescing registers.
    1198                 :            :  * @hw: pointer to hardware structure
    1199                 :            :  *
    1200                 :            :  * Configure DMA coalescing threshold per TC and set high priority bit for
    1201                 :            :  * FCOE TC. The dmac enable bit must be cleared before configuring.
    1202                 :            :  **/
    1203                 :          0 : s32 ixgbe_dmac_config_tcs(struct ixgbe_hw *hw)
    1204                 :            : {
    1205         [ #  # ]:          0 :         return ixgbe_call_func(hw, hw->mac.ops.dmac_config_tcs, (hw),
    1206                 :            :                                 IXGBE_NOT_IMPLEMENTED);
    1207                 :            : }
    1208                 :            : 
    1209                 :            : /**
    1210                 :            :  * ixgbe_setup_eee - Enable/disable EEE support
    1211                 :            :  * @hw: pointer to the HW structure
    1212                 :            :  * @enable_eee: boolean flag to enable EEE
    1213                 :            :  *
    1214                 :            :  * Enable/disable EEE based on enable_ee flag.
    1215                 :            :  * Auto-negotiation must be started after BASE-T EEE bits in PHY register 7.3C
    1216                 :            :  * are modified.
    1217                 :            :  *
    1218                 :            :  **/
    1219                 :          0 : s32 ixgbe_setup_eee(struct ixgbe_hw *hw, bool enable_eee)
    1220                 :            : {
    1221         [ #  # ]:          0 :         return ixgbe_call_func(hw, hw->mac.ops.setup_eee, (hw, enable_eee),
    1222                 :            :                         IXGBE_NOT_IMPLEMENTED);
    1223                 :            : }
    1224                 :            : 
    1225                 :            : /**
    1226                 :            :  * ixgbe_set_source_address_pruning - Enable/Disable source address pruning
    1227                 :            :  * @hw: pointer to hardware structure
    1228                 :            :  * @enable: enable or disable source address pruning
    1229                 :            :  * @pool: Rx pool - Rx pool to toggle source address pruning
    1230                 :            :  **/
    1231                 :          0 : void ixgbe_set_source_address_pruning(struct ixgbe_hw *hw, bool enable,
    1232                 :            :                                       unsigned int pool)
    1233                 :            : {
    1234         [ #  # ]:          0 :         if (hw->mac.ops.set_source_address_pruning)
    1235                 :          0 :                 hw->mac.ops.set_source_address_pruning(hw, enable, pool);
    1236                 :          0 : }
    1237                 :            : 
    1238                 :            : /**
    1239                 :            :  * ixgbe_set_ethertype_anti_spoofing - Enable/Disable Ethertype anti-spoofing
    1240                 :            :  * @hw: pointer to hardware structure
    1241                 :            :  * @enable: enable or disable switch for Ethertype anti-spoofing
    1242                 :            :  * @vf: Virtual Function pool - VF Pool to set for Ethertype anti-spoofing
    1243                 :            :  *
    1244                 :            :  **/
    1245                 :          0 : void ixgbe_set_ethertype_anti_spoofing(struct ixgbe_hw *hw, bool enable, int vf)
    1246                 :            : {
    1247         [ #  # ]:          0 :         if (hw->mac.ops.set_ethertype_anti_spoofing)
    1248                 :          0 :                 hw->mac.ops.set_ethertype_anti_spoofing(hw, enable, vf);
    1249                 :          0 : }
    1250                 :            : 
    1251                 :            : /**
    1252                 :            :  * ixgbe_read_iosf_sb_reg - Read 32 bit PHY register
    1253                 :            :  * @hw: pointer to hardware structure
    1254                 :            :  * @reg_addr: 32 bit address of PHY register to read
    1255                 :            :  * @device_type: type of device you want to communicate with
    1256                 :            :  * @phy_data: Pointer to read data from PHY register
    1257                 :            :  *
    1258                 :            :  * Reads a value from a specified PHY register
    1259                 :            :  **/
    1260                 :          0 : s32 ixgbe_read_iosf_sb_reg(struct ixgbe_hw *hw, u32 reg_addr,
    1261                 :            :                            u32 device_type, u32 *phy_data)
    1262                 :            : {
    1263         [ #  # ]:          0 :         return ixgbe_call_func(hw, hw->mac.ops.read_iosf_sb_reg, (hw, reg_addr,
    1264                 :            :                                device_type, phy_data), IXGBE_NOT_IMPLEMENTED);
    1265                 :            : }
    1266                 :            : 
    1267                 :            : /**
    1268                 :            :  * ixgbe_write_iosf_sb_reg - Write 32 bit register through IOSF Sideband
    1269                 :            :  * @hw: pointer to hardware structure
    1270                 :            :  * @reg_addr: 32 bit PHY register to write
    1271                 :            :  * @device_type: type of device you want to communicate with
    1272                 :            :  * @phy_data: Data to write to the PHY register
    1273                 :            :  *
    1274                 :            :  * Writes a value to specified PHY register
    1275                 :            :  **/
    1276                 :          0 : s32 ixgbe_write_iosf_sb_reg(struct ixgbe_hw *hw, u32 reg_addr,
    1277                 :            :                             u32 device_type, u32 phy_data)
    1278                 :            : {
    1279         [ #  # ]:          0 :         return ixgbe_call_func(hw, hw->mac.ops.write_iosf_sb_reg, (hw, reg_addr,
    1280                 :            :                                device_type, phy_data), IXGBE_NOT_IMPLEMENTED);
    1281                 :            : }
    1282                 :            : 
    1283                 :            : /**
    1284                 :            :  * ixgbe_disable_mdd - Disable malicious driver detection
    1285                 :            :  * @hw: pointer to hardware structure
    1286                 :            :  *
    1287                 :            :  **/
    1288                 :          0 : void ixgbe_disable_mdd(struct ixgbe_hw *hw)
    1289                 :            : {
    1290         [ #  # ]:          0 :         if (hw->mac.ops.disable_mdd)
    1291                 :          0 :                 hw->mac.ops.disable_mdd(hw);
    1292                 :          0 : }
    1293                 :            : 
    1294                 :            : /**
    1295                 :            :  * ixgbe_enable_mdd - Enable malicious driver detection
    1296                 :            :  * @hw: pointer to hardware structure
    1297                 :            :  *
    1298                 :            :  **/
    1299                 :          0 : void ixgbe_enable_mdd(struct ixgbe_hw *hw)
    1300                 :            : {
    1301         [ #  # ]:          0 :         if (hw->mac.ops.enable_mdd)
    1302                 :          0 :                 hw->mac.ops.enable_mdd(hw);
    1303                 :          0 : }
    1304                 :            : 
    1305                 :            : /**
    1306                 :            :  * ixgbe_mdd_event - Handle malicious driver detection event
    1307                 :            :  * @hw: pointer to hardware structure
    1308                 :            :  * @vf_bitmap: vf bitmap of malicious vfs
    1309                 :            :  *
    1310                 :            :  **/
    1311                 :          0 : void ixgbe_mdd_event(struct ixgbe_hw *hw, u32 *vf_bitmap)
    1312                 :            : {
    1313         [ #  # ]:          0 :         if (hw->mac.ops.mdd_event)
    1314                 :          0 :                 hw->mac.ops.mdd_event(hw, vf_bitmap);
    1315                 :          0 : }
    1316                 :            : 
    1317                 :            : /**
    1318                 :            :  * ixgbe_restore_mdd_vf - Restore VF that was disabled during malicious driver
    1319                 :            :  * detection event
    1320                 :            :  * @hw: pointer to hardware structure
    1321                 :            :  * @vf: vf index
    1322                 :            :  *
    1323                 :            :  **/
    1324                 :          0 : void ixgbe_restore_mdd_vf(struct ixgbe_hw *hw, u32 vf)
    1325                 :            : {
    1326         [ #  # ]:          0 :         if (hw->mac.ops.restore_mdd_vf)
    1327                 :          0 :                 hw->mac.ops.restore_mdd_vf(hw, vf);
    1328                 :          0 : }
    1329                 :            : 
    1330                 :            : /**
    1331                 :            :  * ixgbe_fw_recovery_mode - Check if in FW NVM recovery mode
    1332                 :            :  * @hw: pointer to hardware structure
    1333                 :            :  *
    1334                 :            :  **/
    1335                 :          0 : bool ixgbe_fw_recovery_mode(struct ixgbe_hw *hw)
    1336                 :            : {
    1337         [ #  # ]:          0 :         if (hw->mac.ops.fw_recovery_mode)
    1338                 :          0 :                 return hw->mac.ops.fw_recovery_mode(hw);
    1339                 :            :         return false;
    1340                 :            : }
    1341                 :            : 
    1342                 :            : /**
    1343                 :            :  * ixgbe_enter_lplu - Transition to low power states
    1344                 :            :  * @hw: pointer to hardware structure
    1345                 :            :  *
    1346                 :            :  * Configures Low Power Link Up on transition to low power states
    1347                 :            :  * (from D0 to non-D0).
    1348                 :            :  **/
    1349                 :          0 : s32 ixgbe_enter_lplu(struct ixgbe_hw *hw)
    1350                 :            : {
    1351         [ #  # ]:          0 :         return ixgbe_call_func(hw, hw->phy.ops.enter_lplu, (hw),
    1352                 :            :                                 IXGBE_NOT_IMPLEMENTED);
    1353                 :            : }
    1354                 :            : 
    1355                 :            : /**
    1356                 :            :  * ixgbe_handle_lasi - Handle external Base T PHY interrupt
    1357                 :            :  * @hw: pointer to hardware structure
    1358                 :            :  *
    1359                 :            :  * Handle external Base T PHY interrupt. If high temperature
    1360                 :            :  * failure alarm then return error, else if link status change
    1361                 :            :  * then setup internal/external PHY link
    1362                 :            :  *
    1363                 :            :  * Return IXGBE_ERR_OVERTEMP if interrupt is high temperature
    1364                 :            :  * failure alarm, else return PHY access status.
    1365                 :            :  */
    1366                 :          0 : s32 ixgbe_handle_lasi(struct ixgbe_hw *hw)
    1367                 :            : {
    1368         [ #  # ]:          0 :         return ixgbe_call_func(hw, hw->phy.ops.handle_lasi, (hw),
    1369                 :            :                                 IXGBE_NOT_IMPLEMENTED);
    1370                 :            : }
    1371                 :            : 
    1372                 :            : /**
    1373                 :            :  * ixgbe_read_analog_reg8 - Reads 8 bit analog register
    1374                 :            :  * @hw: pointer to hardware structure
    1375                 :            :  * @reg: analog register to read
    1376                 :            :  * @val: read value
    1377                 :            :  *
    1378                 :            :  * Performs write operation to analog register specified.
    1379                 :            :  **/
    1380                 :          0 : s32 ixgbe_read_analog_reg8(struct ixgbe_hw *hw, u32 reg, u8 *val)
    1381                 :            : {
    1382         [ #  # ]:          0 :         return ixgbe_call_func(hw, hw->mac.ops.read_analog_reg8, (hw, reg,
    1383                 :            :                                val), IXGBE_NOT_IMPLEMENTED);
    1384                 :            : }
    1385                 :            : 
    1386                 :            : /**
    1387                 :            :  * ixgbe_write_analog_reg8 - Writes 8 bit analog register
    1388                 :            :  * @hw: pointer to hardware structure
    1389                 :            :  * @reg: analog register to write
    1390                 :            :  * @val: value to write
    1391                 :            :  *
    1392                 :            :  * Performs write operation to Atlas analog register specified.
    1393                 :            :  **/
    1394                 :          0 : s32 ixgbe_write_analog_reg8(struct ixgbe_hw *hw, u32 reg, u8 val)
    1395                 :            : {
    1396         [ #  # ]:          0 :         return ixgbe_call_func(hw, hw->mac.ops.write_analog_reg8, (hw, reg,
    1397                 :            :                                val), IXGBE_NOT_IMPLEMENTED);
    1398                 :            : }
    1399                 :            : 
    1400                 :            : /**
    1401                 :            :  * ixgbe_init_uta_tables - Initializes Unicast Table Arrays.
    1402                 :            :  * @hw: pointer to hardware structure
    1403                 :            :  *
    1404                 :            :  * Initializes the Unicast Table Arrays to zero on device load.  This
    1405                 :            :  * is part of the Rx init addr execution path.
    1406                 :            :  **/
    1407                 :          0 : s32 ixgbe_init_uta_tables(struct ixgbe_hw *hw)
    1408                 :            : {
    1409         [ #  # ]:          0 :         return ixgbe_call_func(hw, hw->mac.ops.init_uta_tables, (hw),
    1410                 :            :                                IXGBE_NOT_IMPLEMENTED);
    1411                 :            : }
    1412                 :            : 
    1413                 :            : /**
    1414                 :            :  * ixgbe_read_i2c_byte - Reads 8 bit word over I2C at specified device address
    1415                 :            :  * @hw: pointer to hardware structure
    1416                 :            :  * @byte_offset: byte offset to read
    1417                 :            :  * @dev_addr: I2C bus address to read from
    1418                 :            :  * @data: value read
    1419                 :            :  *
    1420                 :            :  * Performs byte read operation to SFP module's EEPROM over I2C interface.
    1421                 :            :  **/
    1422                 :          0 : s32 ixgbe_read_i2c_byte(struct ixgbe_hw *hw, u8 byte_offset, u8 dev_addr,
    1423                 :            :                         u8 *data)
    1424                 :            : {
    1425         [ #  # ]:          0 :         return ixgbe_call_func(hw, hw->phy.ops.read_i2c_byte, (hw, byte_offset,
    1426                 :            :                                dev_addr, data), IXGBE_NOT_IMPLEMENTED);
    1427                 :            : }
    1428                 :            : 
    1429                 :            : /**
    1430                 :            :  * ixgbe_read_i2c_byte_unlocked - Reads 8 bit word via I2C from device address
    1431                 :            :  * @hw: pointer to hardware structure
    1432                 :            :  * @byte_offset: byte offset to read
    1433                 :            :  * @dev_addr: I2C bus address to read from
    1434                 :            :  * @data: value read
    1435                 :            :  *
    1436                 :            :  * Performs byte read operation to SFP module's EEPROM over I2C interface.
    1437                 :            :  **/
    1438                 :          0 : s32 ixgbe_read_i2c_byte_unlocked(struct ixgbe_hw *hw, u8 byte_offset,
    1439                 :            :                                  u8 dev_addr, u8 *data)
    1440                 :            : {
    1441         [ #  # ]:          0 :         return ixgbe_call_func(hw, hw->phy.ops.read_i2c_byte_unlocked,
    1442                 :            :                                (hw, byte_offset, dev_addr, data),
    1443                 :            :                                IXGBE_NOT_IMPLEMENTED);
    1444                 :            : }
    1445                 :            : 
    1446                 :            : /**
    1447                 :            :  * ixgbe_read_link - Perform read operation on link device
    1448                 :            :  * @hw: pointer to the hardware structure
    1449                 :            :  * @addr: bus address to read from
    1450                 :            :  * @reg: device register to read from
    1451                 :            :  * @val: pointer to location to receive read value
    1452                 :            :  *
    1453                 :            :  * Returns an error code on error.
    1454                 :            :  */
    1455                 :          0 : s32 ixgbe_read_link(struct ixgbe_hw *hw, u8 addr, u16 reg, u16 *val)
    1456                 :            : {
    1457         [ #  # ]:          0 :         return ixgbe_call_func(hw, hw->link.ops.read_link, (hw, addr,
    1458                 :            :                                reg, val), IXGBE_NOT_IMPLEMENTED);
    1459                 :            : }
    1460                 :            : 
    1461                 :            : /**
    1462                 :            :  * ixgbe_read_link_unlocked - Perform read operation on link device
    1463                 :            :  * @hw: pointer to the hardware structure
    1464                 :            :  * @addr: bus address to read from
    1465                 :            :  * @reg: device register to read from
    1466                 :            :  * @val: pointer to location to receive read value
    1467                 :            :  *
    1468                 :            :  * Returns an error code on error.
    1469                 :            :  **/
    1470                 :          0 : s32 ixgbe_read_link_unlocked(struct ixgbe_hw *hw, u8 addr, u16 reg, u16 *val)
    1471                 :            : {
    1472         [ #  # ]:          0 :         return ixgbe_call_func(hw, hw->link.ops.read_link_unlocked,
    1473                 :            :                                (hw, addr, reg, val), IXGBE_NOT_IMPLEMENTED);
    1474                 :            : }
    1475                 :            : 
    1476                 :            : /**
    1477                 :            :  * ixgbe_write_i2c_byte - Writes 8 bit word over I2C
    1478                 :            :  * @hw: pointer to hardware structure
    1479                 :            :  * @byte_offset: byte offset to write
    1480                 :            :  * @dev_addr: I2C bus address to write to
    1481                 :            :  * @data: value to write
    1482                 :            :  *
    1483                 :            :  * Performs byte write operation to SFP module's EEPROM over I2C interface
    1484                 :            :  * at a specified device address.
    1485                 :            :  **/
    1486                 :          0 : s32 ixgbe_write_i2c_byte(struct ixgbe_hw *hw, u8 byte_offset, u8 dev_addr,
    1487                 :            :                          u8 data)
    1488                 :            : {
    1489         [ #  # ]:          0 :         return ixgbe_call_func(hw, hw->phy.ops.write_i2c_byte, (hw, byte_offset,
    1490                 :            :                                dev_addr, data), IXGBE_NOT_IMPLEMENTED);
    1491                 :            : }
    1492                 :            : 
    1493                 :            : /**
    1494                 :            :  * ixgbe_write_i2c_byte_unlocked - Writes 8 bit word over I2C
    1495                 :            :  * @hw: pointer to hardware structure
    1496                 :            :  * @byte_offset: byte offset to write
    1497                 :            :  * @dev_addr: I2C bus address to write to
    1498                 :            :  * @data: value to write
    1499                 :            :  *
    1500                 :            :  * Performs byte write operation to SFP module's EEPROM over I2C interface
    1501                 :            :  * at a specified device address.
    1502                 :            :  **/
    1503                 :          0 : s32 ixgbe_write_i2c_byte_unlocked(struct ixgbe_hw *hw, u8 byte_offset,
    1504                 :            :                                   u8 dev_addr, u8 data)
    1505                 :            : {
    1506         [ #  # ]:          0 :         return ixgbe_call_func(hw, hw->phy.ops.write_i2c_byte_unlocked,
    1507                 :            :                                (hw, byte_offset, dev_addr, data),
    1508                 :            :                                IXGBE_NOT_IMPLEMENTED);
    1509                 :            : }
    1510                 :            : 
    1511                 :            : /**
    1512                 :            :  * ixgbe_write_link - Perform write operation on link device
    1513                 :            :  * @hw: pointer to the hardware structure
    1514                 :            :  * @addr: bus address to write to
    1515                 :            :  * @reg: device register to write to
    1516                 :            :  * @val: value to write
    1517                 :            :  *
    1518                 :            :  * Returns an error code on error.
    1519                 :            :  */
    1520                 :          0 : s32 ixgbe_write_link(struct ixgbe_hw *hw, u8 addr, u16 reg, u16 val)
    1521                 :            : {
    1522         [ #  # ]:          0 :         return ixgbe_call_func(hw, hw->link.ops.write_link,
    1523                 :            :                                (hw, addr, reg, val), IXGBE_NOT_IMPLEMENTED);
    1524                 :            : }
    1525                 :            : 
    1526                 :            : /**
    1527                 :            :  * ixgbe_write_link_unlocked - Perform write operation on link device
    1528                 :            :  * @hw: pointer to the hardware structure
    1529                 :            :  * @addr: bus address to write to
    1530                 :            :  * @reg: device register to write to
    1531                 :            :  * @val: value to write
    1532                 :            :  *
    1533                 :            :  * Returns an error code on error.
    1534                 :            :  **/
    1535                 :          0 : s32 ixgbe_write_link_unlocked(struct ixgbe_hw *hw, u8 addr, u16 reg, u16 val)
    1536                 :            : {
    1537         [ #  # ]:          0 :         return ixgbe_call_func(hw, hw->link.ops.write_link_unlocked,
    1538                 :            :                                (hw, addr, reg, val), IXGBE_NOT_IMPLEMENTED);
    1539                 :            : }
    1540                 :            : 
    1541                 :            : /**
    1542                 :            :  * ixgbe_write_i2c_eeprom - Writes 8 bit EEPROM word over I2C interface
    1543                 :            :  * @hw: pointer to hardware structure
    1544                 :            :  * @byte_offset: EEPROM byte offset to write
    1545                 :            :  * @eeprom_data: value to write
    1546                 :            :  *
    1547                 :            :  * Performs byte write operation to SFP module's EEPROM over I2C interface.
    1548                 :            :  **/
    1549                 :          0 : s32 ixgbe_write_i2c_eeprom(struct ixgbe_hw *hw,
    1550                 :            :                            u8 byte_offset, u8 eeprom_data)
    1551                 :            : {
    1552         [ #  # ]:          0 :         return ixgbe_call_func(hw, hw->phy.ops.write_i2c_eeprom,
    1553                 :            :                                (hw, byte_offset, eeprom_data),
    1554                 :            :                                IXGBE_NOT_IMPLEMENTED);
    1555                 :            : }
    1556                 :            : 
    1557                 :            : /**
    1558                 :            :  * ixgbe_read_i2c_eeprom - Reads 8 bit EEPROM word over I2C interface
    1559                 :            :  * @hw: pointer to hardware structure
    1560                 :            :  * @byte_offset: EEPROM byte offset to read
    1561                 :            :  * @eeprom_data: value read
    1562                 :            :  *
    1563                 :            :  * Performs byte read operation to SFP module's EEPROM over I2C interface.
    1564                 :            :  **/
    1565                 :          0 : s32 ixgbe_read_i2c_eeprom(struct ixgbe_hw *hw, u8 byte_offset, u8 *eeprom_data)
    1566                 :            : {
    1567         [ #  # ]:          0 :         return ixgbe_call_func(hw, hw->phy.ops.read_i2c_eeprom,
    1568                 :            :                               (hw, byte_offset, eeprom_data),
    1569                 :            :                               IXGBE_NOT_IMPLEMENTED);
    1570                 :            : }
    1571                 :            : 
    1572                 :            : /**
    1573                 :            :  * ixgbe_get_supported_physical_layer - Returns physical layer type
    1574                 :            :  * @hw: pointer to hardware structure
    1575                 :            :  *
    1576                 :            :  * Determines physical layer capabilities of the current configuration.
    1577                 :            :  **/
    1578                 :          0 : u64 ixgbe_get_supported_physical_layer(struct ixgbe_hw *hw)
    1579                 :            : {
    1580         [ #  # ]:          0 :         return ixgbe_call_func(hw, hw->mac.ops.get_supported_physical_layer,
    1581                 :            :                                (hw), IXGBE_PHYSICAL_LAYER_UNKNOWN);
    1582                 :            : }
    1583                 :            : 
    1584                 :            : /**
    1585                 :            :  * ixgbe_enable_rx_dma - Enables Rx DMA unit, dependent on device specifics
    1586                 :            :  * @hw: pointer to hardware structure
    1587                 :            :  * @regval: bitfield to write to the Rx DMA register
    1588                 :            :  *
    1589                 :            :  * Enables the Rx DMA unit of the device.
    1590                 :            :  **/
    1591                 :          0 : s32 ixgbe_enable_rx_dma(struct ixgbe_hw *hw, u32 regval)
    1592                 :            : {
    1593         [ #  # ]:          0 :         return ixgbe_call_func(hw, hw->mac.ops.enable_rx_dma,
    1594                 :            :                                (hw, regval), IXGBE_NOT_IMPLEMENTED);
    1595                 :            : }
    1596                 :            : 
    1597                 :            : /**
    1598                 :            :  * ixgbe_disable_sec_rx_path - Stops the receive data path
    1599                 :            :  * @hw: pointer to hardware structure
    1600                 :            :  *
    1601                 :            :  * Stops the receive data path.
    1602                 :            :  **/
    1603                 :          0 : s32 ixgbe_disable_sec_rx_path(struct ixgbe_hw *hw)
    1604                 :            : {
    1605         [ #  # ]:          0 :         return ixgbe_call_func(hw, hw->mac.ops.disable_sec_rx_path,
    1606                 :            :                                 (hw), IXGBE_NOT_IMPLEMENTED);
    1607                 :            : }
    1608                 :            : 
    1609                 :            : /**
    1610                 :            :  * ixgbe_enable_sec_rx_path - Enables the receive data path
    1611                 :            :  * @hw: pointer to hardware structure
    1612                 :            :  *
    1613                 :            :  * Enables the receive data path.
    1614                 :            :  **/
    1615                 :          0 : s32 ixgbe_enable_sec_rx_path(struct ixgbe_hw *hw)
    1616                 :            : {
    1617         [ #  # ]:          0 :         return ixgbe_call_func(hw, hw->mac.ops.enable_sec_rx_path,
    1618                 :            :                                 (hw), IXGBE_NOT_IMPLEMENTED);
    1619                 :            : }
    1620                 :            : 
    1621                 :            : /**
    1622                 :            :  * ixgbe_acquire_swfw_semaphore - Acquire SWFW semaphore
    1623                 :            :  * @hw: pointer to hardware structure
    1624                 :            :  * @mask: Mask to specify which semaphore to acquire
    1625                 :            :  *
    1626                 :            :  * Acquires the SWFW semaphore through SW_FW_SYNC register for the specified
    1627                 :            :  * function (CSR, PHY0, PHY1, EEPROM, Flash)
    1628                 :            :  **/
    1629                 :          0 : s32 ixgbe_acquire_swfw_semaphore(struct ixgbe_hw *hw, u32 mask)
    1630                 :            : {
    1631         [ #  # ]:          0 :         return ixgbe_call_func(hw, hw->mac.ops.acquire_swfw_sync,
    1632                 :            :                                (hw, mask), IXGBE_NOT_IMPLEMENTED);
    1633                 :            : }
    1634                 :            : 
    1635                 :            : /**
    1636                 :            :  * ixgbe_release_swfw_semaphore - Release SWFW semaphore
    1637                 :            :  * @hw: pointer to hardware structure
    1638                 :            :  * @mask: Mask to specify which semaphore to release
    1639                 :            :  *
    1640                 :            :  * Releases the SWFW semaphore through SW_FW_SYNC register for the specified
    1641                 :            :  * function (CSR, PHY0, PHY1, EEPROM, Flash)
    1642                 :            :  **/
    1643                 :          0 : void ixgbe_release_swfw_semaphore(struct ixgbe_hw *hw, u32 mask)
    1644                 :            : {
    1645         [ #  # ]:          0 :         if (hw->mac.ops.release_swfw_sync)
    1646                 :          0 :                 hw->mac.ops.release_swfw_sync(hw, mask);
    1647                 :          0 : }
    1648                 :            : 
    1649                 :            : /**
    1650                 :            :  * ixgbe_init_swfw_semaphore - Clean up SWFW semaphore
    1651                 :            :  * @hw: pointer to hardware structure
    1652                 :            :  *
    1653                 :            :  * Attempts to acquire the SWFW semaphore through SW_FW_SYNC register.
    1654                 :            :  * Regardless of whether is succeeds or not it then release the semaphore.
    1655                 :            :  * This is function is called to recover from catastrophic failures that
    1656                 :            :  * may have left the semaphore locked.
    1657                 :            :  **/
    1658                 :          0 : void ixgbe_init_swfw_semaphore(struct ixgbe_hw *hw)
    1659                 :            : {
    1660         [ #  # ]:          0 :         if (hw->mac.ops.init_swfw_sync)
    1661                 :          0 :                 hw->mac.ops.init_swfw_sync(hw);
    1662                 :          0 : }
    1663                 :            : 
    1664                 :            : 
    1665                 :          0 : void ixgbe_disable_rx(struct ixgbe_hw *hw)
    1666                 :            : {
    1667         [ #  # ]:          0 :         if (hw->mac.ops.disable_rx)
    1668                 :          0 :                 hw->mac.ops.disable_rx(hw);
    1669                 :          0 : }
    1670                 :            : 
    1671                 :          0 : void ixgbe_enable_rx(struct ixgbe_hw *hw)
    1672                 :            : {
    1673         [ #  # ]:          0 :         if (hw->mac.ops.enable_rx)
    1674                 :          0 :                 hw->mac.ops.enable_rx(hw);
    1675                 :          0 : }
    1676                 :            : 
    1677                 :            : /**
    1678                 :            :  * ixgbe_set_rate_select_speed - Set module link speed
    1679                 :            :  * @hw: pointer to hardware structure
    1680                 :            :  * @speed: link speed to set
    1681                 :            :  *
    1682                 :            :  * Set module link speed via the rate select.
    1683                 :            :  */
    1684                 :          0 : void ixgbe_set_rate_select_speed(struct ixgbe_hw *hw, ixgbe_link_speed speed)
    1685                 :            : {
    1686         [ #  # ]:          0 :         if (hw->mac.ops.set_rate_select_speed)
    1687                 :          0 :                 hw->mac.ops.set_rate_select_speed(hw, speed);
    1688                 :          0 : }

Generated by: LCOV version 1.14