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