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