1228 lines
37 KiB
C
1228 lines
37 KiB
C
/*******************************************************************************
|
|
|
|
Intel PRO/10GbE Linux driver
|
|
Copyright(c) 1999 - 2006 Intel Corporation.
|
|
|
|
This program is free software; you can redistribute it and/or modify it
|
|
under the terms and conditions of the GNU General Public License,
|
|
version 2, as published by the Free Software Foundation.
|
|
|
|
This program is distributed in the hope it will be useful, but WITHOUT
|
|
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
|
|
more details.
|
|
|
|
You should have received a copy of the GNU General Public License along with
|
|
this program; if not, write to the Free Software Foundation, Inc.,
|
|
51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
|
|
|
|
The full GNU General Public License is included in this distribution in
|
|
the file called "COPYING".
|
|
|
|
Contact Information:
|
|
Linux NICS <linux.nics@intel.com>
|
|
e1000-devel Mailing List <e1000-devel@lists.sourceforge.net>
|
|
Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
|
|
|
|
*******************************************************************************/
|
|
|
|
/* ixgb_hw.c
|
|
* Shared functions for accessing and configuring the adapter
|
|
*/
|
|
|
|
#include "ixgb_hw.h"
|
|
#include "ixgb_ids.h"
|
|
|
|
/* Local function prototypes */
|
|
|
|
static uint32_t ixgb_hash_mc_addr(struct ixgb_hw *hw, uint8_t * mc_addr);
|
|
|
|
static void ixgb_mta_set(struct ixgb_hw *hw, uint32_t hash_value);
|
|
|
|
static void ixgb_get_bus_info(struct ixgb_hw *hw);
|
|
|
|
static boolean_t ixgb_link_reset(struct ixgb_hw *hw);
|
|
|
|
static void ixgb_optics_reset(struct ixgb_hw *hw);
|
|
|
|
static ixgb_phy_type ixgb_identify_phy(struct ixgb_hw *hw);
|
|
|
|
static void ixgb_clear_hw_cntrs(struct ixgb_hw *hw);
|
|
|
|
static void ixgb_clear_vfta(struct ixgb_hw *hw);
|
|
|
|
static void ixgb_init_rx_addrs(struct ixgb_hw *hw);
|
|
|
|
static uint16_t ixgb_read_phy_reg(struct ixgb_hw *hw,
|
|
uint32_t reg_address,
|
|
uint32_t phy_address,
|
|
uint32_t device_type);
|
|
|
|
static boolean_t ixgb_setup_fc(struct ixgb_hw *hw);
|
|
|
|
static boolean_t mac_addr_valid(uint8_t *mac_addr);
|
|
|
|
static uint32_t ixgb_mac_reset(struct ixgb_hw *hw)
|
|
{
|
|
uint32_t ctrl_reg;
|
|
|
|
ctrl_reg = IXGB_CTRL0_RST |
|
|
IXGB_CTRL0_SDP3_DIR | /* All pins are Output=1 */
|
|
IXGB_CTRL0_SDP2_DIR |
|
|
IXGB_CTRL0_SDP1_DIR |
|
|
IXGB_CTRL0_SDP0_DIR |
|
|
IXGB_CTRL0_SDP3 | /* Initial value 1101 */
|
|
IXGB_CTRL0_SDP2 |
|
|
IXGB_CTRL0_SDP0;
|
|
|
|
#ifdef HP_ZX1
|
|
/* Workaround for 82597EX reset errata */
|
|
IXGB_WRITE_REG_IO(hw, CTRL0, ctrl_reg);
|
|
#else
|
|
IXGB_WRITE_REG(hw, CTRL0, ctrl_reg);
|
|
#endif
|
|
|
|
/* Delay a few ms just to allow the reset to complete */
|
|
msleep(IXGB_DELAY_AFTER_RESET);
|
|
ctrl_reg = IXGB_READ_REG(hw, CTRL0);
|
|
#ifdef DBG
|
|
/* Make sure the self-clearing global reset bit did self clear */
|
|
ASSERT(!(ctrl_reg & IXGB_CTRL0_RST));
|
|
#endif
|
|
|
|
if (hw->phy_type == ixgb_phy_type_txn17401) {
|
|
ixgb_optics_reset(hw);
|
|
}
|
|
|
|
return ctrl_reg;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Reset the transmit and receive units; mask and clear all interrupts.
|
|
*
|
|
* hw - Struct containing variables accessed by shared code
|
|
*****************************************************************************/
|
|
boolean_t
|
|
ixgb_adapter_stop(struct ixgb_hw *hw)
|
|
{
|
|
uint32_t ctrl_reg;
|
|
uint32_t icr_reg;
|
|
|
|
DEBUGFUNC("ixgb_adapter_stop");
|
|
|
|
/* If we are stopped or resetting exit gracefully and wait to be
|
|
* started again before accessing the hardware.
|
|
*/
|
|
if(hw->adapter_stopped) {
|
|
DEBUGOUT("Exiting because the adapter is already stopped!!!\n");
|
|
return FALSE;
|
|
}
|
|
|
|
/* Set the Adapter Stopped flag so other driver functions stop
|
|
* touching the Hardware.
|
|
*/
|
|
hw->adapter_stopped = TRUE;
|
|
|
|
/* Clear interrupt mask to stop board from generating interrupts */
|
|
DEBUGOUT("Masking off all interrupts\n");
|
|
IXGB_WRITE_REG(hw, IMC, 0xFFFFFFFF);
|
|
|
|
/* Disable the Transmit and Receive units. Then delay to allow
|
|
* any pending transactions to complete before we hit the MAC with
|
|
* the global reset.
|
|
*/
|
|
IXGB_WRITE_REG(hw, RCTL, IXGB_READ_REG(hw, RCTL) & ~IXGB_RCTL_RXEN);
|
|
IXGB_WRITE_REG(hw, TCTL, IXGB_READ_REG(hw, TCTL) & ~IXGB_TCTL_TXEN);
|
|
msleep(IXGB_DELAY_BEFORE_RESET);
|
|
|
|
/* Issue a global reset to the MAC. This will reset the chip's
|
|
* transmit, receive, DMA, and link units. It will not effect
|
|
* the current PCI configuration. The global reset bit is self-
|
|
* clearing, and should clear within a microsecond.
|
|
*/
|
|
DEBUGOUT("Issuing a global reset to MAC\n");
|
|
|
|
ctrl_reg = ixgb_mac_reset(hw);
|
|
|
|
/* Clear interrupt mask to stop board from generating interrupts */
|
|
DEBUGOUT("Masking off all interrupts\n");
|
|
IXGB_WRITE_REG(hw, IMC, 0xffffffff);
|
|
|
|
/* Clear any pending interrupt events. */
|
|
icr_reg = IXGB_READ_REG(hw, ICR);
|
|
|
|
return (ctrl_reg & IXGB_CTRL0_RST);
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
* Identifies the vendor of the optics module on the adapter. The SR adapters
|
|
* support two different types of XPAK optics, so it is necessary to determine
|
|
* which optics are present before applying any optics-specific workarounds.
|
|
*
|
|
* hw - Struct containing variables accessed by shared code.
|
|
*
|
|
* Returns: the vendor of the XPAK optics module.
|
|
*****************************************************************************/
|
|
static ixgb_xpak_vendor
|
|
ixgb_identify_xpak_vendor(struct ixgb_hw *hw)
|
|
{
|
|
uint32_t i;
|
|
uint16_t vendor_name[5];
|
|
ixgb_xpak_vendor xpak_vendor;
|
|
|
|
DEBUGFUNC("ixgb_identify_xpak_vendor");
|
|
|
|
/* Read the first few bytes of the vendor string from the XPAK NVR
|
|
* registers. These are standard XENPAK/XPAK registers, so all XPAK
|
|
* devices should implement them. */
|
|
for (i = 0; i < 5; i++) {
|
|
vendor_name[i] = ixgb_read_phy_reg(hw,
|
|
MDIO_PMA_PMD_XPAK_VENDOR_NAME
|
|
+ i, IXGB_PHY_ADDRESS,
|
|
MDIO_PMA_PMD_DID);
|
|
}
|
|
|
|
/* Determine the actual vendor */
|
|
if (vendor_name[0] == 'I' &&
|
|
vendor_name[1] == 'N' &&
|
|
vendor_name[2] == 'T' &&
|
|
vendor_name[3] == 'E' && vendor_name[4] == 'L') {
|
|
xpak_vendor = ixgb_xpak_vendor_intel;
|
|
} else {
|
|
xpak_vendor = ixgb_xpak_vendor_infineon;
|
|
}
|
|
|
|
return (xpak_vendor);
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Determine the physical layer module on the adapter.
|
|
*
|
|
* hw - Struct containing variables accessed by shared code. The device_id
|
|
* field must be (correctly) populated before calling this routine.
|
|
*
|
|
* Returns: the phy type of the adapter.
|
|
*****************************************************************************/
|
|
static ixgb_phy_type
|
|
ixgb_identify_phy(struct ixgb_hw *hw)
|
|
{
|
|
ixgb_phy_type phy_type;
|
|
ixgb_xpak_vendor xpak_vendor;
|
|
|
|
DEBUGFUNC("ixgb_identify_phy");
|
|
|
|
/* Infer the transceiver/phy type from the device id */
|
|
switch (hw->device_id) {
|
|
case IXGB_DEVICE_ID_82597EX:
|
|
DEBUGOUT("Identified TXN17401 optics\n");
|
|
phy_type = ixgb_phy_type_txn17401;
|
|
break;
|
|
|
|
case IXGB_DEVICE_ID_82597EX_SR:
|
|
/* The SR adapters carry two different types of XPAK optics
|
|
* modules; read the vendor identifier to determine the exact
|
|
* type of optics. */
|
|
xpak_vendor = ixgb_identify_xpak_vendor(hw);
|
|
if (xpak_vendor == ixgb_xpak_vendor_intel) {
|
|
DEBUGOUT("Identified TXN17201 optics\n");
|
|
phy_type = ixgb_phy_type_txn17201;
|
|
} else {
|
|
DEBUGOUT("Identified G6005 optics\n");
|
|
phy_type = ixgb_phy_type_g6005;
|
|
}
|
|
break;
|
|
case IXGB_DEVICE_ID_82597EX_LR:
|
|
DEBUGOUT("Identified G6104 optics\n");
|
|
phy_type = ixgb_phy_type_g6104;
|
|
break;
|
|
case IXGB_DEVICE_ID_82597EX_CX4:
|
|
DEBUGOUT("Identified CX4\n");
|
|
xpak_vendor = ixgb_identify_xpak_vendor(hw);
|
|
if (xpak_vendor == ixgb_xpak_vendor_intel) {
|
|
DEBUGOUT("Identified TXN17201 optics\n");
|
|
phy_type = ixgb_phy_type_txn17201;
|
|
} else {
|
|
DEBUGOUT("Identified G6005 optics\n");
|
|
phy_type = ixgb_phy_type_g6005;
|
|
}
|
|
break;
|
|
default:
|
|
DEBUGOUT("Unknown physical layer module\n");
|
|
phy_type = ixgb_phy_type_unknown;
|
|
break;
|
|
}
|
|
|
|
return (phy_type);
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Performs basic configuration of the adapter.
|
|
*
|
|
* hw - Struct containing variables accessed by shared code
|
|
*
|
|
* Resets the controller.
|
|
* Reads and validates the EEPROM.
|
|
* Initializes the receive address registers.
|
|
* Initializes the multicast table.
|
|
* Clears all on-chip counters.
|
|
* Calls routine to setup flow control settings.
|
|
* Leaves the transmit and receive units disabled and uninitialized.
|
|
*
|
|
* Returns:
|
|
* TRUE if successful,
|
|
* FALSE if unrecoverable problems were encountered.
|
|
*****************************************************************************/
|
|
boolean_t
|
|
ixgb_init_hw(struct ixgb_hw *hw)
|
|
{
|
|
uint32_t i;
|
|
uint32_t ctrl_reg;
|
|
boolean_t status;
|
|
|
|
DEBUGFUNC("ixgb_init_hw");
|
|
|
|
/* Issue a global reset to the MAC. This will reset the chip's
|
|
* transmit, receive, DMA, and link units. It will not effect
|
|
* the current PCI configuration. The global reset bit is self-
|
|
* clearing, and should clear within a microsecond.
|
|
*/
|
|
DEBUGOUT("Issuing a global reset to MAC\n");
|
|
|
|
ctrl_reg = ixgb_mac_reset(hw);
|
|
|
|
DEBUGOUT("Issuing an EE reset to MAC\n");
|
|
#ifdef HP_ZX1
|
|
/* Workaround for 82597EX reset errata */
|
|
IXGB_WRITE_REG_IO(hw, CTRL1, IXGB_CTRL1_EE_RST);
|
|
#else
|
|
IXGB_WRITE_REG(hw, CTRL1, IXGB_CTRL1_EE_RST);
|
|
#endif
|
|
|
|
/* Delay a few ms just to allow the reset to complete */
|
|
msleep(IXGB_DELAY_AFTER_EE_RESET);
|
|
|
|
if (ixgb_get_eeprom_data(hw) == FALSE) {
|
|
return(FALSE);
|
|
}
|
|
|
|
/* Use the device id to determine the type of phy/transceiver. */
|
|
hw->device_id = ixgb_get_ee_device_id(hw);
|
|
hw->phy_type = ixgb_identify_phy(hw);
|
|
|
|
/* Setup the receive addresses.
|
|
* Receive Address Registers (RARs 0 - 15).
|
|
*/
|
|
ixgb_init_rx_addrs(hw);
|
|
|
|
/*
|
|
* Check that a valid MAC address has been set.
|
|
* If it is not valid, we fail hardware init.
|
|
*/
|
|
if (!mac_addr_valid(hw->curr_mac_addr)) {
|
|
DEBUGOUT("MAC address invalid after ixgb_init_rx_addrs\n");
|
|
return(FALSE);
|
|
}
|
|
|
|
/* tell the routines in this file they can access hardware again */
|
|
hw->adapter_stopped = FALSE;
|
|
|
|
/* Fill in the bus_info structure */
|
|
ixgb_get_bus_info(hw);
|
|
|
|
/* Zero out the Multicast HASH table */
|
|
DEBUGOUT("Zeroing the MTA\n");
|
|
for(i = 0; i < IXGB_MC_TBL_SIZE; i++)
|
|
IXGB_WRITE_REG_ARRAY(hw, MTA, i, 0);
|
|
|
|
/* Zero out the VLAN Filter Table Array */
|
|
ixgb_clear_vfta(hw);
|
|
|
|
/* Zero all of the hardware counters */
|
|
ixgb_clear_hw_cntrs(hw);
|
|
|
|
/* Call a subroutine to setup flow control. */
|
|
status = ixgb_setup_fc(hw);
|
|
|
|
/* 82597EX errata: Call check-for-link in case lane deskew is locked */
|
|
ixgb_check_for_link(hw);
|
|
|
|
return (status);
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Initializes receive address filters.
|
|
*
|
|
* hw - Struct containing variables accessed by shared code
|
|
*
|
|
* Places the MAC address in receive address register 0 and clears the rest
|
|
* of the receive addresss registers. Clears the multicast table. Assumes
|
|
* the receiver is in reset when the routine is called.
|
|
*****************************************************************************/
|
|
static void
|
|
ixgb_init_rx_addrs(struct ixgb_hw *hw)
|
|
{
|
|
uint32_t i;
|
|
|
|
DEBUGFUNC("ixgb_init_rx_addrs");
|
|
|
|
/*
|
|
* If the current mac address is valid, assume it is a software override
|
|
* to the permanent address.
|
|
* Otherwise, use the permanent address from the eeprom.
|
|
*/
|
|
if (!mac_addr_valid(hw->curr_mac_addr)) {
|
|
|
|
/* Get the MAC address from the eeprom for later reference */
|
|
ixgb_get_ee_mac_addr(hw, hw->curr_mac_addr);
|
|
|
|
DEBUGOUT3(" Keeping Permanent MAC Addr =%.2X %.2X %.2X ",
|
|
hw->curr_mac_addr[0],
|
|
hw->curr_mac_addr[1], hw->curr_mac_addr[2]);
|
|
DEBUGOUT3("%.2X %.2X %.2X\n",
|
|
hw->curr_mac_addr[3],
|
|
hw->curr_mac_addr[4], hw->curr_mac_addr[5]);
|
|
} else {
|
|
|
|
/* Setup the receive address. */
|
|
DEBUGOUT("Overriding MAC Address in RAR[0]\n");
|
|
DEBUGOUT3(" New MAC Addr =%.2X %.2X %.2X ",
|
|
hw->curr_mac_addr[0],
|
|
hw->curr_mac_addr[1], hw->curr_mac_addr[2]);
|
|
DEBUGOUT3("%.2X %.2X %.2X\n",
|
|
hw->curr_mac_addr[3],
|
|
hw->curr_mac_addr[4], hw->curr_mac_addr[5]);
|
|
|
|
ixgb_rar_set(hw, hw->curr_mac_addr, 0);
|
|
}
|
|
|
|
/* Zero out the other 15 receive addresses. */
|
|
DEBUGOUT("Clearing RAR[1-15]\n");
|
|
for(i = 1; i < IXGB_RAR_ENTRIES; i++) {
|
|
/* Write high reg first to disable the AV bit first */
|
|
IXGB_WRITE_REG_ARRAY(hw, RA, ((i << 1) + 1), 0);
|
|
IXGB_WRITE_REG_ARRAY(hw, RA, (i << 1), 0);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Updates the MAC's list of multicast addresses.
|
|
*
|
|
* hw - Struct containing variables accessed by shared code
|
|
* mc_addr_list - the list of new multicast addresses
|
|
* mc_addr_count - number of addresses
|
|
* pad - number of bytes between addresses in the list
|
|
*
|
|
* The given list replaces any existing list. Clears the last 15 receive
|
|
* address registers and the multicast table. Uses receive address registers
|
|
* for the first 15 multicast addresses, and hashes the rest into the
|
|
* multicast table.
|
|
*****************************************************************************/
|
|
void
|
|
ixgb_mc_addr_list_update(struct ixgb_hw *hw,
|
|
uint8_t *mc_addr_list,
|
|
uint32_t mc_addr_count,
|
|
uint32_t pad)
|
|
{
|
|
uint32_t hash_value;
|
|
uint32_t i;
|
|
uint32_t rar_used_count = 1; /* RAR[0] is used for our MAC address */
|
|
|
|
DEBUGFUNC("ixgb_mc_addr_list_update");
|
|
|
|
/* Set the new number of MC addresses that we are being requested to use. */
|
|
hw->num_mc_addrs = mc_addr_count;
|
|
|
|
/* Clear RAR[1-15] */
|
|
DEBUGOUT(" Clearing RAR[1-15]\n");
|
|
for(i = rar_used_count; i < IXGB_RAR_ENTRIES; i++) {
|
|
IXGB_WRITE_REG_ARRAY(hw, RA, (i << 1), 0);
|
|
IXGB_WRITE_REG_ARRAY(hw, RA, ((i << 1) + 1), 0);
|
|
}
|
|
|
|
/* Clear the MTA */
|
|
DEBUGOUT(" Clearing MTA\n");
|
|
for(i = 0; i < IXGB_MC_TBL_SIZE; i++) {
|
|
IXGB_WRITE_REG_ARRAY(hw, MTA, i, 0);
|
|
}
|
|
|
|
/* Add the new addresses */
|
|
for(i = 0; i < mc_addr_count; i++) {
|
|
DEBUGOUT(" Adding the multicast addresses:\n");
|
|
DEBUGOUT7(" MC Addr #%d =%.2X %.2X %.2X %.2X %.2X %.2X\n", i,
|
|
mc_addr_list[i * (IXGB_ETH_LENGTH_OF_ADDRESS + pad)],
|
|
mc_addr_list[i * (IXGB_ETH_LENGTH_OF_ADDRESS + pad) +
|
|
1],
|
|
mc_addr_list[i * (IXGB_ETH_LENGTH_OF_ADDRESS + pad) +
|
|
2],
|
|
mc_addr_list[i * (IXGB_ETH_LENGTH_OF_ADDRESS + pad) +
|
|
3],
|
|
mc_addr_list[i * (IXGB_ETH_LENGTH_OF_ADDRESS + pad) +
|
|
4],
|
|
mc_addr_list[i * (IXGB_ETH_LENGTH_OF_ADDRESS + pad) +
|
|
5]);
|
|
|
|
/* Place this multicast address in the RAR if there is room, *
|
|
* else put it in the MTA
|
|
*/
|
|
if(rar_used_count < IXGB_RAR_ENTRIES) {
|
|
ixgb_rar_set(hw,
|
|
mc_addr_list +
|
|
(i * (IXGB_ETH_LENGTH_OF_ADDRESS + pad)),
|
|
rar_used_count);
|
|
DEBUGOUT1("Added a multicast address to RAR[%d]\n", i);
|
|
rar_used_count++;
|
|
} else {
|
|
hash_value = ixgb_hash_mc_addr(hw,
|
|
mc_addr_list +
|
|
(i *
|
|
(IXGB_ETH_LENGTH_OF_ADDRESS
|
|
+ pad)));
|
|
|
|
DEBUGOUT1(" Hash value = 0x%03X\n", hash_value);
|
|
|
|
ixgb_mta_set(hw, hash_value);
|
|
}
|
|
}
|
|
|
|
DEBUGOUT("MC Update Complete\n");
|
|
return;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Hashes an address to determine its location in the multicast table
|
|
*
|
|
* hw - Struct containing variables accessed by shared code
|
|
* mc_addr - the multicast address to hash
|
|
*
|
|
* Returns:
|
|
* The hash value
|
|
*****************************************************************************/
|
|
static uint32_t
|
|
ixgb_hash_mc_addr(struct ixgb_hw *hw,
|
|
uint8_t *mc_addr)
|
|
{
|
|
uint32_t hash_value = 0;
|
|
|
|
DEBUGFUNC("ixgb_hash_mc_addr");
|
|
|
|
/* The portion of the address that is used for the hash table is
|
|
* determined by the mc_filter_type setting.
|
|
*/
|
|
switch (hw->mc_filter_type) {
|
|
/* [0] [1] [2] [3] [4] [5]
|
|
* 01 AA 00 12 34 56
|
|
* LSB MSB - According to H/W docs */
|
|
case 0:
|
|
/* [47:36] i.e. 0x563 for above example address */
|
|
hash_value =
|
|
((mc_addr[4] >> 4) | (((uint16_t) mc_addr[5]) << 4));
|
|
break;
|
|
case 1: /* [46:35] i.e. 0xAC6 for above example address */
|
|
hash_value =
|
|
((mc_addr[4] >> 3) | (((uint16_t) mc_addr[5]) << 5));
|
|
break;
|
|
case 2: /* [45:34] i.e. 0x5D8 for above example address */
|
|
hash_value =
|
|
((mc_addr[4] >> 2) | (((uint16_t) mc_addr[5]) << 6));
|
|
break;
|
|
case 3: /* [43:32] i.e. 0x634 for above example address */
|
|
hash_value = ((mc_addr[4]) | (((uint16_t) mc_addr[5]) << 8));
|
|
break;
|
|
default:
|
|
/* Invalid mc_filter_type, what should we do? */
|
|
DEBUGOUT("MC filter type param set incorrectly\n");
|
|
ASSERT(0);
|
|
break;
|
|
}
|
|
|
|
hash_value &= 0xFFF;
|
|
return (hash_value);
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Sets the bit in the multicast table corresponding to the hash value.
|
|
*
|
|
* hw - Struct containing variables accessed by shared code
|
|
* hash_value - Multicast address hash value
|
|
*****************************************************************************/
|
|
static void
|
|
ixgb_mta_set(struct ixgb_hw *hw,
|
|
uint32_t hash_value)
|
|
{
|
|
uint32_t hash_bit, hash_reg;
|
|
uint32_t mta_reg;
|
|
|
|
/* The MTA is a register array of 128 32-bit registers.
|
|
* It is treated like an array of 4096 bits. We want to set
|
|
* bit BitArray[hash_value]. So we figure out what register
|
|
* the bit is in, read it, OR in the new bit, then write
|
|
* back the new value. The register is determined by the
|
|
* upper 7 bits of the hash value and the bit within that
|
|
* register are determined by the lower 5 bits of the value.
|
|
*/
|
|
hash_reg = (hash_value >> 5) & 0x7F;
|
|
hash_bit = hash_value & 0x1F;
|
|
|
|
mta_reg = IXGB_READ_REG_ARRAY(hw, MTA, hash_reg);
|
|
|
|
mta_reg |= (1 << hash_bit);
|
|
|
|
IXGB_WRITE_REG_ARRAY(hw, MTA, hash_reg, mta_reg);
|
|
|
|
return;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Puts an ethernet address into a receive address register.
|
|
*
|
|
* hw - Struct containing variables accessed by shared code
|
|
* addr - Address to put into receive address register
|
|
* index - Receive address register to write
|
|
*****************************************************************************/
|
|
void
|
|
ixgb_rar_set(struct ixgb_hw *hw,
|
|
uint8_t *addr,
|
|
uint32_t index)
|
|
{
|
|
uint32_t rar_low, rar_high;
|
|
|
|
DEBUGFUNC("ixgb_rar_set");
|
|
|
|
/* HW expects these in little endian so we reverse the byte order
|
|
* from network order (big endian) to little endian
|
|
*/
|
|
rar_low = ((uint32_t) addr[0] |
|
|
((uint32_t)addr[1] << 8) |
|
|
((uint32_t)addr[2] << 16) |
|
|
((uint32_t)addr[3] << 24));
|
|
|
|
rar_high = ((uint32_t) addr[4] |
|
|
((uint32_t)addr[5] << 8) |
|
|
IXGB_RAH_AV);
|
|
|
|
IXGB_WRITE_REG_ARRAY(hw, RA, (index << 1), rar_low);
|
|
IXGB_WRITE_REG_ARRAY(hw, RA, ((index << 1) + 1), rar_high);
|
|
return;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Writes a value to the specified offset in the VLAN filter table.
|
|
*
|
|
* hw - Struct containing variables accessed by shared code
|
|
* offset - Offset in VLAN filer table to write
|
|
* value - Value to write into VLAN filter table
|
|
*****************************************************************************/
|
|
void
|
|
ixgb_write_vfta(struct ixgb_hw *hw,
|
|
uint32_t offset,
|
|
uint32_t value)
|
|
{
|
|
IXGB_WRITE_REG_ARRAY(hw, VFTA, offset, value);
|
|
return;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Clears the VLAN filer table
|
|
*
|
|
* hw - Struct containing variables accessed by shared code
|
|
*****************************************************************************/
|
|
static void
|
|
ixgb_clear_vfta(struct ixgb_hw *hw)
|
|
{
|
|
uint32_t offset;
|
|
|
|
for(offset = 0; offset < IXGB_VLAN_FILTER_TBL_SIZE; offset++)
|
|
IXGB_WRITE_REG_ARRAY(hw, VFTA, offset, 0);
|
|
return;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Configures the flow control settings based on SW configuration.
|
|
*
|
|
* hw - Struct containing variables accessed by shared code
|
|
*****************************************************************************/
|
|
|
|
static boolean_t
|
|
ixgb_setup_fc(struct ixgb_hw *hw)
|
|
{
|
|
uint32_t ctrl_reg;
|
|
uint32_t pap_reg = 0; /* by default, assume no pause time */
|
|
boolean_t status = TRUE;
|
|
|
|
DEBUGFUNC("ixgb_setup_fc");
|
|
|
|
/* Get the current control reg 0 settings */
|
|
ctrl_reg = IXGB_READ_REG(hw, CTRL0);
|
|
|
|
/* Clear the Receive Pause Enable and Transmit Pause Enable bits */
|
|
ctrl_reg &= ~(IXGB_CTRL0_RPE | IXGB_CTRL0_TPE);
|
|
|
|
/* The possible values of the "flow_control" parameter are:
|
|
* 0: Flow control is completely disabled
|
|
* 1: Rx flow control is enabled (we can receive pause frames
|
|
* but not send pause frames).
|
|
* 2: Tx flow control is enabled (we can send pause frames
|
|
* but we do not support receiving pause frames).
|
|
* 3: Both Rx and TX flow control (symmetric) are enabled.
|
|
* other: Invalid.
|
|
*/
|
|
switch (hw->fc.type) {
|
|
case ixgb_fc_none: /* 0 */
|
|
/* Set CMDC bit to disable Rx Flow control */
|
|
ctrl_reg |= (IXGB_CTRL0_CMDC);
|
|
break;
|
|
case ixgb_fc_rx_pause: /* 1 */
|
|
/* RX Flow control is enabled, and TX Flow control is
|
|
* disabled.
|
|
*/
|
|
ctrl_reg |= (IXGB_CTRL0_RPE);
|
|
break;
|
|
case ixgb_fc_tx_pause: /* 2 */
|
|
/* TX Flow control is enabled, and RX Flow control is
|
|
* disabled, by a software over-ride.
|
|
*/
|
|
ctrl_reg |= (IXGB_CTRL0_TPE);
|
|
pap_reg = hw->fc.pause_time;
|
|
break;
|
|
case ixgb_fc_full: /* 3 */
|
|
/* Flow control (both RX and TX) is enabled by a software
|
|
* over-ride.
|
|
*/
|
|
ctrl_reg |= (IXGB_CTRL0_RPE | IXGB_CTRL0_TPE);
|
|
pap_reg = hw->fc.pause_time;
|
|
break;
|
|
default:
|
|
/* We should never get here. The value should be 0-3. */
|
|
DEBUGOUT("Flow control param set incorrectly\n");
|
|
ASSERT(0);
|
|
break;
|
|
}
|
|
|
|
/* Write the new settings */
|
|
IXGB_WRITE_REG(hw, CTRL0, ctrl_reg);
|
|
|
|
if (pap_reg != 0) {
|
|
IXGB_WRITE_REG(hw, PAP, pap_reg);
|
|
}
|
|
|
|
/* Set the flow control receive threshold registers. Normally,
|
|
* these registers will be set to a default threshold that may be
|
|
* adjusted later by the driver's runtime code. However, if the
|
|
* ability to transmit pause frames in not enabled, then these
|
|
* registers will be set to 0.
|
|
*/
|
|
if(!(hw->fc.type & ixgb_fc_tx_pause)) {
|
|
IXGB_WRITE_REG(hw, FCRTL, 0);
|
|
IXGB_WRITE_REG(hw, FCRTH, 0);
|
|
} else {
|
|
/* We need to set up the Receive Threshold high and low water
|
|
* marks as well as (optionally) enabling the transmission of XON
|
|
* frames. */
|
|
if(hw->fc.send_xon) {
|
|
IXGB_WRITE_REG(hw, FCRTL,
|
|
(hw->fc.low_water | IXGB_FCRTL_XONE));
|
|
} else {
|
|
IXGB_WRITE_REG(hw, FCRTL, hw->fc.low_water);
|
|
}
|
|
IXGB_WRITE_REG(hw, FCRTH, hw->fc.high_water);
|
|
}
|
|
return (status);
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Reads a word from a device over the Management Data Interface (MDI) bus.
|
|
* This interface is used to manage Physical layer devices.
|
|
*
|
|
* hw - Struct containing variables accessed by hw code
|
|
* reg_address - Offset of device register being read.
|
|
* phy_address - Address of device on MDI.
|
|
*
|
|
* Returns: Data word (16 bits) from MDI device.
|
|
*
|
|
* The 82597EX has support for several MDI access methods. This routine
|
|
* uses the new protocol MDI Single Command and Address Operation.
|
|
* This requires that first an address cycle command is sent, followed by a
|
|
* read command.
|
|
*****************************************************************************/
|
|
static uint16_t
|
|
ixgb_read_phy_reg(struct ixgb_hw *hw,
|
|
uint32_t reg_address,
|
|
uint32_t phy_address,
|
|
uint32_t device_type)
|
|
{
|
|
uint32_t i;
|
|
uint32_t data;
|
|
uint32_t command = 0;
|
|
|
|
ASSERT(reg_address <= IXGB_MAX_PHY_REG_ADDRESS);
|
|
ASSERT(phy_address <= IXGB_MAX_PHY_ADDRESS);
|
|
ASSERT(device_type <= IXGB_MAX_PHY_DEV_TYPE);
|
|
|
|
/* Setup and write the address cycle command */
|
|
command = ((reg_address << IXGB_MSCA_NP_ADDR_SHIFT) |
|
|
(device_type << IXGB_MSCA_DEV_TYPE_SHIFT) |
|
|
(phy_address << IXGB_MSCA_PHY_ADDR_SHIFT) |
|
|
(IXGB_MSCA_ADDR_CYCLE | IXGB_MSCA_MDI_COMMAND));
|
|
|
|
IXGB_WRITE_REG(hw, MSCA, command);
|
|
|
|
/**************************************************************
|
|
** Check every 10 usec to see if the address cycle completed
|
|
** The COMMAND bit will clear when the operation is complete.
|
|
** This may take as long as 64 usecs (we'll wait 100 usecs max)
|
|
** from the CPU Write to the Ready bit assertion.
|
|
**************************************************************/
|
|
|
|
for(i = 0; i < 10; i++)
|
|
{
|
|
udelay(10);
|
|
|
|
command = IXGB_READ_REG(hw, MSCA);
|
|
|
|
if ((command & IXGB_MSCA_MDI_COMMAND) == 0)
|
|
break;
|
|
}
|
|
|
|
ASSERT((command & IXGB_MSCA_MDI_COMMAND) == 0);
|
|
|
|
/* Address cycle complete, setup and write the read command */
|
|
command = ((reg_address << IXGB_MSCA_NP_ADDR_SHIFT) |
|
|
(device_type << IXGB_MSCA_DEV_TYPE_SHIFT) |
|
|
(phy_address << IXGB_MSCA_PHY_ADDR_SHIFT) |
|
|
(IXGB_MSCA_READ | IXGB_MSCA_MDI_COMMAND));
|
|
|
|
IXGB_WRITE_REG(hw, MSCA, command);
|
|
|
|
/**************************************************************
|
|
** Check every 10 usec to see if the read command completed
|
|
** The COMMAND bit will clear when the operation is complete.
|
|
** The read may take as long as 64 usecs (we'll wait 100 usecs max)
|
|
** from the CPU Write to the Ready bit assertion.
|
|
**************************************************************/
|
|
|
|
for(i = 0; i < 10; i++)
|
|
{
|
|
udelay(10);
|
|
|
|
command = IXGB_READ_REG(hw, MSCA);
|
|
|
|
if ((command & IXGB_MSCA_MDI_COMMAND) == 0)
|
|
break;
|
|
}
|
|
|
|
ASSERT((command & IXGB_MSCA_MDI_COMMAND) == 0);
|
|
|
|
/* Operation is complete, get the data from the MDIO Read/Write Data
|
|
* register and return.
|
|
*/
|
|
data = IXGB_READ_REG(hw, MSRWD);
|
|
data >>= IXGB_MSRWD_READ_DATA_SHIFT;
|
|
return((uint16_t) data);
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Writes a word to a device over the Management Data Interface (MDI) bus.
|
|
* This interface is used to manage Physical layer devices.
|
|
*
|
|
* hw - Struct containing variables accessed by hw code
|
|
* reg_address - Offset of device register being read.
|
|
* phy_address - Address of device on MDI.
|
|
* device_type - Also known as the Device ID or DID.
|
|
* data - 16-bit value to be written
|
|
*
|
|
* Returns: void.
|
|
*
|
|
* The 82597EX has support for several MDI access methods. This routine
|
|
* uses the new protocol MDI Single Command and Address Operation.
|
|
* This requires that first an address cycle command is sent, followed by a
|
|
* write command.
|
|
*****************************************************************************/
|
|
static void
|
|
ixgb_write_phy_reg(struct ixgb_hw *hw,
|
|
uint32_t reg_address,
|
|
uint32_t phy_address,
|
|
uint32_t device_type,
|
|
uint16_t data)
|
|
{
|
|
uint32_t i;
|
|
uint32_t command = 0;
|
|
|
|
ASSERT(reg_address <= IXGB_MAX_PHY_REG_ADDRESS);
|
|
ASSERT(phy_address <= IXGB_MAX_PHY_ADDRESS);
|
|
ASSERT(device_type <= IXGB_MAX_PHY_DEV_TYPE);
|
|
|
|
/* Put the data in the MDIO Read/Write Data register */
|
|
IXGB_WRITE_REG(hw, MSRWD, (uint32_t)data);
|
|
|
|
/* Setup and write the address cycle command */
|
|
command = ((reg_address << IXGB_MSCA_NP_ADDR_SHIFT) |
|
|
(device_type << IXGB_MSCA_DEV_TYPE_SHIFT) |
|
|
(phy_address << IXGB_MSCA_PHY_ADDR_SHIFT) |
|
|
(IXGB_MSCA_ADDR_CYCLE | IXGB_MSCA_MDI_COMMAND));
|
|
|
|
IXGB_WRITE_REG(hw, MSCA, command);
|
|
|
|
/**************************************************************
|
|
** Check every 10 usec to see if the address cycle completed
|
|
** The COMMAND bit will clear when the operation is complete.
|
|
** This may take as long as 64 usecs (we'll wait 100 usecs max)
|
|
** from the CPU Write to the Ready bit assertion.
|
|
**************************************************************/
|
|
|
|
for(i = 0; i < 10; i++)
|
|
{
|
|
udelay(10);
|
|
|
|
command = IXGB_READ_REG(hw, MSCA);
|
|
|
|
if ((command & IXGB_MSCA_MDI_COMMAND) == 0)
|
|
break;
|
|
}
|
|
|
|
ASSERT((command & IXGB_MSCA_MDI_COMMAND) == 0);
|
|
|
|
/* Address cycle complete, setup and write the write command */
|
|
command = ((reg_address << IXGB_MSCA_NP_ADDR_SHIFT) |
|
|
(device_type << IXGB_MSCA_DEV_TYPE_SHIFT) |
|
|
(phy_address << IXGB_MSCA_PHY_ADDR_SHIFT) |
|
|
(IXGB_MSCA_WRITE | IXGB_MSCA_MDI_COMMAND));
|
|
|
|
IXGB_WRITE_REG(hw, MSCA, command);
|
|
|
|
/**************************************************************
|
|
** Check every 10 usec to see if the read command completed
|
|
** The COMMAND bit will clear when the operation is complete.
|
|
** The write may take as long as 64 usecs (we'll wait 100 usecs max)
|
|
** from the CPU Write to the Ready bit assertion.
|
|
**************************************************************/
|
|
|
|
for(i = 0; i < 10; i++)
|
|
{
|
|
udelay(10);
|
|
|
|
command = IXGB_READ_REG(hw, MSCA);
|
|
|
|
if ((command & IXGB_MSCA_MDI_COMMAND) == 0)
|
|
break;
|
|
}
|
|
|
|
ASSERT((command & IXGB_MSCA_MDI_COMMAND) == 0);
|
|
|
|
/* Operation is complete, return. */
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Checks to see if the link status of the hardware has changed.
|
|
*
|
|
* hw - Struct containing variables accessed by hw code
|
|
*
|
|
* Called by any function that needs to check the link status of the adapter.
|
|
*****************************************************************************/
|
|
void
|
|
ixgb_check_for_link(struct ixgb_hw *hw)
|
|
{
|
|
uint32_t status_reg;
|
|
uint32_t xpcss_reg;
|
|
|
|
DEBUGFUNC("ixgb_check_for_link");
|
|
|
|
xpcss_reg = IXGB_READ_REG(hw, XPCSS);
|
|
status_reg = IXGB_READ_REG(hw, STATUS);
|
|
|
|
if ((xpcss_reg & IXGB_XPCSS_ALIGN_STATUS) &&
|
|
(status_reg & IXGB_STATUS_LU)) {
|
|
hw->link_up = TRUE;
|
|
} else if (!(xpcss_reg & IXGB_XPCSS_ALIGN_STATUS) &&
|
|
(status_reg & IXGB_STATUS_LU)) {
|
|
DEBUGOUT("XPCSS Not Aligned while Status:LU is set.\n");
|
|
hw->link_up = ixgb_link_reset(hw);
|
|
} else {
|
|
/*
|
|
* 82597EX errata. Since the lane deskew problem may prevent
|
|
* link, reset the link before reporting link down.
|
|
*/
|
|
hw->link_up = ixgb_link_reset(hw);
|
|
}
|
|
/* Anything else for 10 Gig?? */
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Check for a bad link condition that may have occured.
|
|
* The indication is that the RFC / LFC registers may be incrementing
|
|
* continually. A full adapter reset is required to recover.
|
|
*
|
|
* hw - Struct containing variables accessed by hw code
|
|
*
|
|
* Called by any function that needs to check the link status of the adapter.
|
|
*****************************************************************************/
|
|
boolean_t ixgb_check_for_bad_link(struct ixgb_hw *hw)
|
|
{
|
|
uint32_t newLFC, newRFC;
|
|
boolean_t bad_link_returncode = FALSE;
|
|
|
|
if (hw->phy_type == ixgb_phy_type_txn17401) {
|
|
newLFC = IXGB_READ_REG(hw, LFC);
|
|
newRFC = IXGB_READ_REG(hw, RFC);
|
|
if ((hw->lastLFC + 250 < newLFC)
|
|
|| (hw->lastRFC + 250 < newRFC)) {
|
|
DEBUGOUT
|
|
("BAD LINK! too many LFC/RFC since last check\n");
|
|
bad_link_returncode = TRUE;
|
|
}
|
|
hw->lastLFC = newLFC;
|
|
hw->lastRFC = newRFC;
|
|
}
|
|
|
|
return bad_link_returncode;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Clears all hardware statistics counters.
|
|
*
|
|
* hw - Struct containing variables accessed by shared code
|
|
*****************************************************************************/
|
|
static void
|
|
ixgb_clear_hw_cntrs(struct ixgb_hw *hw)
|
|
{
|
|
volatile uint32_t temp_reg;
|
|
|
|
DEBUGFUNC("ixgb_clear_hw_cntrs");
|
|
|
|
/* if we are stopped or resetting exit gracefully */
|
|
if(hw->adapter_stopped) {
|
|
DEBUGOUT("Exiting because the adapter is stopped!!!\n");
|
|
return;
|
|
}
|
|
|
|
temp_reg = IXGB_READ_REG(hw, TPRL);
|
|
temp_reg = IXGB_READ_REG(hw, TPRH);
|
|
temp_reg = IXGB_READ_REG(hw, GPRCL);
|
|
temp_reg = IXGB_READ_REG(hw, GPRCH);
|
|
temp_reg = IXGB_READ_REG(hw, BPRCL);
|
|
temp_reg = IXGB_READ_REG(hw, BPRCH);
|
|
temp_reg = IXGB_READ_REG(hw, MPRCL);
|
|
temp_reg = IXGB_READ_REG(hw, MPRCH);
|
|
temp_reg = IXGB_READ_REG(hw, UPRCL);
|
|
temp_reg = IXGB_READ_REG(hw, UPRCH);
|
|
temp_reg = IXGB_READ_REG(hw, VPRCL);
|
|
temp_reg = IXGB_READ_REG(hw, VPRCH);
|
|
temp_reg = IXGB_READ_REG(hw, JPRCL);
|
|
temp_reg = IXGB_READ_REG(hw, JPRCH);
|
|
temp_reg = IXGB_READ_REG(hw, GORCL);
|
|
temp_reg = IXGB_READ_REG(hw, GORCH);
|
|
temp_reg = IXGB_READ_REG(hw, TORL);
|
|
temp_reg = IXGB_READ_REG(hw, TORH);
|
|
temp_reg = IXGB_READ_REG(hw, RNBC);
|
|
temp_reg = IXGB_READ_REG(hw, RUC);
|
|
temp_reg = IXGB_READ_REG(hw, ROC);
|
|
temp_reg = IXGB_READ_REG(hw, RLEC);
|
|
temp_reg = IXGB_READ_REG(hw, CRCERRS);
|
|
temp_reg = IXGB_READ_REG(hw, ICBC);
|
|
temp_reg = IXGB_READ_REG(hw, ECBC);
|
|
temp_reg = IXGB_READ_REG(hw, MPC);
|
|
temp_reg = IXGB_READ_REG(hw, TPTL);
|
|
temp_reg = IXGB_READ_REG(hw, TPTH);
|
|
temp_reg = IXGB_READ_REG(hw, GPTCL);
|
|
temp_reg = IXGB_READ_REG(hw, GPTCH);
|
|
temp_reg = IXGB_READ_REG(hw, BPTCL);
|
|
temp_reg = IXGB_READ_REG(hw, BPTCH);
|
|
temp_reg = IXGB_READ_REG(hw, MPTCL);
|
|
temp_reg = IXGB_READ_REG(hw, MPTCH);
|
|
temp_reg = IXGB_READ_REG(hw, UPTCL);
|
|
temp_reg = IXGB_READ_REG(hw, UPTCH);
|
|
temp_reg = IXGB_READ_REG(hw, VPTCL);
|
|
temp_reg = IXGB_READ_REG(hw, VPTCH);
|
|
temp_reg = IXGB_READ_REG(hw, JPTCL);
|
|
temp_reg = IXGB_READ_REG(hw, JPTCH);
|
|
temp_reg = IXGB_READ_REG(hw, GOTCL);
|
|
temp_reg = IXGB_READ_REG(hw, GOTCH);
|
|
temp_reg = IXGB_READ_REG(hw, TOTL);
|
|
temp_reg = IXGB_READ_REG(hw, TOTH);
|
|
temp_reg = IXGB_READ_REG(hw, DC);
|
|
temp_reg = IXGB_READ_REG(hw, PLT64C);
|
|
temp_reg = IXGB_READ_REG(hw, TSCTC);
|
|
temp_reg = IXGB_READ_REG(hw, TSCTFC);
|
|
temp_reg = IXGB_READ_REG(hw, IBIC);
|
|
temp_reg = IXGB_READ_REG(hw, RFC);
|
|
temp_reg = IXGB_READ_REG(hw, LFC);
|
|
temp_reg = IXGB_READ_REG(hw, PFRC);
|
|
temp_reg = IXGB_READ_REG(hw, PFTC);
|
|
temp_reg = IXGB_READ_REG(hw, MCFRC);
|
|
temp_reg = IXGB_READ_REG(hw, MCFTC);
|
|
temp_reg = IXGB_READ_REG(hw, XONRXC);
|
|
temp_reg = IXGB_READ_REG(hw, XONTXC);
|
|
temp_reg = IXGB_READ_REG(hw, XOFFRXC);
|
|
temp_reg = IXGB_READ_REG(hw, XOFFTXC);
|
|
temp_reg = IXGB_READ_REG(hw, RJC);
|
|
return;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Turns on the software controllable LED
|
|
*
|
|
* hw - Struct containing variables accessed by shared code
|
|
*****************************************************************************/
|
|
void
|
|
ixgb_led_on(struct ixgb_hw *hw)
|
|
{
|
|
uint32_t ctrl0_reg = IXGB_READ_REG(hw, CTRL0);
|
|
|
|
/* To turn on the LED, clear software-definable pin 0 (SDP0). */
|
|
ctrl0_reg &= ~IXGB_CTRL0_SDP0;
|
|
IXGB_WRITE_REG(hw, CTRL0, ctrl0_reg);
|
|
return;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Turns off the software controllable LED
|
|
*
|
|
* hw - Struct containing variables accessed by shared code
|
|
*****************************************************************************/
|
|
void
|
|
ixgb_led_off(struct ixgb_hw *hw)
|
|
{
|
|
uint32_t ctrl0_reg = IXGB_READ_REG(hw, CTRL0);
|
|
|
|
/* To turn off the LED, set software-definable pin 0 (SDP0). */
|
|
ctrl0_reg |= IXGB_CTRL0_SDP0;
|
|
IXGB_WRITE_REG(hw, CTRL0, ctrl0_reg);
|
|
return;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Gets the current PCI bus type, speed, and width of the hardware
|
|
*
|
|
* hw - Struct containing variables accessed by shared code
|
|
*****************************************************************************/
|
|
static void
|
|
ixgb_get_bus_info(struct ixgb_hw *hw)
|
|
{
|
|
uint32_t status_reg;
|
|
|
|
status_reg = IXGB_READ_REG(hw, STATUS);
|
|
|
|
hw->bus.type = (status_reg & IXGB_STATUS_PCIX_MODE) ?
|
|
ixgb_bus_type_pcix : ixgb_bus_type_pci;
|
|
|
|
if (hw->bus.type == ixgb_bus_type_pci) {
|
|
hw->bus.speed = (status_reg & IXGB_STATUS_PCI_SPD) ?
|
|
ixgb_bus_speed_66 : ixgb_bus_speed_33;
|
|
} else {
|
|
switch (status_reg & IXGB_STATUS_PCIX_SPD_MASK) {
|
|
case IXGB_STATUS_PCIX_SPD_66:
|
|
hw->bus.speed = ixgb_bus_speed_66;
|
|
break;
|
|
case IXGB_STATUS_PCIX_SPD_100:
|
|
hw->bus.speed = ixgb_bus_speed_100;
|
|
break;
|
|
case IXGB_STATUS_PCIX_SPD_133:
|
|
hw->bus.speed = ixgb_bus_speed_133;
|
|
break;
|
|
default:
|
|
hw->bus.speed = ixgb_bus_speed_reserved;
|
|
break;
|
|
}
|
|
}
|
|
|
|
hw->bus.width = (status_reg & IXGB_STATUS_BUS64) ?
|
|
ixgb_bus_width_64 : ixgb_bus_width_32;
|
|
|
|
return;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Tests a MAC address to ensure it is a valid Individual Address
|
|
*
|
|
* mac_addr - pointer to MAC address.
|
|
*
|
|
*****************************************************************************/
|
|
static boolean_t
|
|
mac_addr_valid(uint8_t *mac_addr)
|
|
{
|
|
boolean_t is_valid = TRUE;
|
|
DEBUGFUNC("mac_addr_valid");
|
|
|
|
/* Make sure it is not a multicast address */
|
|
if (IS_MULTICAST(mac_addr)) {
|
|
DEBUGOUT("MAC address is multicast\n");
|
|
is_valid = FALSE;
|
|
}
|
|
/* Not a broadcast address */
|
|
else if (IS_BROADCAST(mac_addr)) {
|
|
DEBUGOUT("MAC address is broadcast\n");
|
|
is_valid = FALSE;
|
|
}
|
|
/* Reject the zero address */
|
|
else if (mac_addr[0] == 0 &&
|
|
mac_addr[1] == 0 &&
|
|
mac_addr[2] == 0 &&
|
|
mac_addr[3] == 0 &&
|
|
mac_addr[4] == 0 &&
|
|
mac_addr[5] == 0) {
|
|
DEBUGOUT("MAC address is all zeros\n");
|
|
is_valid = FALSE;
|
|
}
|
|
return (is_valid);
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Resets the 10GbE link. Waits the settle time and returns the state of
|
|
* the link.
|
|
*
|
|
* hw - Struct containing variables accessed by shared code
|
|
*****************************************************************************/
|
|
boolean_t
|
|
ixgb_link_reset(struct ixgb_hw *hw)
|
|
{
|
|
boolean_t link_status = FALSE;
|
|
uint8_t wait_retries = MAX_RESET_ITERATIONS;
|
|
uint8_t lrst_retries = MAX_RESET_ITERATIONS;
|
|
|
|
do {
|
|
/* Reset the link */
|
|
IXGB_WRITE_REG(hw, CTRL0,
|
|
IXGB_READ_REG(hw, CTRL0) | IXGB_CTRL0_LRST);
|
|
|
|
/* Wait for link-up and lane re-alignment */
|
|
do {
|
|
udelay(IXGB_DELAY_USECS_AFTER_LINK_RESET);
|
|
link_status =
|
|
((IXGB_READ_REG(hw, STATUS) & IXGB_STATUS_LU)
|
|
&& (IXGB_READ_REG(hw, XPCSS) &
|
|
IXGB_XPCSS_ALIGN_STATUS)) ? TRUE : FALSE;
|
|
} while (!link_status && --wait_retries);
|
|
|
|
} while (!link_status && --lrst_retries);
|
|
|
|
return link_status;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Resets the 10GbE optics module.
|
|
*
|
|
* hw - Struct containing variables accessed by shared code
|
|
*****************************************************************************/
|
|
void
|
|
ixgb_optics_reset(struct ixgb_hw *hw)
|
|
{
|
|
if (hw->phy_type == ixgb_phy_type_txn17401) {
|
|
uint16_t mdio_reg;
|
|
|
|
ixgb_write_phy_reg(hw,
|
|
MDIO_PMA_PMD_CR1,
|
|
IXGB_PHY_ADDRESS,
|
|
MDIO_PMA_PMD_DID,
|
|
MDIO_PMA_PMD_CR1_RESET);
|
|
|
|
mdio_reg = ixgb_read_phy_reg( hw,
|
|
MDIO_PMA_PMD_CR1,
|
|
IXGB_PHY_ADDRESS,
|
|
MDIO_PMA_PMD_DID);
|
|
}
|
|
|
|
return;
|
|
}
|