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