drivers/net/e1000/base/e1000_api.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2001 - 2015 Intel Corporation
   3  */
   4
   5 #include "e1000_api.h"
   6
   7 /**
   8  *  e1000_init_mac_params - Initialize MAC function pointers
   9  *  @hw: pointer to the HW structure
  10  *
  11  *  This function initializes the function pointers for the MAC
  12  *  set of functions.  Called by drivers or by e1000_setup_init_funcs.
  13  **/
  14 s32 e1000_init_mac_params(struct e1000_hw *hw)
  15 {
  16         s32 ret_val = E1000_SUCCESS;
  17
  18         if (hw->mac.ops.init_params) {
  19                 ret_val = hw->mac.ops.init_params(hw);
  20                 if (ret_val) {
  21                         DEBUGOUT("MAC Initialization Error\n");
  22                         goto out;
  23                 }
  24         } else {
  25                 DEBUGOUT("mac.init_mac_params was NULL\n");
  26                 ret_val = -E1000_ERR_CONFIG;
  27         }
  28
  29 out:
  30         return ret_val;
  31 }
  32
  33 /**
  34  *  e1000_init_nvm_params - Initialize NVM function pointers
  35  *  @hw: pointer to the HW structure
  36  *
  37  *  This function initializes the function pointers for the NVM
  38  *  set of functions.  Called by drivers or by e1000_setup_init_funcs.
  39  **/
  40 s32 e1000_init_nvm_params(struct e1000_hw *hw)
  41 {
  42         s32 ret_val = E1000_SUCCESS;
  43
  44         if (hw->nvm.ops.init_params) {
  45                 ret_val = hw->nvm.ops.init_params(hw);
  46                 if (ret_val) {
  47                         DEBUGOUT("NVM Initialization Error\n");
  48                         goto out;
  49                 }
  50         } else {
  51                 DEBUGOUT("nvm.init_nvm_params was NULL\n");
  52                 ret_val = -E1000_ERR_CONFIG;
  53         }
  54
  55 out:
  56         return ret_val;
  57 }
  58
  59 /**
  60  *  e1000_init_phy_params - Initialize PHY function pointers
  61  *  @hw: pointer to the HW structure
  62  *
  63  *  This function initializes the function pointers for the PHY
  64  *  set of functions.  Called by drivers or by e1000_setup_init_funcs.
  65  **/
  66 s32 e1000_init_phy_params(struct e1000_hw *hw)
  67 {
  68         s32 ret_val = E1000_SUCCESS;
  69
  70         if (hw->phy.ops.init_params) {
  71                 ret_val = hw->phy.ops.init_params(hw);
  72                 if (ret_val) {
  73                         DEBUGOUT("PHY Initialization Error\n");
  74                         goto out;
  75                 }
  76         } else {
  77                 DEBUGOUT("phy.init_phy_params was NULL\n");
  78                 ret_val =  -E1000_ERR_CONFIG;
  79         }
  80
  81 out:
  82         return ret_val;
  83 }
  84
  85 /**
  86  *  e1000_init_mbx_params - Initialize mailbox function pointers
  87  *  @hw: pointer to the HW structure
  88  *
  89  *  This function initializes the function pointers for the PHY
  90  *  set of functions.  Called by drivers or by e1000_setup_init_funcs.
  91  **/
  92 s32 e1000_init_mbx_params(struct e1000_hw *hw)
  93 {
  94         s32 ret_val = E1000_SUCCESS;
  95
  96         if (hw->mbx.ops.init_params) {
  97                 ret_val = hw->mbx.ops.init_params(hw);
  98                 if (ret_val) {
  99                         DEBUGOUT("Mailbox Initialization Error\n");
 100                         goto out;
 101                 }
 102         } else {
 103                 DEBUGOUT("mbx.init_mbx_params was NULL\n");
 104                 ret_val =  -E1000_ERR_CONFIG;
 105         }
 106
 107 out:
 108         return ret_val;
 109 }
 110
 111 /**
 112  *  e1000_set_mac_type - Sets MAC type
 113  *  @hw: pointer to the HW structure
 114  *
 115  *  This function sets the mac type of the adapter based on the
 116  *  device ID stored in the hw structure.
 117  *  MUST BE FIRST FUNCTION CALLED (explicitly or through
 118  *  e1000_setup_init_funcs()).
 119  **/
 120 s32 e1000_set_mac_type(struct e1000_hw *hw)
 121 {
 122         struct e1000_mac_info *mac = &hw->mac;
 123         s32 ret_val = E1000_SUCCESS;
 124
 125         DEBUGFUNC("e1000_set_mac_type");
 126
 127         switch (hw->device_id) {
 128         case E1000_DEV_ID_82542:
 129                 mac->type = e1000_82542;
 130                 break;
 131         case E1000_DEV_ID_82543GC_FIBER:
 132         case E1000_DEV_ID_82543GC_COPPER:
 133                 mac->type = e1000_82543;
 134                 break;
 135         case E1000_DEV_ID_82544EI_COPPER:
 136         case E1000_DEV_ID_82544EI_FIBER:
 137         case E1000_DEV_ID_82544GC_COPPER:
 138         case E1000_DEV_ID_82544GC_LOM:
 139                 mac->type = e1000_82544;
 140                 break;
 141         case E1000_DEV_ID_82540EM:
 142         case E1000_DEV_ID_82540EM_LOM:
 143         case E1000_DEV_ID_82540EP:
 144         case E1000_DEV_ID_82540EP_LOM:
 145         case E1000_DEV_ID_82540EP_LP:
 146                 mac->type = e1000_82540;
 147                 break;
 148         case E1000_DEV_ID_82545EM_COPPER:
 149         case E1000_DEV_ID_82545EM_FIBER:
 150                 mac->type = e1000_82545;
 151                 break;
 152         case E1000_DEV_ID_82545GM_COPPER:
 153         case E1000_DEV_ID_82545GM_FIBER:
 154         case E1000_DEV_ID_82545GM_SERDES:
 155                 mac->type = e1000_82545_rev_3;
 156                 break;
 157         case E1000_DEV_ID_82546EB_COPPER:
 158         case E1000_DEV_ID_82546EB_FIBER:
 159         case E1000_DEV_ID_82546EB_QUAD_COPPER:
 160                 mac->type = e1000_82546;
 161                 break;
 162         case E1000_DEV_ID_82546GB_COPPER:
 163         case E1000_DEV_ID_82546GB_FIBER:
 164         case E1000_DEV_ID_82546GB_SERDES:
 165         case E1000_DEV_ID_82546GB_PCIE:
 166         case E1000_DEV_ID_82546GB_QUAD_COPPER:
 167         case E1000_DEV_ID_82546GB_QUAD_COPPER_KSP3:
 168                 mac->type = e1000_82546_rev_3;
 169                 break;
 170         case E1000_DEV_ID_82541EI:
 171         case E1000_DEV_ID_82541EI_MOBILE:
 172         case E1000_DEV_ID_82541ER_LOM:
 173                 mac->type = e1000_82541;
 174                 break;
 175         case E1000_DEV_ID_82541ER:
 176         case E1000_DEV_ID_82541GI:
 177         case E1000_DEV_ID_82541GI_LF:
 178         case E1000_DEV_ID_82541GI_MOBILE:
 179                 mac->type = e1000_82541_rev_2;
 180                 break;
 181         case E1000_DEV_ID_82547EI:
 182         case E1000_DEV_ID_82547EI_MOBILE:
 183                 mac->type = e1000_82547;
 184                 break;
 185         case E1000_DEV_ID_82547GI:
 186                 mac->type = e1000_82547_rev_2;
 187                 break;
 188         case E1000_DEV_ID_82571EB_COPPER:
 189         case E1000_DEV_ID_82571EB_FIBER:
 190         case E1000_DEV_ID_82571EB_SERDES:
 191         case E1000_DEV_ID_82571EB_SERDES_DUAL:
 192         case E1000_DEV_ID_82571EB_SERDES_QUAD:
 193         case E1000_DEV_ID_82571EB_QUAD_COPPER:
 194         case E1000_DEV_ID_82571PT_QUAD_COPPER:
 195         case E1000_DEV_ID_82571EB_QUAD_FIBER:
 196         case E1000_DEV_ID_82571EB_QUAD_COPPER_LP:
 197                 mac->type = e1000_82571;
 198                 break;
 199         case E1000_DEV_ID_82572EI:
 200         case E1000_DEV_ID_82572EI_COPPER:
 201         case E1000_DEV_ID_82572EI_FIBER:
 202         case E1000_DEV_ID_82572EI_SERDES:
 203                 mac->type = e1000_82572;
 204                 break;
 205         case E1000_DEV_ID_82573E:
 206         case E1000_DEV_ID_82573E_IAMT:
 207         case E1000_DEV_ID_82573L:
 208                 mac->type = e1000_82573;
 209                 break;
 210         case E1000_DEV_ID_82574L:
 211         case E1000_DEV_ID_82574LA:
 212                 mac->type = e1000_82574;
 213                 break;
 214         case E1000_DEV_ID_82583V:
 215                 mac->type = e1000_82583;
 216                 break;
 217         case E1000_DEV_ID_80003ES2LAN_COPPER_DPT:
 218         case E1000_DEV_ID_80003ES2LAN_SERDES_DPT:
 219         case E1000_DEV_ID_80003ES2LAN_COPPER_SPT:
 220         case E1000_DEV_ID_80003ES2LAN_SERDES_SPT:
 221                 mac->type = e1000_80003es2lan;
 222                 break;
 223         case E1000_DEV_ID_ICH8_IFE:
 224         case E1000_DEV_ID_ICH8_IFE_GT:
 225         case E1000_DEV_ID_ICH8_IFE_G:
 226         case E1000_DEV_ID_ICH8_IGP_M:
 227         case E1000_DEV_ID_ICH8_IGP_M_AMT:
 228         case E1000_DEV_ID_ICH8_IGP_AMT:
 229         case E1000_DEV_ID_ICH8_IGP_C:
 230         case E1000_DEV_ID_ICH8_82567V_3:
 231                 mac->type = e1000_ich8lan;
 232                 break;
 233         case E1000_DEV_ID_ICH9_IFE:
 234         case E1000_DEV_ID_ICH9_IFE_GT:
 235         case E1000_DEV_ID_ICH9_IFE_G:
 236         case E1000_DEV_ID_ICH9_IGP_M:
 237         case E1000_DEV_ID_ICH9_IGP_M_AMT:
 238         case E1000_DEV_ID_ICH9_IGP_M_V:
 239         case E1000_DEV_ID_ICH9_IGP_AMT:
 240         case E1000_DEV_ID_ICH9_BM:
 241         case E1000_DEV_ID_ICH9_IGP_C:
 242         case E1000_DEV_ID_ICH10_R_BM_LM:
 243         case E1000_DEV_ID_ICH10_R_BM_LF:
 244         case E1000_DEV_ID_ICH10_R_BM_V:
 245                 mac->type = e1000_ich9lan;
 246                 break;
 247         case E1000_DEV_ID_ICH10_D_BM_LM:
 248         case E1000_DEV_ID_ICH10_D_BM_LF:
 249         case E1000_DEV_ID_ICH10_D_BM_V:
 250                 mac->type = e1000_ich10lan;
 251                 break;
 252         case E1000_DEV_ID_PCH_D_HV_DM:
 253         case E1000_DEV_ID_PCH_D_HV_DC:
 254         case E1000_DEV_ID_PCH_M_HV_LM:
 255         case E1000_DEV_ID_PCH_M_HV_LC:
 256                 mac->type = e1000_pchlan;
 257                 break;
 258         case E1000_DEV_ID_PCH2_LV_LM:
 259         case E1000_DEV_ID_PCH2_LV_V:
 260                 mac->type = e1000_pch2lan;
 261                 break;
 262         case E1000_DEV_ID_PCH_LPT_I217_LM:
 263         case E1000_DEV_ID_PCH_LPT_I217_V:
 264         case E1000_DEV_ID_PCH_LPTLP_I218_LM:
 265         case E1000_DEV_ID_PCH_LPTLP_I218_V:
 266         case E1000_DEV_ID_PCH_I218_LM2:
 267         case E1000_DEV_ID_PCH_I218_V2:
 268         case E1000_DEV_ID_PCH_I218_LM3:
 269         case E1000_DEV_ID_PCH_I218_V3:
 270                 mac->type = e1000_pch_lpt;
 271                 break;
 272         case E1000_DEV_ID_PCH_SPT_I219_LM:
 273         case E1000_DEV_ID_PCH_SPT_I219_V:
 274         case E1000_DEV_ID_PCH_SPT_I219_LM2:
 275         case E1000_DEV_ID_PCH_SPT_I219_V2:
 276         case E1000_DEV_ID_PCH_LBG_I219_LM3:
 277         case E1000_DEV_ID_PCH_SPT_I219_LM4:
 278         case E1000_DEV_ID_PCH_SPT_I219_V4:
 279         case E1000_DEV_ID_PCH_SPT_I219_LM5:
 280         case E1000_DEV_ID_PCH_SPT_I219_V5:
 281                 mac->type = e1000_pch_spt;
 282                 break;
 283         case E1000_DEV_ID_PCH_CNP_I219_LM6:
 284         case E1000_DEV_ID_PCH_CNP_I219_V6:
 285         case E1000_DEV_ID_PCH_CNP_I219_LM7:
 286         case E1000_DEV_ID_PCH_CNP_I219_V7:
 287         case E1000_DEV_ID_PCH_ICP_I219_LM8:
 288         case E1000_DEV_ID_PCH_ICP_I219_V8:
 289         case E1000_DEV_ID_PCH_ICP_I219_LM9:
 290         case E1000_DEV_ID_PCH_ICP_I219_V9:
 291                 mac->type = e1000_pch_cnp;
 292                 break;
 293         case E1000_DEV_ID_82575EB_COPPER:
 294         case E1000_DEV_ID_82575EB_FIBER_SERDES:
 295         case E1000_DEV_ID_82575GB_QUAD_COPPER:
 296                 mac->type = e1000_82575;
 297                 break;
 298         case E1000_DEV_ID_82576:
 299         case E1000_DEV_ID_82576_FIBER:
 300         case E1000_DEV_ID_82576_SERDES:
 301         case E1000_DEV_ID_82576_QUAD_COPPER:
 302         case E1000_DEV_ID_82576_QUAD_COPPER_ET2:
 303         case E1000_DEV_ID_82576_NS:
 304         case E1000_DEV_ID_82576_NS_SERDES:
 305         case E1000_DEV_ID_82576_SERDES_QUAD:
 306                 mac->type = e1000_82576;
 307                 break;
 308         case E1000_DEV_ID_82580_COPPER:
 309         case E1000_DEV_ID_82580_FIBER:
 310         case E1000_DEV_ID_82580_SERDES:
 311         case E1000_DEV_ID_82580_SGMII:
 312         case E1000_DEV_ID_82580_COPPER_DUAL:
 313         case E1000_DEV_ID_82580_QUAD_FIBER:
 314         case E1000_DEV_ID_DH89XXCC_SGMII:
 315         case E1000_DEV_ID_DH89XXCC_SERDES:
 316         case E1000_DEV_ID_DH89XXCC_BACKPLANE:
 317         case E1000_DEV_ID_DH89XXCC_SFP:
 318                 mac->type = e1000_82580;
 319                 break;
 320         case E1000_DEV_ID_I350_COPPER:
 321         case E1000_DEV_ID_I350_FIBER:
 322         case E1000_DEV_ID_I350_SERDES:
 323         case E1000_DEV_ID_I350_SGMII:
 324         case E1000_DEV_ID_I350_DA4:
 325                 mac->type = e1000_i350;
 326                 break;
 327         case E1000_DEV_ID_I210_COPPER_FLASHLESS:
 328         case E1000_DEV_ID_I210_SERDES_FLASHLESS:
 329         case E1000_DEV_ID_I210_SGMII_FLASHLESS:
 330         case E1000_DEV_ID_I210_COPPER:
 331         case E1000_DEV_ID_I210_COPPER_OEM1:
 332         case E1000_DEV_ID_I210_COPPER_IT:
 333         case E1000_DEV_ID_I210_FIBER:
 334         case E1000_DEV_ID_I210_SERDES:
 335         case E1000_DEV_ID_I210_SGMII:
 336                 mac->type = e1000_i210;
 337                 break;
 338         case E1000_DEV_ID_I211_COPPER:
 339                 mac->type = e1000_i211;
 340                 break;
 341         case E1000_DEV_ID_82576_VF:
 342         case E1000_DEV_ID_82576_VF_HV:
 343                 mac->type = e1000_vfadapt;
 344                 break;
 345         case E1000_DEV_ID_I350_VF:
 346         case E1000_DEV_ID_I350_VF_HV:
 347                 mac->type = e1000_vfadapt_i350;
 348                 break;
 349
 350         case E1000_DEV_ID_I354_BACKPLANE_1GBPS:
 351         case E1000_DEV_ID_I354_SGMII:
 352         case E1000_DEV_ID_I354_BACKPLANE_2_5GBPS:
 353                 mac->type = e1000_i354;
 354                 break;
 355         default:
 356                 /* Should never have loaded on this device */
 357                 ret_val = -E1000_ERR_MAC_INIT;
 358                 break;
 359         }
 360
 361         return ret_val;
 362 }
 363
 364 /**
 365  *  e1000_setup_init_funcs - Initializes function pointers
 366  *  @hw: pointer to the HW structure
 367  *  @init_device: true will initialize the rest of the function pointers
 368  *                getting the device ready for use.  false will only set
 369  *                MAC type and the function pointers for the other init
 370  *                functions.  Passing false will not generate any hardware
 371  *                reads or writes.
 372  *
 373  *  This function must be called by a driver in order to use the rest
 374  *  of the 'shared' code files. Called by drivers only.
 375  **/
 376 s32 e1000_setup_init_funcs(struct e1000_hw *hw, bool init_device)
 377 {
 378         s32 ret_val;
 379
 380         /* Can't do much good without knowing the MAC type. */
 381         ret_val = e1000_set_mac_type(hw);
 382         if (ret_val) {
 383                 DEBUGOUT("ERROR: MAC type could not be set properly.\n");
 384                 goto out;
 385         }
 386
 387         if (!hw->hw_addr) {
 388                 DEBUGOUT("ERROR: Registers not mapped\n");
 389                 ret_val = -E1000_ERR_CONFIG;
 390                 goto out;
 391         }
 392
 393         /*
 394          * Init function pointers to generic implementations. We do this first
 395          * allowing a driver module to override it afterward.
 396          */
 397         e1000_init_mac_ops_generic(hw);
 398         e1000_init_phy_ops_generic(hw);
 399         e1000_init_nvm_ops_generic(hw);
 400         e1000_init_mbx_ops_generic(hw);
 401
 402         /*
 403          * Set up the init function pointers. These are functions within the
 404          * adapter family file that sets up function pointers for the rest of
 405          * the functions in that family.
 406          */
 407         switch (hw->mac.type) {
 408         case e1000_82542:
 409                 e1000_init_function_pointers_82542(hw);
 410                 break;
 411         case e1000_82543:
 412         case e1000_82544:
 413                 e1000_init_function_pointers_82543(hw);
 414                 break;
 415         case e1000_82540:
 416         case e1000_82545:
 417         case e1000_82545_rev_3:
 418         case e1000_82546:
 419         case e1000_82546_rev_3:
 420                 e1000_init_function_pointers_82540(hw);
 421                 break;
 422         case e1000_82541:
 423         case e1000_82541_rev_2:
 424         case e1000_82547:
 425         case e1000_82547_rev_2:
 426                 e1000_init_function_pointers_82541(hw);
 427                 break;
 428         case e1000_82571:
 429         case e1000_82572:
 430         case e1000_82573:
 431         case e1000_82574:
 432         case e1000_82583:
 433                 e1000_init_function_pointers_82571(hw);
 434                 break;
 435         case e1000_80003es2lan:
 436                 e1000_init_function_pointers_80003es2lan(hw);
 437                 break;
 438         case e1000_ich8lan:
 439         case e1000_ich9lan:
 440         case e1000_ich10lan:
 441         case e1000_pchlan:
 442         case e1000_pch2lan:
 443         case e1000_pch_lpt:
 444         case e1000_pch_spt:
 445         case e1000_pch_cnp:
 446                 e1000_init_function_pointers_ich8lan(hw);
 447                 break;
 448         case e1000_82575:
 449         case e1000_82576:
 450         case e1000_82580:
 451         case e1000_i350:
 452         case e1000_i354:
 453                 e1000_init_function_pointers_82575(hw);
 454                 break;
 455         case e1000_i210:
 456         case e1000_i211:
 457                 e1000_init_function_pointers_i210(hw);
 458                 break;
 459         case e1000_vfadapt:
 460                 e1000_init_function_pointers_vf(hw);
 461                 break;
 462         case e1000_vfadapt_i350:
 463                 e1000_init_function_pointers_vf(hw);
 464                 break;
 465         default:
 466                 DEBUGOUT("Hardware not supported\n");
 467                 ret_val = -E1000_ERR_CONFIG;
 468                 break;
 469         }
 470
 471         /*
 472          * Initialize the rest of the function pointers. These require some
 473          * register reads/writes in some cases.
 474          */
 475         if (!(ret_val) && init_device) {
 476                 ret_val = e1000_init_mac_params(hw);
 477                 if (ret_val)
 478                         goto out;
 479
 480                 ret_val = e1000_init_nvm_params(hw);
 481                 if (ret_val)
 482                         goto out;
 483
 484                 ret_val = e1000_init_phy_params(hw);
 485                 if (ret_val)
 486                         goto out;
 487
 488                 ret_val = e1000_init_mbx_params(hw);
 489                 if (ret_val)
 490                         goto out;
 491         }
 492
 493 out:
 494         return ret_val;
 495 }
 496
 497 /**
 498  *  e1000_get_bus_info - Obtain bus information for adapter
 499  *  @hw: pointer to the HW structure
 500  *
 501  *  This will obtain information about the HW bus for which the
 502  *  adapter is attached and stores it in the hw structure. This is a
 503  *  function pointer entry point called by drivers.
 504  **/
 505 s32 e1000_get_bus_info(struct e1000_hw *hw)
 506 {
 507         if (hw->mac.ops.get_bus_info)
 508                 return hw->mac.ops.get_bus_info(hw);
 509
 510         return E1000_SUCCESS;
 511 }
 512
 513 /**
 514  *  e1000_clear_vfta - Clear VLAN filter table
 515  *  @hw: pointer to the HW structure
 516  *
 517  *  This clears the VLAN filter table on the adapter. This is a function
 518  *  pointer entry point called by drivers.
 519  **/
 520 void e1000_clear_vfta(struct e1000_hw *hw)
 521 {
 522         if (hw->mac.ops.clear_vfta)
 523                 hw->mac.ops.clear_vfta(hw);
 524 }
 525
 526 /**
 527  *  e1000_write_vfta - Write value to VLAN filter table
 528  *  @hw: pointer to the HW structure
 529  *  @offset: the 32-bit offset in which to write the value to.
 530  *  @value: the 32-bit value to write at location offset.
 531  *
 532  *  This writes a 32-bit value to a 32-bit offset in the VLAN filter
 533  *  table. This is a function pointer entry point called by drivers.
 534  **/
 535 void e1000_write_vfta(struct e1000_hw *hw, u32 offset, u32 value)
 536 {
 537         if (hw->mac.ops.write_vfta)
 538                 hw->mac.ops.write_vfta(hw, offset, value);
 539 }
 540
 541 /**
 542  *  e1000_update_mc_addr_list - Update Multicast addresses
 543  *  @hw: pointer to the HW structure
 544  *  @mc_addr_list: array of multicast addresses to program
 545  *  @mc_addr_count: number of multicast addresses to program
 546  *
 547  *  Updates the Multicast Table Array.
 548  *  The caller must have a packed mc_addr_list of multicast addresses.
 549  **/
 550 void e1000_update_mc_addr_list(struct e1000_hw *hw, u8 *mc_addr_list,
 551                                u32 mc_addr_count)
 552 {
 553         if (hw->mac.ops.update_mc_addr_list)
 554                 hw->mac.ops.update_mc_addr_list(hw, mc_addr_list,
 555                                                 mc_addr_count);
 556 }
 557
 558 /**
 559  *  e1000_force_mac_fc - Force MAC flow control
 560  *  @hw: pointer to the HW structure
 561  *
 562  *  Force the MAC's flow control settings. Currently no func pointer exists
 563  *  and all implementations are handled in the generic version of this
 564  *  function.
 565  **/
 566 s32 e1000_force_mac_fc(struct e1000_hw *hw)
 567 {
 568         return e1000_force_mac_fc_generic(hw);
 569 }
 570
 571 /**
 572  *  e1000_check_for_link - Check/Store link connection
 573  *  @hw: pointer to the HW structure
 574  *
 575  *  This checks the link condition of the adapter and stores the
 576  *  results in the hw->mac structure. This is a function pointer entry
 577  *  point called by drivers.
 578  **/
 579 s32 e1000_check_for_link(struct e1000_hw *hw)
 580 {
 581         if (hw->mac.ops.check_for_link)
 582                 return hw->mac.ops.check_for_link(hw);
 583
 584         return -E1000_ERR_CONFIG;
 585 }
 586
 587 /**
 588  *  e1000_check_mng_mode - Check management mode
 589  *  @hw: pointer to the HW structure
 590  *
 591  *  This checks if the adapter has manageability enabled.
 592  *  This is a function pointer entry point called by drivers.
 593  **/
 594 bool e1000_check_mng_mode(struct e1000_hw *hw)
 595 {
 596         if (hw->mac.ops.check_mng_mode)
 597                 return hw->mac.ops.check_mng_mode(hw);
 598
 599         return false;
 600 }
 601
 602 /**
 603  *  e1000_mng_write_dhcp_info - Writes DHCP info to host interface
 604  *  @hw: pointer to the HW structure
 605  *  @buffer: pointer to the host interface
 606  *  @length: size of the buffer
 607  *
 608  *  Writes the DHCP information to the host interface.
 609  **/
 610 s32 e1000_mng_write_dhcp_info(struct e1000_hw *hw, u8 *buffer, u16 length)
 611 {
 612         return e1000_mng_write_dhcp_info_generic(hw, buffer, length);
 613 }
 614
 615 /**
 616  *  e1000_reset_hw - Reset hardware
 617  *  @hw: pointer to the HW structure
 618  *
 619  *  This resets the hardware into a known state. This is a function pointer
 620  *  entry point called by drivers.
 621  **/
 622 s32 e1000_reset_hw(struct e1000_hw *hw)
 623 {
 624         if (hw->mac.ops.reset_hw)
 625                 return hw->mac.ops.reset_hw(hw);
 626
 627         return -E1000_ERR_CONFIG;
 628 }
 629
 630 /**
 631  *  e1000_init_hw - Initialize hardware
 632  *  @hw: pointer to the HW structure
 633  *
 634  *  This inits the hardware readying it for operation. This is a function
 635  *  pointer entry point called by drivers.
 636  **/
 637 s32 e1000_init_hw(struct e1000_hw *hw)
 638 {
 639         if (hw->mac.ops.init_hw)
 640                 return hw->mac.ops.init_hw(hw);
 641
 642         return -E1000_ERR_CONFIG;
 643 }
 644
 645 /**
 646  *  e1000_setup_link - Configures link and flow control
 647  *  @hw: pointer to the HW structure
 648  *
 649  *  This configures link and flow control settings for the adapter. This
 650  *  is a function pointer entry point called by drivers. While modules can
 651  *  also call this, they probably call their own version of this function.
 652  **/
 653 s32 e1000_setup_link(struct e1000_hw *hw)
 654 {
 655         if (hw->mac.ops.setup_link)
 656                 return hw->mac.ops.setup_link(hw);
 657
 658         return -E1000_ERR_CONFIG;
 659 }
 660
 661 /**
 662  *  e1000_get_speed_and_duplex - Returns current speed and duplex
 663  *  @hw: pointer to the HW structure
 664  *  @speed: pointer to a 16-bit value to store the speed
 665  *  @duplex: pointer to a 16-bit value to store the duplex.
 666  *
 667  *  This returns the speed and duplex of the adapter in the two 'out'
 668  *  variables passed in. This is a function pointer entry point called
 669  *  by drivers.
 670  **/
 671 s32 e1000_get_speed_and_duplex(struct e1000_hw *hw, u16 *speed, u16 *duplex)
 672 {
 673         if (hw->mac.ops.get_link_up_info)
 674                 return hw->mac.ops.get_link_up_info(hw, speed, duplex);
 675
 676         return -E1000_ERR_CONFIG;
 677 }
 678
 679 /**
 680  *  e1000_setup_led - Configures SW controllable LED
 681  *  @hw: pointer to the HW structure
 682  *
 683  *  This prepares the SW controllable LED for use and saves the current state
 684  *  of the LED so it can be later restored. This is a function pointer entry
 685  *  point called by drivers.
 686  **/
 687 s32 e1000_setup_led(struct e1000_hw *hw)
 688 {
 689         if (hw->mac.ops.setup_led)
 690                 return hw->mac.ops.setup_led(hw);
 691
 692         return E1000_SUCCESS;
 693 }
 694
 695 /**
 696  *  e1000_cleanup_led - Restores SW controllable LED
 697  *  @hw: pointer to the HW structure
 698  *
 699  *  This restores the SW controllable LED to the value saved off by
 700  *  e1000_setup_led. This is a function pointer entry point called by drivers.
 701  **/
 702 s32 e1000_cleanup_led(struct e1000_hw *hw)
 703 {
 704         if (hw->mac.ops.cleanup_led)
 705                 return hw->mac.ops.cleanup_led(hw);
 706
 707         return E1000_SUCCESS;
 708 }
 709
 710 /**
 711  *  e1000_blink_led - Blink SW controllable LED
 712  *  @hw: pointer to the HW structure
 713  *
 714  *  This starts the adapter LED blinking. Request the LED to be setup first
 715  *  and cleaned up after. This is a function pointer entry point called by
 716  *  drivers.
 717  **/
 718 s32 e1000_blink_led(struct e1000_hw *hw)
 719 {
 720         if (hw->mac.ops.blink_led)
 721                 return hw->mac.ops.blink_led(hw);
 722
 723         return E1000_SUCCESS;
 724 }
 725
 726 /**
 727  *  e1000_id_led_init - store LED configurations in SW
 728  *  @hw: pointer to the HW structure
 729  *
 730  *  Initializes the LED config in SW. This is a function pointer entry point
 731  *  called by drivers.
 732  **/
 733 s32 e1000_id_led_init(struct e1000_hw *hw)
 734 {
 735         if (hw->mac.ops.id_led_init)
 736                 return hw->mac.ops.id_led_init(hw);
 737
 738         return E1000_SUCCESS;
 739 }
 740
 741 /**
 742  *  e1000_led_on - Turn on SW controllable LED
 743  *  @hw: pointer to the HW structure
 744  *
 745  *  Turns the SW defined LED on. This is a function pointer entry point
 746  *  called by drivers.
 747  **/
 748 s32 e1000_led_on(struct e1000_hw *hw)
 749 {
 750         if (hw->mac.ops.led_on)
 751                 return hw->mac.ops.led_on(hw);
 752
 753         return E1000_SUCCESS;
 754 }
 755
 756 /**
 757  *  e1000_led_off - Turn off SW controllable LED
 758  *  @hw: pointer to the HW structure
 759  *
 760  *  Turns the SW defined LED off. This is a function pointer entry point
 761  *  called by drivers.
 762  **/
 763 s32 e1000_led_off(struct e1000_hw *hw)
 764 {
 765         if (hw->mac.ops.led_off)
 766                 return hw->mac.ops.led_off(hw);
 767
 768         return E1000_SUCCESS;
 769 }
 770
 771 /**
 772  *  e1000_reset_adaptive - Reset adaptive IFS
 773  *  @hw: pointer to the HW structure
 774  *
 775  *  Resets the adaptive IFS. Currently no func pointer exists and all
 776  *  implementations are handled in the generic version of this function.
 777  **/
 778 void e1000_reset_adaptive(struct e1000_hw *hw)
 779 {
 780         e1000_reset_adaptive_generic(hw);
 781 }
 782
 783 /**
 784  *  e1000_update_adaptive - Update adaptive IFS
 785  *  @hw: pointer to the HW structure
 786  *
 787  *  Updates adapter IFS. Currently no func pointer exists and all
 788  *  implementations are handled in the generic version of this function.
 789  **/
 790 void e1000_update_adaptive(struct e1000_hw *hw)
 791 {
 792         e1000_update_adaptive_generic(hw);
 793 }
 794
 795 /**
 796  *  e1000_disable_pcie_master - Disable PCI-Express master access
 797  *  @hw: pointer to the HW structure
 798  *
 799  *  Disables PCI-Express master access and verifies there are no pending
 800  *  requests. Currently no func pointer exists and all implementations are
 801  *  handled in the generic version of this function.
 802  **/
 803 s32 e1000_disable_pcie_master(struct e1000_hw *hw)
 804 {
 805         return e1000_disable_pcie_master_generic(hw);
 806 }
 807
 808 /**
 809  *  e1000_config_collision_dist - Configure collision distance
 810  *  @hw: pointer to the HW structure
 811  *
 812  *  Configures the collision distance to the default value and is used
 813  *  during link setup.
 814  **/
 815 void e1000_config_collision_dist(struct e1000_hw *hw)
 816 {
 817         if (hw->mac.ops.config_collision_dist)
 818                 hw->mac.ops.config_collision_dist(hw);
 819 }
 820
 821 /**
 822  *  e1000_rar_set - Sets a receive address register
 823  *  @hw: pointer to the HW structure
 824  *  @addr: address to set the RAR to
 825  *  @index: the RAR to set
 826  *
 827  *  Sets a Receive Address Register (RAR) to the specified address.
 828  **/
 829 int e1000_rar_set(struct e1000_hw *hw, u8 *addr, u32 index)
 830 {
 831         if (hw->mac.ops.rar_set)
 832                 return hw->mac.ops.rar_set(hw, addr, index);
 833
 834         return E1000_SUCCESS;
 835 }
 836
 837 /**
 838  *  e1000_validate_mdi_setting - Ensures valid MDI/MDIX SW state
 839  *  @hw: pointer to the HW structure
 840  *
 841  *  Ensures that the MDI/MDIX SW state is valid.
 842  **/
 843 s32 e1000_validate_mdi_setting(struct e1000_hw *hw)
 844 {
 845         if (hw->mac.ops.validate_mdi_setting)
 846                 return hw->mac.ops.validate_mdi_setting(hw);
 847
 848         return E1000_SUCCESS;
 849 }
 850
 851 /**
 852  *  e1000_hash_mc_addr - Determines address location in multicast table
 853  *  @hw: pointer to the HW structure
 854  *  @mc_addr: Multicast address to hash.
 855  *
 856  *  This hashes an address to determine its location in the multicast
 857  *  table. Currently no func pointer exists and all implementations
 858  *  are handled in the generic version of this function.
 859  **/
 860 u32 e1000_hash_mc_addr(struct e1000_hw *hw, u8 *mc_addr)
 861 {
 862         return e1000_hash_mc_addr_generic(hw, mc_addr);
 863 }
 864
 865 /**
 866  *  e1000_enable_tx_pkt_filtering - Enable packet filtering on TX
 867  *  @hw: pointer to the HW structure
 868  *
 869  *  Enables packet filtering on transmit packets if manageability is enabled
 870  *  and host interface is enabled.
 871  *  Currently no func pointer exists and all implementations are handled in the
 872  *  generic version of this function.
 873  **/
 874 bool e1000_enable_tx_pkt_filtering(struct e1000_hw *hw)
 875 {
 876         return e1000_enable_tx_pkt_filtering_generic(hw);
 877 }
 878
 879 /**
 880  *  e1000_mng_host_if_write - Writes to the manageability host interface
 881  *  @hw: pointer to the HW structure
 882  *  @buffer: pointer to the host interface buffer
 883  *  @length: size of the buffer
 884  *  @offset: location in the buffer to write to
 885  *  @sum: sum of the data (not checksum)
 886  *
 887  *  This function writes the buffer content at the offset given on the host if.
 888  *  It also does alignment considerations to do the writes in most efficient
 889  *  way.  Also fills up the sum of the buffer in *buffer parameter.
 890  **/
 891 s32 e1000_mng_host_if_write(struct e1000_hw *hw, u8 *buffer, u16 length,
 892                             u16 offset, u8 *sum)
 893 {
 894         return e1000_mng_host_if_write_generic(hw, buffer, length, offset, sum);
 895 }
 896
 897 /**
 898  *  e1000_mng_write_cmd_header - Writes manageability command header
 899  *  @hw: pointer to the HW structure
 900  *  @hdr: pointer to the host interface command header
 901  *
 902  *  Writes the command header after does the checksum calculation.
 903  **/
 904 s32 e1000_mng_write_cmd_header(struct e1000_hw *hw,
 905                                struct e1000_host_mng_command_header *hdr)
 906 {
 907         return e1000_mng_write_cmd_header_generic(hw, hdr);
 908 }
 909
 910 /**
 911  *  e1000_mng_enable_host_if - Checks host interface is enabled
 912  *  @hw: pointer to the HW structure
 913  *
 914  *  Returns E1000_success upon success, else E1000_ERR_HOST_INTERFACE_COMMAND
 915  *
 916  *  This function checks whether the HOST IF is enabled for command operation
 917  *  and also checks whether the previous command is completed.  It busy waits
 918  *  in case of previous command is not completed.
 919  **/
 920 s32 e1000_mng_enable_host_if(struct e1000_hw *hw)
 921 {
 922         return e1000_mng_enable_host_if_generic(hw);
 923 }
 924
 925 /**
 926  *  e1000_check_reset_block - Verifies PHY can be reset
 927  *  @hw: pointer to the HW structure
 928  *
 929  *  Checks if the PHY is in a state that can be reset or if manageability
 930  *  has it tied up. This is a function pointer entry point called by drivers.
 931  **/
 932 s32 e1000_check_reset_block(struct e1000_hw *hw)
 933 {
 934         if (hw->phy.ops.check_reset_block)
 935                 return hw->phy.ops.check_reset_block(hw);
 936
 937         return E1000_SUCCESS;
 938 }
 939
 940 /**
 941  *  e1000_read_phy_reg - Reads PHY register
 942  *  @hw: pointer to the HW structure
 943  *  @offset: the register to read
 944  *  @data: the buffer to store the 16-bit read.
 945  *
 946  *  Reads the PHY register and returns the value in data.
 947  *  This is a function pointer entry point called by drivers.
 948  **/
 949 s32 e1000_read_phy_reg(struct e1000_hw *hw, u32 offset, u16 *data)
 950 {
 951         if (hw->phy.ops.read_reg)
 952                 return hw->phy.ops.read_reg(hw, offset, data);
 953
 954         return E1000_SUCCESS;
 955 }
 956
 957 /**
 958  *  e1000_write_phy_reg - Writes PHY register
 959  *  @hw: pointer to the HW structure
 960  *  @offset: the register to write
 961  *  @data: the value to write.
 962  *
 963  *  Writes the PHY register at offset with the value in data.
 964  *  This is a function pointer entry point called by drivers.
 965  **/
 966 s32 e1000_write_phy_reg(struct e1000_hw *hw, u32 offset, u16 data)
 967 {
 968         if (hw->phy.ops.write_reg)
 969                 return hw->phy.ops.write_reg(hw, offset, data);
 970
 971         return E1000_SUCCESS;
 972 }
 973
 974 /**
 975  *  e1000_release_phy - Generic release PHY
 976  *  @hw: pointer to the HW structure
 977  *
 978  *  Return if silicon family does not require a semaphore when accessing the
 979  *  PHY.
 980  **/
 981 void e1000_release_phy(struct e1000_hw *hw)
 982 {
 983         if (hw->phy.ops.release)
 984                 hw->phy.ops.release(hw);
 985 }
 986
 987 /**
 988  *  e1000_acquire_phy - Generic acquire PHY
 989  *  @hw: pointer to the HW structure
 990  *
 991  *  Return success if silicon family does not require a semaphore when
 992  *  accessing the PHY.
 993  **/
 994 s32 e1000_acquire_phy(struct e1000_hw *hw)
 995 {
 996         if (hw->phy.ops.acquire)
 997                 return hw->phy.ops.acquire(hw);
 998
 999         return E1000_SUCCESS;
1000 }
1001
1002 /**
1003  *  e1000_cfg_on_link_up - Configure PHY upon link up
1004  *  @hw: pointer to the HW structure
1005  **/
1006 s32 e1000_cfg_on_link_up(struct e1000_hw *hw)
1007 {
1008         if (hw->phy.ops.cfg_on_link_up)
1009                 return hw->phy.ops.cfg_on_link_up(hw);
1010
1011         return E1000_SUCCESS;
1012 }
1013
1014 /**
1015  *  e1000_read_kmrn_reg - Reads register using Kumeran interface
1016  *  @hw: pointer to the HW structure
1017  *  @offset: the register to read
1018  *  @data: the location to store the 16-bit value read.
1019  *
1020  *  Reads a register out of the Kumeran interface. Currently no func pointer
1021  *  exists and all implementations are handled in the generic version of
1022  *  this function.
1023  **/
1024 s32 e1000_read_kmrn_reg(struct e1000_hw *hw, u32 offset, u16 *data)
1025 {
1026         return e1000_read_kmrn_reg_generic(hw, offset, data);
1027 }
1028
1029 /**
1030  *  e1000_write_kmrn_reg - Writes register using Kumeran interface
1031  *  @hw: pointer to the HW structure
1032  *  @offset: the register to write
1033  *  @data: the value to write.
1034  *
1035  *  Writes a register to the Kumeran interface. Currently no func pointer
1036  *  exists and all implementations are handled in the generic version of
1037  *  this function.
1038  **/
1039 s32 e1000_write_kmrn_reg(struct e1000_hw *hw, u32 offset, u16 data)
1040 {
1041         return e1000_write_kmrn_reg_generic(hw, offset, data);
1042 }
1043
1044 /**
1045  *  e1000_get_cable_length - Retrieves cable length estimation
1046  *  @hw: pointer to the HW structure
1047  *
1048  *  This function estimates the cable length and stores them in
1049  *  hw->phy.min_length and hw->phy.max_length. This is a function pointer
1050  *  entry point called by drivers.
1051  **/
1052 s32 e1000_get_cable_length(struct e1000_hw *hw)
1053 {
1054         if (hw->phy.ops.get_cable_length)
1055                 return hw->phy.ops.get_cable_length(hw);
1056
1057         return E1000_SUCCESS;
1058 }
1059
1060 /**
1061  *  e1000_get_phy_info - Retrieves PHY information from registers
1062  *  @hw: pointer to the HW structure
1063  *
1064  *  This function gets some information from various PHY registers and
1065  *  populates hw->phy values with it. This is a function pointer entry
1066  *  point called by drivers.
1067  **/
1068 s32 e1000_get_phy_info(struct e1000_hw *hw)
1069 {
1070         if (hw->phy.ops.get_info)
1071                 return hw->phy.ops.get_info(hw);
1072
1073         return E1000_SUCCESS;
1074 }
1075
1076 /**
1077  *  e1000_phy_hw_reset - Hard PHY reset
1078  *  @hw: pointer to the HW structure
1079  *
1080  *  Performs a hard PHY reset. This is a function pointer entry point called
1081  *  by drivers.
1082  **/
1083 s32 e1000_phy_hw_reset(struct e1000_hw *hw)
1084 {
1085         if (hw->phy.ops.reset)
1086                 return hw->phy.ops.reset(hw);
1087
1088         return E1000_SUCCESS;
1089 }
1090
1091 /**
1092  *  e1000_phy_commit - Soft PHY reset
1093  *  @hw: pointer to the HW structure
1094  *
1095  *  Performs a soft PHY reset on those that apply. This is a function pointer
1096  *  entry point called by drivers.
1097  **/
1098 s32 e1000_phy_commit(struct e1000_hw *hw)
1099 {
1100         if (hw->phy.ops.commit)
1101                 return hw->phy.ops.commit(hw);
1102
1103         return E1000_SUCCESS;
1104 }
1105
1106 /**
1107  *  e1000_set_d0_lplu_state - Sets low power link up state for D0
1108  *  @hw: pointer to the HW structure
1109  *  @active: boolean used to enable/disable lplu
1110  *
1111  *  Success returns 0, Failure returns 1
1112  *
1113  *  The low power link up (lplu) state is set to the power management level D0
1114  *  and SmartSpeed is disabled when active is true, else clear lplu for D0
1115  *  and enable Smartspeed.  LPLU and Smartspeed are mutually exclusive.  LPLU
1116  *  is used during Dx states where the power conservation is most important.
1117  *  During driver activity, SmartSpeed should be enabled so performance is
1118  *  maintained.  This is a function pointer entry point called by drivers.
1119  **/
1120 s32 e1000_set_d0_lplu_state(struct e1000_hw *hw, bool active)
1121 {
1122         if (hw->phy.ops.set_d0_lplu_state)
1123                 return hw->phy.ops.set_d0_lplu_state(hw, active);
1124
1125         return E1000_SUCCESS;
1126 }
1127
1128 /**
1129  *  e1000_set_d3_lplu_state - Sets low power link up state for D3
1130  *  @hw: pointer to the HW structure
1131  *  @active: boolean used to enable/disable lplu
1132  *
1133  *  Success returns 0, Failure returns 1
1134  *
1135  *  The low power link up (lplu) state is set to the power management level D3
1136  *  and SmartSpeed is disabled when active is true, else clear lplu for D3
1137  *  and enable Smartspeed.  LPLU and Smartspeed are mutually exclusive.  LPLU
1138  *  is used during Dx states where the power conservation is most important.
1139  *  During driver activity, SmartSpeed should be enabled so performance is
1140  *  maintained.  This is a function pointer entry point called by drivers.
1141  **/
1142 s32 e1000_set_d3_lplu_state(struct e1000_hw *hw, bool active)
1143 {
1144         if (hw->phy.ops.set_d3_lplu_state)
1145                 return hw->phy.ops.set_d3_lplu_state(hw, active);
1146
1147         return E1000_SUCCESS;
1148 }
1149
1150 /**
1151  *  e1000_read_mac_addr - Reads MAC address
1152  *  @hw: pointer to the HW structure
1153  *
1154  *  Reads the MAC address out of the adapter and stores it in the HW structure.
1155  *  Currently no func pointer exists and all implementations are handled in the
1156  *  generic version of this function.
1157  **/
1158 s32 e1000_read_mac_addr(struct e1000_hw *hw)
1159 {
1160         if (hw->mac.ops.read_mac_addr)
1161                 return hw->mac.ops.read_mac_addr(hw);
1162
1163         return e1000_read_mac_addr_generic(hw);
1164 }
1165
1166 /**
1167  *  e1000_read_pba_string - Read device part number string
1168  *  @hw: pointer to the HW structure
1169  *  @pba_num: pointer to device part number
1170  *  @pba_num_size: size of part number buffer
1171  *
1172  *  Reads the product board assembly (PBA) number from the EEPROM and stores
1173  *  the value in pba_num.
1174  *  Currently no func pointer exists and all implementations are handled in the
1175  *  generic version of this function.
1176  **/
1177 s32 e1000_read_pba_string(struct e1000_hw *hw, u8 *pba_num, u32 pba_num_size)
1178 {
1179         return e1000_read_pba_string_generic(hw, pba_num, pba_num_size);
1180 }
1181
1182 /**
1183  *  e1000_read_pba_length - Read device part number string length
1184  *  @hw: pointer to the HW structure
1185  *  @pba_num_size: size of part number buffer
1186  *
1187  *  Reads the product board assembly (PBA) number length from the EEPROM and
1188  *  stores the value in pba_num.
1189  *  Currently no func pointer exists and all implementations are handled in the
1190  *  generic version of this function.
1191  **/
1192 s32 e1000_read_pba_length(struct e1000_hw *hw, u32 *pba_num_size)
1193 {
1194         return e1000_read_pba_length_generic(hw, pba_num_size);
1195 }
1196
1197 /**
1198  *  e1000_read_pba_num - Read device part number
1199  *  @hw: pointer to the HW structure
1200  *  @pba_num: pointer to device part number
1201  *
1202  *  Reads the product board assembly (PBA) number from the EEPROM and stores
1203  *  the value in pba_num.
1204  *  Currently no func pointer exists and all implementations are handled in the
1205  *  generic version of this function.
1206  **/
1207 s32 e1000_read_pba_num(struct e1000_hw *hw, u32 *pba_num)
1208 {
1209         return e1000_read_pba_num_generic(hw, pba_num);
1210 }
1211
1212 /**
1213  *  e1000_validate_nvm_checksum - Verifies NVM (EEPROM) checksum
1214  *  @hw: pointer to the HW structure
1215  *
1216  *  Validates the NVM checksum is correct. This is a function pointer entry
1217  *  point called by drivers.
1218  **/
1219 s32 e1000_validate_nvm_checksum(struct e1000_hw *hw)
1220 {
1221         if (hw->nvm.ops.validate)
1222                 return hw->nvm.ops.validate(hw);
1223
1224         return -E1000_ERR_CONFIG;
1225 }
1226
1227 /**
1228  *  e1000_update_nvm_checksum - Updates NVM (EEPROM) checksum
1229  *  @hw: pointer to the HW structure
1230  *
1231  *  Updates the NVM checksum. Currently no func pointer exists and all
1232  *  implementations are handled in the generic version of this function.
1233  **/
1234 s32 e1000_update_nvm_checksum(struct e1000_hw *hw)
1235 {
1236         if (hw->nvm.ops.update)
1237                 return hw->nvm.ops.update(hw);
1238
1239         return -E1000_ERR_CONFIG;
1240 }
1241
1242 /**
1243  *  e1000_reload_nvm - Reloads EEPROM
1244  *  @hw: pointer to the HW structure
1245  *
1246  *  Reloads the EEPROM by setting the "Reinitialize from EEPROM" bit in the
1247  *  extended control register.
1248  **/
1249 void e1000_reload_nvm(struct e1000_hw *hw)
1250 {
1251         if (hw->nvm.ops.reload)
1252                 hw->nvm.ops.reload(hw);
1253 }
1254
1255 /**
1256  *  e1000_read_nvm - Reads NVM (EEPROM)
1257  *  @hw: pointer to the HW structure
1258  *  @offset: the word offset to read
1259  *  @words: number of 16-bit words to read
1260  *  @data: pointer to the properly sized buffer for the data.
1261  *
1262  *  Reads 16-bit chunks of data from the NVM (EEPROM). This is a function
1263  *  pointer entry point called by drivers.
1264  **/
1265 s32 e1000_read_nvm(struct e1000_hw *hw, u16 offset, u16 words, u16 *data)
1266 {
1267         if (hw->nvm.ops.read)
1268                 return hw->nvm.ops.read(hw, offset, words, data);
1269
1270         return -E1000_ERR_CONFIG;
1271 }
1272
1273 /**
1274  *  e1000_write_nvm - Writes to NVM (EEPROM)
1275  *  @hw: pointer to the HW structure
1276  *  @offset: the word offset to read
1277  *  @words: number of 16-bit words to write
1278  *  @data: pointer to the properly sized buffer for the data.
1279  *
1280  *  Writes 16-bit chunks of data to the NVM (EEPROM). This is a function
1281  *  pointer entry point called by drivers.
1282  **/
1283 s32 e1000_write_nvm(struct e1000_hw *hw, u16 offset, u16 words, u16 *data)
1284 {
1285         if (hw->nvm.ops.write)
1286                 return hw->nvm.ops.write(hw, offset, words, data);
1287
1288         return E1000_SUCCESS;
1289 }
1290
1291 /**
1292  *  e1000_write_8bit_ctrl_reg - Writes 8bit Control register
1293  *  @hw: pointer to the HW structure
1294  *  @reg: 32bit register offset
1295  *  @offset: the register to write
1296  *  @data: the value to write.
1297  *
1298  *  Writes the PHY register at offset with the value in data.
1299  *  This is a function pointer entry point called by drivers.
1300  **/
1301 s32 e1000_write_8bit_ctrl_reg(struct e1000_hw *hw, u32 reg, u32 offset,
1302                               u8 data)
1303 {
1304         return e1000_write_8bit_ctrl_reg_generic(hw, reg, offset, data);
1305 }
1306
1307 /**
1308  * e1000_power_up_phy - Restores link in case of PHY power down
1309  * @hw: pointer to the HW structure
1310  *
1311  * The phy may be powered down to save power, to turn off link when the
1312  * driver is unloaded, or wake on lan is not enabled (among others).
1313  **/
1314 void e1000_power_up_phy(struct e1000_hw *hw)
1315 {
1316         if (hw->phy.ops.power_up)
1317                 hw->phy.ops.power_up(hw);
1318
1319         e1000_setup_link(hw);
1320 }
1321
1322 /**
1323  * e1000_power_down_phy - Power down PHY
1324  * @hw: pointer to the HW structure
1325  *
1326  * The phy may be powered down to save power, to turn off link when the
1327  * driver is unloaded, or wake on lan is not enabled (among others).
1328  **/
1329 void e1000_power_down_phy(struct e1000_hw *hw)
1330 {
1331         if (hw->phy.ops.power_down)
1332                 hw->phy.ops.power_down(hw);
1333 }
1334
1335 /**
1336  *  e1000_power_up_fiber_serdes_link - Power up serdes link
1337  *  @hw: pointer to the HW structure
1338  *
1339  *  Power on the optics and PCS.
1340  **/
1341 void e1000_power_up_fiber_serdes_link(struct e1000_hw *hw)
1342 {
1343         if (hw->mac.ops.power_up_serdes)
1344                 hw->mac.ops.power_up_serdes(hw);
1345 }
1346
1347 /**
1348  *  e1000_shutdown_fiber_serdes_link - Remove link during power down
1349  *  @hw: pointer to the HW structure
1350  *
1351  *  Shutdown the optics and PCS on driver unload.
1352  **/
1353 void e1000_shutdown_fiber_serdes_link(struct e1000_hw *hw)
1354 {
1355         if (hw->mac.ops.shutdown_serdes)
1356                 hw->mac.ops.shutdown_serdes(hw);
1357 }
1358