sys/dev/netif/ig_hal/e1000_api.c

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