Skip to content

L
linux
Commit ca247341 authored by Jeff Garzik's avatar Jeff Garzik
Browse files
Options

[netdrvr ixgb] Lindent, then fix up obvious indent uglies by hand

parent d2f797b0
Hide whitespace changes
Inline Side-by-side
Showing with 2121 additions and 2184 deletions
drivers/net/ixgb/ixgb.h
View file @ ca247341
...@@ -64,16 +64,14 @@ struct ixgb_adapter; ...@@ -64,16 +64,14 @@ struct ixgb_adapter;
#define BAR_0 0 #define BAR_0 0
#define BAR_1 1 #define BAR_1 1
#define BAR_5 5 #define BAR_5 5
#define PCI_DMA_64BIT 0xffffffffffffffffULL #define PCI_DMA_64BIT 0xffffffffffffffffULL
#define PCI_DMA_32BIT 0x00000000ffffffffULL #define PCI_DMA_32BIT 0x00000000ffffffffULL
#include "ixgb_hw.h" #include "ixgb_hw.h"
#include "ixgb_ee.h" #include "ixgb_ee.h"
#include "ixgb_ids.h" #include "ixgb_ids.h"
#if _DEBUG_DRIVER_ #if _DEBUG_DRIVER_
#define IXGB_DBG(args...) printk(KERN_DEBUG "ixgb: " args) #define IXGB_DBG(args...) printk(KERN_DEBUG "ixgb: " args)
#else #else
...@@ -100,27 +98,27 @@ struct ixgb_adapter; ...@@ -100,27 +98,27 @@ struct ixgb_adapter;
/* wrapper around a pointer to a socket buffer, /* wrapper around a pointer to a socket buffer,
* so a DMA handle can be stored along with the buffer */ * so a DMA handle can be stored along with the buffer */
struct ixgb_buffer { struct ixgb_buffer {
struct sk_buff *skb; struct sk_buff *skb;
uint64_t dma; uint64_t dma;
unsigned long length; unsigned long length;
unsigned long time_stamp; unsigned long time_stamp;
}; };
struct ixgb_desc_ring { struct ixgb_desc_ring {
/* pointer to the descriptor ring memory */ /* pointer to the descriptor ring memory */
void *desc; void *desc;
/* physical address of the descriptor ring */ /* physical address of the descriptor ring */
dma_addr_t dma; dma_addr_t dma;
/* length of descriptor ring in bytes */ /* length of descriptor ring in bytes */
unsigned int size; unsigned int size;
/* number of descriptors in the ring */ /* number of descriptors in the ring */
unsigned int count; unsigned int count;
/* next descriptor to associate a buffer with */ /* next descriptor to associate a buffer with */
unsigned int next_to_use; unsigned int next_to_use;
/* next descriptor to check for DD status bit */ /* next descriptor to check for DD status bit */
unsigned int next_to_clean; unsigned int next_to_clean;
/* array of buffer information structs */ /* array of buffer information structs */
struct ixgb_buffer *buffer_info; struct ixgb_buffer *buffer_info;
}; };
#define IXGB_DESC_UNUSED(R) \ #define IXGB_DESC_UNUSED(R) \
...@@ -134,54 +132,54 @@ struct ixgb_desc_ring { ...@@ -134,54 +132,54 @@ struct ixgb_desc_ring {
/* board specific private data structure */ /* board specific private data structure */
struct ixgb_adapter { struct ixgb_adapter {
struct timer_list watchdog_timer; struct timer_list watchdog_timer;
struct vlan_group *vlgrp; struct vlan_group *vlgrp;
char *id_string; char *id_string;
uint32_t bd_number; uint32_t bd_number;
uint32_t rx_buffer_len; uint32_t rx_buffer_len;
uint32_t part_num; uint32_t part_num;
uint16_t link_speed; uint16_t link_speed;
uint16_t link_duplex; uint16_t link_duplex;
atomic_t irq_sem; atomic_t irq_sem;
struct work_struct tx_timeout_task; struct work_struct tx_timeout_task;
#ifdef ETHTOOL_PHYS_ID #ifdef ETHTOOL_PHYS_ID
struct timer_list blink_timer; struct timer_list blink_timer;
unsigned long led_status; unsigned long led_status;
#endif #endif
#ifdef _INTERNAL_LOOPBACK_DRIVER_ #ifdef _INTERNAL_LOOPBACK_DRIVER_
struct ixgb_desc_ring diag_tx_ring; struct ixgb_desc_ring diag_tx_ring;
struct ixgb_desc_ring diag_rx_ring; struct ixgb_desc_ring diag_rx_ring;
#endif #endif
/* TX */ /* TX */
struct ixgb_desc_ring tx_ring; struct ixgb_desc_ring tx_ring;
unsigned long timeo_start; unsigned long timeo_start;
uint32_t tx_cmd_type; uint32_t tx_cmd_type;
int max_data_per_txd; int max_data_per_txd;
uint64_t hw_csum_tx_good; uint64_t hw_csum_tx_good;
uint64_t hw_csum_tx_error; uint64_t hw_csum_tx_error;
boolean_t tx_csum; boolean_t tx_csum;
uint32_t tx_int_delay; uint32_t tx_int_delay;
boolean_t tx_int_delay_enable; boolean_t tx_int_delay_enable;
/* RX */ /* RX */
struct ixgb_desc_ring rx_ring; struct ixgb_desc_ring rx_ring;
uint64_t hw_csum_rx_error; uint64_t hw_csum_rx_error;
uint64_t hw_csum_rx_good; uint64_t hw_csum_rx_good;
uint32_t rx_int_delay; uint32_t rx_int_delay;
boolean_t raidc; boolean_t raidc;
boolean_t rx_csum; boolean_t rx_csum;
/* OS defined structs */ /* OS defined structs */
struct net_device *netdev; struct net_device *netdev;
struct pci_dev *pdev; struct pci_dev *pdev;
struct net_device_stats net_stats; struct net_device_stats net_stats;
/* structs defined in ixgb_hw.h */ /* structs defined in ixgb_hw.h */
struct ixgb_hw hw; struct ixgb_hw hw;
struct ixgb_hw_stats stats; struct ixgb_hw_stats stats;
uint32_t pci_state[16]; uint32_t pci_state[16];
char ifname[IFNAMSIZ]; char ifname[IFNAMSIZ];
}; };
#endif /* _IXGB_H_ */ #endif /* _IXGB_H_ */
drivers/net/ixgb/ixgb_ee.c
View file @ ca247341
...@@ -25,15 +25,13 @@ ...@@ -25,15 +25,13 @@
Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497 Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
*******************************************************************************/ *******************************************************************************/
#include "ixgb_hw.h" #include "ixgb_hw.h"
#include "ixgb_ee.h" #include "ixgb_ee.h"
/* Local prototypes */ /* Local prototypes */
static uint16_t ixgb_shift_in_bits(struct ixgb_hw *hw); static uint16_t ixgb_shift_in_bits(struct ixgb_hw *hw);
static void ixgb_shift_out_bits(struct ixgb_hw *hw, static void ixgb_shift_out_bits(struct ixgb_hw *hw,
uint16_t data, uint16_t data, uint16_t count);
uint16_t count);
static void ixgb_standby_eeprom(struct ixgb_hw *hw); static void ixgb_standby_eeprom(struct ixgb_hw *hw);
static boolean_t ixgb_wait_eeprom_command(struct ixgb_hw *hw); static boolean_t ixgb_wait_eeprom_command(struct ixgb_hw *hw);
...@@ -47,16 +45,15 @@ static void ixgb_cleanup_eeprom(struct ixgb_hw *hw); ...@@ -47,16 +45,15 @@ static void ixgb_cleanup_eeprom(struct ixgb_hw *hw);
* eecd_reg - EECD's current value * eecd_reg - EECD's current value
*****************************************************************************/ *****************************************************************************/
static void static void
ixgb_raise_clock(struct ixgb_hw *hw, ixgb_raise_clock(struct ixgb_hw *hw, uint32_t * eecd_reg)
uint32_t *eecd_reg)
{ {
/* Raise the clock input to the EEPROM (by setting the SK bit), and then /* Raise the clock input to the EEPROM (by setting the SK bit), and then
* wait 50 microseconds. * wait 50 microseconds.
*/ */
*eecd_reg = *eecd_reg | IXGB_EECD_SK; *eecd_reg = *eecd_reg | IXGB_EECD_SK;
IXGB_WRITE_REG(hw, EECD, *eecd_reg); IXGB_WRITE_REG(hw, EECD, *eecd_reg);
usec_delay(50); usec_delay(50);
return; return;
} }
/****************************************************************************** /******************************************************************************
...@@ -66,16 +63,15 @@ ixgb_raise_clock(struct ixgb_hw *hw, ...@@ -66,16 +63,15 @@ ixgb_raise_clock(struct ixgb_hw *hw,
* eecd_reg - EECD's current value * eecd_reg - EECD's current value
*****************************************************************************/ *****************************************************************************/
static void static void
ixgb_lower_clock(struct ixgb_hw *hw, ixgb_lower_clock(struct ixgb_hw *hw, uint32_t * eecd_reg)
uint32_t *eecd_reg)
{ {
/* Lower the clock input to the EEPROM (by clearing the SK bit), and then /* Lower the clock input to the EEPROM (by clearing the SK bit), and then
* wait 50 microseconds. * wait 50 microseconds.
*/ */
*eecd_reg = *eecd_reg & ~IXGB_EECD_SK; *eecd_reg = *eecd_reg & ~IXGB_EECD_SK;
IXGB_WRITE_REG(hw, EECD, *eecd_reg); IXGB_WRITE_REG(hw, EECD, *eecd_reg);
usec_delay(50); usec_delay(50);
return; return;
} }
/****************************************************************************** /******************************************************************************
...@@ -86,46 +82,44 @@ ixgb_lower_clock(struct ixgb_hw *hw, ...@@ -86,46 +82,44 @@ ixgb_lower_clock(struct ixgb_hw *hw,
* count - number of bits to shift out * count - number of bits to shift out
*****************************************************************************/ *****************************************************************************/
static void static void
ixgb_shift_out_bits(struct ixgb_hw *hw, ixgb_shift_out_bits(struct ixgb_hw *hw, uint16_t data, uint16_t count)
uint16_t data,
uint16_t count)
{ {
uint32_t eecd_reg; uint32_t eecd_reg;
uint32_t mask; uint32_t mask;
/* We need to shift "count" bits out to the EEPROM. So, value in the /* We need to shift "count" bits out to the EEPROM. So, value in the
* "data" parameter will be shifted out to the EEPROM one bit at a time. * "data" parameter will be shifted out to the EEPROM one bit at a time.
* In order to do this, "data" must be broken down into bits. * In order to do this, "data" must be broken down into bits.
*/ */
mask = 0x01 << (count - 1); mask = 0x01 << (count - 1);
eecd_reg = IXGB_READ_REG(hw, EECD); eecd_reg = IXGB_READ_REG(hw, EECD);
eecd_reg &= ~(IXGB_EECD_DO | IXGB_EECD_DI); eecd_reg &= ~(IXGB_EECD_DO | IXGB_EECD_DI);
do { do {
/* A "1" is shifted out to the EEPROM by setting bit "DI" to a "1", /* A "1" is shifted out to the EEPROM by setting bit "DI" to a "1",
* and then raising and then lowering the clock (the SK bit controls * and then raising and then lowering the clock (the SK bit controls
* the clock input to the EEPROM). A "0" is shifted out to the EEPROM * the clock input to the EEPROM). A "0" is shifted out to the EEPROM
* by setting "DI" to "0" and then raising and then lowering the clock. * by setting "DI" to "0" and then raising and then lowering the clock.
*/ */
eecd_reg &= ~IXGB_EECD_DI; eecd_reg &= ~IXGB_EECD_DI;
if(data & mask) if (data & mask)
eecd_reg |= IXGB_EECD_DI; eecd_reg |= IXGB_EECD_DI;
IXGB_WRITE_REG(hw, EECD, eecd_reg); IXGB_WRITE_REG(hw, EECD, eecd_reg);
usec_delay(50); usec_delay(50);
ixgb_raise_clock(hw, &eecd_reg); ixgb_raise_clock(hw, &eecd_reg);
ixgb_lower_clock(hw, &eecd_reg); ixgb_lower_clock(hw, &eecd_reg);
mask = mask >> 1; mask = mask >> 1;
} while(mask); } while (mask);
/* We leave the "DI" bit set to "0" when we leave this routine. */ /* We leave the "DI" bit set to "0" when we leave this routine. */
eecd_reg &= ~IXGB_EECD_DI; eecd_reg &= ~IXGB_EECD_DI;
IXGB_WRITE_REG(hw, EECD, eecd_reg); IXGB_WRITE_REG(hw, EECD, eecd_reg);
return; return;
} }
/****************************************************************************** /******************************************************************************
...@@ -136,36 +130,36 @@ ixgb_shift_out_bits(struct ixgb_hw *hw, ...@@ -136,36 +130,36 @@ ixgb_shift_out_bits(struct ixgb_hw *hw,
static uint16_t static uint16_t
ixgb_shift_in_bits(struct ixgb_hw *hw) ixgb_shift_in_bits(struct ixgb_hw *hw)
{ {
uint32_t eecd_reg; uint32_t eecd_reg;
uint32_t i; uint32_t i;
uint16_t data; uint16_t data;
/* In order to read a register from the EEPROM, we need to shift 16 bits /* In order to read a register from the EEPROM, we need to shift 16 bits
* in from the EEPROM. Bits are "shifted in" by raising the clock input to * in from the EEPROM. Bits are "shifted in" by raising the clock input to
* the EEPROM (setting the SK bit), and then reading the value of the "DO" * the EEPROM (setting the SK bit), and then reading the value of the "DO"
* bit. During this "shifting in" process the "DI" bit should always be * bit. During this "shifting in" process the "DI" bit should always be
* clear.. * clear..
*/ */
eecd_reg = IXGB_READ_REG(hw, EECD); eecd_reg = IXGB_READ_REG(hw, EECD);
eecd_reg &= ~(IXGB_EECD_DO | IXGB_EECD_DI); eecd_reg &= ~(IXGB_EECD_DO | IXGB_EECD_DI);
data = 0; data = 0;
for(i = 0; i < 16; i++) { for (i = 0; i < 16; i++) {
data = data << 1; data = data << 1;
ixgb_raise_clock(hw, &eecd_reg); ixgb_raise_clock(hw, &eecd_reg);
eecd_reg = IXGB_READ_REG(hw, EECD); eecd_reg = IXGB_READ_REG(hw, EECD);
eecd_reg &= ~(IXGB_EECD_DI); eecd_reg &= ~(IXGB_EECD_DI);
if(eecd_reg & IXGB_EECD_DO) if (eecd_reg & IXGB_EECD_DO)
data |= 1; data |= 1;
ixgb_lower_clock(hw, &eecd_reg); ixgb_lower_clock(hw, &eecd_reg);
} }
return data; return data;
} }
/****************************************************************************** /******************************************************************************
...@@ -179,18 +173,18 @@ ixgb_shift_in_bits(struct ixgb_hw *hw) ...@@ -179,18 +173,18 @@ ixgb_shift_in_bits(struct ixgb_hw *hw)
static void static void
ixgb_setup_eeprom(struct ixgb_hw *hw) ixgb_setup_eeprom(struct ixgb_hw *hw)
{ {
uint32_t eecd_reg; uint32_t eecd_reg;
eecd_reg = IXGB_READ_REG(hw, EECD); eecd_reg = IXGB_READ_REG(hw, EECD);
/* Clear SK and DI */ /* Clear SK and DI */
eecd_reg &= ~(IXGB_EECD_SK | IXGB_EECD_DI); eecd_reg &= ~(IXGB_EECD_SK | IXGB_EECD_DI);
IXGB_WRITE_REG(hw, EECD, eecd_reg); IXGB_WRITE_REG(hw, EECD, eecd_reg);
/* Set CS */ /* Set CS */
eecd_reg |= IXGB_EECD_CS; eecd_reg |= IXGB_EECD_CS;
IXGB_WRITE_REG(hw, EECD, eecd_reg); IXGB_WRITE_REG(hw, EECD, eecd_reg);
return; return;
} }
/****************************************************************************** /******************************************************************************
...@@ -201,30 +195,30 @@ ixgb_setup_eeprom(struct ixgb_hw *hw) ...@@ -201,30 +195,30 @@ ixgb_setup_eeprom(struct ixgb_hw *hw)
static void static void
ixgb_standby_eeprom(struct ixgb_hw *hw) ixgb_standby_eeprom(struct ixgb_hw *hw)
{ {
uint32_t eecd_reg; uint32_t eecd_reg;
eecd_reg = IXGB_READ_REG(hw, EECD); eecd_reg = IXGB_READ_REG(hw, EECD);
/* Deselct EEPROM */ /* Deselct EEPROM */
eecd_reg &= ~(IXGB_EECD_CS | IXGB_EECD_SK); eecd_reg &= ~(IXGB_EECD_CS | IXGB_EECD_SK);
IXGB_WRITE_REG(hw, EECD, eecd_reg); IXGB_WRITE_REG(hw, EECD, eecd_reg);
usec_delay(50); usec_delay(50);
/* Clock high */ /* Clock high */
eecd_reg |= IXGB_EECD_SK; eecd_reg |= IXGB_EECD_SK;
IXGB_WRITE_REG(hw, EECD, eecd_reg); IXGB_WRITE_REG(hw, EECD, eecd_reg);
usec_delay(50); usec_delay(50);
/* Select EEPROM */ /* Select EEPROM */
eecd_reg |= IXGB_EECD_CS; eecd_reg |= IXGB_EECD_CS;
IXGB_WRITE_REG(hw, EECD, eecd_reg); IXGB_WRITE_REG(hw, EECD, eecd_reg);
usec_delay(50); usec_delay(50);
/* Clock low */ /* Clock low */
eecd_reg &= ~IXGB_EECD_SK; eecd_reg &= ~IXGB_EECD_SK;
IXGB_WRITE_REG(hw, EECD, eecd_reg); IXGB_WRITE_REG(hw, EECD, eecd_reg);
usec_delay(50); usec_delay(50);
return; return;
} }
/****************************************************************************** /******************************************************************************
...@@ -235,20 +229,20 @@ ixgb_standby_eeprom(struct ixgb_hw *hw) ...@@ -235,20 +229,20 @@ ixgb_standby_eeprom(struct ixgb_hw *hw)
static void static void
ixgb_clock_eeprom(struct ixgb_hw *hw) ixgb_clock_eeprom(struct ixgb_hw *hw)
{ {
uint32_t eecd_reg; uint32_t eecd_reg;
eecd_reg = IXGB_READ_REG(hw, EECD); eecd_reg = IXGB_READ_REG(hw, EECD);
/* Rising edge of clock */ /* Rising edge of clock */
eecd_reg |= IXGB_EECD_SK; eecd_reg |= IXGB_EECD_SK;
IXGB_WRITE_REG(hw, EECD, eecd_reg); IXGB_WRITE_REG(hw, EECD, eecd_reg);
usec_delay(50); usec_delay(50);
/* Falling edge of clock */ /* Falling edge of clock */
eecd_reg &= ~IXGB_EECD_SK; eecd_reg &= ~IXGB_EECD_SK;
IXGB_WRITE_REG(hw, EECD, eecd_reg); IXGB_WRITE_REG(hw, EECD, eecd_reg);
usec_delay(50); usec_delay(50);
return; return;
} }
/****************************************************************************** /******************************************************************************
...@@ -259,16 +253,16 @@ ixgb_clock_eeprom(struct ixgb_hw *hw) ...@@ -259,16 +253,16 @@ ixgb_clock_eeprom(struct ixgb_hw *hw)
static void static void
ixgb_cleanup_eeprom(struct ixgb_hw *hw) ixgb_cleanup_eeprom(struct ixgb_hw *hw)
{ {
uint32_t eecd_reg; uint32_t eecd_reg;
eecd_reg = IXGB_READ_REG(hw, EECD); eecd_reg = IXGB_READ_REG(hw, EECD);
eecd_reg &= ~(IXGB_EECD_CS | IXGB_EECD_DI); eecd_reg &= ~(IXGB_EECD_CS | IXGB_EECD_DI);
IXGB_WRITE_REG(hw, EECD, eecd_reg); IXGB_WRITE_REG(hw, EECD, eecd_reg);
ixgb_clock_eeprom(hw); ixgb_clock_eeprom(hw);
return; return;
} }
/****************************************************************************** /******************************************************************************
...@@ -285,32 +279,30 @@ ixgb_cleanup_eeprom(struct ixgb_hw *hw) ...@@ -285,32 +279,30 @@ ixgb_cleanup_eeprom(struct ixgb_hw *hw)
static boolean_t static boolean_t
ixgb_wait_eeprom_command(struct ixgb_hw *hw) ixgb_wait_eeprom_command(struct ixgb_hw *hw)
{ {
uint32_t eecd_reg; uint32_t eecd_reg;
uint32_t i; uint32_t i;
/* Toggle the CS line. This in effect tells to EEPROM to actually execute
/* Toggle the CS line. This in effect tells to EEPROM to actually execute * the command in question.
* the command in question. */
*/ ixgb_standby_eeprom(hw);
ixgb_standby_eeprom(hw);
/* Now read DO repeatedly until is high (equal to '1'). The EEEPROM will
/* Now read DO repeatedly until is high (equal to '1'). The EEEPROM will * signal that the command has been completed by raising the DO signal.
* signal that the command has been completed by raising the DO signal. * If DO does not go high in 10 milliseconds, then error out.
* If DO does not go high in 10 milliseconds, then error out. */
*/ for (i = 0; i < 200; i++) {
for(i = 0; i < 200; i++) { eecd_reg = IXGB_READ_REG(hw, EECD);
eecd_reg = IXGB_READ_REG(hw, EECD);
if (eecd_reg & IXGB_EECD_DO)
if(eecd_reg & IXGB_EECD_DO) return (TRUE);
return (TRUE);
usec_delay(50);
usec_delay(50); }
} ASSERT(0);
ASSERT(0); return (FALSE);
return (FALSE);
} }
/****************************************************************************** /******************************************************************************
* Verifies that the EEPROM has a valid checksum * Verifies that the EEPROM has a valid checksum
* *
...@@ -325,18 +317,18 @@ ixgb_wait_eeprom_command(struct ixgb_hw *hw) ...@@ -325,18 +317,18 @@ ixgb_wait_eeprom_command(struct ixgb_hw *hw)
* FALSE: Checksum is not valid. * FALSE: Checksum is not valid.
*****************************************************************************/ *****************************************************************************/
boolean_t boolean_t
ixgb_validate_eeprom_checksum(struct ixgb_hw *hw) ixgb_validate_eeprom_checksum(struct ixgb_hw * hw)
{ {
uint16_t checksum = 0; uint16_t checksum = 0;
uint16_t i; uint16_t i;
for(i = 0; i < (EEPROM_CHECKSUM_REG + 1); i++) for (i = 0; i < (EEPROM_CHECKSUM_REG + 1); i++)
checksum += ixgb_read_eeprom(hw, i); checksum += ixgb_read_eeprom(hw, i);
if(checksum == (uint16_t) EEPROM_SUM) if (checksum == (uint16_t) EEPROM_SUM)
return (TRUE); return (TRUE);
else else
return (FALSE); return (FALSE);
} }
/****************************************************************************** /******************************************************************************
...@@ -350,16 +342,16 @@ ixgb_validate_eeprom_checksum(struct ixgb_hw *hw) ...@@ -350,16 +342,16 @@ ixgb_validate_eeprom_checksum(struct ixgb_hw *hw)
void void
ixgb_update_eeprom_checksum(struct ixgb_hw *hw) ixgb_update_eeprom_checksum(struct ixgb_hw *hw)
{ {
uint16_t checksum = 0; uint16_t checksum = 0;
uint16_t i; uint16_t i;
for(i = 0; i < EEPROM_CHECKSUM_REG; i++) for (i = 0; i < EEPROM_CHECKSUM_REG; i++)
checksum += ixgb_read_eeprom(hw, i); checksum += ixgb_read_eeprom(hw, i);
checksum = (uint16_t) EEPROM_SUM - checksum; checksum = (uint16_t) EEPROM_SUM - checksum;
ixgb_write_eeprom(hw, EEPROM_CHECKSUM_REG, checksum); ixgb_write_eeprom(hw, EEPROM_CHECKSUM_REG, checksum);
return; return;
} }
/****************************************************************************** /******************************************************************************
...@@ -374,45 +366,43 @@ ixgb_update_eeprom_checksum(struct ixgb_hw *hw) ...@@ -374,45 +366,43 @@ ixgb_update_eeprom_checksum(struct ixgb_hw *hw)
* *
*****************************************************************************/ *****************************************************************************/
void void
ixgb_write_eeprom(struct ixgb_hw *hw, ixgb_write_eeprom(struct ixgb_hw *hw, uint16_t offset, uint16_t data)
uint16_t offset,
uint16_t data)
{ {
/* Prepare the EEPROM for writing */ /* Prepare the EEPROM for writing */
ixgb_setup_eeprom(hw); ixgb_setup_eeprom(hw);
/* Send the 9-bit EWEN (write enable) command to the EEPROM (5-bit opcode /* Send the 9-bit EWEN (write enable) command to the EEPROM (5-bit opcode
* plus 4-bit dummy). This puts the EEPROM into write/erase mode. * plus 4-bit dummy). This puts the EEPROM into write/erase mode.
*/ */
ixgb_shift_out_bits(hw, EEPROM_EWEN_OPCODE, 5); ixgb_shift_out_bits(hw, EEPROM_EWEN_OPCODE, 5);
ixgb_shift_out_bits(hw, 0, 4); ixgb_shift_out_bits(hw, 0, 4);
/* Prepare the EEPROM */ /* Prepare the EEPROM */
ixgb_standby_eeprom(hw); ixgb_standby_eeprom(hw);
/* Send the Write command (3-bit opcode + 6-bit addr) */ /* Send the Write command (3-bit opcode + 6-bit addr) */
ixgb_shift_out_bits(hw, EEPROM_WRITE_OPCODE, 3); ixgb_shift_out_bits(hw, EEPROM_WRITE_OPCODE, 3);
ixgb_shift_out_bits(hw, offset, 6); ixgb_shift_out_bits(hw, offset, 6);
/* Send the data */ /* Send the data */
ixgb_shift_out_bits(hw, data, 16); ixgb_shift_out_bits(hw, data, 16);
ixgb_wait_eeprom_command(hw); ixgb_wait_eeprom_command(hw);
/* Recover from write */ /* Recover from write */
ixgb_standby_eeprom(hw); ixgb_standby_eeprom(hw);
/* Send the 9-bit EWDS (write disable) command to the EEPROM (5-bit /* Send the 9-bit EWDS (write disable) command to the EEPROM (5-bit
* opcode plus 4-bit dummy). This takes the EEPROM out of write/erase * opcode plus 4-bit dummy). This takes the EEPROM out of write/erase
* mode. * mode.
*/ */
ixgb_shift_out_bits(hw, EEPROM_EWDS_OPCODE, 5); ixgb_shift_out_bits(hw, EEPROM_EWDS_OPCODE, 5);
ixgb_shift_out_bits(hw, 0, 4); ixgb_shift_out_bits(hw, 0, 4);
/* Done with writing */ /* Done with writing */
ixgb_cleanup_eeprom(hw); ixgb_cleanup_eeprom(hw);
return; return;
} }
/****************************************************************************** /******************************************************************************
...@@ -425,28 +415,27 @@ ixgb_write_eeprom(struct ixgb_hw *hw, ...@@ -425,28 +415,27 @@ ixgb_write_eeprom(struct ixgb_hw *hw,
* The 16-bit value read from the eeprom * The 16-bit value read from the eeprom
*****************************************************************************/ *****************************************************************************/
uint16_t uint16_t
ixgb_read_eeprom(struct ixgb_hw *hw, ixgb_read_eeprom(struct ixgb_hw * hw, uint16_t offset)
uint16_t offset)
{ {
uint16_t data; uint16_t data;
/* Prepare the EEPROM for reading */ /* Prepare the EEPROM for reading */
ixgb_setup_eeprom(hw); ixgb_setup_eeprom(hw);
/* Send the READ command (opcode + addr) */ /* Send the READ command (opcode + addr) */
ixgb_shift_out_bits(hw, EEPROM_READ_OPCODE, 3); ixgb_shift_out_bits(hw, EEPROM_READ_OPCODE, 3);
/* /*
* We have a 64 word EEPROM, there are 6 address bits * We have a 64 word EEPROM, there are 6 address bits
*/ */
ixgb_shift_out_bits(hw, offset, 6); ixgb_shift_out_bits(hw, offset, 6);
/* Read the data */ /* Read the data */
data = ixgb_shift_in_bits(hw); data = ixgb_shift_in_bits(hw);
/* End this read operation */ /* End this read operation */
ixgb_standby_eeprom(hw); ixgb_standby_eeprom(hw);
return (data); return (data);
} }
/****************************************************************************** /******************************************************************************
...@@ -460,38 +449,37 @@ ixgb_read_eeprom(struct ixgb_hw *hw, ...@@ -460,38 +449,37 @@ ixgb_read_eeprom(struct ixgb_hw *hw,
* FALSE: otherwise. * FALSE: otherwise.
*****************************************************************************/ *****************************************************************************/
boolean_t boolean_t
ixgb_get_eeprom_data(struct ixgb_hw *hw) ixgb_get_eeprom_data(struct ixgb_hw * hw)
{ {
uint16_t i; uint16_t i;
uint16_t checksum = 0; uint16_t checksum = 0;
struct ixgb_ee_map_type *ee_map; struct ixgb_ee_map_type *ee_map;
DEBUGFUNC("ixgb_get_eeprom_data"); DEBUGFUNC("ixgb_get_eeprom_data");
ee_map = (struct ixgb_ee_map_type *) hw->eeprom; ee_map = (struct ixgb_ee_map_type *) hw->eeprom;
DEBUGOUT("ixgb_ee: Reading eeprom data\n"); DEBUGOUT("ixgb_ee: Reading eeprom data\n");
for (i=0; i < IXGB_EEPROM_SIZE ; i++) { for (i = 0; i < IXGB_EEPROM_SIZE; i++) {
uint16_t ee_data; uint16_t ee_data;
ee_data = ixgb_read_eeprom(hw, i); ee_data = ixgb_read_eeprom(hw, i);
checksum += ee_data; checksum += ee_data;
hw->eeprom[i] = le16_to_cpu (ee_data); hw->eeprom[i] = le16_to_cpu(ee_data);
} }
if (checksum != (uint16_t) EEPROM_SUM) { if (checksum != (uint16_t) EEPROM_SUM) {
DEBUGOUT("ixgb_ee: Checksum invalid.\n"); DEBUGOUT("ixgb_ee: Checksum invalid.\n");
return (FALSE); return (FALSE);
} }
if ((ee_map->init_ctrl_reg_1 & le16_to_cpu(EEPROM_ICW1_SIGNATURE_MASK)) if ((ee_map->init_ctrl_reg_1 & le16_to_cpu(EEPROM_ICW1_SIGNATURE_MASK))
!= le16_to_cpu(EEPROM_ICW1_SIGNATURE_VALID)) { != le16_to_cpu(EEPROM_ICW1_SIGNATURE_VALID)) {
DEBUGOUT("ixgb_ee: Signature invalid.\n"); DEBUGOUT("ixgb_ee: Signature invalid.\n");
return(FALSE); return (FALSE);
} }
return(TRUE); return (TRUE);
} }
/****************************************************************************** /******************************************************************************
* Local function to check if the eeprom signature is good * Local function to check if the eeprom signature is good
...@@ -504,17 +492,17 @@ ixgb_get_eeprom_data(struct ixgb_hw *hw) ...@@ -504,17 +492,17 @@ ixgb_get_eeprom_data(struct ixgb_hw *hw)
* FALSE: otherwise. * FALSE: otherwise.
******************************************************************************/ ******************************************************************************/
static boolean_t static boolean_t
ixgb_check_and_get_eeprom_data (struct ixgb_hw* hw) ixgb_check_and_get_eeprom_data(struct ixgb_hw *hw)
{ {
struct ixgb_ee_map_type *ee_map = (struct ixgb_ee_map_type *) hw->eeprom; struct ixgb_ee_map_type *ee_map =
(struct ixgb_ee_map_type *) hw->eeprom;
if ((ee_map->init_ctrl_reg_1 & le16_to_cpu(EEPROM_ICW1_SIGNATURE_MASK)) if ((ee_map->init_ctrl_reg_1 & le16_to_cpu(EEPROM_ICW1_SIGNATURE_MASK))
== le16_to_cpu(EEPROM_ICW1_SIGNATURE_VALID)) { == le16_to_cpu(EEPROM_ICW1_SIGNATURE_VALID)) {
return (TRUE); return (TRUE);
} else { } else {
return ixgb_get_eeprom_data(hw); return ixgb_get_eeprom_data(hw);
} }
} }
/****************************************************************************** /******************************************************************************
...@@ -526,21 +514,21 @@ ixgb_check_and_get_eeprom_data (struct ixgb_hw* hw) ...@@ -526,21 +514,21 @@ ixgb_check_and_get_eeprom_data (struct ixgb_hw* hw)
* Returns: None. * Returns: None.
******************************************************************************/ ******************************************************************************/
void void
ixgb_get_ee_mac_addr(struct ixgb_hw *hw, ixgb_get_ee_mac_addr(struct ixgb_hw *hw, uint8_t * mac_addr)
uint8_t *mac_addr)
{ {
int i; int i;
struct ixgb_ee_map_type *ee_map = (struct ixgb_ee_map_type *) hw->eeprom; struct ixgb_ee_map_type *ee_map =
(struct ixgb_ee_map_type *) hw->eeprom;
DEBUGFUNC("ixgb_get_ee_mac_addr");
DEBUGFUNC("ixgb_get_ee_mac_addr");
if (ixgb_check_and_get_eeprom_data (hw) == TRUE) {
for (i = 0; i < IXGB_ETH_LENGTH_OF_ADDRESS; i++) { if (ixgb_check_and_get_eeprom_data(hw) == TRUE) {
mac_addr[i] = ee_map->mac_addr[i]; for (i = 0; i < IXGB_ETH_LENGTH_OF_ADDRESS; i++) {
DEBUGOUT2("mac(%d) = %.2X\n", i, mac_addr[i]); mac_addr[i] = ee_map->mac_addr[i];
} DEBUGOUT2("mac(%d) = %.2X\n", i, mac_addr[i]);
} }
} }
}
/****************************************************************************** /******************************************************************************
* return the compatibility flags from EEPROM * return the compatibility flags from EEPROM
...@@ -553,12 +541,13 @@ ixgb_get_ee_mac_addr(struct ixgb_hw *hw, ...@@ -553,12 +541,13 @@ ixgb_get_ee_mac_addr(struct ixgb_hw *hw,
uint16_t uint16_t
ixgb_get_ee_compatibility(struct ixgb_hw *hw) ixgb_get_ee_compatibility(struct ixgb_hw *hw)
{ {
struct ixgb_ee_map_type *ee_map = (struct ixgb_ee_map_type *) hw->eeprom; struct ixgb_ee_map_type *ee_map =
(struct ixgb_ee_map_type *) hw->eeprom;
if (ixgb_check_and_get_eeprom_data (hw) == TRUE) if (ixgb_check_and_get_eeprom_data(hw) == TRUE)
return(ee_map->compatibility); return (ee_map->compatibility);
return(0); return (0);
} }
/****************************************************************************** /******************************************************************************
...@@ -570,13 +559,13 @@ ixgb_get_ee_compatibility(struct ixgb_hw *hw) ...@@ -570,13 +559,13 @@ ixgb_get_ee_compatibility(struct ixgb_hw *hw)
* PBA number if EEPROM contents are valid, 0 otherwise * PBA number if EEPROM contents are valid, 0 otherwise
******************************************************************************/ ******************************************************************************/
uint32_t uint32_t
ixgb_get_ee_pba_number(struct ixgb_hw *hw) ixgb_get_ee_pba_number(struct ixgb_hw * hw)
{ {
if (ixgb_check_and_get_eeprom_data (hw) == TRUE) if (ixgb_check_and_get_eeprom_data(hw) == TRUE)
return ( le16_to_cpu(hw->eeprom[EEPROM_PBA_1_2_REG]) return (le16_to_cpu(hw->eeprom[EEPROM_PBA_1_2_REG])
| (le16_to_cpu(hw->eeprom[EEPROM_PBA_3_4_REG])<<16)); | (le16_to_cpu(hw->eeprom[EEPROM_PBA_3_4_REG]) << 16));
return(0); return (0);
} }
/****************************************************************************** /******************************************************************************
...@@ -588,15 +577,16 @@ ixgb_get_ee_pba_number(struct ixgb_hw *hw) ...@@ -588,15 +577,16 @@ ixgb_get_ee_pba_number(struct ixgb_hw *hw)
* Initialization Control Word 1 if EEPROM contents are valid, 0 otherwise * Initialization Control Word 1 if EEPROM contents are valid, 0 otherwise
******************************************************************************/ ******************************************************************************/
uint16_t uint16_t
ixgb_get_ee_init_ctrl_reg_1(struct ixgb_hw *hw) ixgb_get_ee_init_ctrl_reg_1(struct ixgb_hw * hw)
{ {
struct ixgb_ee_map_type *ee_map = (struct ixgb_ee_map_type *) hw->eeprom; struct ixgb_ee_map_type *ee_map =
(struct ixgb_ee_map_type *) hw->eeprom;
if (ixgb_check_and_get_eeprom_data (hw) == TRUE) if (ixgb_check_and_get_eeprom_data(hw) == TRUE)
return(ee_map->init_ctrl_reg_1); return (ee_map->init_ctrl_reg_1);
return(0); return (0);
} }
/****************************************************************************** /******************************************************************************
* return the Initialization Control Word 2 from EEPROM * return the Initialization Control Word 2 from EEPROM
...@@ -607,15 +597,16 @@ ixgb_get_ee_init_ctrl_reg_1(struct ixgb_hw *hw) ...@@ -607,15 +597,16 @@ ixgb_get_ee_init_ctrl_reg_1(struct ixgb_hw *hw)
* Initialization Control Word 2 if EEPROM contents are valid, 0 otherwise * Initialization Control Word 2 if EEPROM contents are valid, 0 otherwise
******************************************************************************/ ******************************************************************************/
uint16_t uint16_t
ixgb_get_ee_init_ctrl_reg_2(struct ixgb_hw *hw) ixgb_get_ee_init_ctrl_reg_2(struct ixgb_hw * hw)
{ {
struct ixgb_ee_map_type *ee_map = (struct ixgb_ee_map_type *) hw->eeprom; struct ixgb_ee_map_type *ee_map =
(struct ixgb_ee_map_type *) hw->eeprom;
if (ixgb_check_and_get_eeprom_data (hw) == TRUE) if (ixgb_check_and_get_eeprom_data(hw) == TRUE)
return(ee_map->init_ctrl_reg_2); return (ee_map->init_ctrl_reg_2);
return(0); return (0);
} }
/****************************************************************************** /******************************************************************************
* return the Subsystem Id from EEPROM * return the Subsystem Id from EEPROM
...@@ -626,15 +617,16 @@ ixgb_get_ee_init_ctrl_reg_2(struct ixgb_hw *hw) ...@@ -626,15 +617,16 @@ ixgb_get_ee_init_ctrl_reg_2(struct ixgb_hw *hw)
* Subsystem Id if EEPROM contents are valid, 0 otherwise * Subsystem Id if EEPROM contents are valid, 0 otherwise
******************************************************************************/ ******************************************************************************/
uint16_t uint16_t
ixgb_get_ee_subsystem_id(struct ixgb_hw *hw) ixgb_get_ee_subsystem_id(struct ixgb_hw * hw)
{ {
struct ixgb_ee_map_type *ee_map = (struct ixgb_ee_map_type *) hw->eeprom; struct ixgb_ee_map_type *ee_map =
(struct ixgb_ee_map_type *) hw->eeprom;
if (ixgb_check_and_get_eeprom_data (hw) == TRUE) if (ixgb_check_and_get_eeprom_data(hw) == TRUE)
return(ee_map->subsystem_id); return (ee_map->subsystem_id);
return(0); return (0);
} }
/****************************************************************************** /******************************************************************************
* return the Sub Vendor Id from EEPROM * return the Sub Vendor Id from EEPROM
...@@ -645,15 +637,16 @@ ixgb_get_ee_subsystem_id(struct ixgb_hw *hw) ...@@ -645,15 +637,16 @@ ixgb_get_ee_subsystem_id(struct ixgb_hw *hw)
* Sub Vendor Id if EEPROM contents are valid, 0 otherwise * Sub Vendor Id if EEPROM contents are valid, 0 otherwise
******************************************************************************/ ******************************************************************************/
uint16_t uint16_t
ixgb_get_ee_subvendor_id(struct ixgb_hw *hw) ixgb_get_ee_subvendor_id(struct ixgb_hw * hw)
{ {
struct ixgb_ee_map_type *ee_map = (struct ixgb_ee_map_type *) hw->eeprom; struct ixgb_ee_map_type *ee_map =
(struct ixgb_ee_map_type *) hw->eeprom;
if (ixgb_check_and_get_eeprom_data (hw) == TRUE) if (ixgb_check_and_get_eeprom_data(hw) == TRUE)
return(ee_map->subvendor_id); return (ee_map->subvendor_id);
return(0); return (0);
} }
/****************************************************************************** /******************************************************************************
* return the Device Id from EEPROM * return the Device Id from EEPROM
...@@ -664,15 +657,16 @@ ixgb_get_ee_subvendor_id(struct ixgb_hw *hw) ...@@ -664,15 +657,16 @@ ixgb_get_ee_subvendor_id(struct ixgb_hw *hw)
* Device Id if EEPROM contents are valid, 0 otherwise * Device Id if EEPROM contents are valid, 0 otherwise
******************************************************************************/ ******************************************************************************/
uint16_t uint16_t
ixgb_get_ee_device_id(struct ixgb_hw *hw) ixgb_get_ee_device_id(struct ixgb_hw * hw)
{ {
struct ixgb_ee_map_type *ee_map = (struct ixgb_ee_map_type *) hw->eeprom; struct ixgb_ee_map_type *ee_map =
(struct ixgb_ee_map_type *) hw->eeprom;
if (ixgb_check_and_get_eeprom_data (hw) == TRUE) if (ixgb_check_and_get_eeprom_data(hw) == TRUE)
return(ee_map->device_id); return (ee_map->device_id);
return(0); return (0);
} }
/****************************************************************************** /******************************************************************************
* return the Vendor Id from EEPROM * return the Vendor Id from EEPROM
...@@ -683,15 +677,16 @@ ixgb_get_ee_device_id(struct ixgb_hw *hw) ...@@ -683,15 +677,16 @@ ixgb_get_ee_device_id(struct ixgb_hw *hw)
* Device Id if EEPROM contents are valid, 0 otherwise * Device Id if EEPROM contents are valid, 0 otherwise
******************************************************************************/ ******************************************************************************/
uint16_t uint16_t
ixgb_get_ee_vendor_id(struct ixgb_hw *hw) ixgb_get_ee_vendor_id(struct ixgb_hw * hw)
{ {
struct ixgb_ee_map_type *ee_map = (struct ixgb_ee_map_type *) hw->eeprom; struct ixgb_ee_map_type *ee_map =
(struct ixgb_ee_map_type *) hw->eeprom;
if (ixgb_check_and_get_eeprom_data (hw) == TRUE) if (ixgb_check_and_get_eeprom_data(hw) == TRUE)
return(ee_map->vendor_id); return (ee_map->vendor_id);
return(0); return (0);
} }
/****************************************************************************** /******************************************************************************
* return the Software Defined Pins Register from EEPROM * return the Software Defined Pins Register from EEPROM
...@@ -702,15 +697,16 @@ ixgb_get_ee_vendor_id(struct ixgb_hw *hw) ...@@ -702,15 +697,16 @@ ixgb_get_ee_vendor_id(struct ixgb_hw *hw)
* SDP Register if EEPROM contents are valid, 0 otherwise * SDP Register if EEPROM contents are valid, 0 otherwise
******************************************************************************/ ******************************************************************************/
uint16_t uint16_t
ixgb_get_ee_swdpins_reg(struct ixgb_hw *hw) ixgb_get_ee_swdpins_reg(struct ixgb_hw * hw)
{ {
struct ixgb_ee_map_type *ee_map = (struct ixgb_ee_map_type *) hw->eeprom; struct ixgb_ee_map_type *ee_map =
(struct ixgb_ee_map_type *) hw->eeprom;
if (ixgb_check_and_get_eeprom_data (hw) == TRUE) if (ixgb_check_and_get_eeprom_data(hw) == TRUE)
return(ee_map->swdpins_reg); return (ee_map->swdpins_reg);
return(0); return (0);
} }
/****************************************************************************** /******************************************************************************
* return the D3 Power Management Bits from EEPROM * return the D3 Power Management Bits from EEPROM
...@@ -721,15 +717,16 @@ ixgb_get_ee_swdpins_reg(struct ixgb_hw *hw) ...@@ -721,15 +717,16 @@ ixgb_get_ee_swdpins_reg(struct ixgb_hw *hw)
* D3 Power Management Bits if EEPROM contents are valid, 0 otherwise * D3 Power Management Bits if EEPROM contents are valid, 0 otherwise
******************************************************************************/ ******************************************************************************/
uint8_t uint8_t
ixgb_get_ee_d3_power(struct ixgb_hw *hw) ixgb_get_ee_d3_power(struct ixgb_hw * hw)
{ {
struct ixgb_ee_map_type *ee_map = (struct ixgb_ee_map_type *) hw->eeprom; struct ixgb_ee_map_type *ee_map =
(struct ixgb_ee_map_type *) hw->eeprom;
if (ixgb_check_and_get_eeprom_data (hw) == TRUE) if (ixgb_check_and_get_eeprom_data(hw) == TRUE)
return(ee_map->d3_power); return (ee_map->d3_power);
return(0); return (0);
} }
/****************************************************************************** /******************************************************************************
* return the D0 Power Management Bits from EEPROM * return the D0 Power Management Bits from EEPROM
...@@ -740,12 +737,13 @@ ixgb_get_ee_d3_power(struct ixgb_hw *hw) ...@@ -740,12 +737,13 @@ ixgb_get_ee_d3_power(struct ixgb_hw *hw)
* D0 Power Management Bits if EEPROM contents are valid, 0 otherwise * D0 Power Management Bits if EEPROM contents are valid, 0 otherwise
******************************************************************************/ ******************************************************************************/
uint8_t uint8_t
ixgb_get_ee_d0_power(struct ixgb_hw *hw) ixgb_get_ee_d0_power(struct ixgb_hw * hw)
{ {
struct ixgb_ee_map_type *ee_map = (struct ixgb_ee_map_type *) hw->eeprom; struct ixgb_ee_map_type *ee_map =
(struct ixgb_ee_map_type *) hw->eeprom;
if (ixgb_check_and_get_eeprom_data (hw) == TRUE) if (ixgb_check_and_get_eeprom_data(hw) == TRUE)
return(ee_map->d0_power); return (ee_map->d0_power);
return(0); return (0);
} }
drivers/net/ixgb/ixgb_ee.h
View file @ ca247341
...@@ -28,18 +28,16 @@ ...@@ -28,18 +28,16 @@
#ifndef _IXGB_EE_H_ #ifndef _IXGB_EE_H_
#define _IXGB_EE_H_ #define _IXGB_EE_H_
#define IXGB_EEPROM_SIZE 64 /* Size in words */
#define IXGB_EEPROM_SIZE 64 /* Size in words */
#define IXGB_ETH_LENGTH_OF_ADDRESS 6 #define IXGB_ETH_LENGTH_OF_ADDRESS 6
/* EEPROM Commands */ /* EEPROM Commands */
#define EEPROM_READ_OPCODE 0x6 /* EERPOM read opcode */ #define EEPROM_READ_OPCODE 0x6 /* EERPOM read opcode */
#define EEPROM_WRITE_OPCODE 0x5 /* EERPOM write opcode */ #define EEPROM_WRITE_OPCODE 0x5 /* EERPOM write opcode */
#define EEPROM_ERASE_OPCODE 0x7 /* EERPOM erase opcode */ #define EEPROM_ERASE_OPCODE 0x7 /* EERPOM erase opcode */
#define EEPROM_EWEN_OPCODE 0x13 /* EERPOM erase/write enable */ #define EEPROM_EWEN_OPCODE 0x13 /* EERPOM erase/write enable */
#define EEPROM_EWDS_OPCODE 0x10 /* EERPOM erast/write disable */ #define EEPROM_EWDS_OPCODE 0x10 /* EERPOM erast/write disable */
/* EEPROM MAP (Word Offsets) */ /* EEPROM MAP (Word Offsets) */
#define EEPROM_IA_1_2_REG 0x0000 #define EEPROM_IA_1_2_REG 0x0000
...@@ -74,37 +72,33 @@ ...@@ -74,37 +72,33 @@
/* EEPROM Map defines (WORD OFFSETS)*/ /* EEPROM Map defines (WORD OFFSETS)*/
/* EEPROM structure */ /* EEPROM structure */
struct ixgb_ee_map_type{ struct ixgb_ee_map_type {
uint8_t mac_addr[IXGB_ETH_LENGTH_OF_ADDRESS]; uint8_t mac_addr[IXGB_ETH_LENGTH_OF_ADDRESS];
uint16_t compatibility; uint16_t compatibility;
uint16_t reserved1[4]; uint16_t reserved1[4];
uint32_t pba_number; uint32_t pba_number;
uint16_t init_ctrl_reg_1; uint16_t init_ctrl_reg_1;
uint16_t subsystem_id; uint16_t subsystem_id;
uint16_t subvendor_id; uint16_t subvendor_id;
uint16_t device_id; uint16_t device_id;
uint16_t vendor_id; uint16_t vendor_id;
uint16_t init_ctrl_reg_2; uint16_t init_ctrl_reg_2;
uint16_t oem_reserved[16]; uint16_t oem_reserved[16];
uint16_t swdpins_reg; uint16_t swdpins_reg;
uint16_t circuit_ctrl_reg; uint16_t circuit_ctrl_reg;
uint8_t d3_power; uint8_t d3_power;
uint8_t d0_power; uint8_t d0_power;
uint16_t reserved2[28]; uint16_t reserved2[28];
uint16_t checksum; uint16_t checksum;
}; };
/* EEPROM Functions */ /* EEPROM Functions */
uint16_t ixgb_read_eeprom(struct ixgb_hw *hw, uint16_t ixgb_read_eeprom(struct ixgb_hw *hw, uint16_t reg);
uint16_t reg);
boolean_t ixgb_validate_eeprom_checksum(struct ixgb_hw *hw); boolean_t ixgb_validate_eeprom_checksum(struct ixgb_hw *hw);
void ixgb_update_eeprom_checksum(struct ixgb_hw *hw); void ixgb_update_eeprom_checksum(struct ixgb_hw *hw);
void ixgb_write_eeprom(struct ixgb_hw *hw, void ixgb_write_eeprom(struct ixgb_hw *hw, uint16_t reg, uint16_t data);
uint16_t reg,
uint16_t data);
#endif /* IXGB_EE_H */
#endif /* IXGB_EE_H */
drivers/net/ixgb/ixgb_ethtool.c
View file @ ca247341
...@@ -25,7 +25,6 @@ ...@@ -25,7 +25,6 @@
Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497 Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
*******************************************************************************/ *******************************************************************************/
/* ethtool support for ixgb */ /* ethtool support for ixgb */
#include "ixgb.h" #include "ixgb.h"
...@@ -47,324 +46,320 @@ extern int ixgb_down(struct ixgb_adapter *adapter); ...@@ -47,324 +46,320 @@ extern int ixgb_down(struct ixgb_adapter *adapter);
static inline int static inline int
ixgb_eeprom_size(struct ixgb_hw *hw) ixgb_eeprom_size(struct ixgb_hw *hw)
{ {
/* return size in bytes */ /* return size in bytes */
return (IXGB_EEPROM_SIZE << 1); return (IXGB_EEPROM_SIZE << 1);
} }
#define SUPPORTED_10000baseT_Full (1 << 11) #define SUPPORTED_10000baseT_Full (1 << 11)
#define SPEED_10000 10000 #define SPEED_10000 10000
static void static void
ixgb_ethtool_gset(struct ixgb_adapter *adapter, ixgb_ethtool_gset(struct ixgb_adapter *adapter, struct ethtool_cmd *ecmd)
struct ethtool_cmd *ecmd)
{ {
ecmd->supported = (SUPPORTED_10000baseT_Full | SUPPORTED_FIBRE); ecmd->supported = (SUPPORTED_10000baseT_Full | SUPPORTED_FIBRE);
ecmd->advertising = (SUPPORTED_10000baseT_Full | SUPPORTED_FIBRE); ecmd->advertising = (SUPPORTED_10000baseT_Full | SUPPORTED_FIBRE);
ecmd->port = PORT_FIBRE; ecmd->port = PORT_FIBRE;
ecmd->transceiver = XCVR_EXTERNAL; ecmd->transceiver = XCVR_EXTERNAL;
if(netif_carrier_ok(adapter->netdev)) { if (netif_carrier_ok(adapter->netdev)) {
ecmd->speed = 10000; ecmd->speed = 10000;
ecmd->duplex = DUPLEX_FULL; ecmd->duplex = DUPLEX_FULL;
} else { } else {
ecmd->speed = -1; ecmd->speed = -1;
ecmd->duplex = -1; ecmd->duplex = -1;
} }
ecmd->autoneg = AUTONEG_DISABLE; ecmd->autoneg = AUTONEG_DISABLE;
} }
static int static int
ixgb_ethtool_sset(struct ixgb_adapter *adapter, ixgb_ethtool_sset(struct ixgb_adapter *adapter, struct ethtool_cmd *ecmd)
struct ethtool_cmd *ecmd)
{ {
if(ecmd->autoneg == AUTONEG_ENABLE || if (ecmd->autoneg == AUTONEG_ENABLE ||
ecmd->speed + ecmd->duplex != SPEED_10000 + DUPLEX_FULL) ecmd->speed + ecmd->duplex != SPEED_10000 + DUPLEX_FULL)
return -EINVAL; return -EINVAL;
else { else {
ixgb_down(adapter); ixgb_down(adapter);
ixgb_up(adapter); ixgb_up(adapter);
} }
return 0; return 0;
} }
#if 0 #if 0
static int static int
ixgb_ethtool_promiscuous(struct ixgb_adapter *adapter, ixgb_ethtool_promiscuous(struct ixgb_adapter *adapter,
struct ethtool_pmode *pmode) struct ethtool_pmode *pmode)
{ {
uint32_t rctl = IXGB_READ_REG(&adapter->hw, RCTL); uint32_t rctl = IXGB_READ_REG(&adapter->hw, RCTL);
pmode->rctl_old = rctl; pmode->rctl_old = rctl;
if(pmode->upe) if (pmode->upe)
rctl |= IXGB_RCTL_UPE; rctl |= IXGB_RCTL_UPE;
else else
rctl &= ~IXGB_RCTL_UPE; rctl &= ~IXGB_RCTL_UPE;
if(pmode->mpe) if (pmode->mpe)
rctl |= IXGB_RCTL_MPE; rctl |= IXGB_RCTL_MPE;
else else
rctl &= ~IXGB_RCTL_MPE; rctl &= ~IXGB_RCTL_MPE;
IXGB_WRITE_REG(&adapter->hw, RCTL, rctl); IXGB_WRITE_REG(&adapter->hw, RCTL, rctl);
pmode->rctl_new = IXGB_READ_REG(&adapter->hw, RCTL); pmode->rctl_new = IXGB_READ_REG(&adapter->hw, RCTL);
return 0; return 0;
} }
#endif #endif
#define IXGB_REG_DUMP_LEN 136*sizeof(uint32_t) #define IXGB_REG_DUMP_LEN 136*sizeof(uint32_t)
static void static void
ixgb_ethtool_gdrvinfo(struct ixgb_adapter *adapter, ixgb_ethtool_gdrvinfo(struct ixgb_adapter *adapter,
struct ethtool_drvinfo *drvinfo) struct ethtool_drvinfo *drvinfo)
{ {
strncpy(drvinfo->driver, ixgb_driver_name, 32); strncpy(drvinfo->driver, ixgb_driver_name, 32);
strncpy(drvinfo->version, ixgb_driver_version, 32); strncpy(drvinfo->version, ixgb_driver_version, 32);
strncpy(drvinfo->fw_version, "", 32); strncpy(drvinfo->fw_version, "", 32);
strncpy(drvinfo->bus_info, adapter->pdev->slot_name, 32); strncpy(drvinfo->bus_info, adapter->pdev->slot_name, 32);
#ifdef ETHTOOL_GREGS #ifdef ETHTOOL_GREGS
drvinfo->regdump_len = IXGB_REG_DUMP_LEN; drvinfo->regdump_len = IXGB_REG_DUMP_LEN;
#endif /* ETHTOOL_GREGS */ #endif /* ETHTOOL_GREGS */
drvinfo->eedump_len = ixgb_eeprom_size(&adapter->hw); drvinfo->eedump_len = ixgb_eeprom_size(&adapter->hw);
} }
#ifdef ETHTOOL_GREGS #ifdef ETHTOOL_GREGS
#define IXGB_GET_STAT(_A_, _R_) _A_->stats._R_ #define IXGB_GET_STAT(_A_, _R_) _A_->stats._R_
static void static void
ixgb_ethtool_gregs(struct ixgb_adapter *adapter, ixgb_ethtool_gregs(struct ixgb_adapter *adapter,
struct ethtool_regs *regs, struct ethtool_regs *regs, uint8_t * regs_buff)
uint8_t *regs_buff)
{ {
struct ixgb_hw *hw = &adapter->hw; struct ixgb_hw *hw = &adapter->hw;
uint32_t *reg = (uint32_t *) regs_buff; uint32_t *reg = (uint32_t *) regs_buff;
uint32_t *reg_start = reg; uint32_t *reg_start = reg;
uint8_t i; uint8_t i;
regs->version = regs->version =
(adapter->hw.device_id << 16) | adapter->hw.subsystem_id; (adapter->hw.device_id << 16) | adapter->hw.subsystem_id;
/* General Registers */ /* General Registers */
*reg++ = IXGB_READ_REG(hw, CTRL0); /* 0 */ *reg++ = IXGB_READ_REG(hw, CTRL0); /* 0 */
*reg++ = IXGB_READ_REG(hw, CTRL1); /* 1 */ *reg++ = IXGB_READ_REG(hw, CTRL1); /* 1 */
*reg++ = IXGB_READ_REG(hw, STATUS); /* 2 */ *reg++ = IXGB_READ_REG(hw, STATUS); /* 2 */
*reg++ = IXGB_READ_REG(hw, EECD); /* 3 */ *reg++ = IXGB_READ_REG(hw, EECD); /* 3 */
*reg++ = IXGB_READ_REG(hw, MFS); /* 4 */ *reg++ = IXGB_READ_REG(hw, MFS); /* 4 */
/* Interrupt */ /* Interrupt */
*reg++ = IXGB_READ_REG(hw, ICR); /* 5 */ *reg++ = IXGB_READ_REG(hw, ICR); /* 5 */
*reg++ = IXGB_READ_REG(hw, ICS); /* 6 */ *reg++ = IXGB_READ_REG(hw, ICS); /* 6 */
*reg++ = IXGB_READ_REG(hw, IMS); /* 7 */ *reg++ = IXGB_READ_REG(hw, IMS); /* 7 */
*reg++ = IXGB_READ_REG(hw, IMC); /* 8 */ *reg++ = IXGB_READ_REG(hw, IMC); /* 8 */
/* Receive */ /* Receive */
*reg++ = IXGB_READ_REG(hw, RCTL); /* 9 */ *reg++ = IXGB_READ_REG(hw, RCTL); /* 9 */
*reg++ = IXGB_READ_REG(hw, FCRTL); /* 10 */ *reg++ = IXGB_READ_REG(hw, FCRTL); /* 10 */
*reg++ = IXGB_READ_REG(hw, FCRTH); /* 11 */ *reg++ = IXGB_READ_REG(hw, FCRTH); /* 11 */
*reg++ = IXGB_READ_REG(hw, RDBAL); /* 12 */ *reg++ = IXGB_READ_REG(hw, RDBAL); /* 12 */
*reg++ = IXGB_READ_REG(hw, RDBAH); /* 13 */ *reg++ = IXGB_READ_REG(hw, RDBAH); /* 13 */
*reg++ = IXGB_READ_REG(hw, RDLEN); /* 14 */ *reg++ = IXGB_READ_REG(hw, RDLEN); /* 14 */
*reg++ = IXGB_READ_REG(hw, RDH); /* 15 */ *reg++ = IXGB_READ_REG(hw, RDH); /* 15 */
*reg++ = IXGB_READ_REG(hw, RDT); /* 16 */ *reg++ = IXGB_READ_REG(hw, RDT); /* 16 */
*reg++ = IXGB_READ_REG(hw, RDTR); /* 17 */ *reg++ = IXGB_READ_REG(hw, RDTR); /* 17 */
*reg++ = IXGB_READ_REG(hw, RXDCTL); /* 18 */ *reg++ = IXGB_READ_REG(hw, RXDCTL); /* 18 */
*reg++ = IXGB_READ_REG(hw, RAIDC); /* 19 */ *reg++ = IXGB_READ_REG(hw, RAIDC); /* 19 */
*reg++ = IXGB_READ_REG(hw, RXCSUM); /* 20 */ *reg++ = IXGB_READ_REG(hw, RXCSUM); /* 20 */
for(i = 0; i < IXGB_RAR_ENTRIES; i++) { for (i = 0; i < IXGB_RAR_ENTRIES; i++) {
*reg++ = IXGB_READ_REG_ARRAY(hw, RAL, (i << 1)); /*21,...,51 */ *reg++ = IXGB_READ_REG_ARRAY(hw, RAL, (i << 1)); /*21,...,51 */
*reg++ = IXGB_READ_REG_ARRAY(hw, RAH, (i << 1)); /*22,...,52 */ *reg++ = IXGB_READ_REG_ARRAY(hw, RAH, (i << 1)); /*22,...,52 */
} }
/* Transmit */ /* Transmit */
*reg++ = IXGB_READ_REG(hw, TCTL); /* 53 */ *reg++ = IXGB_READ_REG(hw, TCTL); /* 53 */
*reg++ = IXGB_READ_REG(hw, TDBAL); /* 54 */ *reg++ = IXGB_READ_REG(hw, TDBAL); /* 54 */
*reg++ = IXGB_READ_REG(hw, TDBAH); /* 55 */ *reg++ = IXGB_READ_REG(hw, TDBAH); /* 55 */
*reg++ = IXGB_READ_REG(hw, TDLEN); /* 56 */ *reg++ = IXGB_READ_REG(hw, TDLEN); /* 56 */
*reg++ = IXGB_READ_REG(hw, TDH); /* 57 */ *reg++ = IXGB_READ_REG(hw, TDH); /* 57 */
*reg++ = IXGB_READ_REG(hw, TDT); /* 58 */ *reg++ = IXGB_READ_REG(hw, TDT); /* 58 */
*reg++ = IXGB_READ_REG(hw, TIDV); /* 59 */ *reg++ = IXGB_READ_REG(hw, TIDV); /* 59 */
*reg++ = IXGB_READ_REG(hw, TXDCTL); /* 60 */ *reg++ = IXGB_READ_REG(hw, TXDCTL); /* 60 */
*reg++ = IXGB_READ_REG(hw, TSPMT); /* 61 */ *reg++ = IXGB_READ_REG(hw, TSPMT); /* 61 */
*reg++ = IXGB_READ_REG(hw, PAP); /* 62 */ *reg++ = IXGB_READ_REG(hw, PAP); /* 62 */
/* Physical */ /* Physical */
*reg++ = IXGB_READ_REG(hw, PCSC1); /* 63 */ *reg++ = IXGB_READ_REG(hw, PCSC1); /* 63 */
*reg++ = IXGB_READ_REG(hw, PCSC2); /* 64 */ *reg++ = IXGB_READ_REG(hw, PCSC2); /* 64 */
*reg++ = IXGB_READ_REG(hw, PCSS1); /* 65 */ *reg++ = IXGB_READ_REG(hw, PCSS1); /* 65 */
*reg++ = IXGB_READ_REG(hw, PCSS2); /* 66 */ *reg++ = IXGB_READ_REG(hw, PCSS2); /* 66 */
*reg++ = IXGB_READ_REG(hw, XPCSS); /* 67 */ *reg++ = IXGB_READ_REG(hw, XPCSS); /* 67 */
*reg++ = IXGB_READ_REG(hw, UCCR); /* 68 */ *reg++ = IXGB_READ_REG(hw, UCCR); /* 68 */
*reg++ = IXGB_READ_REG(hw, XPCSTC); /* 69 */ *reg++ = IXGB_READ_REG(hw, XPCSTC); /* 69 */
*reg++ = IXGB_READ_REG(hw, MACA); /* 70 */ *reg++ = IXGB_READ_REG(hw, MACA); /* 70 */
*reg++ = IXGB_READ_REG(hw, APAE); /* 71 */ *reg++ = IXGB_READ_REG(hw, APAE); /* 71 */
*reg++ = IXGB_READ_REG(hw, ARD); /* 72 */ *reg++ = IXGB_READ_REG(hw, ARD); /* 72 */
*reg++ = IXGB_READ_REG(hw, AIS); /* 73 */ *reg++ = IXGB_READ_REG(hw, AIS); /* 73 */
*reg++ = IXGB_READ_REG(hw, MSCA); /* 74 */ *reg++ = IXGB_READ_REG(hw, MSCA); /* 74 */
*reg++ = IXGB_READ_REG(hw, MSRWD); /* 75 */ *reg++ = IXGB_READ_REG(hw, MSRWD); /* 75 */
#if 0 #if 0
/* Wake-up */ /* Wake-up */
reg[IXGB_WUFC] = IXGB_READ_REG(hw, WUFC); reg[IXGB_WUFC] = IXGB_READ_REG(hw, WUFC);
reg[IXGB_WUS] = IXGB_READ_REG(hw, WUS); reg[IXGB_WUS] = IXGB_READ_REG(hw, WUS);
reg[IXGB_FFLT] = IXGB_READ_REG(hw, FFLT); reg[IXGB_FFLT] = IXGB_READ_REG(hw, FFLT);
reg[IXGB_FFMT] = IXGB_READ_REG(hw, FFMT); reg[IXGB_FFMT] = IXGB_READ_REG(hw, FFMT);
reg[IXGB_FTVT] = IXGB_READ_REG(hw, FTVT); reg[IXGB_FTVT] = IXGB_READ_REG(hw, FTVT);
#endif #endif
/* Statistics */ /* Statistics */
*reg++ = IXGB_GET_STAT(adapter, tprl); /* 76 */ *reg++ = IXGB_GET_STAT(adapter, tprl); /* 76 */
*reg++ = IXGB_GET_STAT(adapter, tprh); /* 77 */ *reg++ = IXGB_GET_STAT(adapter, tprh); /* 77 */
*reg++ = IXGB_GET_STAT(adapter, gprcl); /* 78 */ *reg++ = IXGB_GET_STAT(adapter, gprcl); /* 78 */
*reg++ = IXGB_GET_STAT(adapter, gprch); /* 79 */ *reg++ = IXGB_GET_STAT(adapter, gprch); /* 79 */
*reg++ = IXGB_GET_STAT(adapter, bprcl); /* 80 */ *reg++ = IXGB_GET_STAT(adapter, bprcl); /* 80 */
*reg++ = IXGB_GET_STAT(adapter, bprch); /* 81 */ *reg++ = IXGB_GET_STAT(adapter, bprch); /* 81 */
*reg++ = IXGB_GET_STAT(adapter, mprcl); /* 82 */ *reg++ = IXGB_GET_STAT(adapter, mprcl); /* 82 */
*reg++ = IXGB_GET_STAT(adapter, mprch); /* 83 */ *reg++ = IXGB_GET_STAT(adapter, mprch); /* 83 */
*reg++ = IXGB_GET_STAT(adapter, uprcl); /* 84 */ *reg++ = IXGB_GET_STAT(adapter, uprcl); /* 84 */
*reg++ = IXGB_GET_STAT(adapter, uprch); /* 85 */ *reg++ = IXGB_GET_STAT(adapter, uprch); /* 85 */
*reg++ = IXGB_GET_STAT(adapter, vprcl); /* 86 */ *reg++ = IXGB_GET_STAT(adapter, vprcl); /* 86 */
*reg++ = IXGB_GET_STAT(adapter, vprch); /* 87 */ *reg++ = IXGB_GET_STAT(adapter, vprch); /* 87 */
*reg++ = IXGB_GET_STAT(adapter, jprcl); /* 88 */ *reg++ = IXGB_GET_STAT(adapter, jprcl); /* 88 */
*reg++ = IXGB_GET_STAT(adapter, jprch); /* 89 */ *reg++ = IXGB_GET_STAT(adapter, jprch); /* 89 */
*reg++ = IXGB_GET_STAT(adapter, gorcl); /* 90 */ *reg++ = IXGB_GET_STAT(adapter, gorcl); /* 90 */
*reg++ = IXGB_GET_STAT(adapter, gorch); /* 91 */ *reg++ = IXGB_GET_STAT(adapter, gorch); /* 91 */
*reg++ = IXGB_GET_STAT(adapter, torl); /* 92 */ *reg++ = IXGB_GET_STAT(adapter, torl); /* 92 */
*reg++ = IXGB_GET_STAT(adapter, torh); /* 93 */ *reg++ = IXGB_GET_STAT(adapter, torh); /* 93 */
*reg++ = IXGB_GET_STAT(adapter, rnbc); /* 94 */ *reg++ = IXGB_GET_STAT(adapter, rnbc); /* 94 */
*reg++ = IXGB_GET_STAT(adapter, ruc); /* 95 */ *reg++ = IXGB_GET_STAT(adapter, ruc); /* 95 */
*reg++ = IXGB_GET_STAT(adapter, roc); /* 96 */ *reg++ = IXGB_GET_STAT(adapter, roc); /* 96 */
*reg++ = IXGB_GET_STAT(adapter, rlec); /* 97 */ *reg++ = IXGB_GET_STAT(adapter, rlec); /* 97 */
*reg++ = IXGB_GET_STAT(adapter, crcerrs); /* 98 */ *reg++ = IXGB_GET_STAT(adapter, crcerrs); /* 98 */
*reg++ = IXGB_GET_STAT(adapter, icbc); /* 99 */ *reg++ = IXGB_GET_STAT(adapter, icbc); /* 99 */
*reg++ = IXGB_GET_STAT(adapter, ecbc); /* 100 */ *reg++ = IXGB_GET_STAT(adapter, ecbc); /* 100 */
*reg++ = IXGB_GET_STAT(adapter, mpc); /* 101 */ *reg++ = IXGB_GET_STAT(adapter, mpc); /* 101 */
*reg++ = IXGB_GET_STAT(adapter, tptl); /* 102 */ *reg++ = IXGB_GET_STAT(adapter, tptl); /* 102 */
*reg++ = IXGB_GET_STAT(adapter, tpth); /* 103 */ *reg++ = IXGB_GET_STAT(adapter, tpth); /* 103 */
*reg++ = IXGB_GET_STAT(adapter, gptcl); /* 104 */ *reg++ = IXGB_GET_STAT(adapter, gptcl); /* 104 */
*reg++ = IXGB_GET_STAT(adapter, gptch); /* 105 */ *reg++ = IXGB_GET_STAT(adapter, gptch); /* 105 */
*reg++ = IXGB_GET_STAT(adapter, bptcl); /* 106 */ *reg++ = IXGB_GET_STAT(adapter, bptcl); /* 106 */
*reg++ = IXGB_GET_STAT(adapter, bptch); /* 107 */ *reg++ = IXGB_GET_STAT(adapter, bptch); /* 107 */
*reg++ = IXGB_GET_STAT(adapter, mptcl); /* 108 */ *reg++ = IXGB_GET_STAT(adapter, mptcl); /* 108 */
*reg++ = IXGB_GET_STAT(adapter, mptch); /* 109 */ *reg++ = IXGB_GET_STAT(adapter, mptch); /* 109 */
*reg++ = IXGB_GET_STAT(adapter, uptcl); /* 110 */ *reg++ = IXGB_GET_STAT(adapter, uptcl); /* 110 */
*reg++ = IXGB_GET_STAT(adapter, uptch); /* 111 */ *reg++ = IXGB_GET_STAT(adapter, uptch); /* 111 */
*reg++ = IXGB_GET_STAT(adapter, vptcl); /* 112 */ *reg++ = IXGB_GET_STAT(adapter, vptcl); /* 112 */
*reg++ = IXGB_GET_STAT(adapter, vptch); /* 113 */ *reg++ = IXGB_GET_STAT(adapter, vptch); /* 113 */
*reg++ = IXGB_GET_STAT(adapter, jptcl); /* 114 */ *reg++ = IXGB_GET_STAT(adapter, jptcl); /* 114 */
*reg++ = IXGB_GET_STAT(adapter, jptch); /* 115 */ *reg++ = IXGB_GET_STAT(adapter, jptch); /* 115 */
*reg++ = IXGB_GET_STAT(adapter, gotcl); /* 116 */ *reg++ = IXGB_GET_STAT(adapter, gotcl); /* 116 */
*reg++ = IXGB_GET_STAT(adapter, gotch); /* 117 */ *reg++ = IXGB_GET_STAT(adapter, gotch); /* 117 */
*reg++ = IXGB_GET_STAT(adapter, totl); /* 118 */ *reg++ = IXGB_GET_STAT(adapter, totl); /* 118 */
*reg++ = IXGB_GET_STAT(adapter, toth); /* 119 */ *reg++ = IXGB_GET_STAT(adapter, toth); /* 119 */
*reg++ = IXGB_GET_STAT(adapter, dc); /* 120 */ *reg++ = IXGB_GET_STAT(adapter, dc); /* 120 */
*reg++ = IXGB_GET_STAT(adapter, plt64c); /* 121 */ *reg++ = IXGB_GET_STAT(adapter, plt64c); /* 121 */
*reg++ = IXGB_GET_STAT(adapter, tsctc); /* 122 */ *reg++ = IXGB_GET_STAT(adapter, tsctc); /* 122 */
*reg++ = IXGB_GET_STAT(adapter, tsctfc); /* 123 */ *reg++ = IXGB_GET_STAT(adapter, tsctfc); /* 123 */
*reg++ = IXGB_GET_STAT(adapter, ibic); /* 124 */ *reg++ = IXGB_GET_STAT(adapter, ibic); /* 124 */
*reg++ = IXGB_GET_STAT(adapter, rfc); /* 125 */ *reg++ = IXGB_GET_STAT(adapter, rfc); /* 125 */
*reg++ = IXGB_GET_STAT(adapter, lfc); /* 126 */ *reg++ = IXGB_GET_STAT(adapter, lfc); /* 126 */
*reg++ = IXGB_GET_STAT(adapter, pfrc); /* 127 */ *reg++ = IXGB_GET_STAT(adapter, pfrc); /* 127 */
*reg++ = IXGB_GET_STAT(adapter, pftc); /* 128 */ *reg++ = IXGB_GET_STAT(adapter, pftc); /* 128 */
*reg++ = IXGB_GET_STAT(adapter, mcfrc); /* 129 */ *reg++ = IXGB_GET_STAT(adapter, mcfrc); /* 129 */
*reg++ = IXGB_GET_STAT(adapter, mcftc); /* 130 */ *reg++ = IXGB_GET_STAT(adapter, mcftc); /* 130 */
*reg++ = IXGB_GET_STAT(adapter, xonrxc); /* 131 */ *reg++ = IXGB_GET_STAT(adapter, xonrxc); /* 131 */
*reg++ = IXGB_GET_STAT(adapter, xontxc); /* 132 */ *reg++ = IXGB_GET_STAT(adapter, xontxc); /* 132 */
*reg++ = IXGB_GET_STAT(adapter, xoffrxc); /* 133 */ *reg++ = IXGB_GET_STAT(adapter, xoffrxc); /* 133 */
*reg++ = IXGB_GET_STAT(adapter, xofftxc); /* 134 */ *reg++ = IXGB_GET_STAT(adapter, xofftxc); /* 134 */
*reg++ = IXGB_GET_STAT(adapter, rjc); /* 135 */ *reg++ = IXGB_GET_STAT(adapter, rjc); /* 135 */
#if 0 #if 0
#endif #endif
regs->len = (reg - reg_start) * sizeof(uint32_t); regs->len = (reg - reg_start) * sizeof (uint32_t);
} }
#endif /* ETHTOOL_GREGS */ #endif /* ETHTOOL_GREGS */
static int static int
ixgb_ethtool_geeprom(struct ixgb_adapter *adapter, ixgb_ethtool_geeprom(struct ixgb_adapter *adapter,
struct ethtool_eeprom *eeprom, struct ethtool_eeprom *eeprom, uint16_t * eeprom_buff)
uint16_t *eeprom_buff)
{ {
struct ixgb_hw *hw = &adapter->hw; struct ixgb_hw *hw = &adapter->hw;
int i, max_len, first_word, last_word; int i, max_len, first_word, last_word;
IXGB_DBG("ixgb_ethtool_geeprom\n"); IXGB_DBG("ixgb_ethtool_geeprom\n");
if (eeprom->len == 0) if (eeprom->len == 0)
return -EINVAL; return -EINVAL;
eeprom->magic = hw->vendor_id | (hw->device_id << 16); eeprom->magic = hw->vendor_id | (hw->device_id << 16);
max_len = ixgb_eeprom_size(hw); max_len = ixgb_eeprom_size(hw);
/* use our function to read the eeprom and update our cache */ /* use our function to read the eeprom and update our cache */
ixgb_get_eeprom_data(hw); ixgb_get_eeprom_data(hw);
if(eeprom->offset > eeprom->offset + eeprom->len) if (eeprom->offset > eeprom->offset + eeprom->len)
return -EINVAL; return -EINVAL;
if((eeprom->offset + eeprom->len) > max_len) if ((eeprom->offset + eeprom->len) > max_len)
eeprom->len = (max_len - eeprom->offset); eeprom->len = (max_len - eeprom->offset);
first_word = eeprom->offset >> 1; first_word = eeprom->offset >> 1;
last_word = (eeprom->offset + eeprom->len - 1) >> 1; last_word = (eeprom->offset + eeprom->len - 1) >> 1;
for(i = 0; i <= (last_word - first_word); i++) { for (i = 0; i <= (last_word - first_word); i++) {
eeprom_buff[i] = hw->eeprom[first_word + i]; eeprom_buff[i] = hw->eeprom[first_word + i];
} }
return 0; return 0;
} }
static int static int
ixgb_ethtool_seeprom(struct ixgb_adapter *adapter, ixgb_ethtool_seeprom(struct ixgb_adapter *adapter,
struct ethtool_eeprom *eeprom, void *user_data) struct ethtool_eeprom *eeprom, void *user_data)
{ {
struct ixgb_hw *hw = &adapter->hw; struct ixgb_hw *hw = &adapter->hw;
uint16_t eeprom_buff[256]; uint16_t eeprom_buff[256];
int i, max_len, first_word, last_word; int i, max_len, first_word, last_word;
void *ptr; void *ptr;
if(eeprom->magic != (hw->vendor_id | (hw->device_id << 16))) if (eeprom->magic != (hw->vendor_id | (hw->device_id << 16)))
return -EFAULT; return -EFAULT;
if(eeprom->len == 0) if (eeprom->len == 0)
return -EINVAL; return -EINVAL;
max_len = ixgb_eeprom_size(hw); max_len = ixgb_eeprom_size(hw);
if(eeprom->offset > eeprom->offset + eeprom->len) if (eeprom->offset > eeprom->offset + eeprom->len)
return -EINVAL; return -EINVAL;
if((eeprom->offset + eeprom->len) > max_len) if ((eeprom->offset + eeprom->len) > max_len)
eeprom->len = (max_len - eeprom->offset); eeprom->len = (max_len - eeprom->offset);
first_word = eeprom->offset >> 1; first_word = eeprom->offset >> 1;
last_word = (eeprom->offset + eeprom->len - 1) >> 1; last_word = (eeprom->offset + eeprom->len - 1) >> 1;
ptr = (void *)eeprom_buff; ptr = (void *) eeprom_buff;
if(eeprom->offset & 1) { if (eeprom->offset & 1) {
/* need read/modify/write of first changed EEPROM word */ /* need read/modify/write of first changed EEPROM word */
/* only the second byte of the word is being modified */ /* only the second byte of the word is being modified */
eeprom_buff[0] = ixgb_read_eeprom(hw, first_word); eeprom_buff[0] = ixgb_read_eeprom(hw, first_word);
ptr++; ptr++;
} }
if((eeprom->offset + eeprom->len) & 1) { if ((eeprom->offset + eeprom->len) & 1) {
/* need read/modify/write of last changed EEPROM word */ /* need read/modify/write of last changed EEPROM word */
/* only the first byte of the word is being modified */ /* only the first byte of the word is being modified */
eeprom_buff[last_word - first_word] eeprom_buff[last_word - first_word]
= ixgb_read_eeprom(hw, last_word); = ixgb_read_eeprom(hw, last_word);
} }
if(copy_from_user(ptr, user_data, eeprom->len)) if (copy_from_user(ptr, user_data, eeprom->len))
return -EFAULT; return -EFAULT;
for(i = 0; i <= (last_word - first_word); i++) for (i = 0; i <= (last_word - first_word); i++)
ixgb_write_eeprom(hw, first_word + i, eeprom_buff[i]); ixgb_write_eeprom(hw, first_word + i, eeprom_buff[i]);
/* Update the checksum over the first part of the EEPROM if needed */ /* Update the checksum over the first part of the EEPROM if needed */
if(first_word <= EEPROM_CHECKSUM_REG) if (first_word <= EEPROM_CHECKSUM_REG)
ixgb_update_eeprom_checksum(hw); ixgb_update_eeprom_checksum(hw);
return 0; return 0;
} }
#ifdef ETHTOOL_PHYS_ID #ifdef ETHTOOL_PHYS_ID
...@@ -378,184 +373,183 @@ ixgb_ethtool_seeprom(struct ixgb_adapter *adapter, ...@@ -378,184 +373,183 @@ ixgb_ethtool_seeprom(struct ixgb_adapter *adapter,
static void static void
ixgb_led_blink_callback(unsigned long data) ixgb_led_blink_callback(unsigned long data)
{ {
struct ixgb_adapter *adapter = (struct ixgb_adapter *) data; struct ixgb_adapter *adapter = (struct ixgb_adapter *) data;
if(test_and_change_bit(IXGB_LED_ON, &adapter->led_status)) if (test_and_change_bit(IXGB_LED_ON, &adapter->led_status))
ixgb_led_off(&adapter->hw); ixgb_led_off(&adapter->hw);
else else
ixgb_led_on(&adapter->hw); ixgb_led_on(&adapter->hw);
mod_timer(&adapter->blink_timer, jiffies + IXGB_ID_INTERVAL); mod_timer(&adapter->blink_timer, jiffies + IXGB_ID_INTERVAL);
} }
static int static int
ixgb_ethtool_led_blink(struct ixgb_adapter *adapter, ixgb_ethtool_led_blink(struct ixgb_adapter *adapter, struct ethtool_value *id)
struct ethtool_value *id)
{ {
if(!adapter->blink_timer.function) { if (!adapter->blink_timer.function) {
init_timer(&adapter->blink_timer); init_timer(&adapter->blink_timer);
adapter->blink_timer.function = ixgb_led_blink_callback; adapter->blink_timer.function = ixgb_led_blink_callback;
adapter->blink_timer.data = (unsigned long) adapter; adapter->blink_timer.data = (unsigned long) adapter;
} }
mod_timer(&adapter->blink_timer, jiffies); mod_timer(&adapter->blink_timer, jiffies);
set_current_state(TASK_INTERRUPTIBLE); set_current_state(TASK_INTERRUPTIBLE);
if(id->data) if (id->data)
schedule_timeout(id->data * HZ); schedule_timeout(id->data * HZ);
else else
schedule_timeout(MAX_SCHEDULE_TIMEOUT); schedule_timeout(MAX_SCHEDULE_TIMEOUT);
del_timer_sync(&adapter->blink_timer); del_timer_sync(&adapter->blink_timer);
ixgb_led_off(&adapter->hw); ixgb_led_off(&adapter->hw);
clear_bit(IXGB_LED_ON, &adapter->led_status); clear_bit(IXGB_LED_ON, &adapter->led_status);
return 0; return 0;
} }
#endif /* ETHTOOL_PHYS_ID */ #endif /* ETHTOOL_PHYS_ID */
int int
ixgb_ethtool_ioctl(struct net_device *netdev, ixgb_ethtool_ioctl(struct net_device *netdev, struct ifreq *ifr)
struct ifreq *ifr)
{ {
struct ixgb_adapter *adapter = netdev->priv; struct ixgb_adapter *adapter = netdev->priv;
void *addr = ifr->ifr_data; void *addr = ifr->ifr_data;
uint32_t cmd; uint32_t cmd;
if(get_user(cmd, (uint32_t *) addr)) if (get_user(cmd, (uint32_t *) addr))
return -EFAULT; return -EFAULT;
switch (cmd) { switch (cmd) {
#if 0 #if 0
case ETHTOOL_PROMISCUOUS: { case ETHTOOL_PROMISCUOUS:{
struct ethtool_pmode pmode; struct ethtool_pmode pmode;
if(copy_from_user(&pmode, addr, sizeof(pmode))) if (copy_from_user(&pmode, addr, sizeof (pmode)))
return -EFAULT; return -EFAULT;
ixgb_ethtool_promiscuous(adapter, &pmode); ixgb_ethtool_promiscuous(adapter, &pmode);
if(copy_to_user(addr, &pmode, sizeof(pmode))) if (copy_to_user(addr, &pmode, sizeof (pmode)))
return -EFAULT; return -EFAULT;
return 0; return 0;
} }
case ETHTOOL_DOWN_UP: case ETHTOOL_DOWN_UP:
ixgb_down(netdev->priv); ixgb_down(netdev->priv);
ixgb_up(netdev->priv); ixgb_up(netdev->priv);
return 0; return 0;
#endif #endif
case ETHTOOL_GSET: { case ETHTOOL_GSET:{
struct ethtool_cmd ecmd = { ETHTOOL_GSET }; struct ethtool_cmd ecmd = { ETHTOOL_GSET };
ixgb_ethtool_gset(adapter, &ecmd); ixgb_ethtool_gset(adapter, &ecmd);
if(copy_to_user(addr, &ecmd, sizeof(ecmd))) if (copy_to_user(addr, &ecmd, sizeof (ecmd)))
return -EFAULT; return -EFAULT;
return 0; return 0;
} }
case ETHTOOL_SSET: { case ETHTOOL_SSET:{
struct ethtool_cmd ecmd; struct ethtool_cmd ecmd;
if(!capable(CAP_NET_ADMIN)) if (!capable(CAP_NET_ADMIN))
return -EPERM; return -EPERM;
if(copy_from_user(&ecmd, addr, sizeof(ecmd))) if (copy_from_user(&ecmd, addr, sizeof (ecmd)))
return -EFAULT; return -EFAULT;
return ixgb_ethtool_sset(adapter, &ecmd); return ixgb_ethtool_sset(adapter, &ecmd);
} }
case ETHTOOL_GDRVINFO: case ETHTOOL_GDRVINFO:
{ {
struct ethtool_drvinfo drvinfo = { ETHTOOL_GDRVINFO }; struct ethtool_drvinfo drvinfo = { ETHTOOL_GDRVINFO };
ixgb_ethtool_gdrvinfo(adapter, &drvinfo); ixgb_ethtool_gdrvinfo(adapter, &drvinfo);
if(copy_to_user(addr, &drvinfo, sizeof(drvinfo))) if (copy_to_user(addr, &drvinfo, sizeof (drvinfo)))
return -EFAULT; return -EFAULT;
return 0; return 0;
} }
#if defined(ETHTOOL_GREGS) && defined(ETHTOOL_GEEPROM) #if defined(ETHTOOL_GREGS) && defined(ETHTOOL_GEEPROM)
case ETHTOOL_GREGS: { case ETHTOOL_GREGS:{
struct ethtool_regs regs = { ETHTOOL_GREGS }; struct ethtool_regs regs = { ETHTOOL_GREGS };
uint8_t regs_buff[IXGB_REG_DUMP_LEN]; uint8_t regs_buff[IXGB_REG_DUMP_LEN];
ixgb_ethtool_gregs(adapter, &regs, regs_buff); ixgb_ethtool_gregs(adapter, &regs, regs_buff);
if(copy_to_user(addr, &regs, sizeof(regs))) if (copy_to_user(addr, &regs, sizeof (regs)))
return -EFAULT; return -EFAULT;
addr += offsetof(struct ethtool_regs, data); addr += offsetof(struct ethtool_regs, data);
if(copy_to_user(addr, regs_buff, regs.len)) if (copy_to_user(addr, regs_buff, regs.len))
return -EFAULT; return -EFAULT;
return 0; return 0;
} }
#endif /* ETHTOOL_GREGS */ #endif /* ETHTOOL_GREGS */
case ETHTOOL_NWAY_RST: { case ETHTOOL_NWAY_RST:{
IXGB_DBG("ETHTOOL_NWAY_RST\n"); IXGB_DBG("ETHTOOL_NWAY_RST\n");
if(!capable(CAP_NET_ADMIN)) if (!capable(CAP_NET_ADMIN))
return -EPERM; return -EPERM;
ixgb_down(adapter); ixgb_down(adapter);
ixgb_up(adapter); ixgb_up(adapter);
return 0; return 0;
} }
#ifdef ETHTOOL_PHYS_ID #ifdef ETHTOOL_PHYS_ID
case ETHTOOL_PHYS_ID: { case ETHTOOL_PHYS_ID:{
struct ethtool_value id; struct ethtool_value id;
IXGB_DBG("ETHTOOL_PHYS_ID\n"); IXGB_DBG("ETHTOOL_PHYS_ID\n");
if(copy_from_user(&id, addr, sizeof(id))) if (copy_from_user(&id, addr, sizeof (id)))
return -EFAULT; return -EFAULT;
return ixgb_ethtool_led_blink(adapter, &id); return ixgb_ethtool_led_blink(adapter, &id);
} }
#endif /* ETHTOOL_PHYS_ID */ #endif /* ETHTOOL_PHYS_ID */
case ETHTOOL_GLINK: { case ETHTOOL_GLINK:{
struct ethtool_value link = { ETHTOOL_GLINK }; struct ethtool_value link = { ETHTOOL_GLINK };
IXGB_DBG("ETHTOOL_GLINK\n"); IXGB_DBG("ETHTOOL_GLINK\n");
link.data = netif_carrier_ok(netdev); link.data = netif_carrier_ok(netdev);
if(copy_to_user(addr, &link, sizeof(link))) if (copy_to_user(addr, &link, sizeof (link)))
return -EFAULT; return -EFAULT;
return 0; return 0;
} }
case ETHTOOL_GEEPROM: { case ETHTOOL_GEEPROM:{
struct ethtool_eeprom eeprom = { ETHTOOL_GEEPROM }; struct ethtool_eeprom eeprom = { ETHTOOL_GEEPROM };
uint16_t eeprom_buff[IXGB_EEPROM_SIZE]; uint16_t eeprom_buff[IXGB_EEPROM_SIZE];
void *ptr; void *ptr;
int err; int err;
IXGB_DBG("ETHTOOL_GEEPROM\n"); IXGB_DBG("ETHTOOL_GEEPROM\n");
if(copy_from_user(&eeprom, addr, sizeof(eeprom))) if (copy_from_user(&eeprom, addr, sizeof (eeprom)))
return -EFAULT; return -EFAULT;
if ((err = ixgb_ethtool_geeprom(adapter, &eeprom, eeprom_buff))<0) if ((err =
return err; ixgb_ethtool_geeprom(adapter, &eeprom,
eeprom_buff)) < 0)
if(copy_to_user(addr, &eeprom, sizeof(eeprom))) return err;
return -EFAULT;
if (copy_to_user(addr, &eeprom, sizeof (eeprom)))
addr += offsetof(struct ethtool_eeprom, data); return -EFAULT;
ptr = ((void *)eeprom_buff) + (eeprom.offset & 1); addr += offsetof(struct ethtool_eeprom, data);
if(copy_to_user(addr, ptr, eeprom.len))
return -EFAULT; ptr = ((void *) eeprom_buff) + (eeprom.offset & 1);
return 0; if (copy_to_user(addr, ptr, eeprom.len))
} return -EFAULT;
case ETHTOOL_SEEPROM: { return 0;
struct ethtool_eeprom eeprom; }
case ETHTOOL_SEEPROM:{
IXGB_DBG("ETHTOOL_SEEPROM\n"); struct ethtool_eeprom eeprom;
if(!capable(CAP_NET_ADMIN))
return -EPERM; IXGB_DBG("ETHTOOL_SEEPROM\n");
if (!capable(CAP_NET_ADMIN))
if(copy_from_user(&eeprom, addr, sizeof(eeprom))) return -EPERM;
return -EFAULT;
if (copy_from_user(&eeprom, addr, sizeof (eeprom)))
addr += offsetof(struct ethtool_eeprom, data); return -EFAULT;
return ixgb_ethtool_seeprom(adapter, &eeprom, addr);
} addr += offsetof(struct ethtool_eeprom, data);
default: return ixgb_ethtool_seeprom(adapter, &eeprom, addr);
return -EOPNOTSUPP; }
} default:
return -EOPNOTSUPP;
}
} }
drivers/net/ixgb/ixgb_hw.c
View file @ ca247341
...@@ -25,7 +25,6 @@ ...@@ -25,7 +25,6 @@
Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497 Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
*******************************************************************************/ *******************************************************************************/
/* ixgb_hw.c /* ixgb_hw.c
* Shared functions for accessing and configuring the adapter * Shared functions for accessing and configuring the adapter
*/ */
...@@ -35,52 +34,46 @@ ...@@ -35,52 +34,46 @@
/* Local function prototypes */ /* Local function prototypes */
static uint32_t ixgb_hash_mc_addr(struct ixgb_hw *hw, static uint32_t ixgb_hash_mc_addr(struct ixgb_hw *hw, uint8_t * mc_addr);
uint8_t *mc_addr);
static void ixgb_mta_set(struct ixgb_hw *hw, static void ixgb_mta_set(struct ixgb_hw *hw, uint32_t hash_value);
uint32_t hash_value);
static void ixgb_get_bus_info(struct ixgb_hw *hw); static void ixgb_get_bus_info(struct ixgb_hw *hw);
boolean_t mac_addr_valid(uint8_t *mac_addr); boolean_t mac_addr_valid(uint8_t * mac_addr);
static boolean_t ixgb_link_reset(struct ixgb_hw *hw); static boolean_t ixgb_link_reset(struct ixgb_hw *hw);
static void ixgb_optics_reset(struct ixgb_hw *hw); static void ixgb_optics_reset(struct ixgb_hw *hw);
uint32_t ixgb_mac_reset (struct ixgb_hw* hw); uint32_t ixgb_mac_reset(struct ixgb_hw *hw);
uint32_t ixgb_mac_reset (struct ixgb_hw* hw) uint32_t
ixgb_mac_reset(struct ixgb_hw *hw)
{ {
uint32_t ctrl_reg; uint32_t ctrl_reg;
/* Setup up hardware to known state with RESET. */ /* Setup up hardware to known state with RESET. */
ctrl_reg = IXGB_CTRL0_RST | ctrl_reg = IXGB_CTRL0_RST | IXGB_CTRL0_SDP3_DIR | /* All pins are Output=1 */
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_DIR | IXGB_CTRL0_SDP2 | IXGB_CTRL0_SDP0;
IXGB_CTRL0_SDP1_DIR |
IXGB_CTRL0_SDP0_DIR |
IXGB_CTRL0_SDP3 | /* Initial value 1101 */
IXGB_CTRL0_SDP2 |
IXGB_CTRL0_SDP0;
#ifdef HP_ZX1 #ifdef HP_ZX1
outl(IXGB_CTRL0, hw->io_base); outl(IXGB_CTRL0, hw->io_base);
outl(ctrl_reg, hw->io_base + 4); outl(ctrl_reg, hw->io_base + 4);
#else #else
IXGB_WRITE_REG(hw, CTRL0, ctrl_reg); IXGB_WRITE_REG(hw, CTRL0, ctrl_reg);
#endif #endif
/* Delay a few ms just to allow the reset to complete */ /* Delay a few ms just to allow the reset to complete */
msec_delay(IXGB_DELAY_AFTER_RESET); msec_delay(IXGB_DELAY_AFTER_RESET);
ctrl_reg = IXGB_READ_REG(hw, CTRL0); ctrl_reg = IXGB_READ_REG(hw, CTRL0);
#if DBG #if DBG
/* Make sure the self-clearing global reset bit did self clear */ /* Make sure the self-clearing global reset bit did self clear */
ASSERT(!(ctrl_reg & IXGB_CTRL0_RST)); ASSERT(!(ctrl_reg & IXGB_CTRL0_RST));
#endif #endif
ixgb_optics_reset(hw); ixgb_optics_reset(hw);
return ctrl_reg; return ctrl_reg;
} }
/****************************************************************************** /******************************************************************************
...@@ -89,55 +82,55 @@ uint32_t ixgb_mac_reset (struct ixgb_hw* hw) ...@@ -89,55 +82,55 @@ uint32_t ixgb_mac_reset (struct ixgb_hw* hw)
* hw - Struct containing variables accessed by shared code * hw - Struct containing variables accessed by shared code
*****************************************************************************/ *****************************************************************************/
boolean_t boolean_t
ixgb_adapter_stop(struct ixgb_hw *hw) ixgb_adapter_stop(struct ixgb_hw * hw)
{ {
uint32_t ctrl_reg; uint32_t ctrl_reg;
uint32_t icr_reg; uint32_t icr_reg;
DEBUGFUNC("ixgb_adapter_stop"); DEBUGFUNC("ixgb_adapter_stop");
/* If we are stopped or resetting exit gracefully and wait to be /* If we are stopped or resetting exit gracefully and wait to be
* started again before accessing the hardware. * started again before accessing the hardware.
*/ */
if(hw->adapter_stopped) { if (hw->adapter_stopped) {
DEBUGOUT("Exiting because the adapter is already stopped!!!\n"); DEBUGOUT("Exiting because the adapter is already stopped!!!\n");
return FALSE; return FALSE;
} }
/* Set the Adapter Stopped flag so other driver functions stop /* Set the Adapter Stopped flag so other driver functions stop
* touching the Hardware. * touching the Hardware.
*/ */
hw->adapter_stopped = TRUE; hw->adapter_stopped = TRUE;
/* Clear interrupt mask to stop board from generating interrupts */ /* Clear interrupt mask to stop board from generating interrupts */
DEBUGOUT("Masking off all interrupts\n"); DEBUGOUT("Masking off all interrupts\n");
IXGB_WRITE_REG(hw, IMC, 0xFFFFFFFF); IXGB_WRITE_REG(hw, IMC, 0xFFFFFFFF);
/* Disable the Transmit and Receive units. Then delay to allow /* Disable the Transmit and Receive units. Then delay to allow
* any pending transactions to complete before we hit the MAC with * any pending transactions to complete before we hit the MAC with
* the global reset. * the global reset.
*/ */
IXGB_WRITE_REG(hw, RCTL, IXGB_READ_REG(hw, RCTL) & ~IXGB_RCTL_RXEN); 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); IXGB_WRITE_REG(hw, TCTL, IXGB_READ_REG(hw, TCTL) & ~IXGB_TCTL_TXEN);
msec_delay(IXGB_DELAY_BEFORE_RESET); msec_delay(IXGB_DELAY_BEFORE_RESET);
/* Issue a global reset to the MAC. This will reset the chip's /* Issue a global reset to the MAC. This will reset the chip's
* transmit, receive, DMA, and link units. It will not effect * transmit, receive, DMA, and link units. It will not effect
* the current PCI configuration. The global reset bit is self- * the current PCI configuration. The global reset bit is self-
* clearing, and should clear within a microsecond. * clearing, and should clear within a microsecond.
*/ */
DEBUGOUT("Issuing a global reset to MAC\n"); DEBUGOUT("Issuing a global reset to MAC\n");
ctrl_reg = ixgb_mac_reset(hw); ctrl_reg = ixgb_mac_reset(hw);
/* Clear interrupt mask to stop board from generating interrupts */ /* Clear interrupt mask to stop board from generating interrupts */
DEBUGOUT("Masking off all interrupts\n"); DEBUGOUT("Masking off all interrupts\n");
IXGB_WRITE_REG(hw, IMC, 0xffffffff); IXGB_WRITE_REG(hw, IMC, 0xffffffff);
/* Clear any pending interrupt events. */ /* Clear any pending interrupt events. */
icr_reg = IXGB_READ_REG(hw, ICR); icr_reg = IXGB_READ_REG(hw, ICR);
return (ctrl_reg & IXGB_CTRL0_RST); return (ctrl_reg & IXGB_CTRL0_RST);
} }
/****************************************************************************** /******************************************************************************
...@@ -158,77 +151,76 @@ ixgb_adapter_stop(struct ixgb_hw *hw) ...@@ -158,77 +151,76 @@ ixgb_adapter_stop(struct ixgb_hw *hw)
* FALSE if unrecoverable problems were encountered. * FALSE if unrecoverable problems were encountered.
*****************************************************************************/ *****************************************************************************/
boolean_t boolean_t
ixgb_init_hw(struct ixgb_hw *hw) ixgb_init_hw(struct ixgb_hw * hw)
{ {
uint32_t i; uint32_t i;
uint32_t ctrl_reg; uint32_t ctrl_reg;
boolean_t status; boolean_t status;
DEBUGFUNC("ixgb_init_hw"); DEBUGFUNC("ixgb_init_hw");
/* Issue a global reset to the MAC. This will reset the chip's /* Issue a global reset to the MAC. This will reset the chip's
* transmit, receive, DMA, and link units. It will not effect * transmit, receive, DMA, and link units. It will not effect
* the current PCI configuration. The global reset bit is self- * the current PCI configuration. The global reset bit is self-
* clearing, and should clear within a microsecond. * clearing, and should clear within a microsecond.
*/ */
DEBUGOUT("Issuing a global reset to MAC\n"); DEBUGOUT("Issuing a global reset to MAC\n");
ctrl_reg = ixgb_mac_reset(hw); ctrl_reg = ixgb_mac_reset(hw);
DEBUGOUT("Issuing an EE reset to MAC\n"); DEBUGOUT("Issuing an EE reset to MAC\n");
#ifdef HP_ZX1 #ifdef HP_ZX1
outl(IXGB_CTRL1, hw->io_base); outl(IXGB_CTRL1, hw->io_base);
outl(IXGB_CTRL1_EE_RST, hw->io_base + 4); outl(IXGB_CTRL1_EE_RST, hw->io_base + 4);
#else #else
IXGB_WRITE_REG(hw, CTRL1, IXGB_CTRL1_EE_RST); IXGB_WRITE_REG(hw, CTRL1, IXGB_CTRL1_EE_RST);
#endif #endif
/* Delay a few ms just to allow the reset to complete */ /* Delay a few ms just to allow the reset to complete */
msec_delay(IXGB_DELAY_AFTER_EE_RESET); msec_delay(IXGB_DELAY_AFTER_EE_RESET);
if (ixgb_get_eeprom_data(hw) == FALSE) { if (ixgb_get_eeprom_data(hw) == FALSE) {
return(FALSE); return (FALSE);
} }
/* Setup the receive addresses. /* Setup the receive addresses.
* Receive Address Registers (RARs 0 - 15). * Receive Address Registers (RARs 0 - 15).
*/ */
ixgb_init_rx_addrs(hw); ixgb_init_rx_addrs(hw);
/* /*
* Check that a valid MAC address has been set. * Check that a valid MAC address has been set.
* If it is not valid, we fail hardware init. * If it is not valid, we fail hardware init.
*/ */
if (!mac_addr_valid(hw->curr_mac_addr)) { if (!mac_addr_valid(hw->curr_mac_addr)) {
DEBUGOUT("MAC address invalid after ixgb_init_rx_addrs\n"); DEBUGOUT("MAC address invalid after ixgb_init_rx_addrs\n");
return(FALSE); return (FALSE);
} }
/* tell the routines in this file they can access hardware again */
hw->adapter_stopped = FALSE;
/* tell the routines in this file they can access hardware again */ /* Fill in the bus_info structure */
hw->adapter_stopped = FALSE; ixgb_get_bus_info(hw);
/* Fill in the bus_info structure */ /* Zero out the Multicast HASH table */
ixgb_get_bus_info(hw); 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 Multicast HASH table */ /* Zero out the VLAN Filter Table Array */
DEBUGOUT("Zeroing the MTA\n"); ixgb_clear_vfta(hw);
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 */ /* Zero all of the hardware counters */
ixgb_clear_hw_cntrs(hw); ixgb_clear_hw_cntrs(hw);
/* Call a subroutine to setup flow control. */ /* Call a subroutine to setup flow control. */
status = ixgb_setup_fc(hw); status = ixgb_setup_fc(hw);
/* check-for-link in case lane deskew is locked */ /* check-for-link in case lane deskew is locked */
ixgb_check_for_link(hw); ixgb_check_for_link(hw);
return (status); return (status);
} }
/****************************************************************************** /******************************************************************************
...@@ -243,53 +235,48 @@ ixgb_init_hw(struct ixgb_hw *hw) ...@@ -243,53 +235,48 @@ ixgb_init_hw(struct ixgb_hw *hw)
void void
ixgb_init_rx_addrs(struct ixgb_hw *hw) ixgb_init_rx_addrs(struct ixgb_hw *hw)
{ {
uint32_t i; uint32_t i;
DEBUGFUNC("ixgb_init_rx_addrs"); DEBUGFUNC("ixgb_init_rx_addrs");
/* /*
* If the current mac address is valid, assume it is a software override * If the current mac address is valid, assume it is a software override
* to the permanent address. * to the permanent address.
* Otherwise, use the permanent address from the eeprom. * Otherwise, use the permanent address from the eeprom.
*/ */
if (!mac_addr_valid(hw->curr_mac_addr)) { if (!mac_addr_valid(hw->curr_mac_addr)) {
/* Get the MAC address from the eeprom for later reference */ /* Get the MAC address from the eeprom for later reference */
ixgb_get_ee_mac_addr(hw, hw->curr_mac_addr); ixgb_get_ee_mac_addr(hw, hw->curr_mac_addr);
DEBUGOUT3(" Keeping Permanent MAC Addr =%.2X %.2X %.2X ", DEBUGOUT3(" Keeping Permanent MAC Addr =%.2X %.2X %.2X ",
hw->curr_mac_addr[0], hw->curr_mac_addr[0],
hw->curr_mac_addr[1], hw->curr_mac_addr[1], hw->curr_mac_addr[2]);
hw->curr_mac_addr[2]); DEBUGOUT3("%.2X %.2X %.2X\n",
DEBUGOUT3("%.2X %.2X %.2X\n", hw->curr_mac_addr[3],
hw->curr_mac_addr[3], hw->curr_mac_addr[4], hw->curr_mac_addr[5]);
hw->curr_mac_addr[4], } else {
hw->curr_mac_addr[5]);
} else { /* Setup the receive address. */
DEBUGOUT("Overriding MAC Address in RAR[0]\n");
/* Setup the receive address. */ DEBUGOUT3(" New MAC Addr =%.2X %.2X %.2X ",
DEBUGOUT("Overriding MAC Address in RAR[0]\n"); hw->curr_mac_addr[0],
DEBUGOUT3(" New MAC Addr =%.2X %.2X %.2X ", hw->curr_mac_addr[1], hw->curr_mac_addr[2]);
hw->curr_mac_addr[0], DEBUGOUT3("%.2X %.2X %.2X\n",
hw->curr_mac_addr[1], hw->curr_mac_addr[3],
hw->curr_mac_addr[2]); hw->curr_mac_addr[4], hw->curr_mac_addr[5]);
DEBUGOUT3("%.2X %.2X %.2X\n",
hw->curr_mac_addr[3], ixgb_rar_set(hw, hw->curr_mac_addr, 0);
hw->curr_mac_addr[4], }
hw->curr_mac_addr[5]);
/* Zero out the other 15 receive addresses. */
DEBUGOUT("Clearing RAR[1-15]\n");
ixgb_rar_set(hw, hw->curr_mac_addr, 0); for (i = 1; i < IXGB_RAR_ENTRIES; i++) {
} IXGB_WRITE_REG_ARRAY(hw, RA, (i << 1), 0);
IXGB_WRITE_REG_ARRAY(hw, RA, ((i << 1) + 1), 0);
/* Zero out the other 15 receive addresses. */ }
DEBUGOUT("Clearing RAR[1-15]\n");
for(i = 1; i < IXGB_RAR_ENTRIES; i++) { return;
IXGB_WRITE_REG_ARRAY(hw, RA, (i << 1), 0);
IXGB_WRITE_REG_ARRAY(hw, RA, ((i << 1) + 1), 0);
}
return;
} }
/****************************************************************************** /******************************************************************************
...@@ -307,65 +294,72 @@ ixgb_init_rx_addrs(struct ixgb_hw *hw) ...@@ -307,65 +294,72 @@ ixgb_init_rx_addrs(struct ixgb_hw *hw)
*****************************************************************************/ *****************************************************************************/
void void
ixgb_mc_addr_list_update(struct ixgb_hw *hw, ixgb_mc_addr_list_update(struct ixgb_hw *hw,
uint8_t *mc_addr_list, uint8_t * mc_addr_list,
uint32_t mc_addr_count, uint32_t mc_addr_count, uint32_t pad)
uint32_t pad)
{ {
uint32_t hash_value; uint32_t hash_value;
uint32_t i; uint32_t i;
uint32_t rar_used_count = 1; /* RAR[0] is used for our MAC address */ uint32_t rar_used_count = 1; /* RAR[0] is used for our MAC address */
DEBUGFUNC("ixgb_mc_addr_list_update"); DEBUGFUNC("ixgb_mc_addr_list_update");
/* Set the new number of MC addresses that we are being requested to use. */ /* Set the new number of MC addresses that we are being requested to use. */
hw->num_mc_addrs = mc_addr_count; hw->num_mc_addrs = mc_addr_count;
/* Clear RAR[1-15] */ /* Clear RAR[1-15] */
DEBUGOUT(" Clearing RAR[1-15]\n"); DEBUGOUT(" Clearing RAR[1-15]\n");
for(i = rar_used_count; i < IXGB_RAR_ENTRIES; i++) { 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), 0);
IXGB_WRITE_REG_ARRAY(hw, RA, ((i << 1) + 1), 0); IXGB_WRITE_REG_ARRAY(hw, RA, ((i << 1) + 1), 0);
} }
/* Clear the MTA */ /* Clear the MTA */
DEBUGOUT(" Clearing MTA\n"); DEBUGOUT(" Clearing MTA\n");
for(i = 0; i < IXGB_MC_TBL_SIZE; i++) { for (i = 0; i < IXGB_MC_TBL_SIZE; i++) {
IXGB_WRITE_REG_ARRAY(hw, MTA, i, 0); IXGB_WRITE_REG_ARRAY(hw, MTA, i, 0);
} }
/* Add the new addresses */ /* Add the new addresses */
for(i = 0; i < mc_addr_count; i++) { for (i = 0; i < mc_addr_count; i++) {
DEBUGOUT(" Adding the multicast addresses:\n"); DEBUGOUT(" Adding the multicast addresses:\n");
DEBUGOUT7(" MC Addr #%d =%.2X %.2X %.2X %.2X %.2X %.2X\n", i, 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)],
mc_addr_list[i * (IXGB_ETH_LENGTH_OF_ADDRESS + pad) + 1], mc_addr_list[i * (IXGB_ETH_LENGTH_OF_ADDRESS + pad) +
mc_addr_list[i * (IXGB_ETH_LENGTH_OF_ADDRESS + pad) + 2], 1],
mc_addr_list[i * (IXGB_ETH_LENGTH_OF_ADDRESS + pad) + 3], mc_addr_list[i * (IXGB_ETH_LENGTH_OF_ADDRESS + pad) +
mc_addr_list[i * (IXGB_ETH_LENGTH_OF_ADDRESS + pad) + 4], 2],
mc_addr_list[i * (IXGB_ETH_LENGTH_OF_ADDRESS + pad) + 5]); mc_addr_list[i * (IXGB_ETH_LENGTH_OF_ADDRESS + pad) +
3],
/* Place this multicast address in the RAR if there is room, * mc_addr_list[i * (IXGB_ETH_LENGTH_OF_ADDRESS + pad) +
* else put it in the MTA 4],
*/ mc_addr_list[i * (IXGB_ETH_LENGTH_OF_ADDRESS + pad) +
if(rar_used_count < IXGB_RAR_ENTRIES) { 5]);
ixgb_rar_set(hw,
mc_addr_list + (i * (IXGB_ETH_LENGTH_OF_ADDRESS + pad)), /* Place this multicast address in the RAR if there is room, *
rar_used_count); * else put it in the MTA
DEBUGOUT1("Added a multicast address to RAR[%d]\n", i); */
rar_used_count++; if (rar_used_count < IXGB_RAR_ENTRIES) {
} else { ixgb_rar_set(hw,
hash_value = ixgb_hash_mc_addr(hw, mc_addr_list +
mc_addr_list + (i * (IXGB_ETH_LENGTH_OF_ADDRESS + pad)),
(i * (IXGB_ETH_LENGTH_OF_ADDRESS + pad))); rar_used_count);
DEBUGOUT1("Added a multicast address to RAR[%d]\n", i);
DEBUGOUT1(" Hash value = 0x%03X\n", hash_value); rar_used_count++;
} else {
ixgb_mta_set(hw, hash_value); hash_value = ixgb_hash_mc_addr(hw,
} mc_addr_list +
} (i *
(IXGB_ETH_LENGTH_OF_ADDRESS
DEBUGOUT("MC Update Complete\n"); + pad)));
return;
DEBUGOUT1(" Hash value = 0x%03X\n", hash_value);
ixgb_mta_set(hw, hash_value);
}
}
DEBUGOUT("MC Update Complete\n");
return;
} }
/****************************************************************************** /******************************************************************************
...@@ -378,42 +372,44 @@ ixgb_mc_addr_list_update(struct ixgb_hw *hw, ...@@ -378,42 +372,44 @@ ixgb_mc_addr_list_update(struct ixgb_hw *hw,
* The hash value * The hash value
*****************************************************************************/ *****************************************************************************/
static uint32_t static uint32_t
ixgb_hash_mc_addr(struct ixgb_hw *hw, ixgb_hash_mc_addr(struct ixgb_hw *hw, uint8_t * mc_addr)
uint8_t *mc_addr)
{ {
uint32_t hash_value = 0; uint32_t hash_value = 0;
DEBUGFUNC("ixgb_hash_mc_addr"); DEBUGFUNC("ixgb_hash_mc_addr");
/* The portion of the address that is used for the hash table is /* The portion of the address that is used for the hash table is
* determined by the mc_filter_type setting. * determined by the mc_filter_type setting.
*/ */
switch (hw->mc_filter_type) { switch (hw->mc_filter_type) {
/* [0] [1] [2] [3] [4] [5] /* [0] [1] [2] [3] [4] [5]
* 01 AA 00 12 34 56 * 01 AA 00 12 34 56
* LSB MSB - According to H/W docs */ * LSB MSB - According to H/W docs */
case 0: case 0:
/* [47:36] i.e. 0x563 for above example address */ /* [47:36] i.e. 0x563 for above example address */
hash_value = ((mc_addr[4] >> 4) | (((uint16_t) mc_addr[5]) << 4)); hash_value =
break; ((mc_addr[4] >> 4) | (((uint16_t) mc_addr[5]) << 4));
case 1: /* [46:35] i.e. 0xAC6 for above example address */ break;
hash_value = ((mc_addr[4] >> 3) | (((uint16_t) mc_addr[5]) << 5)); case 1: /* [46:35] i.e. 0xAC6 for above example address */
break; hash_value =
case 2: /* [45:34] i.e. 0x5D8 for above example address */ ((mc_addr[4] >> 3) | (((uint16_t) mc_addr[5]) << 5));
hash_value = ((mc_addr[4] >> 2) | (((uint16_t) mc_addr[5]) << 6)); break;
break; case 2: /* [45:34] i.e. 0x5D8 for above example address */
case 3: /* [43:32] i.e. 0x634 for above example address */ hash_value =
hash_value = ((mc_addr[4]) | (((uint16_t) mc_addr[5]) << 8)); ((mc_addr[4] >> 2) | (((uint16_t) mc_addr[5]) << 6));
break; break;
default: case 3: /* [43:32] i.e. 0x634 for above example address */
/* Invalid mc_filter_type, what should we do? */ hash_value = ((mc_addr[4]) | (((uint16_t) mc_addr[5]) << 8));
DEBUGOUT("MC filter type param set incorrectly\n"); break;
ASSERT(0); default:
break; /* Invalid mc_filter_type, what should we do? */
} DEBUGOUT("MC filter type param set incorrectly\n");
ASSERT(0);
hash_value &= 0xFFF; break;
return (hash_value); }
hash_value &= 0xFFF;
return (hash_value);
} }
/****************************************************************************** /******************************************************************************
...@@ -423,30 +419,29 @@ ixgb_hash_mc_addr(struct ixgb_hw *hw, ...@@ -423,30 +419,29 @@ ixgb_hash_mc_addr(struct ixgb_hw *hw,
* hash_value - Multicast address hash value * hash_value - Multicast address hash value
*****************************************************************************/ *****************************************************************************/
static void static void
ixgb_mta_set(struct ixgb_hw *hw, ixgb_mta_set(struct ixgb_hw *hw, uint32_t hash_value)
uint32_t hash_value)
{ {
uint32_t hash_bit, hash_reg; uint32_t hash_bit, hash_reg;
uint32_t mta_reg; uint32_t mta_reg;
/* The MTA is a register array of 128 32-bit registers. /* The MTA is a register array of 128 32-bit registers.
* It is treated like an array of 4096 bits. We want to set * It is treated like an array of 4096 bits. We want to set
* bit BitArray[hash_value]. So we figure out what register * bit BitArray[hash_value]. So we figure out what register
* the bit is in, read it, OR in the new bit, then write * the bit is in, read it, OR in the new bit, then write
* back the new value. The register is determined by the * back the new value. The register is determined by the
* upper 7 bits of the hash value and the bit within that * upper 7 bits of the hash value and the bit within that
* register are determined by the lower 5 bits of the value. * register are determined by the lower 5 bits of the value.
*/ */
hash_reg = (hash_value >> 5) & 0x7F; hash_reg = (hash_value >> 5) & 0x7F;
hash_bit = hash_value & 0x1F; hash_bit = hash_value & 0x1F;
mta_reg = IXGB_READ_REG_ARRAY(hw, MTA, hash_reg); mta_reg = IXGB_READ_REG_ARRAY(hw, MTA, hash_reg);
mta_reg |= (1 << hash_bit); mta_reg |= (1 << hash_bit);
IXGB_WRITE_REG_ARRAY(hw, MTA, hash_reg, mta_reg); IXGB_WRITE_REG_ARRAY(hw, MTA, hash_reg, mta_reg);
return; return;
} }
/****************************************************************************** /******************************************************************************
...@@ -457,29 +452,25 @@ ixgb_mta_set(struct ixgb_hw *hw, ...@@ -457,29 +452,25 @@ ixgb_mta_set(struct ixgb_hw *hw,
* index - Receive address register to write * index - Receive address register to write
*****************************************************************************/ *****************************************************************************/
void void
ixgb_rar_set(struct ixgb_hw *hw, ixgb_rar_set(struct ixgb_hw *hw, uint8_t * addr, uint32_t index)
uint8_t *addr,
uint32_t index)
{ {
uint32_t rar_low, rar_high; uint32_t rar_low, rar_high;
DEBUGFUNC("ixgb_rar_set"); DEBUGFUNC("ixgb_rar_set");
/* HW expects these in little endian so we reverse the byte order /* HW expects these in little endian so we reverse the byte order
* from network order (big endian) to little endian * from network order (big endian) to little endian
*/ */
rar_low = ((uint32_t) addr[0] | rar_low = ((uint32_t) addr[0] |
((uint32_t) addr[1] << 8) | ((uint32_t) addr[1] << 8) |
((uint32_t) addr[2] << 16) | ((uint32_t) addr[2] << 16) | ((uint32_t) addr[3] << 24));
((uint32_t) addr[3] << 24));
rar_high = ((uint32_t) addr[4] | rar_high = ((uint32_t) addr[4] |
((uint32_t) addr[5] << 8) | ((uint32_t) addr[5] << 8) | IXGB_RAH_AV);
IXGB_RAH_AV);
IXGB_WRITE_REG_ARRAY(hw, RA, (index << 1), rar_low); IXGB_WRITE_REG_ARRAY(hw, RA, (index << 1), rar_low);
IXGB_WRITE_REG_ARRAY(hw, RA, ((index << 1) + 1), rar_high); IXGB_WRITE_REG_ARRAY(hw, RA, ((index << 1) + 1), rar_high);
return; return;
} }
/****************************************************************************** /******************************************************************************
...@@ -490,12 +481,10 @@ ixgb_rar_set(struct ixgb_hw *hw, ...@@ -490,12 +481,10 @@ ixgb_rar_set(struct ixgb_hw *hw,
* value - Value to write into VLAN filter table * value - Value to write into VLAN filter table
*****************************************************************************/ *****************************************************************************/
void void
ixgb_write_vfta(struct ixgb_hw *hw, ixgb_write_vfta(struct ixgb_hw *hw, uint32_t offset, uint32_t value)
uint32_t offset,
uint32_t value)
{ {
IXGB_WRITE_REG_ARRAY(hw, VFTA, offset, value); IXGB_WRITE_REG_ARRAY(hw, VFTA, offset, value);
return; return;
} }
/****************************************************************************** /******************************************************************************
...@@ -506,11 +495,11 @@ ixgb_write_vfta(struct ixgb_hw *hw, ...@@ -506,11 +495,11 @@ ixgb_write_vfta(struct ixgb_hw *hw,
void void
ixgb_clear_vfta(struct ixgb_hw *hw) ixgb_clear_vfta(struct ixgb_hw *hw)
{ {
uint32_t offset; uint32_t offset;
for(offset = 0; offset < IXGB_VLAN_FILTER_TBL_SIZE; offset++) for (offset = 0; offset < IXGB_VLAN_FILTER_TBL_SIZE; offset++)
IXGB_WRITE_REG_ARRAY(hw, VFTA, offset, 0); IXGB_WRITE_REG_ARRAY(hw, VFTA, offset, 0);
return; return;
} }
/****************************************************************************** /******************************************************************************
...@@ -518,90 +507,90 @@ ixgb_clear_vfta(struct ixgb_hw *hw) ...@@ -518,90 +507,90 @@ ixgb_clear_vfta(struct ixgb_hw *hw)
* *
* hw - Struct containing variables accessed by shared code * hw - Struct containing variables accessed by shared code
*****************************************************************************/ *****************************************************************************/
boolean_t boolean_t
ixgb_setup_fc(struct ixgb_hw *hw) ixgb_setup_fc(struct ixgb_hw * hw)
{ {
uint32_t ctrl_reg; uint32_t ctrl_reg;
uint32_t pap_reg = 0; /* by default, assume no pause time */ uint32_t pap_reg = 0; /* by default, assume no pause time */
boolean_t status = TRUE; boolean_t status = TRUE;
DEBUGFUNC("ixgb_setup_fc"); DEBUGFUNC("ixgb_setup_fc");
/* Get the current control reg 0 settings */ /* Get the current control reg 0 settings */
ctrl_reg = IXGB_READ_REG(hw, CTRL0); ctrl_reg = IXGB_READ_REG(hw, CTRL0);
/* Clear the Receive Pause Enable and Transmit Pause Enable bits */ /* Clear the Receive Pause Enable and Transmit Pause Enable bits */
ctrl_reg &= ~(IXGB_CTRL0_RPE | IXGB_CTRL0_TPE); ctrl_reg &= ~(IXGB_CTRL0_RPE | IXGB_CTRL0_TPE);
/* The possible values of the "flow_control" parameter are: /* The possible values of the "flow_control" parameter are:
* 0: Flow control is completely disabled * 0: Flow control is completely disabled
* 1: Rx flow control is enabled (we can receive pause frames * 1: Rx flow control is enabled (we can receive pause frames
* but not send pause frames). * but not send pause frames).
* 2: Tx flow control is enabled (we can send pause frames * 2: Tx flow control is enabled (we can send pause frames
* but we do not support receiving pause frames). * but we do not support receiving pause frames).
* 3: Both Rx and TX flow control (symmetric) are enabled. * 3: Both Rx and TX flow control (symmetric) are enabled.
* other: Invalid. * other: Invalid.
*/ */
switch (hw->fc.type) { switch (hw->fc.type) {
case ixgb_fc_none: /* 0 */ case ixgb_fc_none: /* 0 */
break; break;
case ixgb_fc_rx_pause: /* 1 */ case ixgb_fc_rx_pause: /* 1 */
/* RX Flow control is enabled, and TX Flow control is /* RX Flow control is enabled, and TX Flow control is
* disabled. * disabled.
*/ */
ctrl_reg |= (IXGB_CTRL0_RPE); ctrl_reg |= (IXGB_CTRL0_RPE);
break; break;
case ixgb_fc_tx_pause: /* 2 */ case ixgb_fc_tx_pause: /* 2 */
/* TX Flow control is enabled, and RX Flow control is /* TX Flow control is enabled, and RX Flow control is
* disabled, by a software over-ride. * disabled, by a software over-ride.
*/ */
ctrl_reg |= (IXGB_CTRL0_TPE); ctrl_reg |= (IXGB_CTRL0_TPE);
pap_reg = hw->fc.pause_time; pap_reg = hw->fc.pause_time;
break; break;
case ixgb_fc_full: /* 3 */ case ixgb_fc_full: /* 3 */
/* Flow control (both RX and TX) is enabled by a software /* Flow control (both RX and TX) is enabled by a software
* over-ride. * over-ride.
*/ */
ctrl_reg |= (IXGB_CTRL0_RPE | IXGB_CTRL0_TPE); ctrl_reg |= (IXGB_CTRL0_RPE | IXGB_CTRL0_TPE);
pap_reg = hw->fc.pause_time; pap_reg = hw->fc.pause_time;
break; break;
default: default:
/* We should never get here. The value should be 0-3. */ /* We should never get here. The value should be 0-3. */
DEBUGOUT("Flow control param set incorrectly\n"); DEBUGOUT("Flow control param set incorrectly\n");
ASSERT(0); ASSERT(0);
break; break;
} }
/* Write the new settings */ /* Write the new settings */
IXGB_WRITE_REG(hw, CTRL0, ctrl_reg); IXGB_WRITE_REG(hw, CTRL0, ctrl_reg);
if (pap_reg != 0) { if (pap_reg != 0) {
IXGB_WRITE_REG(hw, PAP, pap_reg); IXGB_WRITE_REG(hw, PAP, pap_reg);
} }
/* Set the flow control receive threshold registers. Normally, /* Set the flow control receive threshold registers. Normally,
* these registers will be set to a default threshold that may be * these registers will be set to a default threshold that may be
* adjusted later by the driver's runtime code. However, if the * adjusted later by the driver's runtime code. However, if the
* ability to transmit pause frames in not enabled, then these * ability to transmit pause frames in not enabled, then these
* registers will be set to 0. * registers will be set to 0.
*/ */
if(!(hw->fc.type & ixgb_fc_tx_pause)) { if (!(hw->fc.type & ixgb_fc_tx_pause)) {
IXGB_WRITE_REG(hw, FCRTL, 0); IXGB_WRITE_REG(hw, FCRTL, 0);
IXGB_WRITE_REG(hw, FCRTH, 0); IXGB_WRITE_REG(hw, FCRTH, 0);
} else { } else {
/* We need to set up the Receive Threshold high and low water /* We need to set up the Receive Threshold high and low water
* marks as well as (optionally) enabling the transmission of XON frames. * marks as well as (optionally) enabling the transmission of XON frames.
*/ */
if(hw->fc.send_xon) { if (hw->fc.send_xon) {
IXGB_WRITE_REG(hw, FCRTL, IXGB_WRITE_REG(hw, FCRTL,
(hw->fc.low_water | IXGB_FCRTL_XONE)); (hw->fc.low_water | IXGB_FCRTL_XONE));
} else { } else {
IXGB_WRITE_REG(hw, FCRTL, hw->fc.low_water); IXGB_WRITE_REG(hw, FCRTL, hw->fc.low_water);
} }
IXGB_WRITE_REG(hw, FCRTH, hw->fc.high_water); IXGB_WRITE_REG(hw, FCRTH, hw->fc.high_water);
} }
return (status); return (status);
} }
/****************************************************************************** /******************************************************************************
...@@ -619,26 +608,25 @@ ixgb_setup_fc(struct ixgb_hw *hw) ...@@ -619,26 +608,25 @@ ixgb_setup_fc(struct ixgb_hw *hw)
* read command. * read command.
*****************************************************************************/ *****************************************************************************/
uint16_t uint16_t
ixgb_read_phy_reg(struct ixgb_hw *hw, ixgb_read_phy_reg(struct ixgb_hw * hw,
uint32_t reg_address, uint32_t reg_address,
uint32_t phy_address, uint32_t phy_address, uint32_t device_type)
uint32_t device_type)
{ {
uint32_t i; uint32_t i;
uint32_t data; uint32_t data;
uint32_t command = 0; uint32_t command = 0;
ASSERT(reg_address <= IXGB_MAX_PHY_REG_ADDRESS); ASSERT(reg_address <= IXGB_MAX_PHY_REG_ADDRESS);
ASSERT(phy_address <= IXGB_MAX_PHY_ADDRESS); ASSERT(phy_address <= IXGB_MAX_PHY_ADDRESS);
ASSERT(device_type <= IXGB_MAX_PHY_DEV_TYPE); ASSERT(device_type <= IXGB_MAX_PHY_DEV_TYPE);
/* Setup and write the address cycle command */ /* Setup and write the address cycle command */
command = ((reg_address << IXGB_MSCA_NP_ADDR_SHIFT) | command = ((reg_address << IXGB_MSCA_NP_ADDR_SHIFT) |
(device_type << IXGB_MSCA_DEV_TYPE_SHIFT) | (device_type << IXGB_MSCA_DEV_TYPE_SHIFT) |
(phy_address << IXGB_MSCA_PHY_ADDR_SHIFT) | (phy_address << IXGB_MSCA_PHY_ADDR_SHIFT) |
(IXGB_MSCA_ADDR_CYCLE | IXGB_MSCA_MDI_COMMAND)); (IXGB_MSCA_ADDR_CYCLE | IXGB_MSCA_MDI_COMMAND));
IXGB_WRITE_REG(hw, MSCA, command); IXGB_WRITE_REG(hw, MSCA, command);
/************************************************************** /**************************************************************
** Check every 10 usec to see if the address cycle completed ** Check every 10 usec to see if the address cycle completed
...@@ -647,25 +635,24 @@ ixgb_read_phy_reg(struct ixgb_hw *hw, ...@@ -647,25 +635,24 @@ ixgb_read_phy_reg(struct ixgb_hw *hw,
** from the CPU Write to the Ready bit assertion. ** from the CPU Write to the Ready bit assertion.
**************************************************************/ **************************************************************/
for (i = 0; i < 10; i++) for (i = 0; i < 10; i++) {
{ usec_delay(10);
usec_delay(10);
command = IXGB_READ_REG(hw, MSCA);
if ((command & IXGB_MSCA_MDI_COMMAND) == 0)
break;
}
command = IXGB_READ_REG(hw, MSCA); ASSERT((command & IXGB_MSCA_MDI_COMMAND) == 0);
if ((command & IXGB_MSCA_MDI_COMMAND) == 0) /* Address cycle complete, setup and write the read command */
break; command = ((reg_address << IXGB_MSCA_NP_ADDR_SHIFT) |
} (device_type << IXGB_MSCA_DEV_TYPE_SHIFT) |
(phy_address << IXGB_MSCA_PHY_ADDR_SHIFT) |
ASSERT((command & IXGB_MSCA_MDI_COMMAND) == 0); (IXGB_MSCA_READ | IXGB_MSCA_MDI_COMMAND));
/* 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); IXGB_WRITE_REG(hw, MSCA, command);
/************************************************************** /**************************************************************
** Check every 10 usec to see if the read command completed ** Check every 10 usec to see if the read command completed
...@@ -674,24 +661,23 @@ ixgb_read_phy_reg(struct ixgb_hw *hw, ...@@ -674,24 +661,23 @@ ixgb_read_phy_reg(struct ixgb_hw *hw,
** from the CPU Write to the Ready bit assertion. ** from the CPU Write to the Ready bit assertion.
**************************************************************/ **************************************************************/
for (i = 0; i < 10; i++) for (i = 0; i < 10; i++) {
{ usec_delay(10);
usec_delay(10);
command = IXGB_READ_REG(hw, MSCA);
command = IXGB_READ_REG(hw, MSCA);
if ((command & IXGB_MSCA_MDI_COMMAND) == 0)
if ((command & IXGB_MSCA_MDI_COMMAND) == 0) break;
break; }
}
ASSERT((command & IXGB_MSCA_MDI_COMMAND) == 0);
ASSERT((command & IXGB_MSCA_MDI_COMMAND) == 0);
/* Operation is complete, get the data from the MDIO Read/Write Data
/* Operation is complete, get the data from the MDIO Read/Write Data * register and return.
* register and return. */
*/ data = IXGB_READ_REG(hw, MSRWD);
data = IXGB_READ_REG(hw, MSRWD); data >>= IXGB_MSRWD_READ_DATA_SHIFT;
data >>= IXGB_MSRWD_READ_DATA_SHIFT; return ((uint16_t) data);
return((uint16_t) data);
} }
/****************************************************************************** /******************************************************************************
...@@ -712,28 +698,26 @@ ixgb_read_phy_reg(struct ixgb_hw *hw, ...@@ -712,28 +698,26 @@ ixgb_read_phy_reg(struct ixgb_hw *hw,
*****************************************************************************/ *****************************************************************************/
void void
ixgb_write_phy_reg(struct ixgb_hw *hw, ixgb_write_phy_reg(struct ixgb_hw *hw,
uint32_t reg_address, uint32_t reg_address,
uint32_t phy_address, uint32_t phy_address, uint32_t device_type, uint16_t data)
uint32_t device_type,
uint16_t data)
{ {
uint32_t i; uint32_t i;
uint32_t command = 0; uint32_t command = 0;
ASSERT(reg_address <= IXGB_MAX_PHY_REG_ADDRESS); ASSERT(reg_address <= IXGB_MAX_PHY_REG_ADDRESS);
ASSERT(phy_address <= IXGB_MAX_PHY_ADDRESS); ASSERT(phy_address <= IXGB_MAX_PHY_ADDRESS);
ASSERT(device_type <= IXGB_MAX_PHY_DEV_TYPE); ASSERT(device_type <= IXGB_MAX_PHY_DEV_TYPE);
/* Put the data in the MDIO Read/Write Data register */ /* Put the data in the MDIO Read/Write Data register */
IXGB_WRITE_REG(hw, MSRWD, (uint32_t)data); IXGB_WRITE_REG(hw, MSRWD, (uint32_t) data);
/* Setup and write the address cycle command */ /* Setup and write the address cycle command */
command = ((reg_address << IXGB_MSCA_NP_ADDR_SHIFT) | command = ((reg_address << IXGB_MSCA_NP_ADDR_SHIFT) |
(device_type << IXGB_MSCA_DEV_TYPE_SHIFT) | (device_type << IXGB_MSCA_DEV_TYPE_SHIFT) |
(phy_address << IXGB_MSCA_PHY_ADDR_SHIFT) | (phy_address << IXGB_MSCA_PHY_ADDR_SHIFT) |
(IXGB_MSCA_ADDR_CYCLE | IXGB_MSCA_MDI_COMMAND)); (IXGB_MSCA_ADDR_CYCLE | IXGB_MSCA_MDI_COMMAND));
IXGB_WRITE_REG(hw, MSCA, command); IXGB_WRITE_REG(hw, MSCA, command);
/************************************************************** /**************************************************************
** Check every 10 usec to see if the address cycle completed ** Check every 10 usec to see if the address cycle completed
...@@ -742,25 +726,24 @@ ixgb_write_phy_reg(struct ixgb_hw *hw, ...@@ -742,25 +726,24 @@ ixgb_write_phy_reg(struct ixgb_hw *hw,
** from the CPU Write to the Ready bit assertion. ** from the CPU Write to the Ready bit assertion.
**************************************************************/ **************************************************************/
for (i = 0; i < 10; i++) for (i = 0; i < 10; i++) {
{ usec_delay(10);
usec_delay(10);
command = IXGB_READ_REG(hw, MSCA); command = IXGB_READ_REG(hw, MSCA);
if ((command & IXGB_MSCA_MDI_COMMAND) == 0) if ((command & IXGB_MSCA_MDI_COMMAND) == 0)
break; break;
} }
ASSERT((command & IXGB_MSCA_MDI_COMMAND) == 0); ASSERT((command & IXGB_MSCA_MDI_COMMAND) == 0);
/* Address cycle complete, setup and write the write command */ /* Address cycle complete, setup and write the write command */
command = ((reg_address << IXGB_MSCA_NP_ADDR_SHIFT) | command = ((reg_address << IXGB_MSCA_NP_ADDR_SHIFT) |
(device_type << IXGB_MSCA_DEV_TYPE_SHIFT) | (device_type << IXGB_MSCA_DEV_TYPE_SHIFT) |
(phy_address << IXGB_MSCA_PHY_ADDR_SHIFT) | (phy_address << IXGB_MSCA_PHY_ADDR_SHIFT) |
(IXGB_MSCA_WRITE | IXGB_MSCA_MDI_COMMAND)); (IXGB_MSCA_WRITE | IXGB_MSCA_MDI_COMMAND));
IXGB_WRITE_REG(hw, MSCA, command); IXGB_WRITE_REG(hw, MSCA, command);
/************************************************************** /**************************************************************
** Check every 10 usec to see if the read command completed ** Check every 10 usec to see if the read command completed
...@@ -769,22 +752,20 @@ ixgb_write_phy_reg(struct ixgb_hw *hw, ...@@ -769,22 +752,20 @@ ixgb_write_phy_reg(struct ixgb_hw *hw,
** from the CPU Write to the Ready bit assertion. ** from the CPU Write to the Ready bit assertion.
**************************************************************/ **************************************************************/
for (i = 0; i < 10; i++) for (i = 0; i < 10; i++) {
{ usec_delay(10);
usec_delay(10);
command = IXGB_READ_REG(hw, MSCA); command = IXGB_READ_REG(hw, MSCA);
if ((command & IXGB_MSCA_MDI_COMMAND) == 0) if ((command & IXGB_MSCA_MDI_COMMAND) == 0)
break; break;
} }
ASSERT((command & IXGB_MSCA_MDI_COMMAND) == 0); ASSERT((command & IXGB_MSCA_MDI_COMMAND) == 0);
/* Operation is complete, return. */ /* Operation is complete, return. */
} }
/****************************************************************************** /******************************************************************************
* Checks to see if the link status of the hardware has changed. * Checks to see if the link status of the hardware has changed.
* *
...@@ -795,47 +776,49 @@ ixgb_write_phy_reg(struct ixgb_hw *hw, ...@@ -795,47 +776,49 @@ ixgb_write_phy_reg(struct ixgb_hw *hw,
void void
ixgb_check_for_link(struct ixgb_hw *hw) ixgb_check_for_link(struct ixgb_hw *hw)
{ {
uint32_t status_reg; uint32_t status_reg;
uint32_t xpcss_reg; uint32_t xpcss_reg;
DEBUGFUNC("ixgb_check_for_link"); DEBUGFUNC("ixgb_check_for_link");
xpcss_reg = IXGB_READ_REG(hw, XPCSS); xpcss_reg = IXGB_READ_REG(hw, XPCSS);
status_reg = IXGB_READ_REG(hw, STATUS); status_reg = IXGB_READ_REG(hw, STATUS);
if ((xpcss_reg & IXGB_XPCSS_ALIGN_STATUS) && if ((xpcss_reg & IXGB_XPCSS_ALIGN_STATUS) &&
(status_reg & IXGB_STATUS_LU)) { (status_reg & IXGB_STATUS_LU)) {
hw->link_up = TRUE; hw->link_up = TRUE;
} else if (!(xpcss_reg & IXGB_XPCSS_ALIGN_STATUS) && } else if (!(xpcss_reg & IXGB_XPCSS_ALIGN_STATUS) &&
(status_reg & IXGB_STATUS_LU)) { (status_reg & IXGB_STATUS_LU)) {
DEBUGOUT("XPCSS Not Aligned while Status:LU is set.\n"); DEBUGOUT("XPCSS Not Aligned while Status:LU is set.\n");
hw->link_up = ixgb_link_reset(hw); hw->link_up = ixgb_link_reset(hw);
} else { } else {
hw->link_up = ixgb_link_reset(hw); hw->link_up = ixgb_link_reset(hw);
} }
/* Anything else for 10 Gig?? */ /* Anything else for 10 Gig?? */
} }
boolean_t ixgb_check_for_bad_link(struct ixgb_hw *hw) boolean_t
ixgb_check_for_bad_link(struct ixgb_hw *hw)
{ {
uint32_t newLFC, newRFC; uint32_t newLFC, newRFC;
boolean_t bad_link_returncode = FALSE; boolean_t bad_link_returncode = FALSE;
/* check for a bad reset that may have occured /* check for a bad reset that may have occured
* the indication is that the RFC / LFC registers may be incrementing * the indication is that the RFC / LFC registers may be incrementing
* continually. Do a full adapter reset to recover * continually. Do a full adapter reset to recover
*/ */
newLFC = IXGB_READ_REG(hw, LFC); newLFC = IXGB_READ_REG(hw, LFC);
newRFC = IXGB_READ_REG(hw, RFC); newRFC = IXGB_READ_REG(hw, RFC);
if ((hw->lastLFC + 250 < newLFC) || (hw->lastRFC + 250 < newRFC)) { if ((hw->lastLFC + 250 < newLFC) || (hw->lastRFC + 250 < newRFC)) {
DEBUGOUT("BAD LINK! too many LFC/RFC since last check\n"); DEBUGOUT("BAD LINK! too many LFC/RFC since last check\n");
bad_link_returncode = TRUE; bad_link_returncode = TRUE;
} }
hw->lastLFC = newLFC; hw->lastLFC = newLFC;
hw->lastRFC = newRFC; hw->lastRFC = newRFC;
return bad_link_returncode; return bad_link_returncode;
} }
/****************************************************************************** /******************************************************************************
* Clears all hardware statistics counters. * Clears all hardware statistics counters.
* *
...@@ -844,80 +827,79 @@ boolean_t ixgb_check_for_bad_link(struct ixgb_hw *hw) ...@@ -844,80 +827,79 @@ boolean_t ixgb_check_for_bad_link(struct ixgb_hw *hw)
void void
ixgb_clear_hw_cntrs(struct ixgb_hw *hw) ixgb_clear_hw_cntrs(struct ixgb_hw *hw)
{ {
volatile uint32_t temp_reg; volatile uint32_t temp_reg;
DEBUGFUNC("ixgb_clear_hw_cntrs"); DEBUGFUNC("ixgb_clear_hw_cntrs");
/* if we are stopped or resetting exit gracefully */ /* if we are stopped or resetting exit gracefully */
if(hw->adapter_stopped) { if (hw->adapter_stopped) {
DEBUGOUT("Exiting because the adapter is stopped!!!\n"); DEBUGOUT("Exiting because the adapter is stopped!!!\n");
return; return;
} }
temp_reg = IXGB_READ_REG(hw, TPRL); temp_reg = IXGB_READ_REG(hw, TPRL);
temp_reg = IXGB_READ_REG(hw, TPRH); temp_reg = IXGB_READ_REG(hw, TPRH);
temp_reg = IXGB_READ_REG(hw, GPRCL); temp_reg = IXGB_READ_REG(hw, GPRCL);
temp_reg = IXGB_READ_REG(hw, GPRCH); temp_reg = IXGB_READ_REG(hw, GPRCH);
temp_reg = IXGB_READ_REG(hw, BPRCL); temp_reg = IXGB_READ_REG(hw, BPRCL);
temp_reg = IXGB_READ_REG(hw, BPRCH); temp_reg = IXGB_READ_REG(hw, BPRCH);
temp_reg = IXGB_READ_REG(hw, MPRCL); temp_reg = IXGB_READ_REG(hw, MPRCL);
temp_reg = IXGB_READ_REG(hw, MPRCH); temp_reg = IXGB_READ_REG(hw, MPRCH);
temp_reg = IXGB_READ_REG(hw, UPRCL); temp_reg = IXGB_READ_REG(hw, UPRCL);
temp_reg = IXGB_READ_REG(hw, UPRCH); temp_reg = IXGB_READ_REG(hw, UPRCH);
temp_reg = IXGB_READ_REG(hw, VPRCL); temp_reg = IXGB_READ_REG(hw, VPRCL);
temp_reg = IXGB_READ_REG(hw, VPRCH); temp_reg = IXGB_READ_REG(hw, VPRCH);
temp_reg = IXGB_READ_REG(hw, JPRCL); temp_reg = IXGB_READ_REG(hw, JPRCL);
temp_reg = IXGB_READ_REG(hw, JPRCH); temp_reg = IXGB_READ_REG(hw, JPRCH);
temp_reg = IXGB_READ_REG(hw, GORCL); temp_reg = IXGB_READ_REG(hw, GORCL);
temp_reg = IXGB_READ_REG(hw, GORCH); temp_reg = IXGB_READ_REG(hw, GORCH);
temp_reg = IXGB_READ_REG(hw, TORL); temp_reg = IXGB_READ_REG(hw, TORL);
temp_reg = IXGB_READ_REG(hw, TORH); temp_reg = IXGB_READ_REG(hw, TORH);
temp_reg = IXGB_READ_REG(hw, RNBC); temp_reg = IXGB_READ_REG(hw, RNBC);
temp_reg = IXGB_READ_REG(hw, RUC); temp_reg = IXGB_READ_REG(hw, RUC);
temp_reg = IXGB_READ_REG(hw, ROC); temp_reg = IXGB_READ_REG(hw, ROC);
temp_reg = IXGB_READ_REG(hw, RLEC); temp_reg = IXGB_READ_REG(hw, RLEC);
temp_reg = IXGB_READ_REG(hw, CRCERRS); temp_reg = IXGB_READ_REG(hw, CRCERRS);
temp_reg = IXGB_READ_REG(hw, ICBC); temp_reg = IXGB_READ_REG(hw, ICBC);
temp_reg = IXGB_READ_REG(hw, ECBC); temp_reg = IXGB_READ_REG(hw, ECBC);
temp_reg = IXGB_READ_REG(hw, MPC); temp_reg = IXGB_READ_REG(hw, MPC);
temp_reg = IXGB_READ_REG(hw, TPTL); temp_reg = IXGB_READ_REG(hw, TPTL);
temp_reg = IXGB_READ_REG(hw, TPTH); temp_reg = IXGB_READ_REG(hw, TPTH);
temp_reg = IXGB_READ_REG(hw, GPTCL); temp_reg = IXGB_READ_REG(hw, GPTCL);
temp_reg = IXGB_READ_REG(hw, GPTCH); temp_reg = IXGB_READ_REG(hw, GPTCH);
temp_reg = IXGB_READ_REG(hw, BPTCL); temp_reg = IXGB_READ_REG(hw, BPTCL);
temp_reg = IXGB_READ_REG(hw, BPTCH); temp_reg = IXGB_READ_REG(hw, BPTCH);
temp_reg = IXGB_READ_REG(hw, MPTCL); temp_reg = IXGB_READ_REG(hw, MPTCL);
temp_reg = IXGB_READ_REG(hw, MPTCH); temp_reg = IXGB_READ_REG(hw, MPTCH);
temp_reg = IXGB_READ_REG(hw, UPTCL); temp_reg = IXGB_READ_REG(hw, UPTCL);
temp_reg = IXGB_READ_REG(hw, UPTCH); temp_reg = IXGB_READ_REG(hw, UPTCH);
temp_reg = IXGB_READ_REG(hw, VPTCL); temp_reg = IXGB_READ_REG(hw, VPTCL);
temp_reg = IXGB_READ_REG(hw, VPTCH); temp_reg = IXGB_READ_REG(hw, VPTCH);
temp_reg = IXGB_READ_REG(hw, JPTCL); temp_reg = IXGB_READ_REG(hw, JPTCL);
temp_reg = IXGB_READ_REG(hw, JPTCH); temp_reg = IXGB_READ_REG(hw, JPTCH);
temp_reg = IXGB_READ_REG(hw, GOTCL); temp_reg = IXGB_READ_REG(hw, GOTCL);
temp_reg = IXGB_READ_REG(hw, GOTCH); temp_reg = IXGB_READ_REG(hw, GOTCH);
temp_reg = IXGB_READ_REG(hw, TOTL); temp_reg = IXGB_READ_REG(hw, TOTL);
temp_reg = IXGB_READ_REG(hw, TOTH); temp_reg = IXGB_READ_REG(hw, TOTH);
temp_reg = IXGB_READ_REG(hw, DC); temp_reg = IXGB_READ_REG(hw, DC);
temp_reg = IXGB_READ_REG(hw, PLT64C); temp_reg = IXGB_READ_REG(hw, PLT64C);
temp_reg = IXGB_READ_REG(hw, TSCTC); temp_reg = IXGB_READ_REG(hw, TSCTC);
temp_reg = IXGB_READ_REG(hw, TSCTFC); temp_reg = IXGB_READ_REG(hw, TSCTFC);
temp_reg = IXGB_READ_REG(hw, IBIC); temp_reg = IXGB_READ_REG(hw, IBIC);
temp_reg = IXGB_READ_REG(hw, RFC); temp_reg = IXGB_READ_REG(hw, RFC);
temp_reg = IXGB_READ_REG(hw, LFC); temp_reg = IXGB_READ_REG(hw, LFC);
temp_reg = IXGB_READ_REG(hw, PFRC); temp_reg = IXGB_READ_REG(hw, PFRC);
temp_reg = IXGB_READ_REG(hw, PFTC); temp_reg = IXGB_READ_REG(hw, PFTC);
temp_reg = IXGB_READ_REG(hw, MCFRC); temp_reg = IXGB_READ_REG(hw, MCFRC);
temp_reg = IXGB_READ_REG(hw, MCFTC); temp_reg = IXGB_READ_REG(hw, MCFTC);
temp_reg = IXGB_READ_REG(hw, XONRXC); temp_reg = IXGB_READ_REG(hw, XONRXC);
temp_reg = IXGB_READ_REG(hw, XONTXC); temp_reg = IXGB_READ_REG(hw, XONTXC);
temp_reg = IXGB_READ_REG(hw, XOFFRXC); temp_reg = IXGB_READ_REG(hw, XOFFRXC);
temp_reg = IXGB_READ_REG(hw, XOFFTXC); temp_reg = IXGB_READ_REG(hw, XOFFTXC);
temp_reg = IXGB_READ_REG(hw, RJC); temp_reg = IXGB_READ_REG(hw, RJC);
return; return;
} }
/****************************************************************************** /******************************************************************************
* Turns on the software controllable LED * Turns on the software controllable LED
* *
...@@ -926,12 +908,12 @@ ixgb_clear_hw_cntrs(struct ixgb_hw *hw) ...@@ -926,12 +908,12 @@ ixgb_clear_hw_cntrs(struct ixgb_hw *hw)
void void
ixgb_led_on(struct ixgb_hw *hw) ixgb_led_on(struct ixgb_hw *hw)
{ {
uint32_t ctrl0_reg = IXGB_READ_REG(hw, CTRL0); uint32_t ctrl0_reg = IXGB_READ_REG(hw, CTRL0);
/* To turn on the LED, clear software-definable pin 0 (SDP0). */ /* To turn on the LED, clear software-definable pin 0 (SDP0). */
ctrl0_reg &= ~IXGB_CTRL0_SDP0; ctrl0_reg &= ~IXGB_CTRL0_SDP0;
IXGB_WRITE_REG(hw, CTRL0, ctrl0_reg); IXGB_WRITE_REG(hw, CTRL0, ctrl0_reg);
return; return;
} }
/****************************************************************************** /******************************************************************************
...@@ -942,14 +924,13 @@ ixgb_led_on(struct ixgb_hw *hw) ...@@ -942,14 +924,13 @@ ixgb_led_on(struct ixgb_hw *hw)
void void
ixgb_led_off(struct ixgb_hw *hw) ixgb_led_off(struct ixgb_hw *hw)
{ {
uint32_t ctrl0_reg = IXGB_READ_REG(hw, CTRL0); 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;
}
/* 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 * Gets the current PCI bus type, speed, and width of the hardware
...@@ -959,41 +940,39 @@ ixgb_led_off(struct ixgb_hw *hw) ...@@ -959,41 +940,39 @@ ixgb_led_off(struct ixgb_hw *hw)
static void static void
ixgb_get_bus_info(struct ixgb_hw *hw) ixgb_get_bus_info(struct ixgb_hw *hw)
{ {
uint32_t status_reg; uint32_t status_reg;
status_reg = IXGB_READ_REG(hw, STATUS); status_reg = IXGB_READ_REG(hw, STATUS);
hw->bus.type = (status_reg & IXGB_STATUS_PCIX_MODE) ? hw->bus.type = (status_reg & IXGB_STATUS_PCIX_MODE) ?
ixgb_bus_type_pcix : ixgb_bus_type_pci; ixgb_bus_type_pcix : ixgb_bus_type_pci;
if (hw->bus.type == ixgb_bus_type_pci) { if (hw->bus.type == ixgb_bus_type_pci) {
hw->bus.speed = (status_reg & IXGB_STATUS_PCI_SPD) ? hw->bus.speed = (status_reg & IXGB_STATUS_PCI_SPD) ?
ixgb_bus_speed_66 : ixgb_bus_speed_33; ixgb_bus_speed_66 : ixgb_bus_speed_33;
} else { } else {
switch (status_reg & IXGB_STATUS_PCIX_SPD_MASK) { switch (status_reg & IXGB_STATUS_PCIX_SPD_MASK) {
case IXGB_STATUS_PCIX_SPD_66: case IXGB_STATUS_PCIX_SPD_66:
hw->bus.speed = ixgb_bus_speed_66; hw->bus.speed = ixgb_bus_speed_66;
break; break;
case IXGB_STATUS_PCIX_SPD_100: case IXGB_STATUS_PCIX_SPD_100:
hw->bus.speed = ixgb_bus_speed_100; hw->bus.speed = ixgb_bus_speed_100;
break; break;
case IXGB_STATUS_PCIX_SPD_133: case IXGB_STATUS_PCIX_SPD_133:
hw->bus.speed = ixgb_bus_speed_133; hw->bus.speed = ixgb_bus_speed_133;
break; break;
default: default:
hw->bus.speed = ixgb_bus_speed_reserved; hw->bus.speed = ixgb_bus_speed_reserved;
break; break;
} }
} }
hw->bus.width = (status_reg & IXGB_STATUS_BUS64) ? hw->bus.width = (status_reg & IXGB_STATUS_BUS64) ?
ixgb_bus_width_64 : ixgb_bus_width_32; ixgb_bus_width_64 : ixgb_bus_width_32;
return; return;
} }
/****************************************************************************** /******************************************************************************
* Tests a MAC address to ensure it is a valid Individual Address * Tests a MAC address to ensure it is a valid Individual Address
* *
...@@ -1001,35 +980,30 @@ ixgb_get_bus_info(struct ixgb_hw *hw) ...@@ -1001,35 +980,30 @@ ixgb_get_bus_info(struct ixgb_hw *hw)
* *
*****************************************************************************/ *****************************************************************************/
boolean_t boolean_t
mac_addr_valid(uint8_t *mac_addr) mac_addr_valid(uint8_t * mac_addr)
{ {
boolean_t is_valid = TRUE; boolean_t is_valid = TRUE;
DEBUGFUNC("mac_addr_valid"); DEBUGFUNC("mac_addr_valid");
/* Make sure it is not a multicast address */
/* Make sure it is not a multicast address */ if (IS_MULTICAST(mac_addr)) {
if (IS_MULTICAST(mac_addr)) { DEBUGOUT("MAC address is multicast\n");
DEBUGOUT("MAC address is multicast\n"); is_valid = FALSE;
is_valid = FALSE; }
} /* Not a broadcast address */
/* Not a broadcast address */ else if (IS_BROADCAST(mac_addr)) {
else if (IS_BROADCAST(mac_addr)) { DEBUGOUT("MAC address is broadcast\n");
DEBUGOUT("MAC address is broadcast\n"); is_valid = FALSE;
is_valid = FALSE; }
} /* Reject the zero address */
/* Reject the zero address */ else if (mac_addr[0] == 0 &&
else if (mac_addr[0] == 0 && mac_addr[1] == 0 &&
mac_addr[1] == 0 && mac_addr[2] == 0 &&
mac_addr[2] == 0 && mac_addr[3] == 0 && mac_addr[4] == 0 && mac_addr[5] == 0) {
mac_addr[3] == 0 && DEBUGOUT("MAC address is all zeros\n");
mac_addr[4] == 0 && is_valid = FALSE;
mac_addr[5] == 0 }
) return (is_valid);
{
DEBUGOUT("MAC address is all zeros\n");
is_valid = FALSE;
}
return (is_valid);
} }
/****************************************************************************** /******************************************************************************
...@@ -1039,28 +1013,28 @@ mac_addr_valid(uint8_t *mac_addr) ...@@ -1039,28 +1013,28 @@ mac_addr_valid(uint8_t *mac_addr)
* hw - Struct containing variables accessed by shared code * hw - Struct containing variables accessed by shared code
*****************************************************************************/ *****************************************************************************/
boolean_t boolean_t
ixgb_link_reset(struct ixgb_hw *hw) ixgb_link_reset(struct ixgb_hw * hw)
{ {
boolean_t link_status = FALSE; boolean_t link_status = FALSE;
uint8_t wait_retries = MAX_RESET_ITERATIONS; uint8_t wait_retries = MAX_RESET_ITERATIONS;
uint8_t lrst_retries = MAX_RESET_ITERATIONS; uint8_t lrst_retries = MAX_RESET_ITERATIONS;
do { do {
IXGB_WRITE_REG(hw, CTRL0, IXGB_READ_REG(hw, CTRL0) | IXGB_CTRL0_LRST); IXGB_WRITE_REG(hw, CTRL0,
IXGB_READ_REG(hw, CTRL0) | IXGB_CTRL0_LRST);
do {
usec_delay(IXGB_DELAY_USECS_AFTER_LINK_RESET); do {
link_status = ((IXGB_READ_REG(hw, STATUS) & IXGB_STATUS_LU) && usec_delay(IXGB_DELAY_USECS_AFTER_LINK_RESET);
(IXGB_READ_REG(hw, XPCSS) & IXGB_XPCSS_ALIGN_STATUS)) ? link_status =
TRUE : FALSE; ((IXGB_READ_REG(hw, STATUS) & IXGB_STATUS_LU)
} while (!link_status && -- wait_retries); && (IXGB_READ_REG(hw, XPCSS) &
} while (!link_status && --lrst_retries); IXGB_XPCSS_ALIGN_STATUS)) ? TRUE : FALSE;
} while (!link_status && --wait_retries);
return link_status; } while (!link_status && --lrst_retries);
return link_status;
} }
/****************************************************************************** /******************************************************************************
* Resets the 10GbE optics module. * Resets the 10GbE optics module.
* *
...@@ -1069,15 +1043,13 @@ ixgb_link_reset(struct ixgb_hw *hw) ...@@ -1069,15 +1043,13 @@ ixgb_link_reset(struct ixgb_hw *hw)
void void
ixgb_optics_reset(struct ixgb_hw *hw) ixgb_optics_reset(struct ixgb_hw *hw)
{ {
uint16_t mdio_reg; uint16_t mdio_reg;
ixgb_write_phy_reg( hw, ixgb_write_phy_reg(hw,
TXN17401_PMA_PMD_CR1, TXN17401_PMA_PMD_CR1,
IXGB_PHY_ADDRESS, IXGB_PHY_ADDRESS,
TXN17401_PMA_PMD_DID, TXN17401_PMA_PMD_DID, TXN17401_PMA_PMD_CR1_RESET);
TXN17401_PMA_PMD_CR1_RESET); mdio_reg = ixgb_read_phy_reg(hw,
mdio_reg = ixgb_read_phy_reg( hw, TXN17401_PMA_PMD_CR1,
TXN17401_PMA_PMD_CR1, IXGB_PHY_ADDRESS, TXN17401_PMA_PMD_DID);
IXGB_PHY_ADDRESS, }
TXN17401_PMA_PMD_DID);
}
drivers/net/ixgb/ixgb_hw.h
View file @ ca247341
...@@ -32,198 +32,195 @@ ...@@ -32,198 +32,195 @@
/* Enums */ /* Enums */
typedef enum { typedef enum {
ixgb_mac_unknown = 0, ixgb_mac_unknown = 0,
ixgb_82597, ixgb_82597,
ixgb_num_macs ixgb_num_macs
} ixgb_mac_type; } ixgb_mac_type;
/* Media Types */ /* Media Types */
typedef enum { typedef enum {
ixgb_media_type_unknown = 0, ixgb_media_type_unknown = 0,
ixgb_media_type_fiber = 1, ixgb_media_type_fiber = 1,
ixgb_num_media_types ixgb_num_media_types
} ixgb_media_type; } ixgb_media_type;
/* Flow Control Settings */ /* Flow Control Settings */
typedef enum { typedef enum {
ixgb_fc_none = 0, ixgb_fc_none = 0,
ixgb_fc_rx_pause = 1, ixgb_fc_rx_pause = 1,
ixgb_fc_tx_pause = 2, ixgb_fc_tx_pause = 2,
ixgb_fc_full = 3, ixgb_fc_full = 3,
ixgb_fc_default = 0xFF ixgb_fc_default = 0xFF
} ixgb_fc_type; } ixgb_fc_type;
/* PCI bus types */ /* PCI bus types */
typedef enum { typedef enum {
ixgb_bus_type_unknown = 0, ixgb_bus_type_unknown = 0,
ixgb_bus_type_pci, ixgb_bus_type_pci,
ixgb_bus_type_pcix ixgb_bus_type_pcix
} ixgb_bus_type; } ixgb_bus_type;
/* PCI bus speeds */ /* PCI bus speeds */
typedef enum { typedef enum {
ixgb_bus_speed_unknown = 0, ixgb_bus_speed_unknown = 0,
ixgb_bus_speed_33, ixgb_bus_speed_33,
ixgb_bus_speed_66, ixgb_bus_speed_66,
ixgb_bus_speed_100, ixgb_bus_speed_100,
ixgb_bus_speed_133, ixgb_bus_speed_133,
ixgb_bus_speed_reserved ixgb_bus_speed_reserved
} ixgb_bus_speed; } ixgb_bus_speed;
/* PCI bus widths */ /* PCI bus widths */
typedef enum { typedef enum {
ixgb_bus_width_unknown = 0, ixgb_bus_width_unknown = 0,
ixgb_bus_width_32, ixgb_bus_width_32,
ixgb_bus_width_64 ixgb_bus_width_64
} ixgb_bus_width; } ixgb_bus_width;
#define IXGB_ETH_LENGTH_OF_ADDRESS 6 #define IXGB_ETH_LENGTH_OF_ADDRESS 6
#define IXGB_EEPROM_SIZE 64 /* Size in words */ #define IXGB_EEPROM_SIZE 64 /* Size in words */
#define SPEED_10000 10000 #define SPEED_10000 10000
#define FULL_DUPLEX 2 #define FULL_DUPLEX 2
#define IXGB_DELAY_BEFORE_RESET 10 /* allow 10ms after idling rx/tx units */
#define IXGB_DELAY_AFTER_RESET 1 /* allow 1ms after the reset */
#define IXGB_DELAY_AFTER_EE_RESET 10 /* allow 10ms after the EEPROM reset */
#define IXGB_DELAY_BEFORE_RESET 10 /* allow 10ms after idling rx/tx units */ #define IXGB_DELAY_USECS_AFTER_LINK_RESET 13 /* allow 13 microseconds after the reset */
#define IXGB_DELAY_AFTER_RESET 1 /* allow 1ms after the reset */ /* NOTE: this is MICROSECONDS */
#define IXGB_DELAY_AFTER_EE_RESET 10 /* allow 10ms after the EEPROM reset */ #define MAX_RESET_ITERATIONS 8 /* number of iterations to get things right */
#define IXGB_DELAY_USECS_AFTER_LINK_RESET 13 /* allow 13 microseconds after the reset */
/* NOTE: this is MICROSECONDS */
#define MAX_RESET_ITERATIONS 8 /* number of iterations to get things right */
/* General Registers */ /* General Registers */
#define IXGB_CTRL0 0x00000 /* Device Control Register 0 - RW */ #define IXGB_CTRL0 0x00000 /* Device Control Register 0 - RW */
#define IXGB_CTRL1 0x00008 /* Device Control Register 1 - RW */ #define IXGB_CTRL1 0x00008 /* Device Control Register 1 - RW */
#define IXGB_STATUS 0x00010 /* Device Status Register - RO */ #define IXGB_STATUS 0x00010 /* Device Status Register - RO */
#define IXGB_EECD 0x00018 /* EEPROM/Flash Control/Data Register - RW */ #define IXGB_EECD 0x00018 /* EEPROM/Flash Control/Data Register - RW */
#define IXGB_MFS 0x00020 /* Maximum Frame Size - RW */ #define IXGB_MFS 0x00020 /* Maximum Frame Size - RW */
/* Interrupt */ /* Interrupt */
#define IXGB_ICR 0x00080 /* Interrupt Cause Read - R/clr */ #define IXGB_ICR 0x00080 /* Interrupt Cause Read - R/clr */
#define IXGB_ICS 0x00088 /* Interrupt Cause Set - RW */ #define IXGB_ICS 0x00088 /* Interrupt Cause Set - RW */
#define IXGB_IMS 0x00090 /* Interrupt Mask Set/Read - RW */ #define IXGB_IMS 0x00090 /* Interrupt Mask Set/Read - RW */
#define IXGB_IMC 0x00098 /* Interrupt Mask Clear - WO */ #define IXGB_IMC 0x00098 /* Interrupt Mask Clear - WO */
/* Receive */ /* Receive */
#define IXGB_RCTL 0x00100 /* RX Control - RW */ #define IXGB_RCTL 0x00100 /* RX Control - RW */
#define IXGB_FCRTL 0x00108 /* Flow Control Receive Threshold Low - RW */ #define IXGB_FCRTL 0x00108 /* Flow Control Receive Threshold Low - RW */
#define IXGB_FCRTH 0x00110 /* Flow Control Receive Threshold High - RW */ #define IXGB_FCRTH 0x00110 /* Flow Control Receive Threshold High - RW */
#define IXGB_RDBAL 0x00118 /* RX Descriptor Base Low - RW */ #define IXGB_RDBAL 0x00118 /* RX Descriptor Base Low - RW */
#define IXGB_RDBAH 0x0011C /* RX Descriptor Base High - RW */ #define IXGB_RDBAH 0x0011C /* RX Descriptor Base High - RW */
#define IXGB_RDLEN 0x00120 /* RX Descriptor Length - RW */ #define IXGB_RDLEN 0x00120 /* RX Descriptor Length - RW */
#define IXGB_RDH 0x00128 /* RX Descriptor Head - RW */ #define IXGB_RDH 0x00128 /* RX Descriptor Head - RW */
#define IXGB_RDT 0x00130 /* RX Descriptor Tail - RW */ #define IXGB_RDT 0x00130 /* RX Descriptor Tail - RW */
#define IXGB_RDTR 0x00138 /* RX Delay Timer Ring - RW */ #define IXGB_RDTR 0x00138 /* RX Delay Timer Ring - RW */
#define IXGB_RXDCTL 0x00140 /* Receive Descriptor Control - RW */ #define IXGB_RXDCTL 0x00140 /* Receive Descriptor Control - RW */
#define IXGB_RAIDC 0x00148 /* Receive Adaptive Interrupt Delay Control - RW */ #define IXGB_RAIDC 0x00148 /* Receive Adaptive Interrupt Delay Control - RW */
#define IXGB_RXCSUM 0x00158 /* Receive Checksum Control - RW */ #define IXGB_RXCSUM 0x00158 /* Receive Checksum Control - RW */
#define IXGB_RA 0x00180 /* Receive Address Array Base - RW */ #define IXGB_RA 0x00180 /* Receive Address Array Base - RW */
#define IXGB_RAL 0x00180 /* Receive Address Low [0:15] - RW */ #define IXGB_RAL 0x00180 /* Receive Address Low [0:15] - RW */
#define IXGB_RAH 0x00184 /* Receive Address High [0:15] - RW */ #define IXGB_RAH 0x00184 /* Receive Address High [0:15] - RW */
#define IXGB_MTA 0x00200 /* Multicast Table Array [0:127] - RW */ #define IXGB_MTA 0x00200 /* Multicast Table Array [0:127] - RW */
#define IXGB_VFTA 0x00400 /* VLAN Filter Table Array [0:127] - RW */ #define IXGB_VFTA 0x00400 /* VLAN Filter Table Array [0:127] - RW */
#define IXGB_REQ_RX_DESCRIPTOR_MULTIPLE 8 #define IXGB_REQ_RX_DESCRIPTOR_MULTIPLE 8
/* Transmit */ /* Transmit */
#define IXGB_TCTL 0x00600 /* TX Control - RW */ #define IXGB_TCTL 0x00600 /* TX Control - RW */
#define IXGB_TDBAL 0x00608 /* TX Descriptor Base Low - RW */ #define IXGB_TDBAL 0x00608 /* TX Descriptor Base Low - RW */
#define IXGB_TDBAH 0x0060C /* TX Descriptor Base High - RW */ #define IXGB_TDBAH 0x0060C /* TX Descriptor Base High - RW */
#define IXGB_TDLEN 0x00610 /* TX Descriptor Length - RW */ #define IXGB_TDLEN 0x00610 /* TX Descriptor Length - RW */
#define IXGB_TDH 0x00618 /* TX Descriptor Head - RW */ #define IXGB_TDH 0x00618 /* TX Descriptor Head - RW */
#define IXGB_TDT 0x00620 /* TX Descriptor Tail - RW */ #define IXGB_TDT 0x00620 /* TX Descriptor Tail - RW */
#define IXGB_TIDV 0x00628 /* TX Interrupt Delay Value - RW */ #define IXGB_TIDV 0x00628 /* TX Interrupt Delay Value - RW */
#define IXGB_TXDCTL 0x00630 /* Transmit Descriptor Control - RW */ #define IXGB_TXDCTL 0x00630 /* Transmit Descriptor Control - RW */
#define IXGB_TSPMT 0x00638 /* TCP Segmentation PAD & Min Threshold - RW */ #define IXGB_TSPMT 0x00638 /* TCP Segmentation PAD & Min Threshold - RW */
#define IXGB_PAP 0x00640 /* Pause and Pace - RW */ #define IXGB_PAP 0x00640 /* Pause and Pace - RW */
#define IXGB_REQ_TX_DESCRIPTOR_MULTIPLE 8 #define IXGB_REQ_TX_DESCRIPTOR_MULTIPLE 8
/* Physical */ /* Physical */
#define IXGB_PCSC1 0x00700 /* PCS Control 1 - RW */ #define IXGB_PCSC1 0x00700 /* PCS Control 1 - RW */
#define IXGB_PCSC2 0x00708 /* PCS Control 2 - RW */ #define IXGB_PCSC2 0x00708 /* PCS Control 2 - RW */
#define IXGB_PCSS1 0x00710 /* PCS Status 1 - RO */ #define IXGB_PCSS1 0x00710 /* PCS Status 1 - RO */
#define IXGB_PCSS2 0x00718 /* PCS Status 2 - RO */ #define IXGB_PCSS2 0x00718 /* PCS Status 2 - RO */
#define IXGB_XPCSS 0x00720 /* 10GBASE-X PCS Status (or XGXS Lane Status) - RO */ #define IXGB_XPCSS 0x00720 /* 10GBASE-X PCS Status (or XGXS Lane Status) - RO */
#define IXGB_UCCR 0x00728 /* Unilink Circuit Control Register */ #define IXGB_UCCR 0x00728 /* Unilink Circuit Control Register */
#define IXGB_XPCSTC 0x00730 /* 10GBASE-X PCS Test Control */ #define IXGB_XPCSTC 0x00730 /* 10GBASE-X PCS Test Control */
#define IXGB_MACA 0x00738 /* MDI Autoscan Command and Address - RW */ #define IXGB_MACA 0x00738 /* MDI Autoscan Command and Address - RW */
#define IXGB_APAE 0x00740 /* Autoscan PHY Address Enable - RW */ #define IXGB_APAE 0x00740 /* Autoscan PHY Address Enable - RW */
#define IXGB_ARD 0x00748 /* Autoscan Read Data - RO */ #define IXGB_ARD 0x00748 /* Autoscan Read Data - RO */
#define IXGB_AIS 0x00750 /* Autoscan Interrupt Status - RO */ #define IXGB_AIS 0x00750 /* Autoscan Interrupt Status - RO */
#define IXGB_MSCA 0x00758 /* MDI Single Command and Address - RW */ #define IXGB_MSCA 0x00758 /* MDI Single Command and Address - RW */
#define IXGB_MSRWD 0x00760 /* MDI Single Read and Write Data - RW, RO */ #define IXGB_MSRWD 0x00760 /* MDI Single Read and Write Data - RW, RO */
/* Wake-up */ /* Wake-up */
#define IXGB_WUFC 0x00808 /* Wake Up Filter Control - RW */ #define IXGB_WUFC 0x00808 /* Wake Up Filter Control - RW */
#define IXGB_WUS 0x00810 /* Wake Up Status - RO */ #define IXGB_WUS 0x00810 /* Wake Up Status - RO */
#define IXGB_FFLT 0x01000 /* Flexible Filter Length Table - RW */ #define IXGB_FFLT 0x01000 /* Flexible Filter Length Table - RW */
#define IXGB_FFMT 0x01020 /* Flexible Filter Mask Table - RW */ #define IXGB_FFMT 0x01020 /* Flexible Filter Mask Table - RW */
#define IXGB_FTVT 0x01420 /* Flexible Filter Value Table - RW */ #define IXGB_FTVT 0x01420 /* Flexible Filter Value Table - RW */
/* Statistics */ /* Statistics */
#define IXGB_TPRL 0x02000 /* Total Packets Received (Low) */ #define IXGB_TPRL 0x02000 /* Total Packets Received (Low) */
#define IXGB_TPRH 0x02004 /* Total Packets Received (High) */ #define IXGB_TPRH 0x02004 /* Total Packets Received (High) */
#define IXGB_GPRCL 0x02008 /* Good Packets Received Count (Low) */ #define IXGB_GPRCL 0x02008 /* Good Packets Received Count (Low) */
#define IXGB_GPRCH 0x0200C /* Good Packets Received Count (High) */ #define IXGB_GPRCH 0x0200C /* Good Packets Received Count (High) */
#define IXGB_BPRCL 0x02010 /* Broadcast Packets Received Count (Low) */ #define IXGB_BPRCL 0x02010 /* Broadcast Packets Received Count (Low) */
#define IXGB_BPRCH 0x02014 /* Broadcast Packets Received Count (High) */ #define IXGB_BPRCH 0x02014 /* Broadcast Packets Received Count (High) */
#define IXGB_MPRCL 0x02018 /* Multicast Packets Received Count (Low) */ #define IXGB_MPRCL 0x02018 /* Multicast Packets Received Count (Low) */
#define IXGB_MPRCH 0x0201C /* Multicast Packets Received Count (High) */ #define IXGB_MPRCH 0x0201C /* Multicast Packets Received Count (High) */
#define IXGB_UPRCL 0x02020 /* Unicast Packets Received Count (Low) */ #define IXGB_UPRCL 0x02020 /* Unicast Packets Received Count (Low) */
#define IXGB_UPRCH 0x02024 /* Unicast Packets Received Count (High) */ #define IXGB_UPRCH 0x02024 /* Unicast Packets Received Count (High) */
#define IXGB_VPRCL 0x02028 /* VLAN Packets Received Count (Low) */ #define IXGB_VPRCL 0x02028 /* VLAN Packets Received Count (Low) */
#define IXGB_VPRCH 0x0202C /* VLAN Packets Received Count (High) */ #define IXGB_VPRCH 0x0202C /* VLAN Packets Received Count (High) */
#define IXGB_JPRCL 0x02030 /* Jumbo Packets Received Count (Low) */ #define IXGB_JPRCL 0x02030 /* Jumbo Packets Received Count (Low) */
#define IXGB_JPRCH 0x02034 /* Jumbo Packets Received Count (High) */ #define IXGB_JPRCH 0x02034 /* Jumbo Packets Received Count (High) */
#define IXGB_GORCL 0x02038 /* Good Octets Received Count (Low) */ #define IXGB_GORCL 0x02038 /* Good Octets Received Count (Low) */
#define IXGB_GORCH 0x0203C /* Good Octets Received Count (High) */ #define IXGB_GORCH 0x0203C /* Good Octets Received Count (High) */
#define IXGB_TORL 0x02040 /* Total Octets Received (Low) */ #define IXGB_TORL 0x02040 /* Total Octets Received (Low) */
#define IXGB_TORH 0x02044 /* Total Octets Received (High) */ #define IXGB_TORH 0x02044 /* Total Octets Received (High) */
#define IXGB_RNBC 0x02048 /* Receive No Buffers Count */ #define IXGB_RNBC 0x02048 /* Receive No Buffers Count */
#define IXGB_RUC 0x02050 /* Receive Undersize Count */ #define IXGB_RUC 0x02050 /* Receive Undersize Count */
#define IXGB_ROC 0x02058 /* Receive Oversize Count */ #define IXGB_ROC 0x02058 /* Receive Oversize Count */
#define IXGB_RLEC 0x02060 /* Receive Length Error Count */ #define IXGB_RLEC 0x02060 /* Receive Length Error Count */
#define IXGB_CRCERRS 0x02068 /* CRC Error Count */ #define IXGB_CRCERRS 0x02068 /* CRC Error Count */
#define IXGB_ICBC 0x02070 /* Illegal control byte in mid-packet Count */ #define IXGB_ICBC 0x02070 /* Illegal control byte in mid-packet Count */
#define IXGB_ECBC 0x02078 /* Error Control byte in mid-packet Count */ #define IXGB_ECBC 0x02078 /* Error Control byte in mid-packet Count */
#define IXGB_MPC 0x02080 /* Missed Packets Count */ #define IXGB_MPC 0x02080 /* Missed Packets Count */
#define IXGB_TPTL 0x02100 /* Total Packets Transmitted (Low) */ #define IXGB_TPTL 0x02100 /* Total Packets Transmitted (Low) */
#define IXGB_TPTH 0x02104 /* Total Packets Transmitted (High) */ #define IXGB_TPTH 0x02104 /* Total Packets Transmitted (High) */
#define IXGB_GPTCL 0x02108 /* Good Packets Transmitted Count (Low) */ #define IXGB_GPTCL 0x02108 /* Good Packets Transmitted Count (Low) */
#define IXGB_GPTCH 0x0210C /* Good Packets Transmitted Count (High) */ #define IXGB_GPTCH 0x0210C /* Good Packets Transmitted Count (High) */
#define IXGB_BPTCL 0x02110 /* Broadcast Packets Transmitted Count (Low) */ #define IXGB_BPTCL 0x02110 /* Broadcast Packets Transmitted Count (Low) */
#define IXGB_BPTCH 0x02114 /* Broadcast Packets Transmitted Count (High) */ #define IXGB_BPTCH 0x02114 /* Broadcast Packets Transmitted Count (High) */
#define IXGB_MPTCL 0x02118 /* Multicast Packets Transmitted Count (Low) */ #define IXGB_MPTCL 0x02118 /* Multicast Packets Transmitted Count (Low) */
#define IXGB_MPTCH 0x0211C /* Multicast Packets Transmitted Count (High) */ #define IXGB_MPTCH 0x0211C /* Multicast Packets Transmitted Count (High) */
#define IXGB_UPTCL 0x02120 /* Unicast Packets Transmitted Count (Low) */ #define IXGB_UPTCL 0x02120 /* Unicast Packets Transmitted Count (Low) */
#define IXGB_UPTCH 0x02124 /* Unicast Packets Transmitted Count (High) */ #define IXGB_UPTCH 0x02124 /* Unicast Packets Transmitted Count (High) */
#define IXGB_VPTCL 0x02128 /* VLAN Packets Transmitted Count (Low) */ #define IXGB_VPTCL 0x02128 /* VLAN Packets Transmitted Count (Low) */
#define IXGB_VPTCH 0x0212C /* VLAN Packets Transmitted Count (High) */ #define IXGB_VPTCH 0x0212C /* VLAN Packets Transmitted Count (High) */
#define IXGB_JPTCL 0x02130 /* Jumbo Packets Transmitted Count (Low) */ #define IXGB_JPTCL 0x02130 /* Jumbo Packets Transmitted Count (Low) */
#define IXGB_JPTCH 0x02134 /* Jumbo Packets Transmitted Count (High) */ #define IXGB_JPTCH 0x02134 /* Jumbo Packets Transmitted Count (High) */
#define IXGB_GOTCL 0x02138 /* Good Octets Transmitted Count (Low) */ #define IXGB_GOTCL 0x02138 /* Good Octets Transmitted Count (Low) */
#define IXGB_GOTCH 0x0213C /* Good Octets Transmitted Count (High) */ #define IXGB_GOTCH 0x0213C /* Good Octets Transmitted Count (High) */
#define IXGB_TOTL 0x02140 /* Total Octets Transmitted Count (Low) */ #define IXGB_TOTL 0x02140 /* Total Octets Transmitted Count (Low) */
#define IXGB_TOTH 0x02144 /* Total Octets Transmitted Count (High) */ #define IXGB_TOTH 0x02144 /* Total Octets Transmitted Count (High) */
#define IXGB_DC 0x02148 /* Defer Count */ #define IXGB_DC 0x02148 /* Defer Count */
#define IXGB_PLT64C 0x02150 /* Packet Transmitted was less than 64 bytes Count */ #define IXGB_PLT64C 0x02150 /* Packet Transmitted was less than 64 bytes Count */
#define IXGB_TSCTC 0x02170 /* TCP Segmentation Context Transmitted Count */ #define IXGB_TSCTC 0x02170 /* TCP Segmentation Context Transmitted Count */
#define IXGB_TSCTFC 0x02178 /* TCP Segmentation Context Tx Fail Count */ #define IXGB_TSCTFC 0x02178 /* TCP Segmentation Context Tx Fail Count */
#define IXGB_IBIC 0x02180 /* Illegal byte during Idle stream count */ #define IXGB_IBIC 0x02180 /* Illegal byte during Idle stream count */
#define IXGB_RFC 0x02188 /* Remote Fault Count */ #define IXGB_RFC 0x02188 /* Remote Fault Count */
#define IXGB_LFC 0x02190 /* Local Fault Count */ #define IXGB_LFC 0x02190 /* Local Fault Count */
#define IXGB_PFRC 0x02198 /* Pause Frame Receive Count */ #define IXGB_PFRC 0x02198 /* Pause Frame Receive Count */
#define IXGB_PFTC 0x021A0 /* Pause Frame Transmit Count */ #define IXGB_PFTC 0x021A0 /* Pause Frame Transmit Count */
#define IXGB_MCFRC 0x021A8 /* MAC Control Frames (non-Pause) Received Count */ #define IXGB_MCFRC 0x021A8 /* MAC Control Frames (non-Pause) Received Count */
#define IXGB_MCFTC 0x021B0 /* MAC Control Frames (non-Pause) Transmitted Count */ #define IXGB_MCFTC 0x021B0 /* MAC Control Frames (non-Pause) Transmitted Count */
#define IXGB_XONRXC 0x021B8 /* XON Received Count */ #define IXGB_XONRXC 0x021B8 /* XON Received Count */
#define IXGB_XONTXC 0x021C0 /* XON Transmitted Count */ #define IXGB_XONTXC 0x021C0 /* XON Transmitted Count */
#define IXGB_XOFFRXC 0x021C8 /* XOFF Received Count */ #define IXGB_XOFFRXC 0x021C8 /* XOFF Received Count */
#define IXGB_XOFFTXC 0x021D0 /* XOFF Transmitted Count */ #define IXGB_XOFFTXC 0x021D0 /* XOFF Transmitted Count */
#define IXGB_RJC 0x021D8 /* Receive Jabber Count */ #define IXGB_RJC 0x021D8 /* Receive Jabber Count */
/* CTRL0 Bit Masks */ /* CTRL0 Bit Masks */
#define IXGB_CTRL0_LRST 0x00000008 #define IXGB_CTRL0_LRST 0x00000008
...@@ -245,14 +242,11 @@ typedef enum { ...@@ -245,14 +242,11 @@ typedef enum {
#define IXGB_CTRL1_EE_RST 0x00002000 #define IXGB_CTRL1_EE_RST 0x00002000
/* STATUS Bit Masks */ /* STATUS Bit Masks */
#define IXGB_STATUS_LU 0x00000002 #define IXGB_STATUS_LU 0x00000002
#define IXGB_STATUS_TXOFF 0x00000010 #define IXGB_STATUS_TXOFF 0x00000010
#define IXGB_STATUS_PCI_SPD 0x00000800 #define IXGB_STATUS_PCI_SPD 0x00000800
#define IXGB_STATUS_BUS64 0x00001000 #define IXGB_STATUS_BUS64 0x00001000
#define IXGB_STATUS_PCIX_MODE 0x00002000 #define IXGB_STATUS_PCIX_MODE 0x00002000
...@@ -261,14 +255,12 @@ typedef enum { ...@@ -261,14 +255,12 @@ typedef enum {
#define IXGB_STATUS_PCIX_SPD_100 0x00004000 #define IXGB_STATUS_PCIX_SPD_100 0x00004000
#define IXGB_STATUS_PCIX_SPD_133 0x00008000 #define IXGB_STATUS_PCIX_SPD_133 0x00008000
/* EECD Bit Masks */ /* EECD Bit Masks */
#define IXGB_EECD_SK 0x00000001 #define IXGB_EECD_SK 0x00000001
#define IXGB_EECD_CS 0x00000002 #define IXGB_EECD_CS 0x00000002
#define IXGB_EECD_DI 0x00000004 #define IXGB_EECD_DI 0x00000004
#define IXGB_EECD_DO 0x00000008 #define IXGB_EECD_DO 0x00000008
/* MFS */ /* MFS */
#define IXGB_MFS_SHIFT 16 #define IXGB_MFS_SHIFT 16
...@@ -297,18 +289,17 @@ typedef enum { ...@@ -297,18 +289,17 @@ typedef enum {
#define IXGB_RCTL_CFF 0x00800000 #define IXGB_RCTL_CFF 0x00800000
#define IXGB_RCTL_SECRC 0x04000000 #define IXGB_RCTL_SECRC 0x04000000
/* FCRTL Bit Masks */ /* FCRTL Bit Masks */
#define IXGB_FCRTL_XONE 0x80000000 #define IXGB_FCRTL_XONE 0x80000000
/* RXDCTL Bit Masks */ /* RXDCTL Bit Masks */
#define IXGB_RXDCTL_PTHRESH_SHIFT 0 #define IXGB_RXDCTL_PTHRESH_SHIFT 0
#define IXGB_RXDCTL_HTHRESH_SHIFT 9 #define IXGB_RXDCTL_HTHRESH_SHIFT 9
#define IXGB_RXDCTL_WTHRESH_SHIFT 18 #define IXGB_RXDCTL_WTHRESH_SHIFT 18
/* RAIDC Bit Masks */ /* RAIDC Bit Masks */
#define IXGB_RAIDC_DELAY_SHIFT 11 #define IXGB_RAIDC_DELAY_SHIFT 11
#define IXGB_RAIDC_POLL_SHIFT 20 #define IXGB_RAIDC_POLL_SHIFT 20
#define IXGB_RAIDC_RXT_GATE 0x40000000 #define IXGB_RAIDC_RXT_GATE 0x40000000
#define IXGB_RAIDC_EN 0x80000000 #define IXGB_RAIDC_EN 0x80000000
...@@ -323,9 +314,8 @@ typedef enum { ...@@ -323,9 +314,8 @@ typedef enum {
#define IXGB_TCTL_TXEN 0x00000002 #define IXGB_TCTL_TXEN 0x00000002
#define IXGB_TCTL_TPDE 0x00000004 #define IXGB_TCTL_TPDE 0x00000004
/* TXDCTL Bit Masks */ /* TXDCTL Bit Masks */
#define IXGB_TXDCTL_HTHRESH_SHIFT 8 #define IXGB_TXDCTL_HTHRESH_SHIFT 8
/* TSPMT Bit Masks */ /* TSPMT Bit Masks */
...@@ -361,7 +351,7 @@ typedef enum { ...@@ -361,7 +351,7 @@ typedef enum {
#define IXGB_MSRWD_READ_DATA_SHIFT 16 #define IXGB_MSRWD_READ_DATA_SHIFT 16
/* Definitions for the TXN17401 devices on the MDIO bus. */ /* Definitions for the TXN17401 devices on the MDIO bus. */
#define IXGB_PHY_ADDRESS 0x0 /* Single PHY, multiple "Devices" */ #define IXGB_PHY_ADDRESS 0x0 /* Single PHY, multiple "Devices" */
/* Five bit Device IDs */ /* Five bit Device IDs */
#define TXN17401_PMA_PMD_DID 0x01 #define TXN17401_PMA_PMD_DID 0x01
...@@ -376,12 +366,12 @@ typedef enum { ...@@ -376,12 +366,12 @@ typedef enum {
#define TXN17401_PMA_PMD_CR1_RESET 0x8000 #define TXN17401_PMA_PMD_CR1_RESET 0x8000
struct ixgb_rx_desc { struct ixgb_rx_desc {
uint64_t buff_addr; uint64_t buff_addr;
uint16_t length; uint16_t length;
uint16_t reserved; uint16_t reserved;
uint8_t status; uint8_t status;
uint8_t errors; uint8_t errors;
uint16_t special; uint16_t special;
}; };
#define IXGB_RX_DESC_STATUS_DD 0x01 #define IXGB_RX_DESC_STATUS_DD 0x01
...@@ -396,14 +386,14 @@ struct ixgb_rx_desc { ...@@ -396,14 +386,14 @@ struct ixgb_rx_desc {
#define IXGB_RX_DESC_ERRORS_TCPE 0x20 #define IXGB_RX_DESC_ERRORS_TCPE 0x20
#define IXGB_RX_DESC_ERRORS_RXE 0x80 #define IXGB_RX_DESC_ERRORS_RXE 0x80
#define IXGB_RX_DESC_SPECIAL_VLAN_MASK 0x0FFF /* VLAN ID is in lower 12 bits */ #define IXGB_RX_DESC_SPECIAL_VLAN_MASK 0x0FFF /* VLAN ID is in lower 12 bits */
struct ixgb_tx_desc { struct ixgb_tx_desc {
uint64_t buff_addr; uint64_t buff_addr;
uint32_t cmd_type_len; uint32_t cmd_type_len;
uint8_t status; uint8_t status;
uint8_t popts; uint8_t popts;
uint16_t vlan; uint16_t vlan;
}; };
#define IXGB_TX_DESC_CMD_EOP 0x01000000 #define IXGB_TX_DESC_CMD_EOP 0x01000000
...@@ -420,18 +410,18 @@ struct ixgb_tx_desc { ...@@ -420,18 +410,18 @@ struct ixgb_tx_desc {
#define IXGB_TX_DESC_POPTS_TXSM 0x02 #define IXGB_TX_DESC_POPTS_TXSM 0x02
struct ixgb_context_desc { struct ixgb_context_desc {
uint8_t ipcss; uint8_t ipcss;
uint8_t ipcso; uint8_t ipcso;
uint16_t ipcse; uint16_t ipcse;
uint8_t tucss; uint8_t tucss;
uint8_t tucso; uint8_t tucso;
uint16_t tucse; uint16_t tucse;
uint32_t cmd_type_len; uint32_t cmd_type_len;
uint8_t status; uint8_t status;
uint8_t hdr_len; uint8_t hdr_len;
uint16_t mss; uint16_t mss;
}; };
#define IXGB_CONTEXT_DESC_CMD_TCP 0x01000000 #define IXGB_CONTEXT_DESC_CMD_TCP 0x01000000
#define IXGB_CONTEXT_DESC_CMD_IP 0x02000000 #define IXGB_CONTEXT_DESC_CMD_IP 0x02000000
#define IXGB_CONTEXT_DESC_CMD_TSE 0x04000000 #define IXGB_CONTEXT_DESC_CMD_TSE 0x04000000
...@@ -440,11 +430,10 @@ struct ixgb_context_desc { ...@@ -440,11 +430,10 @@ struct ixgb_context_desc {
#define IXGB_CONTEXT_DESC_TYPE 0x00000000 #define IXGB_CONTEXT_DESC_TYPE 0x00000000
/* Filters */ /* Filters */
#define IXGB_RAR_ENTRIES 16 /* Number of entries in Rx Address array */ #define IXGB_RAR_ENTRIES 16 /* Number of entries in Rx Address array */
#define IXGB_MC_TBL_SIZE 128 /* Multicast Filter Table (4096 bits) */ #define IXGB_MC_TBL_SIZE 128 /* Multicast Filter Table (4096 bits) */
#define IXGB_VLAN_FILTER_TBL_SIZE 128 /* VLAN Filter Table (4096 bits) */ #define IXGB_VLAN_FILTER_TBL_SIZE 128 /* VLAN Filter Table (4096 bits) */
#define ENET_HEADER_SIZE 14 #define ENET_HEADER_SIZE 14
#define ENET_FCS_LENGTH 4 #define ENET_FCS_LENGTH 4
...@@ -461,7 +450,6 @@ struct ixgb_context_desc { ...@@ -461,7 +450,6 @@ struct ixgb_context_desc {
#define IS_MULTICAST(Address) \ #define IS_MULTICAST(Address) \
(boolean_t)(((uint8_t *)(Address))[0] & ((uint8_t)0x01)) (boolean_t)(((uint8_t *)(Address))[0] & ((uint8_t)0x01))
/* /*
* Check whether an address is broadcast. * Check whether an address is broadcast.
*/ */
...@@ -470,11 +458,11 @@ struct ixgb_context_desc { ...@@ -470,11 +458,11 @@ struct ixgb_context_desc {
/* Flow control parameters */ /* Flow control parameters */
struct ixgb_fc { struct ixgb_fc {
uint32_t high_water; /* Flow Control High-water */ uint32_t high_water; /* Flow Control High-water */
uint32_t low_water; /* Flow Control Low-water */ uint32_t low_water; /* Flow Control Low-water */
uint16_t pause_time; /* Flow Control Pause timer */ uint16_t pause_time; /* Flow Control Pause timer */
boolean_t send_xon; /* Flow control send XON */ boolean_t send_xon; /* Flow control send XON */
ixgb_fc_type type; /* Type of flow control */ ixgb_fc_type type; /* Type of flow control */
}; };
/* The historical defaults for the flow control values are given below. */ /* The historical defaults for the flow control values are given below. */
...@@ -486,102 +474,102 @@ struct ixgb_fc { ...@@ -486,102 +474,102 @@ struct ixgb_fc {
/* Bus parameters */ /* Bus parameters */
struct ixgb_bus { struct ixgb_bus {
ixgb_bus_speed speed; ixgb_bus_speed speed;
ixgb_bus_width width; ixgb_bus_width width;
ixgb_bus_type type; ixgb_bus_type type;
}; };
struct ixgb_hw { struct ixgb_hw {
uint8_t *hw_addr; /* Base Address of the hardware */ uint8_t *hw_addr; /* Base Address of the hardware */
void *back; /* Pointer to OS-dependent struct */ void *back; /* Pointer to OS-dependent struct */
struct ixgb_fc fc; /* Flow control parameters */ struct ixgb_fc fc; /* Flow control parameters */
struct ixgb_bus bus; /* Bus parameters */ struct ixgb_bus bus; /* Bus parameters */
uint32_t phy_id; /* Phy Identifier */ uint32_t phy_id; /* Phy Identifier */
uint32_t phy_addr; /* XGMII address of Phy */ uint32_t phy_addr; /* XGMII address of Phy */
ixgb_mac_type mac_type; /* Identifier for MAC controller */ ixgb_mac_type mac_type; /* Identifier for MAC controller */
uint32_t max_frame_size; /* Maximum frame size supported */ uint32_t max_frame_size; /* Maximum frame size supported */
uint32_t mc_filter_type; /* Multicast filter hash type */ uint32_t mc_filter_type; /* Multicast filter hash type */
uint32_t num_mc_addrs; /* Number of current Multicast addrs*/ uint32_t num_mc_addrs; /* Number of current Multicast addrs */
uint8_t curr_mac_addr[IXGB_ETH_LENGTH_OF_ADDRESS]; /* Individual address currently programmed in MAC */ uint8_t curr_mac_addr[IXGB_ETH_LENGTH_OF_ADDRESS]; /* Individual address currently programmed in MAC */
uint32_t num_tx_desc; /* Number of Transmit descriptors */ uint32_t num_tx_desc; /* Number of Transmit descriptors */
uint32_t num_rx_desc; /* Number of Receive descriptors */ uint32_t num_rx_desc; /* Number of Receive descriptors */
uint32_t rx_buffer_size; /* Size of Receive buffer */ uint32_t rx_buffer_size; /* Size of Receive buffer */
boolean_t link_up; /* TRUE if link is valid */ boolean_t link_up; /* TRUE if link is valid */
boolean_t adapter_stopped; /* State of adapter */ boolean_t adapter_stopped; /* State of adapter */
uint16_t device_id; /* device id from PCI configuration space */ uint16_t device_id; /* device id from PCI configuration space */
uint16_t vendor_id; /* vendor id from PCI configuration space */ uint16_t vendor_id; /* vendor id from PCI configuration space */
uint8_t revision_id; /* revision id from PCI configuration space */ uint8_t revision_id; /* revision id from PCI configuration space */
uint16_t subsystem_vendor_id;/* subsystem vendor id from PCI configuration space */ uint16_t subsystem_vendor_id; /* subsystem vendor id from PCI configuration space */
uint16_t subsystem_id; /* subsystem id from PCI configuration space */ uint16_t subsystem_id; /* subsystem id from PCI configuration space */
uint16_t pci_cmd_word; /* PCI command register id from PCI configuration space */ uint16_t pci_cmd_word; /* PCI command register id from PCI configuration space */
uint16_t eeprom[IXGB_EEPROM_SIZE]; /* EEPROM contents read at init time */ uint16_t eeprom[IXGB_EEPROM_SIZE]; /* EEPROM contents read at init time */
uint64_t io_base; /* Our I/O mapped location */ uint64_t io_base; /* Our I/O mapped location */
uint32_t lastLFC; uint32_t lastLFC;
uint32_t lastRFC; uint32_t lastRFC;
}; };
struct ixgb_hw_stats { struct ixgb_hw_stats {
uint64_t tprl; uint64_t tprl;
uint64_t tprh; uint64_t tprh;
uint64_t gprcl; uint64_t gprcl;
uint64_t gprch; uint64_t gprch;
uint64_t bprcl; uint64_t bprcl;
uint64_t bprch; uint64_t bprch;
uint64_t mprcl; uint64_t mprcl;
uint64_t mprch; uint64_t mprch;
uint64_t uprcl; uint64_t uprcl;
uint64_t uprch; uint64_t uprch;
uint64_t vprcl; uint64_t vprcl;
uint64_t vprch; uint64_t vprch;
uint64_t jprcl; uint64_t jprcl;
uint64_t jprch; uint64_t jprch;
uint64_t gorcl; uint64_t gorcl;
uint64_t gorch; uint64_t gorch;
uint64_t torl; uint64_t torl;
uint64_t torh; uint64_t torh;
uint64_t rnbc; uint64_t rnbc;
uint64_t ruc; uint64_t ruc;
uint64_t roc; uint64_t roc;
uint64_t rlec; uint64_t rlec;
uint64_t crcerrs; uint64_t crcerrs;
uint64_t icbc; uint64_t icbc;
uint64_t ecbc; uint64_t ecbc;
uint64_t mpc; uint64_t mpc;
uint64_t tptl; uint64_t tptl;
uint64_t tpth; uint64_t tpth;
uint64_t gptcl; uint64_t gptcl;
uint64_t gptch; uint64_t gptch;
uint64_t bptcl; uint64_t bptcl;
uint64_t bptch; uint64_t bptch;
uint64_t mptcl; uint64_t mptcl;
uint64_t mptch; uint64_t mptch;
uint64_t uptcl; uint64_t uptcl;
uint64_t uptch; uint64_t uptch;
uint64_t vptcl; uint64_t vptcl;
uint64_t vptch; uint64_t vptch;
uint64_t jptcl; uint64_t jptcl;
uint64_t jptch; uint64_t jptch;
uint64_t gotcl; uint64_t gotcl;
uint64_t gotch; uint64_t gotch;
uint64_t totl; uint64_t totl;
uint64_t toth; uint64_t toth;
uint64_t dc; uint64_t dc;
uint64_t plt64c; uint64_t plt64c;
uint64_t tsctc; uint64_t tsctc;
uint64_t tsctfc; uint64_t tsctfc;
uint64_t ibic; uint64_t ibic;
uint64_t rfc; uint64_t rfc;
uint64_t lfc; uint64_t lfc;
uint64_t pfrc; uint64_t pfrc;
uint64_t pftc; uint64_t pftc;
uint64_t mcfrc; uint64_t mcfrc;
uint64_t mcftc; uint64_t mcftc;
uint64_t xonrxc; uint64_t xonrxc;
uint64_t xontxc; uint64_t xontxc;
uint64_t xoffrxc; uint64_t xoffrxc;
uint64_t xofftxc; uint64_t xofftxc;
uint64_t rjc; uint64_t rjc;
}; };
/* Function Prototypes */ /* Function Prototypes */
extern boolean_t ixgb_adapter_stop(struct ixgb_hw *hw); extern boolean_t ixgb_adapter_stop(struct ixgb_hw *hw);
...@@ -592,40 +580,32 @@ extern void ixgb_check_for_link(struct ixgb_hw *hw); ...@@ -592,40 +580,32 @@ extern void ixgb_check_for_link(struct ixgb_hw *hw);
extern boolean_t ixgb_check_for_bad_link(struct ixgb_hw *hw); extern boolean_t ixgb_check_for_bad_link(struct ixgb_hw *hw);
extern boolean_t ixgb_setup_fc(struct ixgb_hw *hw); extern boolean_t ixgb_setup_fc(struct ixgb_hw *hw);
extern void ixgb_clear_hw_cntrs(struct ixgb_hw *hw); extern void ixgb_clear_hw_cntrs(struct ixgb_hw *hw);
extern boolean_t mac_addr_valid(uint8_t *mac_addr); extern boolean_t mac_addr_valid(uint8_t * mac_addr);
extern uint16_t ixgb_read_phy_reg(struct ixgb_hw *hw, extern uint16_t ixgb_read_phy_reg(struct ixgb_hw *hw,
uint32_t reg_addr, uint32_t reg_addr,
uint32_t phy_addr, uint32_t phy_addr, uint32_t device_type);
uint32_t device_type);
extern void ixgb_write_phy_reg(struct ixgb_hw *hw, extern void ixgb_write_phy_reg(struct ixgb_hw *hw,
uint32_t reg_addr, uint32_t reg_addr,
uint32_t phy_addr, uint32_t phy_addr,
uint32_t device_type, uint32_t device_type, uint16_t data);
uint16_t data);
extern void ixgb_rar_set(struct ixgb_hw *hw,
uint8_t *addr,
uint32_t index);
extern void ixgb_rar_set(struct ixgb_hw *hw, uint8_t * addr, uint32_t index);
/* Filters (multicast, vlan, receive) */ /* Filters (multicast, vlan, receive) */
extern void ixgb_mc_addr_list_update(struct ixgb_hw *hw, extern void ixgb_mc_addr_list_update(struct ixgb_hw *hw,
uint8_t * mc_addr_list, uint8_t * mc_addr_list,
uint32_t mc_addr_count, uint32_t mc_addr_count, uint32_t pad);
uint32_t pad);
/* Vfta functions */ /* Vfta functions */
extern void ixgb_write_vfta(struct ixgb_hw *hw, extern void ixgb_write_vfta(struct ixgb_hw *hw,
uint32_t offset, uint32_t offset, uint32_t value);
uint32_t value);
extern void ixgb_clear_vfta(struct ixgb_hw *hw); extern void ixgb_clear_vfta(struct ixgb_hw *hw);
/* Access functions to eeprom data */ /* Access functions to eeprom data */
void ixgb_get_ee_mac_addr(struct ixgb_hw *hw, uint8_t *mac_addr); void ixgb_get_ee_mac_addr(struct ixgb_hw *hw, uint8_t * mac_addr);
uint16_t ixgb_get_ee_compatibility(struct ixgb_hw *hw); uint16_t ixgb_get_ee_compatibility(struct ixgb_hw *hw);
uint32_t ixgb_get_ee_pba_number(struct ixgb_hw *hw); uint32_t ixgb_get_ee_pba_number(struct ixgb_hw *hw);
uint16_t ixgb_get_ee_init_ctrl_reg_1(struct ixgb_hw *hw); uint16_t ixgb_get_ee_init_ctrl_reg_1(struct ixgb_hw *hw);
...@@ -635,16 +615,13 @@ uint16_t ixgb_get_ee_subvendor_id(struct ixgb_hw *hw); ...@@ -635,16 +615,13 @@ uint16_t ixgb_get_ee_subvendor_id(struct ixgb_hw *hw);
uint16_t ixgb_get_ee_device_id(struct ixgb_hw *hw); uint16_t ixgb_get_ee_device_id(struct ixgb_hw *hw);
uint16_t ixgb_get_ee_vendor_id(struct ixgb_hw *hw); uint16_t ixgb_get_ee_vendor_id(struct ixgb_hw *hw);
uint16_t ixgb_get_ee_swdpins_reg(struct ixgb_hw *hw); uint16_t ixgb_get_ee_swdpins_reg(struct ixgb_hw *hw);
uint8_t ixgb_get_ee_d3_power(struct ixgb_hw *hw); uint8_t ixgb_get_ee_d3_power(struct ixgb_hw *hw);
uint8_t ixgb_get_ee_d0_power(struct ixgb_hw *hw); uint8_t ixgb_get_ee_d0_power(struct ixgb_hw *hw);
boolean_t ixgb_get_eeprom_data(struct ixgb_hw *hw); boolean_t ixgb_get_eeprom_data(struct ixgb_hw *hw);
/* Everything else */ /* Everything else */
void ixgb_led_on(struct ixgb_hw *hw); void ixgb_led_on(struct ixgb_hw *hw);
void ixgb_led_off(struct ixgb_hw *hw); void ixgb_led_off(struct ixgb_hw *hw);
void ixgb_write_pci_cfg(struct ixgb_hw *hw, void ixgb_write_pci_cfg(struct ixgb_hw *hw, uint32_t reg, uint16_t * value);
uint32_t reg,
uint16_t * value);
#endif /* _IXGB_HW_H_ */ #endif /* _IXGB_HW_H_ */
drivers/net/ixgb/ixgb_ids.h
View file @ ca247341
...@@ -25,7 +25,6 @@ ...@@ -25,7 +25,6 @@
Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497 Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
*******************************************************************************/ *******************************************************************************/
#ifndef _IXGB_IDS_H_ #ifndef _IXGB_IDS_H_
#define _IXGB_IDS_H_ #define _IXGB_IDS_H_
...@@ -37,9 +36,9 @@ ...@@ -37,9 +36,9 @@
#define INTEL_SUBVENDOR_ID 0x8086 #define INTEL_SUBVENDOR_ID 0x8086
#define IXGB_DEVICE_ID_82597EX 0x1048 #define IXGB_DEVICE_ID_82597EX 0x1048
#define IXGB_SUBDEVICE_ID_A11F 0xA11F /* Adapter-OEM-1310nm-Fiber */ #define IXGB_SUBDEVICE_ID_A11F 0xA11F /* Adapter-OEM-1310nm-Fiber */
#define IXGB_SUBDEVICE_ID_A01F 0xA01F /* Adapter-Retail-1310nm-Fiber */ #define IXGB_SUBDEVICE_ID_A01F 0xA01F /* Adapter-Retail-1310nm-Fiber */
#endif /* #ifndef _IXGB_IDS_H_ */ #endif /* #ifndef _IXGB_IDS_H_ */
/* End of File */ /* End of File */
drivers/net/ixgb/ixgb_main.c
View file @ ca247341
...@@ -88,12 +88,13 @@ static void ixgb_free_tx_resources(struct ixgb_adapter *adapter); ...@@ -88,12 +88,13 @@ static void ixgb_free_tx_resources(struct ixgb_adapter *adapter);
static void ixgb_free_rx_resources(struct ixgb_adapter *adapter); static void ixgb_free_rx_resources(struct ixgb_adapter *adapter);
static void ixgb_set_multi(struct net_device *netdev); static void ixgb_set_multi(struct net_device *netdev);
static void ixgb_watchdog(unsigned long data); static void ixgb_watchdog(unsigned long data);
static inline boolean_t ixgb_tso(struct ixgb_adapter *adapter, static inline boolean_t ixgb_tso(struct ixgb_adapter *adapter,
struct sk_buff *skb); struct sk_buff *skb);
static int ixgb_xmit_frame(struct sk_buff *skb, struct net_device *netdev); static int ixgb_xmit_frame(struct sk_buff *skb, struct net_device *netdev);
static void ixgb_tx_timeout(struct net_device *netdev); static void ixgb_tx_timeout(struct net_device *netdev);
static void ixgb_tx_timeout_task(struct net_device *netdev); static void ixgb_tx_timeout_task(struct net_device *netdev);
static void ixgb_vlan_rx_register(struct net_device *netdev, struct vlan_group *grp); static void ixgb_vlan_rx_register(struct net_device *netdev,
struct vlan_group *grp);
static void ixgb_vlan_rx_add_vid(struct net_device *netdev, uint16_t vid); static void ixgb_vlan_rx_add_vid(struct net_device *netdev, uint16_t vid);
static void ixgb_vlan_rx_kill_vid(struct net_device *netdev, uint16_t vid); static void ixgb_vlan_rx_kill_vid(struct net_device *netdev, uint16_t vid);
static void ixgb_restore_vlan(struct ixgb_adapter *adapter); static void ixgb_restore_vlan(struct ixgb_adapter *adapter);
...@@ -113,9 +114,10 @@ static void ixgb_clean_rx_irq(struct ixgb_adapter *adapter); ...@@ -113,9 +114,10 @@ static void ixgb_clean_rx_irq(struct ixgb_adapter *adapter);
static void ixgb_alloc_rx_buffers(struct ixgb_adapter *adapter); static void ixgb_alloc_rx_buffers(struct ixgb_adapter *adapter);
static int ixgb_ioctl(struct net_device *netdev, struct ifreq *ifr, int cmd); static int ixgb_ioctl(struct net_device *netdev, struct ifreq *ifr, int cmd);
static inline void ixgb_rx_checksum(struct ixgb_adapter *adapter, static inline void ixgb_rx_checksum(struct ixgb_adapter *adapter,
struct ixgb_rx_desc *rx_desc, struct ixgb_rx_desc *rx_desc,
struct sk_buff *skb); struct sk_buff *skb);
static int ixgb_notify_reboot(struct notifier_block *, unsigned long event, void *ptr); static int ixgb_notify_reboot(struct notifier_block *, unsigned long event,
void *ptr);
static int ixgb_suspend(struct pci_dev *pdev, uint32_t state); static int ixgb_suspend(struct pci_dev *pdev, uint32_t state);
struct notifier_block ixgb_notifier_reboot = { struct notifier_block ixgb_notifier_reboot = {
...@@ -124,13 +126,11 @@ struct notifier_block ixgb_notifier_reboot = { ...@@ -124,13 +126,11 @@ struct notifier_block ixgb_notifier_reboot = {
.priority = 0 .priority = 0
}; };
/* Exported from other modules */ /* Exported from other modules */
extern void ixgb_check_options(struct ixgb_adapter *adapter); extern void ixgb_check_options(struct ixgb_adapter *adapter);
extern int ixgb_ethtool_ioctl(struct net_device *netdev, struct ifreq *ifr); extern int ixgb_ethtool_ioctl(struct net_device *netdev, struct ifreq *ifr);
static struct pci_driver ixgb_driver = { static struct pci_driver ixgb_driver = {
.name = ixgb_driver_name, .name = ixgb_driver_name,
.id_table = ixgb_pci_tbl, .id_table = ixgb_pci_tbl,
...@@ -146,10 +146,10 @@ MODULE_DESCRIPTION("Intel(R) PRO/10GbE Network Driver"); ...@@ -146,10 +146,10 @@ MODULE_DESCRIPTION("Intel(R) PRO/10GbE Network Driver");
MODULE_LICENSE("GPL"); MODULE_LICENSE("GPL");
/* some defines for controlling descriptor fetches in h/w */ /* some defines for controlling descriptor fetches in h/w */
#define RXDCTL_PTHRESH_DEFAULT 128 /* chip considers prefech below this */ #define RXDCTL_PTHRESH_DEFAULT 128 /* chip considers prefech below this */
#define RXDCTL_HTHRESH_DEFAULT 16 /* chip will only prefetch if tail is #define RXDCTL_HTHRESH_DEFAULT 16 /* chip will only prefetch if tail is
pushed this many descriptors from head */ pushed this many descriptors from head */
#define RXDCTL_WTHRESH_DEFAULT 16 /* chip writes back at this many or RXT0 */ #define RXDCTL_WTHRESH_DEFAULT 16 /* chip writes back at this many or RXT0 */
/** /**
* ixgb_init_module - Driver Registration Routine. * ixgb_init_module - Driver Registration Routine.
...@@ -171,7 +171,7 @@ ixgb_init_module(void) ...@@ -171,7 +171,7 @@ ixgb_init_module(void)
printk(KERN_INFO "NAPI Enabled\n"); printk(KERN_INFO "NAPI Enabled\n");
#endif #endif
ret = pci_module_init(&ixgb_driver); ret = pci_module_init(&ixgb_driver);
if(ret >= 0) { if (ret >= 0) {
register_reboot_notifier(&ixgb_notifier_reboot); register_reboot_notifier(&ixgb_notifier_reboot);
} }
return ret; return ret;
...@@ -211,8 +211,8 @@ ixgb_up(struct ixgb_adapter *adapter) ...@@ -211,8 +211,8 @@ ixgb_up(struct ixgb_adapter *adapter)
IXGB_DBG("ixgb_up\n"); IXGB_DBG("ixgb_up\n");
if(request_irq(netdev->irq, &ixgb_intr, SA_SHIRQ | SA_SAMPLE_RANDOM, if (request_irq(netdev->irq, &ixgb_intr, SA_SHIRQ | SA_SAMPLE_RANDOM,
netdev->name, netdev)) { netdev->name, netdev)) {
IXGB_DBG("%s: request_irq failed\n", netdev->name); IXGB_DBG("%s: request_irq failed\n", netdev->name);
return -1; return -1;
} }
...@@ -233,7 +233,7 @@ ixgb_up(struct ixgb_adapter *adapter) ...@@ -233,7 +233,7 @@ ixgb_up(struct ixgb_adapter *adapter)
IXGB_DBG("ixgb_up: RAH_0 is <%x>\n", IXGB_READ_REG(&adapter->hw, RAH)); IXGB_DBG("ixgb_up: RAH_0 is <%x>\n", IXGB_READ_REG(&adapter->hw, RAH));
IXGB_DBG("ixgb_up: RDBAL is <%x>\n", IXGB_DBG("ixgb_up: RDBAL is <%x>\n",
IXGB_READ_REG(&adapter->hw, RDBAL)); IXGB_READ_REG(&adapter->hw, RDBAL));
return 0; return 0;
} }
...@@ -253,7 +253,7 @@ ixgb_down(struct ixgb_adapter *adapter, boolean_t kill_watchdog) ...@@ -253,7 +253,7 @@ ixgb_down(struct ixgb_adapter *adapter, boolean_t kill_watchdog)
ixgb_irq_disable(adapter); ixgb_irq_disable(adapter);
free_irq(netdev->irq, netdev); free_irq(netdev->irq, netdev);
if(kill_watchdog) if (kill_watchdog)
del_timer_sync(&adapter->watchdog_timer); del_timer_sync(&adapter->watchdog_timer);
adapter->link_speed = 0; adapter->link_speed = 0;
adapter->link_duplex = 0; adapter->link_duplex = 0;
...@@ -278,7 +278,7 @@ ixgb_reset(struct ixgb_adapter *adapter) ...@@ -278,7 +278,7 @@ ixgb_reset(struct ixgb_adapter *adapter)
IXGB_DBG("ixgb_reset\n"); IXGB_DBG("ixgb_reset\n");
ixgb_adapter_stop(&adapter->hw); ixgb_adapter_stop(&adapter->hw);
if(!ixgb_init_hw(&adapter->hw)) if (!ixgb_init_hw(&adapter->hw))
IXGB_DBG("ixgb_init_hw failed.\n"); IXGB_DBG("ixgb_init_hw failed.\n");
} }
...@@ -303,22 +303,22 @@ ixgb_probe(struct pci_dev *pdev, const struct pci_device_id *ent) ...@@ -303,22 +303,22 @@ ixgb_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
IXGB_DBG("ixgb_probe\n"); IXGB_DBG("ixgb_probe\n");
if((i = pci_enable_device(pdev))) { if ((i = pci_enable_device(pdev))) {
IXGB_ERR("pci_enable_device failed\n"); IXGB_ERR("pci_enable_device failed\n");
return i; return i;
} }
if(!(i = pci_set_dma_mask(pdev, PCI_DMA_64BIT))) { if (!(i = pci_set_dma_mask(pdev, PCI_DMA_64BIT))) {
pci_using_dac = 1; pci_using_dac = 1;
} else { } else {
if((i = pci_set_dma_mask(pdev, PCI_DMA_32BIT))) { if ((i = pci_set_dma_mask(pdev, PCI_DMA_32BIT))) {
IXGB_ERR("No usable DMA configuration, aborting\n"); IXGB_ERR("No usable DMA configuration, aborting\n");
return i; return i;
} }
pci_using_dac = 0; pci_using_dac = 0;
} }
if((i = pci_request_regions(pdev, ixgb_driver_name))) { if ((i = pci_request_regions(pdev, ixgb_driver_name))) {
IXGB_ERR("Failed to reserve PCI I/O and Memory resources.\n"); IXGB_ERR("Failed to reserve PCI I/O and Memory resources.\n");
return i; return i;
} }
...@@ -326,8 +326,8 @@ ixgb_probe(struct pci_dev *pdev, const struct pci_device_id *ent) ...@@ -326,8 +326,8 @@ ixgb_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
pci_set_master(pdev); pci_set_master(pdev);
/* alloc_etherdev clears the memory for us */ /* alloc_etherdev clears the memory for us */
netdev = alloc_etherdev(sizeof(struct ixgb_adapter)); netdev = alloc_etherdev(sizeof (struct ixgb_adapter));
if(!netdev) { if (!netdev) {
IXGB_ERR("Unable to allocate net_device struct\n"); IXGB_ERR("Unable to allocate net_device struct\n");
goto err_alloc_etherdev; goto err_alloc_etherdev;
} }
...@@ -344,19 +344,19 @@ ixgb_probe(struct pci_dev *pdev, const struct pci_device_id *ent) ...@@ -344,19 +344,19 @@ ixgb_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
mmio_len = pci_resource_len(pdev, BAR_0); mmio_len = pci_resource_len(pdev, BAR_0);
adapter->hw.hw_addr = ioremap(mmio_start, mmio_len); adapter->hw.hw_addr = ioremap(mmio_start, mmio_len);
if(!adapter->hw.hw_addr) if (!adapter->hw.hw_addr)
goto err_ioremap; goto err_ioremap;
for(i = BAR_1; i <= BAR_5; i++) { for (i = BAR_1; i <= BAR_5; i++) {
if(pci_resource_len(pdev, i) == 0) if (pci_resource_len(pdev, i) == 0)
continue; continue;
if(pci_resource_flags(pdev, i) & IORESOURCE_IO) { if (pci_resource_flags(pdev, i) & IORESOURCE_IO) {
adapter->hw.io_base = pci_resource_start(pdev, i); adapter->hw.io_base = pci_resource_start(pdev, i);
break; break;
} }
} }
IXGB_DBG("mmio_start<%lx> hw_addr<%p>\n", mmio_start, IXGB_DBG("mmio_start<%lx> hw_addr<%p>\n", mmio_start,
adapter->hw.hw_addr); adapter->hw.hw_addr);
netdev->open = &ixgb_open; netdev->open = &ixgb_open;
netdev->stop = &ixgb_close; netdev->stop = &ixgb_close;
...@@ -378,7 +378,7 @@ ixgb_probe(struct pci_dev *pdev, const struct pci_device_id *ent) ...@@ -378,7 +378,7 @@ ixgb_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
netdev->irq = pdev->irq; netdev->irq = pdev->irq;
netdev->mem_start = mmio_start; netdev->mem_start = mmio_start;
netdev->mem_end = mmio_start + mmio_len; netdev->mem_end = mmio_start + mmio_len;
netdev->base_addr = adapter->hw.io_base; netdev->base_addr = adapter->hw.io_base;
adapter->bd_number = cards_found; adapter->bd_number = cards_found;
...@@ -390,27 +390,25 @@ ixgb_probe(struct pci_dev *pdev, const struct pci_device_id *ent) ...@@ -390,27 +390,25 @@ ixgb_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
ixgb_sw_init(adapter); ixgb_sw_init(adapter);
netdev->features = NETIF_F_SG | netdev->features = NETIF_F_SG |
NETIF_F_HW_CSUM | NETIF_F_HW_CSUM |
NETIF_F_HW_VLAN_TX | NETIF_F_HW_VLAN_TX | NETIF_F_HW_VLAN_RX | NETIF_F_HW_VLAN_FILTER;
NETIF_F_HW_VLAN_RX |
NETIF_F_HW_VLAN_FILTER;
#ifdef NETIF_F_TSO #ifdef NETIF_F_TSO
netdev->features |= NETIF_F_TSO; netdev->features |= NETIF_F_TSO;
#endif #endif
if(pci_using_dac) if (pci_using_dac)
netdev->features |= NETIF_F_HIGHDMA; netdev->features |= NETIF_F_HIGHDMA;
/* make sure the EEPROM is good */ /* make sure the EEPROM is good */
if(!ixgb_validate_eeprom_checksum(&adapter->hw)) { if (!ixgb_validate_eeprom_checksum(&adapter->hw)) {
IXGB_DBG("Invalid EEPROM checksum.\n"); IXGB_DBG("Invalid EEPROM checksum.\n");
goto err_eeprom; goto err_eeprom;
} }
ixgb_get_ee_mac_addr(&adapter->hw, netdev->dev_addr); ixgb_get_ee_mac_addr(&adapter->hw, netdev->dev_addr);
if(!is_valid_ether_addr(netdev->dev_addr)) { if (!is_valid_ether_addr(netdev->dev_addr)) {
IXGB_DBG("Invalid MAC address in EEPROM.\n"); IXGB_DBG("Invalid MAC address in EEPROM.\n");
goto err_eeprom; goto err_eeprom;
} }
...@@ -418,17 +416,16 @@ ixgb_probe(struct pci_dev *pdev, const struct pci_device_id *ent) ...@@ -418,17 +416,16 @@ ixgb_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
adapter->max_data_per_txd = IXGB_MAX_JUMBO_FRAME_SIZE; adapter->max_data_per_txd = IXGB_MAX_JUMBO_FRAME_SIZE;
adapter->part_num = ixgb_get_ee_pba_number(&adapter->hw); adapter->part_num = ixgb_get_ee_pba_number(&adapter->hw);
init_timer(&adapter->watchdog_timer); init_timer(&adapter->watchdog_timer);
adapter->watchdog_timer.function = &ixgb_watchdog; adapter->watchdog_timer.function = &ixgb_watchdog;
adapter->watchdog_timer.data = (unsigned long) adapter; adapter->watchdog_timer.data = (unsigned long) adapter;
INIT_WORK(&adapter->tx_timeout_task, INIT_WORK(&adapter->tx_timeout_task,
(void (*)(void *))ixgb_tx_timeout_task, netdev); (void (*)(void *)) ixgb_tx_timeout_task, netdev);
register_netdev(netdev); register_netdev(netdev);
memcpy(adapter->ifname, netdev->name, IFNAMSIZ); memcpy(adapter->ifname, netdev->name, IFNAMSIZ);
adapter->ifname[IFNAMSIZ-1] = 0; adapter->ifname[IFNAMSIZ - 1] = 0;
/* we're going to reset, so assume we have no link for now */ /* we're going to reset, so assume we have no link for now */
...@@ -437,19 +434,19 @@ ixgb_probe(struct pci_dev *pdev, const struct pci_device_id *ent) ...@@ -437,19 +434,19 @@ ixgb_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
printk(KERN_INFO "%s: %s\n", netdev->name, adapter->id_string); printk(KERN_INFO "%s: %s\n", netdev->name, adapter->id_string);
ixgb_check_options(adapter); ixgb_check_options(adapter);
/* reset the hardware with the new settings */ /* reset the hardware with the new settings */
ixgb_reset(adapter); ixgb_reset(adapter);
cards_found++; cards_found++;
return 0; return 0;
err_eeprom: err_eeprom:
iounmap(adapter->hw.hw_addr); iounmap(adapter->hw.hw_addr);
err_ioremap: err_ioremap:
pci_release_regions(pdev); pci_release_regions(pdev);
kfree(netdev); kfree(netdev);
err_alloc_etherdev: err_alloc_etherdev:
return -ENOMEM; return -ENOMEM;
} }
...@@ -477,7 +474,6 @@ ixgb_remove(struct pci_dev *pdev) ...@@ -477,7 +474,6 @@ ixgb_remove(struct pci_dev *pdev)
ixgb_identify_stop(adapter); ixgb_identify_stop(adapter);
#endif #endif
iounmap((void *) adapter->hw.hw_addr); iounmap((void *) adapter->hw.hw_addr);
pci_release_regions(pdev); pci_release_regions(pdev);
...@@ -508,7 +504,7 @@ ixgb_sw_init(struct ixgb_adapter *adapter) ...@@ -508,7 +504,7 @@ ixgb_sw_init(struct ixgb_adapter *adapter)
pci_read_config_word(pdev, PCI_DEVICE_ID, &hw->device_id); pci_read_config_word(pdev, PCI_DEVICE_ID, &hw->device_id);
pci_read_config_byte(pdev, PCI_REVISION_ID, &hw->revision_id); pci_read_config_byte(pdev, PCI_REVISION_ID, &hw->revision_id);
pci_read_config_word(pdev, PCI_SUBSYSTEM_VENDOR_ID, pci_read_config_word(pdev, PCI_SUBSYSTEM_VENDOR_ID,
&hw->subsystem_vendor_id); &hw->subsystem_vendor_id);
pci_read_config_word(pdev, PCI_SUBSYSTEM_ID, &hw->subsystem_id); pci_read_config_word(pdev, PCI_SUBSYSTEM_ID, &hw->subsystem_id);
pci_read_config_word(pdev, PCI_COMMAND, &hw->pci_cmd_word); pci_read_config_word(pdev, PCI_COMMAND, &hw->pci_cmd_word);
...@@ -516,7 +512,7 @@ ixgb_sw_init(struct ixgb_adapter *adapter) ...@@ -516,7 +512,7 @@ ixgb_sw_init(struct ixgb_adapter *adapter)
hw->max_frame_size = netdev->mtu + ENET_HEADER_SIZE + ENET_FCS_LENGTH; hw->max_frame_size = netdev->mtu + ENET_HEADER_SIZE + ENET_FCS_LENGTH;
if(hw->device_id == IXGB_DEVICE_ID_82597EX) if (hw->device_id == IXGB_DEVICE_ID_82597EX)
hw->mac_type = ixgb_82597; hw->mac_type = ixgb_82597;
else { else {
/* should never have loaded on this device */ /* should never have loaded on this device */
...@@ -551,27 +547,27 @@ ixgb_open(struct net_device *netdev) ...@@ -551,27 +547,27 @@ ixgb_open(struct net_device *netdev)
/* allocate transmit descriptors */ /* allocate transmit descriptors */
if(ixgb_setup_tx_resources(adapter)) { if (ixgb_setup_tx_resources(adapter)) {
IXGB_DBG("ixgb_open: failed ixgb_setup_tx_resources.\n"); IXGB_DBG("ixgb_open: failed ixgb_setup_tx_resources.\n");
goto err_setup_tx; goto err_setup_tx;
} }
/* allocate receive descriptors and buffers */ /* allocate receive descriptors and buffers */
if(ixgb_setup_rx_resources(adapter)) { if (ixgb_setup_rx_resources(adapter)) {
IXGB_DBG("ixgb_open: failed ixgb_setup_rx_resources.\n"); IXGB_DBG("ixgb_open: failed ixgb_setup_rx_resources.\n");
goto err_setup_rx; goto err_setup_rx;
} }
if(ixgb_up(adapter)) if (ixgb_up(adapter))
goto err_up; goto err_up;
return 0; return 0;
err_up: err_up:
ixgb_free_rx_resources(adapter); ixgb_free_rx_resources(adapter);
err_setup_rx: err_setup_rx:
ixgb_free_tx_resources(adapter); ixgb_free_tx_resources(adapter);
err_setup_tx: err_setup_tx:
ixgb_reset(adapter); ixgb_reset(adapter);
return -EBUSY; return -EBUSY;
} }
...@@ -619,19 +615,19 @@ ixgb_setup_tx_resources(struct ixgb_adapter *adapter) ...@@ -619,19 +615,19 @@ ixgb_setup_tx_resources(struct ixgb_adapter *adapter)
IXGB_DBG("ixgb_setup_tx_resources\n"); IXGB_DBG("ixgb_setup_tx_resources\n");
size = sizeof(struct ixgb_buffer) * txdr->count; size = sizeof (struct ixgb_buffer) * txdr->count;
txdr->buffer_info = kmalloc(size, GFP_KERNEL); txdr->buffer_info = kmalloc(size, GFP_KERNEL);
if(!txdr->buffer_info) { if (!txdr->buffer_info) {
return -ENOMEM; return -ENOMEM;
} }
memset(txdr->buffer_info, 0, size); memset(txdr->buffer_info, 0, size);
/* round up to nearest 4K */ /* round up to nearest 4K */
txdr->size = txdr->count * sizeof(struct ixgb_tx_desc); txdr->size = txdr->count * sizeof (struct ixgb_tx_desc);
IXGB_ROUNDUP(txdr->size, 4096); IXGB_ROUNDUP(txdr->size, 4096);
txdr->desc = pci_alloc_consistent(pdev, txdr->size, &txdr->dma); txdr->desc = pci_alloc_consistent(pdev, txdr->size, &txdr->dma);
if(!txdr->desc) { if (!txdr->desc) {
kfree(txdr->buffer_info); kfree(txdr->buffer_info);
return -ENOMEM; return -ENOMEM;
} }
...@@ -658,7 +654,7 @@ static void ...@@ -658,7 +654,7 @@ static void
ixgb_configure_tx(struct ixgb_adapter *adapter) ixgb_configure_tx(struct ixgb_adapter *adapter)
{ {
uint32_t tctl; uint32_t tctl;
uint32_t tdlen = adapter->tx_ring.count * sizeof(struct ixgb_tx_desc); uint32_t tdlen = adapter->tx_ring.count * sizeof (struct ixgb_tx_desc);
uint64_t tdba = adapter->tx_ring.dma; uint64_t tdba = adapter->tx_ring.dma;
struct ixgb_hw *hw = &adapter->hw; struct ixgb_hw *hw = &adapter->hw;
...@@ -680,11 +676,11 @@ ixgb_configure_tx(struct ixgb_adapter *adapter) ...@@ -680,11 +676,11 @@ ixgb_configure_tx(struct ixgb_adapter *adapter)
/* don't set up txdctl, it induces performance problems if /* don't set up txdctl, it induces performance problems if
* configured incorrectly * configured incorrectly
txdctl = TXDCTL_PTHRESH_DEFAULT; // prefetch txds below this threshold txdctl = TXDCTL_PTHRESH_DEFAULT; // prefetch txds below this threshold
txdctl |= (TXDCTL_HTHRESH_DEFAULT // only prefetch if there are this many ready txdctl |= (TXDCTL_HTHRESH_DEFAULT // only prefetch if there are this many ready
<< IXGB_TXDCTL_HTHRESH_SHIFT); << IXGB_TXDCTL_HTHRESH_SHIFT);
IXGB_WRITE_REG (hw, TXDCTL, txdctl); IXGB_WRITE_REG (hw, TXDCTL, txdctl);
*/ */
/* Set the Tx Interrupt Delay register */ /* Set the Tx Interrupt Delay register */
...@@ -697,7 +693,7 @@ ixgb_configure_tx(struct ixgb_adapter *adapter) ...@@ -697,7 +693,7 @@ ixgb_configure_tx(struct ixgb_adapter *adapter)
/* Setup Transmit Descriptor Settings for this adapter */ /* Setup Transmit Descriptor Settings for this adapter */
adapter->tx_cmd_type = adapter->tx_cmd_type =
IXGB_TX_DESC_TYPE | IXGB_TX_DESC_CMD_RS IXGB_TX_DESC_TYPE | IXGB_TX_DESC_CMD_RS
| (adapter->tx_int_delay_enable ? IXGB_TX_DESC_CMD_IDE : 0); | (adapter->tx_int_delay_enable ? IXGB_TX_DESC_CMD_IDE : 0);
} }
...@@ -717,20 +713,20 @@ ixgb_setup_rx_resources(struct ixgb_adapter *adapter) ...@@ -717,20 +713,20 @@ ixgb_setup_rx_resources(struct ixgb_adapter *adapter)
IXGB_DBG("ixgb_setup_rx_resources.\n"); IXGB_DBG("ixgb_setup_rx_resources.\n");
size = sizeof(struct ixgb_buffer) * rxdr->count; size = sizeof (struct ixgb_buffer) * rxdr->count;
rxdr->buffer_info = kmalloc(size, GFP_KERNEL); rxdr->buffer_info = kmalloc(size, GFP_KERNEL);
if(!rxdr->buffer_info) { if (!rxdr->buffer_info) {
return -ENOMEM; return -ENOMEM;
} }
memset(rxdr->buffer_info, 0, size); memset(rxdr->buffer_info, 0, size);
/* Round up to nearest 4K */ /* Round up to nearest 4K */
rxdr->size = rxdr->count * sizeof(struct ixgb_rx_desc); rxdr->size = rxdr->count * sizeof (struct ixgb_rx_desc);
IXGB_ROUNDUP(rxdr->size, 4096); IXGB_ROUNDUP(rxdr->size, 4096);
rxdr->desc = pci_alloc_consistent(pdev, rxdr->size, &rxdr->dma); rxdr->desc = pci_alloc_consistent(pdev, rxdr->size, &rxdr->dma);
if(!rxdr->desc) { if (!rxdr->desc) {
IXGB_DBG("pci_alloc_consistent failed.\n"); IXGB_DBG("pci_alloc_consistent failed.\n");
kfree(rxdr->buffer_info); kfree(rxdr->buffer_info);
return -ENOMEM; return -ENOMEM;
...@@ -764,9 +760,9 @@ ixgb_setup_rctl(struct ixgb_adapter *adapter) ...@@ -764,9 +760,9 @@ ixgb_setup_rctl(struct ixgb_adapter *adapter)
rctl &= ~(3 << IXGB_RCTL_MO_SHIFT); rctl &= ~(3 << IXGB_RCTL_MO_SHIFT);
rctl |= rctl |=
IXGB_RCTL_BAM | IXGB_RCTL_RDMTS_1_2 | IXGB_RCTL_BAM | IXGB_RCTL_RDMTS_1_2 |
IXGB_RCTL_RXEN | IXGB_RCTL_CFF | IXGB_RCTL_RXEN | IXGB_RCTL_CFF |
(adapter->hw.mc_filter_type << IXGB_RCTL_MO_SHIFT); (adapter->hw.mc_filter_type << IXGB_RCTL_MO_SHIFT);
rctl |= IXGB_RCTL_SECRC; rctl |= IXGB_RCTL_SECRC;
...@@ -799,7 +795,7 @@ static void ...@@ -799,7 +795,7 @@ static void
ixgb_configure_rx(struct ixgb_adapter *adapter) ixgb_configure_rx(struct ixgb_adapter *adapter)
{ {
uint64_t rdba = adapter->rx_ring.dma; uint64_t rdba = adapter->rx_ring.dma;
uint32_t rdlen = adapter->rx_ring.count * sizeof(struct ixgb_rx_desc); uint32_t rdlen = adapter->rx_ring.count * sizeof (struct ixgb_rx_desc);
struct ixgb_hw *hw = &adapter->hw; struct ixgb_hw *hw = &adapter->hw;
uint32_t rctl; uint32_t rctl;
uint32_t rxcsum; uint32_t rxcsum;
...@@ -823,18 +819,18 @@ ixgb_configure_rx(struct ixgb_adapter *adapter) ...@@ -823,18 +819,18 @@ ixgb_configure_rx(struct ixgb_adapter *adapter)
IXGB_WRITE_REG(hw, RDH, 0); IXGB_WRITE_REG(hw, RDH, 0);
IXGB_WRITE_REG(hw, RDT, 0); IXGB_WRITE_REG(hw, RDT, 0);
{ {
uint32_t rxdctl; uint32_t rxdctl;
/* burst 16 or burst when RXT0*/ /* burst 16 or burst when RXT0 */
rxdctl = RXDCTL_WTHRESH_DEFAULT << IXGB_RXDCTL_WTHRESH_SHIFT rxdctl = RXDCTL_WTHRESH_DEFAULT << IXGB_RXDCTL_WTHRESH_SHIFT
| RXDCTL_HTHRESH_DEFAULT << IXGB_RXDCTL_HTHRESH_SHIFT | RXDCTL_HTHRESH_DEFAULT << IXGB_RXDCTL_HTHRESH_SHIFT
| RXDCTL_PTHRESH_DEFAULT << IXGB_RXDCTL_PTHRESH_SHIFT; | RXDCTL_PTHRESH_DEFAULT << IXGB_RXDCTL_PTHRESH_SHIFT;
IXGB_WRITE_REG(hw, RXDCTL, rxdctl); IXGB_WRITE_REG(hw, RXDCTL, rxdctl);
} }
if (adapter->raidc) { if (adapter->raidc) {
uint32_t raidc; uint32_t raidc;
uint8_t poll_threshold; uint8_t poll_threshold;
/* Poll every rx_int_delay period, if RBD exists /* Poll every rx_int_delay period, if RBD exists
* Receive Backlog Detection is set to <threshold> * Receive Backlog Detection is set to <threshold>
...@@ -843,35 +839,34 @@ ixgb_configure_rx(struct ixgb_adapter *adapter) ...@@ -843,35 +839,34 @@ ixgb_configure_rx(struct ixgb_adapter *adapter)
* min is 0 */ * min is 0 */
/* polling times are 1 == 0.8192us /* polling times are 1 == 0.8192us
2 == 1.6384us 2 == 1.6384us
3 == 3.2768us etc 3 == 3.2768us etc
... ...
511 == 418 us 511 == 418 us
*/ */
#define IXGB_RAIDC_POLL_DEFAULT 122 /* set to poll every ~100 us under load #define IXGB_RAIDC_POLL_DEFAULT 122 /* set to poll every ~100 us under load
also known as 10000 interrupts / sec */ also known as 10000 interrupts / sec */
/* divide this by 2^3 (8) to get a register size count */ /* divide this by 2^3 (8) to get a register size count */
poll_threshold = ((adapter->rx_ring.count-1) >> 3); poll_threshold = ((adapter->rx_ring.count - 1) >> 3);
/* poll at half of that size */ /* poll at half of that size */
poll_threshold >>= 1; poll_threshold >>= 1;
/* make sure its not bigger than our max */ /* make sure its not bigger than our max */
poll_threshold &= 0x3F; poll_threshold &= 0x3F;
raidc = raidc = IXGB_RAIDC_EN | /* turn on raidc style moderation */
IXGB_RAIDC_EN | /* turn on raidc style moderation */ IXGB_RAIDC_RXT_GATE | /* don't interrupt with rxt0 while
IXGB_RAIDC_RXT_GATE | /* don't interrupt with rxt0 while in RBD mode (polling) */
in RBD mode (polling) */ (IXGB_RAIDC_POLL_DEFAULT << IXGB_RAIDC_POLL_SHIFT) |
(IXGB_RAIDC_POLL_DEFAULT << IXGB_RAIDC_POLL_SHIFT) | /* this sets the regular "min interrupt delay" */
/* this sets the regular "min interrupt delay" */ (adapter->rx_int_delay << IXGB_RAIDC_DELAY_SHIFT) |
(adapter-> rx_int_delay << IXGB_RAIDC_DELAY_SHIFT) |
poll_threshold; poll_threshold;
IXGB_WRITE_REG(hw, RAIDC, raidc); IXGB_WRITE_REG(hw, RAIDC, raidc);
} }
/* Enable Receive Checksum Offload for TCP and UDP */ /* Enable Receive Checksum Offload for TCP and UDP */
if(adapter->rx_csum == TRUE) { if (adapter->rx_csum == TRUE) {
rxcsum = IXGB_READ_REG(hw, RXCSUM); rxcsum = IXGB_READ_REG(hw, RXCSUM);
rxcsum |= IXGB_RXCSUM_TUOFL; rxcsum |= IXGB_RXCSUM_TUOFL;
IXGB_WRITE_REG(hw, RXCSUM, rxcsum); IXGB_WRITE_REG(hw, RXCSUM, rxcsum);
...@@ -902,7 +897,7 @@ ixgb_free_tx_resources(struct ixgb_adapter *adapter) ...@@ -902,7 +897,7 @@ ixgb_free_tx_resources(struct ixgb_adapter *adapter)
adapter->tx_ring.buffer_info = NULL; adapter->tx_ring.buffer_info = NULL;
pci_free_consistent(pdev, adapter->tx_ring.size, adapter->tx_ring.desc, pci_free_consistent(pdev, adapter->tx_ring.size, adapter->tx_ring.desc,
adapter->tx_ring.dma); adapter->tx_ring.dma);
adapter->tx_ring.desc = NULL; adapter->tx_ring.desc = NULL;
} }
...@@ -923,13 +918,13 @@ ixgb_clean_tx_ring(struct ixgb_adapter *adapter) ...@@ -923,13 +918,13 @@ ixgb_clean_tx_ring(struct ixgb_adapter *adapter)
/* Free all the Tx ring sk_buffs */ /* Free all the Tx ring sk_buffs */
for(i = 0; i < adapter->tx_ring.count; i++) { for (i = 0; i < adapter->tx_ring.count; i++) {
if(adapter->tx_ring.buffer_info[i].skb) { if (adapter->tx_ring.buffer_info[i].skb) {
pci_unmap_page(pdev, pci_unmap_page(pdev,
adapter->tx_ring.buffer_info[i].dma, adapter->tx_ring.buffer_info[i].dma,
adapter->tx_ring.buffer_info[i].length, adapter->tx_ring.buffer_info[i].length,
PCI_DMA_TODEVICE); PCI_DMA_TODEVICE);
dev_kfree_skb(adapter->tx_ring.buffer_info[i].skb); dev_kfree_skb(adapter->tx_ring.buffer_info[i].skb);
...@@ -937,7 +932,7 @@ ixgb_clean_tx_ring(struct ixgb_adapter *adapter) ...@@ -937,7 +932,7 @@ ixgb_clean_tx_ring(struct ixgb_adapter *adapter)
} }
} }
size = sizeof(struct ixgb_buffer) * adapter->tx_ring.count; size = sizeof (struct ixgb_buffer) * adapter->tx_ring.count;
memset(adapter->tx_ring.buffer_info, 0, size); memset(adapter->tx_ring.buffer_info, 0, size);
/* Zero out the descriptor ring */ /* Zero out the descriptor ring */
...@@ -971,7 +966,7 @@ ixgb_free_rx_resources(struct ixgb_adapter *adapter) ...@@ -971,7 +966,7 @@ ixgb_free_rx_resources(struct ixgb_adapter *adapter)
adapter->rx_ring.buffer_info = NULL; adapter->rx_ring.buffer_info = NULL;
pci_free_consistent(pdev, adapter->rx_ring.size, pci_free_consistent(pdev, adapter->rx_ring.size,
adapter->rx_ring.desc, adapter->rx_ring.dma); adapter->rx_ring.desc, adapter->rx_ring.dma);
adapter->rx_ring.desc = NULL; adapter->rx_ring.desc = NULL;
} }
...@@ -992,13 +987,13 @@ ixgb_clean_rx_ring(struct ixgb_adapter *adapter) ...@@ -992,13 +987,13 @@ ixgb_clean_rx_ring(struct ixgb_adapter *adapter)
/* Free all the Rx ring sk_buffs */ /* Free all the Rx ring sk_buffs */
for(i = 0; i < adapter->rx_ring.count; i++) { for (i = 0; i < adapter->rx_ring.count; i++) {
if(adapter->rx_ring.buffer_info[i].skb) { if (adapter->rx_ring.buffer_info[i].skb) {
pci_unmap_single(pdev, pci_unmap_single(pdev,
adapter->rx_ring.buffer_info[i].dma, adapter->rx_ring.buffer_info[i].dma,
adapter->rx_ring.buffer_info[i].length, adapter->rx_ring.buffer_info[i].length,
PCI_DMA_FROMDEVICE); PCI_DMA_FROMDEVICE);
dev_kfree_skb(adapter->rx_ring.buffer_info[i].skb); dev_kfree_skb(adapter->rx_ring.buffer_info[i].skb);
...@@ -1006,7 +1001,7 @@ ixgb_clean_rx_ring(struct ixgb_adapter *adapter) ...@@ -1006,7 +1001,7 @@ ixgb_clean_rx_ring(struct ixgb_adapter *adapter)
} }
} }
size = sizeof(struct ixgb_buffer) * adapter->rx_ring.count; size = sizeof (struct ixgb_buffer) * adapter->rx_ring.count;
memset(adapter->rx_ring.buffer_info, 0, size); memset(adapter->rx_ring.buffer_info, 0, size);
/* Zero out the descriptor ring */ /* Zero out the descriptor ring */
...@@ -1045,16 +1040,16 @@ ixgb_set_multi(struct net_device *netdev) ...@@ -1045,16 +1040,16 @@ ixgb_set_multi(struct net_device *netdev)
rctl = IXGB_READ_REG(&adapter->hw, RCTL); rctl = IXGB_READ_REG(&adapter->hw, RCTL);
if(netdev->flags & IFF_PROMISC) { if (netdev->flags & IFF_PROMISC) {
rctl |= (IXGB_RCTL_UPE | IXGB_RCTL_MPE); rctl |= (IXGB_RCTL_UPE | IXGB_RCTL_MPE);
} else if(netdev->flags & IFF_ALLMULTI) { } else if (netdev->flags & IFF_ALLMULTI) {
rctl |= IXGB_RCTL_MPE; rctl |= IXGB_RCTL_MPE;
rctl &= ~IXGB_RCTL_UPE; rctl &= ~IXGB_RCTL_UPE;
} else { } else {
rctl &= ~(IXGB_RCTL_UPE | IXGB_RCTL_MPE); rctl &= ~(IXGB_RCTL_UPE | IXGB_RCTL_MPE);
} }
if(netdev->mc_count > IXGB_MAX_NUM_MULTICAST_ADDRESSES) { if (netdev->mc_count > IXGB_MAX_NUM_MULTICAST_ADDRESSES) {
rctl |= IXGB_RCTL_MPE; rctl |= IXGB_RCTL_MPE;
IXGB_WRITE_REG(hw, RCTL, rctl); IXGB_WRITE_REG(hw, RCTL, rctl);
} else { } else {
...@@ -1062,8 +1057,8 @@ ixgb_set_multi(struct net_device *netdev) ...@@ -1062,8 +1057,8 @@ ixgb_set_multi(struct net_device *netdev)
IXGB_WRITE_REG(hw, RCTL, rctl); IXGB_WRITE_REG(hw, RCTL, rctl);
for(i = 0, mc_ptr = netdev->mc_list; mc_ptr; for (i = 0, mc_ptr = netdev->mc_list; mc_ptr;
i++, mc_ptr = mc_ptr->next) i++, mc_ptr = mc_ptr->next)
memcpy(&mta[i * IXGB_ETH_LENGTH_OF_ADDRESS], memcpy(&mta[i * IXGB_ETH_LENGTH_OF_ADDRESS],
mc_ptr->dmi_addr, IXGB_ETH_LENGTH_OF_ADDRESS); mc_ptr->dmi_addr, IXGB_ETH_LENGTH_OF_ADDRESS);
...@@ -1089,8 +1084,8 @@ ixgb_watchdog(unsigned long data) ...@@ -1089,8 +1084,8 @@ ixgb_watchdog(unsigned long data)
netif_stop_queue(netdev); netif_stop_queue(netdev);
} }
if(adapter->hw.link_up) { if (adapter->hw.link_up) {
if(!netif_carrier_ok(netdev)) { if (!netif_carrier_ok(netdev)) {
printk(KERN_INFO "ixgb: %s NIC Link is Up %d Mbps %s\n", printk(KERN_INFO "ixgb: %s NIC Link is Up %d Mbps %s\n",
netdev->name, 10000, "Full Duplex"); netdev->name, 10000, "Full Duplex");
adapter->link_speed = 10000; adapter->link_speed = 10000;
...@@ -1099,8 +1094,9 @@ ixgb_watchdog(unsigned long data) ...@@ -1099,8 +1094,9 @@ ixgb_watchdog(unsigned long data)
netif_wake_queue(netdev); netif_wake_queue(netdev);
} }
} else { } else {
if(netif_carrier_ok(netdev)) { if (netif_carrier_ok(netdev)) {
printk(KERN_INFO "ixgb: %s NIC Link is Down\n", netdev->name); printk(KERN_INFO "ixgb: %s NIC Link is Down\n",
netdev->name);
adapter->link_speed = 0; adapter->link_speed = 0;
adapter->link_duplex = 0; adapter->link_duplex = 0;
netif_carrier_off(netdev); netif_carrier_off(netdev);
...@@ -1118,17 +1114,19 @@ ixgb_watchdog(unsigned long data) ...@@ -1118,17 +1114,19 @@ ixgb_watchdog(unsigned long data)
struct ixgb_desc_ring *txdr = &adapter->tx_ring; struct ixgb_desc_ring *txdr = &adapter->tx_ring;
int i = txdr->next_to_clean; int i = txdr->next_to_clean;
if(txdr->buffer_info[i].dma && if (txdr->buffer_info[i].dma &&
time_after(jiffies, txdr->buffer_info[i].time_stamp + HZ) && time_after(jiffies, txdr->buffer_info[i].time_stamp + HZ) &&
!(IXGB_READ_REG(&adapter->hw, STATUS) & IXGB_STATUS_TXOFF)) { !(IXGB_READ_REG(&adapter->hw, STATUS) & IXGB_STATUS_TXOFF))
IXGB_DBG("ixgb: %s Hung controller? Watchdog stopping queue\n", {
netdev->name); IXGB_DBG
("ixgb: %s Hung controller? Watchdog stopping queue\n",
netdev->name);
netif_stop_queue(netdev); netif_stop_queue(netdev);
} }
} }
/* generate an interrupt to force clean up of any stragglers */ /* generate an interrupt to force clean up of any stragglers */
IXGB_WRITE_REG (&adapter->hw, ICS, IXGB_INT_TXDW); IXGB_WRITE_REG(&adapter->hw, ICS, IXGB_INT_TXDW);
/* Reset the timer */ /* Reset the timer */
mod_timer(&adapter->watchdog_timer, jiffies + 2 * HZ); mod_timer(&adapter->watchdog_timer, jiffies + 2 * HZ);
...@@ -1152,44 +1150,47 @@ ixgb_tso(struct ixgb_adapter *adapter, struct sk_buff *skb) ...@@ -1152,44 +1150,47 @@ ixgb_tso(struct ixgb_adapter *adapter, struct sk_buff *skb)
int i; int i;
uint8_t ipcss, ipcso, tucss, tucso, hdr_len; uint8_t ipcss, ipcso, tucss, tucso, hdr_len;
uint16_t ipcse, tucse, mss; uint16_t ipcse, tucse, mss;
if(likely(skb_shinfo(skb)->tso_size)) { if (likely(skb_shinfo(skb)->tso_size)) {
hdr_len = ((skb->h.raw - skb->data) + (skb->h.th->doff << 2)); hdr_len = ((skb->h.raw - skb->data) + (skb->h.th->doff << 2));
mss = skb_shinfo(skb)->tso_size; mss = skb_shinfo(skb)->tso_size;
skb->nh.iph->tot_len = 0; skb->nh.iph->tot_len = 0;
skb->nh.iph->check = 0; skb->nh.iph->check = 0;
skb->h.th->check = ~csum_tcpudp_magic(skb->nh.iph->saddr, skb->h.th->check = ~csum_tcpudp_magic(skb->nh.iph->saddr,
skb->nh.iph->daddr, skb->nh.iph->daddr,
0, 0, IPPROTO_TCP, 0);
IPPROTO_TCP,
0);
ipcss = skb->nh.raw - skb->data; ipcss = skb->nh.raw - skb->data;
ipcso = (void *)&(skb->nh.iph->check) - (void *)skb->data; ipcso = (void *) &(skb->nh.iph->check) - (void *) skb->data;
ipcse = skb->h.raw - skb->data - 1; ipcse = skb->h.raw - skb->data - 1;
tucss = skb->h.raw - skb->data; tucss = skb->h.raw - skb->data;
tucso = (void *)&(skb->h.th->check) - (void *)skb->data; tucso = (void *) &(skb->h.th->check) - (void *) skb->data;
tucse = 0; tucse = 0;
i = adapter->tx_ring.next_to_use; i = adapter->tx_ring.next_to_use;
context_desc = IXGB_CONTEXT_DESC(adapter->tx_ring, i); context_desc = IXGB_CONTEXT_DESC(adapter->tx_ring, i);
context_desc->ipcss = ipcss; context_desc->ipcss = ipcss;
context_desc->ipcso = ipcso; context_desc->ipcso = ipcso;
context_desc->ipcse = cpu_to_le16(ipcse); context_desc->ipcse = cpu_to_le16(ipcse);
context_desc->tucss = tucss; context_desc->tucss = tucss;
context_desc->tucso = tucso; context_desc->tucso = tucso;
context_desc->tucse = cpu_to_le16(tucse); context_desc->tucse = cpu_to_le16(tucse);
context_desc->mss = cpu_to_le16(mss); context_desc->mss = cpu_to_le16(mss);
context_desc->hdr_len= hdr_len; context_desc->hdr_len = hdr_len;
context_desc->status = 0; context_desc->status = 0;
context_desc->cmd_type_len = cpu_to_le32( context_desc->cmd_type_len = cpu_to_le32(IXGB_CONTEXT_DESC_TYPE
IXGB_CONTEXT_DESC_TYPE |
| IXGB_CONTEXT_DESC_CMD_TSE IXGB_CONTEXT_DESC_CMD_TSE
| IXGB_CONTEXT_DESC_CMD_IP |
| IXGB_CONTEXT_DESC_CMD_TCP IXGB_CONTEXT_DESC_CMD_IP
| IXGB_CONTEXT_DESC_CMD_RS |
| IXGB_CONTEXT_DESC_CMD_IDE IXGB_CONTEXT_DESC_CMD_TCP
| (skb->len - (hdr_len))); |
IXGB_CONTEXT_DESC_CMD_RS
|
IXGB_CONTEXT_DESC_CMD_IDE
| (skb->len -
(hdr_len)));
i = (i + 1) % adapter->tx_ring.count; i = (i + 1) % adapter->tx_ring.count;
adapter->tx_ring.next_to_use = i; adapter->tx_ring.next_to_use = i;
...@@ -1200,7 +1201,6 @@ ixgb_tso(struct ixgb_adapter *adapter, struct sk_buff *skb) ...@@ -1200,7 +1201,6 @@ ixgb_tso(struct ixgb_adapter *adapter, struct sk_buff *skb)
return FALSE; return FALSE;
} }
/** /**
* ixgb_tx_csum - prepare context descriptor for checksum offload. * ixgb_tx_csum - prepare context descriptor for checksum offload.
* *
...@@ -1215,7 +1215,7 @@ ixgb_tx_csum(struct ixgb_adapter *adapter, struct sk_buff *skb) ...@@ -1215,7 +1215,7 @@ ixgb_tx_csum(struct ixgb_adapter *adapter, struct sk_buff *skb)
int i; int i;
uint8_t css, cso; uint8_t css, cso;
if(likely(skb->ip_summed == CHECKSUM_HW)) { if (likely(skb->ip_summed == CHECKSUM_HW)) {
css = skb->h.raw - skb->data; css = skb->h.raw - skb->data;
cso = (skb->h.raw + skb->csum) - skb->data; cso = (skb->h.raw + skb->csum) - skb->data;
i = adapter->tx_ring.next_to_use; i = adapter->tx_ring.next_to_use;
...@@ -1225,14 +1225,13 @@ ixgb_tx_csum(struct ixgb_adapter *adapter, struct sk_buff *skb) ...@@ -1225,14 +1225,13 @@ ixgb_tx_csum(struct ixgb_adapter *adapter, struct sk_buff *skb)
context_desc->tucso = cso; context_desc->tucso = cso;
context_desc->tucse = 0; context_desc->tucse = 0;
/* zero out any previously existing data in one instruction */ /* zero out any previously existing data in one instruction */
*(uint32_t *)&(context_desc->ipcss) = 0; *(uint32_t *) & (context_desc->ipcss) = 0;
context_desc->status = 0; context_desc->status = 0;
context_desc->hdr_len = 0; context_desc->hdr_len = 0;
context_desc->mss = 0; context_desc->mss = 0;
context_desc->cmd_type_len = context_desc->cmd_type_len =
cpu_to_le32(IXGB_CONTEXT_DESC_TYPE cpu_to_le32(IXGB_CONTEXT_DESC_TYPE
| IXGB_TX_DESC_CMD_RS | IXGB_TX_DESC_CMD_RS | IXGB_TX_DESC_CMD_IDE);
| IXGB_TX_DESC_CMD_IDE);
i = (i + 1) % adapter->tx_ring.count; i = (i + 1) % adapter->tx_ring.count;
adapter->tx_ring.next_to_use = i; adapter->tx_ring.next_to_use = i;
...@@ -1264,13 +1263,13 @@ ixgb_tx_map(struct ixgb_adapter *adapter, struct sk_buff *skb) ...@@ -1264,13 +1263,13 @@ ixgb_tx_map(struct ixgb_adapter *adapter, struct sk_buff *skb)
offset = 0; offset = 0;
while(len) { while (len) {
i = (i + 1) % tx_ring->count; i = (i + 1) % tx_ring->count;
size = min(len, adapter->max_data_per_txd); size = min(len, adapter->max_data_per_txd);
tx_ring->buffer_info[i].length = size; tx_ring->buffer_info[i].length = size;
tx_ring->buffer_info[i].dma = tx_ring->buffer_info[i].dma =
pci_map_single(adapter->pdev, skb->data + offset, size, pci_map_single(adapter->pdev, skb->data + offset, size,
PCI_DMA_TODEVICE); PCI_DMA_TODEVICE);
tx_ring->buffer_info[i].time_stamp = jiffies; tx_ring->buffer_info[i].time_stamp = jiffies;
...@@ -1279,21 +1278,21 @@ ixgb_tx_map(struct ixgb_adapter *adapter, struct sk_buff *skb) ...@@ -1279,21 +1278,21 @@ ixgb_tx_map(struct ixgb_adapter *adapter, struct sk_buff *skb)
count++; count++;
} }
for(f = 0; f < skb_shinfo(skb)->nr_frags; f++) { for (f = 0; f < skb_shinfo(skb)->nr_frags; f++) {
struct skb_frag_struct *frag; struct skb_frag_struct *frag;
frag = &skb_shinfo(skb)->frags[f]; frag = &skb_shinfo(skb)->frags[f];
len = frag->size; len = frag->size;
offset = 0; offset = 0;
while(len) { while (len) {
i = (i + 1) % tx_ring->count; i = (i + 1) % tx_ring->count;
size = min(len, adapter->max_data_per_txd); size = min(len, adapter->max_data_per_txd);
tx_ring->buffer_info[i].length = size; tx_ring->buffer_info[i].length = size;
tx_ring->buffer_info[i].dma = tx_ring->buffer_info[i].dma =
pci_map_page(adapter->pdev, frag->page, pci_map_page(adapter->pdev, frag->page,
frag->page_offset + offset, size, frag->page_offset + offset, size,
PCI_DMA_TODEVICE); PCI_DMA_TODEVICE);
tx_ring->buffer_info[i].time_stamp = jiffies; tx_ring->buffer_info[i].time_stamp = jiffies;
len -= size; len -= size;
...@@ -1316,7 +1315,8 @@ ixgb_tx_map(struct ixgb_adapter *adapter, struct sk_buff *skb) ...@@ -1316,7 +1315,8 @@ ixgb_tx_map(struct ixgb_adapter *adapter, struct sk_buff *skb)
**/ **/
static inline void static inline void
ixgb_tx_queue(struct ixgb_adapter *adapter, int count, int vlan_id,int tx_flags) ixgb_tx_queue(struct ixgb_adapter *adapter, int count, int vlan_id,
int tx_flags)
{ {
struct ixgb_desc_ring *tx_ring = &adapter->tx_ring; struct ixgb_desc_ring *tx_ring = &adapter->tx_ring;
struct ixgb_tx_desc *tx_desc = NULL; struct ixgb_tx_desc *tx_desc = NULL;
...@@ -1325,21 +1325,21 @@ ixgb_tx_queue(struct ixgb_adapter *adapter, int count, int vlan_id,int tx_flags) ...@@ -1325,21 +1325,21 @@ ixgb_tx_queue(struct ixgb_adapter *adapter, int count, int vlan_id,int tx_flags)
uint8_t popts = 0; uint8_t popts = 0;
int i; int i;
if(tx_flags & IXGB_TX_FLAGS_TSO) { if (tx_flags & IXGB_TX_FLAGS_TSO) {
cmd_type_len |= IXGB_TX_DESC_CMD_TSE; cmd_type_len |= IXGB_TX_DESC_CMD_TSE;
popts |= (IXGB_TX_DESC_POPTS_IXSM | IXGB_TX_DESC_POPTS_TXSM); popts |= (IXGB_TX_DESC_POPTS_IXSM | IXGB_TX_DESC_POPTS_TXSM);
} }
if(tx_flags & IXGB_TX_FLAGS_CSUM) if (tx_flags & IXGB_TX_FLAGS_CSUM)
popts |= IXGB_TX_DESC_POPTS_TXSM; popts |= IXGB_TX_DESC_POPTS_TXSM;
if(tx_flags & IXGB_TX_FLAGS_VLAN) { if (tx_flags & IXGB_TX_FLAGS_VLAN) {
cmd_type_len |= IXGB_TX_DESC_CMD_VLE; cmd_type_len |= IXGB_TX_DESC_CMD_VLE;
} }
i = tx_ring->next_to_use; i = tx_ring->next_to_use;
while(count--) { while (count--) {
tx_desc = IXGB_TX_DESC(*tx_ring, i); tx_desc = IXGB_TX_DESC(*tx_ring, i);
tx_desc->buff_addr = cpu_to_le64(tx_ring->buffer_info[i].dma); tx_desc->buff_addr = cpu_to_le64(tx_ring->buffer_info[i].dma);
tx_desc->cmd_type_len = tx_desc->cmd_type_len =
...@@ -1384,35 +1384,35 @@ ixgb_xmit_frame(struct sk_buff *skb, struct net_device *netdev) ...@@ -1384,35 +1384,35 @@ ixgb_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
count = count =
TXD_USE_COUNT(skb->len - skb->data_len, adapter->max_data_per_txd); TXD_USE_COUNT(skb->len - skb->data_len, adapter->max_data_per_txd);
if(count == 0) { if (count == 0) {
dev_kfree_skb_any(skb); dev_kfree_skb_any(skb);
return 0; return 0;
} }
for(f = 0; f < skb_shinfo(skb)->nr_frags; f++) for (f = 0; f < skb_shinfo(skb)->nr_frags; f++)
count += TXD_USE_COUNT(skb_shinfo(skb)->frags[f].size, count += TXD_USE_COUNT(skb_shinfo(skb)->frags[f].size,
adapter->max_data_per_txd); adapter->max_data_per_txd);
#ifdef NETIF_F_TSO #ifdef NETIF_F_TSO
if((skb_shinfo(skb)->tso_size) || (skb->ip_summed == CHECKSUM_HW)) if ((skb_shinfo(skb)->tso_size) || (skb->ip_summed == CHECKSUM_HW))
count++; count++;
#else #else
if(skb->ip_summed == CHECKSUM_HW) if (skb->ip_summed == CHECKSUM_HW)
count++; count++;
#endif #endif
if(unlikely(IXGB_DESC_UNUSED(&adapter->tx_ring) < count)) { if (unlikely(IXGB_DESC_UNUSED(&adapter->tx_ring) < count)) {
netif_stop_queue(netdev); netif_stop_queue(netdev);
return 1; return 1;
} }
if(adapter->vlgrp && vlan_tx_tag_present(skb)) { if (adapter->vlgrp && vlan_tx_tag_present(skb)) {
tx_flags |= IXGB_TX_FLAGS_VLAN; tx_flags |= IXGB_TX_FLAGS_VLAN;
vlan_id = vlan_tx_tag_get(skb); vlan_id = vlan_tx_tag_get(skb);
} }
if(ixgb_tso(adapter, skb)) if (ixgb_tso(adapter, skb))
tx_flags |= IXGB_TX_FLAGS_TSO; tx_flags |= IXGB_TX_FLAGS_TSO;
else if(ixgb_tx_csum(adapter, skb)) else if (ixgb_tx_csum(adapter, skb))
tx_flags |= IXGB_TX_FLAGS_CSUM; tx_flags |= IXGB_TX_FLAGS_CSUM;
count = ixgb_tx_map(adapter, skb); count = ixgb_tx_map(adapter, skb);
...@@ -1491,44 +1491,45 @@ ixgb_change_mtu(struct net_device *netdev, int new_mtu) ...@@ -1491,44 +1491,45 @@ ixgb_change_mtu(struct net_device *netdev, int new_mtu)
IXGB_DBG("ixgb_change_mtu\n"); IXGB_DBG("ixgb_change_mtu\n");
if((max_frame < IXGB_MIN_ENET_FRAME_SIZE_WITHOUT_FCS + ENET_FCS_LENGTH) if ((max_frame < IXGB_MIN_ENET_FRAME_SIZE_WITHOUT_FCS + ENET_FCS_LENGTH)
|| (max_frame > IXGB_MAX_JUMBO_FRAME_SIZE + ENET_FCS_LENGTH)) { || (max_frame > IXGB_MAX_JUMBO_FRAME_SIZE + ENET_FCS_LENGTH)) {
IXGB_ERR("Invalid MTU setting\n"); IXGB_ERR("Invalid MTU setting\n");
return -EINVAL; return -EINVAL;
} }
if((max_frame <= IXGB_MAX_ENET_FRAME_SIZE_WITHOUT_FCS + ENET_FCS_LENGTH) if ((max_frame <=
|| (max_frame <= IXGB_RXBUFFER_2048)) { IXGB_MAX_ENET_FRAME_SIZE_WITHOUT_FCS + ENET_FCS_LENGTH)
|| (max_frame <= IXGB_RXBUFFER_2048)) {
adapter->rx_buffer_len = IXGB_RXBUFFER_2048; adapter->rx_buffer_len = IXGB_RXBUFFER_2048;
} else if(max_frame <= IXGB_RXBUFFER_4096) { } else if (max_frame <= IXGB_RXBUFFER_4096) {
adapter->rx_buffer_len = IXGB_RXBUFFER_4096; adapter->rx_buffer_len = IXGB_RXBUFFER_4096;
} else if(max_frame <= IXGB_RXBUFFER_8192) { } else if (max_frame <= IXGB_RXBUFFER_8192) {
adapter->rx_buffer_len = IXGB_RXBUFFER_8192; adapter->rx_buffer_len = IXGB_RXBUFFER_8192;
} else { } else {
adapter->rx_buffer_len = IXGB_RXBUFFER_16384; adapter->rx_buffer_len = IXGB_RXBUFFER_16384;
} }
if(old_mtu != adapter->rx_buffer_len && netif_running(netdev)) { if (old_mtu != adapter->rx_buffer_len && netif_running(netdev)) {
ixgb_down(adapter, TRUE); ixgb_down(adapter, TRUE);
ixgb_up(adapter); ixgb_up(adapter);
} }
if(adapter->hw.max_frame_size != max_frame) { if (adapter->hw.max_frame_size != max_frame) {
struct ixgb_hw *hw = &adapter->hw; struct ixgb_hw *hw = &adapter->hw;
adapter->hw.max_frame_size = max_frame; adapter->hw.max_frame_size = max_frame;
IXGB_WRITE_REG(hw, MFS, hw->max_frame_size << IXGB_MFS_SHIFT); IXGB_WRITE_REG(hw, MFS, hw->max_frame_size << IXGB_MFS_SHIFT);
if(hw->max_frame_size > if (hw->max_frame_size >
IXGB_MAX_ENET_FRAME_SIZE_WITHOUT_FCS + ENET_FCS_LENGTH) { IXGB_MAX_ENET_FRAME_SIZE_WITHOUT_FCS + ENET_FCS_LENGTH) {
uint32_t ctrl0 = IXGB_READ_REG(hw, CTRL0); uint32_t ctrl0 = IXGB_READ_REG(hw, CTRL0);
if(!(ctrl0 & IXGB_CTRL0_JFE)) { if (!(ctrl0 & IXGB_CTRL0_JFE)) {
ctrl0 |= IXGB_CTRL0_JFE; ctrl0 |= IXGB_CTRL0_JFE;
IXGB_WRITE_REG(hw, CTRL0, ctrl0); IXGB_WRITE_REG(hw, CTRL0, ctrl0);
} }
...@@ -1648,8 +1649,10 @@ ixgb_update_stats(struct ixgb_adapter *adapter) ...@@ -1648,8 +1649,10 @@ ixgb_update_stats(struct ixgb_adapter *adapter)
/* ignore RLEC as it reports errors for padded (<64bytes) frames /* ignore RLEC as it reports errors for padded (<64bytes) frames
* with a length in the type/len field */ * with a length in the type/len field */
adapter->net_stats.rx_errors = adapter->net_stats.rx_errors =
/* adapter->stats.rnbc + */ adapter->stats.crcerrs + adapter->stats.ruc + /* adapter->stats.rnbc + */ adapter->stats.crcerrs +
adapter->stats.roc /*+ adapter->stats.rlec*/ + adapter->stats.icbc + adapter->stats.ruc +
adapter->stats.roc /*+ adapter->stats.rlec */ +
adapter->stats.icbc +
adapter->stats.ecbc + adapter->stats.mpc; adapter->stats.ecbc + adapter->stats.mpc;
adapter->net_stats.rx_dropped = adapter->stats.mpc; adapter->net_stats.rx_dropped = adapter->stats.mpc;
...@@ -1697,10 +1700,10 @@ ixgb_irq_enable(struct ixgb_adapter *adapter) ...@@ -1697,10 +1700,10 @@ ixgb_irq_enable(struct ixgb_adapter *adapter)
{ {
IXGB_DBG("ixgb_irq_enable\n"); IXGB_DBG("ixgb_irq_enable\n");
if(atomic_dec_and_test(&adapter->irq_sem)) { if (atomic_dec_and_test(&adapter->irq_sem)) {
IXGB_WRITE_REG(&adapter->hw, IMS, IXGB_WRITE_REG(&adapter->hw, IMS,
IXGB_INT_RXT0 | IXGB_INT_RXDMT0 | IXGB_INT_TXDW | IXGB_INT_RXT0 | IXGB_INT_RXDMT0 | IXGB_INT_TXDW |
IXGB_INT_RXO | IXGB_INT_LSC); IXGB_INT_RXO | IXGB_INT_LSC);
} }
} }
...@@ -1728,11 +1731,11 @@ ixgb_intr(int irq, void *data, struct pt_regs *regs) ...@@ -1728,11 +1731,11 @@ ixgb_intr(int irq, void *data, struct pt_regs *regs)
uint i = IXGB_MAX_INTR; uint i = IXGB_MAX_INTR;
boolean_t rxdmt0 = FALSE; boolean_t rxdmt0 = FALSE;
while(i && (icr = IXGB_READ_REG(hw, ICR))) { while (i && (icr = IXGB_READ_REG(hw, ICR))) {
if(icr & IXGB_INT_RXDMT0) if (icr & IXGB_INT_RXDMT0)
rxdmt0 = TRUE; rxdmt0 = TRUE;
if(unlikely(icr & (IXGB_INT_RXSEQ | IXGB_INT_LSC))) { if (unlikely(icr & (IXGB_INT_RXSEQ | IXGB_INT_LSC))) {
mod_timer(&adapter->watchdog_timer, jiffies); mod_timer(&adapter->watchdog_timer, jiffies);
} }
...@@ -1746,13 +1749,13 @@ ixgb_intr(int irq, void *data, struct pt_regs *regs) ...@@ -1746,13 +1749,13 @@ ixgb_intr(int irq, void *data, struct pt_regs *regs)
/* if RAIDC:EN == 1 and ICR:RXDMT0 == 1, we need to /* if RAIDC:EN == 1 and ICR:RXDMT0 == 1, we need to
* set IMS:RXDMT0 to 1 to restart the RBD timer (POLL) * set IMS:RXDMT0 to 1 to restart the RBD timer (POLL)
*/ */
if(rxdmt0 && adapter->raidc) { if (rxdmt0 && adapter->raidc) {
/* ready the timer by writing the clear reg */ /* ready the timer by writing the clear reg */
IXGB_WRITE_REG(hw, IMC, IXGB_INT_RXDMT0); IXGB_WRITE_REG(hw, IMC, IXGB_INT_RXDMT0);
/* now restart it, h/w will decide if its necessary */ /* now restart it, h/w will decide if its necessary */
IXGB_WRITE_REG(hw, IMS, IXGB_INT_RXDMT0); IXGB_WRITE_REG(hw, IMS, IXGB_INT_RXDMT0);
} }
#endif // NAPI else #endif // NAPI else
} }
#ifdef CONFIG_IXGB_NAPI #ifdef CONFIG_IXGB_NAPI
...@@ -1764,17 +1767,17 @@ ixgb_process_intr(struct net_device *netdev) ...@@ -1764,17 +1767,17 @@ ixgb_process_intr(struct net_device *netdev)
int i = IXGB_MAX_INTR; int i = IXGB_MAX_INTR;
int hasReceived = 0; int hasReceived = 0;
while(i && (icr = IXGB_READ_REG(&adapter->hw, ICR))) { while (i && (icr = IXGB_READ_REG(&adapter->hw, ICR))) {
if (icr & IXGB_INT_RXT0) if (icr & IXGB_INT_RXT0)
hasReceived = 1; hasReceived = 1;
if (!(icr & ~(IXGB_INT_RXT0))) if (!(icr & ~(IXGB_INT_RXT0)))
break; break;
if (icr & (IXGB_INT_RXSEQ | IXGB_INT_LSC)) { if (icr & (IXGB_INT_RXSEQ | IXGB_INT_LSC)) {
mod_timer(&adapter->watchdog_timer, jiffies); mod_timer(&adapter->watchdog_timer, jiffies);
} }
ixgb_clean_tx_irq(adapter); ixgb_clean_tx_irq(adapter);
i--; i--;
} }
...@@ -1796,24 +1799,24 @@ ixgb_clean_tx_irq(struct ixgb_adapter *adapter) ...@@ -1796,24 +1799,24 @@ ixgb_clean_tx_irq(struct ixgb_adapter *adapter)
struct pci_dev *pdev = adapter->pdev; struct pci_dev *pdev = adapter->pdev;
int i = adapter->tx_ring.next_to_clean; int i = adapter->tx_ring.next_to_clean;
struct ixgb_tx_desc *tx_desc = IXGB_TX_DESC(*tx_ring, i); struct ixgb_tx_desc *tx_desc = IXGB_TX_DESC(*tx_ring, i);
while((tx_desc->status & IXGB_TX_DESC_STATUS_DD)) { while ((tx_desc->status & IXGB_TX_DESC_STATUS_DD)) {
if (tx_desc->popts if (tx_desc->popts
& (IXGB_TX_DESC_POPTS_TXSM | IXGB_TX_DESC_POPTS_IXSM)) & (IXGB_TX_DESC_POPTS_TXSM | IXGB_TX_DESC_POPTS_IXSM))
adapter->hw_csum_tx_good++; adapter->hw_csum_tx_good++;
if(tx_ring->buffer_info[i].dma) { if (tx_ring->buffer_info[i].dma) {
pci_unmap_page(pdev, tx_ring->buffer_info[i].dma, pci_unmap_page(pdev, tx_ring->buffer_info[i].dma,
tx_ring->buffer_info[i].length, tx_ring->buffer_info[i].length,
PCI_DMA_TODEVICE); PCI_DMA_TODEVICE);
tx_ring->buffer_info[i].dma = 0; tx_ring->buffer_info[i].dma = 0;
} }
if(tx_ring->buffer_info[i].skb) { if (tx_ring->buffer_info[i].skb) {
dev_kfree_skb_any(tx_ring->buffer_info[i].skb); dev_kfree_skb_any(tx_ring->buffer_info[i].skb);
tx_ring->buffer_info[i].skb = NULL; tx_ring->buffer_info[i].skb = NULL;
} }
*(uint32_t *)&(tx_desc->status) = 0; *(uint32_t *) & (tx_desc->status) = 0;
i = (i + 1) % tx_ring->count; i = (i + 1) % tx_ring->count;
tx_desc = IXGB_TX_DESC(*tx_ring, i); tx_desc = IXGB_TX_DESC(*tx_ring, i);
...@@ -1821,8 +1824,8 @@ ixgb_clean_tx_irq(struct ixgb_adapter *adapter) ...@@ -1821,8 +1824,8 @@ ixgb_clean_tx_irq(struct ixgb_adapter *adapter)
tx_ring->next_to_clean = i; tx_ring->next_to_clean = i;
if(netif_queue_stopped(netdev) && netif_carrier_ok(netdev) && if (netif_queue_stopped(netdev) && netif_carrier_ok(netdev) &&
(IXGB_DESC_UNUSED(tx_ring) > IXGB_TX_QUEUE_WAKE)) { (IXGB_DESC_UNUSED(tx_ring) > IXGB_TX_QUEUE_WAKE)) {
netif_wake_queue(netdev); netif_wake_queue(netdev);
} }
...@@ -1842,7 +1845,7 @@ ixgb_poll(struct net_device *netdev, int *budget) ...@@ -1842,7 +1845,7 @@ ixgb_poll(struct net_device *netdev, int *budget)
int received = 0; int received = 0;
int rx_work_limit = *budget; int rx_work_limit = *budget;
if(rx_work_limit > netdev->quota) if (rx_work_limit > netdev->quota)
rx_work_limit = netdev->quota; rx_work_limit = netdev->quota;
ixgb_process_intr(netdev); ixgb_process_intr(netdev);
...@@ -1850,19 +1853,19 @@ ixgb_poll(struct net_device *netdev, int *budget) ...@@ -1850,19 +1853,19 @@ ixgb_poll(struct net_device *netdev, int *budget)
i = rx_ring->next_to_clean; i = rx_ring->next_to_clean;
rx_desc = IXGB_RX_DESC(*rx_ring, i); rx_desc = IXGB_RX_DESC(*rx_ring, i);
while((rx_desc->status & IXGB_RX_DESC_STATUS_DD)) { while ((rx_desc->status & IXGB_RX_DESC_STATUS_DD)) {
if(--rx_work_limit < 0) if (--rx_work_limit < 0)
goto not_done; goto not_done;
pci_unmap_single(pdev, pci_unmap_single(pdev,
rx_ring->buffer_info[i].dma, rx_ring->buffer_info[i].dma,
rx_ring->buffer_info[i].length, rx_ring->buffer_info[i].length,
PCI_DMA_FROMDEVICE); PCI_DMA_FROMDEVICE);
skb = rx_ring->buffer_info[i].skb; skb = rx_ring->buffer_info[i].skb;
length = le16_to_cpu(rx_desc->length); length = le16_to_cpu(rx_desc->length);
if(!(rx_desc->status & IXGB_RX_DESC_STATUS_EOP)) { if (!(rx_desc->status & IXGB_RX_DESC_STATUS_EOP)) {
/* All receives must fit into a single buffer */ /* All receives must fit into a single buffer */
...@@ -1878,12 +1881,13 @@ ixgb_poll(struct net_device *netdev, int *budget) ...@@ -1878,12 +1881,13 @@ ixgb_poll(struct net_device *netdev, int *budget)
continue; continue;
} }
if(rx_desc-> if (rx_desc->
errors & (IXGB_RX_DESC_ERRORS_CE | IXGB_RX_DESC_ERRORS_SE | errors & (IXGB_RX_DESC_ERRORS_CE | IXGB_RX_DESC_ERRORS_SE |
IXGB_RX_DESC_ERRORS_P | IXGB_RX_DESC_ERRORS_RXE)) { IXGB_RX_DESC_ERRORS_P | IXGB_RX_DESC_ERRORS_RXE))
{
IXGB_DBG("Receive Errors Reported by Hardware-%x.\n", IXGB_DBG("Receive Errors Reported by Hardware-%x.\n",
rx_desc->errors); rx_desc->errors);
dev_kfree_skb_irq(skb); dev_kfree_skb_irq(skb);
rx_desc->status = 0; rx_desc->status = 0;
...@@ -1900,9 +1904,12 @@ ixgb_poll(struct net_device *netdev, int *budget) ...@@ -1900,9 +1904,12 @@ ixgb_poll(struct net_device *netdev, int *budget)
ixgb_rx_checksum(adapter, rx_desc, skb); ixgb_rx_checksum(adapter, rx_desc, skb);
skb->protocol = eth_type_trans(skb, netdev); skb->protocol = eth_type_trans(skb, netdev);
if(adapter->vlgrp && (rx_desc->status & IXGB_RX_DESC_STATUS_VP)) { if (adapter->vlgrp
&& (rx_desc->status & IXGB_RX_DESC_STATUS_VP)) {
vlan_hwaccel_rx(skb, adapter->vlgrp, vlan_hwaccel_rx(skb, adapter->vlgrp,
(rx_desc->special & IXGB_RX_DESC_SPECIAL_VLAN_MASK)); (rx_desc->
special &
IXGB_RX_DESC_SPECIAL_VLAN_MASK));
} else { } else {
netif_receive_skb(skb); netif_receive_skb(skb);
} }
...@@ -1917,11 +1924,11 @@ ixgb_poll(struct net_device *netdev, int *budget) ...@@ -1917,11 +1924,11 @@ ixgb_poll(struct net_device *netdev, int *budget)
received++; received++;
} }
if(!received) if (!received)
received = 1; received = 1;
ixgb_alloc_rx_buffers(adapter); ixgb_alloc_rx_buffers(adapter);
rx_ring->next_to_clean = i; rx_ring->next_to_clean = i;
netdev->quota -= received; netdev->quota -= received;
*budget -= received; *budget -= received;
...@@ -1932,10 +1939,10 @@ ixgb_poll(struct net_device *netdev, int *budget) ...@@ -1932,10 +1939,10 @@ ixgb_poll(struct net_device *netdev, int *budget)
ixgb_irq_enable(adapter); ixgb_irq_enable(adapter);
return 0; return 0;
not_done: not_done:
ixgb_alloc_rx_buffers(adapter); ixgb_alloc_rx_buffers(adapter);
rx_ring->next_to_clean = i; rx_ring->next_to_clean = i;
netdev->quota -= received; netdev->quota -= received;
*budget -= received; *budget -= received;
...@@ -1959,24 +1966,23 @@ ixgb_clean_rx_irq(struct ixgb_adapter *adapter) ...@@ -1959,24 +1966,23 @@ ixgb_clean_rx_irq(struct ixgb_adapter *adapter)
uint32_t length; uint32_t length;
int i; int i;
i = rx_ring->next_to_clean; i = rx_ring->next_to_clean;
rx_desc = IXGB_RX_DESC(*rx_ring, i); rx_desc = IXGB_RX_DESC(*rx_ring, i);
while((rx_desc->status & IXGB_RX_DESC_STATUS_DD)) { while ((rx_desc->status & IXGB_RX_DESC_STATUS_DD)) {
pci_unmap_single(pdev, rx_ring->buffer_info[i].dma, pci_unmap_single(pdev, rx_ring->buffer_info[i].dma,
rx_ring->buffer_info[i].length, rx_ring->buffer_info[i].length,
PCI_DMA_FROMDEVICE); PCI_DMA_FROMDEVICE);
skb = rx_ring->buffer_info[i].skb; skb = rx_ring->buffer_info[i].skb;
length = le16_to_cpu(rx_desc->length); length = le16_to_cpu(rx_desc->length);
if(unlikely(!(rx_desc->status & IXGB_RX_DESC_STATUS_EOP))) { if (unlikely(!(rx_desc->status & IXGB_RX_DESC_STATUS_EOP))) {
/* All receives must fit into a single buffer */ /* All receives must fit into a single buffer */
IXGB_DBG("Receive packet consumed multiple buffers " IXGB_DBG("Receive packet consumed multiple buffers "
"length<%x>\n", length); "length<%x>\n", length);
dev_kfree_skb_irq(skb); dev_kfree_skb_irq(skb);
rx_desc->status = 0; rx_desc->status = 0;
...@@ -1986,12 +1992,13 @@ ixgb_clean_rx_irq(struct ixgb_adapter *adapter) ...@@ -1986,12 +1992,13 @@ ixgb_clean_rx_irq(struct ixgb_adapter *adapter)
continue; continue;
} }
if(unlikely(rx_desc->errors if (unlikely(rx_desc->errors
& (IXGB_RX_DESC_ERRORS_CE | IXGB_RX_DESC_ERRORS_SE | & (IXGB_RX_DESC_ERRORS_CE | IXGB_RX_DESC_ERRORS_SE
IXGB_RX_DESC_ERRORS_P | IXGB_RX_DESC_ERRORS_RXE))) { | IXGB_RX_DESC_ERRORS_P |
IXGB_RX_DESC_ERRORS_RXE))) {
IXGB_DBG("Receive Errors Reported by Hardware-%x.\n", IXGB_DBG("Receive Errors Reported by Hardware-%x.\n",
rx_desc->errors); rx_desc->errors);
dev_kfree_skb_irq(skb); dev_kfree_skb_irq(skb);
rx_desc->status = 0; rx_desc->status = 0;
...@@ -2002,15 +2009,18 @@ ixgb_clean_rx_irq(struct ixgb_adapter *adapter) ...@@ -2002,15 +2009,18 @@ ixgb_clean_rx_irq(struct ixgb_adapter *adapter)
} }
/* Good Receive */ /* Good Receive */
skb_put(skb, length); skb_put(skb, length);
/* Receive Checksum Offload */ /* Receive Checksum Offload */
ixgb_rx_checksum(adapter, rx_desc, skb); ixgb_rx_checksum(adapter, rx_desc, skb);
skb->protocol = eth_type_trans(skb, netdev); skb->protocol = eth_type_trans(skb, netdev);
if(adapter->vlgrp && (rx_desc->status & IXGB_RX_DESC_STATUS_VP)) { if (adapter->vlgrp
&& (rx_desc->status & IXGB_RX_DESC_STATUS_VP)) {
vlan_hwaccel_rx(skb, adapter->vlgrp, vlan_hwaccel_rx(skb, adapter->vlgrp,
(rx_desc->special & IXGB_RX_DESC_SPECIAL_VLAN_MASK)); (rx_desc->
special &
IXGB_RX_DESC_SPECIAL_VLAN_MASK));
} else { } else {
netif_rx(skb); netif_rx(skb);
} }
...@@ -2023,8 +2033,7 @@ ixgb_clean_rx_irq(struct ixgb_adapter *adapter) ...@@ -2023,8 +2033,7 @@ ixgb_clean_rx_irq(struct ixgb_adapter *adapter)
i = (i + 1) % rx_ring->count; i = (i + 1) % rx_ring->count;
rx_desc = IXGB_RX_DESC(*rx_ring, i); rx_desc = IXGB_RX_DESC(*rx_ring, i);
} /* while */ } /* while */
rx_ring->next_to_clean = i; rx_ring->next_to_clean = i;
...@@ -2053,23 +2062,22 @@ ixgb_alloc_rx_buffers(struct ixgb_adapter *adapter) ...@@ -2053,23 +2062,22 @@ ixgb_alloc_rx_buffers(struct ixgb_adapter *adapter)
reserve_len = 2; reserve_len = 2;
i = rx_ring->next_to_use; i = rx_ring->next_to_use;
cleancount = IXGB_DESC_UNUSED (rx_ring); cleancount = IXGB_DESC_UNUSED(rx_ring);
/* lessen this to 4 if we're /* lessen this to 4 if we're
* in the midst of raidc and rbd is occuring * in the midst of raidc and rbd is occuring
* because we don't want to delay returning buffers when low * because we don't want to delay returning buffers when low
*/ */
num_group_tail_writes num_group_tail_writes = adapter->raidc ? 4 : IXGB_RX_BUFFER_WRITE;
= adapter->raidc ? 4 : IXGB_RX_BUFFER_WRITE;
/* leave one descriptor unused */ /* leave one descriptor unused */
while(--cleancount > 0) { while (--cleancount > 0) {
rx_desc = IXGB_RX_DESC(*rx_ring, i); rx_desc = IXGB_RX_DESC(*rx_ring, i);
/* allocate a new one */ /* allocate a new one */
skb = dev_alloc_skb(adapter->rx_buffer_len + reserve_len); skb = dev_alloc_skb(adapter->rx_buffer_len + reserve_len);
if(unlikely(!skb)) { if (unlikely(!skb)) {
/* better luck next time around */ /* better luck next time around */
IXGB_DBG("Could not allocate SKB\n"); IXGB_DBG("Could not allocate SKB\n");
break; break;
...@@ -2085,12 +2093,12 @@ ixgb_alloc_rx_buffers(struct ixgb_adapter *adapter) ...@@ -2085,12 +2093,12 @@ ixgb_alloc_rx_buffers(struct ixgb_adapter *adapter)
rx_ring->buffer_info[i].skb = skb; rx_ring->buffer_info[i].skb = skb;
rx_ring->buffer_info[i].length = adapter->rx_buffer_len; rx_ring->buffer_info[i].length = adapter->rx_buffer_len;
rx_ring->buffer_info[i].dma = rx_ring->buffer_info[i].dma =
pci_map_single(pdev, skb->data, adapter->rx_buffer_len, pci_map_single(pdev, skb->data, adapter->rx_buffer_len,
PCI_DMA_FROMDEVICE); PCI_DMA_FROMDEVICE);
rx_desc->buff_addr = cpu_to_le64(rx_ring->buffer_info[i].dma); rx_desc->buff_addr = cpu_to_le64(rx_ring->buffer_info[i].dma);
if(!(i % num_group_tail_writes)) { if (!(i % num_group_tail_writes)) {
/* Force memory writes to complete before letting h/w /* Force memory writes to complete before letting h/w
* know there are new descriptors to fetch. (Only * know there are new descriptors to fetch. (Only
* applicable for weak-ordered memory model archs, * applicable for weak-ordered memory model archs,
...@@ -2143,7 +2151,7 @@ ixgb_vlan_rx_register(struct net_device *netdev, struct vlan_group *grp) ...@@ -2143,7 +2151,7 @@ ixgb_vlan_rx_register(struct net_device *netdev, struct vlan_group *grp)
ixgb_irq_disable(adapter); ixgb_irq_disable(adapter);
adapter->vlgrp = grp; adapter->vlgrp = grp;
if(grp) { if (grp) {
/* enable VLAN tag insert/strip */ /* enable VLAN tag insert/strip */
ctrl = IXGB_READ_REG(&adapter->hw, CTRL0); ctrl = IXGB_READ_REG(&adapter->hw, CTRL0);
ctrl |= IXGB_CTRL0_VME; ctrl |= IXGB_CTRL0_VME;
...@@ -2203,12 +2211,12 @@ ixgb_vlan_rx_kill_vid(struct net_device *netdev, uint16_t vid) ...@@ -2203,12 +2211,12 @@ ixgb_vlan_rx_kill_vid(struct net_device *netdev, uint16_t vid)
ixgb_irq_disable(adapter); ixgb_irq_disable(adapter);
if(adapter->vlgrp) if (adapter->vlgrp)
adapter->vlgrp->vlan_devices[vid] = NULL; adapter->vlgrp->vlan_devices[vid] = NULL;
ixgb_irq_enable(adapter); ixgb_irq_enable(adapter);
/* remove VID from filter table*/ /* remove VID from filter table */
index = (vid >> 5) & 0x7F; index = (vid >> 5) & 0x7F;
vfta = IXGB_READ_REG_ARRAY(&adapter->hw, VFTA, index); vfta = IXGB_READ_REG_ARRAY(&adapter->hw, VFTA, index);
...@@ -2225,10 +2233,10 @@ ixgb_restore_vlan(struct ixgb_adapter *adapter) ...@@ -2225,10 +2233,10 @@ ixgb_restore_vlan(struct ixgb_adapter *adapter)
{ {
ixgb_vlan_rx_register(adapter->netdev, adapter->vlgrp); ixgb_vlan_rx_register(adapter->netdev, adapter->vlgrp);
if(adapter->vlgrp) { if (adapter->vlgrp) {
uint16_t vid; uint16_t vid;
for(vid = 0; vid < VLAN_GROUP_ARRAY_LEN; vid++) { for (vid = 0; vid < VLAN_GROUP_ARRAY_LEN; vid++) {
if(!adapter->vlgrp->vlan_devices[vid]) if (!adapter->vlgrp->vlan_devices[vid])
continue; continue;
ixgb_vlan_rx_add_vid(adapter->netdev, vid); ixgb_vlan_rx_add_vid(adapter->netdev, vid);
} }
...@@ -2244,14 +2252,13 @@ ixgb_restore_vlan(struct ixgb_adapter *adapter) ...@@ -2244,14 +2252,13 @@ ixgb_restore_vlan(struct ixgb_adapter *adapter)
static inline void static inline void
ixgb_rx_checksum(struct ixgb_adapter *adapter, ixgb_rx_checksum(struct ixgb_adapter *adapter,
struct ixgb_rx_desc *rx_desc, struct ixgb_rx_desc *rx_desc, struct sk_buff *skb)
struct sk_buff *skb)
{ {
/* Ignore Checksum bit is set OR /* Ignore Checksum bit is set OR
* TCP Checksum has not been calculated * TCP Checksum has not been calculated
*/ */
if((rx_desc->status & IXGB_RX_DESC_STATUS_IXSM) || if ((rx_desc->status & IXGB_RX_DESC_STATUS_IXSM) ||
(!(rx_desc->status & IXGB_RX_DESC_STATUS_TCPCS))) { (!(rx_desc->status & IXGB_RX_DESC_STATUS_TCPCS))) {
skb->ip_summed = CHECKSUM_NONE; skb->ip_summed = CHECKSUM_NONE;
return; return;
} }
...@@ -2259,7 +2266,7 @@ ixgb_rx_checksum(struct ixgb_adapter *adapter, ...@@ -2259,7 +2266,7 @@ ixgb_rx_checksum(struct ixgb_adapter *adapter,
/* At this point we know the hardware did the TCP checksum /* At this point we know the hardware did the TCP checksum
* now look at the TCP checksum error bit * now look at the TCP checksum error bit
*/ */
if(rx_desc->errors & IXGB_RX_DESC_ERRORS_TCPE) { if (rx_desc->errors & IXGB_RX_DESC_ERRORS_TCPE) {
/* let the stack verify checksum errors */ /* let the stack verify checksum errors */
skb->ip_summed = CHECKSUM_NONE; skb->ip_summed = CHECKSUM_NONE;
adapter->hw_csum_rx_error++; adapter->hw_csum_rx_error++;
...@@ -2278,7 +2285,7 @@ ixgb_rx_checksum(struct ixgb_adapter *adapter, ...@@ -2278,7 +2285,7 @@ ixgb_rx_checksum(struct ixgb_adapter *adapter,
**/ **/
void void
ixgb_write_pci_cfg(struct ixgb_hw *hw, uint32_t reg, uint16_t *value) ixgb_write_pci_cfg(struct ixgb_hw *hw, uint32_t reg, uint16_t * value)
{ {
struct ixgb_adapter *adapter = (struct ixgb_adapter *) hw->back; struct ixgb_adapter *adapter = (struct ixgb_adapter *) hw->back;
...@@ -2296,19 +2303,18 @@ ixgb_notify_reboot(struct notifier_block *nb, unsigned long event, void *p) ...@@ -2296,19 +2303,18 @@ ixgb_notify_reboot(struct notifier_block *nb, unsigned long event, void *p)
{ {
struct pci_dev *pdev = NULL; struct pci_dev *pdev = NULL;
switch(event) { switch (event) {
case SYS_DOWN: case SYS_DOWN:
case SYS_HALT: case SYS_HALT:
case SYS_POWER_OFF: case SYS_POWER_OFF:
pci_for_each_dev(pdev) { pci_for_each_dev(pdev) {
if(pci_dev_driver(pdev) == &ixgb_driver) if (pci_dev_driver(pdev) == &ixgb_driver)
ixgb_suspend(pdev, 3); ixgb_suspend(pdev, 3);
} }
} }
return NOTIFY_DONE; return NOTIFY_DONE;
} }
/** /**
* ixgb_suspend - driver suspend function called from notify. * ixgb_suspend - driver suspend function called from notify.
* @param pdev pci driver structure used for passing to * @param pdev pci driver structure used for passing to
...@@ -2322,7 +2328,7 @@ ixgb_suspend(struct pci_dev *pdev, uint32_t state) ...@@ -2322,7 +2328,7 @@ ixgb_suspend(struct pci_dev *pdev, uint32_t state)
netif_device_detach(netdev); netif_device_detach(netdev);
if(netif_running(netdev)) if (netif_running(netdev))
ixgb_down(adapter, TRUE); ixgb_down(adapter, TRUE);
pci_save_state(pdev, adapter->pci_state); pci_save_state(pdev, adapter->pci_state);
...@@ -2334,5 +2340,4 @@ ixgb_suspend(struct pci_dev *pdev, uint32_t state) ...@@ -2334,5 +2340,4 @@ ixgb_suspend(struct pci_dev *pdev, uint32_t state)
return 0; return 0;
} }
/* ixgb_main.c */ /* ixgb_main.c */
drivers/net/ixgb/ixgb_osdep.h
View file @ ca247341
...@@ -25,7 +25,6 @@ ...@@ -25,7 +25,6 @@
Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497 Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
*******************************************************************************/ *******************************************************************************/
/* glue for the OS independant part of ixgb /* glue for the OS independant part of ixgb
* includes register access macros * includes register access macros
*/ */
...@@ -52,8 +51,8 @@ ...@@ -52,8 +51,8 @@
#define CMD_MEM_WRT_INVALIDATE PCI_COMMAND_INVALIDATE #define CMD_MEM_WRT_INVALIDATE PCI_COMMAND_INVALIDATE
typedef enum { typedef enum {
FALSE = 0, FALSE = 0,
TRUE = 1 TRUE = 1
} boolean_t; } boolean_t;
#define MSGOUT(S, A, B) printk(KERN_DEBUG S "\n", A, B) #define MSGOUT(S, A, B) printk(KERN_DEBUG S "\n", A, B)
...@@ -87,4 +86,4 @@ typedef enum { ...@@ -87,4 +86,4 @@ typedef enum {
#define IXGB_MEMCPY memcpy #define IXGB_MEMCPY memcpy
#endif /* IXGB_OSDEP_H */ #endif /* IXGB_OSDEP_H */
drivers/net/ixgb/ixgb_param.c
View file @ ca247341
...@@ -132,7 +132,6 @@ IXGB_PARAM(RxIntDelay, "Receive Interrupt Delay"); ...@@ -132,7 +132,6 @@ IXGB_PARAM(RxIntDelay, "Receive Interrupt Delay");
IXGB_PARAM(RAIDC, "Disable or enable Receive Interrupt Moderation"); IXGB_PARAM(RAIDC, "Disable or enable Receive Interrupt Moderation");
/* Receive Flow control high threshold (when we send a pause frame) /* Receive Flow control high threshold (when we send a pause frame)
* (FCRTH) * (FCRTH)
* *
...@@ -143,7 +142,6 @@ IXGB_PARAM(RAIDC, "Disable or enable Receive Interrupt Moderation"); ...@@ -143,7 +142,6 @@ IXGB_PARAM(RAIDC, "Disable or enable Receive Interrupt Moderation");
IXGB_PARAM(RxFCHighThresh, "Receive Flow Control High Threshold"); IXGB_PARAM(RxFCHighThresh, "Receive Flow Control High Threshold");
/* Receive Flow control low threshold (when we send a resume frame) /* Receive Flow control low threshold (when we send a resume frame)
* (FCRTL) * (FCRTL)
* *
...@@ -155,7 +153,6 @@ IXGB_PARAM(RxFCHighThresh, "Receive Flow Control High Threshold"); ...@@ -155,7 +153,6 @@ IXGB_PARAM(RxFCHighThresh, "Receive Flow Control High Threshold");
IXGB_PARAM(RxFCLowThresh, "Receive Flow Control Low Threshold"); IXGB_PARAM(RxFCLowThresh, "Receive Flow Control Low Threshold");
/* Flow control request timeout (how long to pause the link partner's tx) /* Flow control request timeout (how long to pause the link partner's tx)
* (PAP 15:0) * (PAP 15:0)
* *
...@@ -166,7 +163,6 @@ IXGB_PARAM(RxFCLowThresh, "Receive Flow Control Low Threshold"); ...@@ -166,7 +163,6 @@ IXGB_PARAM(RxFCLowThresh, "Receive Flow Control Low Threshold");
IXGB_PARAM(FCReqTimeout, "Flow Control Request Timeout"); IXGB_PARAM(FCReqTimeout, "Flow Control Request Timeout");
/* Transmit Interrupt Delay in units of 0.8192 microseconds /* Transmit Interrupt Delay in units of 0.8192 microseconds
* *
* Valid Range: 0-65535 * Valid Range: 0-65535
...@@ -213,7 +209,6 @@ IXGB_PARAM(IntDelayEnable, "Transmit Interrupt Delay Enable"); ...@@ -213,7 +209,6 @@ IXGB_PARAM(IntDelayEnable, "Transmit Interrupt Delay Enable");
#define MIN_FCPAUSE 1 #define MIN_FCPAUSE 1
#define MAX_FCPAUSE 0xffff #define MAX_FCPAUSE 0xffff
struct ixgb_option { struct ixgb_option {
enum { enable_option, range_option, list_option } type; enum { enable_option, range_option, list_option } type;
char *name; char *name;
...@@ -235,10 +230,9 @@ struct ixgb_option { ...@@ -235,10 +230,9 @@ struct ixgb_option {
}; };
static int __devinit static int __devinit
ixgb_validate_option(int *value, ixgb_validate_option(int *value, struct ixgb_option *opt)
struct ixgb_option *opt)
{ {
if(*value == OPTION_UNSET) { if (*value == OPTION_UNSET) {
*value = opt->def; *value = opt->def;
return 0; return 0;
} }
...@@ -255,7 +249,7 @@ ixgb_validate_option(int *value, ...@@ -255,7 +249,7 @@ ixgb_validate_option(int *value,
} }
break; break;
case range_option: case range_option:
if(*value >= opt->arg.r.min && *value <= opt->arg.r.max) { if (*value >= opt->arg.r.min && *value <= opt->arg.r.max) {
printk(KERN_INFO "%s set to %i\n", opt->name, *value); printk(KERN_INFO "%s set to %i\n", opt->name, *value);
return 0; return 0;
} }
...@@ -265,10 +259,10 @@ ixgb_validate_option(int *value, ...@@ -265,10 +259,10 @@ ixgb_validate_option(int *value,
int i; int i;
struct ixgb_opt_list *ent; struct ixgb_opt_list *ent;
for(i = 0; i < opt->arg.l.nr; i++) { for (i = 0; i < opt->arg.l.nr; i++) {
ent = &opt->arg.l.p[i]; ent = &opt->arg.l.p[i];
if(*value == ent->i) { if (*value == ent->i) {
if(ent->str[0] != '\0') if (ent->str[0] != '\0')
printk(KERN_INFO "%s", printk(KERN_INFO "%s",
ent->str); ent->str);
return 0; return 0;
...@@ -305,8 +299,9 @@ ixgb_check_options(struct ixgb_adapter *adapter) ...@@ -305,8 +299,9 @@ ixgb_check_options(struct ixgb_adapter *adapter)
IXGB_DBG("ixgb_check_options\n"); IXGB_DBG("ixgb_check_options\n");
if(board >= IXGB_MAX_NIC) { if (board >= IXGB_MAX_NIC) {
printk(KERN_NOTICE "Warning: no configuration for board #%i\n", board); printk(KERN_NOTICE "Warning: no configuration for board #%i\n",
board);
printk(KERN_NOTICE "Using defaults for all values\n"); printk(KERN_NOTICE "Using defaults for all values\n");
board = IXGB_MAX_NIC; board = IXGB_MAX_NIC;
} }
...@@ -317,7 +312,7 @@ ixgb_check_options(struct ixgb_adapter *adapter) ...@@ -317,7 +312,7 @@ ixgb_check_options(struct ixgb_adapter *adapter)
.name = "Transmit Descriptors", .name = "Transmit Descriptors",
.err = "using default of " __MODULE_STRING(DEFAULT_TXD), .err = "using default of " __MODULE_STRING(DEFAULT_TXD),
.def = DEFAULT_TXD, .def = DEFAULT_TXD,
.arg = {.r = {.min = MIN_TXD, .max = MAX_TXD}} .arg = {.r = {.min = MIN_TXD,.max = MAX_TXD}}
}; };
struct ixgb_desc_ring *tx_ring = &adapter->tx_ring; struct ixgb_desc_ring *tx_ring = &adapter->tx_ring;
...@@ -332,7 +327,7 @@ ixgb_check_options(struct ixgb_adapter *adapter) ...@@ -332,7 +327,7 @@ ixgb_check_options(struct ixgb_adapter *adapter)
.name = "Receive Descriptors", .name = "Receive Descriptors",
.err = "using default of " __MODULE_STRING(DEFAULT_RXD), .err = "using default of " __MODULE_STRING(DEFAULT_RXD),
.def = DEFAULT_RXD, .def = DEFAULT_RXD,
.arg = {.r = {.min = MIN_RXD, .max = MAX_RXD}} .arg = {.r = {.min = MIN_RXD,.max = MAX_RXD}}
}; };
struct ixgb_desc_ring *rx_ring = &adapter->rx_ring; struct ixgb_desc_ring *rx_ring = &adapter->rx_ring;
...@@ -368,7 +363,7 @@ ixgb_check_options(struct ixgb_adapter *adapter) ...@@ -368,7 +363,7 @@ ixgb_check_options(struct ixgb_adapter *adapter)
} }
{ /* Flow Control */ { /* Flow Control */
struct ixgb_opt_list fc_list[] = { struct ixgb_opt_list fc_list[] = {
{ixgb_fc_none, "Flow Control Disabled\n"}, {ixgb_fc_none, "Flow Control Disabled\n"},
{ixgb_fc_rx_pause, "Flow Control Receive Only\n"}, {ixgb_fc_rx_pause, "Flow Control Receive Only\n"},
{ixgb_fc_tx_pause, "Flow Control Transmit Only\n"}, {ixgb_fc_tx_pause, "Flow Control Transmit Only\n"},
...@@ -381,59 +376,63 @@ ixgb_check_options(struct ixgb_adapter *adapter) ...@@ -381,59 +376,63 @@ ixgb_check_options(struct ixgb_adapter *adapter)
.name = "Flow Control", .name = "Flow Control",
.err = "reading default settings from EEPROM", .err = "reading default settings from EEPROM",
.def = ixgb_fc_full, .def = ixgb_fc_full,
.arg = {.l = {.nr = LIST_LEN(fc_list), .p = fc_list}} .arg = {.l = {.nr = LIST_LEN(fc_list),.p = fc_list}}
}; };
int fc = FlowControl[board]; int fc = FlowControl[board];
ixgb_validate_option(&fc, &opt); ixgb_validate_option(&fc, &opt);
adapter->hw.fc.type = fc; adapter->hw.fc.type = fc;
} }
{ /* Receive Flow Control High Threshold */ { /* Receive Flow Control High Threshold */
struct ixgb_option fcrth = { struct ixgb_option fcrth = {
.type = range_option, .type = range_option,
.name = "Rx Flow Control High Threshold", .name = "Rx Flow Control High Threshold",
.err = "using default of " __MODULE_STRING(DEFAULT_FCRTH), .err =
"using default of " __MODULE_STRING(DEFAULT_FCRTH),
.def = DEFAULT_FCRTH, .def = DEFAULT_FCRTH,
.arg = {.r = {.min = MIN_FCRTH, .max = MAX_FCRTH}} .arg = {.r = {.min = MIN_FCRTH,.max = MAX_FCRTH}}
}; };
adapter->hw.fc.high_water = RxFCHighThresh[board]; adapter->hw.fc.high_water = RxFCHighThresh[board];
ixgb_validate_option(&adapter->hw.fc.high_water, &fcrth); ixgb_validate_option(&adapter->hw.fc.high_water, &fcrth);
if ( !(adapter->hw.fc.type & ixgb_fc_rx_pause) ) if (!(adapter->hw.fc.type & ixgb_fc_rx_pause))
printk (KERN_INFO printk(KERN_INFO
"Ignoring RxFCHighThresh when no RxFC\n"); "Ignoring RxFCHighThresh when no RxFC\n");
} }
{ /* Receive Flow Control Low Threshold */ { /* Receive Flow Control Low Threshold */
struct ixgb_option fcrtl = { struct ixgb_option fcrtl = {
.type = range_option, .type = range_option,
.name = "Rx Flow Control Low Threshold", .name = "Rx Flow Control Low Threshold",
.err = "using default of " __MODULE_STRING(DEFAULT_FCRTL), .err =
"using default of " __MODULE_STRING(DEFAULT_FCRTL),
.def = DEFAULT_FCRTL, .def = DEFAULT_FCRTL,
.arg = {.r = {.min = MIN_FCRTL, .max = MAX_FCRTL}} .arg = {.r = {.min = MIN_FCRTL,.max = MAX_FCRTL}}
}; };
adapter->hw.fc.low_water = RxFCLowThresh[board]; adapter->hw.fc.low_water = RxFCLowThresh[board];
ixgb_validate_option(&adapter->hw.fc.low_water, &fcrtl); ixgb_validate_option(&adapter->hw.fc.low_water, &fcrtl);
if ( !(adapter->hw.fc.type & ixgb_fc_rx_pause) ) if (!(adapter->hw.fc.type & ixgb_fc_rx_pause))
printk (KERN_INFO printk(KERN_INFO
"Ignoring RxFCLowThresh when no RxFC\n"); "Ignoring RxFCLowThresh when no RxFC\n");
} }
{ /* Flow Control Pause Time Request*/ { /* Flow Control Pause Time Request */
struct ixgb_option fcpap = { struct ixgb_option fcpap = {
.type = range_option, .type = range_option,
.name = "Flow Control Pause Time Request", .name = "Flow Control Pause Time Request",
.err = "using default of "__MODULE_STRING(DEFAULT_FCPAUSE), .err =
"using default of "
__MODULE_STRING(DEFAULT_FCPAUSE),
.def = DEFAULT_FCPAUSE, .def = DEFAULT_FCPAUSE,
.arg = {.r = {.min = MIN_FCPAUSE, .max = MAX_FCPAUSE}} .arg = {.r = {.min = MIN_FCPAUSE,.max = MAX_FCPAUSE}}
}; };
int pause_time = FCReqTimeout[board]; int pause_time = FCReqTimeout[board];
ixgb_validate_option(&pause_time, &fcpap); ixgb_validate_option(&pause_time, &fcpap);
if ( !(adapter->hw.fc.type & ixgb_fc_rx_pause) ) if (!(adapter->hw.fc.type & ixgb_fc_rx_pause))
printk (KERN_INFO printk(KERN_INFO
"Ignoring FCReqTimeout when no RxFC\n"); "Ignoring FCReqTimeout when no RxFC\n");
adapter->hw.fc.pause_time = pause_time; adapter->hw.fc.pause_time = pause_time;
} }
/* high low and spacing check for rx flow control thresholds */ /* high low and spacing check for rx flow control thresholds */
...@@ -441,20 +440,21 @@ ixgb_check_options(struct ixgb_adapter *adapter) ...@@ -441,20 +440,21 @@ ixgb_check_options(struct ixgb_adapter *adapter)
/* high must be greater than low */ /* high must be greater than low */
if (adapter->hw.fc.high_water < (adapter->hw.fc.low_water + 8)) { if (adapter->hw.fc.high_water < (adapter->hw.fc.low_water + 8)) {
/* set defaults */ /* set defaults */
printk (KERN_INFO printk(KERN_INFO
"RxFCHighThresh must be >= (RxFCLowThresh + 8), " "RxFCHighThresh must be >= (RxFCLowThresh + 8), "
"Using Defaults\n"); "Using Defaults\n");
adapter->hw.fc.high_water = DEFAULT_FCRTH; adapter->hw.fc.high_water = DEFAULT_FCRTH;
adapter->hw.fc.low_water = DEFAULT_FCRTL; adapter->hw.fc.low_water = DEFAULT_FCRTL;
} }
} }
{ /* Receive Interrupt Delay */ { /* Receive Interrupt Delay */
struct ixgb_option opt = { struct ixgb_option opt = {
.type = range_option, .type = range_option,
.name = "Receive Interrupt Delay", .name = "Receive Interrupt Delay",
.err = "using default of " __MODULE_STRING(DEFAULT_RDTR), .err =
"using default of " __MODULE_STRING(DEFAULT_RDTR),
.def = DEFAULT_RDTR, .def = DEFAULT_RDTR,
.arg = {.r = {.min = MIN_RDTR, .max = MAX_RDTR}} .arg = {.r = {.min = MIN_RDTR,.max = MAX_RDTR}}
}; };
adapter->rx_int_delay = RxIntDelay[board]; adapter->rx_int_delay = RxIntDelay[board];
...@@ -473,20 +473,21 @@ ixgb_check_options(struct ixgb_adapter *adapter) ...@@ -473,20 +473,21 @@ ixgb_check_options(struct ixgb_adapter *adapter)
adapter->raidc = raidc; adapter->raidc = raidc;
} }
{ /* Transmit Interrupt Delay */ { /* Transmit Interrupt Delay */
struct ixgb_option opt = { struct ixgb_option opt = {
.type = range_option, .type = range_option,
.name = "Transmit Interrupt Delay", .name = "Transmit Interrupt Delay",
.err = "using default of " __MODULE_STRING(DEFAULT_TIDV), .err =
"using default of " __MODULE_STRING(DEFAULT_TIDV),
.def = DEFAULT_TIDV, .def = DEFAULT_TIDV,
.arg = {.r = {.min = MIN_TIDV, .max = MAX_TIDV}} .arg = {.r = {.min = MIN_TIDV,.max = MAX_TIDV}}
}; };
adapter->tx_int_delay = TxIntDelay[board]; adapter->tx_int_delay = TxIntDelay[board];
ixgb_validate_option(&adapter->tx_int_delay, &opt); ixgb_validate_option(&adapter->tx_int_delay, &opt);
} }
{ /* Transmit Interrupt Delay Enable */ { /* Transmit Interrupt Delay Enable */
struct ixgb_option opt = { struct ixgb_option opt = {
.type = enable_option, .type = enable_option,
.name = "Tx Interrupt Delay Enable", .name = "Tx Interrupt Delay Enable",
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7