sys/dev/netif/ig_hal/e1000_api.c

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