dect
/
linux-2.6
Archived
13
0
Fork 0
Code Releases Activity

e1000e: pass pointer to ring struct instead of adapter struct 

For ring-specific functions, pass a pointer to the ring struct instead of a
pointer to the adapter struct.

Signed-off-by: Bruce Allan <bruce.w.allan@intel.com>
Tested-by: Aaron Brown <aaron.f.brown@intel.com>
Signed-off-by: Jeff Kirsher <jeffrey.t.kirsher@intel.com>
This commit is contained in:
Bruce Allan 2011-12-16 00:45:45 +00:00 committed by Jeff Kirsher
parent c5083cf6d2
commit 55aa69854a
3 changed files with 136 additions and 127 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
drivers/net/ethernet/intel/e1000e/e1000.h
View File

@ -234,6 +234,7 @@ struct e1000_buffer {
}; };
struct e1000_ring { struct e1000_ring {
struct e1000_adapter *adapter; /* back pointer to adapter */
void *desc; /* pointer to ring memory */ void *desc; /* pointer to ring memory */
dma_addr_t dma; /* phys address of ring */ dma_addr_t dma; /* phys address of ring */
unsigned int size; /* length of ring in bytes */ unsigned int size; /* length of ring in bytes */
@ -334,11 +335,10 @@ struct e1000_adapter {
/* /*
* Rx * Rx
*/ */
bool (*clean_rx) (struct e1000_adapter *adapter, bool (*clean_rx) (struct e1000_ring *ring, int *work_done,
int *work_done, int work_to_do) int work_to_do) ____cacheline_aligned_in_smp;
____cacheline_aligned_in_smp; void (*alloc_rx_buf) (struct e1000_ring *ring, int cleaned_count,
void (*alloc_rx_buf) (struct e1000_adapter *adapter, gfp_t gfp);
int cleaned_count, gfp_t gfp);
struct e1000_ring *rx_ring; struct e1000_ring *rx_ring;
u32 rx_int_delay; u32 rx_int_delay;
@ -398,6 +398,9 @@ struct e1000_adapter {
bool idle_check; bool idle_check;
int phy_hang_count; int phy_hang_count;
u16 tx_ring_count;
u16 rx_ring_count;
}; };
struct e1000_info { struct e1000_info {
@ -492,10 +495,10 @@ extern void e1000e_down(struct e1000_adapter *adapter);
extern void e1000e_reinit_locked(struct e1000_adapter *adapter); extern void e1000e_reinit_locked(struct e1000_adapter *adapter);
extern void e1000e_reset(struct e1000_adapter *adapter); extern void e1000e_reset(struct e1000_adapter *adapter);
extern void e1000e_power_up_phy(struct e1000_adapter *adapter); extern void e1000e_power_up_phy(struct e1000_adapter *adapter);
extern int e1000e_setup_rx_resources(struct e1000_adapter *adapter); extern int e1000e_setup_rx_resources(struct e1000_ring *ring);
extern int e1000e_setup_tx_resources(struct e1000_adapter *adapter); extern int e1000e_setup_tx_resources(struct e1000_ring *ring);
extern void e1000e_free_rx_resources(struct e1000_adapter *adapter); extern void e1000e_free_rx_resources(struct e1000_ring *ring);
extern void e1000e_free_tx_resources(struct e1000_adapter *adapter); extern void e1000e_free_tx_resources(struct e1000_ring *ring);
extern struct rtnl_link_stats64 *e1000e_get_stats64(struct net_device *netdev, extern struct rtnl_link_stats64 *e1000e_get_stats64(struct net_device *netdev,
struct rtnl_link_stats64 struct rtnl_link_stats64
*stats); *stats);

10
drivers/net/ethernet/intel/e1000e/ethtool.c
View File

@ -656,10 +656,10 @@ static int e1000_set_ringparam(struct net_device *netdev,
if (netif_running(adapter->netdev)) { if (netif_running(adapter->netdev)) {
/* Try to get new resources before deleting old */ /* Try to get new resources before deleting old */
err = e1000e_setup_rx_resources(adapter); err = e1000e_setup_rx_resources(rx_ring);
if (err) if (err)
goto err_setup_rx; goto err_setup_rx;
err = e1000e_setup_tx_resources(adapter); err = e1000e_setup_tx_resources(tx_ring);
if (err) if (err)
goto err_setup_tx; goto err_setup_tx;
@ -669,8 +669,8 @@ static int e1000_set_ringparam(struct net_device *netdev,
*/ */
adapter->rx_ring = rx_old; adapter->rx_ring = rx_old;
adapter->tx_ring = tx_old; adapter->tx_ring = tx_old;
e1000e_free_rx_resources(adapter); e1000e_free_rx_resources(adapter->rx_ring);
e1000e_free_tx_resources(adapter); e1000e_free_tx_resources(adapter->tx_ring);
kfree(tx_old); kfree(tx_old);
kfree(rx_old); kfree(rx_old);
adapter->rx_ring = rx_ring; adapter->rx_ring = rx_ring;
@ -683,7 +683,7 @@ static int e1000_set_ringparam(struct net_device *netdev,
clear_bit(__E1000_RESETTING, &adapter->state); clear_bit(__E1000_RESETTING, &adapter->state);
return 0; return 0;
err_setup_tx: err_setup_tx:
e1000e_free_rx_resources(adapter); e1000e_free_rx_resources(rx_ring);
err_setup_rx: err_setup_rx:
adapter->rx_ring = rx_old; adapter->rx_ring = rx_old;
adapter->tx_ring = tx_old; adapter->tx_ring = tx_old;

230
drivers/net/ethernet/intel/e1000e/netdev.c
View File

@ -567,11 +567,12 @@ static inline s32 e1000e_update_tail_wa(struct e1000_hw *hw, void __iomem *tail,
return 0; return 0;
} }
static void e1000e_update_rdt_wa(struct e1000_adapter *adapter, unsigned int i) static void e1000e_update_rdt_wa(struct e1000_ring *rx_ring, unsigned int i)
{ {
struct e1000_adapter *adapter = rx_ring->adapter;
struct e1000_hw *hw = &adapter->hw; struct e1000_hw *hw = &adapter->hw;
if (e1000e_update_tail_wa(hw, adapter->rx_ring->tail, i)) { if (e1000e_update_tail_wa(hw, rx_ring->tail, i)) {
u32 rctl = er32(RCTL); u32 rctl = er32(RCTL);
ew32(RCTL, rctl & ~E1000_RCTL_EN); ew32(RCTL, rctl & ~E1000_RCTL_EN);
e_err("ME firmware caused invalid RDT - resetting\n"); e_err("ME firmware caused invalid RDT - resetting\n");
@ -579,11 +580,12 @@ static void e1000e_update_rdt_wa(struct e1000_adapter *adapter, unsigned int i)
} }
} }
static void e1000e_update_tdt_wa(struct e1000_adapter *adapter, unsigned int i) static void e1000e_update_tdt_wa(struct e1000_ring *tx_ring, unsigned int i)
{ {
struct e1000_adapter *adapter = tx_ring->adapter;
struct e1000_hw *hw = &adapter->hw; struct e1000_hw *hw = &adapter->hw;
if (e1000e_update_tail_wa(hw, adapter->tx_ring->tail, i)) { if (e1000e_update_tail_wa(hw, tx_ring->tail, i)) {
u32 tctl = er32(TCTL); u32 tctl = er32(TCTL);
ew32(TCTL, tctl & ~E1000_TCTL_EN); ew32(TCTL, tctl & ~E1000_TCTL_EN);
e_err("ME firmware caused invalid TDT - resetting\n"); e_err("ME firmware caused invalid TDT - resetting\n");
@ -593,14 +595,14 @@ static void e1000e_update_tdt_wa(struct e1000_adapter *adapter, unsigned int i)
/** /**
* e1000_alloc_rx_buffers - Replace used receive buffers * e1000_alloc_rx_buffers - Replace used receive buffers
* @adapter: address of board private structure * @rx_ring: Rx descriptor ring
**/ **/
static void e1000_alloc_rx_buffers(struct e1000_adapter *adapter, static void e1000_alloc_rx_buffers(struct e1000_ring *rx_ring,
int cleaned_count, gfp_t gfp) int cleaned_count, gfp_t gfp)
{ {
struct e1000_adapter *adapter = rx_ring->adapter;
struct net_device *netdev = adapter->netdev; struct net_device *netdev = adapter->netdev;
struct pci_dev *pdev = adapter->pdev; struct pci_dev *pdev = adapter->pdev;
struct e1000_ring *rx_ring = adapter->rx_ring;
union e1000_rx_desc_extended *rx_desc; union e1000_rx_desc_extended *rx_desc;
struct e1000_buffer *buffer_info; struct e1000_buffer *buffer_info;
struct sk_buff *skb; struct sk_buff *skb;
@ -647,7 +649,7 @@ map_skb:
*/ */
wmb(); wmb();
if (adapter->flags2 & FLAG2_PCIM2PCI_ARBITER_WA) if (adapter->flags2 & FLAG2_PCIM2PCI_ARBITER_WA)
e1000e_update_rdt_wa(adapter, i); e1000e_update_rdt_wa(rx_ring, i);
else else
writel(i, rx_ring->tail); writel(i, rx_ring->tail);
} }
@ -662,15 +664,15 @@ map_skb:
/** /**
* e1000_alloc_rx_buffers_ps - Replace used receive buffers; packet split * e1000_alloc_rx_buffers_ps - Replace used receive buffers; packet split
* @adapter: address of board private structure * @rx_ring: Rx descriptor ring
**/ **/
static void e1000_alloc_rx_buffers_ps(struct e1000_adapter *adapter, static void e1000_alloc_rx_buffers_ps(struct e1000_ring *rx_ring,
int cleaned_count, gfp_t gfp) int cleaned_count, gfp_t gfp)
{ {
struct e1000_adapter *adapter = rx_ring->adapter;
struct net_device *netdev = adapter->netdev; struct net_device *netdev = adapter->netdev;
struct pci_dev *pdev = adapter->pdev; struct pci_dev *pdev = adapter->pdev;
union e1000_rx_desc_packet_split *rx_desc; union e1000_rx_desc_packet_split *rx_desc;
struct e1000_ring *rx_ring = adapter->rx_ring;
struct e1000_buffer *buffer_info; struct e1000_buffer *buffer_info;
struct e1000_ps_page *ps_page; struct e1000_ps_page *ps_page;
struct sk_buff *skb; struct sk_buff *skb;
@ -750,7 +752,7 @@ static void e1000_alloc_rx_buffers_ps(struct e1000_adapter *adapter,
*/ */
wmb(); wmb();
if (adapter->flags2 & FLAG2_PCIM2PCI_ARBITER_WA) if (adapter->flags2 & FLAG2_PCIM2PCI_ARBITER_WA)
e1000e_update_rdt_wa(adapter, i << 1); e1000e_update_rdt_wa(rx_ring, i << 1);
else else
writel(i << 1, rx_ring->tail); writel(i << 1, rx_ring->tail);
} }
@ -767,17 +769,17 @@ no_buffers:
/** /**
* e1000_alloc_jumbo_rx_buffers - Replace used jumbo receive buffers * e1000_alloc_jumbo_rx_buffers - Replace used jumbo receive buffers
* @adapter: address of board private structure * @rx_ring: Rx descriptor ring
* @cleaned_count: number of buffers to allocate this pass * @cleaned_count: number of buffers to allocate this pass
**/ **/
static void e1000_alloc_jumbo_rx_buffers(struct e1000_adapter *adapter, static void e1000_alloc_jumbo_rx_buffers(struct e1000_ring *rx_ring,
int cleaned_count, gfp_t gfp) int cleaned_count, gfp_t gfp)
{ {
struct e1000_adapter *adapter = rx_ring->adapter;
struct net_device *netdev = adapter->netdev; struct net_device *netdev = adapter->netdev;
struct pci_dev *pdev = adapter->pdev; struct pci_dev *pdev = adapter->pdev;
union e1000_rx_desc_extended *rx_desc; union e1000_rx_desc_extended *rx_desc;
struct e1000_ring *rx_ring = adapter->rx_ring;
struct e1000_buffer *buffer_info; struct e1000_buffer *buffer_info;
struct sk_buff *skb; struct sk_buff *skb;
unsigned int i; unsigned int i;
@ -836,7 +838,7 @@ check_page:
* such as IA-64). */ * such as IA-64). */
wmb(); wmb();
if (adapter->flags2 & FLAG2_PCIM2PCI_ARBITER_WA) if (adapter->flags2 & FLAG2_PCIM2PCI_ARBITER_WA)
e1000e_update_rdt_wa(adapter, i); e1000e_update_rdt_wa(rx_ring, i);
else else
writel(i, rx_ring->tail); writel(i, rx_ring->tail);
} }
@ -850,19 +852,19 @@ static inline void e1000_rx_hash(struct net_device *netdev, __le32 rss,
} }
/** /**
* e1000_clean_rx_irq - Send received data up the network stack; legacy * e1000_clean_rx_irq - Send received data up the network stack
* @adapter: board private structure * @rx_ring: Rx descriptor ring
* *
* the return value indicates whether actual cleaning was done, there * the return value indicates whether actual cleaning was done, there
* is no guarantee that everything was cleaned * is no guarantee that everything was cleaned
**/ **/
static bool e1000_clean_rx_irq(struct e1000_adapter *adapter, static bool e1000_clean_rx_irq(struct e1000_ring *rx_ring, int *work_done,
int *work_done, int work_to_do) int work_to_do)
{ {
struct e1000_adapter *adapter = rx_ring->adapter;
struct net_device *netdev = adapter->netdev; struct net_device *netdev = adapter->netdev;
struct pci_dev *pdev = adapter->pdev; struct pci_dev *pdev = adapter->pdev;
struct e1000_hw *hw = &adapter->hw; struct e1000_hw *hw = &adapter->hw;
struct e1000_ring *rx_ring = adapter->rx_ring;
union e1000_rx_desc_extended *rx_desc, *next_rxd; union e1000_rx_desc_extended *rx_desc, *next_rxd;
struct e1000_buffer *buffer_info, *next_buffer; struct e1000_buffer *buffer_info, *next_buffer;
u32 length, staterr; u32 length, staterr;
@ -978,7 +980,7 @@ next_desc:
/* return some buffers to hardware, one at a time is too slow */ /* return some buffers to hardware, one at a time is too slow */
if (cleaned_count >= E1000_RX_BUFFER_WRITE) { if (cleaned_count >= E1000_RX_BUFFER_WRITE) {
adapter->alloc_rx_buf(adapter, cleaned_count, adapter->alloc_rx_buf(rx_ring, cleaned_count,
GFP_ATOMIC); GFP_ATOMIC);
cleaned_count = 0; cleaned_count = 0;
} }
@ -993,16 +995,18 @@ next_desc:
cleaned_count = e1000_desc_unused(rx_ring); cleaned_count = e1000_desc_unused(rx_ring);
if (cleaned_count) if (cleaned_count)
adapter->alloc_rx_buf(adapter, cleaned_count, GFP_ATOMIC); adapter->alloc_rx_buf(rx_ring, cleaned_count, GFP_ATOMIC);
adapter->total_rx_bytes += total_rx_bytes; adapter->total_rx_bytes += total_rx_bytes;
adapter->total_rx_packets += total_rx_packets; adapter->total_rx_packets += total_rx_packets;
return cleaned; return cleaned;
} }
static void e1000_put_txbuf(struct e1000_adapter *adapter, static void e1000_put_txbuf(struct e1000_ring *tx_ring,
struct e1000_buffer *buffer_info) struct e1000_buffer *buffer_info)
{ {
struct e1000_adapter *adapter = tx_ring->adapter;
if (buffer_info->dma) { if (buffer_info->dma) {
if (buffer_info->mapped_as_page) if (buffer_info->mapped_as_page)
dma_unmap_page(&adapter->pdev->dev, buffer_info->dma, dma_unmap_page(&adapter->pdev->dev, buffer_info->dma,
@ -1090,16 +1094,16 @@ static void e1000_print_hw_hang(struct work_struct *work)
/** /**
* e1000_clean_tx_irq - Reclaim resources after transmit completes * e1000_clean_tx_irq - Reclaim resources after transmit completes
* @adapter: board private structure * @tx_ring: Tx descriptor ring
* *
* the return value indicates whether actual cleaning was done, there * the return value indicates whether actual cleaning was done, there
* is no guarantee that everything was cleaned * is no guarantee that everything was cleaned
**/ **/
static bool e1000_clean_tx_irq(struct e1000_adapter *adapter) static bool e1000_clean_tx_irq(struct e1000_ring *tx_ring)
{ {
struct e1000_adapter *adapter = tx_ring->adapter;
struct net_device *netdev = adapter->netdev; struct net_device *netdev = adapter->netdev;
struct e1000_hw *hw = &adapter->hw; struct e1000_hw *hw = &adapter->hw;
struct e1000_ring *tx_ring = adapter->tx_ring;
struct e1000_tx_desc *tx_desc, *eop_desc; struct e1000_tx_desc *tx_desc, *eop_desc;
struct e1000_buffer *buffer_info; struct e1000_buffer *buffer_info;
unsigned int i, eop; unsigned int i, eop;
@ -1129,7 +1133,7 @@ static bool e1000_clean_tx_irq(struct e1000_adapter *adapter)
} }
} }
e1000_put_txbuf(adapter, buffer_info); e1000_put_txbuf(tx_ring, buffer_info);
tx_desc->upper.data = 0; tx_desc->upper.data = 0;
i++; i++;
@ -1183,19 +1187,19 @@ static bool e1000_clean_tx_irq(struct e1000_adapter *adapter)
/** /**
* e1000_clean_rx_irq_ps - Send received data up the network stack; packet split * e1000_clean_rx_irq_ps - Send received data up the network stack; packet split
* @adapter: board private structure * @rx_ring: Rx descriptor ring
* *
* the return value indicates whether actual cleaning was done, there * the return value indicates whether actual cleaning was done, there
* is no guarantee that everything was cleaned * is no guarantee that everything was cleaned
**/ **/
static bool e1000_clean_rx_irq_ps(struct e1000_adapter *adapter, static bool e1000_clean_rx_irq_ps(struct e1000_ring *rx_ring, int *work_done,
int *work_done, int work_to_do) int work_to_do)
{ {
struct e1000_adapter *adapter = rx_ring->adapter;
struct e1000_hw *hw = &adapter->hw; struct e1000_hw *hw = &adapter->hw;
union e1000_rx_desc_packet_split *rx_desc, *next_rxd; union e1000_rx_desc_packet_split *rx_desc, *next_rxd;
struct net_device *netdev = adapter->netdev; struct net_device *netdev = adapter->netdev;
struct pci_dev *pdev = adapter->pdev; struct pci_dev *pdev = adapter->pdev;
struct e1000_ring *rx_ring = adapter->rx_ring;
struct e1000_buffer *buffer_info, *next_buffer; struct e1000_buffer *buffer_info, *next_buffer;
struct e1000_ps_page *ps_page; struct e1000_ps_page *ps_page;
struct sk_buff *skb; struct sk_buff *skb;
@ -1346,7 +1350,7 @@ next_desc:
/* return some buffers to hardware, one at a time is too slow */ /* return some buffers to hardware, one at a time is too slow */
if (cleaned_count >= E1000_RX_BUFFER_WRITE) { if (cleaned_count >= E1000_RX_BUFFER_WRITE) {
adapter->alloc_rx_buf(adapter, cleaned_count, adapter->alloc_rx_buf(rx_ring, cleaned_count,
GFP_ATOMIC); GFP_ATOMIC);
cleaned_count = 0; cleaned_count = 0;
} }
@ -1361,7 +1365,7 @@ next_desc:
cleaned_count = e1000_desc_unused(rx_ring); cleaned_count = e1000_desc_unused(rx_ring);
if (cleaned_count) if (cleaned_count)
adapter->alloc_rx_buf(adapter, cleaned_count, GFP_ATOMIC); adapter->alloc_rx_buf(rx_ring, cleaned_count, GFP_ATOMIC);
adapter->total_rx_bytes += total_rx_bytes; adapter->total_rx_bytes += total_rx_bytes;
adapter->total_rx_packets += total_rx_packets; adapter->total_rx_packets += total_rx_packets;
@ -1387,13 +1391,12 @@ static void e1000_consume_page(struct e1000_buffer *bi, struct sk_buff *skb,
* the return value indicates whether actual cleaning was done, there * the return value indicates whether actual cleaning was done, there
* is no guarantee that everything was cleaned * is no guarantee that everything was cleaned
**/ **/
static bool e1000_clean_jumbo_rx_irq(struct e1000_ring *rx_ring, int *work_done,
static bool e1000_clean_jumbo_rx_irq(struct e1000_adapter *adapter, int work_to_do)
int *work_done, int work_to_do)
{ {
struct e1000_adapter *adapter = rx_ring->adapter;
struct net_device *netdev = adapter->netdev; struct net_device *netdev = adapter->netdev;
struct pci_dev *pdev = adapter->pdev; struct pci_dev *pdev = adapter->pdev;
struct e1000_ring *rx_ring = adapter->rx_ring;
union e1000_rx_desc_extended *rx_desc, *next_rxd; union e1000_rx_desc_extended *rx_desc, *next_rxd;
struct e1000_buffer *buffer_info, *next_buffer; struct e1000_buffer *buffer_info, *next_buffer;
u32 length, staterr; u32 length, staterr;
@ -1526,7 +1529,7 @@ next_desc:
/* return some buffers to hardware, one at a time is too slow */ /* return some buffers to hardware, one at a time is too slow */
if (unlikely(cleaned_count >= E1000_RX_BUFFER_WRITE)) { if (unlikely(cleaned_count >= E1000_RX_BUFFER_WRITE)) {
adapter->alloc_rx_buf(adapter, cleaned_count, adapter->alloc_rx_buf(rx_ring, cleaned_count,
GFP_ATOMIC); GFP_ATOMIC);
cleaned_count = 0; cleaned_count = 0;
} }
@ -1541,7 +1544,7 @@ next_desc:
cleaned_count = e1000_desc_unused(rx_ring); cleaned_count = e1000_desc_unused(rx_ring);
if (cleaned_count) if (cleaned_count)
adapter->alloc_rx_buf(adapter, cleaned_count, GFP_ATOMIC); adapter->alloc_rx_buf(rx_ring, cleaned_count, GFP_ATOMIC);
adapter->total_rx_bytes += total_rx_bytes; adapter->total_rx_bytes += total_rx_bytes;
adapter->total_rx_packets += total_rx_packets; adapter->total_rx_packets += total_rx_packets;
@ -1550,11 +1553,11 @@ next_desc:
/** /**
* e1000_clean_rx_ring - Free Rx Buffers per Queue * e1000_clean_rx_ring - Free Rx Buffers per Queue
* @adapter: board private structure * @rx_ring: Rx descriptor ring
**/ **/
static void e1000_clean_rx_ring(struct e1000_adapter *adapter) static void e1000_clean_rx_ring(struct e1000_ring *rx_ring)
{ {
struct e1000_ring *rx_ring = adapter->rx_ring; struct e1000_adapter *adapter = rx_ring->adapter;
struct e1000_buffer *buffer_info; struct e1000_buffer *buffer_info;
struct e1000_ps_page *ps_page; struct e1000_ps_page *ps_page;
struct pci_dev *pdev = adapter->pdev; struct pci_dev *pdev = adapter->pdev;
@ -1794,7 +1797,7 @@ static irqreturn_t e1000_intr_msix_tx(int irq, void *data)
adapter->total_tx_bytes = 0; adapter->total_tx_bytes = 0;
adapter->total_tx_packets = 0; adapter->total_tx_packets = 0;
if (!e1000_clean_tx_irq(adapter)) if (!e1000_clean_tx_irq(tx_ring))
/* Ring was not completely cleaned, so fire another interrupt */ /* Ring was not completely cleaned, so fire another interrupt */
ew32(ICS, tx_ring->ims_val); ew32(ICS, tx_ring->ims_val);
@ -1805,14 +1808,15 @@ static irqreturn_t e1000_intr_msix_rx(int irq, void *data)
{ {
struct net_device *netdev = data; struct net_device *netdev = data;
struct e1000_adapter *adapter = netdev_priv(netdev); struct e1000_adapter *adapter = netdev_priv(netdev);
struct e1000_ring *rx_ring = adapter->rx_ring;
/* Write the ITR value calculated at the end of the /* Write the ITR value calculated at the end of the
* previous interrupt. * previous interrupt.
*/ */
if (adapter->rx_ring->set_itr) { if (rx_ring->set_itr) {
writel(1000000000 / (adapter->rx_ring->itr_val * 256), writel(1000000000 / (rx_ring->itr_val * 256),
adapter->rx_ring->itr_register); rx_ring->itr_register);
adapter->rx_ring->set_itr = 0; rx_ring->set_itr = 0;
} }
if (napi_schedule_prep(&adapter->napi)) { if (napi_schedule_prep(&adapter->napi)) {
@ -2177,13 +2181,13 @@ static int e1000_alloc_ring_dma(struct e1000_adapter *adapter,
/** /**
* e1000e_setup_tx_resources - allocate Tx resources (Descriptors) * e1000e_setup_tx_resources - allocate Tx resources (Descriptors)
* @adapter: board private structure * @tx_ring: Tx descriptor ring
* *
* Return 0 on success, negative on failure * Return 0 on success, negative on failure
**/ **/
int e1000e_setup_tx_resources(struct e1000_adapter *adapter) int e1000e_setup_tx_resources(struct e1000_ring *tx_ring)
{ {
struct e1000_ring *tx_ring = adapter->tx_ring; struct e1000_adapter *adapter = tx_ring->adapter;
int err = -ENOMEM, size; int err = -ENOMEM, size;
size = sizeof(struct e1000_buffer) * tx_ring->count; size = sizeof(struct e1000_buffer) * tx_ring->count;
@ -2211,13 +2215,13 @@ err:
/** /**
* e1000e_setup_rx_resources - allocate Rx resources (Descriptors) * e1000e_setup_rx_resources - allocate Rx resources (Descriptors)
* @adapter: board private structure * @rx_ring: Rx descriptor ring
* *
* Returns 0 on success, negative on failure * Returns 0 on success, negative on failure
**/ **/
int e1000e_setup_rx_resources(struct e1000_adapter *adapter) int e1000e_setup_rx_resources(struct e1000_ring *rx_ring)
{ {
struct e1000_ring *rx_ring = adapter->rx_ring; struct e1000_adapter *adapter = rx_ring->adapter;
struct e1000_buffer *buffer_info; struct e1000_buffer *buffer_info;
int i, size, desc_len, err = -ENOMEM; int i, size, desc_len, err = -ENOMEM;
@ -2264,18 +2268,18 @@ err:
/** /**
* e1000_clean_tx_ring - Free Tx Buffers * e1000_clean_tx_ring - Free Tx Buffers
* @adapter: board private structure * @tx_ring: Tx descriptor ring
**/ **/
static void e1000_clean_tx_ring(struct e1000_adapter *adapter) static void e1000_clean_tx_ring(struct e1000_ring *tx_ring)
{ {
struct e1000_ring *tx_ring = adapter->tx_ring; struct e1000_adapter *adapter = tx_ring->adapter;
struct e1000_buffer *buffer_info; struct e1000_buffer *buffer_info;
unsigned long size; unsigned long size;
unsigned int i; unsigned int i;
for (i = 0; i < tx_ring->count; i++) { for (i = 0; i < tx_ring->count; i++) {
buffer_info = &tx_ring->buffer_info[i]; buffer_info = &tx_ring->buffer_info[i];
e1000_put_txbuf(adapter, buffer_info); e1000_put_txbuf(tx_ring, buffer_info);
} }
netdev_reset_queue(adapter->netdev); netdev_reset_queue(adapter->netdev);
@ -2293,16 +2297,16 @@ static void e1000_clean_tx_ring(struct e1000_adapter *adapter)
/** /**
* e1000e_free_tx_resources - Free Tx Resources per Queue * e1000e_free_tx_resources - Free Tx Resources per Queue
* @adapter: board private structure * @tx_ring: Tx descriptor ring
* *
* Free all transmit software resources * Free all transmit software resources
**/ **/
void e1000e_free_tx_resources(struct e1000_adapter *adapter) void e1000e_free_tx_resources(struct e1000_ring *tx_ring)
{ {
struct e1000_adapter *adapter = tx_ring->adapter;
struct pci_dev *pdev = adapter->pdev; struct pci_dev *pdev = adapter->pdev;
struct e1000_ring *tx_ring = adapter->tx_ring;
e1000_clean_tx_ring(adapter); e1000_clean_tx_ring(tx_ring);
vfree(tx_ring->buffer_info); vfree(tx_ring->buffer_info);
tx_ring->buffer_info = NULL; tx_ring->buffer_info = NULL;
@ -2314,18 +2318,17 @@ void e1000e_free_tx_resources(struct e1000_adapter *adapter)
/** /**
* e1000e_free_rx_resources - Free Rx Resources * e1000e_free_rx_resources - Free Rx Resources
* @adapter: board private structure * @rx_ring: Rx descriptor ring
* *
* Free all receive software resources * Free all receive software resources
**/ **/
void e1000e_free_rx_resources(struct e1000_ring *rx_ring)
void e1000e_free_rx_resources(struct e1000_adapter *adapter)
{ {
struct e1000_adapter *adapter = rx_ring->adapter;
struct pci_dev *pdev = adapter->pdev; struct pci_dev *pdev = adapter->pdev;
struct e1000_ring *rx_ring = adapter->rx_ring;
int i; int i;
e1000_clean_rx_ring(adapter); e1000_clean_rx_ring(rx_ring);
for (i = 0; i < rx_ring->count; i++) for (i = 0; i < rx_ring->count; i++)
kfree(rx_ring->buffer_info[i].ps_pages); kfree(rx_ring->buffer_info[i].ps_pages);
@ -2479,13 +2482,19 @@ set_itr_now:
**/ **/
static int __devinit e1000_alloc_queues(struct e1000_adapter *adapter) static int __devinit e1000_alloc_queues(struct e1000_adapter *adapter)
{ {
adapter->tx_ring = kzalloc(sizeof(struct e1000_ring), GFP_KERNEL); int size = sizeof(struct e1000_ring);
adapter->tx_ring = kzalloc(size, GFP_KERNEL);
if (!adapter->tx_ring) if (!adapter->tx_ring)
goto err; goto err;
adapter->tx_ring->count = adapter->tx_ring_count;
adapter->tx_ring->adapter = adapter;
adapter->rx_ring = kzalloc(sizeof(struct e1000_ring), GFP_KERNEL); adapter->rx_ring = kzalloc(size, GFP_KERNEL);
if (!adapter->rx_ring) if (!adapter->rx_ring)
goto err; goto err;
adapter->rx_ring->count = adapter->rx_ring_count;
adapter->rx_ring->adapter = adapter;
return 0; return 0;
err: err:
@ -2513,10 +2522,10 @@ static int e1000_clean(struct napi_struct *napi, int budget)
!(adapter->rx_ring->ims_val & adapter->tx_ring->ims_val)) !(adapter->rx_ring->ims_val & adapter->tx_ring->ims_val))
goto clean_rx; goto clean_rx;
tx_cleaned = e1000_clean_tx_irq(adapter); tx_cleaned = e1000_clean_tx_irq(adapter->tx_ring);
clean_rx: clean_rx:
adapter->clean_rx(adapter, &work_done, budget); adapter->clean_rx(adapter->rx_ring, &work_done, budget);
if (!tx_cleaned) if (!tx_cleaned)
work_done = budget; work_done = budget;
@ -3325,6 +3334,8 @@ static void e1000e_setup_rss_hash(struct e1000_adapter *adapter)
**/ **/
static void e1000_configure(struct e1000_adapter *adapter) static void e1000_configure(struct e1000_adapter *adapter)
{ {
struct e1000_ring *rx_ring = adapter->rx_ring;
e1000e_set_rx_mode(adapter->netdev); e1000e_set_rx_mode(adapter->netdev);
e1000_restore_vlan(adapter); e1000_restore_vlan(adapter);
@ -3336,8 +3347,7 @@ static void e1000_configure(struct e1000_adapter *adapter)
e1000e_setup_rss_hash(adapter); e1000e_setup_rss_hash(adapter);
e1000_setup_rctl(adapter); e1000_setup_rctl(adapter);
e1000_configure_rx(adapter); e1000_configure_rx(adapter);
adapter->alloc_rx_buf(adapter, e1000_desc_unused(adapter->rx_ring), adapter->alloc_rx_buf(rx_ring, e1000_desc_unused(rx_ring), GFP_KERNEL);
GFP_KERNEL);
} }
/** /**
@ -3647,8 +3657,8 @@ void e1000e_down(struct e1000_adapter *adapter)
spin_unlock(&adapter->stats64_lock); spin_unlock(&adapter->stats64_lock);
e1000e_flush_descriptors(adapter); e1000e_flush_descriptors(adapter);
e1000_clean_tx_ring(adapter); e1000_clean_tx_ring(adapter->tx_ring);
e1000_clean_rx_ring(adapter); e1000_clean_rx_ring(adapter->rx_ring);
adapter->link_speed = 0; adapter->link_speed = 0;
adapter->link_duplex = 0; adapter->link_duplex = 0;
@ -3688,6 +3698,8 @@ static int __devinit e1000_sw_init(struct e1000_adapter *adapter)
adapter->rx_ps_bsize0 = 128; adapter->rx_ps_bsize0 = 128;
adapter->max_frame_size = netdev->mtu + ETH_HLEN + ETH_FCS_LEN; adapter->max_frame_size = netdev->mtu + ETH_HLEN + ETH_FCS_LEN;
adapter->min_frame_size = ETH_ZLEN + ETH_FCS_LEN; adapter->min_frame_size = ETH_ZLEN + ETH_FCS_LEN;
adapter->tx_ring_count = E1000_DEFAULT_TXD;
adapter->rx_ring_count = E1000_DEFAULT_RXD;
spin_lock_init(&adapter->stats64_lock); spin_lock_init(&adapter->stats64_lock);
@ -3846,12 +3858,12 @@ static int e1000_open(struct net_device *netdev)
netif_carrier_off(netdev); netif_carrier_off(netdev);
/* allocate transmit descriptors */ /* allocate transmit descriptors */
err = e1000e_setup_tx_resources(adapter); err = e1000e_setup_tx_resources(adapter->tx_ring);
if (err) if (err)
goto err_setup_tx; goto err_setup_tx;
/* allocate receive descriptors */ /* allocate receive descriptors */
err = e1000e_setup_rx_resources(adapter); err = e1000e_setup_rx_resources(adapter->rx_ring);
if (err) if (err)
goto err_setup_rx; goto err_setup_rx;
@ -3927,9 +3939,9 @@ static int e1000_open(struct net_device *netdev)
err_req_irq: err_req_irq:
e1000e_release_hw_control(adapter); e1000e_release_hw_control(adapter);
e1000_power_down_phy(adapter); e1000_power_down_phy(adapter);
e1000e_free_rx_resources(adapter); e1000e_free_rx_resources(adapter->rx_ring);
err_setup_rx: err_setup_rx:
e1000e_free_tx_resources(adapter); e1000e_free_tx_resources(adapter->tx_ring);
err_setup_tx: err_setup_tx:
e1000e_reset(adapter); e1000e_reset(adapter);
pm_runtime_put_sync(&pdev->dev); pm_runtime_put_sync(&pdev->dev);
@ -3965,8 +3977,8 @@ static int e1000_close(struct net_device *netdev)
} }
e1000_power_down_phy(adapter); e1000_power_down_phy(adapter);
e1000e_free_tx_resources(adapter); e1000e_free_tx_resources(adapter->tx_ring);
e1000e_free_rx_resources(adapter); e1000e_free_rx_resources(adapter->rx_ring);
/* /*
* kill manageability vlan ID if supported, but not if a vlan with * kill manageability vlan ID if supported, but not if a vlan with
@ -4623,10 +4635,8 @@ link_up:
#define E1000_TX_FLAGS_VLAN_MASK 0xffff0000 #define E1000_TX_FLAGS_VLAN_MASK 0xffff0000
#define E1000_TX_FLAGS_VLAN_SHIFT 16 #define E1000_TX_FLAGS_VLAN_SHIFT 16
static int e1000_tso(struct e1000_adapter *adapter, static int e1000_tso(struct e1000_ring *tx_ring, struct sk_buff *skb)
struct sk_buff *skb)
{ {
struct e1000_ring *tx_ring = adapter->tx_ring;
struct e1000_context_desc *context_desc; struct e1000_context_desc *context_desc;
struct e1000_buffer *buffer_info; struct e1000_buffer *buffer_info;
unsigned int i; unsigned int i;
@ -4695,9 +4705,9 @@ static int e1000_tso(struct e1000_adapter *adapter,
return 1; return 1;
} }
static bool e1000_tx_csum(struct e1000_adapter *adapter, struct sk_buff *skb) static bool e1000_tx_csum(struct e1000_ring *tx_ring, struct sk_buff *skb)
{ {
struct e1000_ring *tx_ring = adapter->tx_ring; struct e1000_adapter *adapter = tx_ring->adapter;
struct e1000_context_desc *context_desc; struct e1000_context_desc *context_desc;
struct e1000_buffer *buffer_info; struct e1000_buffer *buffer_info;
unsigned int i; unsigned int i;
@ -4758,12 +4768,11 @@ static bool e1000_tx_csum(struct e1000_adapter *adapter, struct sk_buff *skb)
#define E1000_MAX_PER_TXD 8192 #define E1000_MAX_PER_TXD 8192
#define E1000_MAX_TXD_PWR 12 #define E1000_MAX_TXD_PWR 12
static int e1000_tx_map(struct e1000_adapter *adapter, static int e1000_tx_map(struct e1000_ring *tx_ring, struct sk_buff *skb,
struct sk_buff *skb, unsigned int first, unsigned int first, unsigned int max_per_txd,
unsigned int max_per_txd, unsigned int nr_frags, unsigned int nr_frags, unsigned int mss)
unsigned int mss)
{ {
struct e1000_ring *tx_ring = adapter->tx_ring; struct e1000_adapter *adapter = tx_ring->adapter;
struct pci_dev *pdev = adapter->pdev; struct pci_dev *pdev = adapter->pdev;
struct e1000_buffer *buffer_info; struct e1000_buffer *buffer_info;
unsigned int len = skb_headlen(skb); unsigned int len = skb_headlen(skb);
@ -4849,16 +4858,15 @@ dma_error:
i += tx_ring->count; i += tx_ring->count;
i--; i--;
buffer_info = &tx_ring->buffer_info[i]; buffer_info = &tx_ring->buffer_info[i];
e1000_put_txbuf(adapter, buffer_info); e1000_put_txbuf(tx_ring, buffer_info);
} }
return 0; return 0;
} }
static void e1000_tx_queue(struct e1000_adapter *adapter, static void e1000_tx_queue(struct e1000_ring *tx_ring, int tx_flags, int count)
int tx_flags, int count)
{ {
struct e1000_ring *tx_ring = adapter->tx_ring; struct e1000_adapter *adapter = tx_ring->adapter;
struct e1000_tx_desc *tx_desc = NULL; struct e1000_tx_desc *tx_desc = NULL;
struct e1000_buffer *buffer_info; struct e1000_buffer *buffer_info;
u32 txd_upper = 0, txd_lower = E1000_TXD_CMD_IFCS; u32 txd_upper = 0, txd_lower = E1000_TXD_CMD_IFCS;
@ -4911,7 +4919,7 @@ static void e1000_tx_queue(struct e1000_adapter *adapter,
tx_ring->next_to_use = i; tx_ring->next_to_use = i;
if (adapter->flags2 & FLAG2_PCIM2PCI_ARBITER_WA) if (adapter->flags2 & FLAG2_PCIM2PCI_ARBITER_WA)
e1000e_update_tdt_wa(adapter, i); e1000e_update_tdt_wa(tx_ring, i);
else else
writel(i, tx_ring->tail); writel(i, tx_ring->tail);
@ -4961,11 +4969,11 @@ static int e1000_transfer_dhcp_info(struct e1000_adapter *adapter,
return 0; return 0;
} }
static int __e1000_maybe_stop_tx(struct net_device *netdev, int size) static int __e1000_maybe_stop_tx(struct e1000_ring *tx_ring, int size)
{ {
struct e1000_adapter *adapter = netdev_priv(netdev); struct e1000_adapter *adapter = tx_ring->adapter;
netif_stop_queue(netdev); netif_stop_queue(adapter->netdev);
/* /*
* Herbert's original patch had: * Herbert's original patch had:
* smp_mb__after_netif_stop_queue(); * smp_mb__after_netif_stop_queue();
@ -4977,22 +4985,20 @@ static int __e1000_maybe_stop_tx(struct net_device *netdev, int size)
* We need to check again in a case another CPU has just * We need to check again in a case another CPU has just
* made room available. * made room available.
*/ */
if (e1000_desc_unused(adapter->tx_ring) < size) if (e1000_desc_unused(tx_ring) < size)
return -EBUSY; return -EBUSY;
/* A reprieve! */ /* A reprieve! */
netif_start_queue(netdev); netif_start_queue(adapter->netdev);
++adapter->restart_queue; ++adapter->restart_queue;
return 0; return 0;
} }
static int e1000_maybe_stop_tx(struct net_device *netdev, int size) static int e1000_maybe_stop_tx(struct e1000_ring *tx_ring, int size)
{ {
struct e1000_adapter *adapter = netdev_priv(netdev); if (e1000_desc_unused(tx_ring) >= size)
if (e1000_desc_unused(adapter->tx_ring) >= size)
return 0; return 0;
return __e1000_maybe_stop_tx(netdev, size); return __e1000_maybe_stop_tx(tx_ring, size);
} }
#define TXD_USE_COUNT(S, X) (((S) >> (X)) + 1 ) #define TXD_USE_COUNT(S, X) (((S) >> (X)) + 1 )
@ -5078,7 +5084,7 @@ static netdev_tx_t e1000_xmit_frame(struct sk_buff *skb,
* need: count + 2 desc gap to keep tail from touching * need: count + 2 desc gap to keep tail from touching
* head, otherwise try next time * head, otherwise try next time
*/ */
if (e1000_maybe_stop_tx(netdev, count + 2)) if (e1000_maybe_stop_tx(tx_ring, count + 2))
return NETDEV_TX_BUSY; return NETDEV_TX_BUSY;
if (vlan_tx_tag_present(skb)) { if (vlan_tx_tag_present(skb)) {
@ -5088,7 +5094,7 @@ static netdev_tx_t e1000_xmit_frame(struct sk_buff *skb,
first = tx_ring->next_to_use; first = tx_ring->next_to_use;
tso = e1000_tso(adapter, skb); tso = e1000_tso(tx_ring, skb);
if (tso < 0) { if (tso < 0) {
dev_kfree_skb_any(skb); dev_kfree_skb_any(skb);
return NETDEV_TX_OK; return NETDEV_TX_OK;
@ -5096,7 +5102,7 @@ static netdev_tx_t e1000_xmit_frame(struct sk_buff *skb,
if (tso) if (tso)
tx_flags |= E1000_TX_FLAGS_TSO; tx_flags |= E1000_TX_FLAGS_TSO;
else if (e1000_tx_csum(adapter, skb)) else if (e1000_tx_csum(tx_ring, skb))
tx_flags |= E1000_TX_FLAGS_CSUM; tx_flags |= E1000_TX_FLAGS_CSUM;
/* /*
@ -5108,12 +5114,12 @@ static netdev_tx_t e1000_xmit_frame(struct sk_buff *skb,
tx_flags |= E1000_TX_FLAGS_IPV4; tx_flags |= E1000_TX_FLAGS_IPV4;
/* if count is 0 then mapping error has occurred */ /* if count is 0 then mapping error has occurred */
count = e1000_tx_map(adapter, skb, first, max_per_txd, nr_frags, mss); count = e1000_tx_map(tx_ring, skb, first, max_per_txd, nr_frags, mss);
if (count) { if (count) {
netdev_sent_queue(netdev, skb->len); netdev_sent_queue(netdev, skb->len);
e1000_tx_queue(adapter, tx_flags, count); e1000_tx_queue(tx_ring, tx_flags, count);
/* Make sure there is space in the ring for the next send. */ /* Make sure there is space in the ring for the next send. */
e1000_maybe_stop_tx(netdev, MAX_SKB_FRAGS + 2); e1000_maybe_stop_tx(tx_ring, MAX_SKB_FRAGS + 2);
} else { } else {
dev_kfree_skb_any(skb); dev_kfree_skb_any(skb);