drivers/net/e1000/base/e1000_api.c

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