sys/dev/e1000/e1000_api.c

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