sys/dev/e1000/e1000_api.c

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