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_COPPER:
 330         case E1000_DEV_ID_I210_COPPER_OEM1:
 331         case E1000_DEV_ID_I210_COPPER_IT:
 332         case E1000_DEV_ID_I210_FIBER:
 333         case E1000_DEV_ID_I210_SERDES:
 334         case E1000_DEV_ID_I210_SGMII:
 335                 mac->type = e1000_i210;
 336                 break;
 337         case E1000_DEV_ID_I211_COPPER:
 338                 mac->type = e1000_i211;
 339                 break;
 340         case E1000_DEV_ID_82576_VF:
 341         case E1000_DEV_ID_82576_VF_HV:
 342                 mac->type = e1000_vfadapt;
 343                 break;
 344         case E1000_DEV_ID_I350_VF:
 345         case E1000_DEV_ID_I350_VF_HV:
 346                 mac->type = e1000_vfadapt_i350;
 347                 break;
 348
 349         case E1000_DEV_ID_I354_BACKPLANE_1GBPS:
 350         case E1000_DEV_ID_I354_SGMII:
 351         case E1000_DEV_ID_I354_BACKPLANE_2_5GBPS:
 352                 mac->type = e1000_i354;
 353                 break;
 354         default:
 355                 /* Should never have loaded on this device */
 356                 ret_val = -E1000_ERR_MAC_INIT;
 357                 break;
 358         }
 359
 360         return ret_val;
 361 }
 362
 363 /**
 364  *  e1000_setup_init_funcs - Initializes function pointers
 365  *  @hw: pointer to the HW structure
 366  *  @init_device: true will initialize the rest of the function pointers
 367  *                getting the device ready for use.  false will only set
 368  *                MAC type and the function pointers for the other init
 369  *                functions.  Passing false will not generate any hardware
 370  *                reads or writes.
 371  *
 372  *  This function must be called by a driver in order to use the rest
 373  *  of the 'shared' code files. Called by drivers only.
 374  **/
 375 s32 e1000_setup_init_funcs(struct e1000_hw *hw, bool init_device)
 376 {
 377         s32 ret_val;
 378
 379         /* Can't do much good without knowing the MAC type. */
 380         ret_val = e1000_set_mac_type(hw);
 381         if (ret_val) {
 382                 DEBUGOUT("ERROR: MAC type could not be set properly.\n");
 383                 goto out;
 384         }
 385
 386         if (!hw->hw_addr) {
 387                 DEBUGOUT("ERROR: Registers not mapped\n");
 388                 ret_val = -E1000_ERR_CONFIG;
 389                 goto out;
 390         }
 391
 392         /*
 393          * Init function pointers to generic implementations. We do this first
 394          * allowing a driver module to override it afterward.
 395          */
 396         e1000_init_mac_ops_generic(hw);
 397         e1000_init_phy_ops_generic(hw);
 398         e1000_init_nvm_ops_generic(hw);
 399         e1000_init_mbx_ops_generic(hw);
 400
 401         /*
 402          * Set up the init function pointers. These are functions within the
 403          * adapter family file that sets up function pointers for the rest of
 404          * the functions in that family.
 405          */
 406         switch (hw->mac.type) {
 407         case e1000_82542:
 408                 e1000_init_function_pointers_82542(hw);
 409                 break;
 410         case e1000_82543:
 411         case e1000_82544:
 412                 e1000_init_function_pointers_82543(hw);
 413                 break;
 414         case e1000_82540:
 415         case e1000_82545:
 416         case e1000_82545_rev_3:
 417         case e1000_82546:
 418         case e1000_82546_rev_3:
 419                 e1000_init_function_pointers_82540(hw);
 420                 break;
 421         case e1000_82541:
 422         case e1000_82541_rev_2:
 423         case e1000_82547:
 424         case e1000_82547_rev_2:
 425                 e1000_init_function_pointers_82541(hw);
 426                 break;
 427         case e1000_82571:
 428         case e1000_82572:
 429         case e1000_82573:
 430         case e1000_82574:
 431         case e1000_82583:
 432                 e1000_init_function_pointers_82571(hw);
 433                 break;
 434         case e1000_80003es2lan:
 435                 e1000_init_function_pointers_80003es2lan(hw);
 436                 break;
 437         case e1000_ich8lan:
 438         case e1000_ich9lan:
 439         case e1000_ich10lan:
 440         case e1000_pchlan:
 441         case e1000_pch2lan:
 442         case e1000_pch_lpt:
 443         case e1000_pch_spt:
 444         case e1000_pch_cnp:
 445                 e1000_init_function_pointers_ich8lan(hw);
 446                 break;
 447         case e1000_82575:
 448         case e1000_82576:
 449         case e1000_82580:
 450         case e1000_i350:
 451         case e1000_i354:
 452                 e1000_init_function_pointers_82575(hw);
 453                 break;
 454         case e1000_i210:
 455         case e1000_i211:
 456                 e1000_init_function_pointers_i210(hw);
 457                 break;
 458         case e1000_vfadapt:
 459                 e1000_init_function_pointers_vf(hw);
 460                 break;
 461         case e1000_vfadapt_i350:
 462                 e1000_init_function_pointers_vf(hw);
 463                 break;
 464         default:
 465                 DEBUGOUT("Hardware not supported\n");
 466                 ret_val = -E1000_ERR_CONFIG;
 467                 break;
 468         }
 469
 470         /*
 471          * Initialize the rest of the function pointers. These require some
 472          * register reads/writes in some cases.
 473          */
 474         if (!(ret_val) && init_device) {
 475                 ret_val = e1000_init_mac_params(hw);
 476                 if (ret_val)
 477                         goto out;
 478
 479                 ret_val = e1000_init_nvm_params(hw);
 480                 if (ret_val)
 481                         goto out;
 482
 483                 ret_val = e1000_init_phy_params(hw);
 484                 if (ret_val)
 485                         goto out;
 486
 487                 ret_val = e1000_init_mbx_params(hw);
 488                 if (ret_val)
 489                         goto out;
 490         }
 491
 492 out:
 493         return ret_val;
 494 }
 495
 496 /**
 497  *  e1000_get_bus_info - Obtain bus information for adapter
 498  *  @hw: pointer to the HW structure
 499  *
 500  *  This will obtain information about the HW bus for which the
 501  *  adapter is attached and stores it in the hw structure. This is a
 502  *  function pointer entry point called by drivers.
 503  **/
 504 s32 e1000_get_bus_info(struct e1000_hw *hw)
 505 {
 506         if (hw->mac.ops.get_bus_info)
 507                 return hw->mac.ops.get_bus_info(hw);
 508
 509         return E1000_SUCCESS;
 510 }
 511
 512 /**
 513  *  e1000_clear_vfta - Clear VLAN filter table
 514  *  @hw: pointer to the HW structure
 515  *
 516  *  This clears the VLAN filter table on the adapter. This is a function
 517  *  pointer entry point called by drivers.
 518  **/
 519 void e1000_clear_vfta(struct e1000_hw *hw)
 520 {
 521         if (hw->mac.ops.clear_vfta)
 522                 hw->mac.ops.clear_vfta(hw);
 523 }
 524
 525 /**
 526  *  e1000_write_vfta - Write value to VLAN filter table
 527  *  @hw: pointer to the HW structure
 528  *  @offset: the 32-bit offset in which to write the value to.
 529  *  @value: the 32-bit value to write at location offset.
 530  *
 531  *  This writes a 32-bit value to a 32-bit offset in the VLAN filter
 532  *  table. This is a function pointer entry point called by drivers.
 533  **/
 534 void e1000_write_vfta(struct e1000_hw *hw, u32 offset, u32 value)
 535 {
 536         if (hw->mac.ops.write_vfta)
 537                 hw->mac.ops.write_vfta(hw, offset, value);
 538 }
 539
 540 /**
 541  *  e1000_update_mc_addr_list - Update Multicast addresses
 542  *  @hw: pointer to the HW structure
 543  *  @mc_addr_list: array of multicast addresses to program
 544  *  @mc_addr_count: number of multicast addresses to program
 545  *
 546  *  Updates the Multicast Table Array.
 547  *  The caller must have a packed mc_addr_list of multicast addresses.
 548  **/
 549 void e1000_update_mc_addr_list(struct e1000_hw *hw, u8 *mc_addr_list,
 550                                u32 mc_addr_count)
 551 {
 552         if (hw->mac.ops.update_mc_addr_list)
 553                 hw->mac.ops.update_mc_addr_list(hw, mc_addr_list,
 554                                                 mc_addr_count);
 555 }
 556
 557 /**
 558  *  e1000_force_mac_fc - Force MAC flow control
 559  *  @hw: pointer to the HW structure
 560  *
 561  *  Force the MAC's flow control settings. Currently no func pointer exists
 562  *  and all implementations are handled in the generic version of this
 563  *  function.
 564  **/
 565 s32 e1000_force_mac_fc(struct e1000_hw *hw)
 566 {
 567         return e1000_force_mac_fc_generic(hw);
 568 }
 569
 570 /**
 571  *  e1000_check_for_link - Check/Store link connection
 572  *  @hw: pointer to the HW structure
 573  *
 574  *  This checks the link condition of the adapter and stores the
 575  *  results in the hw->mac structure. This is a function pointer entry
 576  *  point called by drivers.
 577  **/
 578 s32 e1000_check_for_link(struct e1000_hw *hw)
 579 {
 580         if (hw->mac.ops.check_for_link)
 581                 return hw->mac.ops.check_for_link(hw);
 582
 583         return -E1000_ERR_CONFIG;
 584 }
 585
 586 /**
 587  *  e1000_check_mng_mode - Check management mode
 588  *  @hw: pointer to the HW structure
 589  *
 590  *  This checks if the adapter has manageability enabled.
 591  *  This is a function pointer entry point called by drivers.
 592  **/
 593 bool e1000_check_mng_mode(struct e1000_hw *hw)
 594 {
 595         if (hw->mac.ops.check_mng_mode)
 596                 return hw->mac.ops.check_mng_mode(hw);
 597
 598         return false;
 599 }
 600
 601 /**
 602  *  e1000_mng_write_dhcp_info - Writes DHCP info to host interface
 603  *  @hw: pointer to the HW structure
 604  *  @buffer: pointer to the host interface
 605  *  @length: size of the buffer
 606  *
 607  *  Writes the DHCP information to the host interface.
 608  **/
 609 s32 e1000_mng_write_dhcp_info(struct e1000_hw *hw, u8 *buffer, u16 length)
 610 {
 611         return e1000_mng_write_dhcp_info_generic(hw, buffer, length);
 612 }
 613
 614 /**
 615  *  e1000_reset_hw - Reset hardware
 616  *  @hw: pointer to the HW structure
 617  *
 618  *  This resets the hardware into a known state. This is a function pointer
 619  *  entry point called by drivers.
 620  **/
 621 s32 e1000_reset_hw(struct e1000_hw *hw)
 622 {
 623         if (hw->mac.ops.reset_hw)
 624                 return hw->mac.ops.reset_hw(hw);
 625
 626         return -E1000_ERR_CONFIG;
 627 }
 628
 629 /**
 630  *  e1000_init_hw - Initialize hardware
 631  *  @hw: pointer to the HW structure
 632  *
 633  *  This inits the hardware readying it for operation. This is a function
 634  *  pointer entry point called by drivers.
 635  **/
 636 s32 e1000_init_hw(struct e1000_hw *hw)
 637 {
 638         if (hw->mac.ops.init_hw)
 639                 return hw->mac.ops.init_hw(hw);
 640
 641         return -E1000_ERR_CONFIG;
 642 }
 643
 644 /**
 645  *  e1000_setup_link - Configures link and flow control
 646  *  @hw: pointer to the HW structure
 647  *
 648  *  This configures link and flow control settings for the adapter. This
 649  *  is a function pointer entry point called by drivers. While modules can
 650  *  also call this, they probably call their own version of this function.
 651  **/
 652 s32 e1000_setup_link(struct e1000_hw *hw)
 653 {
 654         if (hw->mac.ops.setup_link)
 655                 return hw->mac.ops.setup_link(hw);
 656
 657         return -E1000_ERR_CONFIG;
 658 }
 659
 660 /**
 661  *  e1000_get_speed_and_duplex - Returns current speed and duplex
 662  *  @hw: pointer to the HW structure
 663  *  @speed: pointer to a 16-bit value to store the speed
 664  *  @duplex: pointer to a 16-bit value to store the duplex.
 665  *
 666  *  This returns the speed and duplex of the adapter in the two 'out'
 667  *  variables passed in. This is a function pointer entry point called
 668  *  by drivers.
 669  **/
 670 s32 e1000_get_speed_and_duplex(struct e1000_hw *hw, u16 *speed, u16 *duplex)
 671 {
 672         if (hw->mac.ops.get_link_up_info)
 673                 return hw->mac.ops.get_link_up_info(hw, speed, duplex);
 674
 675         return -E1000_ERR_CONFIG;
 676 }
 677
 678 /**
 679  *  e1000_setup_led - Configures SW controllable LED
 680  *  @hw: pointer to the HW structure
 681  *
 682  *  This prepares the SW controllable LED for use and saves the current state
 683  *  of the LED so it can be later restored. This is a function pointer entry
 684  *  point called by drivers.
 685  **/
 686 s32 e1000_setup_led(struct e1000_hw *hw)
 687 {
 688         if (hw->mac.ops.setup_led)
 689                 return hw->mac.ops.setup_led(hw);
 690
 691         return E1000_SUCCESS;
 692 }
 693
 694 /**
 695  *  e1000_cleanup_led - Restores SW controllable LED
 696  *  @hw: pointer to the HW structure
 697  *
 698  *  This restores the SW controllable LED to the value saved off by
 699  *  e1000_setup_led. This is a function pointer entry point called by drivers.
 700  **/
 701 s32 e1000_cleanup_led(struct e1000_hw *hw)
 702 {
 703         if (hw->mac.ops.cleanup_led)
 704                 return hw->mac.ops.cleanup_led(hw);
 705
 706         return E1000_SUCCESS;
 707 }
 708
 709 /**
 710  *  e1000_blink_led - Blink SW controllable LED
 711  *  @hw: pointer to the HW structure
 712  *
 713  *  This starts the adapter LED blinking. Request the LED to be setup first
 714  *  and cleaned up after. This is a function pointer entry point called by
 715  *  drivers.
 716  **/
 717 s32 e1000_blink_led(struct e1000_hw *hw)
 718 {
 719         if (hw->mac.ops.blink_led)
 720                 return hw->mac.ops.blink_led(hw);
 721
 722         return E1000_SUCCESS;
 723 }
 724
 725 /**
 726  *  e1000_id_led_init - store LED configurations in SW
 727  *  @hw: pointer to the HW structure
 728  *
 729  *  Initializes the LED config in SW. This is a function pointer entry point
 730  *  called by drivers.
 731  **/
 732 s32 e1000_id_led_init(struct e1000_hw *hw)
 733 {
 734         if (hw->mac.ops.id_led_init)
 735                 return hw->mac.ops.id_led_init(hw);
 736
 737         return E1000_SUCCESS;
 738 }
 739
 740 /**
 741  *  e1000_led_on - Turn on SW controllable LED
 742  *  @hw: pointer to the HW structure
 743  *
 744  *  Turns the SW defined LED on. This is a function pointer entry point
 745  *  called by drivers.
 746  **/
 747 s32 e1000_led_on(struct e1000_hw *hw)
 748 {
 749         if (hw->mac.ops.led_on)
 750                 return hw->mac.ops.led_on(hw);
 751
 752         return E1000_SUCCESS;
 753 }
 754
 755 /**
 756  *  e1000_led_off - Turn off SW controllable LED
 757  *  @hw: pointer to the HW structure
 758  *
 759  *  Turns the SW defined LED off. This is a function pointer entry point
 760  *  called by drivers.
 761  **/
 762 s32 e1000_led_off(struct e1000_hw *hw)
 763 {
 764         if (hw->mac.ops.led_off)
 765                 return hw->mac.ops.led_off(hw);
 766
 767         return E1000_SUCCESS;
 768 }
 769
 770 /**
 771  *  e1000_reset_adaptive - Reset adaptive IFS
 772  *  @hw: pointer to the HW structure
 773  *
 774  *  Resets the adaptive IFS. Currently no func pointer exists and all
 775  *  implementations are handled in the generic version of this function.
 776  **/
 777 void e1000_reset_adaptive(struct e1000_hw *hw)
 778 {
 779         e1000_reset_adaptive_generic(hw);
 780 }
 781
 782 /**
 783  *  e1000_update_adaptive - Update adaptive IFS
 784  *  @hw: pointer to the HW structure
 785  *
 786  *  Updates adapter IFS. Currently no func pointer exists and all
 787  *  implementations are handled in the generic version of this function.
 788  **/
 789 void e1000_update_adaptive(struct e1000_hw *hw)
 790 {
 791         e1000_update_adaptive_generic(hw);
 792 }
 793
 794 /**
 795  *  e1000_disable_pcie_master - Disable PCI-Express master access
 796  *  @hw: pointer to the HW structure
 797  *
 798  *  Disables PCI-Express master access and verifies there are no pending
 799  *  requests. Currently no func pointer exists and all implementations are
 800  *  handled in the generic version of this function.
 801  **/
 802 s32 e1000_disable_pcie_master(struct e1000_hw *hw)
 803 {
 804         return e1000_disable_pcie_master_generic(hw);
 805 }
 806
 807 /**
 808  *  e1000_config_collision_dist - Configure collision distance
 809  *  @hw: pointer to the HW structure
 810  *
 811  *  Configures the collision distance to the default value and is used
 812  *  during link setup.
 813  **/
 814 void e1000_config_collision_dist(struct e1000_hw *hw)
 815 {
 816         if (hw->mac.ops.config_collision_dist)
 817                 hw->mac.ops.config_collision_dist(hw);
 818 }
 819
 820 /**
 821  *  e1000_rar_set - Sets a receive address register
 822  *  @hw: pointer to the HW structure
 823  *  @addr: address to set the RAR to
 824  *  @index: the RAR to set
 825  *
 826  *  Sets a Receive Address Register (RAR) to the specified address.
 827  **/
 828 int e1000_rar_set(struct e1000_hw *hw, u8 *addr, u32 index)
 829 {
 830         if (hw->mac.ops.rar_set)
 831                 return hw->mac.ops.rar_set(hw, addr, index);
 832
 833         return E1000_SUCCESS;
 834 }
 835
 836 /**
 837  *  e1000_validate_mdi_setting - Ensures valid MDI/MDIX SW state
 838  *  @hw: pointer to the HW structure
 839  *
 840  *  Ensures that the MDI/MDIX SW state is valid.
 841  **/
 842 s32 e1000_validate_mdi_setting(struct e1000_hw *hw)
 843 {
 844         if (hw->mac.ops.validate_mdi_setting)
 845                 return hw->mac.ops.validate_mdi_setting(hw);
 846
 847         return E1000_SUCCESS;
 848 }
 849
 850 /**
 851  *  e1000_hash_mc_addr - Determines address location in multicast table
 852  *  @hw: pointer to the HW structure
 853  *  @mc_addr: Multicast address to hash.
 854  *
 855  *  This hashes an address to determine its location in the multicast
 856  *  table. Currently no func pointer exists and all implementations
 857  *  are handled in the generic version of this function.
 858  **/
 859 u32 e1000_hash_mc_addr(struct e1000_hw *hw, u8 *mc_addr)
 860 {
 861         return e1000_hash_mc_addr_generic(hw, mc_addr);
 862 }
 863
 864 /**
 865  *  e1000_enable_tx_pkt_filtering - Enable packet filtering on TX
 866  *  @hw: pointer to the HW structure
 867  *
 868  *  Enables packet filtering on transmit packets if manageability is enabled
 869  *  and host interface is enabled.
 870  *  Currently no func pointer exists and all implementations are handled in the
 871  *  generic version of this function.
 872  **/
 873 bool e1000_enable_tx_pkt_filtering(struct e1000_hw *hw)
 874 {
 875         return e1000_enable_tx_pkt_filtering_generic(hw);
 876 }
 877
 878 /**
 879  *  e1000_mng_host_if_write - Writes to the manageability host interface
 880  *  @hw: pointer to the HW structure
 881  *  @buffer: pointer to the host interface buffer
 882  *  @length: size of the buffer
 883  *  @offset: location in the buffer to write to
 884  *  @sum: sum of the data (not checksum)
 885  *
 886  *  This function writes the buffer content at the offset given on the host if.
 887  *  It also does alignment considerations to do the writes in most efficient
 888  *  way.  Also fills up the sum of the buffer in *buffer parameter.
 889  **/
 890 s32 e1000_mng_host_if_write(struct e1000_hw *hw, u8 *buffer, u16 length,
 891                             u16 offset, u8 *sum)
 892 {
 893         return e1000_mng_host_if_write_generic(hw, buffer, length, offset, sum);
 894 }
 895
 896 /**
 897  *  e1000_mng_write_cmd_header - Writes manageability command header
 898  *  @hw: pointer to the HW structure
 899  *  @hdr: pointer to the host interface command header
 900  *
 901  *  Writes the command header after does the checksum calculation.
 902  **/
 903 s32 e1000_mng_write_cmd_header(struct e1000_hw *hw,
 904                                struct e1000_host_mng_command_header *hdr)
 905 {
 906         return e1000_mng_write_cmd_header_generic(hw, hdr);
 907 }
 908
 909 /**
 910  *  e1000_mng_enable_host_if - Checks host interface is enabled
 911  *  @hw: pointer to the HW structure
 912  *
 913  *  Returns E1000_success upon success, else E1000_ERR_HOST_INTERFACE_COMMAND
 914  *
 915  *  This function checks whether the HOST IF is enabled for command operation
 916  *  and also checks whether the previous command is completed.  It busy waits
 917  *  in case of previous command is not completed.
 918  **/
 919 s32 e1000_mng_enable_host_if(struct e1000_hw *hw)
 920 {
 921         return e1000_mng_enable_host_if_generic(hw);
 922 }
 923
 924 /**
 925  *  e1000_check_reset_block - Verifies PHY can be reset
 926  *  @hw: pointer to the HW structure
 927  *
 928  *  Checks if the PHY is in a state that can be reset or if manageability
 929  *  has it tied up. This is a function pointer entry point called by drivers.
 930  **/
 931 s32 e1000_check_reset_block(struct e1000_hw *hw)
 932 {
 933         if (hw->phy.ops.check_reset_block)
 934                 return hw->phy.ops.check_reset_block(hw);
 935
 936         return E1000_SUCCESS;
 937 }
 938
 939 /**
 940  *  e1000_read_phy_reg - Reads PHY register
 941  *  @hw: pointer to the HW structure
 942  *  @offset: the register to read
 943  *  @data: the buffer to store the 16-bit read.
 944  *
 945  *  Reads the PHY register and returns the value in data.
 946  *  This is a function pointer entry point called by drivers.
 947  **/
 948 s32 e1000_read_phy_reg(struct e1000_hw *hw, u32 offset, u16 *data)
 949 {
 950         if (hw->phy.ops.read_reg)
 951                 return hw->phy.ops.read_reg(hw, offset, data);
 952
 953         return E1000_SUCCESS;
 954 }
 955
 956 /**
 957  *  e1000_write_phy_reg - Writes PHY register
 958  *  @hw: pointer to the HW structure
 959  *  @offset: the register to write
 960  *  @data: the value to write.
 961  *
 962  *  Writes the PHY register at offset with the value in data.
 963  *  This is a function pointer entry point called by drivers.
 964  **/
 965 s32 e1000_write_phy_reg(struct e1000_hw *hw, u32 offset, u16 data)
 966 {
 967         if (hw->phy.ops.write_reg)
 968                 return hw->phy.ops.write_reg(hw, offset, data);
 969
 970         return E1000_SUCCESS;
 971 }
 972
 973 /**
 974  *  e1000_release_phy - Generic release PHY
 975  *  @hw: pointer to the HW structure
 976  *
 977  *  Return if silicon family does not require a semaphore when accessing the
 978  *  PHY.
 979  **/
 980 void e1000_release_phy(struct e1000_hw *hw)
 981 {
 982         if (hw->phy.ops.release)
 983                 hw->phy.ops.release(hw);
 984 }
 985
 986 /**
 987  *  e1000_acquire_phy - Generic acquire PHY
 988  *  @hw: pointer to the HW structure
 989  *
 990  *  Return success if silicon family does not require a semaphore when
 991  *  accessing the PHY.
 992  **/
 993 s32 e1000_acquire_phy(struct e1000_hw *hw)
 994 {
 995         if (hw->phy.ops.acquire)
 996                 return hw->phy.ops.acquire(hw);
 997
 998         return E1000_SUCCESS;
 999 }
1000
1001 /**
1002  *  e1000_cfg_on_link_up - Configure PHY upon link up
1003  *  @hw: pointer to the HW structure
1004  **/
1005 s32 e1000_cfg_on_link_up(struct e1000_hw *hw)
1006 {
1007         if (hw->phy.ops.cfg_on_link_up)
1008                 return hw->phy.ops.cfg_on_link_up(hw);
1009
1010         return E1000_SUCCESS;
1011 }
1012
1013 /**
1014  *  e1000_read_kmrn_reg - Reads register using Kumeran interface
1015  *  @hw: pointer to the HW structure
1016  *  @offset: the register to read
1017  *  @data: the location to store the 16-bit value read.
1018  *
1019  *  Reads a register out of the Kumeran interface. Currently no func pointer
1020  *  exists and all implementations are handled in the generic version of
1021  *  this function.
1022  **/
1023 s32 e1000_read_kmrn_reg(struct e1000_hw *hw, u32 offset, u16 *data)
1024 {
1025         return e1000_read_kmrn_reg_generic(hw, offset, data);
1026 }
1027
1028 /**
1029  *  e1000_write_kmrn_reg - Writes register using Kumeran interface
1030  *  @hw: pointer to the HW structure
1031  *  @offset: the register to write
1032  *  @data: the value to write.
1033  *
1034  *  Writes a register to the Kumeran interface. Currently no func pointer
1035  *  exists and all implementations are handled in the generic version of
1036  *  this function.
1037  **/
1038 s32 e1000_write_kmrn_reg(struct e1000_hw *hw, u32 offset, u16 data)
1039 {
1040         return e1000_write_kmrn_reg_generic(hw, offset, data);
1041 }
1042
1043 /**
1044  *  e1000_get_cable_length - Retrieves cable length estimation
1045  *  @hw: pointer to the HW structure
1046  *
1047  *  This function estimates the cable length and stores them in
1048  *  hw->phy.min_length and hw->phy.max_length. This is a function pointer
1049  *  entry point called by drivers.
1050  **/
1051 s32 e1000_get_cable_length(struct e1000_hw *hw)
1052 {
1053         if (hw->phy.ops.get_cable_length)
1054                 return hw->phy.ops.get_cable_length(hw);
1055
1056         return E1000_SUCCESS;
1057 }
1058
1059 /**
1060  *  e1000_get_phy_info - Retrieves PHY information from registers
1061  *  @hw: pointer to the HW structure
1062  *
1063  *  This function gets some information from various PHY registers and
1064  *  populates hw->phy values with it. This is a function pointer entry
1065  *  point called by drivers.
1066  **/
1067 s32 e1000_get_phy_info(struct e1000_hw *hw)
1068 {
1069         if (hw->phy.ops.get_info)
1070                 return hw->phy.ops.get_info(hw);
1071
1072         return E1000_SUCCESS;
1073 }
1074
1075 /**
1076  *  e1000_phy_hw_reset - Hard PHY reset
1077  *  @hw: pointer to the HW structure
1078  *
1079  *  Performs a hard PHY reset. This is a function pointer entry point called
1080  *  by drivers.
1081  **/
1082 s32 e1000_phy_hw_reset(struct e1000_hw *hw)
1083 {
1084         if (hw->phy.ops.reset)
1085                 return hw->phy.ops.reset(hw);
1086
1087         return E1000_SUCCESS;
1088 }
1089
1090 /**
1091  *  e1000_phy_commit - Soft PHY reset
1092  *  @hw: pointer to the HW structure
1093  *
1094  *  Performs a soft PHY reset on those that apply. This is a function pointer
1095  *  entry point called by drivers.
1096  **/
1097 s32 e1000_phy_commit(struct e1000_hw *hw)
1098 {
1099         if (hw->phy.ops.commit)
1100                 return hw->phy.ops.commit(hw);
1101
1102         return E1000_SUCCESS;
1103 }
1104
1105 /**
1106  *  e1000_set_d0_lplu_state - Sets low power link up state for D0
1107  *  @hw: pointer to the HW structure
1108  *  @active: boolean used to enable/disable lplu
1109  *
1110  *  Success returns 0, Failure returns 1
1111  *
1112  *  The low power link up (lplu) state is set to the power management level D0
1113  *  and SmartSpeed is disabled when active is true, else clear lplu for D0
1114  *  and enable Smartspeed.  LPLU and Smartspeed are mutually exclusive.  LPLU
1115  *  is used during Dx states where the power conservation is most important.
1116  *  During driver activity, SmartSpeed should be enabled so performance is
1117  *  maintained.  This is a function pointer entry point called by drivers.
1118  **/
1119 s32 e1000_set_d0_lplu_state(struct e1000_hw *hw, bool active)
1120 {
1121         if (hw->phy.ops.set_d0_lplu_state)
1122                 return hw->phy.ops.set_d0_lplu_state(hw, active);
1123
1124         return E1000_SUCCESS;
1125 }
1126
1127 /**
1128  *  e1000_set_d3_lplu_state - Sets low power link up state for D3
1129  *  @hw: pointer to the HW structure
1130  *  @active: boolean used to enable/disable lplu
1131  *
1132  *  Success returns 0, Failure returns 1
1133  *
1134  *  The low power link up (lplu) state is set to the power management level D3
1135  *  and SmartSpeed is disabled when active is true, else clear lplu for D3
1136  *  and enable Smartspeed.  LPLU and Smartspeed are mutually exclusive.  LPLU
1137  *  is used during Dx states where the power conservation is most important.
1138  *  During driver activity, SmartSpeed should be enabled so performance is
1139  *  maintained.  This is a function pointer entry point called by drivers.
1140  **/
1141 s32 e1000_set_d3_lplu_state(struct e1000_hw *hw, bool active)
1142 {
1143         if (hw->phy.ops.set_d3_lplu_state)
1144                 return hw->phy.ops.set_d3_lplu_state(hw, active);
1145
1146         return E1000_SUCCESS;
1147 }
1148
1149 /**
1150  *  e1000_read_mac_addr - Reads MAC address
1151  *  @hw: pointer to the HW structure
1152  *
1153  *  Reads the MAC address out of the adapter and stores it in the HW structure.
1154  *  Currently no func pointer exists and all implementations are handled in the
1155  *  generic version of this function.
1156  **/
1157 s32 e1000_read_mac_addr(struct e1000_hw *hw)
1158 {
1159         if (hw->mac.ops.read_mac_addr)
1160                 return hw->mac.ops.read_mac_addr(hw);
1161
1162         return e1000_read_mac_addr_generic(hw);
1163 }
1164
1165 /**
1166  *  e1000_read_pba_string - Read device part number string
1167  *  @hw: pointer to the HW structure
1168  *  @pba_num: pointer to device part number
1169  *  @pba_num_size: size of part number buffer
1170  *
1171  *  Reads the product board assembly (PBA) number from the EEPROM and stores
1172  *  the value in pba_num.
1173  *  Currently no func pointer exists and all implementations are handled in the
1174  *  generic version of this function.
1175  **/
1176 s32 e1000_read_pba_string(struct e1000_hw *hw, u8 *pba_num, u32 pba_num_size)
1177 {
1178         return e1000_read_pba_string_generic(hw, pba_num, pba_num_size);
1179 }
1180
1181 /**
1182  *  e1000_read_pba_length - Read device part number string length
1183  *  @hw: pointer to the HW structure
1184  *  @pba_num_size: size of part number buffer
1185  *
1186  *  Reads the product board assembly (PBA) number length from the EEPROM and
1187  *  stores the value in pba_num.
1188  *  Currently no func pointer exists and all implementations are handled in the
1189  *  generic version of this function.
1190  **/
1191 s32 e1000_read_pba_length(struct e1000_hw *hw, u32 *pba_num_size)
1192 {
1193         return e1000_read_pba_length_generic(hw, pba_num_size);
1194 }
1195
1196 /**
1197  *  e1000_read_pba_num - Read device part number
1198  *  @hw: pointer to the HW structure
1199  *  @pba_num: pointer to device part number
1200  *
1201  *  Reads the product board assembly (PBA) number from the EEPROM and stores
1202  *  the value in pba_num.
1203  *  Currently no func pointer exists and all implementations are handled in the
1204  *  generic version of this function.
1205  **/
1206 s32 e1000_read_pba_num(struct e1000_hw *hw, u32 *pba_num)
1207 {
1208         return e1000_read_pba_num_generic(hw, pba_num);
1209 }
1210
1211 /**
1212  *  e1000_validate_nvm_checksum - Verifies NVM (EEPROM) checksum
1213  *  @hw: pointer to the HW structure
1214  *
1215  *  Validates the NVM checksum is correct. This is a function pointer entry
1216  *  point called by drivers.
1217  **/
1218 s32 e1000_validate_nvm_checksum(struct e1000_hw *hw)
1219 {
1220         if (hw->nvm.ops.validate)
1221                 return hw->nvm.ops.validate(hw);
1222
1223         return -E1000_ERR_CONFIG;
1224 }
1225
1226 /**
1227  *  e1000_update_nvm_checksum - Updates NVM (EEPROM) checksum
1228  *  @hw: pointer to the HW structure
1229  *
1230  *  Updates the NVM checksum. Currently no func pointer exists and all
1231  *  implementations are handled in the generic version of this function.
1232  **/
1233 s32 e1000_update_nvm_checksum(struct e1000_hw *hw)
1234 {
1235         if (hw->nvm.ops.update)
1236                 return hw->nvm.ops.update(hw);
1237
1238         return -E1000_ERR_CONFIG;
1239 }
1240
1241 /**
1242  *  e1000_reload_nvm - Reloads EEPROM
1243  *  @hw: pointer to the HW structure
1244  *
1245  *  Reloads the EEPROM by setting the "Reinitialize from EEPROM" bit in the
1246  *  extended control register.
1247  **/
1248 void e1000_reload_nvm(struct e1000_hw *hw)
1249 {
1250         if (hw->nvm.ops.reload)
1251                 hw->nvm.ops.reload(hw);
1252 }
1253
1254 /**
1255  *  e1000_read_nvm - Reads NVM (EEPROM)
1256  *  @hw: pointer to the HW structure
1257  *  @offset: the word offset to read
1258  *  @words: number of 16-bit words to read
1259  *  @data: pointer to the properly sized buffer for the data.
1260  *
1261  *  Reads 16-bit chunks of data from the NVM (EEPROM). This is a function
1262  *  pointer entry point called by drivers.
1263  **/
1264 s32 e1000_read_nvm(struct e1000_hw *hw, u16 offset, u16 words, u16 *data)
1265 {
1266         if (hw->nvm.ops.read)
1267                 return hw->nvm.ops.read(hw, offset, words, data);
1268
1269         return -E1000_ERR_CONFIG;
1270 }
1271
1272 /**
1273  *  e1000_write_nvm - Writes to NVM (EEPROM)
1274  *  @hw: pointer to the HW structure
1275  *  @offset: the word offset to read
1276  *  @words: number of 16-bit words to write
1277  *  @data: pointer to the properly sized buffer for the data.
1278  *
1279  *  Writes 16-bit chunks of data to the NVM (EEPROM). This is a function
1280  *  pointer entry point called by drivers.
1281  **/
1282 s32 e1000_write_nvm(struct e1000_hw *hw, u16 offset, u16 words, u16 *data)
1283 {
1284         if (hw->nvm.ops.write)
1285                 return hw->nvm.ops.write(hw, offset, words, data);
1286
1287         return E1000_SUCCESS;
1288 }
1289
1290 /**
1291  *  e1000_write_8bit_ctrl_reg - Writes 8bit Control register
1292  *  @hw: pointer to the HW structure
1293  *  @reg: 32bit register offset
1294  *  @offset: the register to write
1295  *  @data: the value to write.
1296  *
1297  *  Writes the PHY register at offset with the value in data.
1298  *  This is a function pointer entry point called by drivers.
1299  **/
1300 s32 e1000_write_8bit_ctrl_reg(struct e1000_hw *hw, u32 reg, u32 offset,
1301                               u8 data)
1302 {
1303         return e1000_write_8bit_ctrl_reg_generic(hw, reg, offset, data);
1304 }
1305
1306 /**
1307  * e1000_power_up_phy - Restores link in case of PHY power down
1308  * @hw: pointer to the HW structure
1309  *
1310  * The phy may be powered down to save power, to turn off link when the
1311  * driver is unloaded, or wake on lan is not enabled (among others).
1312  **/
1313 void e1000_power_up_phy(struct e1000_hw *hw)
1314 {
1315         if (hw->phy.ops.power_up)
1316                 hw->phy.ops.power_up(hw);
1317
1318         e1000_setup_link(hw);
1319 }
1320
1321 /**
1322  * e1000_power_down_phy - Power down PHY
1323  * @hw: pointer to the HW structure
1324  *
1325  * The phy may be powered down to save power, to turn off link when the
1326  * driver is unloaded, or wake on lan is not enabled (among others).
1327  **/
1328 void e1000_power_down_phy(struct e1000_hw *hw)
1329 {
1330         if (hw->phy.ops.power_down)
1331                 hw->phy.ops.power_down(hw);
1332 }
1333
1334 /**
1335  *  e1000_power_up_fiber_serdes_link - Power up serdes link
1336  *  @hw: pointer to the HW structure
1337  *
1338  *  Power on the optics and PCS.
1339  **/
1340 void e1000_power_up_fiber_serdes_link(struct e1000_hw *hw)
1341 {
1342         if (hw->mac.ops.power_up_serdes)
1343                 hw->mac.ops.power_up_serdes(hw);
1344 }
1345
1346 /**
1347  *  e1000_shutdown_fiber_serdes_link - Remove link during power down
1348  *  @hw: pointer to the HW structure
1349  *
1350  *  Shutdown the optics and PCS on driver unload.
1351  **/
1352 void e1000_shutdown_fiber_serdes_link(struct e1000_hw *hw)
1353 {
1354         if (hw->mac.ops.shutdown_serdes)
1355                 hw->mac.ops.shutdown_serdes(hw);
1356 }
1357