sys/dev/e1000/e1000_api.c

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