1 /******************************************************************************
3 Copyright (c) 2001-2011, Intel Corporation
6 Redistribution and use in source and binary forms, with or without
7 modification, are permitted provided that the following conditions are met:
9 1. Redistributions of source code must retain the above copyright notice,
10 this list of conditions and the following disclaimer.
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.
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.
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.
32 ******************************************************************************/
35 #include "e1000_api.h"
38 * e1000_init_mac_params - Initialize MAC function pointers
39 * @hw: pointer to the HW structure
41 * This function initializes the function pointers for the MAC
42 * set of functions. Called by drivers or by e1000_setup_init_funcs.
44 s32 e1000_init_mac_params(struct e1000_hw *hw)
46 s32 ret_val = E1000_SUCCESS;
48 if (hw->mac.ops.init_params) {
49 ret_val = hw->mac.ops.init_params(hw);
51 DEBUGOUT("MAC Initialization Error\n");
55 DEBUGOUT("mac.init_mac_params was NULL\n");
56 ret_val = -E1000_ERR_CONFIG;
64 * e1000_init_nvm_params - Initialize NVM function pointers
65 * @hw: pointer to the HW structure
67 * This function initializes the function pointers for the NVM
68 * set of functions. Called by drivers or by e1000_setup_init_funcs.
70 s32 e1000_init_nvm_params(struct e1000_hw *hw)
72 s32 ret_val = E1000_SUCCESS;
74 if (hw->nvm.ops.init_params) {
75 ret_val = hw->nvm.ops.init_params(hw);
77 DEBUGOUT("NVM Initialization Error\n");
81 DEBUGOUT("nvm.init_nvm_params was NULL\n");
82 ret_val = -E1000_ERR_CONFIG;
90 * e1000_init_phy_params - Initialize PHY function pointers
91 * @hw: pointer to the HW structure
93 * This function initializes the function pointers for the PHY
94 * set of functions. Called by drivers or by e1000_setup_init_funcs.
96 s32 e1000_init_phy_params(struct e1000_hw *hw)
98 s32 ret_val = E1000_SUCCESS;
100 if (hw->phy.ops.init_params) {
101 ret_val = hw->phy.ops.init_params(hw);
103 DEBUGOUT("PHY Initialization Error\n");
107 DEBUGOUT("phy.init_phy_params was NULL\n");
108 ret_val = -E1000_ERR_CONFIG;
116 * e1000_init_mbx_params - Initialize mailbox function pointers
117 * @hw: pointer to the HW structure
119 * This function initializes the function pointers for the PHY
120 * set of functions. Called by drivers or by e1000_setup_init_funcs.
122 s32 e1000_init_mbx_params(struct e1000_hw *hw)
124 s32 ret_val = E1000_SUCCESS;
126 if (hw->mbx.ops.init_params) {
127 ret_val = hw->mbx.ops.init_params(hw);
129 DEBUGOUT("Mailbox Initialization Error\n");
133 DEBUGOUT("mbx.init_mbx_params was NULL\n");
134 ret_val = -E1000_ERR_CONFIG;
142 * e1000_set_mac_type - Sets MAC type
143 * @hw: pointer to the HW structure
145 * This function sets the mac type of the adapter based on the
146 * device ID stored in the hw structure.
147 * MUST BE FIRST FUNCTION CALLED (explicitly or through
148 * e1000_setup_init_funcs()).
150 s32 e1000_set_mac_type(struct e1000_hw *hw)
152 struct e1000_mac_info *mac = &hw->mac;
153 s32 ret_val = E1000_SUCCESS;
155 DEBUGFUNC("e1000_set_mac_type");
157 switch (hw->device_id) {
158 case E1000_DEV_ID_82575EB_COPPER:
159 case E1000_DEV_ID_82575EB_FIBER_SERDES:
160 case E1000_DEV_ID_82575GB_QUAD_COPPER:
161 mac->type = e1000_82575;
163 case E1000_DEV_ID_82576:
164 case E1000_DEV_ID_82576_FIBER:
165 case E1000_DEV_ID_82576_SERDES:
166 case E1000_DEV_ID_82576_QUAD_COPPER:
167 case E1000_DEV_ID_82576_QUAD_COPPER_ET2:
168 case E1000_DEV_ID_82576_NS:
169 case E1000_DEV_ID_82576_NS_SERDES:
170 case E1000_DEV_ID_82576_SERDES_QUAD:
171 mac->type = e1000_82576;
173 case E1000_DEV_ID_82580_COPPER:
174 case E1000_DEV_ID_82580_FIBER:
175 case E1000_DEV_ID_82580_SERDES:
176 case E1000_DEV_ID_82580_SGMII:
177 case E1000_DEV_ID_82580_COPPER_DUAL:
178 case E1000_DEV_ID_82580_QUAD_FIBER:
179 case E1000_DEV_ID_DH89XXCC_SGMII:
180 case E1000_DEV_ID_DH89XXCC_SERDES:
181 case E1000_DEV_ID_DH89XXCC_BACKPLANE:
182 case E1000_DEV_ID_DH89XXCC_SFP:
183 mac->type = e1000_82580;
185 case E1000_DEV_ID_I350_COPPER:
186 case E1000_DEV_ID_I350_FIBER:
187 case E1000_DEV_ID_I350_SERDES:
188 case E1000_DEV_ID_I350_SGMII:
189 case E1000_DEV_ID_I350_DA4:
190 mac->type = e1000_i350;
192 case E1000_DEV_ID_82576_VF:
193 mac->type = e1000_vfadapt;
195 case E1000_DEV_ID_I350_VF:
196 mac->type = e1000_vfadapt_i350;
199 /* Should never have loaded on this device */
200 ret_val = -E1000_ERR_MAC_INIT;
208 * e1000_setup_init_funcs - Initializes function pointers
209 * @hw: pointer to the HW structure
210 * @init_device: TRUE will initialize the rest of the function pointers
211 * getting the device ready for use. FALSE will only set
212 * MAC type and the function pointers for the other init
213 * functions. Passing FALSE will not generate any hardware
216 * This function must be called by a driver in order to use the rest
217 * of the 'shared' code files. Called by drivers only.
219 s32 e1000_setup_init_funcs(struct e1000_hw *hw, bool init_device)
223 /* Can't do much good without knowing the MAC type. */
224 ret_val = e1000_set_mac_type(hw);
226 DEBUGOUT("ERROR: MAC type could not be set properly.\n");
231 DEBUGOUT("ERROR: Registers not mapped\n");
232 ret_val = -E1000_ERR_CONFIG;
237 * Init function pointers to generic implementations. We do this first
238 * allowing a driver module to override it afterward.
240 e1000_init_mac_ops_generic(hw);
241 e1000_init_phy_ops_generic(hw);
242 e1000_init_nvm_ops_generic(hw);
243 e1000_init_mbx_ops_generic(hw);
246 * Set up the init function pointers. These are functions within the
247 * adapter family file that sets up function pointers for the rest of
248 * the functions in that family.
250 switch (hw->mac.type) {
255 e1000_init_function_pointers_82575(hw);
258 e1000_init_function_pointers_vf(hw);
260 case e1000_vfadapt_i350:
261 e1000_init_function_pointers_vf(hw);
264 DEBUGOUT("Hardware not supported\n");
265 ret_val = -E1000_ERR_CONFIG;
270 * Initialize the rest of the function pointers. These require some
271 * register reads/writes in some cases.
273 if (!(ret_val) && init_device) {
274 ret_val = e1000_init_mac_params(hw);
278 ret_val = e1000_init_nvm_params(hw);
282 ret_val = e1000_init_phy_params(hw);
286 ret_val = e1000_init_mbx_params(hw);
296 * e1000_get_bus_info - Obtain bus information for adapter
297 * @hw: pointer to the HW structure
299 * This will obtain information about the HW bus for which the
300 * adapter is attached and stores it in the hw structure. This is a
301 * function pointer entry point called by drivers.
303 s32 e1000_get_bus_info(struct e1000_hw *hw)
305 if (hw->mac.ops.get_bus_info)
306 return hw->mac.ops.get_bus_info(hw);
308 return E1000_SUCCESS;
312 * e1000_clear_vfta - Clear VLAN filter table
313 * @hw: pointer to the HW structure
315 * This clears the VLAN filter table on the adapter. This is a function
316 * pointer entry point called by drivers.
318 void e1000_clear_vfta(struct e1000_hw *hw)
320 if (hw->mac.ops.clear_vfta)
321 hw->mac.ops.clear_vfta(hw);
325 * e1000_write_vfta - Write value to VLAN filter table
326 * @hw: pointer to the HW structure
327 * @offset: the 32-bit offset in which to write the value to.
328 * @value: the 32-bit value to write at location offset.
330 * This writes a 32-bit value to a 32-bit offset in the VLAN filter
331 * table. This is a function pointer entry point called by drivers.
333 void e1000_write_vfta(struct e1000_hw *hw, u32 offset, u32 value)
335 if (hw->mac.ops.write_vfta)
336 hw->mac.ops.write_vfta(hw, offset, value);
340 * e1000_update_mc_addr_list - Update Multicast addresses
341 * @hw: pointer to the HW structure
342 * @mc_addr_list: array of multicast addresses to program
343 * @mc_addr_count: number of multicast addresses to program
345 * Updates the Multicast Table Array.
346 * The caller must have a packed mc_addr_list of multicast addresses.
348 void e1000_update_mc_addr_list(struct e1000_hw *hw, u8 *mc_addr_list,
351 if (hw->mac.ops.update_mc_addr_list)
352 hw->mac.ops.update_mc_addr_list(hw, mc_addr_list,
357 * e1000_force_mac_fc - Force MAC flow control
358 * @hw: pointer to the HW structure
360 * Force the MAC's flow control settings. Currently no func pointer exists
361 * and all implementations are handled in the generic version of this
364 s32 e1000_force_mac_fc(struct e1000_hw *hw)
366 return e1000_force_mac_fc_generic(hw);
370 * e1000_check_for_link - Check/Store link connection
371 * @hw: pointer to the HW structure
373 * This checks the link condition of the adapter and stores the
374 * results in the hw->mac structure. This is a function pointer entry
375 * point called by drivers.
377 s32 e1000_check_for_link(struct e1000_hw *hw)
379 if (hw->mac.ops.check_for_link)
380 return hw->mac.ops.check_for_link(hw);
382 return -E1000_ERR_CONFIG;
386 * e1000_check_mng_mode - Check management mode
387 * @hw: pointer to the HW structure
389 * This checks if the adapter has manageability enabled.
390 * This is a function pointer entry point called by drivers.
392 bool e1000_check_mng_mode(struct e1000_hw *hw)
394 if (hw->mac.ops.check_mng_mode)
395 return hw->mac.ops.check_mng_mode(hw);
401 * e1000_mng_write_dhcp_info - Writes DHCP info to host interface
402 * @hw: pointer to the HW structure
403 * @buffer: pointer to the host interface
404 * @length: size of the buffer
406 * Writes the DHCP information to the host interface.
408 s32 e1000_mng_write_dhcp_info(struct e1000_hw *hw, u8 *buffer, u16 length)
410 return e1000_mng_write_dhcp_info_generic(hw, buffer, length);
414 * e1000_reset_hw - Reset hardware
415 * @hw: pointer to the HW structure
417 * This resets the hardware into a known state. This is a function pointer
418 * entry point called by drivers.
420 s32 e1000_reset_hw(struct e1000_hw *hw)
422 if (hw->mac.ops.reset_hw)
423 return hw->mac.ops.reset_hw(hw);
425 return -E1000_ERR_CONFIG;
429 * e1000_init_hw - Initialize hardware
430 * @hw: pointer to the HW structure
432 * This inits the hardware readying it for operation. This is a function
433 * pointer entry point called by drivers.
435 s32 e1000_init_hw(struct e1000_hw *hw)
437 if (hw->mac.ops.init_hw)
438 return hw->mac.ops.init_hw(hw);
440 return -E1000_ERR_CONFIG;
444 * e1000_setup_link - Configures link and flow control
445 * @hw: pointer to the HW structure
447 * This configures link and flow control settings for the adapter. This
448 * is a function pointer entry point called by drivers. While modules can
449 * also call this, they probably call their own version of this function.
451 s32 e1000_setup_link(struct e1000_hw *hw)
453 if (hw->mac.ops.setup_link)
454 return hw->mac.ops.setup_link(hw);
456 return -E1000_ERR_CONFIG;
460 * e1000_get_speed_and_duplex - Returns current speed and duplex
461 * @hw: pointer to the HW structure
462 * @speed: pointer to a 16-bit value to store the speed
463 * @duplex: pointer to a 16-bit value to store the duplex.
465 * This returns the speed and duplex of the adapter in the two 'out'
466 * variables passed in. This is a function pointer entry point called
469 s32 e1000_get_speed_and_duplex(struct e1000_hw *hw, u16 *speed, u16 *duplex)
471 if (hw->mac.ops.get_link_up_info)
472 return hw->mac.ops.get_link_up_info(hw, speed, duplex);
474 return -E1000_ERR_CONFIG;
478 * e1000_setup_led - Configures SW controllable LED
479 * @hw: pointer to the HW structure
481 * This prepares the SW controllable LED for use and saves the current state
482 * of the LED so it can be later restored. This is a function pointer entry
483 * point called by drivers.
485 s32 e1000_setup_led(struct e1000_hw *hw)
487 if (hw->mac.ops.setup_led)
488 return hw->mac.ops.setup_led(hw);
490 return E1000_SUCCESS;
494 * e1000_cleanup_led - Restores SW controllable LED
495 * @hw: pointer to the HW structure
497 * This restores the SW controllable LED to the value saved off by
498 * e1000_setup_led. This is a function pointer entry point called by drivers.
500 s32 e1000_cleanup_led(struct e1000_hw *hw)
502 if (hw->mac.ops.cleanup_led)
503 return hw->mac.ops.cleanup_led(hw);
505 return E1000_SUCCESS;
509 * e1000_blink_led - Blink SW controllable LED
510 * @hw: pointer to the HW structure
512 * This starts the adapter LED blinking. Request the LED to be setup first
513 * and cleaned up after. This is a function pointer entry point called by
516 s32 e1000_blink_led(struct e1000_hw *hw)
518 if (hw->mac.ops.blink_led)
519 return hw->mac.ops.blink_led(hw);
521 return E1000_SUCCESS;
525 * e1000_id_led_init - store LED configurations in SW
526 * @hw: pointer to the HW structure
528 * Initializes the LED config in SW. This is a function pointer entry point
531 s32 e1000_id_led_init(struct e1000_hw *hw)
533 if (hw->mac.ops.id_led_init)
534 return hw->mac.ops.id_led_init(hw);
536 return E1000_SUCCESS;
540 * e1000_led_on - Turn on SW controllable LED
541 * @hw: pointer to the HW structure
543 * Turns the SW defined LED on. This is a function pointer entry point
546 s32 e1000_led_on(struct e1000_hw *hw)
548 if (hw->mac.ops.led_on)
549 return hw->mac.ops.led_on(hw);
551 return E1000_SUCCESS;
555 * e1000_led_off - Turn off SW controllable LED
556 * @hw: pointer to the HW structure
558 * Turns the SW defined LED off. This is a function pointer entry point
561 s32 e1000_led_off(struct e1000_hw *hw)
563 if (hw->mac.ops.led_off)
564 return hw->mac.ops.led_off(hw);
566 return E1000_SUCCESS;
570 * e1000_reset_adaptive - Reset adaptive IFS
571 * @hw: pointer to the HW structure
573 * Resets the adaptive IFS. Currently no func pointer exists and all
574 * implementations are handled in the generic version of this function.
576 void e1000_reset_adaptive(struct e1000_hw *hw)
578 e1000_reset_adaptive_generic(hw);
582 * e1000_update_adaptive - Update adaptive IFS
583 * @hw: pointer to the HW structure
585 * Updates adapter IFS. Currently no func pointer exists and all
586 * implementations are handled in the generic version of this function.
588 void e1000_update_adaptive(struct e1000_hw *hw)
590 e1000_update_adaptive_generic(hw);
594 * e1000_disable_pcie_master - Disable PCI-Express master access
595 * @hw: pointer to the HW structure
597 * Disables PCI-Express master access and verifies there are no pending
598 * requests. Currently no func pointer exists and all implementations are
599 * handled in the generic version of this function.
601 s32 e1000_disable_pcie_master(struct e1000_hw *hw)
603 return e1000_disable_pcie_master_generic(hw);
607 * e1000_config_collision_dist - Configure collision distance
608 * @hw: pointer to the HW structure
610 * Configures the collision distance to the default value and is used
613 void e1000_config_collision_dist(struct e1000_hw *hw)
615 if (hw->mac.ops.config_collision_dist)
616 hw->mac.ops.config_collision_dist(hw);
620 * e1000_rar_set - Sets a receive address register
621 * @hw: pointer to the HW structure
622 * @addr: address to set the RAR to
623 * @index: the RAR to set
625 * Sets a Receive Address Register (RAR) to the specified address.
627 void e1000_rar_set(struct e1000_hw *hw, u8 *addr, u32 index)
629 if (hw->mac.ops.rar_set)
630 hw->mac.ops.rar_set(hw, addr, index);
634 * e1000_validate_mdi_setting - Ensures valid MDI/MDIX SW state
635 * @hw: pointer to the HW structure
637 * Ensures that the MDI/MDIX SW state is valid.
639 s32 e1000_validate_mdi_setting(struct e1000_hw *hw)
641 if (hw->mac.ops.validate_mdi_setting)
642 return hw->mac.ops.validate_mdi_setting(hw);
644 return E1000_SUCCESS;
648 * e1000_hash_mc_addr - Determines address location in multicast table
649 * @hw: pointer to the HW structure
650 * @mc_addr: Multicast address to hash.
652 * This hashes an address to determine its location in the multicast
653 * table. Currently no func pointer exists and all implementations
654 * are handled in the generic version of this function.
656 u32 e1000_hash_mc_addr(struct e1000_hw *hw, u8 *mc_addr)
658 return e1000_hash_mc_addr_generic(hw, mc_addr);
662 * e1000_enable_tx_pkt_filtering - Enable packet filtering on TX
663 * @hw: pointer to the HW structure
665 * Enables packet filtering on transmit packets if manageability is enabled
666 * and host interface is enabled.
667 * Currently no func pointer exists and all implementations are handled in the
668 * generic version of this function.
670 bool e1000_enable_tx_pkt_filtering(struct e1000_hw *hw)
672 return e1000_enable_tx_pkt_filtering_generic(hw);
676 * e1000_mng_host_if_write - Writes to the manageability host interface
677 * @hw: pointer to the HW structure
678 * @buffer: pointer to the host interface buffer
679 * @length: size of the buffer
680 * @offset: location in the buffer to write to
681 * @sum: sum of the data (not checksum)
683 * This function writes the buffer content at the offset given on the host if.
684 * It also does alignment considerations to do the writes in most efficient
685 * way. Also fills up the sum of the buffer in *buffer parameter.
687 s32 e1000_mng_host_if_write(struct e1000_hw * hw, u8 *buffer, u16 length,
690 if (hw->mac.ops.mng_host_if_write)
691 return hw->mac.ops.mng_host_if_write(hw, buffer, length,
694 return E1000_NOT_IMPLEMENTED;
698 * e1000_mng_write_cmd_header - Writes manageability command header
699 * @hw: pointer to the HW structure
700 * @hdr: pointer to the host interface command header
702 * Writes the command header after does the checksum calculation.
704 s32 e1000_mng_write_cmd_header(struct e1000_hw *hw,
705 struct e1000_host_mng_command_header *hdr)
707 if (hw->mac.ops.mng_write_cmd_header)
708 return hw->mac.ops.mng_write_cmd_header(hw, hdr);
710 return E1000_NOT_IMPLEMENTED;
714 * e1000_mng_enable_host_if - Checks host interface is enabled
715 * @hw: pointer to the HW structure
717 * Returns E1000_success upon success, else E1000_ERR_HOST_INTERFACE_COMMAND
719 * This function checks whether the HOST IF is enabled for command operation
720 * and also checks whether the previous command is completed. It busy waits
721 * in case of previous command is not completed.
723 s32 e1000_mng_enable_host_if(struct e1000_hw * hw)
725 if (hw->mac.ops.mng_enable_host_if)
726 return hw->mac.ops.mng_enable_host_if(hw);
728 return E1000_NOT_IMPLEMENTED;
732 * e1000_wait_autoneg - Waits for autonegotiation completion
733 * @hw: pointer to the HW structure
735 * Waits for autoneg to complete. Currently no func pointer exists and all
736 * implementations are handled in the generic version of this function.
738 s32 e1000_wait_autoneg(struct e1000_hw *hw)
740 if (hw->mac.ops.wait_autoneg)
741 return hw->mac.ops.wait_autoneg(hw);
743 return E1000_SUCCESS;
747 * e1000_check_reset_block - Verifies PHY can be reset
748 * @hw: pointer to the HW structure
750 * Checks if the PHY is in a state that can be reset or if manageability
751 * has it tied up. This is a function pointer entry point called by drivers.
753 s32 e1000_check_reset_block(struct e1000_hw *hw)
755 if (hw->phy.ops.check_reset_block)
756 return hw->phy.ops.check_reset_block(hw);
758 return E1000_SUCCESS;
762 * e1000_read_phy_reg - Reads PHY register
763 * @hw: pointer to the HW structure
764 * @offset: the register to read
765 * @data: the buffer to store the 16-bit read.
767 * Reads the PHY register and returns the value in data.
768 * This is a function pointer entry point called by drivers.
770 s32 e1000_read_phy_reg(struct e1000_hw *hw, u32 offset, u16 *data)
772 if (hw->phy.ops.read_reg)
773 return hw->phy.ops.read_reg(hw, offset, data);
775 return E1000_SUCCESS;
779 * e1000_write_phy_reg - Writes PHY register
780 * @hw: pointer to the HW structure
781 * @offset: the register to write
782 * @data: the value to write.
784 * Writes the PHY register at offset with the value in data.
785 * This is a function pointer entry point called by drivers.
787 s32 e1000_write_phy_reg(struct e1000_hw *hw, u32 offset, u16 data)
789 if (hw->phy.ops.write_reg)
790 return hw->phy.ops.write_reg(hw, offset, data);
792 return E1000_SUCCESS;
796 * e1000_release_phy - Generic release PHY
797 * @hw: pointer to the HW structure
799 * Return if silicon family does not require a semaphore when accessing the
802 void e1000_release_phy(struct e1000_hw *hw)
804 if (hw->phy.ops.release)
805 hw->phy.ops.release(hw);
809 * e1000_acquire_phy - Generic acquire PHY
810 * @hw: pointer to the HW structure
812 * Return success if silicon family does not require a semaphore when
815 s32 e1000_acquire_phy(struct e1000_hw *hw)
817 if (hw->phy.ops.acquire)
818 return hw->phy.ops.acquire(hw);
820 return E1000_SUCCESS;
824 * e1000_read_kmrn_reg - Reads register using Kumeran interface
825 * @hw: pointer to the HW structure
826 * @offset: the register to read
827 * @data: the location to store the 16-bit value read.
829 * Reads a register out of the Kumeran interface. Currently no func pointer
830 * exists and all implementations are handled in the generic version of
833 s32 e1000_read_kmrn_reg(struct e1000_hw *hw, u32 offset, u16 *data)
835 return e1000_read_kmrn_reg_generic(hw, offset, data);
839 * e1000_write_kmrn_reg - Writes register using Kumeran interface
840 * @hw: pointer to the HW structure
841 * @offset: the register to write
842 * @data: the value to write.
844 * Writes a register to the Kumeran interface. Currently no func pointer
845 * exists and all implementations are handled in the generic version of
848 s32 e1000_write_kmrn_reg(struct e1000_hw *hw, u32 offset, u16 data)
850 return e1000_write_kmrn_reg_generic(hw, offset, data);
854 * e1000_get_cable_length - Retrieves cable length estimation
855 * @hw: pointer to the HW structure
857 * This function estimates the cable length and stores them in
858 * hw->phy.min_length and hw->phy.max_length. This is a function pointer
859 * entry point called by drivers.
861 s32 e1000_get_cable_length(struct e1000_hw *hw)
863 if (hw->phy.ops.get_cable_length)
864 return hw->phy.ops.get_cable_length(hw);
866 return E1000_SUCCESS;
870 * e1000_get_phy_info - Retrieves PHY information from registers
871 * @hw: pointer to the HW structure
873 * This function gets some information from various PHY registers and
874 * populates hw->phy values with it. This is a function pointer entry
875 * point called by drivers.
877 s32 e1000_get_phy_info(struct e1000_hw *hw)
879 if (hw->phy.ops.get_info)
880 return hw->phy.ops.get_info(hw);
882 return E1000_SUCCESS;
886 * e1000_phy_hw_reset - Hard PHY reset
887 * @hw: pointer to the HW structure
889 * Performs a hard PHY reset. This is a function pointer entry point called
892 s32 e1000_phy_hw_reset(struct e1000_hw *hw)
894 if (hw->phy.ops.reset)
895 return hw->phy.ops.reset(hw);
897 return E1000_SUCCESS;
901 * e1000_phy_commit - Soft PHY reset
902 * @hw: pointer to the HW structure
904 * Performs a soft PHY reset on those that apply. This is a function pointer
905 * entry point called by drivers.
907 s32 e1000_phy_commit(struct e1000_hw *hw)
909 if (hw->phy.ops.commit)
910 return hw->phy.ops.commit(hw);
912 return E1000_SUCCESS;
916 * e1000_set_d0_lplu_state - Sets low power link up state for D0
917 * @hw: pointer to the HW structure
918 * @active: boolean used to enable/disable lplu
920 * Success returns 0, Failure returns 1
922 * The low power link up (lplu) state is set to the power management level D0
923 * and SmartSpeed is disabled when active is TRUE, else clear lplu for D0
924 * and enable Smartspeed. LPLU and Smartspeed are mutually exclusive. LPLU
925 * is used during Dx states where the power conservation is most important.
926 * During driver activity, SmartSpeed should be enabled so performance is
927 * maintained. This is a function pointer entry point called by drivers.
929 s32 e1000_set_d0_lplu_state(struct e1000_hw *hw, bool active)
931 if (hw->phy.ops.set_d0_lplu_state)
932 return hw->phy.ops.set_d0_lplu_state(hw, active);
934 return E1000_SUCCESS;
938 * e1000_set_d3_lplu_state - Sets low power link up state for D3
939 * @hw: pointer to the HW structure
940 * @active: boolean used to enable/disable lplu
942 * Success returns 0, Failure returns 1
944 * The low power link up (lplu) state is set to the power management level D3
945 * and SmartSpeed is disabled when active is TRUE, else clear lplu for D3
946 * and enable Smartspeed. LPLU and Smartspeed are mutually exclusive. LPLU
947 * is used during Dx states where the power conservation is most important.
948 * During driver activity, SmartSpeed should be enabled so performance is
949 * maintained. This is a function pointer entry point called by drivers.
951 s32 e1000_set_d3_lplu_state(struct e1000_hw *hw, bool active)
953 if (hw->phy.ops.set_d3_lplu_state)
954 return hw->phy.ops.set_d3_lplu_state(hw, active);
956 return E1000_SUCCESS;
960 * e1000_read_mac_addr - Reads MAC address
961 * @hw: pointer to the HW structure
963 * Reads the MAC address out of the adapter and stores it in the HW structure.
964 * Currently no func pointer exists and all implementations are handled in the
965 * generic version of this function.
967 s32 e1000_read_mac_addr(struct e1000_hw *hw)
969 if (hw->mac.ops.read_mac_addr)
970 return hw->mac.ops.read_mac_addr(hw);
972 return e1000_read_mac_addr_generic(hw);
976 * e1000_read_pba_string - Read device part number string
977 * @hw: pointer to the HW structure
978 * @pba_num: pointer to device part number
979 * @pba_num_size: size of part number buffer
981 * Reads the product board assembly (PBA) number from the EEPROM and stores
982 * the value in pba_num.
983 * Currently no func pointer exists and all implementations are handled in the
984 * generic version of this function.
986 s32 e1000_read_pba_string(struct e1000_hw *hw, u8 *pba_num, u32 pba_num_size)
988 return e1000_read_pba_string_generic(hw, pba_num, pba_num_size);
992 * e1000_read_pba_length - Read device part number string length
993 * @hw: pointer to the HW structure
994 * @pba_num_size: size of part number buffer
996 * Reads the product board assembly (PBA) number length from the EEPROM and
997 * stores the value in pba_num.
998 * Currently no func pointer exists and all implementations are handled in the
999 * generic version of this function.
1001 s32 e1000_read_pba_length(struct e1000_hw *hw, u32 *pba_num_size)
1003 return e1000_read_pba_length_generic(hw, pba_num_size);
1007 * e1000_validate_nvm_checksum - Verifies NVM (EEPROM) checksum
1008 * @hw: pointer to the HW structure
1010 * Validates the NVM checksum is correct. This is a function pointer entry
1011 * point called by drivers.
1013 s32 e1000_validate_nvm_checksum(struct e1000_hw *hw)
1015 if (hw->nvm.ops.validate)
1016 return hw->nvm.ops.validate(hw);
1018 return -E1000_ERR_CONFIG;
1022 * e1000_update_nvm_checksum - Updates NVM (EEPROM) checksum
1023 * @hw: pointer to the HW structure
1025 * Updates the NVM checksum. Currently no func pointer exists and all
1026 * implementations are handled in the generic version of this function.
1028 s32 e1000_update_nvm_checksum(struct e1000_hw *hw)
1030 if (hw->nvm.ops.update)
1031 return hw->nvm.ops.update(hw);
1033 return -E1000_ERR_CONFIG;
1037 * e1000_reload_nvm - Reloads EEPROM
1038 * @hw: pointer to the HW structure
1040 * Reloads the EEPROM by setting the "Reinitialize from EEPROM" bit in the
1041 * extended control register.
1043 void e1000_reload_nvm(struct e1000_hw *hw)
1045 if (hw->nvm.ops.reload)
1046 hw->nvm.ops.reload(hw);
1050 * e1000_read_nvm - Reads NVM (EEPROM)
1051 * @hw: pointer to the HW structure
1052 * @offset: the word offset to read
1053 * @words: number of 16-bit words to read
1054 * @data: pointer to the properly sized buffer for the data.
1056 * Reads 16-bit chunks of data from the NVM (EEPROM). This is a function
1057 * pointer entry point called by drivers.
1059 s32 e1000_read_nvm(struct e1000_hw *hw, u16 offset, u16 words, u16 *data)
1061 if (hw->nvm.ops.read)
1062 return hw->nvm.ops.read(hw, offset, words, data);
1064 return -E1000_ERR_CONFIG;
1068 * e1000_write_nvm - Writes to NVM (EEPROM)
1069 * @hw: pointer to the HW structure
1070 * @offset: the word offset to read
1071 * @words: number of 16-bit words to write
1072 * @data: pointer to the properly sized buffer for the data.
1074 * Writes 16-bit chunks of data to the NVM (EEPROM). This is a function
1075 * pointer entry point called by drivers.
1077 s32 e1000_write_nvm(struct e1000_hw *hw, u16 offset, u16 words, u16 *data)
1079 if (hw->nvm.ops.write)
1080 return hw->nvm.ops.write(hw, offset, words, data);
1082 return E1000_SUCCESS;
1086 * e1000_write_8bit_ctrl_reg - Writes 8bit Control register
1087 * @hw: pointer to the HW structure
1088 * @reg: 32bit register offset
1089 * @offset: the register to write
1090 * @data: the value to write.
1092 * Writes the PHY register at offset with the value in data.
1093 * This is a function pointer entry point called by drivers.
1095 s32 e1000_write_8bit_ctrl_reg(struct e1000_hw *hw, u32 reg, u32 offset,
1098 return e1000_write_8bit_ctrl_reg_generic(hw, reg, offset, data);
1102 * e1000_power_up_phy - Restores link in case of PHY power down
1103 * @hw: pointer to the HW structure
1105 * The phy may be powered down to save power, to turn off link when the
1106 * driver is unloaded, or wake on lan is not enabled (among others).
1108 void e1000_power_up_phy(struct e1000_hw *hw)
1110 if (hw->phy.ops.power_up)
1111 hw->phy.ops.power_up(hw);
1113 e1000_setup_link(hw);
1117 * e1000_power_down_phy - Power down PHY
1118 * @hw: pointer to the HW structure
1120 * The phy may be powered down to save power, to turn off link when the
1121 * driver is unloaded, or wake on lan is not enabled (among others).
1123 void e1000_power_down_phy(struct e1000_hw *hw)
1125 if (hw->phy.ops.power_down)
1126 hw->phy.ops.power_down(hw);
1130 * e1000_power_up_fiber_serdes_link - Power up serdes link
1131 * @hw: pointer to the HW structure
1133 * Power on the optics and PCS.
1135 void e1000_power_up_fiber_serdes_link(struct e1000_hw *hw)
1137 if (hw->mac.ops.power_up_serdes)
1138 hw->mac.ops.power_up_serdes(hw);
1142 * e1000_shutdown_fiber_serdes_link - Remove link during power down
1143 * @hw: pointer to the HW structure
1145 * Shutdown the optics and PCS on driver unload.
1147 void e1000_shutdown_fiber_serdes_link(struct e1000_hw *hw)
1149 if (hw->mac.ops.shutdown_serdes)
1150 hw->mac.ops.shutdown_serdes(hw);