2005-04-16 22:20:36 +00:00
|
|
|
/*******************************************************************************
|
|
|
|
|
2006-09-27 19:53:14 +00:00
|
|
|
Intel PRO/1000 Linux driver
|
|
|
|
Copyright(c) 1999 - 2006 Intel Corporation.
|
|
|
|
|
|
|
|
This program is free software; you can redistribute it and/or modify it
|
|
|
|
under the terms and conditions of the GNU General Public License,
|
|
|
|
version 2, as published by the Free Software Foundation.
|
|
|
|
|
|
|
|
This program is distributed in the hope it will be useful, but WITHOUT
|
|
|
|
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
|
|
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
|
2005-04-16 22:20:36 +00:00
|
|
|
more details.
|
2006-09-27 19:53:14 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
You should have received a copy of the GNU General Public License along with
|
2006-09-27 19:53:14 +00:00
|
|
|
this program; if not, write to the Free Software Foundation, Inc.,
|
|
|
|
51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
|
|
|
|
|
|
|
|
The full GNU General Public License is included in this distribution in
|
|
|
|
the file called "COPYING".
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
Contact Information:
|
|
|
|
Linux NICS <linux.nics@intel.com>
|
2006-04-15 02:05:31 +00:00
|
|
|
e1000-devel Mailing List <e1000-devel@lists.sourceforge.net>
|
2005-04-16 22:20:36 +00:00
|
|
|
Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
|
|
|
|
|
|
|
|
*******************************************************************************/
|
|
|
|
|
|
|
|
#include "e1000.h"
|
2006-11-14 15:35:03 +00:00
|
|
|
#include <net/ip6_checksum.h>
|
2011-01-06 14:29:54 +00:00
|
|
|
#include <linux/io.h>
|
2011-05-22 20:47:17 +00:00
|
|
|
#include <linux/prefetch.h>
|
2011-07-21 03:26:31 +00:00
|
|
|
#include <linux/bitops.h>
|
|
|
|
#include <linux/if_vlan.h>
|
2011-01-06 14:29:54 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
char e1000_driver_name[] = "e1000";
|
2005-10-30 15:53:34 +00:00
|
|
|
static char e1000_driver_string[] = "Intel(R) PRO/1000 Network Driver";
|
2010-11-21 17:54:21 +00:00
|
|
|
#define DRV_VERSION "7.3.21-k8-NAPI"
|
2007-10-29 17:46:19 +00:00
|
|
|
const char e1000_driver_version[] = DRV_VERSION;
|
|
|
|
static const char e1000_copyright[] = "Copyright (c) 1999-2006 Intel Corporation.";
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* e1000_pci_tbl - PCI Device ID Table
|
|
|
|
*
|
|
|
|
* Last entry must be all 0s
|
|
|
|
*
|
|
|
|
* Macro expands to...
|
|
|
|
* {PCI_DEVICE(PCI_VENDOR_ID_INTEL, device_id)}
|
|
|
|
*/
|
2010-01-07 11:58:11 +00:00
|
|
|
static DEFINE_PCI_DEVICE_TABLE(e1000_pci_tbl) = {
|
2005-04-16 22:20:36 +00:00
|
|
|
INTEL_E1000_ETHERNET_DEVICE(0x1000),
|
|
|
|
INTEL_E1000_ETHERNET_DEVICE(0x1001),
|
|
|
|
INTEL_E1000_ETHERNET_DEVICE(0x1004),
|
|
|
|
INTEL_E1000_ETHERNET_DEVICE(0x1008),
|
|
|
|
INTEL_E1000_ETHERNET_DEVICE(0x1009),
|
|
|
|
INTEL_E1000_ETHERNET_DEVICE(0x100C),
|
|
|
|
INTEL_E1000_ETHERNET_DEVICE(0x100D),
|
|
|
|
INTEL_E1000_ETHERNET_DEVICE(0x100E),
|
|
|
|
INTEL_E1000_ETHERNET_DEVICE(0x100F),
|
|
|
|
INTEL_E1000_ETHERNET_DEVICE(0x1010),
|
|
|
|
INTEL_E1000_ETHERNET_DEVICE(0x1011),
|
|
|
|
INTEL_E1000_ETHERNET_DEVICE(0x1012),
|
|
|
|
INTEL_E1000_ETHERNET_DEVICE(0x1013),
|
|
|
|
INTEL_E1000_ETHERNET_DEVICE(0x1014),
|
|
|
|
INTEL_E1000_ETHERNET_DEVICE(0x1015),
|
|
|
|
INTEL_E1000_ETHERNET_DEVICE(0x1016),
|
|
|
|
INTEL_E1000_ETHERNET_DEVICE(0x1017),
|
|
|
|
INTEL_E1000_ETHERNET_DEVICE(0x1018),
|
|
|
|
INTEL_E1000_ETHERNET_DEVICE(0x1019),
|
2005-04-29 02:44:46 +00:00
|
|
|
INTEL_E1000_ETHERNET_DEVICE(0x101A),
|
2005-04-16 22:20:36 +00:00
|
|
|
INTEL_E1000_ETHERNET_DEVICE(0x101D),
|
|
|
|
INTEL_E1000_ETHERNET_DEVICE(0x101E),
|
|
|
|
INTEL_E1000_ETHERNET_DEVICE(0x1026),
|
|
|
|
INTEL_E1000_ETHERNET_DEVICE(0x1027),
|
|
|
|
INTEL_E1000_ETHERNET_DEVICE(0x1028),
|
|
|
|
INTEL_E1000_ETHERNET_DEVICE(0x1075),
|
|
|
|
INTEL_E1000_ETHERNET_DEVICE(0x1076),
|
|
|
|
INTEL_E1000_ETHERNET_DEVICE(0x1077),
|
|
|
|
INTEL_E1000_ETHERNET_DEVICE(0x1078),
|
|
|
|
INTEL_E1000_ETHERNET_DEVICE(0x1079),
|
|
|
|
INTEL_E1000_ETHERNET_DEVICE(0x107A),
|
|
|
|
INTEL_E1000_ETHERNET_DEVICE(0x107B),
|
|
|
|
INTEL_E1000_ETHERNET_DEVICE(0x107C),
|
|
|
|
INTEL_E1000_ETHERNET_DEVICE(0x108A),
|
2006-01-13 00:51:21 +00:00
|
|
|
INTEL_E1000_ETHERNET_DEVICE(0x1099),
|
|
|
|
INTEL_E1000_ETHERNET_DEVICE(0x10B5),
|
2011-01-06 14:29:54 +00:00
|
|
|
INTEL_E1000_ETHERNET_DEVICE(0x2E6E),
|
2005-04-16 22:20:36 +00:00
|
|
|
/* required last entry */
|
|
|
|
{0,}
|
|
|
|
};
|
|
|
|
|
|
|
|
MODULE_DEVICE_TABLE(pci, e1000_pci_tbl);
|
|
|
|
|
2006-09-27 19:53:34 +00:00
|
|
|
int e1000_up(struct e1000_adapter *adapter);
|
|
|
|
void e1000_down(struct e1000_adapter *adapter);
|
|
|
|
void e1000_reinit_locked(struct e1000_adapter *adapter);
|
|
|
|
void e1000_reset(struct e1000_adapter *adapter);
|
|
|
|
int e1000_setup_all_tx_resources(struct e1000_adapter *adapter);
|
|
|
|
int e1000_setup_all_rx_resources(struct e1000_adapter *adapter);
|
|
|
|
void e1000_free_all_tx_resources(struct e1000_adapter *adapter);
|
|
|
|
void e1000_free_all_rx_resources(struct e1000_adapter *adapter);
|
2005-10-30 15:53:34 +00:00
|
|
|
static int e1000_setup_tx_resources(struct e1000_adapter *adapter,
|
2006-09-27 19:53:34 +00:00
|
|
|
struct e1000_tx_ring *txdr);
|
2005-10-30 15:53:34 +00:00
|
|
|
static int e1000_setup_rx_resources(struct e1000_adapter *adapter,
|
2006-09-27 19:53:34 +00:00
|
|
|
struct e1000_rx_ring *rxdr);
|
2005-10-30 15:53:34 +00:00
|
|
|
static void e1000_free_tx_resources(struct e1000_adapter *adapter,
|
2006-09-27 19:53:34 +00:00
|
|
|
struct e1000_tx_ring *tx_ring);
|
2005-10-30 15:53:34 +00:00
|
|
|
static void e1000_free_rx_resources(struct e1000_adapter *adapter,
|
2006-09-27 19:53:34 +00:00
|
|
|
struct e1000_rx_ring *rx_ring);
|
|
|
|
void e1000_update_stats(struct e1000_adapter *adapter);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
static int e1000_init_module(void);
|
|
|
|
static void e1000_exit_module(void);
|
|
|
|
static int e1000_probe(struct pci_dev *pdev, const struct pci_device_id *ent);
|
2012-12-03 14:24:25 +00:00
|
|
|
static void e1000_remove(struct pci_dev *pdev);
|
2005-10-04 11:01:55 +00:00
|
|
|
static int e1000_alloc_queues(struct e1000_adapter *adapter);
|
2005-04-16 22:20:36 +00:00
|
|
|
static int e1000_sw_init(struct e1000_adapter *adapter);
|
|
|
|
static int e1000_open(struct net_device *netdev);
|
|
|
|
static int e1000_close(struct net_device *netdev);
|
|
|
|
static void e1000_configure_tx(struct e1000_adapter *adapter);
|
|
|
|
static void e1000_configure_rx(struct e1000_adapter *adapter);
|
|
|
|
static void e1000_setup_rctl(struct e1000_adapter *adapter);
|
2005-10-04 11:01:55 +00:00
|
|
|
static void e1000_clean_all_tx_rings(struct e1000_adapter *adapter);
|
|
|
|
static void e1000_clean_all_rx_rings(struct e1000_adapter *adapter);
|
|
|
|
static void e1000_clean_tx_ring(struct e1000_adapter *adapter,
|
|
|
|
struct e1000_tx_ring *tx_ring);
|
|
|
|
static void e1000_clean_rx_ring(struct e1000_adapter *adapter,
|
|
|
|
struct e1000_rx_ring *rx_ring);
|
2007-11-14 04:54:59 +00:00
|
|
|
static void e1000_set_rx_mode(struct net_device *netdev);
|
2010-09-22 18:22:17 +00:00
|
|
|
static void e1000_update_phy_info_task(struct work_struct *work);
|
2011-10-05 07:24:41 +00:00
|
|
|
static void e1000_watchdog(struct work_struct *work);
|
2010-09-22 18:22:17 +00:00
|
|
|
static void e1000_82547_tx_fifo_stall_task(struct work_struct *work);
|
2009-08-31 19:50:55 +00:00
|
|
|
static netdev_tx_t e1000_xmit_frame(struct sk_buff *skb,
|
|
|
|
struct net_device *netdev);
|
2005-04-16 22:20:36 +00:00
|
|
|
static struct net_device_stats * e1000_get_stats(struct net_device *netdev);
|
|
|
|
static int e1000_change_mtu(struct net_device *netdev, int new_mtu);
|
|
|
|
static int e1000_set_mac(struct net_device *netdev, void *p);
|
IRQ: Maintain regs pointer globally rather than passing to IRQ handlers
Maintain a per-CPU global "struct pt_regs *" variable which can be used instead
of passing regs around manually through all ~1800 interrupt handlers in the
Linux kernel.
The regs pointer is used in few places, but it potentially costs both stack
space and code to pass it around. On the FRV arch, removing the regs parameter
from all the genirq function results in a 20% speed up of the IRQ exit path
(ie: from leaving timer_interrupt() to leaving do_IRQ()).
Where appropriate, an arch may override the generic storage facility and do
something different with the variable. On FRV, for instance, the address is
maintained in GR28 at all times inside the kernel as part of general exception
handling.
Having looked over the code, it appears that the parameter may be handed down
through up to twenty or so layers of functions. Consider a USB character
device attached to a USB hub, attached to a USB controller that posts its
interrupts through a cascaded auxiliary interrupt controller. A character
device driver may want to pass regs to the sysrq handler through the input
layer which adds another few layers of parameter passing.
I've build this code with allyesconfig for x86_64 and i386. I've runtested the
main part of the code on FRV and i386, though I can't test most of the drivers.
I've also done partial conversion for powerpc and MIPS - these at least compile
with minimal configurations.
This will affect all archs. Mostly the changes should be relatively easy.
Take do_IRQ(), store the regs pointer at the beginning, saving the old one:
struct pt_regs *old_regs = set_irq_regs(regs);
And put the old one back at the end:
set_irq_regs(old_regs);
Don't pass regs through to generic_handle_irq() or __do_IRQ().
In timer_interrupt(), this sort of change will be necessary:
- update_process_times(user_mode(regs));
- profile_tick(CPU_PROFILING, regs);
+ update_process_times(user_mode(get_irq_regs()));
+ profile_tick(CPU_PROFILING);
I'd like to move update_process_times()'s use of get_irq_regs() into itself,
except that i386, alone of the archs, uses something other than user_mode().
Some notes on the interrupt handling in the drivers:
(*) input_dev() is now gone entirely. The regs pointer is no longer stored in
the input_dev struct.
(*) finish_unlinks() in drivers/usb/host/ohci-q.c needs checking. It does
something different depending on whether it's been supplied with a regs
pointer or not.
(*) Various IRQ handler function pointers have been moved to type
irq_handler_t.
Signed-Off-By: David Howells <dhowells@redhat.com>
(cherry picked from 1b16e7ac850969f38b375e511e3fa2f474a33867 commit)
2006-10-05 13:55:46 +00:00
|
|
|
static irqreturn_t e1000_intr(int irq, void *data);
|
2008-03-21 18:06:25 +00:00
|
|
|
static bool e1000_clean_tx_irq(struct e1000_adapter *adapter,
|
|
|
|
struct e1000_tx_ring *tx_ring);
|
[NET]: Make NAPI polling independent of struct net_device objects.
Several devices have multiple independant RX queues per net
device, and some have a single interrupt doorbell for several
queues.
In either case, it's easier to support layouts like that if the
structure representing the poll is independant from the net
device itself.
The signature of the ->poll() call back goes from:
int foo_poll(struct net_device *dev, int *budget)
to
int foo_poll(struct napi_struct *napi, int budget)
The caller is returned the number of RX packets processed (or
the number of "NAPI credits" consumed if you want to get
abstract). The callee no longer messes around bumping
dev->quota, *budget, etc. because that is all handled in the
caller upon return.
The napi_struct is to be embedded in the device driver private data
structures.
Furthermore, it is the driver's responsibility to disable all NAPI
instances in it's ->stop() device close handler. Since the
napi_struct is privatized into the driver's private data structures,
only the driver knows how to get at all of the napi_struct instances
it may have per-device.
With lots of help and suggestions from Rusty Russell, Roland Dreier,
Michael Chan, Jeff Garzik, and Jamal Hadi Salim.
Bug fixes from Thomas Graf, Roland Dreier, Peter Zijlstra,
Joseph Fannin, Scott Wood, Hans J. Koch, and Michael Chan.
[ Ported to current tree and all drivers converted. Integrated
Stephen's follow-on kerneldoc additions, and restored poll_list
handling to the old style to fix mutual exclusion issues. -DaveM ]
Signed-off-by: Stephen Hemminger <shemminger@linux-foundation.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
2007-10-03 23:41:36 +00:00
|
|
|
static int e1000_clean(struct napi_struct *napi, int budget);
|
2008-03-21 18:06:25 +00:00
|
|
|
static bool e1000_clean_rx_irq(struct e1000_adapter *adapter,
|
|
|
|
struct e1000_rx_ring *rx_ring,
|
|
|
|
int *work_done, int work_to_do);
|
2009-07-06 10:44:39 +00:00
|
|
|
static bool e1000_clean_jumbo_rx_irq(struct e1000_adapter *adapter,
|
|
|
|
struct e1000_rx_ring *rx_ring,
|
|
|
|
int *work_done, int work_to_do);
|
2005-10-04 11:01:55 +00:00
|
|
|
static void e1000_alloc_rx_buffers(struct e1000_adapter *adapter,
|
2009-07-06 10:44:39 +00:00
|
|
|
struct e1000_rx_ring *rx_ring,
|
2006-01-13 00:51:19 +00:00
|
|
|
int cleaned_count);
|
2009-07-06 10:44:39 +00:00
|
|
|
static void e1000_alloc_jumbo_rx_buffers(struct e1000_adapter *adapter,
|
|
|
|
struct e1000_rx_ring *rx_ring,
|
|
|
|
int cleaned_count);
|
2005-04-16 22:20:36 +00:00
|
|
|
static int e1000_ioctl(struct net_device *netdev, struct ifreq *ifr, int cmd);
|
|
|
|
static int e1000_mii_ioctl(struct net_device *netdev, struct ifreq *ifr,
|
|
|
|
int cmd);
|
|
|
|
static void e1000_enter_82542_rst(struct e1000_adapter *adapter);
|
|
|
|
static void e1000_leave_82542_rst(struct e1000_adapter *adapter);
|
|
|
|
static void e1000_tx_timeout(struct net_device *dev);
|
2006-11-22 14:55:48 +00:00
|
|
|
static void e1000_reset_task(struct work_struct *work);
|
2005-04-16 22:20:36 +00:00
|
|
|
static void e1000_smartspeed(struct e1000_adapter *adapter);
|
2006-04-15 02:04:52 +00:00
|
|
|
static int e1000_82547_fifo_workaround(struct e1000_adapter *adapter,
|
|
|
|
struct sk_buff *skb);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2011-07-21 03:26:31 +00:00
|
|
|
static bool e1000_vlan_used(struct e1000_adapter *adapter);
|
2011-11-15 15:29:55 +00:00
|
|
|
static void e1000_vlan_mode(struct net_device *netdev,
|
|
|
|
netdev_features_t features);
|
2012-03-20 18:10:01 +00:00
|
|
|
static void e1000_vlan_filter_on_off(struct e1000_adapter *adapter,
|
|
|
|
bool filter_on);
|
2013-04-19 02:04:28 +00:00
|
|
|
static int e1000_vlan_rx_add_vid(struct net_device *netdev,
|
|
|
|
__be16 proto, u16 vid);
|
|
|
|
static int e1000_vlan_rx_kill_vid(struct net_device *netdev,
|
|
|
|
__be16 proto, u16 vid);
|
2005-04-16 22:20:36 +00:00
|
|
|
static void e1000_restore_vlan(struct e1000_adapter *adapter);
|
|
|
|
|
2006-06-27 16:06:36 +00:00
|
|
|
#ifdef CONFIG_PM
|
2009-04-15 17:43:24 +00:00
|
|
|
static int e1000_suspend(struct pci_dev *pdev, pm_message_t state);
|
2005-04-16 22:20:36 +00:00
|
|
|
static int e1000_resume(struct pci_dev *pdev);
|
|
|
|
#endif
|
2006-05-23 20:35:57 +00:00
|
|
|
static void e1000_shutdown(struct pci_dev *pdev);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
#ifdef CONFIG_NET_POLL_CONTROLLER
|
|
|
|
/* for netdump / net console */
|
|
|
|
static void e1000_netpoll (struct net_device *netdev);
|
|
|
|
#endif
|
|
|
|
|
2006-12-15 09:40:39 +00:00
|
|
|
#define COPYBREAK_DEFAULT 256
|
|
|
|
static unsigned int copybreak __read_mostly = COPYBREAK_DEFAULT;
|
|
|
|
module_param(copybreak, uint, 0644);
|
|
|
|
MODULE_PARM_DESC(copybreak,
|
|
|
|
"Maximum size of packet that is copied to a new buffer on receive");
|
|
|
|
|
2006-06-08 16:30:24 +00:00
|
|
|
static pci_ers_result_t e1000_io_error_detected(struct pci_dev *pdev,
|
|
|
|
pci_channel_state_t state);
|
|
|
|
static pci_ers_result_t e1000_io_slot_reset(struct pci_dev *pdev);
|
|
|
|
static void e1000_io_resume(struct pci_dev *pdev);
|
|
|
|
|
2012-09-07 16:33:15 +00:00
|
|
|
static const struct pci_error_handlers e1000_err_handler = {
|
2006-06-08 16:30:24 +00:00
|
|
|
.error_detected = e1000_io_error_detected,
|
|
|
|
.slot_reset = e1000_io_slot_reset,
|
|
|
|
.resume = e1000_io_resume,
|
|
|
|
};
|
2005-10-04 11:03:23 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
static struct pci_driver e1000_driver = {
|
|
|
|
.name = e1000_driver_name,
|
|
|
|
.id_table = e1000_pci_tbl,
|
|
|
|
.probe = e1000_probe,
|
2012-12-03 14:24:25 +00:00
|
|
|
.remove = e1000_remove,
|
2006-09-27 19:53:19 +00:00
|
|
|
#ifdef CONFIG_PM
|
2011-03-31 01:57:33 +00:00
|
|
|
/* Power Management Hooks */
|
2005-04-16 22:20:36 +00:00
|
|
|
.suspend = e1000_suspend,
|
2006-05-23 20:35:57 +00:00
|
|
|
.resume = e1000_resume,
|
2005-04-16 22:20:36 +00:00
|
|
|
#endif
|
2006-06-08 16:30:24 +00:00
|
|
|
.shutdown = e1000_shutdown,
|
|
|
|
.err_handler = &e1000_err_handler
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
MODULE_AUTHOR("Intel Corporation, <linux.nics@intel.com>");
|
|
|
|
MODULE_DESCRIPTION("Intel(R) PRO/1000 Network Driver");
|
|
|
|
MODULE_LICENSE("GPL");
|
|
|
|
MODULE_VERSION(DRV_VERSION);
|
|
|
|
|
2012-03-13 06:04:20 +00:00
|
|
|
#define DEFAULT_MSG_ENABLE (NETIF_MSG_DRV|NETIF_MSG_PROBE|NETIF_MSG_LINK)
|
|
|
|
static int debug = -1;
|
2005-04-16 22:20:36 +00:00
|
|
|
module_param(debug, int, 0);
|
|
|
|
MODULE_PARM_DESC(debug, "Debug level (0=none,...,16=all)");
|
|
|
|
|
2010-04-27 14:02:58 +00:00
|
|
|
/**
|
|
|
|
* e1000_get_hw_dev - return device
|
|
|
|
* used by hardware layer to print debugging information
|
|
|
|
*
|
|
|
|
**/
|
|
|
|
struct net_device *e1000_get_hw_dev(struct e1000_hw *hw)
|
|
|
|
{
|
|
|
|
struct e1000_adapter *adapter = hw->back;
|
|
|
|
return adapter->netdev;
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/**
|
|
|
|
* e1000_init_module - Driver Registration Routine
|
|
|
|
*
|
|
|
|
* e1000_init_module is the first routine called when the driver is
|
|
|
|
* loaded. All it does is register with the PCI subsystem.
|
|
|
|
**/
|
2008-07-11 22:17:02 +00:00
|
|
|
static int __init e1000_init_module(void)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
int ret;
|
2010-04-27 14:02:58 +00:00
|
|
|
pr_info("%s - version %s\n", e1000_driver_string, e1000_driver_version);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2010-04-27 14:02:58 +00:00
|
|
|
pr_info("%s\n", e1000_copyright);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-08-19 21:48:59 +00:00
|
|
|
ret = pci_register_driver(&e1000_driver);
|
2006-12-15 09:40:39 +00:00
|
|
|
if (copybreak != COPYBREAK_DEFAULT) {
|
|
|
|
if (copybreak == 0)
|
2010-04-27 14:02:58 +00:00
|
|
|
pr_info("copybreak disabled\n");
|
2006-12-15 09:40:39 +00:00
|
|
|
else
|
2010-04-27 14:02:58 +00:00
|
|
|
pr_info("copybreak enabled for "
|
|
|
|
"packets <= %u bytes\n", copybreak);
|
2006-12-15 09:40:39 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
module_init(e1000_init_module);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* e1000_exit_module - Driver Exit Cleanup Routine
|
|
|
|
*
|
|
|
|
* e1000_exit_module is called just before the driver is removed
|
|
|
|
* from memory.
|
|
|
|
**/
|
2008-07-11 22:17:02 +00:00
|
|
|
static void __exit e1000_exit_module(void)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
pci_unregister_driver(&e1000_driver);
|
|
|
|
}
|
|
|
|
|
|
|
|
module_exit(e1000_exit_module);
|
|
|
|
|
2006-06-27 16:06:28 +00:00
|
|
|
static int e1000_request_irq(struct e1000_adapter *adapter)
|
|
|
|
{
|
|
|
|
struct net_device *netdev = adapter->netdev;
|
2007-12-11 19:49:39 +00:00
|
|
|
irq_handler_t handler = e1000_intr;
|
2007-05-16 08:49:46 +00:00
|
|
|
int irq_flags = IRQF_SHARED;
|
|
|
|
int err;
|
2006-06-27 16:06:28 +00:00
|
|
|
|
2007-05-16 08:49:46 +00:00
|
|
|
err = request_irq(adapter->pdev->irq, handler, irq_flags, netdev->name,
|
|
|
|
netdev);
|
|
|
|
if (err) {
|
2010-07-27 06:37:21 +00:00
|
|
|
e_err(probe, "Unable to allocate interrupt Error: %d\n", err);
|
2007-05-16 08:49:46 +00:00
|
|
|
}
|
2006-06-27 16:06:28 +00:00
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void e1000_free_irq(struct e1000_adapter *adapter)
|
|
|
|
{
|
|
|
|
struct net_device *netdev = adapter->netdev;
|
|
|
|
|
|
|
|
free_irq(adapter->pdev->irq, netdev);
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/**
|
|
|
|
* e1000_irq_disable - Mask off interrupt generation on the NIC
|
|
|
|
* @adapter: board private structure
|
|
|
|
**/
|
2008-07-11 22:17:02 +00:00
|
|
|
static void e1000_irq_disable(struct e1000_adapter *adapter)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2008-07-11 22:17:08 +00:00
|
|
|
struct e1000_hw *hw = &adapter->hw;
|
|
|
|
|
|
|
|
ew32(IMC, ~0);
|
|
|
|
E1000_WRITE_FLUSH();
|
2005-04-16 22:20:36 +00:00
|
|
|
synchronize_irq(adapter->pdev->irq);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* e1000_irq_enable - Enable default interrupt generation settings
|
|
|
|
* @adapter: board private structure
|
|
|
|
**/
|
2008-07-11 22:17:02 +00:00
|
|
|
static void e1000_irq_enable(struct e1000_adapter *adapter)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2008-07-11 22:17:08 +00:00
|
|
|
struct e1000_hw *hw = &adapter->hw;
|
|
|
|
|
|
|
|
ew32(IMS, IMS_ENABLE_MASK);
|
|
|
|
E1000_WRITE_FLUSH();
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2005-10-30 15:53:34 +00:00
|
|
|
|
2008-07-11 22:17:02 +00:00
|
|
|
static void e1000_update_mng_vlan(struct e1000_adapter *adapter)
|
2005-04-29 02:43:52 +00:00
|
|
|
{
|
2008-07-11 22:17:08 +00:00
|
|
|
struct e1000_hw *hw = &adapter->hw;
|
2005-04-29 02:43:52 +00:00
|
|
|
struct net_device *netdev = adapter->netdev;
|
2008-07-11 22:17:08 +00:00
|
|
|
u16 vid = hw->mng_cookie.vlan_id;
|
2008-04-03 17:06:32 +00:00
|
|
|
u16 old_vid = adapter->mng_vlan_id;
|
2006-01-18 21:01:39 +00:00
|
|
|
|
2011-07-21 03:26:31 +00:00
|
|
|
if (!e1000_vlan_used(adapter))
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (!test_bit(vid, adapter->active_vlans)) {
|
|
|
|
if (hw->mng_cookie.status &
|
|
|
|
E1000_MNG_DHCP_COOKIE_STATUS_VLAN_SUPPORT) {
|
2013-04-19 02:04:28 +00:00
|
|
|
e1000_vlan_rx_add_vid(netdev, htons(ETH_P_8021Q), vid);
|
2006-03-03 02:17:55 +00:00
|
|
|
adapter->mng_vlan_id = vid;
|
2011-07-21 03:26:31 +00:00
|
|
|
} else {
|
|
|
|
adapter->mng_vlan_id = E1000_MNG_VLAN_NONE;
|
|
|
|
}
|
|
|
|
if ((old_vid != (u16)E1000_MNG_VLAN_NONE) &&
|
|
|
|
(vid != old_vid) &&
|
|
|
|
!test_bit(old_vid, adapter->active_vlans))
|
2013-04-19 02:04:28 +00:00
|
|
|
e1000_vlan_rx_kill_vid(netdev, htons(ETH_P_8021Q),
|
|
|
|
old_vid);
|
2011-07-21 03:26:31 +00:00
|
|
|
} else {
|
|
|
|
adapter->mng_vlan_id = vid;
|
2005-04-29 02:43:52 +00:00
|
|
|
}
|
|
|
|
}
|
2006-01-13 00:50:30 +00:00
|
|
|
|
2008-07-11 22:17:02 +00:00
|
|
|
static void e1000_init_manageability(struct e1000_adapter *adapter)
|
2006-12-15 15:56:10 +00:00
|
|
|
{
|
2008-07-11 22:17:08 +00:00
|
|
|
struct e1000_hw *hw = &adapter->hw;
|
|
|
|
|
2006-12-15 15:56:10 +00:00
|
|
|
if (adapter->en_mng_pt) {
|
2008-07-11 22:17:08 +00:00
|
|
|
u32 manc = er32(MANC);
|
2006-12-15 15:56:10 +00:00
|
|
|
|
|
|
|
/* disable hardware interception of ARP */
|
|
|
|
manc &= ~(E1000_MANC_ARP_EN);
|
|
|
|
|
2008-07-11 22:17:08 +00:00
|
|
|
ew32(MANC, manc);
|
2006-12-15 15:56:10 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-07-11 22:17:02 +00:00
|
|
|
static void e1000_release_manageability(struct e1000_adapter *adapter)
|
2006-12-15 15:56:10 +00:00
|
|
|
{
|
2008-07-11 22:17:08 +00:00
|
|
|
struct e1000_hw *hw = &adapter->hw;
|
|
|
|
|
2006-12-15 15:56:10 +00:00
|
|
|
if (adapter->en_mng_pt) {
|
2008-07-11 22:17:08 +00:00
|
|
|
u32 manc = er32(MANC);
|
2006-12-15 15:56:10 +00:00
|
|
|
|
|
|
|
/* re-enable hardware interception of ARP */
|
|
|
|
manc |= E1000_MANC_ARP_EN;
|
|
|
|
|
2008-07-11 22:17:08 +00:00
|
|
|
ew32(MANC, manc);
|
2006-12-15 15:56:10 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-03-06 16:57:21 +00:00
|
|
|
/**
|
|
|
|
* e1000_configure - configure the hardware for RX and TX
|
|
|
|
* @adapter = private board structure
|
|
|
|
**/
|
|
|
|
static void e1000_configure(struct e1000_adapter *adapter)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct net_device *netdev = adapter->netdev;
|
2006-06-27 16:06:28 +00:00
|
|
|
int i;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-11-14 04:54:59 +00:00
|
|
|
e1000_set_rx_mode(netdev);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
e1000_restore_vlan(adapter);
|
2006-12-15 15:56:10 +00:00
|
|
|
e1000_init_manageability(adapter);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
e1000_configure_tx(adapter);
|
|
|
|
e1000_setup_rctl(adapter);
|
|
|
|
e1000_configure_rx(adapter);
|
2006-01-13 00:51:19 +00:00
|
|
|
/* call E1000_DESC_UNUSED which always leaves
|
|
|
|
* at least 1 descriptor unused to make sure
|
2013-02-09 12:49:21 +00:00
|
|
|
* next_to_use != next_to_clean
|
|
|
|
*/
|
2006-01-13 00:50:39 +00:00
|
|
|
for (i = 0; i < adapter->num_rx_queues; i++) {
|
2006-01-13 00:51:19 +00:00
|
|
|
struct e1000_rx_ring *ring = &adapter->rx_ring[i];
|
2006-01-13 00:51:30 +00:00
|
|
|
adapter->alloc_rx_buf(adapter, ring,
|
2013-02-09 12:49:21 +00:00
|
|
|
E1000_DESC_UNUSED(ring));
|
2006-01-13 00:50:39 +00:00
|
|
|
}
|
2007-03-06 16:57:21 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int e1000_up(struct e1000_adapter *adapter)
|
|
|
|
{
|
2008-07-11 22:17:08 +00:00
|
|
|
struct e1000_hw *hw = &adapter->hw;
|
|
|
|
|
2007-03-06 16:57:21 +00:00
|
|
|
/* hardware has been reset, we need to reload some things */
|
|
|
|
e1000_configure(adapter);
|
|
|
|
|
|
|
|
clear_bit(__E1000_DOWN, &adapter->flags);
|
2006-01-13 00:50:41 +00:00
|
|
|
|
[NET]: Make NAPI polling independent of struct net_device objects.
Several devices have multiple independant RX queues per net
device, and some have a single interrupt doorbell for several
queues.
In either case, it's easier to support layouts like that if the
structure representing the poll is independant from the net
device itself.
The signature of the ->poll() call back goes from:
int foo_poll(struct net_device *dev, int *budget)
to
int foo_poll(struct napi_struct *napi, int budget)
The caller is returned the number of RX packets processed (or
the number of "NAPI credits" consumed if you want to get
abstract). The callee no longer messes around bumping
dev->quota, *budget, etc. because that is all handled in the
caller upon return.
The napi_struct is to be embedded in the device driver private data
structures.
Furthermore, it is the driver's responsibility to disable all NAPI
instances in it's ->stop() device close handler. Since the
napi_struct is privatized into the driver's private data structures,
only the driver knows how to get at all of the napi_struct instances
it may have per-device.
With lots of help and suggestions from Rusty Russell, Roland Dreier,
Michael Chan, Jeff Garzik, and Jamal Hadi Salim.
Bug fixes from Thomas Graf, Roland Dreier, Peter Zijlstra,
Joseph Fannin, Scott Wood, Hans J. Koch, and Michael Chan.
[ Ported to current tree and all drivers converted. Integrated
Stephen's follow-on kerneldoc additions, and restored poll_list
handling to the old style to fix mutual exclusion issues. -DaveM ]
Signed-off-by: Stephen Hemminger <shemminger@linux-foundation.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
2007-10-03 23:41:36 +00:00
|
|
|
napi_enable(&adapter->napi);
|
2008-07-11 22:17:38 +00:00
|
|
|
|
2005-04-29 02:39:30 +00:00
|
|
|
e1000_irq_enable(adapter);
|
|
|
|
|
2009-04-21 18:42:05 +00:00
|
|
|
netif_wake_queue(adapter->netdev);
|
|
|
|
|
2006-12-15 09:42:34 +00:00
|
|
|
/* fire a link change interrupt to start the watchdog */
|
2008-07-11 22:17:08 +00:00
|
|
|
ew32(ICS, E1000_ICS_LSC);
|
2005-04-16 22:20:36 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-06-27 16:06:32 +00:00
|
|
|
/**
|
|
|
|
* e1000_power_up_phy - restore link in case the phy was powered down
|
|
|
|
* @adapter: address of board private structure
|
|
|
|
*
|
|
|
|
* The phy may be powered down to save power and turn off link when the
|
|
|
|
* driver is unloaded and wake on lan is not enabled (among others)
|
|
|
|
* *** this routine MUST be followed by a call to e1000_reset ***
|
|
|
|
**/
|
2006-08-16 20:31:33 +00:00
|
|
|
void e1000_power_up_phy(struct e1000_adapter *adapter)
|
2006-06-27 16:06:32 +00:00
|
|
|
{
|
2008-07-11 22:17:08 +00:00
|
|
|
struct e1000_hw *hw = &adapter->hw;
|
2008-04-03 17:06:32 +00:00
|
|
|
u16 mii_reg = 0;
|
2006-06-27 16:06:32 +00:00
|
|
|
|
|
|
|
/* Just clear the power down bit to wake the phy back up */
|
2008-07-11 22:17:08 +00:00
|
|
|
if (hw->media_type == e1000_media_type_copper) {
|
2006-06-27 16:06:32 +00:00
|
|
|
/* according to the manual, the phy will retain its
|
2013-02-09 12:49:21 +00:00
|
|
|
* settings across a power-down/up cycle
|
|
|
|
*/
|
2008-07-11 22:17:08 +00:00
|
|
|
e1000_read_phy_reg(hw, PHY_CTRL, &mii_reg);
|
2006-06-27 16:06:32 +00:00
|
|
|
mii_reg &= ~MII_CR_POWER_DOWN;
|
2008-07-11 22:17:08 +00:00
|
|
|
e1000_write_phy_reg(hw, PHY_CTRL, mii_reg);
|
2006-06-27 16:06:32 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void e1000_power_down_phy(struct e1000_adapter *adapter)
|
|
|
|
{
|
2008-07-11 22:17:08 +00:00
|
|
|
struct e1000_hw *hw = &adapter->hw;
|
|
|
|
|
2006-09-27 19:53:54 +00:00
|
|
|
/* Power down the PHY so no link is implied when interface is down *
|
2008-03-21 18:06:25 +00:00
|
|
|
* The PHY cannot be powered down if any of the following is true *
|
2006-06-27 16:06:32 +00:00
|
|
|
* (a) WoL is enabled
|
|
|
|
* (b) AMT is active
|
2013-02-09 12:49:21 +00:00
|
|
|
* (c) SoL/IDER session is active
|
|
|
|
*/
|
2008-07-11 22:17:08 +00:00
|
|
|
if (!adapter->wol && hw->mac_type >= e1000_82540 &&
|
|
|
|
hw->media_type == e1000_media_type_copper) {
|
2008-04-03 17:06:32 +00:00
|
|
|
u16 mii_reg = 0;
|
2006-09-27 19:53:54 +00:00
|
|
|
|
2008-07-11 22:17:08 +00:00
|
|
|
switch (hw->mac_type) {
|
2006-09-27 19:53:54 +00:00
|
|
|
case e1000_82540:
|
|
|
|
case e1000_82545:
|
|
|
|
case e1000_82545_rev_3:
|
|
|
|
case e1000_82546:
|
2011-01-06 14:29:54 +00:00
|
|
|
case e1000_ce4100:
|
2006-09-27 19:53:54 +00:00
|
|
|
case e1000_82546_rev_3:
|
|
|
|
case e1000_82541:
|
|
|
|
case e1000_82541_rev_2:
|
|
|
|
case e1000_82547:
|
|
|
|
case e1000_82547_rev_2:
|
2008-07-11 22:17:08 +00:00
|
|
|
if (er32(MANC) & E1000_MANC_SMBUS_EN)
|
2006-09-27 19:53:54 +00:00
|
|
|
goto out;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
goto out;
|
|
|
|
}
|
2008-07-11 22:17:08 +00:00
|
|
|
e1000_read_phy_reg(hw, PHY_CTRL, &mii_reg);
|
2006-06-27 16:06:32 +00:00
|
|
|
mii_reg |= MII_CR_POWER_DOWN;
|
2008-07-11 22:17:08 +00:00
|
|
|
e1000_write_phy_reg(hw, PHY_CTRL, mii_reg);
|
2011-10-05 07:24:46 +00:00
|
|
|
msleep(1);
|
2006-06-27 16:06:32 +00:00
|
|
|
}
|
2006-09-27 19:53:54 +00:00
|
|
|
out:
|
|
|
|
return;
|
2006-06-27 16:06:32 +00:00
|
|
|
}
|
|
|
|
|
2011-10-05 07:24:41 +00:00
|
|
|
static void e1000_down_and_stop(struct e1000_adapter *adapter)
|
|
|
|
{
|
|
|
|
set_bit(__E1000_DOWN, &adapter->flags);
|
2012-05-17 01:04:50 +00:00
|
|
|
|
|
|
|
/* Only kill reset task if adapter is not resetting */
|
|
|
|
if (!test_bit(__E1000_RESETTING, &adapter->flags))
|
|
|
|
cancel_work_sync(&adapter->reset_task);
|
|
|
|
|
2011-10-05 07:24:41 +00:00
|
|
|
cancel_delayed_work_sync(&adapter->watchdog_task);
|
|
|
|
cancel_delayed_work_sync(&adapter->phy_info_task);
|
|
|
|
cancel_delayed_work_sync(&adapter->fifo_stall_task);
|
|
|
|
}
|
|
|
|
|
2008-07-11 22:17:02 +00:00
|
|
|
void e1000_down(struct e1000_adapter *adapter)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2009-03-25 21:59:22 +00:00
|
|
|
struct e1000_hw *hw = &adapter->hw;
|
2005-04-16 22:20:36 +00:00
|
|
|
struct net_device *netdev = adapter->netdev;
|
2009-03-25 21:59:22 +00:00
|
|
|
u32 rctl, tctl;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-09-27 19:54:02 +00:00
|
|
|
|
2009-03-25 21:59:22 +00:00
|
|
|
/* disable receives in the hardware */
|
|
|
|
rctl = er32(RCTL);
|
|
|
|
ew32(RCTL, rctl & ~E1000_RCTL_EN);
|
|
|
|
/* flush and sleep below */
|
|
|
|
|
2009-09-25 12:17:01 +00:00
|
|
|
netif_tx_disable(netdev);
|
2009-03-25 21:59:22 +00:00
|
|
|
|
|
|
|
/* disable transmits in the hardware */
|
|
|
|
tctl = er32(TCTL);
|
|
|
|
tctl &= ~E1000_TCTL_EN;
|
|
|
|
ew32(TCTL, tctl);
|
|
|
|
/* flush both disables and wait for them to finish */
|
|
|
|
E1000_WRITE_FLUSH();
|
|
|
|
msleep(10);
|
|
|
|
|
[NET]: Make NAPI polling independent of struct net_device objects.
Several devices have multiple independant RX queues per net
device, and some have a single interrupt doorbell for several
queues.
In either case, it's easier to support layouts like that if the
structure representing the poll is independant from the net
device itself.
The signature of the ->poll() call back goes from:
int foo_poll(struct net_device *dev, int *budget)
to
int foo_poll(struct napi_struct *napi, int budget)
The caller is returned the number of RX packets processed (or
the number of "NAPI credits" consumed if you want to get
abstract). The callee no longer messes around bumping
dev->quota, *budget, etc. because that is all handled in the
caller upon return.
The napi_struct is to be embedded in the device driver private data
structures.
Furthermore, it is the driver's responsibility to disable all NAPI
instances in it's ->stop() device close handler. Since the
napi_struct is privatized into the driver's private data structures,
only the driver knows how to get at all of the napi_struct instances
it may have per-device.
With lots of help and suggestions from Rusty Russell, Roland Dreier,
Michael Chan, Jeff Garzik, and Jamal Hadi Salim.
Bug fixes from Thomas Graf, Roland Dreier, Peter Zijlstra,
Joseph Fannin, Scott Wood, Hans J. Koch, and Michael Chan.
[ Ported to current tree and all drivers converted. Integrated
Stephen's follow-on kerneldoc additions, and restored poll_list
handling to the old style to fix mutual exclusion issues. -DaveM ]
Signed-off-by: Stephen Hemminger <shemminger@linux-foundation.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
2007-10-03 23:41:36 +00:00
|
|
|
napi_disable(&adapter->napi);
|
2008-07-11 22:17:38 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
e1000_irq_disable(adapter);
|
2006-03-03 02:16:38 +00:00
|
|
|
|
2013-02-09 12:49:21 +00:00
|
|
|
/* Setting DOWN must be after irq_disable to prevent
|
2010-11-21 17:54:21 +00:00
|
|
|
* a screaming interrupt. Setting DOWN also prevents
|
2011-10-05 07:24:41 +00:00
|
|
|
* tasks from rescheduling.
|
2010-11-21 17:54:21 +00:00
|
|
|
*/
|
2011-10-05 07:24:41 +00:00
|
|
|
e1000_down_and_stop(adapter);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
adapter->link_speed = 0;
|
|
|
|
adapter->link_duplex = 0;
|
|
|
|
netif_carrier_off(netdev);
|
|
|
|
|
|
|
|
e1000_reset(adapter);
|
2005-10-04 11:01:55 +00:00
|
|
|
e1000_clean_all_tx_rings(adapter);
|
|
|
|
e1000_clean_all_rx_rings(adapter);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2010-10-21 07:50:57 +00:00
|
|
|
static void e1000_reinit_safe(struct e1000_adapter *adapter)
|
2010-09-22 18:22:42 +00:00
|
|
|
{
|
|
|
|
while (test_and_set_bit(__E1000_RESETTING, &adapter->flags))
|
|
|
|
msleep(1);
|
2011-10-05 07:24:51 +00:00
|
|
|
mutex_lock(&adapter->mutex);
|
2010-09-22 18:22:42 +00:00
|
|
|
e1000_down(adapter);
|
|
|
|
e1000_up(adapter);
|
2011-10-05 07:24:51 +00:00
|
|
|
mutex_unlock(&adapter->mutex);
|
2010-09-22 18:22:42 +00:00
|
|
|
clear_bit(__E1000_RESETTING, &adapter->flags);
|
|
|
|
}
|
|
|
|
|
2008-07-11 22:17:02 +00:00
|
|
|
void e1000_reinit_locked(struct e1000_adapter *adapter)
|
2006-06-27 16:06:28 +00:00
|
|
|
{
|
2010-09-22 18:22:42 +00:00
|
|
|
/* if rtnl_lock is not held the call path is bogus */
|
|
|
|
ASSERT_RTNL();
|
2006-06-27 16:06:28 +00:00
|
|
|
WARN_ON(in_interrupt());
|
|
|
|
while (test_and_set_bit(__E1000_RESETTING, &adapter->flags))
|
|
|
|
msleep(1);
|
|
|
|
e1000_down(adapter);
|
|
|
|
e1000_up(adapter);
|
|
|
|
clear_bit(__E1000_RESETTING, &adapter->flags);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2008-07-11 22:17:02 +00:00
|
|
|
void e1000_reset(struct e1000_adapter *adapter)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2008-07-11 22:17:08 +00:00
|
|
|
struct e1000_hw *hw = &adapter->hw;
|
2008-04-03 17:06:32 +00:00
|
|
|
u32 pba = 0, tx_space, min_tx_space, min_rx_space;
|
2008-03-21 18:06:25 +00:00
|
|
|
bool legacy_pba_adjust = false;
|
2009-07-06 10:45:01 +00:00
|
|
|
u16 hwm;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* Repartition Pba for greater than 9k mtu
|
|
|
|
* To take effect CTRL.RST is required.
|
|
|
|
*/
|
|
|
|
|
2008-07-11 22:17:08 +00:00
|
|
|
switch (hw->mac_type) {
|
2006-12-15 09:39:45 +00:00
|
|
|
case e1000_82542_rev2_0:
|
|
|
|
case e1000_82542_rev2_1:
|
|
|
|
case e1000_82543:
|
|
|
|
case e1000_82544:
|
|
|
|
case e1000_82540:
|
|
|
|
case e1000_82541:
|
|
|
|
case e1000_82541_rev_2:
|
2008-03-21 18:06:25 +00:00
|
|
|
legacy_pba_adjust = true;
|
2006-12-15 09:39:45 +00:00
|
|
|
pba = E1000_PBA_48K;
|
|
|
|
break;
|
|
|
|
case e1000_82545:
|
|
|
|
case e1000_82545_rev_3:
|
|
|
|
case e1000_82546:
|
2011-01-06 14:29:54 +00:00
|
|
|
case e1000_ce4100:
|
2006-12-15 09:39:45 +00:00
|
|
|
case e1000_82546_rev_3:
|
|
|
|
pba = E1000_PBA_48K;
|
|
|
|
break;
|
2005-04-29 02:43:52 +00:00
|
|
|
case e1000_82547:
|
2005-04-29 02:44:14 +00:00
|
|
|
case e1000_82547_rev_2:
|
2008-03-21 18:06:25 +00:00
|
|
|
legacy_pba_adjust = true;
|
2005-04-29 02:43:52 +00:00
|
|
|
pba = E1000_PBA_30K;
|
|
|
|
break;
|
2006-12-15 09:39:45 +00:00
|
|
|
case e1000_undefined:
|
|
|
|
case e1000_num_macs:
|
2005-04-29 02:43:52 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2008-03-21 18:06:25 +00:00
|
|
|
if (legacy_pba_adjust) {
|
2009-07-06 10:45:01 +00:00
|
|
|
if (hw->max_frame_size > E1000_RXBUFFER_8192)
|
2006-12-15 09:39:45 +00:00
|
|
|
pba -= 8; /* allocate more FIFO for Tx */
|
2005-04-29 02:43:52 +00:00
|
|
|
|
2008-07-11 22:17:08 +00:00
|
|
|
if (hw->mac_type == e1000_82547) {
|
2006-12-15 09:39:45 +00:00
|
|
|
adapter->tx_fifo_head = 0;
|
|
|
|
adapter->tx_head_addr = pba << E1000_TX_HEAD_ADDR_SHIFT;
|
|
|
|
adapter->tx_fifo_size =
|
|
|
|
(E1000_PBA_40K - pba) << E1000_PBA_BYTES_SHIFT;
|
|
|
|
atomic_set(&adapter->tx_fifo_stall, 0);
|
|
|
|
}
|
2009-07-06 10:45:01 +00:00
|
|
|
} else if (hw->max_frame_size > ETH_FRAME_LEN + ETH_FCS_LEN) {
|
2006-12-15 09:39:45 +00:00
|
|
|
/* adjust PBA for jumbo frames */
|
2008-07-11 22:17:08 +00:00
|
|
|
ew32(PBA, pba);
|
2006-12-15 09:39:45 +00:00
|
|
|
|
|
|
|
/* To maintain wire speed transmits, the Tx FIFO should be
|
2009-07-06 10:45:01 +00:00
|
|
|
* large enough to accommodate two full transmit packets,
|
2006-12-15 09:39:45 +00:00
|
|
|
* rounded up to the next 1KB and expressed in KB. Likewise,
|
2009-07-06 10:45:01 +00:00
|
|
|
* the Rx FIFO should be large enough to accommodate at least
|
2006-12-15 09:39:45 +00:00
|
|
|
* one full receive packet and is similarly rounded up and
|
2013-02-09 12:49:21 +00:00
|
|
|
* expressed in KB.
|
|
|
|
*/
|
2008-07-11 22:17:08 +00:00
|
|
|
pba = er32(PBA);
|
2006-12-15 09:39:45 +00:00
|
|
|
/* upper 16 bits has Tx packet buffer allocation size in KB */
|
|
|
|
tx_space = pba >> 16;
|
|
|
|
/* lower 16 bits has Rx packet buffer allocation size in KB */
|
|
|
|
pba &= 0xffff;
|
2013-02-09 12:49:21 +00:00
|
|
|
/* the Tx fifo also stores 16 bytes of information about the Tx
|
2009-07-06 10:45:01 +00:00
|
|
|
* but don't include ethernet FCS because hardware appends it
|
|
|
|
*/
|
|
|
|
min_tx_space = (hw->max_frame_size +
|
|
|
|
sizeof(struct e1000_tx_desc) -
|
|
|
|
ETH_FCS_LEN) * 2;
|
2007-04-27 20:55:29 +00:00
|
|
|
min_tx_space = ALIGN(min_tx_space, 1024);
|
2006-12-15 09:39:45 +00:00
|
|
|
min_tx_space >>= 10;
|
2009-07-06 10:45:01 +00:00
|
|
|
/* software strips receive CRC, so leave room for it */
|
|
|
|
min_rx_space = hw->max_frame_size;
|
2007-04-27 20:55:29 +00:00
|
|
|
min_rx_space = ALIGN(min_rx_space, 1024);
|
2006-12-15 09:39:45 +00:00
|
|
|
min_rx_space >>= 10;
|
|
|
|
|
|
|
|
/* If current Tx allocation is less than the min Tx FIFO size,
|
|
|
|
* and the min Tx FIFO size is less than the current Rx FIFO
|
2013-02-09 12:49:21 +00:00
|
|
|
* allocation, take space away from current Rx allocation
|
|
|
|
*/
|
2006-12-15 09:39:45 +00:00
|
|
|
if (tx_space < min_tx_space &&
|
|
|
|
((min_tx_space - tx_space) < pba)) {
|
|
|
|
pba = pba - (min_tx_space - tx_space);
|
|
|
|
|
|
|
|
/* PCI/PCIx hardware has PBA alignment constraints */
|
2008-07-11 22:17:08 +00:00
|
|
|
switch (hw->mac_type) {
|
2006-12-15 09:39:45 +00:00
|
|
|
case e1000_82545 ... e1000_82546_rev_3:
|
|
|
|
pba &= ~(E1000_PBA_8K - 1);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2013-02-09 12:49:21 +00:00
|
|
|
/* if short on Rx space, Rx wins and must trump Tx
|
|
|
|
* adjustment or use Early Receive if available
|
|
|
|
*/
|
2009-09-25 12:16:14 +00:00
|
|
|
if (pba < min_rx_space)
|
|
|
|
pba = min_rx_space;
|
2006-12-15 09:39:45 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2005-04-29 02:43:52 +00:00
|
|
|
|
2008-07-11 22:17:08 +00:00
|
|
|
ew32(PBA, pba);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2013-02-09 12:49:21 +00:00
|
|
|
/* flow control settings:
|
2009-07-06 10:45:01 +00:00
|
|
|
* The high water mark must be low enough to fit one full frame
|
|
|
|
* (or the size used for early receive) above it in the Rx FIFO.
|
|
|
|
* Set it to the lower of:
|
|
|
|
* - 90% of the Rx FIFO size, and
|
|
|
|
* - the full Rx FIFO size minus the early receive size (for parts
|
|
|
|
* with ERT support assuming ERT set to E1000_ERT_2048), or
|
|
|
|
* - the full Rx FIFO size minus one full frame
|
|
|
|
*/
|
|
|
|
hwm = min(((pba << 10) * 9 / 10),
|
|
|
|
((pba << 10) - hw->max_frame_size));
|
|
|
|
|
|
|
|
hw->fc_high_water = hwm & 0xFFF8; /* 8-byte granularity */
|
|
|
|
hw->fc_low_water = hw->fc_high_water - 8;
|
2009-07-06 10:44:39 +00:00
|
|
|
hw->fc_pause_time = E1000_FC_PAUSE_TIME;
|
2008-07-11 22:17:08 +00:00
|
|
|
hw->fc_send_xon = 1;
|
|
|
|
hw->fc = hw->original_fc;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2005-04-29 02:43:52 +00:00
|
|
|
/* Allow time for pending master requests to run */
|
2008-07-11 22:17:08 +00:00
|
|
|
e1000_reset_hw(hw);
|
|
|
|
if (hw->mac_type >= e1000_82544)
|
|
|
|
ew32(WUC, 0);
|
2006-09-27 19:53:51 +00:00
|
|
|
|
2008-07-11 22:17:08 +00:00
|
|
|
if (e1000_init_hw(hw))
|
2010-07-27 06:37:21 +00:00
|
|
|
e_dev_err("Hardware Error\n");
|
2005-04-29 02:43:52 +00:00
|
|
|
e1000_update_mng_vlan(adapter);
|
2006-12-15 09:33:46 +00:00
|
|
|
|
|
|
|
/* if (adapter->hwflags & HWFLAGS_PHY_PWR_BIT) { */
|
2008-07-11 22:17:08 +00:00
|
|
|
if (hw->mac_type >= e1000_82544 &&
|
|
|
|
hw->autoneg == 1 &&
|
|
|
|
hw->autoneg_advertised == ADVERTISE_1000_FULL) {
|
|
|
|
u32 ctrl = er32(CTRL);
|
2006-12-15 09:33:46 +00:00
|
|
|
/* clear phy power management bit if we are in gig only mode,
|
|
|
|
* which if enabled will attempt negotiation to 100Mb, which
|
2013-02-09 12:49:21 +00:00
|
|
|
* can cause a loss of link at power off or driver unload
|
|
|
|
*/
|
2006-12-15 09:33:46 +00:00
|
|
|
ctrl &= ~E1000_CTRL_SWDPIN3;
|
2008-07-11 22:17:08 +00:00
|
|
|
ew32(CTRL, ctrl);
|
2006-12-15 09:33:46 +00:00
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* Enable h/w to recognize an 802.1Q VLAN Ethernet packet */
|
2008-07-11 22:17:08 +00:00
|
|
|
ew32(VET, ETHERNET_IEEE_VLAN_TYPE);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-07-11 22:17:08 +00:00
|
|
|
e1000_reset_adaptive(hw);
|
|
|
|
e1000_phy_get_info(hw, &adapter->phy_info);
|
2006-06-27 16:06:45 +00:00
|
|
|
|
2006-12-15 15:56:10 +00:00
|
|
|
e1000_release_manageability(adapter);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2012-07-10 10:56:59 +00:00
|
|
|
/* Dump the eeprom for users having checksum issues */
|
2008-02-01 16:21:28 +00:00
|
|
|
static void e1000_dump_eeprom(struct e1000_adapter *adapter)
|
2007-12-17 21:50:23 +00:00
|
|
|
{
|
|
|
|
struct net_device *netdev = adapter->netdev;
|
|
|
|
struct ethtool_eeprom eeprom;
|
|
|
|
const struct ethtool_ops *ops = netdev->ethtool_ops;
|
|
|
|
u8 *data;
|
|
|
|
int i;
|
|
|
|
u16 csum_old, csum_new = 0;
|
|
|
|
|
|
|
|
eeprom.len = ops->get_eeprom_len(netdev);
|
|
|
|
eeprom.offset = 0;
|
|
|
|
|
|
|
|
data = kmalloc(eeprom.len, GFP_KERNEL);
|
2012-01-29 12:56:23 +00:00
|
|
|
if (!data)
|
2007-12-17 21:50:23 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
ops->get_eeprom(netdev, &eeprom, data);
|
|
|
|
|
|
|
|
csum_old = (data[EEPROM_CHECKSUM_REG * 2]) +
|
|
|
|
(data[EEPROM_CHECKSUM_REG * 2 + 1] << 8);
|
|
|
|
for (i = 0; i < EEPROM_CHECKSUM_REG * 2; i += 2)
|
|
|
|
csum_new += data[i] + (data[i + 1] << 8);
|
|
|
|
csum_new = EEPROM_SUM - csum_new;
|
|
|
|
|
2010-04-27 14:02:58 +00:00
|
|
|
pr_err("/*********************/\n");
|
|
|
|
pr_err("Current EEPROM Checksum : 0x%04x\n", csum_old);
|
|
|
|
pr_err("Calculated : 0x%04x\n", csum_new);
|
2007-12-17 21:50:23 +00:00
|
|
|
|
2010-04-27 14:02:58 +00:00
|
|
|
pr_err("Offset Values\n");
|
|
|
|
pr_err("======== ======\n");
|
2007-12-17 21:50:23 +00:00
|
|
|
print_hex_dump(KERN_ERR, "", DUMP_PREFIX_OFFSET, 16, 1, data, 128, 0);
|
|
|
|
|
2010-04-27 14:02:58 +00:00
|
|
|
pr_err("Include this output when contacting your support provider.\n");
|
|
|
|
pr_err("This is not a software error! Something bad happened to\n");
|
|
|
|
pr_err("your hardware or EEPROM image. Ignoring this problem could\n");
|
|
|
|
pr_err("result in further problems, possibly loss of data,\n");
|
|
|
|
pr_err("corruption or system hangs!\n");
|
|
|
|
pr_err("The MAC Address will be reset to 00:00:00:00:00:00,\n");
|
|
|
|
pr_err("which is invalid and requires you to set the proper MAC\n");
|
|
|
|
pr_err("address manually before continuing to enable this network\n");
|
|
|
|
pr_err("device. Please inspect the EEPROM dump and report the\n");
|
|
|
|
pr_err("issue to your hardware vendor or Intel Customer Support.\n");
|
|
|
|
pr_err("/*********************/\n");
|
2007-12-17 21:50:23 +00:00
|
|
|
|
|
|
|
kfree(data);
|
|
|
|
}
|
|
|
|
|
2008-07-11 22:17:44 +00:00
|
|
|
/**
|
|
|
|
* e1000_is_need_ioport - determine if an adapter needs ioport resources or not
|
|
|
|
* @pdev: PCI device information struct
|
|
|
|
*
|
|
|
|
* Return true if an adapter needs ioport resources
|
|
|
|
**/
|
|
|
|
static int e1000_is_need_ioport(struct pci_dev *pdev)
|
|
|
|
{
|
|
|
|
switch (pdev->device) {
|
|
|
|
case E1000_DEV_ID_82540EM:
|
|
|
|
case E1000_DEV_ID_82540EM_LOM:
|
|
|
|
case E1000_DEV_ID_82540EP:
|
|
|
|
case E1000_DEV_ID_82540EP_LOM:
|
|
|
|
case E1000_DEV_ID_82540EP_LP:
|
|
|
|
case E1000_DEV_ID_82541EI:
|
|
|
|
case E1000_DEV_ID_82541EI_MOBILE:
|
|
|
|
case E1000_DEV_ID_82541ER:
|
|
|
|
case E1000_DEV_ID_82541ER_LOM:
|
|
|
|
case E1000_DEV_ID_82541GI:
|
|
|
|
case E1000_DEV_ID_82541GI_LF:
|
|
|
|
case E1000_DEV_ID_82541GI_MOBILE:
|
|
|
|
case E1000_DEV_ID_82544EI_COPPER:
|
|
|
|
case E1000_DEV_ID_82544EI_FIBER:
|
|
|
|
case E1000_DEV_ID_82544GC_COPPER:
|
|
|
|
case E1000_DEV_ID_82544GC_LOM:
|
|
|
|
case E1000_DEV_ID_82545EM_COPPER:
|
|
|
|
case E1000_DEV_ID_82545EM_FIBER:
|
|
|
|
case E1000_DEV_ID_82546EB_COPPER:
|
|
|
|
case E1000_DEV_ID_82546EB_FIBER:
|
|
|
|
case E1000_DEV_ID_82546EB_QUAD_COPPER:
|
|
|
|
return true;
|
|
|
|
default:
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-11-15 15:29:55 +00:00
|
|
|
static netdev_features_t e1000_fix_features(struct net_device *netdev,
|
|
|
|
netdev_features_t features)
|
2011-07-21 03:26:31 +00:00
|
|
|
{
|
2013-02-09 12:49:21 +00:00
|
|
|
/* Since there is no support for separate Rx/Tx vlan accel
|
|
|
|
* enable/disable make sure Tx flag is always in same state as Rx.
|
2011-07-21 03:26:31 +00:00
|
|
|
*/
|
2013-04-19 02:04:27 +00:00
|
|
|
if (features & NETIF_F_HW_VLAN_CTAG_RX)
|
|
|
|
features |= NETIF_F_HW_VLAN_CTAG_TX;
|
2011-07-21 03:26:31 +00:00
|
|
|
else
|
2013-04-19 02:04:27 +00:00
|
|
|
features &= ~NETIF_F_HW_VLAN_CTAG_TX;
|
2011-07-21 03:26:31 +00:00
|
|
|
|
|
|
|
return features;
|
|
|
|
}
|
|
|
|
|
2011-11-15 15:29:55 +00:00
|
|
|
static int e1000_set_features(struct net_device *netdev,
|
|
|
|
netdev_features_t features)
|
2011-06-08 08:36:42 +00:00
|
|
|
{
|
|
|
|
struct e1000_adapter *adapter = netdev_priv(netdev);
|
2011-11-15 15:29:55 +00:00
|
|
|
netdev_features_t changed = features ^ netdev->features;
|
2011-06-08 08:36:42 +00:00
|
|
|
|
2013-04-19 02:04:27 +00:00
|
|
|
if (changed & NETIF_F_HW_VLAN_CTAG_RX)
|
2011-07-21 03:26:31 +00:00
|
|
|
e1000_vlan_mode(netdev, features);
|
|
|
|
|
2012-04-04 06:01:29 +00:00
|
|
|
if (!(changed & (NETIF_F_RXCSUM | NETIF_F_RXALL)))
|
2011-06-08 08:36:42 +00:00
|
|
|
return 0;
|
|
|
|
|
2012-04-04 06:01:29 +00:00
|
|
|
netdev->features = features;
|
2011-06-08 08:36:42 +00:00
|
|
|
adapter->rx_csum = !!(features & NETIF_F_RXCSUM);
|
|
|
|
|
|
|
|
if (netif_running(netdev))
|
|
|
|
e1000_reinit_locked(adapter);
|
|
|
|
else
|
|
|
|
e1000_reset(adapter);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-11-20 06:18:22 +00:00
|
|
|
static const struct net_device_ops e1000_netdev_ops = {
|
|
|
|
.ndo_open = e1000_open,
|
|
|
|
.ndo_stop = e1000_close,
|
2008-11-21 04:14:53 +00:00
|
|
|
.ndo_start_xmit = e1000_xmit_frame,
|
2008-11-20 06:18:22 +00:00
|
|
|
.ndo_get_stats = e1000_get_stats,
|
|
|
|
.ndo_set_rx_mode = e1000_set_rx_mode,
|
|
|
|
.ndo_set_mac_address = e1000_set_mac,
|
2011-07-21 03:26:31 +00:00
|
|
|
.ndo_tx_timeout = e1000_tx_timeout,
|
2008-11-20 06:18:22 +00:00
|
|
|
.ndo_change_mtu = e1000_change_mtu,
|
|
|
|
.ndo_do_ioctl = e1000_ioctl,
|
|
|
|
.ndo_validate_addr = eth_validate_addr,
|
|
|
|
.ndo_vlan_rx_add_vid = e1000_vlan_rx_add_vid,
|
|
|
|
.ndo_vlan_rx_kill_vid = e1000_vlan_rx_kill_vid,
|
|
|
|
#ifdef CONFIG_NET_POLL_CONTROLLER
|
|
|
|
.ndo_poll_controller = e1000_netpoll,
|
|
|
|
#endif
|
2011-07-21 03:26:31 +00:00
|
|
|
.ndo_fix_features = e1000_fix_features,
|
|
|
|
.ndo_set_features = e1000_set_features,
|
2008-11-20 06:18:22 +00:00
|
|
|
};
|
|
|
|
|
2010-09-07 21:01:12 +00:00
|
|
|
/**
|
|
|
|
* e1000_init_hw_struct - initialize members of hw struct
|
|
|
|
* @adapter: board private struct
|
|
|
|
* @hw: structure used by e1000_hw.c
|
|
|
|
*
|
|
|
|
* Factors out initialization of the e1000_hw struct to its own function
|
|
|
|
* that can be called very early at init (just after struct allocation).
|
|
|
|
* Fields are initialized based on PCI device information and
|
|
|
|
* OS network device settings (MTU size).
|
|
|
|
* Returns negative error codes if MAC type setup fails.
|
|
|
|
*/
|
|
|
|
static int e1000_init_hw_struct(struct e1000_adapter *adapter,
|
|
|
|
struct e1000_hw *hw)
|
|
|
|
{
|
|
|
|
struct pci_dev *pdev = adapter->pdev;
|
|
|
|
|
|
|
|
/* PCI config space info */
|
|
|
|
hw->vendor_id = pdev->vendor;
|
|
|
|
hw->device_id = pdev->device;
|
|
|
|
hw->subsystem_vendor_id = pdev->subsystem_vendor;
|
|
|
|
hw->subsystem_id = pdev->subsystem_device;
|
|
|
|
hw->revision_id = pdev->revision;
|
|
|
|
|
|
|
|
pci_read_config_word(pdev, PCI_COMMAND, &hw->pci_cmd_word);
|
|
|
|
|
|
|
|
hw->max_frame_size = adapter->netdev->mtu +
|
|
|
|
ENET_HEADER_SIZE + ETHERNET_FCS_SIZE;
|
|
|
|
hw->min_frame_size = MINIMUM_ETHERNET_FRAME_SIZE;
|
|
|
|
|
|
|
|
/* identify the MAC */
|
|
|
|
if (e1000_set_mac_type(hw)) {
|
|
|
|
e_err(probe, "Unknown MAC Type\n");
|
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (hw->mac_type) {
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
case e1000_82541:
|
|
|
|
case e1000_82547:
|
|
|
|
case e1000_82541_rev_2:
|
|
|
|
case e1000_82547_rev_2:
|
|
|
|
hw->phy_init_script = 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
e1000_set_media_type(hw);
|
|
|
|
e1000_get_bus_info(hw);
|
|
|
|
|
|
|
|
hw->wait_autoneg_complete = false;
|
|
|
|
hw->tbi_compatibility_en = true;
|
|
|
|
hw->adaptive_ifs = true;
|
|
|
|
|
|
|
|
/* Copper options */
|
|
|
|
|
|
|
|
if (hw->media_type == e1000_media_type_copper) {
|
|
|
|
hw->mdix = AUTO_ALL_MODES;
|
|
|
|
hw->disable_polarity_correction = false;
|
|
|
|
hw->master_slave = E1000_MASTER_SLAVE;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/**
|
|
|
|
* e1000_probe - Device Initialization Routine
|
|
|
|
* @pdev: PCI device information struct
|
|
|
|
* @ent: entry in e1000_pci_tbl
|
|
|
|
*
|
|
|
|
* Returns 0 on success, negative on failure
|
|
|
|
*
|
|
|
|
* e1000_probe initializes an adapter identified by a pci_dev structure.
|
|
|
|
* The OS initialization, configuring of the adapter private structure,
|
|
|
|
* and a hardware reset occur.
|
|
|
|
**/
|
2012-12-06 14:30:56 +00:00
|
|
|
static int e1000_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct net_device *netdev;
|
|
|
|
struct e1000_adapter *adapter;
|
2008-07-11 22:17:08 +00:00
|
|
|
struct e1000_hw *hw;
|
2005-04-29 02:43:52 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
static int cards_found = 0;
|
2006-08-31 21:27:46 +00:00
|
|
|
static int global_quad_port_a = 0; /* global ksp3 port a indication */
|
2005-04-29 02:43:52 +00:00
|
|
|
int i, err, pci_using_dac;
|
2008-04-03 17:06:32 +00:00
|
|
|
u16 eeprom_data = 0;
|
2011-01-06 14:29:54 +00:00
|
|
|
u16 tmp = 0;
|
2008-04-03 17:06:32 +00:00
|
|
|
u16 eeprom_apme_mask = E1000_EEPROM_APME;
|
2008-07-11 22:17:44 +00:00
|
|
|
int bars, need_ioport;
|
2007-10-04 00:59:30 +00:00
|
|
|
|
2008-07-11 22:17:44 +00:00
|
|
|
/* do not allocate ioport bars when not needed */
|
|
|
|
need_ioport = e1000_is_need_ioport(pdev);
|
|
|
|
if (need_ioport) {
|
|
|
|
bars = pci_select_bars(pdev, IORESOURCE_MEM | IORESOURCE_IO);
|
|
|
|
err = pci_enable_device(pdev);
|
|
|
|
} else {
|
|
|
|
bars = pci_select_bars(pdev, IORESOURCE_MEM);
|
2009-02-03 23:18:01 +00:00
|
|
|
err = pci_enable_device_mem(pdev);
|
2008-07-11 22:17:44 +00:00
|
|
|
}
|
2008-07-11 22:17:28 +00:00
|
|
|
if (err)
|
2005-04-16 22:20:36 +00:00
|
|
|
return err;
|
|
|
|
|
2008-07-11 22:17:44 +00:00
|
|
|
err = pci_request_selected_regions(pdev, bars, e1000_driver_name);
|
2008-07-11 22:17:28 +00:00
|
|
|
if (err)
|
2006-08-28 21:56:22 +00:00
|
|
|
goto err_pci_reg;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
pci_set_master(pdev);
|
2010-02-03 14:49:48 +00:00
|
|
|
err = pci_save_state(pdev);
|
|
|
|
if (err)
|
|
|
|
goto err_alloc_etherdev;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-08-28 21:56:22 +00:00
|
|
|
err = -ENOMEM;
|
2005-04-16 22:20:36 +00:00
|
|
|
netdev = alloc_etherdev(sizeof(struct e1000_adapter));
|
2006-08-28 21:56:22 +00:00
|
|
|
if (!netdev)
|
2005-04-16 22:20:36 +00:00
|
|
|
goto err_alloc_etherdev;
|
|
|
|
|
|
|
|
SET_NETDEV_DEV(netdev, &pdev->dev);
|
|
|
|
|
|
|
|
pci_set_drvdata(pdev, netdev);
|
2005-06-18 00:41:45 +00:00
|
|
|
adapter = netdev_priv(netdev);
|
2005-04-16 22:20:36 +00:00
|
|
|
adapter->netdev = netdev;
|
|
|
|
adapter->pdev = pdev;
|
2012-03-13 06:04:20 +00:00
|
|
|
adapter->msg_enable = netif_msg_init(debug, DEFAULT_MSG_ENABLE);
|
2008-07-11 22:17:44 +00:00
|
|
|
adapter->bars = bars;
|
|
|
|
adapter->need_ioport = need_ioport;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-07-11 22:17:08 +00:00
|
|
|
hw = &adapter->hw;
|
|
|
|
hw->back = adapter;
|
|
|
|
|
2006-08-28 21:56:22 +00:00
|
|
|
err = -EIO;
|
2008-10-21 04:42:39 +00:00
|
|
|
hw->hw_addr = pci_ioremap_bar(pdev, BAR_0);
|
2008-07-11 22:17:08 +00:00
|
|
|
if (!hw->hw_addr)
|
2005-04-16 22:20:36 +00:00
|
|
|
goto err_ioremap;
|
|
|
|
|
2008-07-11 22:17:44 +00:00
|
|
|
if (adapter->need_ioport) {
|
|
|
|
for (i = BAR_1; i <= BAR_5; i++) {
|
|
|
|
if (pci_resource_len(pdev, i) == 0)
|
|
|
|
continue;
|
|
|
|
if (pci_resource_flags(pdev, i) & IORESOURCE_IO) {
|
|
|
|
hw->io_base = pci_resource_start(pdev, i);
|
|
|
|
break;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-09-07 21:01:12 +00:00
|
|
|
/* make ready for any if (hw->...) below */
|
|
|
|
err = e1000_init_hw_struct(adapter, hw);
|
|
|
|
if (err)
|
|
|
|
goto err_sw_init;
|
|
|
|
|
2013-02-09 12:49:21 +00:00
|
|
|
/* there is a workaround being applied below that limits
|
2010-09-07 21:01:12 +00:00
|
|
|
* 64-bit DMA addresses to 64-bit hardware. There are some
|
|
|
|
* 32-bit adapters that Tx hang when given 64-bit DMA addresses
|
|
|
|
*/
|
|
|
|
pci_using_dac = 0;
|
|
|
|
if ((hw->bus_type == e1000_bus_type_pcix) &&
|
2013-06-26 22:49:11 +00:00
|
|
|
!dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(64))) {
|
2010-09-07 21:01:12 +00:00
|
|
|
pci_using_dac = 1;
|
|
|
|
} else {
|
2013-06-26 22:49:11 +00:00
|
|
|
err = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32));
|
2010-11-11 05:50:25 +00:00
|
|
|
if (err) {
|
|
|
|
pr_err("No usable DMA config, aborting\n");
|
|
|
|
goto err_dma;
|
|
|
|
}
|
2010-09-07 21:01:12 +00:00
|
|
|
}
|
|
|
|
|
2008-11-20 06:18:22 +00:00
|
|
|
netdev->netdev_ops = &e1000_netdev_ops;
|
2005-04-16 22:20:36 +00:00
|
|
|
e1000_set_ethtool_ops(netdev);
|
|
|
|
netdev->watchdog_timeo = 5 * HZ;
|
[NET]: Make NAPI polling independent of struct net_device objects.
Several devices have multiple independant RX queues per net
device, and some have a single interrupt doorbell for several
queues.
In either case, it's easier to support layouts like that if the
structure representing the poll is independant from the net
device itself.
The signature of the ->poll() call back goes from:
int foo_poll(struct net_device *dev, int *budget)
to
int foo_poll(struct napi_struct *napi, int budget)
The caller is returned the number of RX packets processed (or
the number of "NAPI credits" consumed if you want to get
abstract). The callee no longer messes around bumping
dev->quota, *budget, etc. because that is all handled in the
caller upon return.
The napi_struct is to be embedded in the device driver private data
structures.
Furthermore, it is the driver's responsibility to disable all NAPI
instances in it's ->stop() device close handler. Since the
napi_struct is privatized into the driver's private data structures,
only the driver knows how to get at all of the napi_struct instances
it may have per-device.
With lots of help and suggestions from Rusty Russell, Roland Dreier,
Michael Chan, Jeff Garzik, and Jamal Hadi Salim.
Bug fixes from Thomas Graf, Roland Dreier, Peter Zijlstra,
Joseph Fannin, Scott Wood, Hans J. Koch, and Michael Chan.
[ Ported to current tree and all drivers converted. Integrated
Stephen's follow-on kerneldoc additions, and restored poll_list
handling to the old style to fix mutual exclusion issues. -DaveM ]
Signed-off-by: Stephen Hemminger <shemminger@linux-foundation.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
2007-10-03 23:41:36 +00:00
|
|
|
netif_napi_add(netdev, &adapter->napi, e1000_clean, 64);
|
2008-11-20 06:18:22 +00:00
|
|
|
|
2006-09-27 19:53:17 +00:00
|
|
|
strncpy(netdev->name, pci_name(pdev), sizeof(netdev->name) - 1);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
adapter->bd_number = cards_found;
|
|
|
|
|
|
|
|
/* setup the private structure */
|
|
|
|
|
2008-07-11 22:17:28 +00:00
|
|
|
err = e1000_sw_init(adapter);
|
|
|
|
if (err)
|
2005-04-16 22:20:36 +00:00
|
|
|
goto err_sw_init;
|
|
|
|
|
2006-08-28 21:56:22 +00:00
|
|
|
err = -EIO;
|
2011-01-06 14:29:54 +00:00
|
|
|
if (hw->mac_type == e1000_ce4100) {
|
2012-01-04 20:23:35 +00:00
|
|
|
hw->ce4100_gbe_mdio_base_virt =
|
|
|
|
ioremap(pci_resource_start(pdev, BAR_1),
|
2011-01-06 14:29:54 +00:00
|
|
|
pci_resource_len(pdev, BAR_1));
|
|
|
|
|
2012-01-04 20:23:35 +00:00
|
|
|
if (!hw->ce4100_gbe_mdio_base_virt)
|
2011-01-06 14:29:54 +00:00
|
|
|
goto err_mdio_ioremap;
|
|
|
|
}
|
2005-04-29 02:43:52 +00:00
|
|
|
|
2008-07-11 22:17:08 +00:00
|
|
|
if (hw->mac_type >= e1000_82543) {
|
2011-06-08 08:36:42 +00:00
|
|
|
netdev->hw_features = NETIF_F_SG |
|
2011-07-21 03:26:31 +00:00
|
|
|
NETIF_F_HW_CSUM |
|
2013-04-19 02:04:27 +00:00
|
|
|
NETIF_F_HW_VLAN_CTAG_RX;
|
|
|
|
netdev->features = NETIF_F_HW_VLAN_CTAG_TX |
|
|
|
|
NETIF_F_HW_VLAN_CTAG_FILTER;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2008-07-11 22:17:08 +00:00
|
|
|
if ((hw->mac_type >= e1000_82544) &&
|
|
|
|
(hw->mac_type != e1000_82547))
|
2011-06-08 08:36:42 +00:00
|
|
|
netdev->hw_features |= NETIF_F_TSO;
|
|
|
|
|
2012-02-11 15:40:01 +00:00
|
|
|
netdev->priv_flags |= IFF_SUPP_NOFCS;
|
|
|
|
|
2011-06-08 08:36:42 +00:00
|
|
|
netdev->features |= netdev->hw_features;
|
2012-06-12 13:03:29 +00:00
|
|
|
netdev->hw_features |= (NETIF_F_RXCSUM |
|
|
|
|
NETIF_F_RXALL |
|
|
|
|
NETIF_F_RXFCS);
|
2005-04-29 02:43:52 +00:00
|
|
|
|
2010-09-22 17:57:58 +00:00
|
|
|
if (pci_using_dac) {
|
2005-04-16 22:20:36 +00:00
|
|
|
netdev->features |= NETIF_F_HIGHDMA;
|
2010-09-22 17:57:58 +00:00
|
|
|
netdev->vlan_features |= NETIF_F_HIGHDMA;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2012-06-12 13:03:29 +00:00
|
|
|
netdev->vlan_features |= (NETIF_F_TSO |
|
|
|
|
NETIF_F_HW_CSUM |
|
|
|
|
NETIF_F_SG);
|
2008-10-11 19:25:59 +00:00
|
|
|
|
2011-08-16 06:29:00 +00:00
|
|
|
netdev->priv_flags |= IFF_UNICAST_FLT;
|
|
|
|
|
2008-07-11 22:17:08 +00:00
|
|
|
adapter->en_mng_pt = e1000_enable_mng_pass_thru(hw);
|
2005-04-29 02:43:52 +00:00
|
|
|
|
2006-06-27 16:08:22 +00:00
|
|
|
/* initialize eeprom parameters */
|
2008-07-11 22:17:08 +00:00
|
|
|
if (e1000_init_eeprom_params(hw)) {
|
2010-07-27 06:37:21 +00:00
|
|
|
e_err(probe, "EEPROM initialization failed\n");
|
2006-08-28 21:56:22 +00:00
|
|
|
goto err_eeprom;
|
2006-06-27 16:08:22 +00:00
|
|
|
}
|
|
|
|
|
2006-01-18 21:01:39 +00:00
|
|
|
/* before reading the EEPROM, reset the controller to
|
2013-02-09 12:49:21 +00:00
|
|
|
* put the device in a known good starting state
|
|
|
|
*/
|
2006-01-18 21:01:39 +00:00
|
|
|
|
2008-07-11 22:17:08 +00:00
|
|
|
e1000_reset_hw(hw);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* make sure the EEPROM is good */
|
2008-07-11 22:17:08 +00:00
|
|
|
if (e1000_validate_eeprom_checksum(hw) < 0) {
|
2010-07-27 06:37:21 +00:00
|
|
|
e_err(probe, "The EEPROM Checksum Is Not Valid\n");
|
2007-12-17 21:50:23 +00:00
|
|
|
e1000_dump_eeprom(adapter);
|
2013-02-09 12:49:21 +00:00
|
|
|
/* set MAC address to all zeroes to invalidate and temporary
|
2007-12-17 21:50:23 +00:00
|
|
|
* disable this device for the user. This blocks regular
|
|
|
|
* traffic while still permitting ethtool ioctls from reaching
|
|
|
|
* the hardware as well as allowing the user to run the
|
|
|
|
* interface after manually setting a hw addr using
|
|
|
|
* `ip set address`
|
|
|
|
*/
|
2008-07-11 22:17:08 +00:00
|
|
|
memset(hw->mac_addr, 0, netdev->addr_len);
|
2007-12-17 21:50:23 +00:00
|
|
|
} else {
|
|
|
|
/* copy the MAC address out of the EEPROM */
|
2008-07-11 22:17:08 +00:00
|
|
|
if (e1000_read_mac_addr(hw))
|
2010-07-27 06:37:21 +00:00
|
|
|
e_err(probe, "EEPROM Read Error\n");
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2007-12-17 21:50:23 +00:00
|
|
|
/* don't block initalization here due to bad MAC address */
|
2008-07-11 22:17:08 +00:00
|
|
|
memcpy(netdev->dev_addr, hw->mac_addr, netdev->addr_len);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2013-01-08 01:38:26 +00:00
|
|
|
if (!is_valid_ether_addr(netdev->dev_addr))
|
2010-07-27 06:37:21 +00:00
|
|
|
e_err(probe, "Invalid MAC Address\n");
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
2011-10-05 07:24:41 +00:00
|
|
|
INIT_DELAYED_WORK(&adapter->watchdog_task, e1000_watchdog);
|
|
|
|
INIT_DELAYED_WORK(&adapter->fifo_stall_task,
|
|
|
|
e1000_82547_tx_fifo_stall_task);
|
|
|
|
INIT_DELAYED_WORK(&adapter->phy_info_task, e1000_update_phy_info_task);
|
2006-11-22 14:55:48 +00:00
|
|
|
INIT_WORK(&adapter->reset_task, e1000_reset_task);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
e1000_check_options(adapter);
|
|
|
|
|
|
|
|
/* Initial Wake on LAN setting
|
|
|
|
* If APM wake is enabled in the EEPROM,
|
|
|
|
* enable the ACPI Magic Packet filter
|
|
|
|
*/
|
|
|
|
|
2008-07-11 22:17:08 +00:00
|
|
|
switch (hw->mac_type) {
|
2005-04-16 22:20:36 +00:00
|
|
|
case e1000_82542_rev2_0:
|
|
|
|
case e1000_82542_rev2_1:
|
|
|
|
case e1000_82543:
|
|
|
|
break;
|
|
|
|
case e1000_82544:
|
2008-07-11 22:17:08 +00:00
|
|
|
e1000_read_eeprom(hw,
|
2005-04-16 22:20:36 +00:00
|
|
|
EEPROM_INIT_CONTROL2_REG, 1, &eeprom_data);
|
|
|
|
eeprom_apme_mask = E1000_EEPROM_82544_APM;
|
|
|
|
break;
|
|
|
|
case e1000_82546:
|
|
|
|
case e1000_82546_rev_3:
|
2008-07-11 22:17:08 +00:00
|
|
|
if (er32(STATUS) & E1000_STATUS_FUNC_1){
|
|
|
|
e1000_read_eeprom(hw,
|
2005-04-16 22:20:36 +00:00
|
|
|
EEPROM_INIT_CONTROL3_PORT_B, 1, &eeprom_data);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
/* Fall Through */
|
|
|
|
default:
|
2008-07-11 22:17:08 +00:00
|
|
|
e1000_read_eeprom(hw,
|
2005-04-16 22:20:36 +00:00
|
|
|
EEPROM_INIT_CONTROL3_PORT_A, 1, &eeprom_data);
|
|
|
|
break;
|
|
|
|
}
|
2006-01-18 21:01:39 +00:00
|
|
|
if (eeprom_data & eeprom_apme_mask)
|
2006-08-31 21:27:46 +00:00
|
|
|
adapter->eeprom_wol |= E1000_WUFC_MAG;
|
|
|
|
|
|
|
|
/* now that we have the eeprom settings, apply the special cases
|
|
|
|
* where the eeprom may be wrong or the board simply won't support
|
2013-02-09 12:49:21 +00:00
|
|
|
* wake on lan on a particular port
|
|
|
|
*/
|
2006-08-31 21:27:46 +00:00
|
|
|
switch (pdev->device) {
|
|
|
|
case E1000_DEV_ID_82546GB_PCIE:
|
|
|
|
adapter->eeprom_wol = 0;
|
|
|
|
break;
|
|
|
|
case E1000_DEV_ID_82546EB_FIBER:
|
|
|
|
case E1000_DEV_ID_82546GB_FIBER:
|
|
|
|
/* Wake events only supported on port A for dual fiber
|
2013-02-09 12:49:21 +00:00
|
|
|
* regardless of eeprom setting
|
|
|
|
*/
|
2008-07-11 22:17:08 +00:00
|
|
|
if (er32(STATUS) & E1000_STATUS_FUNC_1)
|
2006-08-31 21:27:46 +00:00
|
|
|
adapter->eeprom_wol = 0;
|
|
|
|
break;
|
|
|
|
case E1000_DEV_ID_82546GB_QUAD_COPPER_KSP3:
|
|
|
|
/* if quad port adapter, disable WoL on all but port A */
|
|
|
|
if (global_quad_port_a != 0)
|
|
|
|
adapter->eeprom_wol = 0;
|
|
|
|
else
|
2011-12-19 13:56:45 +00:00
|
|
|
adapter->quad_port_a = true;
|
2006-08-31 21:27:46 +00:00
|
|
|
/* Reset for multiple quad port adapters */
|
|
|
|
if (++global_quad_port_a == 4)
|
|
|
|
global_quad_port_a = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* initialize the wol settings based on the eeprom settings */
|
|
|
|
adapter->wol = adapter->eeprom_wol;
|
2008-11-07 20:30:19 +00:00
|
|
|
device_set_wakeup_enable(&adapter->pdev->dev, adapter->wol);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2011-01-06 14:29:54 +00:00
|
|
|
/* Auto detect PHY address */
|
|
|
|
if (hw->mac_type == e1000_ce4100) {
|
|
|
|
for (i = 0; i < 32; i++) {
|
|
|
|
hw->phy_addr = i;
|
|
|
|
e1000_read_phy_reg(hw, PHY_ID2, &tmp);
|
|
|
|
if (tmp == 0 || tmp == 0xFF) {
|
|
|
|
if (i == 31)
|
|
|
|
goto err_eeprom;
|
|
|
|
continue;
|
|
|
|
} else
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-04-27 14:02:58 +00:00
|
|
|
/* reset the hardware with the new settings */
|
|
|
|
e1000_reset(adapter);
|
|
|
|
|
|
|
|
strcpy(netdev->name, "eth%d");
|
|
|
|
err = register_netdev(netdev);
|
|
|
|
if (err)
|
|
|
|
goto err_register;
|
|
|
|
|
2012-03-20 18:10:01 +00:00
|
|
|
e1000_vlan_filter_on_off(adapter, false);
|
2011-07-21 03:26:31 +00:00
|
|
|
|
2006-01-13 00:51:25 +00:00
|
|
|
/* print bus type/speed/width info */
|
2010-07-27 06:37:21 +00:00
|
|
|
e_info(probe, "(PCI%s:%dMHz:%d-bit) %pM\n",
|
2010-06-11 12:51:49 +00:00
|
|
|
((hw->bus_type == e1000_bus_type_pcix) ? "-X" : ""),
|
|
|
|
((hw->bus_speed == e1000_bus_speed_133) ? 133 :
|
|
|
|
(hw->bus_speed == e1000_bus_speed_120) ? 120 :
|
|
|
|
(hw->bus_speed == e1000_bus_speed_100) ? 100 :
|
|
|
|
(hw->bus_speed == e1000_bus_speed_66) ? 66 : 33),
|
|
|
|
((hw->bus_width == e1000_bus_width_64) ? 64 : 32),
|
|
|
|
netdev->dev_addr);
|
2006-09-27 19:54:02 +00:00
|
|
|
|
2009-04-17 20:44:36 +00:00
|
|
|
/* carrier off reporting is important to ethtool even BEFORE open */
|
|
|
|
netif_carrier_off(netdev);
|
|
|
|
|
2010-07-27 06:37:21 +00:00
|
|
|
e_info(probe, "Intel(R) PRO/1000 Network Connection\n");
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
cards_found++;
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
err_register:
|
2006-08-28 21:56:22 +00:00
|
|
|
err_eeprom:
|
2009-09-25 12:16:14 +00:00
|
|
|
e1000_phy_hw_reset(hw);
|
2006-08-28 21:56:22 +00:00
|
|
|
|
2008-07-11 22:17:08 +00:00
|
|
|
if (hw->flash_address)
|
|
|
|
iounmap(hw->flash_address);
|
2006-08-28 21:56:22 +00:00
|
|
|
kfree(adapter->tx_ring);
|
|
|
|
kfree(adapter->rx_ring);
|
2010-09-07 21:01:12 +00:00
|
|
|
err_dma:
|
2005-04-16 22:20:36 +00:00
|
|
|
err_sw_init:
|
2011-01-06 14:29:54 +00:00
|
|
|
err_mdio_ioremap:
|
2012-01-04 20:23:35 +00:00
|
|
|
iounmap(hw->ce4100_gbe_mdio_base_virt);
|
2008-07-11 22:17:08 +00:00
|
|
|
iounmap(hw->hw_addr);
|
2005-04-16 22:20:36 +00:00
|
|
|
err_ioremap:
|
|
|
|
free_netdev(netdev);
|
|
|
|
err_alloc_etherdev:
|
2008-07-11 22:17:44 +00:00
|
|
|
pci_release_selected_regions(pdev, bars);
|
2006-08-28 21:56:22 +00:00
|
|
|
err_pci_reg:
|
|
|
|
pci_disable_device(pdev);
|
2005-04-16 22:20:36 +00:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* e1000_remove - Device Removal Routine
|
|
|
|
* @pdev: PCI device information struct
|
|
|
|
*
|
|
|
|
* e1000_remove is called by the PCI subsystem to alert the driver
|
|
|
|
* that it should release a PCI device. The could be caused by a
|
|
|
|
* Hot-Plug event, or because the driver is going to be removed from
|
|
|
|
* memory.
|
|
|
|
**/
|
2012-12-03 14:24:25 +00:00
|
|
|
static void e1000_remove(struct pci_dev *pdev)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct net_device *netdev = pci_get_drvdata(pdev);
|
2005-06-18 00:41:45 +00:00
|
|
|
struct e1000_adapter *adapter = netdev_priv(netdev);
|
2008-07-11 22:17:08 +00:00
|
|
|
struct e1000_hw *hw = &adapter->hw;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2011-10-05 07:24:41 +00:00
|
|
|
e1000_down_and_stop(adapter);
|
2006-12-15 15:56:10 +00:00
|
|
|
e1000_release_manageability(adapter);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
[NET]: Make NAPI polling independent of struct net_device objects.
Several devices have multiple independant RX queues per net
device, and some have a single interrupt doorbell for several
queues.
In either case, it's easier to support layouts like that if the
structure representing the poll is independant from the net
device itself.
The signature of the ->poll() call back goes from:
int foo_poll(struct net_device *dev, int *budget)
to
int foo_poll(struct napi_struct *napi, int budget)
The caller is returned the number of RX packets processed (or
the number of "NAPI credits" consumed if you want to get
abstract). The callee no longer messes around bumping
dev->quota, *budget, etc. because that is all handled in the
caller upon return.
The napi_struct is to be embedded in the device driver private data
structures.
Furthermore, it is the driver's responsibility to disable all NAPI
instances in it's ->stop() device close handler. Since the
napi_struct is privatized into the driver's private data structures,
only the driver knows how to get at all of the napi_struct instances
it may have per-device.
With lots of help and suggestions from Rusty Russell, Roland Dreier,
Michael Chan, Jeff Garzik, and Jamal Hadi Salim.
Bug fixes from Thomas Graf, Roland Dreier, Peter Zijlstra,
Joseph Fannin, Scott Wood, Hans J. Koch, and Michael Chan.
[ Ported to current tree and all drivers converted. Integrated
Stephen's follow-on kerneldoc additions, and restored poll_list
handling to the old style to fix mutual exclusion issues. -DaveM ]
Signed-off-by: Stephen Hemminger <shemminger@linux-foundation.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
2007-10-03 23:41:36 +00:00
|
|
|
unregister_netdev(netdev);
|
|
|
|
|
2009-09-25 12:16:14 +00:00
|
|
|
e1000_phy_hw_reset(hw);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2005-10-04 11:03:23 +00:00
|
|
|
kfree(adapter->tx_ring);
|
|
|
|
kfree(adapter->rx_ring);
|
|
|
|
|
2012-01-04 20:23:34 +00:00
|
|
|
if (hw->mac_type == e1000_ce4100)
|
2012-01-04 20:23:35 +00:00
|
|
|
iounmap(hw->ce4100_gbe_mdio_base_virt);
|
2008-07-11 22:17:08 +00:00
|
|
|
iounmap(hw->hw_addr);
|
|
|
|
if (hw->flash_address)
|
|
|
|
iounmap(hw->flash_address);
|
2008-07-11 22:17:44 +00:00
|
|
|
pci_release_selected_regions(pdev, adapter->bars);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
free_netdev(netdev);
|
|
|
|
|
|
|
|
pci_disable_device(pdev);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* e1000_sw_init - Initialize general software structures (struct e1000_adapter)
|
|
|
|
* @adapter: board private structure to initialize
|
|
|
|
*
|
|
|
|
* e1000_sw_init initializes the Adapter private data structure.
|
2010-09-07 21:01:12 +00:00
|
|
|
* e1000_init_hw_struct MUST be called before this function
|
2005-04-16 22:20:36 +00:00
|
|
|
**/
|
2012-12-03 14:24:25 +00:00
|
|
|
static int e1000_sw_init(struct e1000_adapter *adapter)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2006-07-14 23:14:48 +00:00
|
|
|
adapter->rx_buffer_len = MAXIMUM_ETHERNET_VLAN_SIZE;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-01-13 00:50:39 +00:00
|
|
|
adapter->num_tx_queues = 1;
|
|
|
|
adapter->num_rx_queues = 1;
|
2005-10-04 11:01:55 +00:00
|
|
|
|
|
|
|
if (e1000_alloc_queues(adapter)) {
|
2010-07-27 06:37:21 +00:00
|
|
|
e_err(probe, "Unable to allocate memory for queues\n");
|
2005-10-04 11:01:55 +00:00
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
2007-05-29 22:07:31 +00:00
|
|
|
/* Explicitly disable IRQ since the NIC can be in any state. */
|
|
|
|
e1000_irq_disable(adapter);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
spin_lock_init(&adapter->stats_lock);
|
2011-10-05 07:24:51 +00:00
|
|
|
mutex_init(&adapter->mutex);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-09-27 19:54:02 +00:00
|
|
|
set_bit(__E1000_DOWN, &adapter->flags);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-10-04 11:01:55 +00:00
|
|
|
/**
|
|
|
|
* e1000_alloc_queues - Allocate memory for all rings
|
|
|
|
* @adapter: board private structure to initialize
|
|
|
|
*
|
|
|
|
* We allocate one ring per queue at run-time since we don't know the
|
2008-12-04 06:07:10 +00:00
|
|
|
* number of queues at compile-time.
|
2005-10-04 11:01:55 +00:00
|
|
|
**/
|
2012-12-03 14:24:25 +00:00
|
|
|
static int e1000_alloc_queues(struct e1000_adapter *adapter)
|
2005-10-04 11:01:55 +00:00
|
|
|
{
|
2007-03-06 16:58:04 +00:00
|
|
|
adapter->tx_ring = kcalloc(adapter->num_tx_queues,
|
|
|
|
sizeof(struct e1000_tx_ring), GFP_KERNEL);
|
2005-10-04 11:01:55 +00:00
|
|
|
if (!adapter->tx_ring)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2007-03-06 16:58:04 +00:00
|
|
|
adapter->rx_ring = kcalloc(adapter->num_rx_queues,
|
|
|
|
sizeof(struct e1000_rx_ring), GFP_KERNEL);
|
2005-10-04 11:01:55 +00:00
|
|
|
if (!adapter->rx_ring) {
|
|
|
|
kfree(adapter->tx_ring);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
|
|
|
return E1000_SUCCESS;
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/**
|
|
|
|
* e1000_open - Called when a network interface is made active
|
|
|
|
* @netdev: network interface device structure
|
|
|
|
*
|
|
|
|
* Returns 0 on success, negative value on failure
|
|
|
|
*
|
|
|
|
* The open entry point is called when a network interface is made
|
|
|
|
* active by the system (IFF_UP). At this point all resources needed
|
|
|
|
* for transmit and receive operations are allocated, the interrupt
|
2011-10-05 07:24:41 +00:00
|
|
|
* handler is registered with the OS, the watchdog task is started,
|
2005-04-16 22:20:36 +00:00
|
|
|
* and the stack is notified that the interface is ready.
|
|
|
|
**/
|
2008-07-11 22:17:02 +00:00
|
|
|
static int e1000_open(struct net_device *netdev)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2005-06-18 00:41:45 +00:00
|
|
|
struct e1000_adapter *adapter = netdev_priv(netdev);
|
2008-07-11 22:17:08 +00:00
|
|
|
struct e1000_hw *hw = &adapter->hw;
|
2005-04-16 22:20:36 +00:00
|
|
|
int err;
|
|
|
|
|
2006-06-27 16:06:28 +00:00
|
|
|
/* disallow open during test */
|
2006-09-27 19:54:02 +00:00
|
|
|
if (test_bit(__E1000_TESTING, &adapter->flags))
|
2006-06-27 16:06:28 +00:00
|
|
|
return -EBUSY;
|
|
|
|
|
2009-04-17 20:44:36 +00:00
|
|
|
netif_carrier_off(netdev);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* allocate transmit descriptors */
|
2007-03-06 16:57:21 +00:00
|
|
|
err = e1000_setup_all_tx_resources(adapter);
|
|
|
|
if (err)
|
2005-04-16 22:20:36 +00:00
|
|
|
goto err_setup_tx;
|
|
|
|
|
|
|
|
/* allocate receive descriptors */
|
2007-03-06 16:57:21 +00:00
|
|
|
err = e1000_setup_all_rx_resources(adapter);
|
2007-02-21 19:21:44 +00:00
|
|
|
if (err)
|
2007-03-06 16:57:21 +00:00
|
|
|
goto err_setup_rx;
|
2007-02-21 19:21:44 +00:00
|
|
|
|
2006-06-27 16:06:32 +00:00
|
|
|
e1000_power_up_phy(adapter);
|
|
|
|
|
2005-04-29 02:43:52 +00:00
|
|
|
adapter->mng_vlan_id = E1000_MNG_VLAN_NONE;
|
2008-07-11 22:17:08 +00:00
|
|
|
if ((hw->mng_cookie.status &
|
2005-04-29 02:43:52 +00:00
|
|
|
E1000_MNG_DHCP_COOKIE_STATUS_VLAN_SUPPORT)) {
|
|
|
|
e1000_update_mng_vlan(adapter);
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-03-06 16:57:21 +00:00
|
|
|
/* before we allocate an interrupt, we must be ready to handle it.
|
|
|
|
* Setting DEBUG_SHIRQ in the kernel makes it fire an interrupt
|
|
|
|
* as soon as we call pci_request_irq, so we have to setup our
|
2013-02-09 12:49:21 +00:00
|
|
|
* clean_rx handler before we do so.
|
|
|
|
*/
|
2007-03-06 16:57:21 +00:00
|
|
|
e1000_configure(adapter);
|
|
|
|
|
|
|
|
err = e1000_request_irq(adapter);
|
|
|
|
if (err)
|
|
|
|
goto err_req_irq;
|
|
|
|
|
|
|
|
/* From here on the code is the same as e1000_up() */
|
|
|
|
clear_bit(__E1000_DOWN, &adapter->flags);
|
|
|
|
|
[NET]: Make NAPI polling independent of struct net_device objects.
Several devices have multiple independant RX queues per net
device, and some have a single interrupt doorbell for several
queues.
In either case, it's easier to support layouts like that if the
structure representing the poll is independant from the net
device itself.
The signature of the ->poll() call back goes from:
int foo_poll(struct net_device *dev, int *budget)
to
int foo_poll(struct napi_struct *napi, int budget)
The caller is returned the number of RX packets processed (or
the number of "NAPI credits" consumed if you want to get
abstract). The callee no longer messes around bumping
dev->quota, *budget, etc. because that is all handled in the
caller upon return.
The napi_struct is to be embedded in the device driver private data
structures.
Furthermore, it is the driver's responsibility to disable all NAPI
instances in it's ->stop() device close handler. Since the
napi_struct is privatized into the driver's private data structures,
only the driver knows how to get at all of the napi_struct instances
it may have per-device.
With lots of help and suggestions from Rusty Russell, Roland Dreier,
Michael Chan, Jeff Garzik, and Jamal Hadi Salim.
Bug fixes from Thomas Graf, Roland Dreier, Peter Zijlstra,
Joseph Fannin, Scott Wood, Hans J. Koch, and Michael Chan.
[ Ported to current tree and all drivers converted. Integrated
Stephen's follow-on kerneldoc additions, and restored poll_list
handling to the old style to fix mutual exclusion issues. -DaveM ]
Signed-off-by: Stephen Hemminger <shemminger@linux-foundation.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
2007-10-03 23:41:36 +00:00
|
|
|
napi_enable(&adapter->napi);
|
2007-05-29 22:07:31 +00:00
|
|
|
|
2007-03-06 16:57:21 +00:00
|
|
|
e1000_irq_enable(adapter);
|
|
|
|
|
2008-07-19 00:50:57 +00:00
|
|
|
netif_start_queue(netdev);
|
|
|
|
|
2007-03-06 16:57:21 +00:00
|
|
|
/* fire a link status change interrupt to start the watchdog */
|
2008-07-11 22:17:08 +00:00
|
|
|
ew32(ICS, E1000_ICS_LSC);
|
2007-03-06 16:57:21 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
return E1000_SUCCESS;
|
|
|
|
|
2007-02-21 19:21:44 +00:00
|
|
|
err_req_irq:
|
2007-03-06 16:57:21 +00:00
|
|
|
e1000_power_down_phy(adapter);
|
2005-10-04 11:01:55 +00:00
|
|
|
e1000_free_all_rx_resources(adapter);
|
2005-04-16 22:20:36 +00:00
|
|
|
err_setup_rx:
|
2005-10-04 11:01:55 +00:00
|
|
|
e1000_free_all_tx_resources(adapter);
|
2005-04-16 22:20:36 +00:00
|
|
|
err_setup_tx:
|
|
|
|
e1000_reset(adapter);
|
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* e1000_close - Disables a network interface
|
|
|
|
* @netdev: network interface device structure
|
|
|
|
*
|
|
|
|
* Returns 0, this is not allowed to fail
|
|
|
|
*
|
|
|
|
* The close entry point is called when an interface is de-activated
|
|
|
|
* by the OS. The hardware is still under the drivers control, but
|
|
|
|
* needs to be disabled. A global MAC reset is issued to stop the
|
|
|
|
* hardware, and all transmit and receive resources are freed.
|
|
|
|
**/
|
2008-07-11 22:17:02 +00:00
|
|
|
static int e1000_close(struct net_device *netdev)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2005-06-18 00:41:45 +00:00
|
|
|
struct e1000_adapter *adapter = netdev_priv(netdev);
|
2008-07-11 22:17:08 +00:00
|
|
|
struct e1000_hw *hw = &adapter->hw;
|
2013-11-23 07:07:40 +00:00
|
|
|
int count = E1000_CHECK_RESET_COUNT;
|
|
|
|
|
|
|
|
while (test_bit(__E1000_RESETTING, &adapter->flags) && count--)
|
|
|
|
usleep_range(10000, 20000);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-06-27 16:06:28 +00:00
|
|
|
WARN_ON(test_bit(__E1000_RESETTING, &adapter->flags));
|
2005-04-16 22:20:36 +00:00
|
|
|
e1000_down(adapter);
|
2006-06-27 16:06:32 +00:00
|
|
|
e1000_power_down_phy(adapter);
|
2006-06-27 16:06:28 +00:00
|
|
|
e1000_free_irq(adapter);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2005-10-04 11:01:55 +00:00
|
|
|
e1000_free_all_tx_resources(adapter);
|
|
|
|
e1000_free_all_rx_resources(adapter);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-09-27 19:54:08 +00:00
|
|
|
/* kill manageability vlan ID if supported, but not if a vlan with
|
2013-02-09 12:49:21 +00:00
|
|
|
* the same ID is registered on the host OS (let 8021q kill it)
|
|
|
|
*/
|
2008-07-11 22:17:08 +00:00
|
|
|
if ((hw->mng_cookie.status &
|
2013-02-09 12:49:21 +00:00
|
|
|
E1000_MNG_DHCP_COOKIE_STATUS_VLAN_SUPPORT) &&
|
|
|
|
!test_bit(adapter->mng_vlan_id, adapter->active_vlans)) {
|
2013-04-19 02:04:28 +00:00
|
|
|
e1000_vlan_rx_kill_vid(netdev, htons(ETH_P_8021Q),
|
|
|
|
adapter->mng_vlan_id);
|
2005-04-29 02:43:52 +00:00
|
|
|
}
|
2006-01-13 00:50:30 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* e1000_check_64k_bound - check that memory doesn't cross 64kB boundary
|
|
|
|
* @adapter: address of board private structure
|
2005-04-29 02:43:52 +00:00
|
|
|
* @start: address of beginning of memory
|
|
|
|
* @len: length of memory
|
2005-04-16 22:20:36 +00:00
|
|
|
**/
|
2008-07-11 22:17:02 +00:00
|
|
|
static bool e1000_check_64k_bound(struct e1000_adapter *adapter, void *start,
|
|
|
|
unsigned long len)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2008-07-11 22:17:08 +00:00
|
|
|
struct e1000_hw *hw = &adapter->hw;
|
2008-07-11 22:17:18 +00:00
|
|
|
unsigned long begin = (unsigned long)start;
|
2005-04-16 22:20:36 +00:00
|
|
|
unsigned long end = begin + len;
|
|
|
|
|
2005-04-29 02:44:46 +00:00
|
|
|
/* First rev 82545 and 82546 need to not allow any memory
|
2013-02-09 12:49:21 +00:00
|
|
|
* write location to cross 64k boundary due to errata 23
|
|
|
|
*/
|
2008-07-11 22:17:08 +00:00
|
|
|
if (hw->mac_type == e1000_82545 ||
|
2011-01-06 14:29:54 +00:00
|
|
|
hw->mac_type == e1000_ce4100 ||
|
2008-07-11 22:17:08 +00:00
|
|
|
hw->mac_type == e1000_82546) {
|
2008-03-21 18:06:25 +00:00
|
|
|
return ((begin ^ (end - 1)) >> 16) != 0 ? false : true;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2008-03-21 18:06:25 +00:00
|
|
|
return true;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* e1000_setup_tx_resources - allocate Tx resources (Descriptors)
|
|
|
|
* @adapter: board private structure
|
2005-10-04 11:01:55 +00:00
|
|
|
* @txdr: tx descriptor ring (for a specific queue) to setup
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
|
|
|
* Return 0 on success, negative on failure
|
|
|
|
**/
|
2008-07-11 22:17:02 +00:00
|
|
|
static int e1000_setup_tx_resources(struct e1000_adapter *adapter,
|
|
|
|
struct e1000_tx_ring *txdr)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct pci_dev *pdev = adapter->pdev;
|
|
|
|
int size;
|
|
|
|
|
|
|
|
size = sizeof(struct e1000_buffer) * txdr->count;
|
2010-11-22 00:15:06 +00:00
|
|
|
txdr->buffer_info = vzalloc(size);
|
2013-02-07 11:46:27 +00:00
|
|
|
if (!txdr->buffer_info)
|
2005-04-16 22:20:36 +00:00
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
/* round up to nearest 4K */
|
|
|
|
|
|
|
|
txdr->size = txdr->count * sizeof(struct e1000_tx_desc);
|
2007-04-27 20:55:29 +00:00
|
|
|
txdr->size = ALIGN(txdr->size, 4096);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2010-04-27 13:08:45 +00:00
|
|
|
txdr->desc = dma_alloc_coherent(&pdev->dev, txdr->size, &txdr->dma,
|
|
|
|
GFP_KERNEL);
|
2006-01-18 21:01:39 +00:00
|
|
|
if (!txdr->desc) {
|
2005-04-16 22:20:36 +00:00
|
|
|
setup_tx_desc_die:
|
|
|
|
vfree(txdr->buffer_info);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
2005-04-29 02:44:46 +00:00
|
|
|
/* Fix for errata 23, can't cross 64kB boundary */
|
2005-04-16 22:20:36 +00:00
|
|
|
if (!e1000_check_64k_bound(adapter, txdr->desc, txdr->size)) {
|
|
|
|
void *olddesc = txdr->desc;
|
|
|
|
dma_addr_t olddma = txdr->dma;
|
2010-07-27 06:37:21 +00:00
|
|
|
e_err(tx_err, "txdr align check failed: %u bytes at %p\n",
|
2010-04-27 14:02:58 +00:00
|
|
|
txdr->size, txdr->desc);
|
2005-04-29 02:44:46 +00:00
|
|
|
/* Try again, without freeing the previous */
|
2010-04-27 13:08:45 +00:00
|
|
|
txdr->desc = dma_alloc_coherent(&pdev->dev, txdr->size,
|
|
|
|
&txdr->dma, GFP_KERNEL);
|
2005-04-29 02:44:46 +00:00
|
|
|
/* Failed allocation, critical failure */
|
2006-01-18 21:01:39 +00:00
|
|
|
if (!txdr->desc) {
|
2010-04-27 13:08:45 +00:00
|
|
|
dma_free_coherent(&pdev->dev, txdr->size, olddesc,
|
|
|
|
olddma);
|
2005-04-16 22:20:36 +00:00
|
|
|
goto setup_tx_desc_die;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!e1000_check_64k_bound(adapter, txdr->desc, txdr->size)) {
|
|
|
|
/* give up */
|
2010-04-27 13:08:45 +00:00
|
|
|
dma_free_coherent(&pdev->dev, txdr->size, txdr->desc,
|
|
|
|
txdr->dma);
|
|
|
|
dma_free_coherent(&pdev->dev, txdr->size, olddesc,
|
|
|
|
olddma);
|
2010-07-27 06:37:21 +00:00
|
|
|
e_err(probe, "Unable to allocate aligned memory "
|
2010-04-27 14:02:58 +00:00
|
|
|
"for the transmit descriptor ring\n");
|
2005-04-16 22:20:36 +00:00
|
|
|
vfree(txdr->buffer_info);
|
|
|
|
return -ENOMEM;
|
|
|
|
} else {
|
2005-04-29 02:44:46 +00:00
|
|
|
/* Free old allocation, new allocation was successful */
|
2010-04-27 13:08:45 +00:00
|
|
|
dma_free_coherent(&pdev->dev, txdr->size, olddesc,
|
|
|
|
olddma);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
memset(txdr->desc, 0, txdr->size);
|
|
|
|
|
|
|
|
txdr->next_to_use = 0;
|
|
|
|
txdr->next_to_clean = 0;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-10-04 11:01:55 +00:00
|
|
|
/**
|
|
|
|
* e1000_setup_all_tx_resources - wrapper to allocate Tx resources
|
|
|
|
* (Descriptors) for all queues
|
|
|
|
* @adapter: board private structure
|
|
|
|
*
|
|
|
|
* Return 0 on success, negative on failure
|
|
|
|
**/
|
2008-07-11 22:17:02 +00:00
|
|
|
int e1000_setup_all_tx_resources(struct e1000_adapter *adapter)
|
2005-10-04 11:01:55 +00:00
|
|
|
{
|
|
|
|
int i, err = 0;
|
|
|
|
|
2006-01-13 00:50:39 +00:00
|
|
|
for (i = 0; i < adapter->num_tx_queues; i++) {
|
2005-10-04 11:01:55 +00:00
|
|
|
err = e1000_setup_tx_resources(adapter, &adapter->tx_ring[i]);
|
|
|
|
if (err) {
|
2010-07-27 06:37:21 +00:00
|
|
|
e_err(probe, "Allocation for Tx Queue %u failed\n", i);
|
2006-08-28 21:56:24 +00:00
|
|
|
for (i-- ; i >= 0; i--)
|
|
|
|
e1000_free_tx_resources(adapter,
|
|
|
|
&adapter->tx_ring[i]);
|
2005-10-04 11:01:55 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/**
|
|
|
|
* e1000_configure_tx - Configure 8254x Transmit Unit after Reset
|
|
|
|
* @adapter: board private structure
|
|
|
|
*
|
|
|
|
* Configure the Tx unit of the MAC after a reset.
|
|
|
|
**/
|
2008-07-11 22:17:02 +00:00
|
|
|
static void e1000_configure_tx(struct e1000_adapter *adapter)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2008-04-03 17:06:32 +00:00
|
|
|
u64 tdba;
|
2005-10-04 11:01:55 +00:00
|
|
|
struct e1000_hw *hw = &adapter->hw;
|
2009-09-25 12:16:14 +00:00
|
|
|
u32 tdlen, tctl, tipg;
|
2008-04-03 17:06:32 +00:00
|
|
|
u32 ipgr1, ipgr2;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* Setup the HW Tx Head and Tail descriptor pointers */
|
|
|
|
|
2006-01-13 00:50:39 +00:00
|
|
|
switch (adapter->num_tx_queues) {
|
2005-10-04 11:03:23 +00:00
|
|
|
case 1:
|
|
|
|
default:
|
2005-10-04 11:01:55 +00:00
|
|
|
tdba = adapter->tx_ring[0].dma;
|
|
|
|
tdlen = adapter->tx_ring[0].count *
|
|
|
|
sizeof(struct e1000_tx_desc);
|
2008-07-11 22:17:08 +00:00
|
|
|
ew32(TDLEN, tdlen);
|
|
|
|
ew32(TDBAH, (tdba >> 32));
|
|
|
|
ew32(TDBAL, (tdba & 0x00000000ffffffffULL));
|
|
|
|
ew32(TDT, 0);
|
|
|
|
ew32(TDH, 0);
|
2013-02-09 12:49:21 +00:00
|
|
|
adapter->tx_ring[0].tdh = ((hw->mac_type >= e1000_82543) ?
|
|
|
|
E1000_TDH : E1000_82542_TDH);
|
|
|
|
adapter->tx_ring[0].tdt = ((hw->mac_type >= e1000_82543) ?
|
|
|
|
E1000_TDT : E1000_82542_TDT);
|
2005-10-04 11:03:23 +00:00
|
|
|
break;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* Set the default values for the Tx Inter Packet Gap timer */
|
2009-09-25 12:16:14 +00:00
|
|
|
if ((hw->media_type == e1000_media_type_fiber ||
|
2006-12-15 09:38:32 +00:00
|
|
|
hw->media_type == e1000_media_type_internal_serdes))
|
2006-01-13 00:51:05 +00:00
|
|
|
tipg = DEFAULT_82543_TIPG_IPGT_FIBER;
|
|
|
|
else
|
|
|
|
tipg = DEFAULT_82543_TIPG_IPGT_COPPER;
|
|
|
|
|
2005-10-04 11:01:55 +00:00
|
|
|
switch (hw->mac_type) {
|
2005-04-16 22:20:36 +00:00
|
|
|
case e1000_82542_rev2_0:
|
|
|
|
case e1000_82542_rev2_1:
|
|
|
|
tipg = DEFAULT_82542_TIPG_IPGT;
|
2006-01-13 00:51:05 +00:00
|
|
|
ipgr1 = DEFAULT_82542_TIPG_IPGR1;
|
|
|
|
ipgr2 = DEFAULT_82542_TIPG_IPGR2;
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
|
|
|
default:
|
2006-01-13 00:51:05 +00:00
|
|
|
ipgr1 = DEFAULT_82543_TIPG_IPGR1;
|
|
|
|
ipgr2 = DEFAULT_82543_TIPG_IPGR2;
|
|
|
|
break;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2006-01-13 00:51:05 +00:00
|
|
|
tipg |= ipgr1 << E1000_TIPG_IPGR1_SHIFT;
|
|
|
|
tipg |= ipgr2 << E1000_TIPG_IPGR2_SHIFT;
|
2008-07-11 22:17:08 +00:00
|
|
|
ew32(TIPG, tipg);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* Set the Tx Interrupt Delay register */
|
|
|
|
|
2008-07-11 22:17:08 +00:00
|
|
|
ew32(TIDV, adapter->tx_int_delay);
|
2005-10-04 11:01:55 +00:00
|
|
|
if (hw->mac_type >= e1000_82540)
|
2008-07-11 22:17:08 +00:00
|
|
|
ew32(TADV, adapter->tx_abs_int_delay);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* Program the Transmit Control Register */
|
|
|
|
|
2008-07-11 22:17:08 +00:00
|
|
|
tctl = er32(TCTL);
|
2005-04-16 22:20:36 +00:00
|
|
|
tctl &= ~E1000_TCTL_CT;
|
2006-03-03 02:19:30 +00:00
|
|
|
tctl |= E1000_TCTL_PSP | E1000_TCTL_RTLC |
|
2005-04-16 22:20:36 +00:00
|
|
|
(E1000_COLLISION_THRESHOLD << E1000_CT_SHIFT);
|
|
|
|
|
2005-10-04 11:01:55 +00:00
|
|
|
e1000_config_collision_dist(hw);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* Setup Transmit Descriptor Settings for eop descriptor */
|
2006-11-01 16:48:04 +00:00
|
|
|
adapter->txd_cmd = E1000_TXD_CMD_EOP | E1000_TXD_CMD_IFCS;
|
|
|
|
|
|
|
|
/* only set IDE if we are delaying interrupts using the timers */
|
|
|
|
if (adapter->tx_int_delay)
|
|
|
|
adapter->txd_cmd |= E1000_TXD_CMD_IDE;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2005-10-04 11:01:55 +00:00
|
|
|
if (hw->mac_type < e1000_82543)
|
2005-04-16 22:20:36 +00:00
|
|
|
adapter->txd_cmd |= E1000_TXD_CMD_RPS;
|
|
|
|
else
|
|
|
|
adapter->txd_cmd |= E1000_TXD_CMD_RS;
|
|
|
|
|
|
|
|
/* Cache if we're 82544 running in PCI-X because we'll
|
2013-02-09 12:49:21 +00:00
|
|
|
* need this to apply a workaround later in the send path.
|
|
|
|
*/
|
2005-10-04 11:01:55 +00:00
|
|
|
if (hw->mac_type == e1000_82544 &&
|
|
|
|
hw->bus_type == e1000_bus_type_pcix)
|
2011-12-19 13:56:45 +00:00
|
|
|
adapter->pcix_82544 = true;
|
2006-03-03 02:19:30 +00:00
|
|
|
|
2008-07-11 22:17:08 +00:00
|
|
|
ew32(TCTL, tctl);
|
2006-03-03 02:19:30 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* e1000_setup_rx_resources - allocate Rx resources (Descriptors)
|
|
|
|
* @adapter: board private structure
|
2005-10-04 11:01:55 +00:00
|
|
|
* @rxdr: rx descriptor ring (for a specific queue) to setup
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
|
|
|
* Returns 0 on success, negative on failure
|
|
|
|
**/
|
2008-07-11 22:17:02 +00:00
|
|
|
static int e1000_setup_rx_resources(struct e1000_adapter *adapter,
|
|
|
|
struct e1000_rx_ring *rxdr)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct pci_dev *pdev = adapter->pdev;
|
2005-04-29 02:43:52 +00:00
|
|
|
int size, desc_len;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
size = sizeof(struct e1000_buffer) * rxdr->count;
|
2010-11-22 00:15:06 +00:00
|
|
|
rxdr->buffer_info = vzalloc(size);
|
2013-02-07 11:46:27 +00:00
|
|
|
if (!rxdr->buffer_info)
|
2005-04-16 22:20:36 +00:00
|
|
|
return -ENOMEM;
|
|
|
|
|
2009-09-25 12:16:14 +00:00
|
|
|
desc_len = sizeof(struct e1000_rx_desc);
|
2005-04-29 02:43:52 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* Round up to nearest 4K */
|
|
|
|
|
2005-04-29 02:43:52 +00:00
|
|
|
rxdr->size = rxdr->count * desc_len;
|
2007-04-27 20:55:29 +00:00
|
|
|
rxdr->size = ALIGN(rxdr->size, 4096);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2010-04-27 13:08:45 +00:00
|
|
|
rxdr->desc = dma_alloc_coherent(&pdev->dev, rxdr->size, &rxdr->dma,
|
|
|
|
GFP_KERNEL);
|
2005-10-04 11:01:55 +00:00
|
|
|
if (!rxdr->desc) {
|
2005-04-16 22:20:36 +00:00
|
|
|
setup_rx_desc_die:
|
|
|
|
vfree(rxdr->buffer_info);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
2005-04-29 02:44:46 +00:00
|
|
|
/* Fix for errata 23, can't cross 64kB boundary */
|
2005-04-16 22:20:36 +00:00
|
|
|
if (!e1000_check_64k_bound(adapter, rxdr->desc, rxdr->size)) {
|
|
|
|
void *olddesc = rxdr->desc;
|
|
|
|
dma_addr_t olddma = rxdr->dma;
|
2010-07-27 06:37:21 +00:00
|
|
|
e_err(rx_err, "rxdr align check failed: %u bytes at %p\n",
|
2010-04-27 14:02:58 +00:00
|
|
|
rxdr->size, rxdr->desc);
|
2005-04-29 02:44:46 +00:00
|
|
|
/* Try again, without freeing the previous */
|
2010-04-27 13:08:45 +00:00
|
|
|
rxdr->desc = dma_alloc_coherent(&pdev->dev, rxdr->size,
|
|
|
|
&rxdr->dma, GFP_KERNEL);
|
2005-04-29 02:44:46 +00:00
|
|
|
/* Failed allocation, critical failure */
|
2005-10-04 11:01:55 +00:00
|
|
|
if (!rxdr->desc) {
|
2010-04-27 13:08:45 +00:00
|
|
|
dma_free_coherent(&pdev->dev, rxdr->size, olddesc,
|
|
|
|
olddma);
|
2005-04-16 22:20:36 +00:00
|
|
|
goto setup_rx_desc_die;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!e1000_check_64k_bound(adapter, rxdr->desc, rxdr->size)) {
|
|
|
|
/* give up */
|
2010-04-27 13:08:45 +00:00
|
|
|
dma_free_coherent(&pdev->dev, rxdr->size, rxdr->desc,
|
|
|
|
rxdr->dma);
|
|
|
|
dma_free_coherent(&pdev->dev, rxdr->size, olddesc,
|
|
|
|
olddma);
|
2010-07-27 06:37:21 +00:00
|
|
|
e_err(probe, "Unable to allocate aligned memory for "
|
|
|
|
"the Rx descriptor ring\n");
|
2005-10-04 11:01:55 +00:00
|
|
|
goto setup_rx_desc_die;
|
2005-04-16 22:20:36 +00:00
|
|
|
} else {
|
2005-04-29 02:44:46 +00:00
|
|
|
/* Free old allocation, new allocation was successful */
|
2010-04-27 13:08:45 +00:00
|
|
|
dma_free_coherent(&pdev->dev, rxdr->size, olddesc,
|
|
|
|
olddma);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
memset(rxdr->desc, 0, rxdr->size);
|
|
|
|
|
|
|
|
rxdr->next_to_clean = 0;
|
|
|
|
rxdr->next_to_use = 0;
|
2009-07-06 10:44:39 +00:00
|
|
|
rxdr->rx_skb_top = NULL;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-10-04 11:01:55 +00:00
|
|
|
/**
|
|
|
|
* e1000_setup_all_rx_resources - wrapper to allocate Rx resources
|
|
|
|
* (Descriptors) for all queues
|
|
|
|
* @adapter: board private structure
|
|
|
|
*
|
|
|
|
* Return 0 on success, negative on failure
|
|
|
|
**/
|
2008-07-11 22:17:02 +00:00
|
|
|
int e1000_setup_all_rx_resources(struct e1000_adapter *adapter)
|
2005-10-04 11:01:55 +00:00
|
|
|
{
|
|
|
|
int i, err = 0;
|
|
|
|
|
2006-01-13 00:50:39 +00:00
|
|
|
for (i = 0; i < adapter->num_rx_queues; i++) {
|
2005-10-04 11:01:55 +00:00
|
|
|
err = e1000_setup_rx_resources(adapter, &adapter->rx_ring[i]);
|
|
|
|
if (err) {
|
2010-07-27 06:37:21 +00:00
|
|
|
e_err(probe, "Allocation for Rx Queue %u failed\n", i);
|
2006-08-28 21:56:24 +00:00
|
|
|
for (i-- ; i >= 0; i--)
|
|
|
|
e1000_free_rx_resources(adapter,
|
|
|
|
&adapter->rx_ring[i]);
|
2005-10-04 11:01:55 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/**
|
2005-04-29 02:44:46 +00:00
|
|
|
* e1000_setup_rctl - configure the receive control registers
|
2005-04-16 22:20:36 +00:00
|
|
|
* @adapter: Board private structure
|
|
|
|
**/
|
2008-07-11 22:17:02 +00:00
|
|
|
static void e1000_setup_rctl(struct e1000_adapter *adapter)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2008-07-11 22:17:08 +00:00
|
|
|
struct e1000_hw *hw = &adapter->hw;
|
2008-09-16 20:01:28 +00:00
|
|
|
u32 rctl;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-07-11 22:17:08 +00:00
|
|
|
rctl = er32(RCTL);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
rctl &= ~(3 << E1000_RCTL_MO_SHIFT);
|
|
|
|
|
e1000: don't enable dma receives until after dma address has been setup
Doing an 'ifconfig ethN down' followed by an 'ifconfig ethN up' on a qemu-kvm
guest system configured with two e1000 NICs can result in an 'unable to handle
kernel paging request at 0000000100000000' or 'bad page map in process ...' or
something similar.
These result from a 4096-byte page being corrupted with the following two-word
pattern (16-bytes) repeated throughout the entire page:
0x0000000000000000
0x0000000100000000
There can be other bits set as well. What is a constant is that the 2nd word
has the 32nd bit set. So one could see:
:
0x0000000000000000
0x0000000100000000
0x0000000000000000
0x0000000172adc067 <<< bad pte
0x800000006ec60067
0x0000000700000040
0x0000000000000000
0x0000000100000000
:
Which came from from a process' page table I dumped out when the marked line
was seen as bad by print_bad_pte().
The repeating pattern represents the e1000's two-word receive descriptor:
struct e1000_rx_desc {
__le64 buffer_addr; /* Address of the descriptor's data buffer */
__le16 length; /* Length of data DMAed into data buffer */
__le16 csum; /* Packet checksum */
u8 status; /* Descriptor status */
u8 errors; /* Descriptor Errors */
__le16 special;
};
And the 32nd bit of the 2nd word maps to the 'u8 status' member, and
corresponds to E1000_RXD_STAT_DD which indicates the descriptor is done.
The corruption appears to result from the following...
. An 'ifconfig ethN down' gets us into e1000_close(), which through a number
of subfunctions results in:
1. E1000_RCTL_EN being cleared in RCTL register. [e1000_down()]
2. dma_free_coherent() being called. [e1000_free_rx_resources()]
. An 'ifconfig ethN up' gets us into e1000_open(), which through a number of
subfunctions results in:
1. dma_alloc_coherent() being called. [e1000_setup_rx_resources()]
2. E1000_RCTL_EN being set in RCTL register. [e1000_setup_rctl()]
3. E1000_RCTL_EN being cleared in RCTL register. [e1000_configure_rx()]
4. RDLEN, RDBAH and RDBAL registers being set to reflect the dma page
allocated in step 1. [e1000_configure_rx()]
5. E1000_RCTL_EN being set in RCTL register. [e1000_configure_rx()]
During the 'ifconfig ethN up' there is a window opened, starting in step 2
where the receives are enabled up until they are disabled in step 3, in which
the address of the receive descriptor dma page known by the NIC is still the
previous one which was freed during the 'ifconfig ethN down'. If this memory
has been reallocated for some other use and the NIC feels so inclined, it will
write to that former dma page with predictably unpleasant results.
I realize that in the guest, we're dealing with an e1000 NIC that is software
emulated by qemu-kvm. The problem doesn't appear to occur on bare-metal. Andy
suspects that this is because in the emulator link-up is essentially instant
and traffic can start flowing immediately. Whereas on bare-metal, link-up
usually seems to take at least a few milliseconds. And this might be enough
to prevent traffic from flowing into the device inside the window where
E1000_RCTL_EN is set.
So perhaps a modification needs to be made to the qemu-kvm e1000 NIC emulator
to delay the link-up. But in defense of the emulator, it seems like a bad idea
to enable dma operations before the address of the memory to be involved has
been made known.
The following patch no longer enables receives in e1000_setup_rctl() but leaves
them however they were. It only enables receives in e1000_configure_rx(), and
only after the dma address has been made known to the hardware.
There are two places where e1000_setup_rctl() gets called. The one in
e1000_configure() is followed immediately by a call to e1000_configure_rx(), so
there's really no change functionally (except for the removal of the problem
window. The other is in __e1000_shutdown() and is not followed by a call to
e1000_configure_rx(), so there is a change functionally. But consider...
. An 'ifconfig ethN down' (just as described above).
. A 'suspend' of the system, which (I'm assuming) will find its way into
e1000_suspend() which calls __e1000_shutdown() resulting in:
1. E1000_RCTL_EN being set in RCTL register. [e1000_setup_rctl()]
And again we've re-opened the problem window for some unknown amount of time.
Signed-off-by: Andy Gospodarek <andy@greyhouse.net>
Signed-off-by: Dean Nelson <dnelson@redhat.com>
Signed-off-by: Jeff Kirsher <jeffrey.t.kirsher@intel.com>
2011-09-16 16:52:54 +00:00
|
|
|
rctl |= E1000_RCTL_BAM | E1000_RCTL_LBM_NO |
|
|
|
|
E1000_RCTL_RDMTS_HALF |
|
2008-07-11 22:17:08 +00:00
|
|
|
(hw->mc_filter_type << E1000_RCTL_MO_SHIFT);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-07-11 22:17:08 +00:00
|
|
|
if (hw->tbi_compatibility_on == 1)
|
2005-04-16 22:20:36 +00:00
|
|
|
rctl |= E1000_RCTL_SBP;
|
|
|
|
else
|
|
|
|
rctl &= ~E1000_RCTL_SBP;
|
|
|
|
|
2005-04-29 02:43:52 +00:00
|
|
|
if (adapter->netdev->mtu <= ETH_DATA_LEN)
|
|
|
|
rctl &= ~E1000_RCTL_LPE;
|
|
|
|
else
|
|
|
|
rctl |= E1000_RCTL_LPE;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* Setup buffer sizes */
|
2006-04-15 02:05:18 +00:00
|
|
|
rctl &= ~E1000_RCTL_SZ_4096;
|
|
|
|
rctl |= E1000_RCTL_BSEX;
|
|
|
|
switch (adapter->rx_buffer_len) {
|
2006-03-01 04:24:07 +00:00
|
|
|
case E1000_RXBUFFER_2048:
|
|
|
|
default:
|
|
|
|
rctl |= E1000_RCTL_SZ_2048;
|
|
|
|
rctl &= ~E1000_RCTL_BSEX;
|
|
|
|
break;
|
|
|
|
case E1000_RXBUFFER_4096:
|
|
|
|
rctl |= E1000_RCTL_SZ_4096;
|
|
|
|
break;
|
|
|
|
case E1000_RXBUFFER_8192:
|
|
|
|
rctl |= E1000_RCTL_SZ_8192;
|
|
|
|
break;
|
|
|
|
case E1000_RXBUFFER_16384:
|
|
|
|
rctl |= E1000_RCTL_SZ_16384;
|
|
|
|
break;
|
2005-04-29 02:43:52 +00:00
|
|
|
}
|
|
|
|
|
2012-04-04 06:01:29 +00:00
|
|
|
/* This is useful for sniffing bad packets. */
|
|
|
|
if (adapter->netdev->features & NETIF_F_RXALL) {
|
|
|
|
/* UPE and MPE will be handled by normal PROMISC logic
|
2013-02-09 12:49:21 +00:00
|
|
|
* in e1000e_set_rx_mode
|
|
|
|
*/
|
2012-04-04 06:01:29 +00:00
|
|
|
rctl |= (E1000_RCTL_SBP | /* Receive bad packets */
|
|
|
|
E1000_RCTL_BAM | /* RX All Bcast Pkts */
|
|
|
|
E1000_RCTL_PMCF); /* RX All MAC Ctrl Pkts */
|
|
|
|
|
|
|
|
rctl &= ~(E1000_RCTL_VFE | /* Disable VLAN filter */
|
|
|
|
E1000_RCTL_DPF | /* Allow filtered pause */
|
|
|
|
E1000_RCTL_CFIEN); /* Dis VLAN CFIEN Filter */
|
|
|
|
/* Do not mess with E1000_CTRL_VME, it affects transmit as well,
|
|
|
|
* and that breaks VLANs.
|
|
|
|
*/
|
|
|
|
}
|
|
|
|
|
2008-07-11 22:17:08 +00:00
|
|
|
ew32(RCTL, rctl);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* e1000_configure_rx - Configure 8254x Receive Unit after Reset
|
|
|
|
* @adapter: board private structure
|
|
|
|
*
|
|
|
|
* Configure the Rx unit of the MAC after a reset.
|
|
|
|
**/
|
2008-07-11 22:17:02 +00:00
|
|
|
static void e1000_configure_rx(struct e1000_adapter *adapter)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2008-04-03 17:06:32 +00:00
|
|
|
u64 rdba;
|
2005-10-04 11:01:55 +00:00
|
|
|
struct e1000_hw *hw = &adapter->hw;
|
2009-09-25 12:16:14 +00:00
|
|
|
u32 rdlen, rctl, rxcsum;
|
2005-04-29 02:43:52 +00:00
|
|
|
|
2009-07-06 10:44:39 +00:00
|
|
|
if (adapter->netdev->mtu > ETH_DATA_LEN) {
|
|
|
|
rdlen = adapter->rx_ring[0].count *
|
|
|
|
sizeof(struct e1000_rx_desc);
|
|
|
|
adapter->clean_rx = e1000_clean_jumbo_rx_irq;
|
|
|
|
adapter->alloc_rx_buf = e1000_alloc_jumbo_rx_buffers;
|
|
|
|
} else {
|
|
|
|
rdlen = adapter->rx_ring[0].count *
|
|
|
|
sizeof(struct e1000_rx_desc);
|
|
|
|
adapter->clean_rx = e1000_clean_rx_irq;
|
|
|
|
adapter->alloc_rx_buf = e1000_alloc_rx_buffers;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* disable receives while setting up the descriptors */
|
2008-07-11 22:17:08 +00:00
|
|
|
rctl = er32(RCTL);
|
|
|
|
ew32(RCTL, rctl & ~E1000_RCTL_EN);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* set the Receive Delay Timer Register */
|
2008-07-11 22:17:08 +00:00
|
|
|
ew32(RDTR, adapter->rx_int_delay);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2005-10-04 11:01:55 +00:00
|
|
|
if (hw->mac_type >= e1000_82540) {
|
2008-07-11 22:17:08 +00:00
|
|
|
ew32(RADV, adapter->rx_abs_int_delay);
|
e1000: add dynamic itr modes
Add a new dynamic itr algorithm, with 2 modes, and make it the default
operation mode. This greatly reduces latency and increases small packet
performance, at the "cost" of some CPU utilization. Bulk traffic
throughput is unaffected.
The driver can limit the amount of interrupts per second that the
adapter will generate for incoming packets. It does this by writing a
value to the adapter that is based on the maximum amount of interrupts
that the adapter will generate per second.
Setting InterruptThrottleRate to a value greater or equal to 100 will
program the adapter to send out a maximum of that many interrupts per
second, even if more packets have come in. This reduces interrupt
load on the system and can lower CPU utilization under heavy load,
but will increase latency as packets are not processed as quickly.
The default behaviour of the driver previously assumed a static
InterruptThrottleRate value of 8000, providing a good fallback value
for all traffic types,but lacking in small packet performance and
latency. The hardware can handle many more small packets per second
however, and for this reason an adaptive interrupt moderation algorithm
was implemented.
Since 7.3.x, the driver has two adaptive modes (setting 1 or 3) in
which it dynamically adjusts the InterruptThrottleRate value based on
the traffic that it receives. After determining the type of incoming
traffic in the last timeframe, it will adjust the InterruptThrottleRate
to an appropriate value for that traffic.
The algorithm classifies the incoming traffic every interval into
classes. Once the class is determined, the InterruptThrottleRate
value is adjusted to suit that traffic type the best. There are
three classes defined: "Bulk traffic", for large amounts of packets
of normal size; "Low latency", for small amounts of traffic and/or
a significant percentage of small packets; and "Lowest latency",
for almost completely small packets or minimal traffic.
In dynamic conservative mode, the InterruptThrottleRate value is
set to 4000 for traffic that falls in class "Bulk traffic". If
traffic falls in the "Low latency" or "Lowest latency" class, the
InterruptThrottleRate is increased stepwise to 20000. This default
mode is suitable for most applications.
For situations where low latency is vital such as cluster or
grid computing, the algorithm can reduce latency even more when
InterruptThrottleRate is set to mode 1. In this mode, which operates
the same as mode 3, the InterruptThrottleRate will be increased
stepwise to 70000 for traffic in class "Lowest latency".
Setting InterruptThrottleRate to 0 turns off any interrupt moderation
and may improve small packet latency, but is generally not suitable
for bulk throughput traffic.
Signed-off-by: Jesse Brandeburg <jesse.brandeburg@intel.com>
Cc: Rick Jones <rick.jones2@hp.com>
Signed-off-by: Auke Kok <auke-jan.h.kok@intel.com>
2006-11-01 16:48:13 +00:00
|
|
|
if (adapter->itr_setting != 0)
|
2008-07-11 22:17:08 +00:00
|
|
|
ew32(ITR, 1000000000 / (adapter->itr * 256));
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2005-10-04 11:01:55 +00:00
|
|
|
/* Setup the HW Rx Head and Tail Descriptor Pointers and
|
2013-02-09 12:49:21 +00:00
|
|
|
* the Base and Length of the Rx Descriptor Ring
|
|
|
|
*/
|
2006-01-13 00:50:39 +00:00
|
|
|
switch (adapter->num_rx_queues) {
|
2005-10-04 11:03:23 +00:00
|
|
|
case 1:
|
|
|
|
default:
|
2005-10-04 11:01:55 +00:00
|
|
|
rdba = adapter->rx_ring[0].dma;
|
2008-07-11 22:17:08 +00:00
|
|
|
ew32(RDLEN, rdlen);
|
|
|
|
ew32(RDBAH, (rdba >> 32));
|
|
|
|
ew32(RDBAL, (rdba & 0x00000000ffffffffULL));
|
|
|
|
ew32(RDT, 0);
|
|
|
|
ew32(RDH, 0);
|
2013-02-09 12:49:21 +00:00
|
|
|
adapter->rx_ring[0].rdh = ((hw->mac_type >= e1000_82543) ?
|
|
|
|
E1000_RDH : E1000_82542_RDH);
|
|
|
|
adapter->rx_ring[0].rdt = ((hw->mac_type >= e1000_82543) ?
|
|
|
|
E1000_RDT : E1000_82542_RDT);
|
2005-10-04 11:01:55 +00:00
|
|
|
break;
|
2005-10-04 11:03:23 +00:00
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* Enable 82543 Receive Checksum Offload for TCP and UDP */
|
2005-10-04 11:01:55 +00:00
|
|
|
if (hw->mac_type >= e1000_82543) {
|
2008-07-11 22:17:08 +00:00
|
|
|
rxcsum = er32(RXCSUM);
|
2008-09-16 20:01:28 +00:00
|
|
|
if (adapter->rx_csum)
|
2005-04-29 02:43:52 +00:00
|
|
|
rxcsum |= E1000_RXCSUM_TUOFL;
|
2008-09-16 20:01:28 +00:00
|
|
|
else
|
2005-04-29 02:43:52 +00:00
|
|
|
/* don't need to clear IPPCSE as it defaults to 0 */
|
2008-09-16 20:01:28 +00:00
|
|
|
rxcsum &= ~E1000_RXCSUM_TUOFL;
|
2008-07-11 22:17:08 +00:00
|
|
|
ew32(RXCSUM, rxcsum);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Enable Receives */
|
e1000: don't enable dma receives until after dma address has been setup
Doing an 'ifconfig ethN down' followed by an 'ifconfig ethN up' on a qemu-kvm
guest system configured with two e1000 NICs can result in an 'unable to handle
kernel paging request at 0000000100000000' or 'bad page map in process ...' or
something similar.
These result from a 4096-byte page being corrupted with the following two-word
pattern (16-bytes) repeated throughout the entire page:
0x0000000000000000
0x0000000100000000
There can be other bits set as well. What is a constant is that the 2nd word
has the 32nd bit set. So one could see:
:
0x0000000000000000
0x0000000100000000
0x0000000000000000
0x0000000172adc067 <<< bad pte
0x800000006ec60067
0x0000000700000040
0x0000000000000000
0x0000000100000000
:
Which came from from a process' page table I dumped out when the marked line
was seen as bad by print_bad_pte().
The repeating pattern represents the e1000's two-word receive descriptor:
struct e1000_rx_desc {
__le64 buffer_addr; /* Address of the descriptor's data buffer */
__le16 length; /* Length of data DMAed into data buffer */
__le16 csum; /* Packet checksum */
u8 status; /* Descriptor status */
u8 errors; /* Descriptor Errors */
__le16 special;
};
And the 32nd bit of the 2nd word maps to the 'u8 status' member, and
corresponds to E1000_RXD_STAT_DD which indicates the descriptor is done.
The corruption appears to result from the following...
. An 'ifconfig ethN down' gets us into e1000_close(), which through a number
of subfunctions results in:
1. E1000_RCTL_EN being cleared in RCTL register. [e1000_down()]
2. dma_free_coherent() being called. [e1000_free_rx_resources()]
. An 'ifconfig ethN up' gets us into e1000_open(), which through a number of
subfunctions results in:
1. dma_alloc_coherent() being called. [e1000_setup_rx_resources()]
2. E1000_RCTL_EN being set in RCTL register. [e1000_setup_rctl()]
3. E1000_RCTL_EN being cleared in RCTL register. [e1000_configure_rx()]
4. RDLEN, RDBAH and RDBAL registers being set to reflect the dma page
allocated in step 1. [e1000_configure_rx()]
5. E1000_RCTL_EN being set in RCTL register. [e1000_configure_rx()]
During the 'ifconfig ethN up' there is a window opened, starting in step 2
where the receives are enabled up until they are disabled in step 3, in which
the address of the receive descriptor dma page known by the NIC is still the
previous one which was freed during the 'ifconfig ethN down'. If this memory
has been reallocated for some other use and the NIC feels so inclined, it will
write to that former dma page with predictably unpleasant results.
I realize that in the guest, we're dealing with an e1000 NIC that is software
emulated by qemu-kvm. The problem doesn't appear to occur on bare-metal. Andy
suspects that this is because in the emulator link-up is essentially instant
and traffic can start flowing immediately. Whereas on bare-metal, link-up
usually seems to take at least a few milliseconds. And this might be enough
to prevent traffic from flowing into the device inside the window where
E1000_RCTL_EN is set.
So perhaps a modification needs to be made to the qemu-kvm e1000 NIC emulator
to delay the link-up. But in defense of the emulator, it seems like a bad idea
to enable dma operations before the address of the memory to be involved has
been made known.
The following patch no longer enables receives in e1000_setup_rctl() but leaves
them however they were. It only enables receives in e1000_configure_rx(), and
only after the dma address has been made known to the hardware.
There are two places where e1000_setup_rctl() gets called. The one in
e1000_configure() is followed immediately by a call to e1000_configure_rx(), so
there's really no change functionally (except for the removal of the problem
window. The other is in __e1000_shutdown() and is not followed by a call to
e1000_configure_rx(), so there is a change functionally. But consider...
. An 'ifconfig ethN down' (just as described above).
. A 'suspend' of the system, which (I'm assuming) will find its way into
e1000_suspend() which calls __e1000_shutdown() resulting in:
1. E1000_RCTL_EN being set in RCTL register. [e1000_setup_rctl()]
And again we've re-opened the problem window for some unknown amount of time.
Signed-off-by: Andy Gospodarek <andy@greyhouse.net>
Signed-off-by: Dean Nelson <dnelson@redhat.com>
Signed-off-by: Jeff Kirsher <jeffrey.t.kirsher@intel.com>
2011-09-16 16:52:54 +00:00
|
|
|
ew32(RCTL, rctl | E1000_RCTL_EN);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2005-10-04 11:01:55 +00:00
|
|
|
* e1000_free_tx_resources - Free Tx Resources per Queue
|
2005-04-16 22:20:36 +00:00
|
|
|
* @adapter: board private structure
|
2005-10-04 11:01:55 +00:00
|
|
|
* @tx_ring: Tx descriptor ring for a specific queue
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
|
|
|
* Free all transmit software resources
|
|
|
|
**/
|
2008-07-11 22:17:02 +00:00
|
|
|
static void e1000_free_tx_resources(struct e1000_adapter *adapter,
|
|
|
|
struct e1000_tx_ring *tx_ring)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct pci_dev *pdev = adapter->pdev;
|
|
|
|
|
2005-10-04 11:01:55 +00:00
|
|
|
e1000_clean_tx_ring(adapter, tx_ring);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2005-10-04 11:01:55 +00:00
|
|
|
vfree(tx_ring->buffer_info);
|
|
|
|
tx_ring->buffer_info = NULL;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2010-04-27 13:08:45 +00:00
|
|
|
dma_free_coherent(&pdev->dev, tx_ring->size, tx_ring->desc,
|
|
|
|
tx_ring->dma);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2005-10-04 11:01:55 +00:00
|
|
|
tx_ring->desc = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* e1000_free_all_tx_resources - Free Tx Resources for All Queues
|
|
|
|
* @adapter: board private structure
|
|
|
|
*
|
|
|
|
* Free all transmit software resources
|
|
|
|
**/
|
2008-07-11 22:17:02 +00:00
|
|
|
void e1000_free_all_tx_resources(struct e1000_adapter *adapter)
|
2005-10-04 11:01:55 +00:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
2006-01-13 00:50:39 +00:00
|
|
|
for (i = 0; i < adapter->num_tx_queues; i++)
|
2005-10-04 11:01:55 +00:00
|
|
|
e1000_free_tx_resources(adapter, &adapter->tx_ring[i]);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2008-07-11 22:17:02 +00:00
|
|
|
static void e1000_unmap_and_free_tx_resource(struct e1000_adapter *adapter,
|
|
|
|
struct e1000_buffer *buffer_info)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2009-12-02 16:46:00 +00:00
|
|
|
if (buffer_info->dma) {
|
|
|
|
if (buffer_info->mapped_as_page)
|
2010-04-27 13:08:45 +00:00
|
|
|
dma_unmap_page(&adapter->pdev->dev, buffer_info->dma,
|
|
|
|
buffer_info->length, DMA_TO_DEVICE);
|
2009-12-02 16:46:00 +00:00
|
|
|
else
|
2010-04-27 13:08:45 +00:00
|
|
|
dma_unmap_single(&adapter->pdev->dev, buffer_info->dma,
|
2009-12-02 16:46:00 +00:00
|
|
|
buffer_info->length,
|
2010-04-27 13:08:45 +00:00
|
|
|
DMA_TO_DEVICE);
|
2009-12-02 16:46:00 +00:00
|
|
|
buffer_info->dma = 0;
|
|
|
|
}
|
2006-11-01 16:47:53 +00:00
|
|
|
if (buffer_info->skb) {
|
2005-04-16 22:20:36 +00:00
|
|
|
dev_kfree_skb_any(buffer_info->skb);
|
2006-11-01 16:47:53 +00:00
|
|
|
buffer_info->skb = NULL;
|
|
|
|
}
|
2009-03-25 21:58:45 +00:00
|
|
|
buffer_info->time_stamp = 0;
|
2006-11-01 16:47:53 +00:00
|
|
|
/* buffer_info must be completely set up in the transmit path */
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* e1000_clean_tx_ring - Free Tx Buffers
|
|
|
|
* @adapter: board private structure
|
2005-10-04 11:01:55 +00:00
|
|
|
* @tx_ring: ring to be cleaned
|
2005-04-16 22:20:36 +00:00
|
|
|
**/
|
2008-07-11 22:17:02 +00:00
|
|
|
static void e1000_clean_tx_ring(struct e1000_adapter *adapter,
|
|
|
|
struct e1000_tx_ring *tx_ring)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2008-07-11 22:17:08 +00:00
|
|
|
struct e1000_hw *hw = &adapter->hw;
|
2005-04-16 22:20:36 +00:00
|
|
|
struct e1000_buffer *buffer_info;
|
|
|
|
unsigned long size;
|
|
|
|
unsigned int i;
|
|
|
|
|
|
|
|
/* Free all the Tx ring sk_buffs */
|
|
|
|
|
2006-01-18 21:01:39 +00:00
|
|
|
for (i = 0; i < tx_ring->count; i++) {
|
2005-04-16 22:20:36 +00:00
|
|
|
buffer_info = &tx_ring->buffer_info[i];
|
|
|
|
e1000_unmap_and_free_tx_resource(adapter, buffer_info);
|
|
|
|
}
|
|
|
|
|
2012-08-24 08:04:58 +00:00
|
|
|
netdev_reset_queue(adapter->netdev);
|
2005-04-16 22:20:36 +00:00
|
|
|
size = sizeof(struct e1000_buffer) * tx_ring->count;
|
|
|
|
memset(tx_ring->buffer_info, 0, size);
|
|
|
|
|
|
|
|
/* Zero out the descriptor ring */
|
|
|
|
|
|
|
|
memset(tx_ring->desc, 0, tx_ring->size);
|
|
|
|
|
|
|
|
tx_ring->next_to_use = 0;
|
|
|
|
tx_ring->next_to_clean = 0;
|
2011-12-19 13:56:45 +00:00
|
|
|
tx_ring->last_tx_tso = false;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-07-11 22:17:08 +00:00
|
|
|
writel(0, hw->hw_addr + tx_ring->tdh);
|
|
|
|
writel(0, hw->hw_addr + tx_ring->tdt);
|
2005-10-04 11:01:55 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* e1000_clean_all_tx_rings - Free Tx Buffers for all queues
|
|
|
|
* @adapter: board private structure
|
|
|
|
**/
|
2008-07-11 22:17:02 +00:00
|
|
|
static void e1000_clean_all_tx_rings(struct e1000_adapter *adapter)
|
2005-10-04 11:01:55 +00:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
2006-01-13 00:50:39 +00:00
|
|
|
for (i = 0; i < adapter->num_tx_queues; i++)
|
2005-10-04 11:01:55 +00:00
|
|
|
e1000_clean_tx_ring(adapter, &adapter->tx_ring[i]);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* e1000_free_rx_resources - Free Rx Resources
|
|
|
|
* @adapter: board private structure
|
2005-10-04 11:01:55 +00:00
|
|
|
* @rx_ring: ring to clean the resources from
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
|
|
|
* Free all receive software resources
|
|
|
|
**/
|
2008-07-11 22:17:02 +00:00
|
|
|
static void e1000_free_rx_resources(struct e1000_adapter *adapter,
|
|
|
|
struct e1000_rx_ring *rx_ring)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct pci_dev *pdev = adapter->pdev;
|
|
|
|
|
2005-10-04 11:01:55 +00:00
|
|
|
e1000_clean_rx_ring(adapter, rx_ring);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
vfree(rx_ring->buffer_info);
|
|
|
|
rx_ring->buffer_info = NULL;
|
|
|
|
|
2010-04-27 13:08:45 +00:00
|
|
|
dma_free_coherent(&pdev->dev, rx_ring->size, rx_ring->desc,
|
|
|
|
rx_ring->dma);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
rx_ring->desc = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2005-10-04 11:01:55 +00:00
|
|
|
* e1000_free_all_rx_resources - Free Rx Resources for All Queues
|
2005-04-16 22:20:36 +00:00
|
|
|
* @adapter: board private structure
|
2005-10-04 11:01:55 +00:00
|
|
|
*
|
|
|
|
* Free all receive software resources
|
|
|
|
**/
|
2008-07-11 22:17:02 +00:00
|
|
|
void e1000_free_all_rx_resources(struct e1000_adapter *adapter)
|
2005-10-04 11:01:55 +00:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
2006-01-13 00:50:39 +00:00
|
|
|
for (i = 0; i < adapter->num_rx_queues; i++)
|
2005-10-04 11:01:55 +00:00
|
|
|
e1000_free_rx_resources(adapter, &adapter->rx_ring[i]);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* e1000_clean_rx_ring - Free Rx Buffers per Queue
|
|
|
|
* @adapter: board private structure
|
|
|
|
* @rx_ring: ring to free buffers from
|
2005-04-16 22:20:36 +00:00
|
|
|
**/
|
2008-07-11 22:17:02 +00:00
|
|
|
static void e1000_clean_rx_ring(struct e1000_adapter *adapter,
|
|
|
|
struct e1000_rx_ring *rx_ring)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2008-07-11 22:17:08 +00:00
|
|
|
struct e1000_hw *hw = &adapter->hw;
|
2005-04-16 22:20:36 +00:00
|
|
|
struct e1000_buffer *buffer_info;
|
|
|
|
struct pci_dev *pdev = adapter->pdev;
|
|
|
|
unsigned long size;
|
2008-09-16 20:01:28 +00:00
|
|
|
unsigned int i;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* Free all the Rx ring sk_buffs */
|
2006-01-18 21:01:39 +00:00
|
|
|
for (i = 0; i < rx_ring->count; i++) {
|
2005-04-16 22:20:36 +00:00
|
|
|
buffer_info = &rx_ring->buffer_info[i];
|
2009-07-06 10:44:39 +00:00
|
|
|
if (buffer_info->dma &&
|
|
|
|
adapter->clean_rx == e1000_clean_rx_irq) {
|
2010-04-27 13:08:45 +00:00
|
|
|
dma_unmap_single(&pdev->dev, buffer_info->dma,
|
2009-07-06 10:44:39 +00:00
|
|
|
buffer_info->length,
|
2010-04-27 13:08:45 +00:00
|
|
|
DMA_FROM_DEVICE);
|
2009-07-06 10:44:39 +00:00
|
|
|
} else if (buffer_info->dma &&
|
|
|
|
adapter->clean_rx == e1000_clean_jumbo_rx_irq) {
|
2010-04-27 13:08:45 +00:00
|
|
|
dma_unmap_page(&pdev->dev, buffer_info->dma,
|
|
|
|
buffer_info->length,
|
|
|
|
DMA_FROM_DEVICE);
|
2009-06-30 12:45:34 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-06-30 12:45:34 +00:00
|
|
|
buffer_info->dma = 0;
|
2009-07-06 10:44:39 +00:00
|
|
|
if (buffer_info->page) {
|
|
|
|
put_page(buffer_info->page);
|
|
|
|
buffer_info->page = NULL;
|
|
|
|
}
|
2009-06-30 12:45:34 +00:00
|
|
|
if (buffer_info->skb) {
|
2005-04-16 22:20:36 +00:00
|
|
|
dev_kfree_skb(buffer_info->skb);
|
|
|
|
buffer_info->skb = NULL;
|
2006-01-13 00:50:55 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2009-07-06 10:44:39 +00:00
|
|
|
/* there also may be some cached data from a chained receive */
|
|
|
|
if (rx_ring->rx_skb_top) {
|
|
|
|
dev_kfree_skb(rx_ring->rx_skb_top);
|
|
|
|
rx_ring->rx_skb_top = NULL;
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
size = sizeof(struct e1000_buffer) * rx_ring->count;
|
|
|
|
memset(rx_ring->buffer_info, 0, size);
|
|
|
|
|
|
|
|
/* Zero out the descriptor ring */
|
|
|
|
memset(rx_ring->desc, 0, rx_ring->size);
|
|
|
|
|
|
|
|
rx_ring->next_to_clean = 0;
|
|
|
|
rx_ring->next_to_use = 0;
|
|
|
|
|
2008-07-11 22:17:08 +00:00
|
|
|
writel(0, hw->hw_addr + rx_ring->rdh);
|
|
|
|
writel(0, hw->hw_addr + rx_ring->rdt);
|
2005-10-04 11:01:55 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* e1000_clean_all_rx_rings - Free Rx Buffers for all queues
|
|
|
|
* @adapter: board private structure
|
|
|
|
**/
|
2008-07-11 22:17:02 +00:00
|
|
|
static void e1000_clean_all_rx_rings(struct e1000_adapter *adapter)
|
2005-10-04 11:01:55 +00:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
2006-01-13 00:50:39 +00:00
|
|
|
for (i = 0; i < adapter->num_rx_queues; i++)
|
2005-10-04 11:01:55 +00:00
|
|
|
e1000_clean_rx_ring(adapter, &adapter->rx_ring[i]);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* The 82542 2.0 (revision 2) needs to have the receive unit in reset
|
|
|
|
* and memory write and invalidate disabled for certain operations
|
|
|
|
*/
|
2008-07-11 22:17:02 +00:00
|
|
|
static void e1000_enter_82542_rst(struct e1000_adapter *adapter)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2008-07-11 22:17:08 +00:00
|
|
|
struct e1000_hw *hw = &adapter->hw;
|
2005-04-16 22:20:36 +00:00
|
|
|
struct net_device *netdev = adapter->netdev;
|
2008-04-03 17:06:32 +00:00
|
|
|
u32 rctl;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-07-11 22:17:08 +00:00
|
|
|
e1000_pci_clear_mwi(hw);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-07-11 22:17:08 +00:00
|
|
|
rctl = er32(RCTL);
|
2005-04-16 22:20:36 +00:00
|
|
|
rctl |= E1000_RCTL_RST;
|
2008-07-11 22:17:08 +00:00
|
|
|
ew32(RCTL, rctl);
|
|
|
|
E1000_WRITE_FLUSH();
|
2005-04-16 22:20:36 +00:00
|
|
|
mdelay(5);
|
|
|
|
|
2006-01-18 21:01:39 +00:00
|
|
|
if (netif_running(netdev))
|
2005-10-04 11:01:55 +00:00
|
|
|
e1000_clean_all_rx_rings(adapter);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2008-07-11 22:17:02 +00:00
|
|
|
static void e1000_leave_82542_rst(struct e1000_adapter *adapter)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2008-07-11 22:17:08 +00:00
|
|
|
struct e1000_hw *hw = &adapter->hw;
|
2005-04-16 22:20:36 +00:00
|
|
|
struct net_device *netdev = adapter->netdev;
|
2008-04-03 17:06:32 +00:00
|
|
|
u32 rctl;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-07-11 22:17:08 +00:00
|
|
|
rctl = er32(RCTL);
|
2005-04-16 22:20:36 +00:00
|
|
|
rctl &= ~E1000_RCTL_RST;
|
2008-07-11 22:17:08 +00:00
|
|
|
ew32(RCTL, rctl);
|
|
|
|
E1000_WRITE_FLUSH();
|
2005-04-16 22:20:36 +00:00
|
|
|
mdelay(5);
|
|
|
|
|
2008-07-11 22:17:08 +00:00
|
|
|
if (hw->pci_cmd_word & PCI_COMMAND_INVALIDATE)
|
|
|
|
e1000_pci_set_mwi(hw);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-01-18 21:01:39 +00:00
|
|
|
if (netif_running(netdev)) {
|
2006-01-13 00:51:19 +00:00
|
|
|
/* No need to loop, because 82542 supports only 1 queue */
|
|
|
|
struct e1000_rx_ring *ring = &adapter->rx_ring[0];
|
2006-01-18 21:01:45 +00:00
|
|
|
e1000_configure_rx(adapter);
|
2006-01-13 00:51:19 +00:00
|
|
|
adapter->alloc_rx_buf(adapter, ring, E1000_DESC_UNUSED(ring));
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* e1000_set_mac - Change the Ethernet Address of the NIC
|
|
|
|
* @netdev: network interface device structure
|
|
|
|
* @p: pointer to an address structure
|
|
|
|
*
|
|
|
|
* Returns 0 on success, negative on failure
|
|
|
|
**/
|
2008-07-11 22:17:02 +00:00
|
|
|
static int e1000_set_mac(struct net_device *netdev, void *p)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2005-06-18 00:41:45 +00:00
|
|
|
struct e1000_adapter *adapter = netdev_priv(netdev);
|
2008-07-11 22:17:08 +00:00
|
|
|
struct e1000_hw *hw = &adapter->hw;
|
2005-04-16 22:20:36 +00:00
|
|
|
struct sockaddr *addr = p;
|
|
|
|
|
2006-01-18 21:01:39 +00:00
|
|
|
if (!is_valid_ether_addr(addr->sa_data))
|
2005-04-16 22:20:36 +00:00
|
|
|
return -EADDRNOTAVAIL;
|
|
|
|
|
|
|
|
/* 82542 2.0 needs to be in reset to write receive address registers */
|
|
|
|
|
2008-07-11 22:17:08 +00:00
|
|
|
if (hw->mac_type == e1000_82542_rev2_0)
|
2005-04-16 22:20:36 +00:00
|
|
|
e1000_enter_82542_rst(adapter);
|
|
|
|
|
|
|
|
memcpy(netdev->dev_addr, addr->sa_data, netdev->addr_len);
|
2008-07-11 22:17:08 +00:00
|
|
|
memcpy(hw->mac_addr, addr->sa_data, netdev->addr_len);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-07-11 22:17:08 +00:00
|
|
|
e1000_rar_set(hw, hw->mac_addr, 0);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-07-11 22:17:08 +00:00
|
|
|
if (hw->mac_type == e1000_82542_rev2_0)
|
2005-04-16 22:20:36 +00:00
|
|
|
e1000_leave_82542_rst(adapter);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2007-11-14 04:54:59 +00:00
|
|
|
* e1000_set_rx_mode - Secondary Unicast, Multicast and Promiscuous mode set
|
2005-04-16 22:20:36 +00:00
|
|
|
* @netdev: network interface device structure
|
|
|
|
*
|
2007-11-14 04:54:59 +00:00
|
|
|
* The set_rx_mode entry point is called whenever the unicast or multicast
|
|
|
|
* address lists or the network interface flags are updated. This routine is
|
|
|
|
* responsible for configuring the hardware for proper unicast, multicast,
|
2005-04-16 22:20:36 +00:00
|
|
|
* promiscuous mode, and all-multi behavior.
|
|
|
|
**/
|
2008-07-11 22:17:02 +00:00
|
|
|
static void e1000_set_rx_mode(struct net_device *netdev)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2005-06-18 00:41:45 +00:00
|
|
|
struct e1000_adapter *adapter = netdev_priv(netdev);
|
2005-04-16 22:20:36 +00:00
|
|
|
struct e1000_hw *hw = &adapter->hw;
|
2009-05-22 23:22:17 +00:00
|
|
|
struct netdev_hw_addr *ha;
|
|
|
|
bool use_uc = false;
|
2008-04-03 17:06:32 +00:00
|
|
|
u32 rctl;
|
|
|
|
u32 hash_value;
|
2005-10-04 10:58:59 +00:00
|
|
|
int i, rar_entries = E1000_RAR_ENTRIES;
|
2009-09-25 12:16:14 +00:00
|
|
|
int mta_reg_count = E1000_NUM_MTA_REGISTERS;
|
2009-04-04 23:36:53 +00:00
|
|
|
u32 *mcarray = kcalloc(mta_reg_count, sizeof(u32), GFP_ATOMIC);
|
|
|
|
|
2013-02-07 11:46:27 +00:00
|
|
|
if (!mcarray)
|
2009-04-04 23:36:53 +00:00
|
|
|
return;
|
2006-06-27 16:08:22 +00:00
|
|
|
|
2005-04-29 02:44:46 +00:00
|
|
|
/* Check for Promiscuous and All Multicast modes */
|
|
|
|
|
2008-07-11 22:17:08 +00:00
|
|
|
rctl = er32(RCTL);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-01-18 21:01:39 +00:00
|
|
|
if (netdev->flags & IFF_PROMISC) {
|
2005-04-16 22:20:36 +00:00
|
|
|
rctl |= (E1000_RCTL_UPE | E1000_RCTL_MPE);
|
2008-07-17 03:15:45 +00:00
|
|
|
rctl &= ~E1000_RCTL_VFE;
|
2005-04-16 22:20:36 +00:00
|
|
|
} else {
|
2009-09-25 12:16:14 +00:00
|
|
|
if (netdev->flags & IFF_ALLMULTI)
|
2008-07-17 03:15:45 +00:00
|
|
|
rctl |= E1000_RCTL_MPE;
|
2009-09-25 12:16:14 +00:00
|
|
|
else
|
2008-07-17 03:15:45 +00:00
|
|
|
rctl &= ~E1000_RCTL_MPE;
|
2009-09-25 12:16:14 +00:00
|
|
|
/* Enable VLAN filter if there is a VLAN */
|
2011-07-21 03:26:31 +00:00
|
|
|
if (e1000_vlan_used(adapter))
|
2009-09-25 12:16:14 +00:00
|
|
|
rctl |= E1000_RCTL_VFE;
|
2007-11-14 04:54:59 +00:00
|
|
|
}
|
|
|
|
|
2010-01-25 21:36:10 +00:00
|
|
|
if (netdev_uc_count(netdev) > rar_entries - 1) {
|
2007-11-14 04:54:59 +00:00
|
|
|
rctl |= E1000_RCTL_UPE;
|
|
|
|
} else if (!(netdev->flags & IFF_PROMISC)) {
|
|
|
|
rctl &= ~E1000_RCTL_UPE;
|
2009-05-22 23:22:17 +00:00
|
|
|
use_uc = true;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2008-07-11 22:17:08 +00:00
|
|
|
ew32(RCTL, rctl);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* 82542 2.0 needs to be in reset to write receive address registers */
|
|
|
|
|
2006-01-18 21:01:39 +00:00
|
|
|
if (hw->mac_type == e1000_82542_rev2_0)
|
2005-04-16 22:20:36 +00:00
|
|
|
e1000_enter_82542_rst(adapter);
|
|
|
|
|
2007-11-14 04:54:59 +00:00
|
|
|
/* load the first 14 addresses into the exact filters 1-14. Unicast
|
|
|
|
* addresses take precedence to avoid disabling unicast filtering
|
|
|
|
* when possible.
|
|
|
|
*
|
tree-wide: fix comment/printk typos
"gadget", "through", "command", "maintain", "maintain", "controller", "address",
"between", "initiali[zs]e", "instead", "function", "select", "already",
"equal", "access", "management", "hierarchy", "registration", "interest",
"relative", "memory", "offset", "already",
Signed-off-by: Uwe Kleine-König <u.kleine-koenig@pengutronix.de>
Signed-off-by: Jiri Kosina <jkosina@suse.cz>
2010-11-01 19:38:34 +00:00
|
|
|
* RAR 0 is used for the station MAC address
|
2005-04-16 22:20:36 +00:00
|
|
|
* if there are not 14 addresses, go ahead and clear the filters
|
|
|
|
*/
|
2009-05-22 23:22:17 +00:00
|
|
|
i = 1;
|
|
|
|
if (use_uc)
|
2010-01-25 21:36:10 +00:00
|
|
|
netdev_for_each_uc_addr(ha, netdev) {
|
2009-05-22 23:22:17 +00:00
|
|
|
if (i == rar_entries)
|
|
|
|
break;
|
|
|
|
e1000_rar_set(hw, ha->addr, i++);
|
|
|
|
}
|
|
|
|
|
2010-04-01 21:22:57 +00:00
|
|
|
netdev_for_each_mc_addr(ha, netdev) {
|
2010-02-22 09:10:44 +00:00
|
|
|
if (i == rar_entries) {
|
|
|
|
/* load any remaining addresses into the hash table */
|
|
|
|
u32 hash_reg, hash_bit, mta;
|
2010-04-01 21:22:57 +00:00
|
|
|
hash_value = e1000_hash_mc_addr(hw, ha->addr);
|
2010-02-22 09:10:44 +00:00
|
|
|
hash_reg = (hash_value >> 5) & 0x7F;
|
|
|
|
hash_bit = hash_value & 0x1F;
|
|
|
|
mta = (1 << hash_bit);
|
|
|
|
mcarray[hash_reg] |= mta;
|
2010-02-23 09:19:22 +00:00
|
|
|
} else {
|
2010-04-01 21:22:57 +00:00
|
|
|
e1000_rar_set(hw, ha->addr, i++);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-02-22 09:10:44 +00:00
|
|
|
for (; i < rar_entries; i++) {
|
|
|
|
E1000_WRITE_REG_ARRAY(hw, RA, i << 1, 0);
|
|
|
|
E1000_WRITE_FLUSH();
|
|
|
|
E1000_WRITE_REG_ARRAY(hw, RA, (i << 1) + 1, 0);
|
|
|
|
E1000_WRITE_FLUSH();
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2009-04-04 23:36:53 +00:00
|
|
|
/* write the hash table completely, write from bottom to avoid
|
2013-02-09 12:49:21 +00:00
|
|
|
* both stupid write combining chipsets, and flushing each write
|
|
|
|
*/
|
2009-04-04 23:36:53 +00:00
|
|
|
for (i = mta_reg_count - 1; i >= 0 ; i--) {
|
2013-02-09 12:49:21 +00:00
|
|
|
/* If we are on an 82544 has an errata where writing odd
|
2009-04-04 23:36:53 +00:00
|
|
|
* offsets overwrites the previous even offset, but writing
|
|
|
|
* backwards over the range solves the issue by always
|
|
|
|
* writing the odd offset first
|
|
|
|
*/
|
|
|
|
E1000_WRITE_REG_ARRAY(hw, MTA, i, mcarray[i]);
|
|
|
|
}
|
|
|
|
E1000_WRITE_FLUSH();
|
|
|
|
|
2006-01-18 21:01:39 +00:00
|
|
|
if (hw->mac_type == e1000_82542_rev2_0)
|
2005-04-16 22:20:36 +00:00
|
|
|
e1000_leave_82542_rst(adapter);
|
2009-04-04 23:36:53 +00:00
|
|
|
|
|
|
|
kfree(mcarray);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2011-10-05 07:24:41 +00:00
|
|
|
/**
|
|
|
|
* e1000_update_phy_info_task - get phy info
|
|
|
|
* @work: work struct contained inside adapter struct
|
|
|
|
*
|
|
|
|
* Need to wait a few seconds after link up to get diagnostic information from
|
|
|
|
* the phy
|
|
|
|
*/
|
2010-09-22 18:22:17 +00:00
|
|
|
static void e1000_update_phy_info_task(struct work_struct *work)
|
|
|
|
{
|
|
|
|
struct e1000_adapter *adapter = container_of(work,
|
2011-10-05 07:24:41 +00:00
|
|
|
struct e1000_adapter,
|
|
|
|
phy_info_task.work);
|
2011-10-05 07:24:51 +00:00
|
|
|
if (test_bit(__E1000_DOWN, &adapter->flags))
|
|
|
|
return;
|
|
|
|
mutex_lock(&adapter->mutex);
|
2011-10-05 07:24:41 +00:00
|
|
|
e1000_phy_get_info(&adapter->hw, &adapter->phy_info);
|
2011-10-05 07:24:51 +00:00
|
|
|
mutex_unlock(&adapter->mutex);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2010-09-22 18:22:17 +00:00
|
|
|
/**
|
|
|
|
* e1000_82547_tx_fifo_stall_task - task to complete work
|
|
|
|
* @work: work struct contained inside adapter struct
|
|
|
|
**/
|
|
|
|
static void e1000_82547_tx_fifo_stall_task(struct work_struct *work)
|
|
|
|
{
|
|
|
|
struct e1000_adapter *adapter = container_of(work,
|
2011-10-05 07:24:41 +00:00
|
|
|
struct e1000_adapter,
|
|
|
|
fifo_stall_task.work);
|
2008-07-11 22:17:08 +00:00
|
|
|
struct e1000_hw *hw = &adapter->hw;
|
2005-04-16 22:20:36 +00:00
|
|
|
struct net_device *netdev = adapter->netdev;
|
2008-04-03 17:06:32 +00:00
|
|
|
u32 tctl;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2011-10-05 07:24:51 +00:00
|
|
|
if (test_bit(__E1000_DOWN, &adapter->flags))
|
|
|
|
return;
|
|
|
|
mutex_lock(&adapter->mutex);
|
2006-01-18 21:01:39 +00:00
|
|
|
if (atomic_read(&adapter->tx_fifo_stall)) {
|
2008-07-11 22:17:08 +00:00
|
|
|
if ((er32(TDT) == er32(TDH)) &&
|
|
|
|
(er32(TDFT) == er32(TDFH)) &&
|
|
|
|
(er32(TDFTS) == er32(TDFHS))) {
|
|
|
|
tctl = er32(TCTL);
|
|
|
|
ew32(TCTL, tctl & ~E1000_TCTL_EN);
|
|
|
|
ew32(TDFT, adapter->tx_head_addr);
|
|
|
|
ew32(TDFH, adapter->tx_head_addr);
|
|
|
|
ew32(TDFTS, adapter->tx_head_addr);
|
|
|
|
ew32(TDFHS, adapter->tx_head_addr);
|
|
|
|
ew32(TCTL, tctl);
|
|
|
|
E1000_WRITE_FLUSH();
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
adapter->tx_fifo_head = 0;
|
|
|
|
atomic_set(&adapter->tx_fifo_stall, 0);
|
|
|
|
netif_wake_queue(netdev);
|
2009-09-25 12:17:23 +00:00
|
|
|
} else if (!test_bit(__E1000_DOWN, &adapter->flags)) {
|
2011-10-05 07:24:41 +00:00
|
|
|
schedule_delayed_work(&adapter->fifo_stall_task, 1);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
}
|
2011-10-05 07:24:51 +00:00
|
|
|
mutex_unlock(&adapter->mutex);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2010-02-03 14:49:28 +00:00
|
|
|
bool e1000_has_link(struct e1000_adapter *adapter)
|
2009-09-25 12:17:44 +00:00
|
|
|
{
|
|
|
|
struct e1000_hw *hw = &adapter->hw;
|
|
|
|
bool link_active = false;
|
|
|
|
|
2011-07-09 00:24:18 +00:00
|
|
|
/* get_link_status is set on LSC (link status) interrupt or rx
|
|
|
|
* sequence error interrupt (except on intel ce4100).
|
|
|
|
* get_link_status will stay false until the
|
|
|
|
* e1000_check_for_link establishes link for copper adapters
|
|
|
|
* ONLY
|
2009-09-25 12:17:44 +00:00
|
|
|
*/
|
|
|
|
switch (hw->media_type) {
|
|
|
|
case e1000_media_type_copper:
|
2011-07-09 00:24:18 +00:00
|
|
|
if (hw->mac_type == e1000_ce4100)
|
|
|
|
hw->get_link_status = 1;
|
2009-09-25 12:17:44 +00:00
|
|
|
if (hw->get_link_status) {
|
2009-09-25 22:19:46 +00:00
|
|
|
e1000_check_for_link(hw);
|
2009-09-25 12:17:44 +00:00
|
|
|
link_active = !hw->get_link_status;
|
|
|
|
} else {
|
|
|
|
link_active = true;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case e1000_media_type_fiber:
|
2009-09-25 22:19:46 +00:00
|
|
|
e1000_check_for_link(hw);
|
2009-09-25 12:17:44 +00:00
|
|
|
link_active = !!(er32(STATUS) & E1000_STATUS_LU);
|
|
|
|
break;
|
|
|
|
case e1000_media_type_internal_serdes:
|
2009-09-25 22:19:46 +00:00
|
|
|
e1000_check_for_link(hw);
|
2009-09-25 12:17:44 +00:00
|
|
|
link_active = hw->serdes_has_link;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return link_active;
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/**
|
2011-10-05 07:24:41 +00:00
|
|
|
* e1000_watchdog - work function
|
|
|
|
* @work: work struct contained inside adapter struct
|
2005-04-16 22:20:36 +00:00
|
|
|
**/
|
2011-10-05 07:24:41 +00:00
|
|
|
static void e1000_watchdog(struct work_struct *work)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2011-10-05 07:24:41 +00:00
|
|
|
struct e1000_adapter *adapter = container_of(work,
|
|
|
|
struct e1000_adapter,
|
|
|
|
watchdog_task.work);
|
2008-07-11 22:17:08 +00:00
|
|
|
struct e1000_hw *hw = &adapter->hw;
|
2005-04-16 22:20:36 +00:00
|
|
|
struct net_device *netdev = adapter->netdev;
|
2006-01-13 00:50:25 +00:00
|
|
|
struct e1000_tx_ring *txdr = adapter->tx_ring;
|
2008-04-03 17:06:32 +00:00
|
|
|
u32 link, tctl;
|
2006-11-01 16:47:30 +00:00
|
|
|
|
2011-10-05 07:24:51 +00:00
|
|
|
if (test_bit(__E1000_DOWN, &adapter->flags))
|
|
|
|
return;
|
|
|
|
|
|
|
|
mutex_lock(&adapter->mutex);
|
2009-09-25 12:17:44 +00:00
|
|
|
link = e1000_has_link(adapter);
|
|
|
|
if ((netif_carrier_ok(netdev)) && link)
|
|
|
|
goto link_up;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-01-18 21:01:39 +00:00
|
|
|
if (link) {
|
|
|
|
if (!netif_carrier_ok(netdev)) {
|
2008-04-03 17:06:32 +00:00
|
|
|
u32 ctrl;
|
2008-03-21 18:06:25 +00:00
|
|
|
bool txb2b = true;
|
2009-09-25 12:17:44 +00:00
|
|
|
/* update snapshot of PHY registers on LSC */
|
2008-07-11 22:17:08 +00:00
|
|
|
e1000_get_speed_and_duplex(hw,
|
2013-02-09 12:49:21 +00:00
|
|
|
&adapter->link_speed,
|
|
|
|
&adapter->link_duplex);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-07-11 22:17:08 +00:00
|
|
|
ctrl = er32(CTRL);
|
2010-04-27 14:02:58 +00:00
|
|
|
pr_info("%s NIC Link is Up %d Mbps %s, "
|
|
|
|
"Flow Control: %s\n",
|
|
|
|
netdev->name,
|
|
|
|
adapter->link_speed,
|
|
|
|
adapter->link_duplex == FULL_DUPLEX ?
|
|
|
|
"Full Duplex" : "Half Duplex",
|
|
|
|
((ctrl & E1000_CTRL_TFCE) && (ctrl &
|
|
|
|
E1000_CTRL_RFCE)) ? "RX/TX" : ((ctrl &
|
|
|
|
E1000_CTRL_RFCE) ? "RX" : ((ctrl &
|
|
|
|
E1000_CTRL_TFCE) ? "TX" : "None")));
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2010-03-26 11:25:58 +00:00
|
|
|
/* adjust timeout factor according to speed/duplex */
|
2006-01-13 00:50:53 +00:00
|
|
|
adapter->tx_timeout_factor = 1;
|
2006-03-03 02:19:30 +00:00
|
|
|
switch (adapter->link_speed) {
|
|
|
|
case SPEED_10:
|
2008-03-21 18:06:25 +00:00
|
|
|
txb2b = false;
|
2009-09-25 12:17:44 +00:00
|
|
|
adapter->tx_timeout_factor = 16;
|
2006-03-03 02:19:30 +00:00
|
|
|
break;
|
|
|
|
case SPEED_100:
|
2008-03-21 18:06:25 +00:00
|
|
|
txb2b = false;
|
2006-03-03 02:19:30 +00:00
|
|
|
/* maybe add some timeout factor ? */
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2009-09-25 12:16:14 +00:00
|
|
|
/* enable transmits in the hardware */
|
2008-07-11 22:17:08 +00:00
|
|
|
tctl = er32(TCTL);
|
2006-03-03 02:19:30 +00:00
|
|
|
tctl |= E1000_TCTL_EN;
|
2008-07-11 22:17:08 +00:00
|
|
|
ew32(TCTL, tctl);
|
2006-01-13 00:50:53 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
netif_carrier_on(netdev);
|
2009-09-25 12:17:23 +00:00
|
|
|
if (!test_bit(__E1000_DOWN, &adapter->flags))
|
2011-10-05 07:24:41 +00:00
|
|
|
schedule_delayed_work(&adapter->phy_info_task,
|
|
|
|
2 * HZ);
|
2005-04-16 22:20:36 +00:00
|
|
|
adapter->smartspeed = 0;
|
|
|
|
}
|
|
|
|
} else {
|
2006-01-18 21:01:39 +00:00
|
|
|
if (netif_carrier_ok(netdev)) {
|
2005-04-16 22:20:36 +00:00
|
|
|
adapter->link_speed = 0;
|
|
|
|
adapter->link_duplex = 0;
|
2010-04-27 14:02:58 +00:00
|
|
|
pr_info("%s NIC Link is Down\n",
|
|
|
|
netdev->name);
|
2005-04-16 22:20:36 +00:00
|
|
|
netif_carrier_off(netdev);
|
2009-09-25 12:17:23 +00:00
|
|
|
|
|
|
|
if (!test_bit(__E1000_DOWN, &adapter->flags))
|
2011-10-05 07:24:41 +00:00
|
|
|
schedule_delayed_work(&adapter->phy_info_task,
|
|
|
|
2 * HZ);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
e1000_smartspeed(adapter);
|
|
|
|
}
|
|
|
|
|
2009-09-25 12:17:44 +00:00
|
|
|
link_up:
|
2005-04-16 22:20:36 +00:00
|
|
|
e1000_update_stats(adapter);
|
|
|
|
|
2008-07-11 22:17:08 +00:00
|
|
|
hw->tx_packet_delta = adapter->stats.tpt - adapter->tpt_old;
|
2005-04-16 22:20:36 +00:00
|
|
|
adapter->tpt_old = adapter->stats.tpt;
|
2008-07-11 22:17:08 +00:00
|
|
|
hw->collision_delta = adapter->stats.colc - adapter->colc_old;
|
2005-04-16 22:20:36 +00:00
|
|
|
adapter->colc_old = adapter->stats.colc;
|
|
|
|
|
|
|
|
adapter->gorcl = adapter->stats.gorcl - adapter->gorcl_old;
|
|
|
|
adapter->gorcl_old = adapter->stats.gorcl;
|
|
|
|
adapter->gotcl = adapter->stats.gotcl - adapter->gotcl_old;
|
|
|
|
adapter->gotcl_old = adapter->stats.gotcl;
|
|
|
|
|
2008-07-11 22:17:08 +00:00
|
|
|
e1000_update_adaptive(hw);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-01-13 00:50:39 +00:00
|
|
|
if (!netif_carrier_ok(netdev)) {
|
2005-10-04 11:01:55 +00:00
|
|
|
if (E1000_DESC_UNUSED(txdr) + 1 < txdr->count) {
|
2005-04-16 22:20:36 +00:00
|
|
|
/* We've lost link, so the controller stops DMA,
|
|
|
|
* but we've got queued Tx work that's never going
|
|
|
|
* to get done, so reset controller to flush Tx.
|
2013-02-09 12:49:21 +00:00
|
|
|
* (Do the reset outside of interrupt context).
|
|
|
|
*/
|
2006-03-03 02:21:24 +00:00
|
|
|
adapter->tx_timeout_count++;
|
|
|
|
schedule_work(&adapter->reset_task);
|
2011-10-05 07:24:51 +00:00
|
|
|
/* exit immediately since reset is imminent */
|
|
|
|
goto unlock;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-05-04 22:26:03 +00:00
|
|
|
/* Simple mode for Interrupt Throttle Rate (ITR) */
|
|
|
|
if (hw->mac_type >= e1000_82540 && adapter->itr_setting == 4) {
|
2013-02-09 12:49:21 +00:00
|
|
|
/* Symmetric Tx/Rx gets a reduced ITR=2000;
|
2010-05-04 22:26:03 +00:00
|
|
|
* Total asymmetrical Tx or Rx gets ITR=8000;
|
|
|
|
* everyone else is between 2000-8000.
|
|
|
|
*/
|
|
|
|
u32 goc = (adapter->gotcl + adapter->gorcl) / 10000;
|
|
|
|
u32 dif = (adapter->gotcl > adapter->gorcl ?
|
|
|
|
adapter->gotcl - adapter->gorcl :
|
|
|
|
adapter->gorcl - adapter->gotcl) / 10000;
|
|
|
|
u32 itr = goc > 0 ? (dif * 6000 / goc + 2000) : 8000;
|
|
|
|
|
|
|
|
ew32(ITR, 1000000000 / (itr * 256));
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* Cause software interrupt to ensure rx ring is cleaned */
|
2008-07-11 22:17:08 +00:00
|
|
|
ew32(ICS, E1000_ICS_RXDMT0);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2005-04-29 02:44:46 +00:00
|
|
|
/* Force detection of hung controller every watchdog period */
|
2008-03-21 18:06:25 +00:00
|
|
|
adapter->detect_tx_hung = true;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2011-10-05 07:24:41 +00:00
|
|
|
/* Reschedule the task */
|
2009-09-25 12:17:23 +00:00
|
|
|
if (!test_bit(__E1000_DOWN, &adapter->flags))
|
2011-10-05 07:24:41 +00:00
|
|
|
schedule_delayed_work(&adapter->watchdog_task, 2 * HZ);
|
2011-10-05 07:24:51 +00:00
|
|
|
|
|
|
|
unlock:
|
|
|
|
mutex_unlock(&adapter->mutex);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
e1000: add dynamic itr modes
Add a new dynamic itr algorithm, with 2 modes, and make it the default
operation mode. This greatly reduces latency and increases small packet
performance, at the "cost" of some CPU utilization. Bulk traffic
throughput is unaffected.
The driver can limit the amount of interrupts per second that the
adapter will generate for incoming packets. It does this by writing a
value to the adapter that is based on the maximum amount of interrupts
that the adapter will generate per second.
Setting InterruptThrottleRate to a value greater or equal to 100 will
program the adapter to send out a maximum of that many interrupts per
second, even if more packets have come in. This reduces interrupt
load on the system and can lower CPU utilization under heavy load,
but will increase latency as packets are not processed as quickly.
The default behaviour of the driver previously assumed a static
InterruptThrottleRate value of 8000, providing a good fallback value
for all traffic types,but lacking in small packet performance and
latency. The hardware can handle many more small packets per second
however, and for this reason an adaptive interrupt moderation algorithm
was implemented.
Since 7.3.x, the driver has two adaptive modes (setting 1 or 3) in
which it dynamically adjusts the InterruptThrottleRate value based on
the traffic that it receives. After determining the type of incoming
traffic in the last timeframe, it will adjust the InterruptThrottleRate
to an appropriate value for that traffic.
The algorithm classifies the incoming traffic every interval into
classes. Once the class is determined, the InterruptThrottleRate
value is adjusted to suit that traffic type the best. There are
three classes defined: "Bulk traffic", for large amounts of packets
of normal size; "Low latency", for small amounts of traffic and/or
a significant percentage of small packets; and "Lowest latency",
for almost completely small packets or minimal traffic.
In dynamic conservative mode, the InterruptThrottleRate value is
set to 4000 for traffic that falls in class "Bulk traffic". If
traffic falls in the "Low latency" or "Lowest latency" class, the
InterruptThrottleRate is increased stepwise to 20000. This default
mode is suitable for most applications.
For situations where low latency is vital such as cluster or
grid computing, the algorithm can reduce latency even more when
InterruptThrottleRate is set to mode 1. In this mode, which operates
the same as mode 3, the InterruptThrottleRate will be increased
stepwise to 70000 for traffic in class "Lowest latency".
Setting InterruptThrottleRate to 0 turns off any interrupt moderation
and may improve small packet latency, but is generally not suitable
for bulk throughput traffic.
Signed-off-by: Jesse Brandeburg <jesse.brandeburg@intel.com>
Cc: Rick Jones <rick.jones2@hp.com>
Signed-off-by: Auke Kok <auke-jan.h.kok@intel.com>
2006-11-01 16:48:13 +00:00
|
|
|
enum latency_range {
|
|
|
|
lowest_latency = 0,
|
|
|
|
low_latency = 1,
|
|
|
|
bulk_latency = 2,
|
|
|
|
latency_invalid = 255
|
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* e1000_update_itr - update the dynamic ITR value based on statistics
|
2009-09-25 12:18:41 +00:00
|
|
|
* @adapter: pointer to adapter
|
|
|
|
* @itr_setting: current adapter->itr
|
|
|
|
* @packets: the number of packets during this measurement interval
|
|
|
|
* @bytes: the number of bytes during this measurement interval
|
|
|
|
*
|
e1000: add dynamic itr modes
Add a new dynamic itr algorithm, with 2 modes, and make it the default
operation mode. This greatly reduces latency and increases small packet
performance, at the "cost" of some CPU utilization. Bulk traffic
throughput is unaffected.
The driver can limit the amount of interrupts per second that the
adapter will generate for incoming packets. It does this by writing a
value to the adapter that is based on the maximum amount of interrupts
that the adapter will generate per second.
Setting InterruptThrottleRate to a value greater or equal to 100 will
program the adapter to send out a maximum of that many interrupts per
second, even if more packets have come in. This reduces interrupt
load on the system and can lower CPU utilization under heavy load,
but will increase latency as packets are not processed as quickly.
The default behaviour of the driver previously assumed a static
InterruptThrottleRate value of 8000, providing a good fallback value
for all traffic types,but lacking in small packet performance and
latency. The hardware can handle many more small packets per second
however, and for this reason an adaptive interrupt moderation algorithm
was implemented.
Since 7.3.x, the driver has two adaptive modes (setting 1 or 3) in
which it dynamically adjusts the InterruptThrottleRate value based on
the traffic that it receives. After determining the type of incoming
traffic in the last timeframe, it will adjust the InterruptThrottleRate
to an appropriate value for that traffic.
The algorithm classifies the incoming traffic every interval into
classes. Once the class is determined, the InterruptThrottleRate
value is adjusted to suit that traffic type the best. There are
three classes defined: "Bulk traffic", for large amounts of packets
of normal size; "Low latency", for small amounts of traffic and/or
a significant percentage of small packets; and "Lowest latency",
for almost completely small packets or minimal traffic.
In dynamic conservative mode, the InterruptThrottleRate value is
set to 4000 for traffic that falls in class "Bulk traffic". If
traffic falls in the "Low latency" or "Lowest latency" class, the
InterruptThrottleRate is increased stepwise to 20000. This default
mode is suitable for most applications.
For situations where low latency is vital such as cluster or
grid computing, the algorithm can reduce latency even more when
InterruptThrottleRate is set to mode 1. In this mode, which operates
the same as mode 3, the InterruptThrottleRate will be increased
stepwise to 70000 for traffic in class "Lowest latency".
Setting InterruptThrottleRate to 0 turns off any interrupt moderation
and may improve small packet latency, but is generally not suitable
for bulk throughput traffic.
Signed-off-by: Jesse Brandeburg <jesse.brandeburg@intel.com>
Cc: Rick Jones <rick.jones2@hp.com>
Signed-off-by: Auke Kok <auke-jan.h.kok@intel.com>
2006-11-01 16:48:13 +00:00
|
|
|
* Stores a new ITR value based on packets and byte
|
|
|
|
* counts during the last interrupt. The advantage of per interrupt
|
|
|
|
* computation is faster updates and more accurate ITR for the current
|
|
|
|
* traffic pattern. Constants in this function were computed
|
|
|
|
* based on theoretical maximum wire speed and thresholds were set based
|
|
|
|
* on testing data as well as attempting to minimize response time
|
|
|
|
* while increasing bulk throughput.
|
|
|
|
* this functionality is controlled by the InterruptThrottleRate module
|
|
|
|
* parameter (see e1000_param.c)
|
|
|
|
**/
|
|
|
|
static unsigned int e1000_update_itr(struct e1000_adapter *adapter,
|
2008-07-11 22:17:02 +00:00
|
|
|
u16 itr_setting, int packets, int bytes)
|
e1000: add dynamic itr modes
Add a new dynamic itr algorithm, with 2 modes, and make it the default
operation mode. This greatly reduces latency and increases small packet
performance, at the "cost" of some CPU utilization. Bulk traffic
throughput is unaffected.
The driver can limit the amount of interrupts per second that the
adapter will generate for incoming packets. It does this by writing a
value to the adapter that is based on the maximum amount of interrupts
that the adapter will generate per second.
Setting InterruptThrottleRate to a value greater or equal to 100 will
program the adapter to send out a maximum of that many interrupts per
second, even if more packets have come in. This reduces interrupt
load on the system and can lower CPU utilization under heavy load,
but will increase latency as packets are not processed as quickly.
The default behaviour of the driver previously assumed a static
InterruptThrottleRate value of 8000, providing a good fallback value
for all traffic types,but lacking in small packet performance and
latency. The hardware can handle many more small packets per second
however, and for this reason an adaptive interrupt moderation algorithm
was implemented.
Since 7.3.x, the driver has two adaptive modes (setting 1 or 3) in
which it dynamically adjusts the InterruptThrottleRate value based on
the traffic that it receives. After determining the type of incoming
traffic in the last timeframe, it will adjust the InterruptThrottleRate
to an appropriate value for that traffic.
The algorithm classifies the incoming traffic every interval into
classes. Once the class is determined, the InterruptThrottleRate
value is adjusted to suit that traffic type the best. There are
three classes defined: "Bulk traffic", for large amounts of packets
of normal size; "Low latency", for small amounts of traffic and/or
a significant percentage of small packets; and "Lowest latency",
for almost completely small packets or minimal traffic.
In dynamic conservative mode, the InterruptThrottleRate value is
set to 4000 for traffic that falls in class "Bulk traffic". If
traffic falls in the "Low latency" or "Lowest latency" class, the
InterruptThrottleRate is increased stepwise to 20000. This default
mode is suitable for most applications.
For situations where low latency is vital such as cluster or
grid computing, the algorithm can reduce latency even more when
InterruptThrottleRate is set to mode 1. In this mode, which operates
the same as mode 3, the InterruptThrottleRate will be increased
stepwise to 70000 for traffic in class "Lowest latency".
Setting InterruptThrottleRate to 0 turns off any interrupt moderation
and may improve small packet latency, but is generally not suitable
for bulk throughput traffic.
Signed-off-by: Jesse Brandeburg <jesse.brandeburg@intel.com>
Cc: Rick Jones <rick.jones2@hp.com>
Signed-off-by: Auke Kok <auke-jan.h.kok@intel.com>
2006-11-01 16:48:13 +00:00
|
|
|
{
|
|
|
|
unsigned int retval = itr_setting;
|
|
|
|
struct e1000_hw *hw = &adapter->hw;
|
|
|
|
|
|
|
|
if (unlikely(hw->mac_type < e1000_82540))
|
|
|
|
goto update_itr_done;
|
|
|
|
|
|
|
|
if (packets == 0)
|
|
|
|
goto update_itr_done;
|
|
|
|
|
|
|
|
switch (itr_setting) {
|
|
|
|
case lowest_latency:
|
2006-12-15 09:30:44 +00:00
|
|
|
/* jumbo frames get bulk treatment*/
|
|
|
|
if (bytes/packets > 8000)
|
|
|
|
retval = bulk_latency;
|
|
|
|
else if ((packets < 5) && (bytes > 512))
|
e1000: add dynamic itr modes
Add a new dynamic itr algorithm, with 2 modes, and make it the default
operation mode. This greatly reduces latency and increases small packet
performance, at the "cost" of some CPU utilization. Bulk traffic
throughput is unaffected.
The driver can limit the amount of interrupts per second that the
adapter will generate for incoming packets. It does this by writing a
value to the adapter that is based on the maximum amount of interrupts
that the adapter will generate per second.
Setting InterruptThrottleRate to a value greater or equal to 100 will
program the adapter to send out a maximum of that many interrupts per
second, even if more packets have come in. This reduces interrupt
load on the system and can lower CPU utilization under heavy load,
but will increase latency as packets are not processed as quickly.
The default behaviour of the driver previously assumed a static
InterruptThrottleRate value of 8000, providing a good fallback value
for all traffic types,but lacking in small packet performance and
latency. The hardware can handle many more small packets per second
however, and for this reason an adaptive interrupt moderation algorithm
was implemented.
Since 7.3.x, the driver has two adaptive modes (setting 1 or 3) in
which it dynamically adjusts the InterruptThrottleRate value based on
the traffic that it receives. After determining the type of incoming
traffic in the last timeframe, it will adjust the InterruptThrottleRate
to an appropriate value for that traffic.
The algorithm classifies the incoming traffic every interval into
classes. Once the class is determined, the InterruptThrottleRate
value is adjusted to suit that traffic type the best. There are
three classes defined: "Bulk traffic", for large amounts of packets
of normal size; "Low latency", for small amounts of traffic and/or
a significant percentage of small packets; and "Lowest latency",
for almost completely small packets or minimal traffic.
In dynamic conservative mode, the InterruptThrottleRate value is
set to 4000 for traffic that falls in class "Bulk traffic". If
traffic falls in the "Low latency" or "Lowest latency" class, the
InterruptThrottleRate is increased stepwise to 20000. This default
mode is suitable for most applications.
For situations where low latency is vital such as cluster or
grid computing, the algorithm can reduce latency even more when
InterruptThrottleRate is set to mode 1. In this mode, which operates
the same as mode 3, the InterruptThrottleRate will be increased
stepwise to 70000 for traffic in class "Lowest latency".
Setting InterruptThrottleRate to 0 turns off any interrupt moderation
and may improve small packet latency, but is generally not suitable
for bulk throughput traffic.
Signed-off-by: Jesse Brandeburg <jesse.brandeburg@intel.com>
Cc: Rick Jones <rick.jones2@hp.com>
Signed-off-by: Auke Kok <auke-jan.h.kok@intel.com>
2006-11-01 16:48:13 +00:00
|
|
|
retval = low_latency;
|
|
|
|
break;
|
|
|
|
case low_latency: /* 50 usec aka 20000 ints/s */
|
|
|
|
if (bytes > 10000) {
|
2006-12-15 09:30:44 +00:00
|
|
|
/* jumbo frames need bulk latency setting */
|
|
|
|
if (bytes/packets > 8000)
|
|
|
|
retval = bulk_latency;
|
|
|
|
else if ((packets < 10) || ((bytes/packets) > 1200))
|
e1000: add dynamic itr modes
Add a new dynamic itr algorithm, with 2 modes, and make it the default
operation mode. This greatly reduces latency and increases small packet
performance, at the "cost" of some CPU utilization. Bulk traffic
throughput is unaffected.
The driver can limit the amount of interrupts per second that the
adapter will generate for incoming packets. It does this by writing a
value to the adapter that is based on the maximum amount of interrupts
that the adapter will generate per second.
Setting InterruptThrottleRate to a value greater or equal to 100 will
program the adapter to send out a maximum of that many interrupts per
second, even if more packets have come in. This reduces interrupt
load on the system and can lower CPU utilization under heavy load,
but will increase latency as packets are not processed as quickly.
The default behaviour of the driver previously assumed a static
InterruptThrottleRate value of 8000, providing a good fallback value
for all traffic types,but lacking in small packet performance and
latency. The hardware can handle many more small packets per second
however, and for this reason an adaptive interrupt moderation algorithm
was implemented.
Since 7.3.x, the driver has two adaptive modes (setting 1 or 3) in
which it dynamically adjusts the InterruptThrottleRate value based on
the traffic that it receives. After determining the type of incoming
traffic in the last timeframe, it will adjust the InterruptThrottleRate
to an appropriate value for that traffic.
The algorithm classifies the incoming traffic every interval into
classes. Once the class is determined, the InterruptThrottleRate
value is adjusted to suit that traffic type the best. There are
three classes defined: "Bulk traffic", for large amounts of packets
of normal size; "Low latency", for small amounts of traffic and/or
a significant percentage of small packets; and "Lowest latency",
for almost completely small packets or minimal traffic.
In dynamic conservative mode, the InterruptThrottleRate value is
set to 4000 for traffic that falls in class "Bulk traffic". If
traffic falls in the "Low latency" or "Lowest latency" class, the
InterruptThrottleRate is increased stepwise to 20000. This default
mode is suitable for most applications.
For situations where low latency is vital such as cluster or
grid computing, the algorithm can reduce latency even more when
InterruptThrottleRate is set to mode 1. In this mode, which operates
the same as mode 3, the InterruptThrottleRate will be increased
stepwise to 70000 for traffic in class "Lowest latency".
Setting InterruptThrottleRate to 0 turns off any interrupt moderation
and may improve small packet latency, but is generally not suitable
for bulk throughput traffic.
Signed-off-by: Jesse Brandeburg <jesse.brandeburg@intel.com>
Cc: Rick Jones <rick.jones2@hp.com>
Signed-off-by: Auke Kok <auke-jan.h.kok@intel.com>
2006-11-01 16:48:13 +00:00
|
|
|
retval = bulk_latency;
|
|
|
|
else if ((packets > 35))
|
|
|
|
retval = lowest_latency;
|
2006-12-15 09:30:44 +00:00
|
|
|
} else if (bytes/packets > 2000)
|
|
|
|
retval = bulk_latency;
|
|
|
|
else if (packets <= 2 && bytes < 512)
|
e1000: add dynamic itr modes
Add a new dynamic itr algorithm, with 2 modes, and make it the default
operation mode. This greatly reduces latency and increases small packet
performance, at the "cost" of some CPU utilization. Bulk traffic
throughput is unaffected.
The driver can limit the amount of interrupts per second that the
adapter will generate for incoming packets. It does this by writing a
value to the adapter that is based on the maximum amount of interrupts
that the adapter will generate per second.
Setting InterruptThrottleRate to a value greater or equal to 100 will
program the adapter to send out a maximum of that many interrupts per
second, even if more packets have come in. This reduces interrupt
load on the system and can lower CPU utilization under heavy load,
but will increase latency as packets are not processed as quickly.
The default behaviour of the driver previously assumed a static
InterruptThrottleRate value of 8000, providing a good fallback value
for all traffic types,but lacking in small packet performance and
latency. The hardware can handle many more small packets per second
however, and for this reason an adaptive interrupt moderation algorithm
was implemented.
Since 7.3.x, the driver has two adaptive modes (setting 1 or 3) in
which it dynamically adjusts the InterruptThrottleRate value based on
the traffic that it receives. After determining the type of incoming
traffic in the last timeframe, it will adjust the InterruptThrottleRate
to an appropriate value for that traffic.
The algorithm classifies the incoming traffic every interval into
classes. Once the class is determined, the InterruptThrottleRate
value is adjusted to suit that traffic type the best. There are
three classes defined: "Bulk traffic", for large amounts of packets
of normal size; "Low latency", for small amounts of traffic and/or
a significant percentage of small packets; and "Lowest latency",
for almost completely small packets or minimal traffic.
In dynamic conservative mode, the InterruptThrottleRate value is
set to 4000 for traffic that falls in class "Bulk traffic". If
traffic falls in the "Low latency" or "Lowest latency" class, the
InterruptThrottleRate is increased stepwise to 20000. This default
mode is suitable for most applications.
For situations where low latency is vital such as cluster or
grid computing, the algorithm can reduce latency even more when
InterruptThrottleRate is set to mode 1. In this mode, which operates
the same as mode 3, the InterruptThrottleRate will be increased
stepwise to 70000 for traffic in class "Lowest latency".
Setting InterruptThrottleRate to 0 turns off any interrupt moderation
and may improve small packet latency, but is generally not suitable
for bulk throughput traffic.
Signed-off-by: Jesse Brandeburg <jesse.brandeburg@intel.com>
Cc: Rick Jones <rick.jones2@hp.com>
Signed-off-by: Auke Kok <auke-jan.h.kok@intel.com>
2006-11-01 16:48:13 +00:00
|
|
|
retval = lowest_latency;
|
|
|
|
break;
|
|
|
|
case bulk_latency: /* 250 usec aka 4000 ints/s */
|
|
|
|
if (bytes > 25000) {
|
|
|
|
if (packets > 35)
|
|
|
|
retval = low_latency;
|
2006-12-15 09:30:44 +00:00
|
|
|
} else if (bytes < 6000) {
|
|
|
|
retval = low_latency;
|
e1000: add dynamic itr modes
Add a new dynamic itr algorithm, with 2 modes, and make it the default
operation mode. This greatly reduces latency and increases small packet
performance, at the "cost" of some CPU utilization. Bulk traffic
throughput is unaffected.
The driver can limit the amount of interrupts per second that the
adapter will generate for incoming packets. It does this by writing a
value to the adapter that is based on the maximum amount of interrupts
that the adapter will generate per second.
Setting InterruptThrottleRate to a value greater or equal to 100 will
program the adapter to send out a maximum of that many interrupts per
second, even if more packets have come in. This reduces interrupt
load on the system and can lower CPU utilization under heavy load,
but will increase latency as packets are not processed as quickly.
The default behaviour of the driver previously assumed a static
InterruptThrottleRate value of 8000, providing a good fallback value
for all traffic types,but lacking in small packet performance and
latency. The hardware can handle many more small packets per second
however, and for this reason an adaptive interrupt moderation algorithm
was implemented.
Since 7.3.x, the driver has two adaptive modes (setting 1 or 3) in
which it dynamically adjusts the InterruptThrottleRate value based on
the traffic that it receives. After determining the type of incoming
traffic in the last timeframe, it will adjust the InterruptThrottleRate
to an appropriate value for that traffic.
The algorithm classifies the incoming traffic every interval into
classes. Once the class is determined, the InterruptThrottleRate
value is adjusted to suit that traffic type the best. There are
three classes defined: "Bulk traffic", for large amounts of packets
of normal size; "Low latency", for small amounts of traffic and/or
a significant percentage of small packets; and "Lowest latency",
for almost completely small packets or minimal traffic.
In dynamic conservative mode, the InterruptThrottleRate value is
set to 4000 for traffic that falls in class "Bulk traffic". If
traffic falls in the "Low latency" or "Lowest latency" class, the
InterruptThrottleRate is increased stepwise to 20000. This default
mode is suitable for most applications.
For situations where low latency is vital such as cluster or
grid computing, the algorithm can reduce latency even more when
InterruptThrottleRate is set to mode 1. In this mode, which operates
the same as mode 3, the InterruptThrottleRate will be increased
stepwise to 70000 for traffic in class "Lowest latency".
Setting InterruptThrottleRate to 0 turns off any interrupt moderation
and may improve small packet latency, but is generally not suitable
for bulk throughput traffic.
Signed-off-by: Jesse Brandeburg <jesse.brandeburg@intel.com>
Cc: Rick Jones <rick.jones2@hp.com>
Signed-off-by: Auke Kok <auke-jan.h.kok@intel.com>
2006-11-01 16:48:13 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
update_itr_done:
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void e1000_set_itr(struct e1000_adapter *adapter)
|
|
|
|
{
|
|
|
|
struct e1000_hw *hw = &adapter->hw;
|
2008-04-03 17:06:32 +00:00
|
|
|
u16 current_itr;
|
|
|
|
u32 new_itr = adapter->itr;
|
e1000: add dynamic itr modes
Add a new dynamic itr algorithm, with 2 modes, and make it the default
operation mode. This greatly reduces latency and increases small packet
performance, at the "cost" of some CPU utilization. Bulk traffic
throughput is unaffected.
The driver can limit the amount of interrupts per second that the
adapter will generate for incoming packets. It does this by writing a
value to the adapter that is based on the maximum amount of interrupts
that the adapter will generate per second.
Setting InterruptThrottleRate to a value greater or equal to 100 will
program the adapter to send out a maximum of that many interrupts per
second, even if more packets have come in. This reduces interrupt
load on the system and can lower CPU utilization under heavy load,
but will increase latency as packets are not processed as quickly.
The default behaviour of the driver previously assumed a static
InterruptThrottleRate value of 8000, providing a good fallback value
for all traffic types,but lacking in small packet performance and
latency. The hardware can handle many more small packets per second
however, and for this reason an adaptive interrupt moderation algorithm
was implemented.
Since 7.3.x, the driver has two adaptive modes (setting 1 or 3) in
which it dynamically adjusts the InterruptThrottleRate value based on
the traffic that it receives. After determining the type of incoming
traffic in the last timeframe, it will adjust the InterruptThrottleRate
to an appropriate value for that traffic.
The algorithm classifies the incoming traffic every interval into
classes. Once the class is determined, the InterruptThrottleRate
value is adjusted to suit that traffic type the best. There are
three classes defined: "Bulk traffic", for large amounts of packets
of normal size; "Low latency", for small amounts of traffic and/or
a significant percentage of small packets; and "Lowest latency",
for almost completely small packets or minimal traffic.
In dynamic conservative mode, the InterruptThrottleRate value is
set to 4000 for traffic that falls in class "Bulk traffic". If
traffic falls in the "Low latency" or "Lowest latency" class, the
InterruptThrottleRate is increased stepwise to 20000. This default
mode is suitable for most applications.
For situations where low latency is vital such as cluster or
grid computing, the algorithm can reduce latency even more when
InterruptThrottleRate is set to mode 1. In this mode, which operates
the same as mode 3, the InterruptThrottleRate will be increased
stepwise to 70000 for traffic in class "Lowest latency".
Setting InterruptThrottleRate to 0 turns off any interrupt moderation
and may improve small packet latency, but is generally not suitable
for bulk throughput traffic.
Signed-off-by: Jesse Brandeburg <jesse.brandeburg@intel.com>
Cc: Rick Jones <rick.jones2@hp.com>
Signed-off-by: Auke Kok <auke-jan.h.kok@intel.com>
2006-11-01 16:48:13 +00:00
|
|
|
|
|
|
|
if (unlikely(hw->mac_type < e1000_82540))
|
|
|
|
return;
|
|
|
|
|
|
|
|
/* for non-gigabit speeds, just fix the interrupt rate at 4000 */
|
|
|
|
if (unlikely(adapter->link_speed != SPEED_1000)) {
|
|
|
|
current_itr = 0;
|
|
|
|
new_itr = 4000;
|
|
|
|
goto set_itr_now;
|
|
|
|
}
|
|
|
|
|
2013-02-09 12:49:21 +00:00
|
|
|
adapter->tx_itr = e1000_update_itr(adapter, adapter->tx_itr,
|
|
|
|
adapter->total_tx_packets,
|
|
|
|
adapter->total_tx_bytes);
|
2006-12-15 09:30:44 +00:00
|
|
|
/* conservative mode (itr 3) eliminates the lowest_latency setting */
|
|
|
|
if (adapter->itr_setting == 3 && adapter->tx_itr == lowest_latency)
|
|
|
|
adapter->tx_itr = low_latency;
|
|
|
|
|
2013-02-09 12:49:21 +00:00
|
|
|
adapter->rx_itr = e1000_update_itr(adapter, adapter->rx_itr,
|
|
|
|
adapter->total_rx_packets,
|
|
|
|
adapter->total_rx_bytes);
|
2006-12-15 09:30:44 +00:00
|
|
|
/* conservative mode (itr 3) eliminates the lowest_latency setting */
|
|
|
|
if (adapter->itr_setting == 3 && adapter->rx_itr == lowest_latency)
|
|
|
|
adapter->rx_itr = low_latency;
|
e1000: add dynamic itr modes
Add a new dynamic itr algorithm, with 2 modes, and make it the default
operation mode. This greatly reduces latency and increases small packet
performance, at the "cost" of some CPU utilization. Bulk traffic
throughput is unaffected.
The driver can limit the amount of interrupts per second that the
adapter will generate for incoming packets. It does this by writing a
value to the adapter that is based on the maximum amount of interrupts
that the adapter will generate per second.
Setting InterruptThrottleRate to a value greater or equal to 100 will
program the adapter to send out a maximum of that many interrupts per
second, even if more packets have come in. This reduces interrupt
load on the system and can lower CPU utilization under heavy load,
but will increase latency as packets are not processed as quickly.
The default behaviour of the driver previously assumed a static
InterruptThrottleRate value of 8000, providing a good fallback value
for all traffic types,but lacking in small packet performance and
latency. The hardware can handle many more small packets per second
however, and for this reason an adaptive interrupt moderation algorithm
was implemented.
Since 7.3.x, the driver has two adaptive modes (setting 1 or 3) in
which it dynamically adjusts the InterruptThrottleRate value based on
the traffic that it receives. After determining the type of incoming
traffic in the last timeframe, it will adjust the InterruptThrottleRate
to an appropriate value for that traffic.
The algorithm classifies the incoming traffic every interval into
classes. Once the class is determined, the InterruptThrottleRate
value is adjusted to suit that traffic type the best. There are
three classes defined: "Bulk traffic", for large amounts of packets
of normal size; "Low latency", for small amounts of traffic and/or
a significant percentage of small packets; and "Lowest latency",
for almost completely small packets or minimal traffic.
In dynamic conservative mode, the InterruptThrottleRate value is
set to 4000 for traffic that falls in class "Bulk traffic". If
traffic falls in the "Low latency" or "Lowest latency" class, the
InterruptThrottleRate is increased stepwise to 20000. This default
mode is suitable for most applications.
For situations where low latency is vital such as cluster or
grid computing, the algorithm can reduce latency even more when
InterruptThrottleRate is set to mode 1. In this mode, which operates
the same as mode 3, the InterruptThrottleRate will be increased
stepwise to 70000 for traffic in class "Lowest latency".
Setting InterruptThrottleRate to 0 turns off any interrupt moderation
and may improve small packet latency, but is generally not suitable
for bulk throughput traffic.
Signed-off-by: Jesse Brandeburg <jesse.brandeburg@intel.com>
Cc: Rick Jones <rick.jones2@hp.com>
Signed-off-by: Auke Kok <auke-jan.h.kok@intel.com>
2006-11-01 16:48:13 +00:00
|
|
|
|
|
|
|
current_itr = max(adapter->rx_itr, adapter->tx_itr);
|
|
|
|
|
|
|
|
switch (current_itr) {
|
|
|
|
/* counts and packets in update_itr are dependent on these numbers */
|
|
|
|
case lowest_latency:
|
|
|
|
new_itr = 70000;
|
|
|
|
break;
|
|
|
|
case low_latency:
|
|
|
|
new_itr = 20000; /* aka hwitr = ~200 */
|
|
|
|
break;
|
|
|
|
case bulk_latency:
|
|
|
|
new_itr = 4000;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
set_itr_now:
|
|
|
|
if (new_itr != adapter->itr) {
|
|
|
|
/* this attempts to bias the interrupt rate towards Bulk
|
|
|
|
* by adding intermediate steps when interrupt rate is
|
2013-02-09 12:49:21 +00:00
|
|
|
* increasing
|
|
|
|
*/
|
e1000: add dynamic itr modes
Add a new dynamic itr algorithm, with 2 modes, and make it the default
operation mode. This greatly reduces latency and increases small packet
performance, at the "cost" of some CPU utilization. Bulk traffic
throughput is unaffected.
The driver can limit the amount of interrupts per second that the
adapter will generate for incoming packets. It does this by writing a
value to the adapter that is based on the maximum amount of interrupts
that the adapter will generate per second.
Setting InterruptThrottleRate to a value greater or equal to 100 will
program the adapter to send out a maximum of that many interrupts per
second, even if more packets have come in. This reduces interrupt
load on the system and can lower CPU utilization under heavy load,
but will increase latency as packets are not processed as quickly.
The default behaviour of the driver previously assumed a static
InterruptThrottleRate value of 8000, providing a good fallback value
for all traffic types,but lacking in small packet performance and
latency. The hardware can handle many more small packets per second
however, and for this reason an adaptive interrupt moderation algorithm
was implemented.
Since 7.3.x, the driver has two adaptive modes (setting 1 or 3) in
which it dynamically adjusts the InterruptThrottleRate value based on
the traffic that it receives. After determining the type of incoming
traffic in the last timeframe, it will adjust the InterruptThrottleRate
to an appropriate value for that traffic.
The algorithm classifies the incoming traffic every interval into
classes. Once the class is determined, the InterruptThrottleRate
value is adjusted to suit that traffic type the best. There are
three classes defined: "Bulk traffic", for large amounts of packets
of normal size; "Low latency", for small amounts of traffic and/or
a significant percentage of small packets; and "Lowest latency",
for almost completely small packets or minimal traffic.
In dynamic conservative mode, the InterruptThrottleRate value is
set to 4000 for traffic that falls in class "Bulk traffic". If
traffic falls in the "Low latency" or "Lowest latency" class, the
InterruptThrottleRate is increased stepwise to 20000. This default
mode is suitable for most applications.
For situations where low latency is vital such as cluster or
grid computing, the algorithm can reduce latency even more when
InterruptThrottleRate is set to mode 1. In this mode, which operates
the same as mode 3, the InterruptThrottleRate will be increased
stepwise to 70000 for traffic in class "Lowest latency".
Setting InterruptThrottleRate to 0 turns off any interrupt moderation
and may improve small packet latency, but is generally not suitable
for bulk throughput traffic.
Signed-off-by: Jesse Brandeburg <jesse.brandeburg@intel.com>
Cc: Rick Jones <rick.jones2@hp.com>
Signed-off-by: Auke Kok <auke-jan.h.kok@intel.com>
2006-11-01 16:48:13 +00:00
|
|
|
new_itr = new_itr > adapter->itr ?
|
2013-02-09 12:49:21 +00:00
|
|
|
min(adapter->itr + (new_itr >> 2), new_itr) :
|
|
|
|
new_itr;
|
e1000: add dynamic itr modes
Add a new dynamic itr algorithm, with 2 modes, and make it the default
operation mode. This greatly reduces latency and increases small packet
performance, at the "cost" of some CPU utilization. Bulk traffic
throughput is unaffected.
The driver can limit the amount of interrupts per second that the
adapter will generate for incoming packets. It does this by writing a
value to the adapter that is based on the maximum amount of interrupts
that the adapter will generate per second.
Setting InterruptThrottleRate to a value greater or equal to 100 will
program the adapter to send out a maximum of that many interrupts per
second, even if more packets have come in. This reduces interrupt
load on the system and can lower CPU utilization under heavy load,
but will increase latency as packets are not processed as quickly.
The default behaviour of the driver previously assumed a static
InterruptThrottleRate value of 8000, providing a good fallback value
for all traffic types,but lacking in small packet performance and
latency. The hardware can handle many more small packets per second
however, and for this reason an adaptive interrupt moderation algorithm
was implemented.
Since 7.3.x, the driver has two adaptive modes (setting 1 or 3) in
which it dynamically adjusts the InterruptThrottleRate value based on
the traffic that it receives. After determining the type of incoming
traffic in the last timeframe, it will adjust the InterruptThrottleRate
to an appropriate value for that traffic.
The algorithm classifies the incoming traffic every interval into
classes. Once the class is determined, the InterruptThrottleRate
value is adjusted to suit that traffic type the best. There are
three classes defined: "Bulk traffic", for large amounts of packets
of normal size; "Low latency", for small amounts of traffic and/or
a significant percentage of small packets; and "Lowest latency",
for almost completely small packets or minimal traffic.
In dynamic conservative mode, the InterruptThrottleRate value is
set to 4000 for traffic that falls in class "Bulk traffic". If
traffic falls in the "Low latency" or "Lowest latency" class, the
InterruptThrottleRate is increased stepwise to 20000. This default
mode is suitable for most applications.
For situations where low latency is vital such as cluster or
grid computing, the algorithm can reduce latency even more when
InterruptThrottleRate is set to mode 1. In this mode, which operates
the same as mode 3, the InterruptThrottleRate will be increased
stepwise to 70000 for traffic in class "Lowest latency".
Setting InterruptThrottleRate to 0 turns off any interrupt moderation
and may improve small packet latency, but is generally not suitable
for bulk throughput traffic.
Signed-off-by: Jesse Brandeburg <jesse.brandeburg@intel.com>
Cc: Rick Jones <rick.jones2@hp.com>
Signed-off-by: Auke Kok <auke-jan.h.kok@intel.com>
2006-11-01 16:48:13 +00:00
|
|
|
adapter->itr = new_itr;
|
2008-07-11 22:17:08 +00:00
|
|
|
ew32(ITR, 1000000000 / (new_itr * 256));
|
e1000: add dynamic itr modes
Add a new dynamic itr algorithm, with 2 modes, and make it the default
operation mode. This greatly reduces latency and increases small packet
performance, at the "cost" of some CPU utilization. Bulk traffic
throughput is unaffected.
The driver can limit the amount of interrupts per second that the
adapter will generate for incoming packets. It does this by writing a
value to the adapter that is based on the maximum amount of interrupts
that the adapter will generate per second.
Setting InterruptThrottleRate to a value greater or equal to 100 will
program the adapter to send out a maximum of that many interrupts per
second, even if more packets have come in. This reduces interrupt
load on the system and can lower CPU utilization under heavy load,
but will increase latency as packets are not processed as quickly.
The default behaviour of the driver previously assumed a static
InterruptThrottleRate value of 8000, providing a good fallback value
for all traffic types,but lacking in small packet performance and
latency. The hardware can handle many more small packets per second
however, and for this reason an adaptive interrupt moderation algorithm
was implemented.
Since 7.3.x, the driver has two adaptive modes (setting 1 or 3) in
which it dynamically adjusts the InterruptThrottleRate value based on
the traffic that it receives. After determining the type of incoming
traffic in the last timeframe, it will adjust the InterruptThrottleRate
to an appropriate value for that traffic.
The algorithm classifies the incoming traffic every interval into
classes. Once the class is determined, the InterruptThrottleRate
value is adjusted to suit that traffic type the best. There are
three classes defined: "Bulk traffic", for large amounts of packets
of normal size; "Low latency", for small amounts of traffic and/or
a significant percentage of small packets; and "Lowest latency",
for almost completely small packets or minimal traffic.
In dynamic conservative mode, the InterruptThrottleRate value is
set to 4000 for traffic that falls in class "Bulk traffic". If
traffic falls in the "Low latency" or "Lowest latency" class, the
InterruptThrottleRate is increased stepwise to 20000. This default
mode is suitable for most applications.
For situations where low latency is vital such as cluster or
grid computing, the algorithm can reduce latency even more when
InterruptThrottleRate is set to mode 1. In this mode, which operates
the same as mode 3, the InterruptThrottleRate will be increased
stepwise to 70000 for traffic in class "Lowest latency".
Setting InterruptThrottleRate to 0 turns off any interrupt moderation
and may improve small packet latency, but is generally not suitable
for bulk throughput traffic.
Signed-off-by: Jesse Brandeburg <jesse.brandeburg@intel.com>
Cc: Rick Jones <rick.jones2@hp.com>
Signed-off-by: Auke Kok <auke-jan.h.kok@intel.com>
2006-11-01 16:48:13 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
#define E1000_TX_FLAGS_CSUM 0x00000001
|
|
|
|
#define E1000_TX_FLAGS_VLAN 0x00000002
|
|
|
|
#define E1000_TX_FLAGS_TSO 0x00000004
|
2005-04-29 02:43:52 +00:00
|
|
|
#define E1000_TX_FLAGS_IPV4 0x00000008
|
2012-02-11 15:40:01 +00:00
|
|
|
#define E1000_TX_FLAGS_NO_FCS 0x00000010
|
2005-04-16 22:20:36 +00:00
|
|
|
#define E1000_TX_FLAGS_VLAN_MASK 0xffff0000
|
|
|
|
#define E1000_TX_FLAGS_VLAN_SHIFT 16
|
|
|
|
|
2008-07-11 22:17:02 +00:00
|
|
|
static int e1000_tso(struct e1000_adapter *adapter,
|
|
|
|
struct e1000_tx_ring *tx_ring, struct sk_buff *skb)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct e1000_context_desc *context_desc;
|
2006-01-13 00:50:25 +00:00
|
|
|
struct e1000_buffer *buffer_info;
|
2005-04-16 22:20:36 +00:00
|
|
|
unsigned int i;
|
2008-04-03 17:06:32 +00:00
|
|
|
u32 cmd_length = 0;
|
|
|
|
u16 ipcse = 0, tucse, mss;
|
|
|
|
u8 ipcss, ipcso, tucss, tucso, hdr_len;
|
2005-04-16 22:20:36 +00:00
|
|
|
int err;
|
|
|
|
|
2006-07-08 20:34:32 +00:00
|
|
|
if (skb_is_gso(skb)) {
|
2005-04-16 22:20:36 +00:00
|
|
|
if (skb_header_cloned(skb)) {
|
|
|
|
err = pskb_expand_head(skb, 0, 0, GFP_ATOMIC);
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2007-03-19 00:43:48 +00:00
|
|
|
hdr_len = skb_transport_offset(skb) + tcp_hdrlen(skb);
|
2006-06-22 09:40:14 +00:00
|
|
|
mss = skb_shinfo(skb)->gso_size;
|
2006-05-23 21:52:21 +00:00
|
|
|
if (skb->protocol == htons(ETH_P_IP)) {
|
2007-04-21 05:47:35 +00:00
|
|
|
struct iphdr *iph = ip_hdr(skb);
|
|
|
|
iph->tot_len = 0;
|
|
|
|
iph->check = 0;
|
2007-04-11 04:04:22 +00:00
|
|
|
tcp_hdr(skb)->check = ~csum_tcpudp_magic(iph->saddr,
|
|
|
|
iph->daddr, 0,
|
|
|
|
IPPROTO_TCP,
|
|
|
|
0);
|
2005-04-29 02:43:52 +00:00
|
|
|
cmd_length = E1000_TXD_CMD_IP;
|
2007-04-26 00:55:53 +00:00
|
|
|
ipcse = skb_transport_offset(skb) - 1;
|
2006-08-16 18:28:45 +00:00
|
|
|
} else if (skb->protocol == htons(ETH_P_IPV6)) {
|
2007-04-26 00:54:47 +00:00
|
|
|
ipv6_hdr(skb)->payload_len = 0;
|
2007-04-11 04:04:22 +00:00
|
|
|
tcp_hdr(skb)->check =
|
2007-04-26 00:54:47 +00:00
|
|
|
~csum_ipv6_magic(&ipv6_hdr(skb)->saddr,
|
|
|
|
&ipv6_hdr(skb)->daddr,
|
|
|
|
0, IPPROTO_TCP, 0);
|
2005-04-29 02:43:52 +00:00
|
|
|
ipcse = 0;
|
|
|
|
}
|
2007-03-11 01:16:10 +00:00
|
|
|
ipcss = skb_network_offset(skb);
|
2007-04-21 05:47:35 +00:00
|
|
|
ipcso = (void *)&(ip_hdr(skb)->check) - (void *)skb->data;
|
2007-04-26 00:55:53 +00:00
|
|
|
tucss = skb_transport_offset(skb);
|
2007-04-11 04:04:22 +00:00
|
|
|
tucso = (void *)&(tcp_hdr(skb)->check) - (void *)skb->data;
|
2005-04-16 22:20:36 +00:00
|
|
|
tucse = 0;
|
|
|
|
|
|
|
|
cmd_length |= (E1000_TXD_CMD_DEXT | E1000_TXD_CMD_TSE |
|
2005-04-29 02:43:52 +00:00
|
|
|
E1000_TXD_CMD_TCP | (skb->len - (hdr_len)));
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2005-10-04 11:01:55 +00:00
|
|
|
i = tx_ring->next_to_use;
|
|
|
|
context_desc = E1000_CONTEXT_DESC(*tx_ring, i);
|
2006-01-13 00:50:25 +00:00
|
|
|
buffer_info = &tx_ring->buffer_info[i];
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
context_desc->lower_setup.ip_fields.ipcss = ipcss;
|
|
|
|
context_desc->lower_setup.ip_fields.ipcso = ipcso;
|
|
|
|
context_desc->lower_setup.ip_fields.ipcse = cpu_to_le16(ipcse);
|
|
|
|
context_desc->upper_setup.tcp_fields.tucss = tucss;
|
|
|
|
context_desc->upper_setup.tcp_fields.tucso = tucso;
|
|
|
|
context_desc->upper_setup.tcp_fields.tucse = cpu_to_le16(tucse);
|
|
|
|
context_desc->tcp_seg_setup.fields.mss = cpu_to_le16(mss);
|
|
|
|
context_desc->tcp_seg_setup.fields.hdr_len = hdr_len;
|
|
|
|
context_desc->cmd_and_length = cpu_to_le32(cmd_length);
|
|
|
|
|
2006-01-13 00:50:25 +00:00
|
|
|
buffer_info->time_stamp = jiffies;
|
2006-11-01 16:47:53 +00:00
|
|
|
buffer_info->next_to_watch = i;
|
2006-01-13 00:50:25 +00:00
|
|
|
|
2005-10-04 11:01:55 +00:00
|
|
|
if (++i == tx_ring->count) i = 0;
|
|
|
|
tx_ring->next_to_use = i;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-03-21 18:06:25 +00:00
|
|
|
return true;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2008-03-21 18:06:25 +00:00
|
|
|
return false;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2008-07-11 22:17:02 +00:00
|
|
|
static bool e1000_tx_csum(struct e1000_adapter *adapter,
|
|
|
|
struct e1000_tx_ring *tx_ring, struct sk_buff *skb)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct e1000_context_desc *context_desc;
|
2006-01-13 00:50:25 +00:00
|
|
|
struct e1000_buffer *buffer_info;
|
2005-04-16 22:20:36 +00:00
|
|
|
unsigned int i;
|
2008-04-03 17:06:32 +00:00
|
|
|
u8 css;
|
2008-10-09 21:29:26 +00:00
|
|
|
u32 cmd_len = E1000_TXD_CMD_DEXT;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-10-09 21:29:26 +00:00
|
|
|
if (skb->ip_summed != CHECKSUM_PARTIAL)
|
|
|
|
return false;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-10-09 21:29:26 +00:00
|
|
|
switch (skb->protocol) {
|
2009-02-01 08:45:17 +00:00
|
|
|
case cpu_to_be16(ETH_P_IP):
|
2008-10-09 21:29:26 +00:00
|
|
|
if (ip_hdr(skb)->protocol == IPPROTO_TCP)
|
|
|
|
cmd_len |= E1000_TXD_CMD_TCP;
|
|
|
|
break;
|
2009-02-01 08:45:17 +00:00
|
|
|
case cpu_to_be16(ETH_P_IPV6):
|
2008-10-09 21:29:26 +00:00
|
|
|
/* XXX not handling all IPV6 headers */
|
|
|
|
if (ipv6_hdr(skb)->nexthdr == IPPROTO_TCP)
|
|
|
|
cmd_len |= E1000_TXD_CMD_TCP;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
if (unlikely(net_ratelimit()))
|
2010-07-27 06:37:21 +00:00
|
|
|
e_warn(drv, "checksum_partial proto=%x!\n",
|
|
|
|
skb->protocol);
|
2008-10-09 21:29:26 +00:00
|
|
|
break;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2010-12-14 15:24:08 +00:00
|
|
|
css = skb_checksum_start_offset(skb);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-10-09 21:29:26 +00:00
|
|
|
i = tx_ring->next_to_use;
|
|
|
|
buffer_info = &tx_ring->buffer_info[i];
|
|
|
|
context_desc = E1000_CONTEXT_DESC(*tx_ring, i);
|
2006-01-13 00:50:25 +00:00
|
|
|
|
2008-10-09 21:29:26 +00:00
|
|
|
context_desc->lower_setup.ip_config = 0;
|
|
|
|
context_desc->upper_setup.tcp_fields.tucss = css;
|
|
|
|
context_desc->upper_setup.tcp_fields.tucso =
|
|
|
|
css + skb->csum_offset;
|
|
|
|
context_desc->upper_setup.tcp_fields.tucse = 0;
|
|
|
|
context_desc->tcp_seg_setup.data = 0;
|
|
|
|
context_desc->cmd_and_length = cpu_to_le32(cmd_len);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-10-09 21:29:26 +00:00
|
|
|
buffer_info->time_stamp = jiffies;
|
|
|
|
buffer_info->next_to_watch = i;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-10-09 21:29:26 +00:00
|
|
|
if (unlikely(++i == tx_ring->count)) i = 0;
|
|
|
|
tx_ring->next_to_use = i;
|
|
|
|
|
|
|
|
return true;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#define E1000_MAX_TXD_PWR 12
|
|
|
|
#define E1000_MAX_DATA_PER_TXD (1<<E1000_MAX_TXD_PWR)
|
|
|
|
|
2008-07-11 22:17:02 +00:00
|
|
|
static int e1000_tx_map(struct e1000_adapter *adapter,
|
|
|
|
struct e1000_tx_ring *tx_ring,
|
|
|
|
struct sk_buff *skb, unsigned int first,
|
|
|
|
unsigned int max_per_txd, unsigned int nr_frags,
|
|
|
|
unsigned int mss)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2008-07-11 22:17:08 +00:00
|
|
|
struct e1000_hw *hw = &adapter->hw;
|
2009-12-02 16:46:00 +00:00
|
|
|
struct pci_dev *pdev = adapter->pdev;
|
2009-03-25 21:58:45 +00:00
|
|
|
struct e1000_buffer *buffer_info;
|
2009-03-03 00:03:21 +00:00
|
|
|
unsigned int len = skb_headlen(skb);
|
2009-12-02 16:46:00 +00:00
|
|
|
unsigned int offset = 0, size, count = 0, i;
|
2011-08-25 14:39:24 +00:00
|
|
|
unsigned int f, bytecount, segs;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
i = tx_ring->next_to_use;
|
|
|
|
|
2006-01-18 21:01:39 +00:00
|
|
|
while (len) {
|
2009-03-25 21:58:45 +00:00
|
|
|
buffer_info = &tx_ring->buffer_info[i];
|
2005-04-16 22:20:36 +00:00
|
|
|
size = min(len, max_per_txd);
|
2005-12-13 05:06:22 +00:00
|
|
|
/* Workaround for Controller erratum --
|
|
|
|
* descriptor for non-tso packet in a linear SKB that follows a
|
|
|
|
* tso gets written back prematurely before the data is fully
|
2013-02-09 12:49:21 +00:00
|
|
|
* DMA'd to the controller
|
|
|
|
*/
|
2005-12-13 05:06:22 +00:00
|
|
|
if (!skb->data_len && tx_ring->last_tx_tso &&
|
2006-07-08 20:34:32 +00:00
|
|
|
!skb_is_gso(skb)) {
|
2011-12-19 13:56:45 +00:00
|
|
|
tx_ring->last_tx_tso = false;
|
2005-12-13 05:06:22 +00:00
|
|
|
size -= 4;
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* Workaround for premature desc write-backs
|
2013-02-09 12:49:21 +00:00
|
|
|
* in TSO mode. Append 4-byte sentinel desc
|
|
|
|
*/
|
2006-01-18 21:01:39 +00:00
|
|
|
if (unlikely(mss && !nr_frags && size == len && size > 8))
|
2005-04-16 22:20:36 +00:00
|
|
|
size -= 4;
|
2005-04-29 02:41:46 +00:00
|
|
|
/* work-around for errata 10 and it applies
|
|
|
|
* to all controllers in PCI-X mode
|
|
|
|
* The fix is to make sure that the first descriptor of a
|
|
|
|
* packet is smaller than 2048 - 16 - 16 (or 2016) bytes
|
|
|
|
*/
|
2008-07-11 22:17:08 +00:00
|
|
|
if (unlikely((hw->bus_type == e1000_bus_type_pcix) &&
|
2005-04-29 02:41:46 +00:00
|
|
|
(size > 2015) && count == 0))
|
|
|
|
size = 2015;
|
2006-01-18 21:01:39 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* Workaround for potential 82544 hang in PCI-X. Avoid
|
2013-02-09 12:49:21 +00:00
|
|
|
* terminating buffers within evenly-aligned dwords.
|
|
|
|
*/
|
2006-01-18 21:01:39 +00:00
|
|
|
if (unlikely(adapter->pcix_82544 &&
|
2005-04-16 22:20:36 +00:00
|
|
|
!((unsigned long)(skb->data + offset + size - 1) & 4) &&
|
|
|
|
size > 4))
|
|
|
|
size -= 4;
|
|
|
|
|
|
|
|
buffer_info->length = size;
|
2009-09-25 12:18:07 +00:00
|
|
|
/* set time_stamp *before* dma to help avoid a possible race */
|
2005-04-16 22:20:36 +00:00
|
|
|
buffer_info->time_stamp = jiffies;
|
2009-12-02 16:46:00 +00:00
|
|
|
buffer_info->mapped_as_page = false;
|
2010-04-27 13:08:45 +00:00
|
|
|
buffer_info->dma = dma_map_single(&pdev->dev,
|
|
|
|
skb->data + offset,
|
2013-02-09 12:49:21 +00:00
|
|
|
size, DMA_TO_DEVICE);
|
2010-04-27 13:08:45 +00:00
|
|
|
if (dma_mapping_error(&pdev->dev, buffer_info->dma))
|
2009-12-02 16:46:00 +00:00
|
|
|
goto dma_error;
|
2006-11-01 16:47:53 +00:00
|
|
|
buffer_info->next_to_watch = i;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
len -= size;
|
|
|
|
offset += size;
|
|
|
|
count++;
|
2009-03-25 21:58:45 +00:00
|
|
|
if (len) {
|
|
|
|
i++;
|
|
|
|
if (unlikely(i == tx_ring->count))
|
|
|
|
i = 0;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2006-01-18 21:01:39 +00:00
|
|
|
for (f = 0; f < nr_frags; f++) {
|
2011-10-18 21:00:24 +00:00
|
|
|
const struct skb_frag_struct *frag;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
frag = &skb_shinfo(skb)->frags[f];
|
2011-10-18 21:00:24 +00:00
|
|
|
len = skb_frag_size(frag);
|
2011-08-29 23:18:26 +00:00
|
|
|
offset = 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-01-18 21:01:39 +00:00
|
|
|
while (len) {
|
2011-08-29 23:18:26 +00:00
|
|
|
unsigned long bufend;
|
2009-03-25 21:58:45 +00:00
|
|
|
i++;
|
|
|
|
if (unlikely(i == tx_ring->count))
|
|
|
|
i = 0;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
buffer_info = &tx_ring->buffer_info[i];
|
|
|
|
size = min(len, max_per_txd);
|
|
|
|
/* Workaround for premature desc write-backs
|
2013-02-09 12:49:21 +00:00
|
|
|
* in TSO mode. Append 4-byte sentinel desc
|
|
|
|
*/
|
|
|
|
if (unlikely(mss && f == (nr_frags-1) &&
|
|
|
|
size == len && size > 8))
|
2005-04-16 22:20:36 +00:00
|
|
|
size -= 4;
|
|
|
|
/* Workaround for potential 82544 hang in PCI-X.
|
|
|
|
* Avoid terminating buffers within evenly-aligned
|
2013-02-09 12:49:21 +00:00
|
|
|
* dwords.
|
|
|
|
*/
|
2011-08-29 23:18:26 +00:00
|
|
|
bufend = (unsigned long)
|
|
|
|
page_to_phys(skb_frag_page(frag));
|
|
|
|
bufend += offset + size - 1;
|
2006-01-18 21:01:39 +00:00
|
|
|
if (unlikely(adapter->pcix_82544 &&
|
2011-08-29 23:18:26 +00:00
|
|
|
!(bufend & 4) &&
|
|
|
|
size > 4))
|
2005-04-16 22:20:36 +00:00
|
|
|
size -= 4;
|
|
|
|
|
|
|
|
buffer_info->length = size;
|
|
|
|
buffer_info->time_stamp = jiffies;
|
2009-12-02 16:46:00 +00:00
|
|
|
buffer_info->mapped_as_page = true;
|
2011-08-29 23:18:26 +00:00
|
|
|
buffer_info->dma = skb_frag_dma_map(&pdev->dev, frag,
|
|
|
|
offset, size, DMA_TO_DEVICE);
|
2010-04-27 13:08:45 +00:00
|
|
|
if (dma_mapping_error(&pdev->dev, buffer_info->dma))
|
2009-12-02 16:46:00 +00:00
|
|
|
goto dma_error;
|
2006-11-01 16:47:53 +00:00
|
|
|
buffer_info->next_to_watch = i;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
len -= size;
|
|
|
|
offset += size;
|
|
|
|
count++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-08-25 14:39:24 +00:00
|
|
|
segs = skb_shinfo(skb)->gso_segs ?: 1;
|
|
|
|
/* multiply data chunks by size of headers */
|
|
|
|
bytecount = ((segs - 1) * skb_headlen(skb)) + skb->len;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
tx_ring->buffer_info[i].skb = skb;
|
2011-08-25 14:39:24 +00:00
|
|
|
tx_ring->buffer_info[i].segs = segs;
|
|
|
|
tx_ring->buffer_info[i].bytecount = bytecount;
|
2005-04-16 22:20:36 +00:00
|
|
|
tx_ring->buffer_info[first].next_to_watch = i;
|
|
|
|
|
|
|
|
return count;
|
2009-12-02 16:46:00 +00:00
|
|
|
|
|
|
|
dma_error:
|
|
|
|
dev_err(&pdev->dev, "TX DMA map failed\n");
|
|
|
|
buffer_info->dma = 0;
|
2010-01-19 14:21:45 +00:00
|
|
|
if (count)
|
2009-12-02 16:46:00 +00:00
|
|
|
count--;
|
2010-01-19 14:21:45 +00:00
|
|
|
|
|
|
|
while (count--) {
|
|
|
|
if (i==0)
|
2009-12-02 16:46:00 +00:00
|
|
|
i += tx_ring->count;
|
2010-01-19 14:21:45 +00:00
|
|
|
i--;
|
2009-12-02 16:46:00 +00:00
|
|
|
buffer_info = &tx_ring->buffer_info[i];
|
|
|
|
e1000_unmap_and_free_tx_resource(adapter, buffer_info);
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2008-07-11 22:17:02 +00:00
|
|
|
static void e1000_tx_queue(struct e1000_adapter *adapter,
|
|
|
|
struct e1000_tx_ring *tx_ring, int tx_flags,
|
|
|
|
int count)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2008-07-11 22:17:08 +00:00
|
|
|
struct e1000_hw *hw = &adapter->hw;
|
2005-04-16 22:20:36 +00:00
|
|
|
struct e1000_tx_desc *tx_desc = NULL;
|
|
|
|
struct e1000_buffer *buffer_info;
|
2008-04-03 17:06:32 +00:00
|
|
|
u32 txd_upper = 0, txd_lower = E1000_TXD_CMD_IFCS;
|
2005-04-16 22:20:36 +00:00
|
|
|
unsigned int i;
|
|
|
|
|
2006-01-18 21:01:39 +00:00
|
|
|
if (likely(tx_flags & E1000_TX_FLAGS_TSO)) {
|
2005-04-16 22:20:36 +00:00
|
|
|
txd_lower |= E1000_TXD_CMD_DEXT | E1000_TXD_DTYP_D |
|
2013-02-09 12:49:21 +00:00
|
|
|
E1000_TXD_CMD_TSE;
|
2005-04-29 02:43:52 +00:00
|
|
|
txd_upper |= E1000_TXD_POPTS_TXSM << 8;
|
|
|
|
|
2006-01-18 21:01:39 +00:00
|
|
|
if (likely(tx_flags & E1000_TX_FLAGS_IPV4))
|
2005-04-29 02:43:52 +00:00
|
|
|
txd_upper |= E1000_TXD_POPTS_IXSM << 8;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2006-01-18 21:01:39 +00:00
|
|
|
if (likely(tx_flags & E1000_TX_FLAGS_CSUM)) {
|
2005-04-16 22:20:36 +00:00
|
|
|
txd_lower |= E1000_TXD_CMD_DEXT | E1000_TXD_DTYP_D;
|
|
|
|
txd_upper |= E1000_TXD_POPTS_TXSM << 8;
|
|
|
|
}
|
|
|
|
|
2006-01-18 21:01:39 +00:00
|
|
|
if (unlikely(tx_flags & E1000_TX_FLAGS_VLAN)) {
|
2005-04-16 22:20:36 +00:00
|
|
|
txd_lower |= E1000_TXD_CMD_VLE;
|
|
|
|
txd_upper |= (tx_flags & E1000_TX_FLAGS_VLAN_MASK);
|
|
|
|
}
|
|
|
|
|
2012-02-11 15:40:01 +00:00
|
|
|
if (unlikely(tx_flags & E1000_TX_FLAGS_NO_FCS))
|
|
|
|
txd_lower &= ~(E1000_TXD_CMD_IFCS);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
i = tx_ring->next_to_use;
|
|
|
|
|
2006-01-18 21:01:39 +00:00
|
|
|
while (count--) {
|
2005-04-16 22:20:36 +00:00
|
|
|
buffer_info = &tx_ring->buffer_info[i];
|
|
|
|
tx_desc = E1000_TX_DESC(*tx_ring, i);
|
|
|
|
tx_desc->buffer_addr = cpu_to_le64(buffer_info->dma);
|
|
|
|
tx_desc->lower.data =
|
|
|
|
cpu_to_le32(txd_lower | buffer_info->length);
|
|
|
|
tx_desc->upper.data = cpu_to_le32(txd_upper);
|
2006-01-18 21:01:39 +00:00
|
|
|
if (unlikely(++i == tx_ring->count)) i = 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
tx_desc->lower.data |= cpu_to_le32(adapter->txd_cmd);
|
|
|
|
|
2012-02-11 15:40:01 +00:00
|
|
|
/* txd_cmd re-enables FCS, so we'll re-disable it here as desired. */
|
|
|
|
if (unlikely(tx_flags & E1000_TX_FLAGS_NO_FCS))
|
|
|
|
tx_desc->lower.data &= ~(cpu_to_le32(E1000_TXD_CMD_IFCS));
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* Force memory writes to complete before letting h/w
|
|
|
|
* know there are new descriptors to fetch. (Only
|
|
|
|
* applicable for weak-ordered memory model archs,
|
2013-02-09 12:49:21 +00:00
|
|
|
* such as IA-64).
|
|
|
|
*/
|
2005-04-16 22:20:36 +00:00
|
|
|
wmb();
|
|
|
|
|
|
|
|
tx_ring->next_to_use = i;
|
2008-07-11 22:17:08 +00:00
|
|
|
writel(i, hw->hw_addr + tx_ring->tdt);
|
2006-11-01 16:47:42 +00:00
|
|
|
/* we need this if more than one processor can write to our tail
|
2013-02-09 12:49:21 +00:00
|
|
|
* at a time, it synchronizes IO on IA64/Altix systems
|
|
|
|
*/
|
2006-11-01 16:47:42 +00:00
|
|
|
mmiowb();
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2012-07-10 10:56:59 +00:00
|
|
|
/* 82547 workaround to avoid controller hang in half-duplex environment.
|
2005-04-16 22:20:36 +00:00
|
|
|
* The workaround is to avoid queuing a large packet that would span
|
|
|
|
* the internal Tx FIFO ring boundary by notifying the stack to resend
|
|
|
|
* the packet at a later time. This gives the Tx FIFO an opportunity to
|
|
|
|
* flush all packets. When that occurs, we reset the Tx FIFO pointers
|
|
|
|
* to the beginning of the Tx FIFO.
|
2012-07-10 10:56:59 +00:00
|
|
|
*/
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
#define E1000_FIFO_HDR 0x10
|
|
|
|
#define E1000_82547_PAD_LEN 0x3E0
|
|
|
|
|
2008-07-11 22:17:02 +00:00
|
|
|
static int e1000_82547_fifo_workaround(struct e1000_adapter *adapter,
|
|
|
|
struct sk_buff *skb)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2008-04-03 17:06:32 +00:00
|
|
|
u32 fifo_space = adapter->tx_fifo_size - adapter->tx_fifo_head;
|
|
|
|
u32 skb_fifo_len = skb->len + E1000_FIFO_HDR;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-04-27 20:55:29 +00:00
|
|
|
skb_fifo_len = ALIGN(skb_fifo_len, E1000_FIFO_HDR);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-01-18 21:01:39 +00:00
|
|
|
if (adapter->link_duplex != HALF_DUPLEX)
|
2005-04-16 22:20:36 +00:00
|
|
|
goto no_fifo_stall_required;
|
|
|
|
|
2006-01-18 21:01:39 +00:00
|
|
|
if (atomic_read(&adapter->tx_fifo_stall))
|
2005-04-16 22:20:36 +00:00
|
|
|
return 1;
|
|
|
|
|
2006-01-18 21:01:39 +00:00
|
|
|
if (skb_fifo_len >= (E1000_82547_PAD_LEN + fifo_space)) {
|
2005-04-16 22:20:36 +00:00
|
|
|
atomic_set(&adapter->tx_fifo_stall, 1);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
no_fifo_stall_required:
|
|
|
|
adapter->tx_fifo_head += skb_fifo_len;
|
2006-01-18 21:01:39 +00:00
|
|
|
if (adapter->tx_fifo_head >= adapter->tx_fifo_size)
|
2005-04-16 22:20:36 +00:00
|
|
|
adapter->tx_fifo_head -= adapter->tx_fifo_size;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-09-27 19:53:48 +00:00
|
|
|
static int __e1000_maybe_stop_tx(struct net_device *netdev, int size)
|
|
|
|
{
|
|
|
|
struct e1000_adapter *adapter = netdev_priv(netdev);
|
|
|
|
struct e1000_tx_ring *tx_ring = adapter->tx_ring;
|
|
|
|
|
|
|
|
netif_stop_queue(netdev);
|
|
|
|
/* Herbert's original patch had:
|
|
|
|
* smp_mb__after_netif_stop_queue();
|
2013-02-09 12:49:21 +00:00
|
|
|
* but since that doesn't exist yet, just open code it.
|
|
|
|
*/
|
2006-09-27 19:53:48 +00:00
|
|
|
smp_mb();
|
|
|
|
|
|
|
|
/* We need to check again in a case another CPU has just
|
2013-02-09 12:49:21 +00:00
|
|
|
* made room available.
|
|
|
|
*/
|
2006-09-27 19:53:48 +00:00
|
|
|
if (likely(E1000_DESC_UNUSED(tx_ring) < size))
|
|
|
|
return -EBUSY;
|
|
|
|
|
|
|
|
/* A reprieve! */
|
|
|
|
netif_start_queue(netdev);
|
2006-11-01 16:47:59 +00:00
|
|
|
++adapter->restart_queue;
|
2006-09-27 19:53:48 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int e1000_maybe_stop_tx(struct net_device *netdev,
|
2013-02-09 12:49:21 +00:00
|
|
|
struct e1000_tx_ring *tx_ring, int size)
|
2006-09-27 19:53:48 +00:00
|
|
|
{
|
|
|
|
if (likely(E1000_DESC_UNUSED(tx_ring) >= size))
|
|
|
|
return 0;
|
|
|
|
return __e1000_maybe_stop_tx(netdev, size);
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
#define TXD_USE_COUNT(S, X) (((S) >> (X)) + 1 )
|
2009-08-31 19:50:55 +00:00
|
|
|
static netdev_tx_t e1000_xmit_frame(struct sk_buff *skb,
|
|
|
|
struct net_device *netdev)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2005-06-18 00:41:45 +00:00
|
|
|
struct e1000_adapter *adapter = netdev_priv(netdev);
|
2008-07-11 22:17:08 +00:00
|
|
|
struct e1000_hw *hw = &adapter->hw;
|
2005-10-04 11:01:55 +00:00
|
|
|
struct e1000_tx_ring *tx_ring;
|
2005-04-16 22:20:36 +00:00
|
|
|
unsigned int first, max_per_txd = E1000_MAX_DATA_PER_TXD;
|
|
|
|
unsigned int max_txd_pwr = E1000_MAX_TXD_PWR;
|
|
|
|
unsigned int tx_flags = 0;
|
2010-04-14 22:59:40 +00:00
|
|
|
unsigned int len = skb_headlen(skb);
|
2007-10-05 21:15:16 +00:00
|
|
|
unsigned int nr_frags;
|
|
|
|
unsigned int mss;
|
2005-04-16 22:20:36 +00:00
|
|
|
int count = 0;
|
2006-05-23 20:36:06 +00:00
|
|
|
int tso;
|
2005-04-16 22:20:36 +00:00
|
|
|
unsigned int f;
|
|
|
|
|
2013-02-09 12:49:21 +00:00
|
|
|
/* This goes back to the question of how to logically map a Tx queue
|
2006-09-27 19:53:48 +00:00
|
|
|
* to a flow. Right now, performance is impacted slightly negatively
|
2013-02-09 12:49:21 +00:00
|
|
|
* if using multiple Tx queues. If the stack breaks away from a
|
|
|
|
* single qdisc implementation, we can look at this again.
|
|
|
|
*/
|
2005-10-04 11:01:55 +00:00
|
|
|
tx_ring = adapter->tx_ring;
|
2005-10-04 11:03:23 +00:00
|
|
|
|
2005-10-04 11:01:55 +00:00
|
|
|
if (unlikely(skb->len <= 0)) {
|
2005-04-16 22:20:36 +00:00
|
|
|
dev_kfree_skb_any(skb);
|
|
|
|
return NETDEV_TX_OK;
|
|
|
|
}
|
|
|
|
|
2012-09-15 10:16:57 +00:00
|
|
|
/* On PCI/PCI-X HW, if packet size is less than ETH_ZLEN,
|
|
|
|
* packets may get corrupted during padding by HW.
|
|
|
|
* To WA this issue, pad all small packets manually.
|
|
|
|
*/
|
|
|
|
if (skb->len < ETH_ZLEN) {
|
|
|
|
if (skb_pad(skb, ETH_ZLEN - skb->len))
|
|
|
|
return NETDEV_TX_OK;
|
|
|
|
skb->len = ETH_ZLEN;
|
|
|
|
skb_set_tail_pointer(skb, ETH_ZLEN);
|
|
|
|
}
|
|
|
|
|
2006-06-22 09:40:14 +00:00
|
|
|
mss = skb_shinfo(skb)->gso_size;
|
2006-05-23 20:36:06 +00:00
|
|
|
/* The controller does a simple calculation to
|
2005-04-16 22:20:36 +00:00
|
|
|
* make sure there is enough room in the FIFO before
|
|
|
|
* initiating the DMA for each buffer. The calc is:
|
|
|
|
* 4 = ceil(buffer len/mss). To make sure we don't
|
|
|
|
* overrun the FIFO, adjust the max buffer len if mss
|
2013-02-09 12:49:21 +00:00
|
|
|
* drops.
|
|
|
|
*/
|
2006-01-18 21:01:39 +00:00
|
|
|
if (mss) {
|
2008-04-03 17:06:32 +00:00
|
|
|
u8 hdr_len;
|
2005-04-16 22:20:36 +00:00
|
|
|
max_per_txd = min(mss << 2, max_per_txd);
|
|
|
|
max_txd_pwr = fls(max_per_txd) - 1;
|
2006-01-13 00:50:23 +00:00
|
|
|
|
2007-03-19 00:43:48 +00:00
|
|
|
hdr_len = skb_transport_offset(skb) + tcp_hdrlen(skb);
|
2007-10-05 21:15:16 +00:00
|
|
|
if (skb->data_len && hdr_len == len) {
|
2008-07-11 22:17:08 +00:00
|
|
|
switch (hw->mac_type) {
|
2006-03-03 02:20:17 +00:00
|
|
|
unsigned int pull_size;
|
2006-12-16 01:04:33 +00:00
|
|
|
case e1000_82544:
|
|
|
|
/* Make sure we have room to chop off 4 bytes,
|
|
|
|
* and that the end alignment will work out to
|
|
|
|
* this hardware's requirements
|
|
|
|
* NOTE: this is a TSO only workaround
|
|
|
|
* if end byte alignment not correct move us
|
2013-02-09 12:49:21 +00:00
|
|
|
* into the next dword
|
|
|
|
*/
|
|
|
|
if ((unsigned long)(skb_tail_pointer(skb) - 1)
|
|
|
|
& 4)
|
2006-12-16 01:04:33 +00:00
|
|
|
break;
|
|
|
|
/* fall through */
|
2006-03-03 02:20:17 +00:00
|
|
|
pull_size = min((unsigned int)4, skb->data_len);
|
|
|
|
if (!__pskb_pull_tail(skb, pull_size)) {
|
2010-07-27 06:37:21 +00:00
|
|
|
e_err(drv, "__pskb_pull_tail "
|
|
|
|
"failed.\n");
|
2006-03-03 02:20:17 +00:00
|
|
|
dev_kfree_skb_any(skb);
|
2006-03-11 18:35:31 +00:00
|
|
|
return NETDEV_TX_OK;
|
2006-03-03 02:20:17 +00:00
|
|
|
}
|
2010-04-14 22:59:40 +00:00
|
|
|
len = skb_headlen(skb);
|
2006-03-03 02:20:17 +00:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
/* do nothing */
|
|
|
|
break;
|
2006-01-13 00:51:07 +00:00
|
|
|
}
|
2006-01-13 00:50:23 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2006-01-13 00:50:23 +00:00
|
|
|
/* reserve a descriptor for the offload context */
|
2006-08-29 23:44:56 +00:00
|
|
|
if ((mss) || (skb->ip_summed == CHECKSUM_PARTIAL))
|
2005-04-16 22:20:36 +00:00
|
|
|
count++;
|
2005-04-29 02:44:46 +00:00
|
|
|
count++;
|
2005-12-13 05:06:22 +00:00
|
|
|
|
|
|
|
/* Controller Erratum workaround */
|
2006-07-08 20:34:32 +00:00
|
|
|
if (!skb->data_len && tx_ring->last_tx_tso && !skb_is_gso(skb))
|
2005-12-13 05:06:22 +00:00
|
|
|
count++;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
count += TXD_USE_COUNT(len, max_txd_pwr);
|
|
|
|
|
2006-01-18 21:01:39 +00:00
|
|
|
if (adapter->pcix_82544)
|
2005-04-16 22:20:36 +00:00
|
|
|
count++;
|
|
|
|
|
2006-01-18 21:01:39 +00:00
|
|
|
/* work-around for errata 10 and it applies to all controllers
|
2005-04-29 02:41:46 +00:00
|
|
|
* in PCI-X mode, so add one more descriptor to the count
|
|
|
|
*/
|
2008-07-11 22:17:08 +00:00
|
|
|
if (unlikely((hw->bus_type == e1000_bus_type_pcix) &&
|
2005-04-29 02:41:46 +00:00
|
|
|
(len > 2015)))
|
|
|
|
count++;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
nr_frags = skb_shinfo(skb)->nr_frags;
|
2006-01-18 21:01:39 +00:00
|
|
|
for (f = 0; f < nr_frags; f++)
|
2011-10-18 21:00:24 +00:00
|
|
|
count += TXD_USE_COUNT(skb_frag_size(&skb_shinfo(skb)->frags[f]),
|
2005-04-16 22:20:36 +00:00
|
|
|
max_txd_pwr);
|
2006-01-18 21:01:39 +00:00
|
|
|
if (adapter->pcix_82544)
|
2005-04-16 22:20:36 +00:00
|
|
|
count += nr_frags;
|
|
|
|
|
|
|
|
/* need: count + 2 desc gap to keep tail from touching
|
2013-02-09 12:49:21 +00:00
|
|
|
* head, otherwise try next time
|
|
|
|
*/
|
2009-01-21 22:42:47 +00:00
|
|
|
if (unlikely(e1000_maybe_stop_tx(netdev, tx_ring, count + 2)))
|
2005-04-16 22:20:36 +00:00
|
|
|
return NETDEV_TX_BUSY;
|
|
|
|
|
2011-10-05 07:24:41 +00:00
|
|
|
if (unlikely((hw->mac_type == e1000_82547) &&
|
|
|
|
(e1000_82547_fifo_workaround(adapter, skb)))) {
|
|
|
|
netif_stop_queue(netdev);
|
|
|
|
if (!test_bit(__E1000_DOWN, &adapter->flags))
|
|
|
|
schedule_delayed_work(&adapter->fifo_stall_task, 1);
|
|
|
|
return NETDEV_TX_BUSY;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2011-07-21 03:26:31 +00:00
|
|
|
if (vlan_tx_tag_present(skb)) {
|
2005-04-16 22:20:36 +00:00
|
|
|
tx_flags |= E1000_TX_FLAGS_VLAN;
|
|
|
|
tx_flags |= (vlan_tx_tag_get(skb) << E1000_TX_FLAGS_VLAN_SHIFT);
|
|
|
|
}
|
|
|
|
|
2005-10-04 11:01:55 +00:00
|
|
|
first = tx_ring->next_to_use;
|
2006-01-18 21:01:39 +00:00
|
|
|
|
2005-10-04 11:01:55 +00:00
|
|
|
tso = e1000_tso(adapter, tx_ring, skb);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (tso < 0) {
|
|
|
|
dev_kfree_skb_any(skb);
|
|
|
|
return NETDEV_TX_OK;
|
|
|
|
}
|
|
|
|
|
2005-12-13 05:06:22 +00:00
|
|
|
if (likely(tso)) {
|
2009-09-25 12:18:41 +00:00
|
|
|
if (likely(hw->mac_type != e1000_82544))
|
2011-12-19 13:56:45 +00:00
|
|
|
tx_ring->last_tx_tso = true;
|
2005-04-16 22:20:36 +00:00
|
|
|
tx_flags |= E1000_TX_FLAGS_TSO;
|
2005-12-13 05:06:22 +00:00
|
|
|
} else if (likely(e1000_tx_csum(adapter, tx_ring, skb)))
|
2005-04-16 22:20:36 +00:00
|
|
|
tx_flags |= E1000_TX_FLAGS_CSUM;
|
|
|
|
|
2006-05-23 21:52:21 +00:00
|
|
|
if (likely(skb->protocol == htons(ETH_P_IP)))
|
2005-04-29 02:43:52 +00:00
|
|
|
tx_flags |= E1000_TX_FLAGS_IPV4;
|
|
|
|
|
2012-02-11 15:40:01 +00:00
|
|
|
if (unlikely(skb->no_fcs))
|
|
|
|
tx_flags |= E1000_TX_FLAGS_NO_FCS;
|
|
|
|
|
2009-03-25 21:58:45 +00:00
|
|
|
count = e1000_tx_map(adapter, tx_ring, skb, first, max_per_txd,
|
2013-02-09 12:49:21 +00:00
|
|
|
nr_frags, mss);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-03-25 21:58:45 +00:00
|
|
|
if (count) {
|
2012-08-24 08:04:58 +00:00
|
|
|
netdev_sent_queue(netdev, skb->len);
|
2012-04-27 09:04:04 +00:00
|
|
|
skb_tx_timestamp(skb);
|
|
|
|
|
2009-03-25 21:58:45 +00:00
|
|
|
e1000_tx_queue(adapter, tx_ring, tx_flags, count);
|
|
|
|
/* Make sure there is space in the ring for the next send. */
|
|
|
|
e1000_maybe_stop_tx(netdev, tx_ring, MAX_SKB_FRAGS + 2);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-03-25 21:58:45 +00:00
|
|
|
} else {
|
|
|
|
dev_kfree_skb_any(skb);
|
|
|
|
tx_ring->buffer_info[first].time_stamp = 0;
|
|
|
|
tx_ring->next_to_use = first;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
return NETDEV_TX_OK;
|
|
|
|
}
|
|
|
|
|
2012-01-27 09:00:46 +00:00
|
|
|
#define NUM_REGS 38 /* 1 based count */
|
|
|
|
static void e1000_regdump(struct e1000_adapter *adapter)
|
|
|
|
{
|
|
|
|
struct e1000_hw *hw = &adapter->hw;
|
|
|
|
u32 regs[NUM_REGS];
|
|
|
|
u32 *regs_buff = regs;
|
|
|
|
int i = 0;
|
|
|
|
|
2012-02-10 08:06:36 +00:00
|
|
|
static const char * const reg_name[] = {
|
|
|
|
"CTRL", "STATUS",
|
|
|
|
"RCTL", "RDLEN", "RDH", "RDT", "RDTR",
|
|
|
|
"TCTL", "TDBAL", "TDBAH", "TDLEN", "TDH", "TDT",
|
|
|
|
"TIDV", "TXDCTL", "TADV", "TARC0",
|
|
|
|
"TDBAL1", "TDBAH1", "TDLEN1", "TDH1", "TDT1",
|
|
|
|
"TXDCTL1", "TARC1",
|
|
|
|
"CTRL_EXT", "ERT", "RDBAL", "RDBAH",
|
|
|
|
"TDFH", "TDFT", "TDFHS", "TDFTS", "TDFPC",
|
|
|
|
"RDFH", "RDFT", "RDFHS", "RDFTS", "RDFPC"
|
2012-01-27 09:00:46 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
regs_buff[0] = er32(CTRL);
|
|
|
|
regs_buff[1] = er32(STATUS);
|
|
|
|
|
|
|
|
regs_buff[2] = er32(RCTL);
|
|
|
|
regs_buff[3] = er32(RDLEN);
|
|
|
|
regs_buff[4] = er32(RDH);
|
|
|
|
regs_buff[5] = er32(RDT);
|
|
|
|
regs_buff[6] = er32(RDTR);
|
|
|
|
|
|
|
|
regs_buff[7] = er32(TCTL);
|
|
|
|
regs_buff[8] = er32(TDBAL);
|
|
|
|
regs_buff[9] = er32(TDBAH);
|
|
|
|
regs_buff[10] = er32(TDLEN);
|
|
|
|
regs_buff[11] = er32(TDH);
|
|
|
|
regs_buff[12] = er32(TDT);
|
|
|
|
regs_buff[13] = er32(TIDV);
|
|
|
|
regs_buff[14] = er32(TXDCTL);
|
|
|
|
regs_buff[15] = er32(TADV);
|
|
|
|
regs_buff[16] = er32(TARC0);
|
|
|
|
|
|
|
|
regs_buff[17] = er32(TDBAL1);
|
|
|
|
regs_buff[18] = er32(TDBAH1);
|
|
|
|
regs_buff[19] = er32(TDLEN1);
|
|
|
|
regs_buff[20] = er32(TDH1);
|
|
|
|
regs_buff[21] = er32(TDT1);
|
|
|
|
regs_buff[22] = er32(TXDCTL1);
|
|
|
|
regs_buff[23] = er32(TARC1);
|
|
|
|
regs_buff[24] = er32(CTRL_EXT);
|
|
|
|
regs_buff[25] = er32(ERT);
|
|
|
|
regs_buff[26] = er32(RDBAL0);
|
|
|
|
regs_buff[27] = er32(RDBAH0);
|
|
|
|
regs_buff[28] = er32(TDFH);
|
|
|
|
regs_buff[29] = er32(TDFT);
|
|
|
|
regs_buff[30] = er32(TDFHS);
|
|
|
|
regs_buff[31] = er32(TDFTS);
|
|
|
|
regs_buff[32] = er32(TDFPC);
|
|
|
|
regs_buff[33] = er32(RDFH);
|
|
|
|
regs_buff[34] = er32(RDFT);
|
|
|
|
regs_buff[35] = er32(RDFHS);
|
|
|
|
regs_buff[36] = er32(RDFTS);
|
|
|
|
regs_buff[37] = er32(RDFPC);
|
|
|
|
|
|
|
|
pr_info("Register dump\n");
|
2012-02-10 08:06:36 +00:00
|
|
|
for (i = 0; i < NUM_REGS; i++)
|
|
|
|
pr_info("%-15s %08x\n", reg_name[i], regs_buff[i]);
|
2012-01-27 09:00:46 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* e1000_dump: Print registers, tx ring and rx ring
|
|
|
|
*/
|
|
|
|
static void e1000_dump(struct e1000_adapter *adapter)
|
|
|
|
{
|
|
|
|
/* this code doesn't handle multiple rings */
|
|
|
|
struct e1000_tx_ring *tx_ring = adapter->tx_ring;
|
|
|
|
struct e1000_rx_ring *rx_ring = adapter->rx_ring;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (!netif_msg_hw(adapter))
|
|
|
|
return;
|
|
|
|
|
|
|
|
/* Print Registers */
|
|
|
|
e1000_regdump(adapter);
|
|
|
|
|
2013-02-09 12:49:21 +00:00
|
|
|
/* transmit dump */
|
2012-01-27 09:00:46 +00:00
|
|
|
pr_info("TX Desc ring0 dump\n");
|
|
|
|
|
|
|
|
/* Transmit Descriptor Formats - DEXT[29] is 0 (Legacy) or 1 (Extended)
|
|
|
|
*
|
|
|
|
* Legacy Transmit Descriptor
|
|
|
|
* +--------------------------------------------------------------+
|
|
|
|
* 0 | Buffer Address [63:0] (Reserved on Write Back) |
|
|
|
|
* +--------------------------------------------------------------+
|
|
|
|
* 8 | Special | CSS | Status | CMD | CSO | Length |
|
|
|
|
* +--------------------------------------------------------------+
|
|
|
|
* 63 48 47 36 35 32 31 24 23 16 15 0
|
|
|
|
*
|
|
|
|
* Extended Context Descriptor (DTYP=0x0) for TSO or checksum offload
|
|
|
|
* 63 48 47 40 39 32 31 16 15 8 7 0
|
|
|
|
* +----------------------------------------------------------------+
|
|
|
|
* 0 | TUCSE | TUCS0 | TUCSS | IPCSE | IPCS0 | IPCSS |
|
|
|
|
* +----------------------------------------------------------------+
|
|
|
|
* 8 | MSS | HDRLEN | RSV | STA | TUCMD | DTYP | PAYLEN |
|
|
|
|
* +----------------------------------------------------------------+
|
|
|
|
* 63 48 47 40 39 36 35 32 31 24 23 20 19 0
|
|
|
|
*
|
|
|
|
* Extended Data Descriptor (DTYP=0x1)
|
|
|
|
* +----------------------------------------------------------------+
|
|
|
|
* 0 | Buffer Address [63:0] |
|
|
|
|
* +----------------------------------------------------------------+
|
|
|
|
* 8 | VLAN tag | POPTS | Rsvd | Status | Command | DTYP | DTALEN |
|
|
|
|
* +----------------------------------------------------------------+
|
|
|
|
* 63 48 47 40 39 36 35 32 31 24 23 20 19 0
|
|
|
|
*/
|
2012-02-10 08:06:36 +00:00
|
|
|
pr_info("Tc[desc] [Ce CoCsIpceCoS] [MssHlRSCm0Plen] [bi->dma ] leng ntw timestmp bi->skb\n");
|
|
|
|
pr_info("Td[desc] [address 63:0 ] [VlaPoRSCm1Dlen] [bi->dma ] leng ntw timestmp bi->skb\n");
|
2012-01-27 09:00:46 +00:00
|
|
|
|
|
|
|
if (!netif_msg_tx_done(adapter))
|
|
|
|
goto rx_ring_summary;
|
|
|
|
|
|
|
|
for (i = 0; tx_ring->desc && (i < tx_ring->count); i++) {
|
|
|
|
struct e1000_tx_desc *tx_desc = E1000_TX_DESC(*tx_ring, i);
|
|
|
|
struct e1000_buffer *buffer_info = &tx_ring->buffer_info[i];
|
2012-03-25 17:49:25 +00:00
|
|
|
struct my_u { __le64 a; __le64 b; };
|
2012-01-27 09:00:46 +00:00
|
|
|
struct my_u *u = (struct my_u *)tx_desc;
|
2012-02-10 08:06:36 +00:00
|
|
|
const char *type;
|
|
|
|
|
2012-01-27 09:00:46 +00:00
|
|
|
if (i == tx_ring->next_to_use && i == tx_ring->next_to_clean)
|
2012-02-10 08:06:36 +00:00
|
|
|
type = "NTC/U";
|
2012-01-27 09:00:46 +00:00
|
|
|
else if (i == tx_ring->next_to_use)
|
2012-02-10 08:06:36 +00:00
|
|
|
type = "NTU";
|
2012-01-27 09:00:46 +00:00
|
|
|
else if (i == tx_ring->next_to_clean)
|
2012-02-10 08:06:36 +00:00
|
|
|
type = "NTC";
|
2012-01-27 09:00:46 +00:00
|
|
|
else
|
2012-02-10 08:06:36 +00:00
|
|
|
type = "";
|
2012-01-27 09:00:46 +00:00
|
|
|
|
2012-02-10 08:06:36 +00:00
|
|
|
pr_info("T%c[0x%03X] %016llX %016llX %016llX %04X %3X %016llX %p %s\n",
|
|
|
|
((le64_to_cpu(u->b) & (1<<20)) ? 'd' : 'c'), i,
|
|
|
|
le64_to_cpu(u->a), le64_to_cpu(u->b),
|
|
|
|
(u64)buffer_info->dma, buffer_info->length,
|
|
|
|
buffer_info->next_to_watch,
|
|
|
|
(u64)buffer_info->time_stamp, buffer_info->skb, type);
|
2012-01-27 09:00:46 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
rx_ring_summary:
|
2013-02-09 12:49:21 +00:00
|
|
|
/* receive dump */
|
2012-01-27 09:00:46 +00:00
|
|
|
pr_info("\nRX Desc ring dump\n");
|
|
|
|
|
|
|
|
/* Legacy Receive Descriptor Format
|
|
|
|
*
|
|
|
|
* +-----------------------------------------------------+
|
|
|
|
* | Buffer Address [63:0] |
|
|
|
|
* +-----------------------------------------------------+
|
|
|
|
* | VLAN Tag | Errors | Status 0 | Packet csum | Length |
|
|
|
|
* +-----------------------------------------------------+
|
|
|
|
* 63 48 47 40 39 32 31 16 15 0
|
|
|
|
*/
|
2012-02-10 08:06:36 +00:00
|
|
|
pr_info("R[desc] [address 63:0 ] [vl er S cks ln] [bi->dma ] [bi->skb]\n");
|
2012-01-27 09:00:46 +00:00
|
|
|
|
|
|
|
if (!netif_msg_rx_status(adapter))
|
|
|
|
goto exit;
|
|
|
|
|
|
|
|
for (i = 0; rx_ring->desc && (i < rx_ring->count); i++) {
|
|
|
|
struct e1000_rx_desc *rx_desc = E1000_RX_DESC(*rx_ring, i);
|
|
|
|
struct e1000_buffer *buffer_info = &rx_ring->buffer_info[i];
|
2012-03-25 17:49:25 +00:00
|
|
|
struct my_u { __le64 a; __le64 b; };
|
2012-01-27 09:00:46 +00:00
|
|
|
struct my_u *u = (struct my_u *)rx_desc;
|
2012-02-10 08:06:36 +00:00
|
|
|
const char *type;
|
|
|
|
|
2012-01-27 09:00:46 +00:00
|
|
|
if (i == rx_ring->next_to_use)
|
2012-02-10 08:06:36 +00:00
|
|
|
type = "NTU";
|
2012-01-27 09:00:46 +00:00
|
|
|
else if (i == rx_ring->next_to_clean)
|
2012-02-10 08:06:36 +00:00
|
|
|
type = "NTC";
|
2012-01-27 09:00:46 +00:00
|
|
|
else
|
2012-02-10 08:06:36 +00:00
|
|
|
type = "";
|
2012-01-27 09:00:46 +00:00
|
|
|
|
2012-02-10 08:06:36 +00:00
|
|
|
pr_info("R[0x%03X] %016llX %016llX %016llX %p %s\n",
|
|
|
|
i, le64_to_cpu(u->a), le64_to_cpu(u->b),
|
|
|
|
(u64)buffer_info->dma, buffer_info->skb, type);
|
2012-01-27 09:00:46 +00:00
|
|
|
} /* for */
|
|
|
|
|
|
|
|
/* dump the descriptor caches */
|
|
|
|
/* rx */
|
2012-02-10 08:06:36 +00:00
|
|
|
pr_info("Rx descriptor cache in 64bit format\n");
|
2012-01-27 09:00:46 +00:00
|
|
|
for (i = 0x6000; i <= 0x63FF ; i += 0x10) {
|
2012-02-10 08:06:36 +00:00
|
|
|
pr_info("R%04X: %08X|%08X %08X|%08X\n",
|
|
|
|
i,
|
|
|
|
readl(adapter->hw.hw_addr + i+4),
|
|
|
|
readl(adapter->hw.hw_addr + i),
|
|
|
|
readl(adapter->hw.hw_addr + i+12),
|
|
|
|
readl(adapter->hw.hw_addr + i+8));
|
2012-01-27 09:00:46 +00:00
|
|
|
}
|
|
|
|
/* tx */
|
2012-02-10 08:06:36 +00:00
|
|
|
pr_info("Tx descriptor cache in 64bit format\n");
|
2012-01-27 09:00:46 +00:00
|
|
|
for (i = 0x7000; i <= 0x73FF ; i += 0x10) {
|
2012-02-10 08:06:36 +00:00
|
|
|
pr_info("T%04X: %08X|%08X %08X|%08X\n",
|
|
|
|
i,
|
|
|
|
readl(adapter->hw.hw_addr + i+4),
|
|
|
|
readl(adapter->hw.hw_addr + i),
|
|
|
|
readl(adapter->hw.hw_addr + i+12),
|
|
|
|
readl(adapter->hw.hw_addr + i+8));
|
2012-01-27 09:00:46 +00:00
|
|
|
}
|
|
|
|
exit:
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/**
|
|
|
|
* e1000_tx_timeout - Respond to a Tx Hang
|
|
|
|
* @netdev: network interface device structure
|
|
|
|
**/
|
2008-07-11 22:17:02 +00:00
|
|
|
static void e1000_tx_timeout(struct net_device *netdev)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2005-06-18 00:41:45 +00:00
|
|
|
struct e1000_adapter *adapter = netdev_priv(netdev);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* Do the reset outside of interrupt context */
|
2006-03-03 02:21:24 +00:00
|
|
|
adapter->tx_timeout_count++;
|
|
|
|
schedule_work(&adapter->reset_task);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2008-07-11 22:17:02 +00:00
|
|
|
static void e1000_reset_task(struct work_struct *work)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2006-11-22 14:55:48 +00:00
|
|
|
struct e1000_adapter *adapter =
|
|
|
|
container_of(work, struct e1000_adapter, reset_task);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2011-10-05 07:24:51 +00:00
|
|
|
if (test_bit(__E1000_DOWN, &adapter->flags))
|
|
|
|
return;
|
2012-01-27 09:00:46 +00:00
|
|
|
e_err(drv, "Reset adapter\n");
|
2010-09-22 18:22:42 +00:00
|
|
|
e1000_reinit_safe(adapter);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* e1000_get_stats - Get System Network Statistics
|
|
|
|
* @netdev: network interface device structure
|
|
|
|
*
|
|
|
|
* Returns the address of the device statistics structure.
|
2011-10-05 07:24:41 +00:00
|
|
|
* The statistics are actually updated from the watchdog.
|
2005-04-16 22:20:36 +00:00
|
|
|
**/
|
2008-07-11 22:17:02 +00:00
|
|
|
static struct net_device_stats *e1000_get_stats(struct net_device *netdev)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2006-01-13 00:50:35 +00:00
|
|
|
/* only return the current stats */
|
2009-10-07 02:42:23 +00:00
|
|
|
return &netdev->stats;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* e1000_change_mtu - Change the Maximum Transfer Unit
|
|
|
|
* @netdev: network interface device structure
|
|
|
|
* @new_mtu: new value for maximum frame size
|
|
|
|
*
|
|
|
|
* Returns 0 on success, negative on failure
|
|
|
|
**/
|
2008-07-11 22:17:02 +00:00
|
|
|
static int e1000_change_mtu(struct net_device *netdev, int new_mtu)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2005-06-18 00:41:45 +00:00
|
|
|
struct e1000_adapter *adapter = netdev_priv(netdev);
|
2008-07-11 22:17:08 +00:00
|
|
|
struct e1000_hw *hw = &adapter->hw;
|
2005-04-16 22:20:36 +00:00
|
|
|
int max_frame = new_mtu + ENET_HEADER_SIZE + ETHERNET_FCS_SIZE;
|
|
|
|
|
2006-01-18 21:01:39 +00:00
|
|
|
if ((max_frame < MINIMUM_ETHERNET_FRAME_SIZE) ||
|
|
|
|
(max_frame > MAX_JUMBO_FRAME_SIZE)) {
|
2010-07-27 06:37:21 +00:00
|
|
|
e_err(probe, "Invalid MTU setting\n");
|
2005-04-16 22:20:36 +00:00
|
|
|
return -EINVAL;
|
2005-04-29 02:43:52 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-01-13 00:50:55 +00:00
|
|
|
/* Adapter-specific max frame size limits. */
|
2008-07-11 22:17:08 +00:00
|
|
|
switch (hw->mac_type) {
|
2006-04-15 02:05:18 +00:00
|
|
|
case e1000_undefined ... e1000_82542_rev2_1:
|
2009-07-06 10:45:01 +00:00
|
|
|
if (max_frame > (ETH_FRAME_LEN + ETH_FCS_LEN)) {
|
2010-07-27 06:37:21 +00:00
|
|
|
e_err(probe, "Jumbo Frames not supported.\n");
|
2005-04-29 02:43:52 +00:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
2006-01-13 00:50:55 +00:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
/* Capable of supporting up to MAX_JUMBO_FRAME_SIZE limit. */
|
|
|
|
break;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2009-09-25 12:19:02 +00:00
|
|
|
while (test_and_set_bit(__E1000_RESETTING, &adapter->flags))
|
|
|
|
msleep(1);
|
|
|
|
/* e1000_down has a dependency on max_frame_size */
|
|
|
|
hw->max_frame_size = max_frame;
|
|
|
|
if (netif_running(netdev))
|
|
|
|
e1000_down(adapter);
|
|
|
|
|
2006-08-01 05:39:40 +00:00
|
|
|
/* NOTE: netdev_alloc_skb reserves 16 bytes, and typically NET_IP_ALIGN
|
2006-04-15 02:05:18 +00:00
|
|
|
* means we reserve 2 more, this pushes us to allocate from the next
|
2009-07-06 10:44:39 +00:00
|
|
|
* larger slab size.
|
|
|
|
* i.e. RXBUFFER_2048 --> size-4096 slab
|
2013-02-09 12:49:21 +00:00
|
|
|
* however with the new *_jumbo_rx* routines, jumbo receives will use
|
|
|
|
* fragmented skbs
|
|
|
|
*/
|
2006-04-15 02:05:18 +00:00
|
|
|
|
2010-01-22 22:56:16 +00:00
|
|
|
if (max_frame <= E1000_RXBUFFER_2048)
|
2006-04-15 02:05:18 +00:00
|
|
|
adapter->rx_buffer_len = E1000_RXBUFFER_2048;
|
2009-07-06 10:44:39 +00:00
|
|
|
else
|
|
|
|
#if (PAGE_SIZE >= E1000_RXBUFFER_16384)
|
2006-04-15 02:05:18 +00:00
|
|
|
adapter->rx_buffer_len = E1000_RXBUFFER_16384;
|
2009-07-06 10:44:39 +00:00
|
|
|
#elif (PAGE_SIZE >= E1000_RXBUFFER_4096)
|
|
|
|
adapter->rx_buffer_len = PAGE_SIZE;
|
|
|
|
#endif
|
2006-04-15 02:05:18 +00:00
|
|
|
|
|
|
|
/* adjust allocation if LPE protects us, and we aren't using SBP */
|
2008-07-11 22:17:08 +00:00
|
|
|
if (!hw->tbi_compatibility_on &&
|
2009-07-06 10:45:01 +00:00
|
|
|
((max_frame == (ETH_FRAME_LEN + ETH_FCS_LEN)) ||
|
2006-04-15 02:05:18 +00:00
|
|
|
(max_frame == MAXIMUM_ETHERNET_VLAN_SIZE)))
|
|
|
|
adapter->rx_buffer_len = MAXIMUM_ETHERNET_VLAN_SIZE;
|
2006-01-13 00:50:55 +00:00
|
|
|
|
2010-04-27 14:02:58 +00:00
|
|
|
pr_info("%s changing MTU from %d to %d\n",
|
|
|
|
netdev->name, netdev->mtu, new_mtu);
|
2005-04-29 02:43:52 +00:00
|
|
|
netdev->mtu = new_mtu;
|
|
|
|
|
2006-06-27 16:06:28 +00:00
|
|
|
if (netif_running(netdev))
|
2009-09-25 12:19:02 +00:00
|
|
|
e1000_up(adapter);
|
|
|
|
else
|
|
|
|
e1000_reset(adapter);
|
|
|
|
|
|
|
|
clear_bit(__E1000_RESETTING, &adapter->flags);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* e1000_update_stats - Update the board statistics counters
|
|
|
|
* @adapter: board private structure
|
|
|
|
**/
|
2008-07-11 22:17:02 +00:00
|
|
|
void e1000_update_stats(struct e1000_adapter *adapter)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2009-10-07 02:42:23 +00:00
|
|
|
struct net_device *netdev = adapter->netdev;
|
2005-04-16 22:20:36 +00:00
|
|
|
struct e1000_hw *hw = &adapter->hw;
|
2006-06-09 05:19:44 +00:00
|
|
|
struct pci_dev *pdev = adapter->pdev;
|
2005-04-16 22:20:36 +00:00
|
|
|
unsigned long flags;
|
2008-04-03 17:06:32 +00:00
|
|
|
u16 phy_tmp;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
#define PHY_IDLE_ERROR_COUNT_MASK 0x00FF
|
|
|
|
|
2013-02-09 12:49:21 +00:00
|
|
|
/* Prevent stats update while adapter is being reset, or if the pci
|
2006-06-09 05:19:44 +00:00
|
|
|
* connection is down.
|
|
|
|
*/
|
2006-06-08 16:30:24 +00:00
|
|
|
if (adapter->link_speed == 0)
|
2006-06-09 05:19:44 +00:00
|
|
|
return;
|
2006-12-13 00:29:15 +00:00
|
|
|
if (pci_channel_offline(pdev))
|
2006-06-08 16:30:24 +00:00
|
|
|
return;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
spin_lock_irqsave(&adapter->stats_lock, flags);
|
|
|
|
|
2007-10-20 01:06:37 +00:00
|
|
|
/* these counters are modified from e1000_tbi_adjust_stats,
|
2005-04-16 22:20:36 +00:00
|
|
|
* called from the interrupt context, so they must only
|
|
|
|
* be written while holding adapter->stats_lock
|
|
|
|
*/
|
|
|
|
|
2008-07-11 22:17:08 +00:00
|
|
|
adapter->stats.crcerrs += er32(CRCERRS);
|
|
|
|
adapter->stats.gprc += er32(GPRC);
|
|
|
|
adapter->stats.gorcl += er32(GORCL);
|
|
|
|
adapter->stats.gorch += er32(GORCH);
|
|
|
|
adapter->stats.bprc += er32(BPRC);
|
|
|
|
adapter->stats.mprc += er32(MPRC);
|
|
|
|
adapter->stats.roc += er32(ROC);
|
|
|
|
|
2009-09-25 12:16:14 +00:00
|
|
|
adapter->stats.prc64 += er32(PRC64);
|
|
|
|
adapter->stats.prc127 += er32(PRC127);
|
|
|
|
adapter->stats.prc255 += er32(PRC255);
|
|
|
|
adapter->stats.prc511 += er32(PRC511);
|
|
|
|
adapter->stats.prc1023 += er32(PRC1023);
|
|
|
|
adapter->stats.prc1522 += er32(PRC1522);
|
2008-07-11 22:17:08 +00:00
|
|
|
|
|
|
|
adapter->stats.symerrs += er32(SYMERRS);
|
|
|
|
adapter->stats.mpc += er32(MPC);
|
|
|
|
adapter->stats.scc += er32(SCC);
|
|
|
|
adapter->stats.ecol += er32(ECOL);
|
|
|
|
adapter->stats.mcc += er32(MCC);
|
|
|
|
adapter->stats.latecol += er32(LATECOL);
|
|
|
|
adapter->stats.dc += er32(DC);
|
|
|
|
adapter->stats.sec += er32(SEC);
|
|
|
|
adapter->stats.rlec += er32(RLEC);
|
|
|
|
adapter->stats.xonrxc += er32(XONRXC);
|
|
|
|
adapter->stats.xontxc += er32(XONTXC);
|
|
|
|
adapter->stats.xoffrxc += er32(XOFFRXC);
|
|
|
|
adapter->stats.xofftxc += er32(XOFFTXC);
|
|
|
|
adapter->stats.fcruc += er32(FCRUC);
|
|
|
|
adapter->stats.gptc += er32(GPTC);
|
|
|
|
adapter->stats.gotcl += er32(GOTCL);
|
|
|
|
adapter->stats.gotch += er32(GOTCH);
|
|
|
|
adapter->stats.rnbc += er32(RNBC);
|
|
|
|
adapter->stats.ruc += er32(RUC);
|
|
|
|
adapter->stats.rfc += er32(RFC);
|
|
|
|
adapter->stats.rjc += er32(RJC);
|
|
|
|
adapter->stats.torl += er32(TORL);
|
|
|
|
adapter->stats.torh += er32(TORH);
|
|
|
|
adapter->stats.totl += er32(TOTL);
|
|
|
|
adapter->stats.toth += er32(TOTH);
|
|
|
|
adapter->stats.tpr += er32(TPR);
|
|
|
|
|
2009-09-25 12:16:14 +00:00
|
|
|
adapter->stats.ptc64 += er32(PTC64);
|
|
|
|
adapter->stats.ptc127 += er32(PTC127);
|
|
|
|
adapter->stats.ptc255 += er32(PTC255);
|
|
|
|
adapter->stats.ptc511 += er32(PTC511);
|
|
|
|
adapter->stats.ptc1023 += er32(PTC1023);
|
|
|
|
adapter->stats.ptc1522 += er32(PTC1522);
|
2008-07-11 22:17:08 +00:00
|
|
|
|
|
|
|
adapter->stats.mptc += er32(MPTC);
|
|
|
|
adapter->stats.bptc += er32(BPTC);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* used for adaptive IFS */
|
|
|
|
|
2008-07-11 22:17:08 +00:00
|
|
|
hw->tx_packet_delta = er32(TPT);
|
2005-04-16 22:20:36 +00:00
|
|
|
adapter->stats.tpt += hw->tx_packet_delta;
|
2008-07-11 22:17:08 +00:00
|
|
|
hw->collision_delta = er32(COLC);
|
2005-04-16 22:20:36 +00:00
|
|
|
adapter->stats.colc += hw->collision_delta;
|
|
|
|
|
2006-01-18 21:01:39 +00:00
|
|
|
if (hw->mac_type >= e1000_82543) {
|
2008-07-11 22:17:08 +00:00
|
|
|
adapter->stats.algnerrc += er32(ALGNERRC);
|
|
|
|
adapter->stats.rxerrc += er32(RXERRC);
|
|
|
|
adapter->stats.tncrs += er32(TNCRS);
|
|
|
|
adapter->stats.cexterr += er32(CEXTERR);
|
|
|
|
adapter->stats.tsctc += er32(TSCTC);
|
|
|
|
adapter->stats.tsctfc += er32(TSCTFC);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Fill out the OS statistics structure */
|
2009-10-07 02:42:23 +00:00
|
|
|
netdev->stats.multicast = adapter->stats.mprc;
|
|
|
|
netdev->stats.collisions = adapter->stats.colc;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* Rx Errors */
|
|
|
|
|
2006-03-03 02:21:24 +00:00
|
|
|
/* RLEC on some newer hardware can be incorrect so build
|
2013-02-09 12:49:21 +00:00
|
|
|
* our own version based on RUC and ROC
|
|
|
|
*/
|
2009-10-07 02:42:23 +00:00
|
|
|
netdev->stats.rx_errors = adapter->stats.rxerrc +
|
2005-04-16 22:20:36 +00:00
|
|
|
adapter->stats.crcerrs + adapter->stats.algnerrc +
|
2006-03-03 02:21:24 +00:00
|
|
|
adapter->stats.ruc + adapter->stats.roc +
|
|
|
|
adapter->stats.cexterr;
|
2006-09-27 19:53:37 +00:00
|
|
|
adapter->stats.rlerrc = adapter->stats.ruc + adapter->stats.roc;
|
2009-10-07 02:42:23 +00:00
|
|
|
netdev->stats.rx_length_errors = adapter->stats.rlerrc;
|
|
|
|
netdev->stats.rx_crc_errors = adapter->stats.crcerrs;
|
|
|
|
netdev->stats.rx_frame_errors = adapter->stats.algnerrc;
|
|
|
|
netdev->stats.rx_missed_errors = adapter->stats.mpc;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* Tx Errors */
|
2006-09-27 19:53:37 +00:00
|
|
|
adapter->stats.txerrc = adapter->stats.ecol + adapter->stats.latecol;
|
2009-10-07 02:42:23 +00:00
|
|
|
netdev->stats.tx_errors = adapter->stats.txerrc;
|
|
|
|
netdev->stats.tx_aborted_errors = adapter->stats.ecol;
|
|
|
|
netdev->stats.tx_window_errors = adapter->stats.latecol;
|
|
|
|
netdev->stats.tx_carrier_errors = adapter->stats.tncrs;
|
2008-07-11 22:17:08 +00:00
|
|
|
if (hw->bad_tx_carr_stats_fd &&
|
2006-12-15 15:41:15 +00:00
|
|
|
adapter->link_duplex == FULL_DUPLEX) {
|
2009-10-07 02:42:23 +00:00
|
|
|
netdev->stats.tx_carrier_errors = 0;
|
2006-12-15 15:41:15 +00:00
|
|
|
adapter->stats.tncrs = 0;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* Tx Dropped needs to be maintained elsewhere */
|
|
|
|
|
|
|
|
/* Phy Stats */
|
2006-01-18 21:01:39 +00:00
|
|
|
if (hw->media_type == e1000_media_type_copper) {
|
|
|
|
if ((adapter->link_speed == SPEED_1000) &&
|
2005-04-16 22:20:36 +00:00
|
|
|
(!e1000_read_phy_reg(hw, PHY_1000T_STATUS, &phy_tmp))) {
|
|
|
|
phy_tmp &= PHY_IDLE_ERROR_COUNT_MASK;
|
|
|
|
adapter->phy_stats.idle_errors += phy_tmp;
|
|
|
|
}
|
|
|
|
|
2006-01-18 21:01:39 +00:00
|
|
|
if ((hw->mac_type <= e1000_82546) &&
|
2005-04-16 22:20:36 +00:00
|
|
|
(hw->phy_type == e1000_phy_m88) &&
|
|
|
|
!e1000_read_phy_reg(hw, M88E1000_RX_ERR_CNTR, &phy_tmp))
|
|
|
|
adapter->phy_stats.receive_errors += phy_tmp;
|
|
|
|
}
|
|
|
|
|
2006-12-15 16:16:33 +00:00
|
|
|
/* Management Stats */
|
2008-07-11 22:17:08 +00:00
|
|
|
if (hw->has_smbus) {
|
|
|
|
adapter->stats.mgptc += er32(MGTPTC);
|
|
|
|
adapter->stats.mgprc += er32(MGTPRC);
|
|
|
|
adapter->stats.mgpdc += er32(MGTPDC);
|
2006-12-15 16:16:33 +00:00
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
spin_unlock_irqrestore(&adapter->stats_lock, flags);
|
|
|
|
}
|
2006-11-01 16:48:10 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/**
|
|
|
|
* e1000_intr - Interrupt Handler
|
|
|
|
* @irq: interrupt number
|
|
|
|
* @data: pointer to a network interface device structure
|
|
|
|
**/
|
2008-07-11 22:17:02 +00:00
|
|
|
static irqreturn_t e1000_intr(int irq, void *data)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct net_device *netdev = data;
|
2005-06-18 00:41:45 +00:00
|
|
|
struct e1000_adapter *adapter = netdev_priv(netdev);
|
2005-04-16 22:20:36 +00:00
|
|
|
struct e1000_hw *hw = &adapter->hw;
|
2009-09-25 12:16:14 +00:00
|
|
|
u32 icr = er32(ICR);
|
2008-07-11 22:17:38 +00:00
|
|
|
|
2011-01-13 07:48:13 +00:00
|
|
|
if (unlikely((!icr)))
|
e1000: add dynamic itr modes
Add a new dynamic itr algorithm, with 2 modes, and make it the default
operation mode. This greatly reduces latency and increases small packet
performance, at the "cost" of some CPU utilization. Bulk traffic
throughput is unaffected.
The driver can limit the amount of interrupts per second that the
adapter will generate for incoming packets. It does this by writing a
value to the adapter that is based on the maximum amount of interrupts
that the adapter will generate per second.
Setting InterruptThrottleRate to a value greater or equal to 100 will
program the adapter to send out a maximum of that many interrupts per
second, even if more packets have come in. This reduces interrupt
load on the system and can lower CPU utilization under heavy load,
but will increase latency as packets are not processed as quickly.
The default behaviour of the driver previously assumed a static
InterruptThrottleRate value of 8000, providing a good fallback value
for all traffic types,but lacking in small packet performance and
latency. The hardware can handle many more small packets per second
however, and for this reason an adaptive interrupt moderation algorithm
was implemented.
Since 7.3.x, the driver has two adaptive modes (setting 1 or 3) in
which it dynamically adjusts the InterruptThrottleRate value based on
the traffic that it receives. After determining the type of incoming
traffic in the last timeframe, it will adjust the InterruptThrottleRate
to an appropriate value for that traffic.
The algorithm classifies the incoming traffic every interval into
classes. Once the class is determined, the InterruptThrottleRate
value is adjusted to suit that traffic type the best. There are
three classes defined: "Bulk traffic", for large amounts of packets
of normal size; "Low latency", for small amounts of traffic and/or
a significant percentage of small packets; and "Lowest latency",
for almost completely small packets or minimal traffic.
In dynamic conservative mode, the InterruptThrottleRate value is
set to 4000 for traffic that falls in class "Bulk traffic". If
traffic falls in the "Low latency" or "Lowest latency" class, the
InterruptThrottleRate is increased stepwise to 20000. This default
mode is suitable for most applications.
For situations where low latency is vital such as cluster or
grid computing, the algorithm can reduce latency even more when
InterruptThrottleRate is set to mode 1. In this mode, which operates
the same as mode 3, the InterruptThrottleRate will be increased
stepwise to 70000 for traffic in class "Lowest latency".
Setting InterruptThrottleRate to 0 turns off any interrupt moderation
and may improve small packet latency, but is generally not suitable
for bulk throughput traffic.
Signed-off-by: Jesse Brandeburg <jesse.brandeburg@intel.com>
Cc: Rick Jones <rick.jones2@hp.com>
Signed-off-by: Auke Kok <auke-jan.h.kok@intel.com>
2006-11-01 16:48:13 +00:00
|
|
|
return IRQ_NONE; /* Not our interrupt */
|
|
|
|
|
2013-02-09 12:49:21 +00:00
|
|
|
/* we might have caused the interrupt, but the above
|
2011-01-13 07:48:13 +00:00
|
|
|
* read cleared it, and just in case the driver is
|
|
|
|
* down there is nothing to do so return handled
|
|
|
|
*/
|
|
|
|
if (unlikely(test_bit(__E1000_DOWN, &adapter->flags)))
|
|
|
|
return IRQ_HANDLED;
|
|
|
|
|
2006-01-18 21:01:39 +00:00
|
|
|
if (unlikely(icr & (E1000_ICR_RXSEQ | E1000_ICR_LSC))) {
|
2005-04-16 22:20:36 +00:00
|
|
|
hw->get_link_status = 1;
|
2006-09-27 19:54:02 +00:00
|
|
|
/* guard against interrupt when we're going down */
|
|
|
|
if (!test_bit(__E1000_DOWN, &adapter->flags))
|
2011-10-05 07:24:41 +00:00
|
|
|
schedule_delayed_work(&adapter->watchdog_task, 1);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2009-09-25 12:16:14 +00:00
|
|
|
/* disable interrupts, without the synchronize_irq bit */
|
|
|
|
ew32(IMC, ~0);
|
|
|
|
E1000_WRITE_FLUSH();
|
|
|
|
|
2009-01-20 00:43:59 +00:00
|
|
|
if (likely(napi_schedule_prep(&adapter->napi))) {
|
e1000: add dynamic itr modes
Add a new dynamic itr algorithm, with 2 modes, and make it the default
operation mode. This greatly reduces latency and increases small packet
performance, at the "cost" of some CPU utilization. Bulk traffic
throughput is unaffected.
The driver can limit the amount of interrupts per second that the
adapter will generate for incoming packets. It does this by writing a
value to the adapter that is based on the maximum amount of interrupts
that the adapter will generate per second.
Setting InterruptThrottleRate to a value greater or equal to 100 will
program the adapter to send out a maximum of that many interrupts per
second, even if more packets have come in. This reduces interrupt
load on the system and can lower CPU utilization under heavy load,
but will increase latency as packets are not processed as quickly.
The default behaviour of the driver previously assumed a static
InterruptThrottleRate value of 8000, providing a good fallback value
for all traffic types,but lacking in small packet performance and
latency. The hardware can handle many more small packets per second
however, and for this reason an adaptive interrupt moderation algorithm
was implemented.
Since 7.3.x, the driver has two adaptive modes (setting 1 or 3) in
which it dynamically adjusts the InterruptThrottleRate value based on
the traffic that it receives. After determining the type of incoming
traffic in the last timeframe, it will adjust the InterruptThrottleRate
to an appropriate value for that traffic.
The algorithm classifies the incoming traffic every interval into
classes. Once the class is determined, the InterruptThrottleRate
value is adjusted to suit that traffic type the best. There are
three classes defined: "Bulk traffic", for large amounts of packets
of normal size; "Low latency", for small amounts of traffic and/or
a significant percentage of small packets; and "Lowest latency",
for almost completely small packets or minimal traffic.
In dynamic conservative mode, the InterruptThrottleRate value is
set to 4000 for traffic that falls in class "Bulk traffic". If
traffic falls in the "Low latency" or "Lowest latency" class, the
InterruptThrottleRate is increased stepwise to 20000. This default
mode is suitable for most applications.
For situations where low latency is vital such as cluster or
grid computing, the algorithm can reduce latency even more when
InterruptThrottleRate is set to mode 1. In this mode, which operates
the same as mode 3, the InterruptThrottleRate will be increased
stepwise to 70000 for traffic in class "Lowest latency".
Setting InterruptThrottleRate to 0 turns off any interrupt moderation
and may improve small packet latency, but is generally not suitable
for bulk throughput traffic.
Signed-off-by: Jesse Brandeburg <jesse.brandeburg@intel.com>
Cc: Rick Jones <rick.jones2@hp.com>
Signed-off-by: Auke Kok <auke-jan.h.kok@intel.com>
2006-11-01 16:48:13 +00:00
|
|
|
adapter->total_tx_bytes = 0;
|
|
|
|
adapter->total_tx_packets = 0;
|
|
|
|
adapter->total_rx_bytes = 0;
|
|
|
|
adapter->total_rx_packets = 0;
|
2009-01-20 00:43:59 +00:00
|
|
|
__napi_schedule(&adapter->napi);
|
2009-03-25 21:59:22 +00:00
|
|
|
} else {
|
2006-11-01 16:47:30 +00:00
|
|
|
/* this really should not happen! if it does it is basically a
|
2013-02-09 12:49:21 +00:00
|
|
|
* bug, but not a hard error, so enable ints and continue
|
|
|
|
*/
|
2009-03-25 21:59:22 +00:00
|
|
|
if (!test_bit(__E1000_DOWN, &adapter->flags))
|
|
|
|
e1000_irq_enable(adapter);
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
return IRQ_HANDLED;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* e1000_clean - NAPI Rx polling callback
|
|
|
|
* @adapter: board private structure
|
|
|
|
**/
|
2008-07-11 22:17:02 +00:00
|
|
|
static int e1000_clean(struct napi_struct *napi, int budget)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2013-02-09 12:49:21 +00:00
|
|
|
struct e1000_adapter *adapter = container_of(napi, struct e1000_adapter,
|
|
|
|
napi);
|
2009-09-25 12:19:23 +00:00
|
|
|
int tx_clean_complete = 0, work_done = 0;
|
2005-10-04 11:01:55 +00:00
|
|
|
|
2009-09-25 12:19:23 +00:00
|
|
|
tx_clean_complete = e1000_clean_tx_irq(adapter, &adapter->tx_ring[0]);
|
2005-10-04 11:01:55 +00:00
|
|
|
|
2009-09-25 12:19:23 +00:00
|
|
|
adapter->clean_rx(adapter, &adapter->rx_ring[0], &work_done, budget);
|
2005-10-04 11:01:55 +00:00
|
|
|
|
2009-09-25 12:19:23 +00:00
|
|
|
if (!tx_clean_complete)
|
2008-01-16 06:43:24 +00:00
|
|
|
work_done = budget;
|
|
|
|
|
2008-01-08 05:06:12 +00:00
|
|
|
/* If budget not fully consumed, exit the polling mode */
|
|
|
|
if (work_done < budget) {
|
e1000: add dynamic itr modes
Add a new dynamic itr algorithm, with 2 modes, and make it the default
operation mode. This greatly reduces latency and increases small packet
performance, at the "cost" of some CPU utilization. Bulk traffic
throughput is unaffected.
The driver can limit the amount of interrupts per second that the
adapter will generate for incoming packets. It does this by writing a
value to the adapter that is based on the maximum amount of interrupts
that the adapter will generate per second.
Setting InterruptThrottleRate to a value greater or equal to 100 will
program the adapter to send out a maximum of that many interrupts per
second, even if more packets have come in. This reduces interrupt
load on the system and can lower CPU utilization under heavy load,
but will increase latency as packets are not processed as quickly.
The default behaviour of the driver previously assumed a static
InterruptThrottleRate value of 8000, providing a good fallback value
for all traffic types,but lacking in small packet performance and
latency. The hardware can handle many more small packets per second
however, and for this reason an adaptive interrupt moderation algorithm
was implemented.
Since 7.3.x, the driver has two adaptive modes (setting 1 or 3) in
which it dynamically adjusts the InterruptThrottleRate value based on
the traffic that it receives. After determining the type of incoming
traffic in the last timeframe, it will adjust the InterruptThrottleRate
to an appropriate value for that traffic.
The algorithm classifies the incoming traffic every interval into
classes. Once the class is determined, the InterruptThrottleRate
value is adjusted to suit that traffic type the best. There are
three classes defined: "Bulk traffic", for large amounts of packets
of normal size; "Low latency", for small amounts of traffic and/or
a significant percentage of small packets; and "Lowest latency",
for almost completely small packets or minimal traffic.
In dynamic conservative mode, the InterruptThrottleRate value is
set to 4000 for traffic that falls in class "Bulk traffic". If
traffic falls in the "Low latency" or "Lowest latency" class, the
InterruptThrottleRate is increased stepwise to 20000. This default
mode is suitable for most applications.
For situations where low latency is vital such as cluster or
grid computing, the algorithm can reduce latency even more when
InterruptThrottleRate is set to mode 1. In this mode, which operates
the same as mode 3, the InterruptThrottleRate will be increased
stepwise to 70000 for traffic in class "Lowest latency".
Setting InterruptThrottleRate to 0 turns off any interrupt moderation
and may improve small packet latency, but is generally not suitable
for bulk throughput traffic.
Signed-off-by: Jesse Brandeburg <jesse.brandeburg@intel.com>
Cc: Rick Jones <rick.jones2@hp.com>
Signed-off-by: Auke Kok <auke-jan.h.kok@intel.com>
2006-11-01 16:48:13 +00:00
|
|
|
if (likely(adapter->itr_setting & 3))
|
|
|
|
e1000_set_itr(adapter);
|
2009-01-20 00:43:59 +00:00
|
|
|
napi_complete(napi);
|
2009-03-25 21:59:22 +00:00
|
|
|
if (!test_bit(__E1000_DOWN, &adapter->flags))
|
|
|
|
e1000_irq_enable(adapter);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
[NET]: Make NAPI polling independent of struct net_device objects.
Several devices have multiple independant RX queues per net
device, and some have a single interrupt doorbell for several
queues.
In either case, it's easier to support layouts like that if the
structure representing the poll is independant from the net
device itself.
The signature of the ->poll() call back goes from:
int foo_poll(struct net_device *dev, int *budget)
to
int foo_poll(struct napi_struct *napi, int budget)
The caller is returned the number of RX packets processed (or
the number of "NAPI credits" consumed if you want to get
abstract). The callee no longer messes around bumping
dev->quota, *budget, etc. because that is all handled in the
caller upon return.
The napi_struct is to be embedded in the device driver private data
structures.
Furthermore, it is the driver's responsibility to disable all NAPI
instances in it's ->stop() device close handler. Since the
napi_struct is privatized into the driver's private data structures,
only the driver knows how to get at all of the napi_struct instances
it may have per-device.
With lots of help and suggestions from Rusty Russell, Roland Dreier,
Michael Chan, Jeff Garzik, and Jamal Hadi Salim.
Bug fixes from Thomas Graf, Roland Dreier, Peter Zijlstra,
Joseph Fannin, Scott Wood, Hans J. Koch, and Michael Chan.
[ Ported to current tree and all drivers converted. Integrated
Stephen's follow-on kerneldoc additions, and restored poll_list
handling to the old style to fix mutual exclusion issues. -DaveM ]
Signed-off-by: Stephen Hemminger <shemminger@linux-foundation.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
2007-10-03 23:41:36 +00:00
|
|
|
return work_done;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* e1000_clean_tx_irq - Reclaim resources after transmit completes
|
|
|
|
* @adapter: board private structure
|
|
|
|
**/
|
2008-07-11 22:17:02 +00:00
|
|
|
static bool e1000_clean_tx_irq(struct e1000_adapter *adapter,
|
|
|
|
struct e1000_tx_ring *tx_ring)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2008-07-11 22:17:08 +00:00
|
|
|
struct e1000_hw *hw = &adapter->hw;
|
2005-04-16 22:20:36 +00:00
|
|
|
struct net_device *netdev = adapter->netdev;
|
|
|
|
struct e1000_tx_desc *tx_desc, *eop_desc;
|
|
|
|
struct e1000_buffer *buffer_info;
|
|
|
|
unsigned int i, eop;
|
2006-03-03 02:20:43 +00:00
|
|
|
unsigned int count = 0;
|
e1000: add dynamic itr modes
Add a new dynamic itr algorithm, with 2 modes, and make it the default
operation mode. This greatly reduces latency and increases small packet
performance, at the "cost" of some CPU utilization. Bulk traffic
throughput is unaffected.
The driver can limit the amount of interrupts per second that the
adapter will generate for incoming packets. It does this by writing a
value to the adapter that is based on the maximum amount of interrupts
that the adapter will generate per second.
Setting InterruptThrottleRate to a value greater or equal to 100 will
program the adapter to send out a maximum of that many interrupts per
second, even if more packets have come in. This reduces interrupt
load on the system and can lower CPU utilization under heavy load,
but will increase latency as packets are not processed as quickly.
The default behaviour of the driver previously assumed a static
InterruptThrottleRate value of 8000, providing a good fallback value
for all traffic types,but lacking in small packet performance and
latency. The hardware can handle many more small packets per second
however, and for this reason an adaptive interrupt moderation algorithm
was implemented.
Since 7.3.x, the driver has two adaptive modes (setting 1 or 3) in
which it dynamically adjusts the InterruptThrottleRate value based on
the traffic that it receives. After determining the type of incoming
traffic in the last timeframe, it will adjust the InterruptThrottleRate
to an appropriate value for that traffic.
The algorithm classifies the incoming traffic every interval into
classes. Once the class is determined, the InterruptThrottleRate
value is adjusted to suit that traffic type the best. There are
three classes defined: "Bulk traffic", for large amounts of packets
of normal size; "Low latency", for small amounts of traffic and/or
a significant percentage of small packets; and "Lowest latency",
for almost completely small packets or minimal traffic.
In dynamic conservative mode, the InterruptThrottleRate value is
set to 4000 for traffic that falls in class "Bulk traffic". If
traffic falls in the "Low latency" or "Lowest latency" class, the
InterruptThrottleRate is increased stepwise to 20000. This default
mode is suitable for most applications.
For situations where low latency is vital such as cluster or
grid computing, the algorithm can reduce latency even more when
InterruptThrottleRate is set to mode 1. In this mode, which operates
the same as mode 3, the InterruptThrottleRate will be increased
stepwise to 70000 for traffic in class "Lowest latency".
Setting InterruptThrottleRate to 0 turns off any interrupt moderation
and may improve small packet latency, but is generally not suitable
for bulk throughput traffic.
Signed-off-by: Jesse Brandeburg <jesse.brandeburg@intel.com>
Cc: Rick Jones <rick.jones2@hp.com>
Signed-off-by: Auke Kok <auke-jan.h.kok@intel.com>
2006-11-01 16:48:13 +00:00
|
|
|
unsigned int total_tx_bytes=0, total_tx_packets=0;
|
2012-08-24 08:04:58 +00:00
|
|
|
unsigned int bytes_compl = 0, pkts_compl = 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
i = tx_ring->next_to_clean;
|
|
|
|
eop = tx_ring->buffer_info[i].next_to_watch;
|
|
|
|
eop_desc = E1000_TX_DESC(*tx_ring, eop);
|
|
|
|
|
2009-03-25 21:59:04 +00:00
|
|
|
while ((eop_desc->upper.data & cpu_to_le32(E1000_TXD_STAT_DD)) &&
|
|
|
|
(count < tx_ring->count)) {
|
2009-04-16 16:59:47 +00:00
|
|
|
bool cleaned = false;
|
2010-08-08 16:02:31 +00:00
|
|
|
rmb(); /* read buffer_info after eop_desc */
|
2009-04-16 16:59:47 +00:00
|
|
|
for ( ; !cleaned; count++) {
|
2005-04-16 22:20:36 +00:00
|
|
|
tx_desc = E1000_TX_DESC(*tx_ring, i);
|
|
|
|
buffer_info = &tx_ring->buffer_info[i];
|
|
|
|
cleaned = (i == eop);
|
|
|
|
|
e1000: add dynamic itr modes
Add a new dynamic itr algorithm, with 2 modes, and make it the default
operation mode. This greatly reduces latency and increases small packet
performance, at the "cost" of some CPU utilization. Bulk traffic
throughput is unaffected.
The driver can limit the amount of interrupts per second that the
adapter will generate for incoming packets. It does this by writing a
value to the adapter that is based on the maximum amount of interrupts
that the adapter will generate per second.
Setting InterruptThrottleRate to a value greater or equal to 100 will
program the adapter to send out a maximum of that many interrupts per
second, even if more packets have come in. This reduces interrupt
load on the system and can lower CPU utilization under heavy load,
but will increase latency as packets are not processed as quickly.
The default behaviour of the driver previously assumed a static
InterruptThrottleRate value of 8000, providing a good fallback value
for all traffic types,but lacking in small packet performance and
latency. The hardware can handle many more small packets per second
however, and for this reason an adaptive interrupt moderation algorithm
was implemented.
Since 7.3.x, the driver has two adaptive modes (setting 1 or 3) in
which it dynamically adjusts the InterruptThrottleRate value based on
the traffic that it receives. After determining the type of incoming
traffic in the last timeframe, it will adjust the InterruptThrottleRate
to an appropriate value for that traffic.
The algorithm classifies the incoming traffic every interval into
classes. Once the class is determined, the InterruptThrottleRate
value is adjusted to suit that traffic type the best. There are
three classes defined: "Bulk traffic", for large amounts of packets
of normal size; "Low latency", for small amounts of traffic and/or
a significant percentage of small packets; and "Lowest latency",
for almost completely small packets or minimal traffic.
In dynamic conservative mode, the InterruptThrottleRate value is
set to 4000 for traffic that falls in class "Bulk traffic". If
traffic falls in the "Low latency" or "Lowest latency" class, the
InterruptThrottleRate is increased stepwise to 20000. This default
mode is suitable for most applications.
For situations where low latency is vital such as cluster or
grid computing, the algorithm can reduce latency even more when
InterruptThrottleRate is set to mode 1. In this mode, which operates
the same as mode 3, the InterruptThrottleRate will be increased
stepwise to 70000 for traffic in class "Lowest latency".
Setting InterruptThrottleRate to 0 turns off any interrupt moderation
and may improve small packet latency, but is generally not suitable
for bulk throughput traffic.
Signed-off-by: Jesse Brandeburg <jesse.brandeburg@intel.com>
Cc: Rick Jones <rick.jones2@hp.com>
Signed-off-by: Auke Kok <auke-jan.h.kok@intel.com>
2006-11-01 16:48:13 +00:00
|
|
|
if (cleaned) {
|
2011-08-25 14:39:24 +00:00
|
|
|
total_tx_packets += buffer_info->segs;
|
|
|
|
total_tx_bytes += buffer_info->bytecount;
|
2012-08-24 08:04:58 +00:00
|
|
|
if (buffer_info->skb) {
|
|
|
|
bytes_compl += buffer_info->skb->len;
|
|
|
|
pkts_compl++;
|
|
|
|
}
|
|
|
|
|
e1000: add dynamic itr modes
Add a new dynamic itr algorithm, with 2 modes, and make it the default
operation mode. This greatly reduces latency and increases small packet
performance, at the "cost" of some CPU utilization. Bulk traffic
throughput is unaffected.
The driver can limit the amount of interrupts per second that the
adapter will generate for incoming packets. It does this by writing a
value to the adapter that is based on the maximum amount of interrupts
that the adapter will generate per second.
Setting InterruptThrottleRate to a value greater or equal to 100 will
program the adapter to send out a maximum of that many interrupts per
second, even if more packets have come in. This reduces interrupt
load on the system and can lower CPU utilization under heavy load,
but will increase latency as packets are not processed as quickly.
The default behaviour of the driver previously assumed a static
InterruptThrottleRate value of 8000, providing a good fallback value
for all traffic types,but lacking in small packet performance and
latency. The hardware can handle many more small packets per second
however, and for this reason an adaptive interrupt moderation algorithm
was implemented.
Since 7.3.x, the driver has two adaptive modes (setting 1 or 3) in
which it dynamically adjusts the InterruptThrottleRate value based on
the traffic that it receives. After determining the type of incoming
traffic in the last timeframe, it will adjust the InterruptThrottleRate
to an appropriate value for that traffic.
The algorithm classifies the incoming traffic every interval into
classes. Once the class is determined, the InterruptThrottleRate
value is adjusted to suit that traffic type the best. There are
three classes defined: "Bulk traffic", for large amounts of packets
of normal size; "Low latency", for small amounts of traffic and/or
a significant percentage of small packets; and "Lowest latency",
for almost completely small packets or minimal traffic.
In dynamic conservative mode, the InterruptThrottleRate value is
set to 4000 for traffic that falls in class "Bulk traffic". If
traffic falls in the "Low latency" or "Lowest latency" class, the
InterruptThrottleRate is increased stepwise to 20000. This default
mode is suitable for most applications.
For situations where low latency is vital such as cluster or
grid computing, the algorithm can reduce latency even more when
InterruptThrottleRate is set to mode 1. In this mode, which operates
the same as mode 3, the InterruptThrottleRate will be increased
stepwise to 70000 for traffic in class "Lowest latency".
Setting InterruptThrottleRate to 0 turns off any interrupt moderation
and may improve small packet latency, but is generally not suitable
for bulk throughput traffic.
Signed-off-by: Jesse Brandeburg <jesse.brandeburg@intel.com>
Cc: Rick Jones <rick.jones2@hp.com>
Signed-off-by: Auke Kok <auke-jan.h.kok@intel.com>
2006-11-01 16:48:13 +00:00
|
|
|
}
|
2005-12-13 05:06:22 +00:00
|
|
|
e1000_unmap_and_free_tx_resource(adapter, buffer_info);
|
2006-11-01 16:47:53 +00:00
|
|
|
tx_desc->upper.data = 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-01-18 21:01:39 +00:00
|
|
|
if (unlikely(++i == tx_ring->count)) i = 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2005-10-04 11:01:55 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
eop = tx_ring->buffer_info[i].next_to_watch;
|
|
|
|
eop_desc = E1000_TX_DESC(*tx_ring, eop);
|
|
|
|
}
|
|
|
|
|
|
|
|
tx_ring->next_to_clean = i;
|
|
|
|
|
2012-08-24 08:04:58 +00:00
|
|
|
netdev_completed_queue(netdev, pkts_compl, bytes_compl);
|
|
|
|
|
2006-04-15 02:05:25 +00:00
|
|
|
#define TX_WAKE_THRESHOLD 32
|
2009-04-16 16:59:47 +00:00
|
|
|
if (unlikely(count && netif_carrier_ok(netdev) &&
|
2006-09-27 19:53:48 +00:00
|
|
|
E1000_DESC_UNUSED(tx_ring) >= TX_WAKE_THRESHOLD)) {
|
|
|
|
/* Make sure that anybody stopping the queue after this
|
|
|
|
* sees the new next_to_clean.
|
|
|
|
*/
|
|
|
|
smp_mb();
|
2009-09-25 12:18:07 +00:00
|
|
|
|
|
|
|
if (netif_queue_stopped(netdev) &&
|
|
|
|
!(test_bit(__E1000_DOWN, &adapter->flags))) {
|
2006-04-15 02:05:25 +00:00
|
|
|
netif_wake_queue(netdev);
|
2006-11-01 16:47:59 +00:00
|
|
|
++adapter->restart_queue;
|
|
|
|
}
|
2006-04-15 02:05:25 +00:00
|
|
|
}
|
2005-04-29 02:44:46 +00:00
|
|
|
|
2005-10-04 11:01:55 +00:00
|
|
|
if (adapter->detect_tx_hung) {
|
2005-04-29 02:44:46 +00:00
|
|
|
/* Detect a transmit hang in hardware, this serializes the
|
2013-02-09 12:49:21 +00:00
|
|
|
* check with the clearing of time_stamp and movement of i
|
|
|
|
*/
|
2008-03-21 18:06:25 +00:00
|
|
|
adapter->detect_tx_hung = false;
|
2009-09-25 12:18:07 +00:00
|
|
|
if (tx_ring->buffer_info[eop].time_stamp &&
|
|
|
|
time_after(jiffies, tx_ring->buffer_info[eop].time_stamp +
|
2013-02-09 12:49:21 +00:00
|
|
|
(adapter->tx_timeout_factor * HZ)) &&
|
2009-12-03 07:58:21 +00:00
|
|
|
!(er32(STATUS) & E1000_STATUS_TXOFF)) {
|
2005-04-29 02:40:40 +00:00
|
|
|
|
|
|
|
/* detected Tx unit hang */
|
2010-07-27 06:37:21 +00:00
|
|
|
e_err(drv, "Detected Tx Unit Hang\n"
|
2010-04-27 14:02:58 +00:00
|
|
|
" Tx Queue <%lu>\n"
|
|
|
|
" TDH <%x>\n"
|
|
|
|
" TDT <%x>\n"
|
|
|
|
" next_to_use <%x>\n"
|
|
|
|
" next_to_clean <%x>\n"
|
|
|
|
"buffer_info[next_to_clean]\n"
|
|
|
|
" time_stamp <%lx>\n"
|
|
|
|
" next_to_watch <%x>\n"
|
|
|
|
" jiffies <%lx>\n"
|
|
|
|
" next_to_watch.status <%x>\n",
|
2013-10-22 18:32:56 +00:00
|
|
|
(unsigned long)(tx_ring - adapter->tx_ring),
|
2008-07-11 22:17:08 +00:00
|
|
|
readl(hw->hw_addr + tx_ring->tdh),
|
|
|
|
readl(hw->hw_addr + tx_ring->tdt),
|
2005-04-29 02:40:40 +00:00
|
|
|
tx_ring->next_to_use,
|
2006-01-13 00:50:57 +00:00
|
|
|
tx_ring->next_to_clean,
|
2009-09-25 12:18:07 +00:00
|
|
|
tx_ring->buffer_info[eop].time_stamp,
|
2005-04-29 02:40:40 +00:00
|
|
|
eop,
|
|
|
|
jiffies,
|
|
|
|
eop_desc->upper.fields.status);
|
2012-01-27 09:00:46 +00:00
|
|
|
e1000_dump(adapter);
|
2005-04-16 22:20:36 +00:00
|
|
|
netif_stop_queue(netdev);
|
2005-04-29 02:40:40 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
e1000: add dynamic itr modes
Add a new dynamic itr algorithm, with 2 modes, and make it the default
operation mode. This greatly reduces latency and increases small packet
performance, at the "cost" of some CPU utilization. Bulk traffic
throughput is unaffected.
The driver can limit the amount of interrupts per second that the
adapter will generate for incoming packets. It does this by writing a
value to the adapter that is based on the maximum amount of interrupts
that the adapter will generate per second.
Setting InterruptThrottleRate to a value greater or equal to 100 will
program the adapter to send out a maximum of that many interrupts per
second, even if more packets have come in. This reduces interrupt
load on the system and can lower CPU utilization under heavy load,
but will increase latency as packets are not processed as quickly.
The default behaviour of the driver previously assumed a static
InterruptThrottleRate value of 8000, providing a good fallback value
for all traffic types,but lacking in small packet performance and
latency. The hardware can handle many more small packets per second
however, and for this reason an adaptive interrupt moderation algorithm
was implemented.
Since 7.3.x, the driver has two adaptive modes (setting 1 or 3) in
which it dynamically adjusts the InterruptThrottleRate value based on
the traffic that it receives. After determining the type of incoming
traffic in the last timeframe, it will adjust the InterruptThrottleRate
to an appropriate value for that traffic.
The algorithm classifies the incoming traffic every interval into
classes. Once the class is determined, the InterruptThrottleRate
value is adjusted to suit that traffic type the best. There are
three classes defined: "Bulk traffic", for large amounts of packets
of normal size; "Low latency", for small amounts of traffic and/or
a significant percentage of small packets; and "Lowest latency",
for almost completely small packets or minimal traffic.
In dynamic conservative mode, the InterruptThrottleRate value is
set to 4000 for traffic that falls in class "Bulk traffic". If
traffic falls in the "Low latency" or "Lowest latency" class, the
InterruptThrottleRate is increased stepwise to 20000. This default
mode is suitable for most applications.
For situations where low latency is vital such as cluster or
grid computing, the algorithm can reduce latency even more when
InterruptThrottleRate is set to mode 1. In this mode, which operates
the same as mode 3, the InterruptThrottleRate will be increased
stepwise to 70000 for traffic in class "Lowest latency".
Setting InterruptThrottleRate to 0 turns off any interrupt moderation
and may improve small packet latency, but is generally not suitable
for bulk throughput traffic.
Signed-off-by: Jesse Brandeburg <jesse.brandeburg@intel.com>
Cc: Rick Jones <rick.jones2@hp.com>
Signed-off-by: Auke Kok <auke-jan.h.kok@intel.com>
2006-11-01 16:48:13 +00:00
|
|
|
adapter->total_tx_bytes += total_tx_bytes;
|
|
|
|
adapter->total_tx_packets += total_tx_packets;
|
2009-10-07 02:42:23 +00:00
|
|
|
netdev->stats.tx_bytes += total_tx_bytes;
|
|
|
|
netdev->stats.tx_packets += total_tx_packets;
|
2010-09-23 05:40:09 +00:00
|
|
|
return count < tx_ring->count;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* e1000_rx_checksum - Receive Checksum Offload for 82543
|
2005-04-29 02:43:52 +00:00
|
|
|
* @adapter: board private structure
|
|
|
|
* @status_err: receive descriptor status and error fields
|
|
|
|
* @csum: receive descriptor csum field
|
|
|
|
* @sk_buff: socket buffer with received data
|
2005-04-16 22:20:36 +00:00
|
|
|
**/
|
2008-07-11 22:17:02 +00:00
|
|
|
static void e1000_rx_checksum(struct e1000_adapter *adapter, u32 status_err,
|
|
|
|
u32 csum, struct sk_buff *skb)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2008-07-11 22:17:08 +00:00
|
|
|
struct e1000_hw *hw = &adapter->hw;
|
2008-04-03 17:06:32 +00:00
|
|
|
u16 status = (u16)status_err;
|
|
|
|
u8 errors = (u8)(status_err >> 24);
|
2010-09-02 20:07:41 +00:00
|
|
|
|
|
|
|
skb_checksum_none_assert(skb);
|
2005-04-29 02:43:52 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* 82543 or newer only */
|
2008-07-11 22:17:08 +00:00
|
|
|
if (unlikely(hw->mac_type < e1000_82543)) return;
|
2005-04-16 22:20:36 +00:00
|
|
|
/* Ignore Checksum bit is set */
|
2006-01-18 21:01:39 +00:00
|
|
|
if (unlikely(status & E1000_RXD_STAT_IXSM)) return;
|
2005-04-29 02:43:52 +00:00
|
|
|
/* TCP/UDP checksum error bit is set */
|
2006-01-18 21:01:39 +00:00
|
|
|
if (unlikely(errors & E1000_RXD_ERR_TCPE)) {
|
2005-04-16 22:20:36 +00:00
|
|
|
/* let the stack verify checksum errors */
|
|
|
|
adapter->hw_csum_err++;
|
2005-04-29 02:43:52 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
/* TCP/UDP Checksum has not been calculated */
|
2009-09-25 12:16:14 +00:00
|
|
|
if (!(status & E1000_RXD_STAT_TCPCS))
|
|
|
|
return;
|
|
|
|
|
2005-04-29 02:43:52 +00:00
|
|
|
/* It must be a TCP or UDP packet with a valid checksum */
|
|
|
|
if (likely(status & E1000_RXD_STAT_TCPCS)) {
|
2005-04-16 22:20:36 +00:00
|
|
|
/* TCP checksum is good */
|
|
|
|
skb->ip_summed = CHECKSUM_UNNECESSARY;
|
|
|
|
}
|
2005-04-29 02:43:52 +00:00
|
|
|
adapter->hw_csum_good++;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2009-07-06 10:44:39 +00:00
|
|
|
/**
|
|
|
|
* e1000_consume_page - helper function
|
|
|
|
**/
|
|
|
|
static void e1000_consume_page(struct e1000_buffer *bi, struct sk_buff *skb,
|
2013-02-09 12:49:21 +00:00
|
|
|
u16 length)
|
2009-07-06 10:44:39 +00:00
|
|
|
{
|
|
|
|
bi->page = NULL;
|
|
|
|
skb->len += length;
|
|
|
|
skb->data_len += length;
|
2011-10-13 07:53:42 +00:00
|
|
|
skb->truesize += PAGE_SIZE;
|
2009-07-06 10:44:39 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* e1000_receive_skb - helper function to handle rx indications
|
|
|
|
* @adapter: board private structure
|
|
|
|
* @status: descriptor status field as written by hardware
|
|
|
|
* @vlan: descriptor vlan field as written by hardware (no le/be conversion)
|
|
|
|
* @skb: pointer to sk_buff to be indicated to stack
|
|
|
|
*/
|
|
|
|
static void e1000_receive_skb(struct e1000_adapter *adapter, u8 status,
|
|
|
|
__le16 vlan, struct sk_buff *skb)
|
|
|
|
{
|
2010-09-22 18:23:05 +00:00
|
|
|
skb->protocol = eth_type_trans(skb, adapter->netdev);
|
|
|
|
|
2011-07-21 03:26:31 +00:00
|
|
|
if (status & E1000_RXD_STAT_VP) {
|
|
|
|
u16 vid = le16_to_cpu(vlan) & E1000_RXD_SPC_VLAN_MASK;
|
|
|
|
|
2013-04-19 02:04:30 +00:00
|
|
|
__vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), vid);
|
2011-07-21 03:26:31 +00:00
|
|
|
}
|
|
|
|
napi_gro_receive(&adapter->napi, skb);
|
2009-07-06 10:44:39 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* e1000_clean_jumbo_rx_irq - Send received data up the network stack; legacy
|
|
|
|
* @adapter: board private structure
|
|
|
|
* @rx_ring: ring to clean
|
|
|
|
* @work_done: amount of napi work completed this call
|
|
|
|
* @work_to_do: max amount of work allowed for this call to do
|
|
|
|
*
|
|
|
|
* the return value indicates whether actual cleaning was done, there
|
|
|
|
* is no guarantee that everything was cleaned
|
|
|
|
*/
|
|
|
|
static bool e1000_clean_jumbo_rx_irq(struct e1000_adapter *adapter,
|
|
|
|
struct e1000_rx_ring *rx_ring,
|
|
|
|
int *work_done, int work_to_do)
|
|
|
|
{
|
|
|
|
struct e1000_hw *hw = &adapter->hw;
|
|
|
|
struct net_device *netdev = adapter->netdev;
|
|
|
|
struct pci_dev *pdev = adapter->pdev;
|
|
|
|
struct e1000_rx_desc *rx_desc, *next_rxd;
|
|
|
|
struct e1000_buffer *buffer_info, *next_buffer;
|
|
|
|
unsigned long irq_flags;
|
|
|
|
u32 length;
|
|
|
|
unsigned int i;
|
|
|
|
int cleaned_count = 0;
|
|
|
|
bool cleaned = false;
|
|
|
|
unsigned int total_rx_bytes=0, total_rx_packets=0;
|
|
|
|
|
|
|
|
i = rx_ring->next_to_clean;
|
|
|
|
rx_desc = E1000_RX_DESC(*rx_ring, i);
|
|
|
|
buffer_info = &rx_ring->buffer_info[i];
|
|
|
|
|
|
|
|
while (rx_desc->status & E1000_RXD_STAT_DD) {
|
|
|
|
struct sk_buff *skb;
|
|
|
|
u8 status;
|
|
|
|
|
|
|
|
if (*work_done >= work_to_do)
|
|
|
|
break;
|
|
|
|
(*work_done)++;
|
2010-08-08 16:02:31 +00:00
|
|
|
rmb(); /* read descriptor and rx_buffer_info after status DD */
|
2009-07-06 10:44:39 +00:00
|
|
|
|
|
|
|
status = rx_desc->status;
|
|
|
|
skb = buffer_info->skb;
|
|
|
|
buffer_info->skb = NULL;
|
|
|
|
|
|
|
|
if (++i == rx_ring->count) i = 0;
|
|
|
|
next_rxd = E1000_RX_DESC(*rx_ring, i);
|
|
|
|
prefetch(next_rxd);
|
|
|
|
|
|
|
|
next_buffer = &rx_ring->buffer_info[i];
|
|
|
|
|
|
|
|
cleaned = true;
|
|
|
|
cleaned_count++;
|
2010-04-27 13:08:45 +00:00
|
|
|
dma_unmap_page(&pdev->dev, buffer_info->dma,
|
|
|
|
buffer_info->length, DMA_FROM_DEVICE);
|
2009-07-06 10:44:39 +00:00
|
|
|
buffer_info->dma = 0;
|
|
|
|
|
|
|
|
length = le16_to_cpu(rx_desc->length);
|
|
|
|
|
|
|
|
/* errors is only valid for DD + EOP descriptors */
|
|
|
|
if (unlikely((status & E1000_RXD_STAT_EOP) &&
|
|
|
|
(rx_desc->errors & E1000_RXD_ERR_FRAME_ERR_MASK))) {
|
2012-05-11 16:30:46 +00:00
|
|
|
u8 *mapped;
|
|
|
|
u8 last_byte;
|
|
|
|
|
|
|
|
mapped = page_address(buffer_info->page);
|
|
|
|
last_byte = *(mapped + length - 1);
|
2009-07-06 10:44:39 +00:00
|
|
|
if (TBI_ACCEPT(hw, status, rx_desc->errors, length,
|
|
|
|
last_byte)) {
|
|
|
|
spin_lock_irqsave(&adapter->stats_lock,
|
2013-02-09 12:49:21 +00:00
|
|
|
irq_flags);
|
2009-07-06 10:44:39 +00:00
|
|
|
e1000_tbi_adjust_stats(hw, &adapter->stats,
|
2012-05-15 09:18:55 +00:00
|
|
|
length, mapped);
|
2009-07-06 10:44:39 +00:00
|
|
|
spin_unlock_irqrestore(&adapter->stats_lock,
|
2013-02-09 12:49:21 +00:00
|
|
|
irq_flags);
|
2009-07-06 10:44:39 +00:00
|
|
|
length--;
|
|
|
|
} else {
|
2012-04-04 06:01:29 +00:00
|
|
|
if (netdev->features & NETIF_F_RXALL)
|
|
|
|
goto process_skb;
|
2009-07-06 10:44:39 +00:00
|
|
|
/* recycle both page and skb */
|
|
|
|
buffer_info->skb = skb;
|
|
|
|
/* an error means any chain goes out the window
|
2013-02-09 12:49:21 +00:00
|
|
|
* too
|
|
|
|
*/
|
2009-07-06 10:44:39 +00:00
|
|
|
if (rx_ring->rx_skb_top)
|
|
|
|
dev_kfree_skb(rx_ring->rx_skb_top);
|
|
|
|
rx_ring->rx_skb_top = NULL;
|
|
|
|
goto next_desc;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#define rxtop rx_ring->rx_skb_top
|
2012-04-04 06:01:29 +00:00
|
|
|
process_skb:
|
2009-07-06 10:44:39 +00:00
|
|
|
if (!(status & E1000_RXD_STAT_EOP)) {
|
|
|
|
/* this descriptor is only the beginning (or middle) */
|
|
|
|
if (!rxtop) {
|
|
|
|
/* this is the beginning of a chain */
|
|
|
|
rxtop = skb;
|
|
|
|
skb_fill_page_desc(rxtop, 0, buffer_info->page,
|
2013-02-09 12:49:21 +00:00
|
|
|
0, length);
|
2009-07-06 10:44:39 +00:00
|
|
|
} else {
|
|
|
|
/* this is the middle of a chain */
|
|
|
|
skb_fill_page_desc(rxtop,
|
|
|
|
skb_shinfo(rxtop)->nr_frags,
|
|
|
|
buffer_info->page, 0, length);
|
|
|
|
/* re-use the skb, only consumed the page */
|
|
|
|
buffer_info->skb = skb;
|
|
|
|
}
|
|
|
|
e1000_consume_page(buffer_info, rxtop, length);
|
|
|
|
goto next_desc;
|
|
|
|
} else {
|
|
|
|
if (rxtop) {
|
|
|
|
/* end of the chain */
|
|
|
|
skb_fill_page_desc(rxtop,
|
|
|
|
skb_shinfo(rxtop)->nr_frags,
|
|
|
|
buffer_info->page, 0, length);
|
|
|
|
/* re-use the current skb, we only consumed the
|
2013-02-09 12:49:21 +00:00
|
|
|
* page
|
|
|
|
*/
|
2009-07-06 10:44:39 +00:00
|
|
|
buffer_info->skb = skb;
|
|
|
|
skb = rxtop;
|
|
|
|
rxtop = NULL;
|
|
|
|
e1000_consume_page(buffer_info, skb, length);
|
|
|
|
} else {
|
|
|
|
/* no chain, got EOP, this buf is the packet
|
2013-02-09 12:49:21 +00:00
|
|
|
* copybreak to save the put_page/alloc_page
|
|
|
|
*/
|
2009-07-06 10:44:39 +00:00
|
|
|
if (length <= copybreak &&
|
|
|
|
skb_tailroom(skb) >= length) {
|
|
|
|
u8 *vaddr;
|
2011-11-25 15:14:23 +00:00
|
|
|
vaddr = kmap_atomic(buffer_info->page);
|
2013-02-09 12:49:21 +00:00
|
|
|
memcpy(skb_tail_pointer(skb), vaddr,
|
|
|
|
length);
|
2011-11-25 15:14:23 +00:00
|
|
|
kunmap_atomic(vaddr);
|
2009-07-06 10:44:39 +00:00
|
|
|
/* re-use the page, so don't erase
|
2013-02-09 12:49:21 +00:00
|
|
|
* buffer_info->page
|
|
|
|
*/
|
2009-07-06 10:44:39 +00:00
|
|
|
skb_put(skb, length);
|
|
|
|
} else {
|
|
|
|
skb_fill_page_desc(skb, 0,
|
2013-02-09 12:49:21 +00:00
|
|
|
buffer_info->page, 0,
|
|
|
|
length);
|
2009-07-06 10:44:39 +00:00
|
|
|
e1000_consume_page(buffer_info, skb,
|
2013-02-09 12:49:21 +00:00
|
|
|
length);
|
2009-07-06 10:44:39 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Receive Checksum Offload XXX recompute due to CRC strip? */
|
|
|
|
e1000_rx_checksum(adapter,
|
2013-02-09 12:49:21 +00:00
|
|
|
(u32)(status) |
|
|
|
|
((u32)(rx_desc->errors) << 24),
|
|
|
|
le16_to_cpu(rx_desc->csum), skb);
|
2009-07-06 10:44:39 +00:00
|
|
|
|
2012-02-11 15:40:11 +00:00
|
|
|
total_rx_bytes += (skb->len - 4); /* don't count FCS */
|
|
|
|
if (likely(!(netdev->features & NETIF_F_RXFCS)))
|
|
|
|
pskb_trim(skb, skb->len - 4);
|
2009-07-06 10:44:39 +00:00
|
|
|
total_rx_packets++;
|
|
|
|
|
|
|
|
/* eth type trans needs skb->data to point to something */
|
|
|
|
if (!pskb_may_pull(skb, ETH_HLEN)) {
|
2010-07-27 06:37:21 +00:00
|
|
|
e_err(drv, "pskb_may_pull failed.\n");
|
2009-07-06 10:44:39 +00:00
|
|
|
dev_kfree_skb(skb);
|
|
|
|
goto next_desc;
|
|
|
|
}
|
|
|
|
|
|
|
|
e1000_receive_skb(adapter, status, rx_desc->special, skb);
|
|
|
|
|
|
|
|
next_desc:
|
|
|
|
rx_desc->status = 0;
|
|
|
|
|
|
|
|
/* return some buffers to hardware, one at a time is too slow */
|
|
|
|
if (unlikely(cleaned_count >= E1000_RX_BUFFER_WRITE)) {
|
|
|
|
adapter->alloc_rx_buf(adapter, rx_ring, cleaned_count);
|
|
|
|
cleaned_count = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* use prefetched values */
|
|
|
|
rx_desc = next_rxd;
|
|
|
|
buffer_info = next_buffer;
|
|
|
|
}
|
|
|
|
rx_ring->next_to_clean = i;
|
|
|
|
|
|
|
|
cleaned_count = E1000_DESC_UNUSED(rx_ring);
|
|
|
|
if (cleaned_count)
|
|
|
|
adapter->alloc_rx_buf(adapter, rx_ring, cleaned_count);
|
|
|
|
|
|
|
|
adapter->total_rx_packets += total_rx_packets;
|
|
|
|
adapter->total_rx_bytes += total_rx_bytes;
|
2009-10-07 02:42:23 +00:00
|
|
|
netdev->stats.rx_bytes += total_rx_bytes;
|
|
|
|
netdev->stats.rx_packets += total_rx_packets;
|
2009-07-06 10:44:39 +00:00
|
|
|
return cleaned;
|
|
|
|
}
|
|
|
|
|
2013-02-09 12:49:21 +00:00
|
|
|
/* this should improve performance for small packets with large amounts
|
2010-05-13 15:26:17 +00:00
|
|
|
* of reassembly being done in the stack
|
|
|
|
*/
|
|
|
|
static void e1000_check_copybreak(struct net_device *netdev,
|
|
|
|
struct e1000_buffer *buffer_info,
|
|
|
|
u32 length, struct sk_buff **skb)
|
|
|
|
{
|
|
|
|
struct sk_buff *new_skb;
|
|
|
|
|
|
|
|
if (length > copybreak)
|
|
|
|
return;
|
|
|
|
|
|
|
|
new_skb = netdev_alloc_skb_ip_align(netdev, length);
|
|
|
|
if (!new_skb)
|
|
|
|
return;
|
|
|
|
|
|
|
|
skb_copy_to_linear_data_offset(new_skb, -NET_IP_ALIGN,
|
|
|
|
(*skb)->data - NET_IP_ALIGN,
|
|
|
|
length + NET_IP_ALIGN);
|
|
|
|
/* save the skb in buffer_info as good */
|
|
|
|
buffer_info->skb = *skb;
|
|
|
|
*skb = new_skb;
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/**
|
2005-04-29 02:43:52 +00:00
|
|
|
* e1000_clean_rx_irq - Send received data up the network stack; legacy
|
2005-04-16 22:20:36 +00:00
|
|
|
* @adapter: board private structure
|
2009-07-06 10:44:39 +00:00
|
|
|
* @rx_ring: ring to clean
|
|
|
|
* @work_done: amount of napi work completed this call
|
|
|
|
* @work_to_do: max amount of work allowed for this call to do
|
|
|
|
*/
|
2008-07-11 22:17:02 +00:00
|
|
|
static bool e1000_clean_rx_irq(struct e1000_adapter *adapter,
|
|
|
|
struct e1000_rx_ring *rx_ring,
|
|
|
|
int *work_done, int work_to_do)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2008-07-11 22:17:08 +00:00
|
|
|
struct e1000_hw *hw = &adapter->hw;
|
2005-04-16 22:20:36 +00:00
|
|
|
struct net_device *netdev = adapter->netdev;
|
|
|
|
struct pci_dev *pdev = adapter->pdev;
|
2006-01-18 21:01:43 +00:00
|
|
|
struct e1000_rx_desc *rx_desc, *next_rxd;
|
|
|
|
struct e1000_buffer *buffer_info, *next_buffer;
|
2005-04-16 22:20:36 +00:00
|
|
|
unsigned long flags;
|
2008-04-03 17:06:32 +00:00
|
|
|
u32 length;
|
2005-04-16 22:20:36 +00:00
|
|
|
unsigned int i;
|
2006-01-13 00:51:19 +00:00
|
|
|
int cleaned_count = 0;
|
2008-03-21 18:06:25 +00:00
|
|
|
bool cleaned = false;
|
e1000: add dynamic itr modes
Add a new dynamic itr algorithm, with 2 modes, and make it the default
operation mode. This greatly reduces latency and increases small packet
performance, at the "cost" of some CPU utilization. Bulk traffic
throughput is unaffected.
The driver can limit the amount of interrupts per second that the
adapter will generate for incoming packets. It does this by writing a
value to the adapter that is based on the maximum amount of interrupts
that the adapter will generate per second.
Setting InterruptThrottleRate to a value greater or equal to 100 will
program the adapter to send out a maximum of that many interrupts per
second, even if more packets have come in. This reduces interrupt
load on the system and can lower CPU utilization under heavy load,
but will increase latency as packets are not processed as quickly.
The default behaviour of the driver previously assumed a static
InterruptThrottleRate value of 8000, providing a good fallback value
for all traffic types,but lacking in small packet performance and
latency. The hardware can handle many more small packets per second
however, and for this reason an adaptive interrupt moderation algorithm
was implemented.
Since 7.3.x, the driver has two adaptive modes (setting 1 or 3) in
which it dynamically adjusts the InterruptThrottleRate value based on
the traffic that it receives. After determining the type of incoming
traffic in the last timeframe, it will adjust the InterruptThrottleRate
to an appropriate value for that traffic.
The algorithm classifies the incoming traffic every interval into
classes. Once the class is determined, the InterruptThrottleRate
value is adjusted to suit that traffic type the best. There are
three classes defined: "Bulk traffic", for large amounts of packets
of normal size; "Low latency", for small amounts of traffic and/or
a significant percentage of small packets; and "Lowest latency",
for almost completely small packets or minimal traffic.
In dynamic conservative mode, the InterruptThrottleRate value is
set to 4000 for traffic that falls in class "Bulk traffic". If
traffic falls in the "Low latency" or "Lowest latency" class, the
InterruptThrottleRate is increased stepwise to 20000. This default
mode is suitable for most applications.
For situations where low latency is vital such as cluster or
grid computing, the algorithm can reduce latency even more when
InterruptThrottleRate is set to mode 1. In this mode, which operates
the same as mode 3, the InterruptThrottleRate will be increased
stepwise to 70000 for traffic in class "Lowest latency".
Setting InterruptThrottleRate to 0 turns off any interrupt moderation
and may improve small packet latency, but is generally not suitable
for bulk throughput traffic.
Signed-off-by: Jesse Brandeburg <jesse.brandeburg@intel.com>
Cc: Rick Jones <rick.jones2@hp.com>
Signed-off-by: Auke Kok <auke-jan.h.kok@intel.com>
2006-11-01 16:48:13 +00:00
|
|
|
unsigned int total_rx_bytes=0, total_rx_packets=0;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
i = rx_ring->next_to_clean;
|
|
|
|
rx_desc = E1000_RX_DESC(*rx_ring, i);
|
2006-01-18 21:01:32 +00:00
|
|
|
buffer_info = &rx_ring->buffer_info[i];
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-01-18 21:01:32 +00:00
|
|
|
while (rx_desc->status & E1000_RXD_STAT_DD) {
|
2006-06-08 16:28:47 +00:00
|
|
|
struct sk_buff *skb;
|
2006-01-13 00:51:30 +00:00
|
|
|
u8 status;
|
2006-11-01 16:47:30 +00:00
|
|
|
|
2006-01-18 21:01:39 +00:00
|
|
|
if (*work_done >= work_to_do)
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
|
|
|
(*work_done)++;
|
2010-08-08 16:02:31 +00:00
|
|
|
rmb(); /* read descriptor and rx_buffer_info after status DD */
|
2008-07-11 22:17:38 +00:00
|
|
|
|
2006-01-13 00:51:30 +00:00
|
|
|
status = rx_desc->status;
|
2006-01-18 21:01:32 +00:00
|
|
|
skb = buffer_info->skb;
|
2006-01-18 21:01:43 +00:00
|
|
|
buffer_info->skb = NULL;
|
|
|
|
|
2006-03-03 02:21:57 +00:00
|
|
|
prefetch(skb->data - NET_IP_ALIGN);
|
|
|
|
|
2006-01-18 21:01:43 +00:00
|
|
|
if (++i == rx_ring->count) i = 0;
|
|
|
|
next_rxd = E1000_RX_DESC(*rx_ring, i);
|
2006-03-03 02:21:57 +00:00
|
|
|
prefetch(next_rxd);
|
|
|
|
|
2006-01-18 21:01:43 +00:00
|
|
|
next_buffer = &rx_ring->buffer_info[i];
|
|
|
|
|
2008-03-21 18:06:25 +00:00
|
|
|
cleaned = true;
|
2006-01-13 00:51:19 +00:00
|
|
|
cleaned_count++;
|
2010-04-27 13:08:45 +00:00
|
|
|
dma_unmap_single(&pdev->dev, buffer_info->dma,
|
|
|
|
buffer_info->length, DMA_FROM_DEVICE);
|
2009-06-30 12:45:34 +00:00
|
|
|
buffer_info->dma = 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
length = le16_to_cpu(rx_desc->length);
|
e1000: add missing length check to e1000 receive routine
Patch to fix bad length checking in e1000. E1000 by default does two
things:
1) Spans rx descriptors for packets that don't fit into 1 skb on recieve
2) Strips the crc from a frame by subtracting 4 bytes from the length prior to
doing an skb_put
Since the e1000 driver isn't written to support receiving packets that span
multiple rx buffers, it checks the End of Packet bit of every frame, and
discards it if its not set. This places us in a situation where, if we have a
spanning packet, the first part is discarded, but the second part is not (since
it is the end of packet, and it passes the EOP bit test). If the second part of
the frame is small (4 bytes or less), we subtract 4 from it to remove its crc,
underflow the length, and wind up in skb_over_panic, when we try to skb_put a
huge number of bytes into the skb. This amounts to a remote DOS attack through
careful selection of frame size in relation to interface MTU. The fix for this
is already in the e1000e driver, as well as the e1000 sourceforge driver, but no
one ever pushed it to e1000. This is lifted straight from e1000e, and prevents
small frames from causing the underflow described above
Signed-off-by: Neil Horman <nhorman@tuxdriver.com>
Tested-by: Andy Gospodarek <andy@greyhouse.net>
Signed-off-by: David S. Miller <davem@davemloft.net>
2009-06-02 08:29:58 +00:00
|
|
|
/* !EOP means multiple descriptors were used to store a single
|
2010-01-19 14:15:38 +00:00
|
|
|
* packet, if thats the case we need to toss it. In fact, we
|
|
|
|
* to toss every packet with the EOP bit clear and the next
|
|
|
|
* frame that _does_ have the EOP bit set, as it is by
|
|
|
|
* definition only a frame fragment
|
|
|
|
*/
|
|
|
|
if (unlikely(!(status & E1000_RXD_STAT_EOP)))
|
|
|
|
adapter->discarding = true;
|
|
|
|
|
|
|
|
if (adapter->discarding) {
|
2006-03-01 04:24:07 +00:00
|
|
|
/* All receives must fit into a single buffer */
|
2010-07-27 06:37:21 +00:00
|
|
|
e_dbg("Receive packet consumed multiple buffers\n");
|
2006-06-27 16:06:53 +00:00
|
|
|
/* recycle */
|
2006-08-28 21:56:16 +00:00
|
|
|
buffer_info->skb = skb;
|
2010-01-19 14:15:38 +00:00
|
|
|
if (status & E1000_RXD_STAT_EOP)
|
|
|
|
adapter->discarding = false;
|
2005-04-16 22:20:36 +00:00
|
|
|
goto next_desc;
|
|
|
|
}
|
|
|
|
|
2006-01-18 21:01:39 +00:00
|
|
|
if (unlikely(rx_desc->errors & E1000_RXD_ERR_FRAME_ERR_MASK)) {
|
2009-07-06 10:44:39 +00:00
|
|
|
u8 last_byte = *(skb->data + length - 1);
|
2008-07-11 22:17:08 +00:00
|
|
|
if (TBI_ACCEPT(hw, status, rx_desc->errors, length,
|
|
|
|
last_byte)) {
|
2005-04-16 22:20:36 +00:00
|
|
|
spin_lock_irqsave(&adapter->stats_lock, flags);
|
2008-07-11 22:17:08 +00:00
|
|
|
e1000_tbi_adjust_stats(hw, &adapter->stats,
|
2013-02-09 12:49:21 +00:00
|
|
|
length, skb->data);
|
2005-04-16 22:20:36 +00:00
|
|
|
spin_unlock_irqrestore(&adapter->stats_lock,
|
2013-02-09 12:49:21 +00:00
|
|
|
flags);
|
2005-04-16 22:20:36 +00:00
|
|
|
length--;
|
|
|
|
} else {
|
2012-04-04 06:01:29 +00:00
|
|
|
if (netdev->features & NETIF_F_RXALL)
|
|
|
|
goto process_skb;
|
2006-04-15 02:05:18 +00:00
|
|
|
/* recycle */
|
|
|
|
buffer_info->skb = skb;
|
2005-04-16 22:20:36 +00:00
|
|
|
goto next_desc;
|
|
|
|
}
|
2006-04-18 19:31:04 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2012-04-04 06:01:29 +00:00
|
|
|
process_skb:
|
2012-02-11 15:40:11 +00:00
|
|
|
total_rx_bytes += (length - 4); /* don't count FCS */
|
e1000: add dynamic itr modes
Add a new dynamic itr algorithm, with 2 modes, and make it the default
operation mode. This greatly reduces latency and increases small packet
performance, at the "cost" of some CPU utilization. Bulk traffic
throughput is unaffected.
The driver can limit the amount of interrupts per second that the
adapter will generate for incoming packets. It does this by writing a
value to the adapter that is based on the maximum amount of interrupts
that the adapter will generate per second.
Setting InterruptThrottleRate to a value greater or equal to 100 will
program the adapter to send out a maximum of that many interrupts per
second, even if more packets have come in. This reduces interrupt
load on the system and can lower CPU utilization under heavy load,
but will increase latency as packets are not processed as quickly.
The default behaviour of the driver previously assumed a static
InterruptThrottleRate value of 8000, providing a good fallback value
for all traffic types,but lacking in small packet performance and
latency. The hardware can handle many more small packets per second
however, and for this reason an adaptive interrupt moderation algorithm
was implemented.
Since 7.3.x, the driver has two adaptive modes (setting 1 or 3) in
which it dynamically adjusts the InterruptThrottleRate value based on
the traffic that it receives. After determining the type of incoming
traffic in the last timeframe, it will adjust the InterruptThrottleRate
to an appropriate value for that traffic.
The algorithm classifies the incoming traffic every interval into
classes. Once the class is determined, the InterruptThrottleRate
value is adjusted to suit that traffic type the best. There are
three classes defined: "Bulk traffic", for large amounts of packets
of normal size; "Low latency", for small amounts of traffic and/or
a significant percentage of small packets; and "Lowest latency",
for almost completely small packets or minimal traffic.
In dynamic conservative mode, the InterruptThrottleRate value is
set to 4000 for traffic that falls in class "Bulk traffic". If
traffic falls in the "Low latency" or "Lowest latency" class, the
InterruptThrottleRate is increased stepwise to 20000. This default
mode is suitable for most applications.
For situations where low latency is vital such as cluster or
grid computing, the algorithm can reduce latency even more when
InterruptThrottleRate is set to mode 1. In this mode, which operates
the same as mode 3, the InterruptThrottleRate will be increased
stepwise to 70000 for traffic in class "Lowest latency".
Setting InterruptThrottleRate to 0 turns off any interrupt moderation
and may improve small packet latency, but is generally not suitable
for bulk throughput traffic.
Signed-off-by: Jesse Brandeburg <jesse.brandeburg@intel.com>
Cc: Rick Jones <rick.jones2@hp.com>
Signed-off-by: Auke Kok <auke-jan.h.kok@intel.com>
2006-11-01 16:48:13 +00:00
|
|
|
total_rx_packets++;
|
|
|
|
|
2012-02-11 15:40:11 +00:00
|
|
|
if (likely(!(netdev->features & NETIF_F_RXFCS)))
|
|
|
|
/* adjust length to remove Ethernet CRC, this must be
|
|
|
|
* done after the TBI_ACCEPT workaround above
|
|
|
|
*/
|
|
|
|
length -= 4;
|
|
|
|
|
2010-05-13 15:26:17 +00:00
|
|
|
e1000_check_copybreak(netdev, buffer_info, length, &skb);
|
|
|
|
|
2006-11-01 16:47:50 +00:00
|
|
|
skb_put(skb, length);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* Receive Checksum Offload */
|
2006-01-13 00:51:30 +00:00
|
|
|
e1000_rx_checksum(adapter,
|
2008-04-03 17:06:32 +00:00
|
|
|
(u32)(status) |
|
|
|
|
((u32)(rx_desc->errors) << 24),
|
2006-03-15 22:26:28 +00:00
|
|
|
le16_to_cpu(rx_desc->csum), skb);
|
2006-01-18 21:01:39 +00:00
|
|
|
|
2009-07-06 10:44:39 +00:00
|
|
|
e1000_receive_skb(adapter, status, rx_desc->special, skb);
|
2008-07-11 22:17:38 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
next_desc:
|
|
|
|
rx_desc->status = 0;
|
|
|
|
|
2006-01-13 00:51:19 +00:00
|
|
|
/* return some buffers to hardware, one at a time is too slow */
|
|
|
|
if (unlikely(cleaned_count >= E1000_RX_BUFFER_WRITE)) {
|
|
|
|
adapter->alloc_rx_buf(adapter, rx_ring, cleaned_count);
|
|
|
|
cleaned_count = 0;
|
|
|
|
}
|
|
|
|
|
2006-03-03 02:21:57 +00:00
|
|
|
/* use prefetched values */
|
2006-01-18 21:01:43 +00:00
|
|
|
rx_desc = next_rxd;
|
|
|
|
buffer_info = next_buffer;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
rx_ring->next_to_clean = i;
|
2006-01-13 00:51:19 +00:00
|
|
|
|
|
|
|
cleaned_count = E1000_DESC_UNUSED(rx_ring);
|
|
|
|
if (cleaned_count)
|
|
|
|
adapter->alloc_rx_buf(adapter, rx_ring, cleaned_count);
|
2005-04-29 02:43:52 +00:00
|
|
|
|
e1000: add dynamic itr modes
Add a new dynamic itr algorithm, with 2 modes, and make it the default
operation mode. This greatly reduces latency and increases small packet
performance, at the "cost" of some CPU utilization. Bulk traffic
throughput is unaffected.
The driver can limit the amount of interrupts per second that the
adapter will generate for incoming packets. It does this by writing a
value to the adapter that is based on the maximum amount of interrupts
that the adapter will generate per second.
Setting InterruptThrottleRate to a value greater or equal to 100 will
program the adapter to send out a maximum of that many interrupts per
second, even if more packets have come in. This reduces interrupt
load on the system and can lower CPU utilization under heavy load,
but will increase latency as packets are not processed as quickly.
The default behaviour of the driver previously assumed a static
InterruptThrottleRate value of 8000, providing a good fallback value
for all traffic types,but lacking in small packet performance and
latency. The hardware can handle many more small packets per second
however, and for this reason an adaptive interrupt moderation algorithm
was implemented.
Since 7.3.x, the driver has two adaptive modes (setting 1 or 3) in
which it dynamically adjusts the InterruptThrottleRate value based on
the traffic that it receives. After determining the type of incoming
traffic in the last timeframe, it will adjust the InterruptThrottleRate
to an appropriate value for that traffic.
The algorithm classifies the incoming traffic every interval into
classes. Once the class is determined, the InterruptThrottleRate
value is adjusted to suit that traffic type the best. There are
three classes defined: "Bulk traffic", for large amounts of packets
of normal size; "Low latency", for small amounts of traffic and/or
a significant percentage of small packets; and "Lowest latency",
for almost completely small packets or minimal traffic.
In dynamic conservative mode, the InterruptThrottleRate value is
set to 4000 for traffic that falls in class "Bulk traffic". If
traffic falls in the "Low latency" or "Lowest latency" class, the
InterruptThrottleRate is increased stepwise to 20000. This default
mode is suitable for most applications.
For situations where low latency is vital such as cluster or
grid computing, the algorithm can reduce latency even more when
InterruptThrottleRate is set to mode 1. In this mode, which operates
the same as mode 3, the InterruptThrottleRate will be increased
stepwise to 70000 for traffic in class "Lowest latency".
Setting InterruptThrottleRate to 0 turns off any interrupt moderation
and may improve small packet latency, but is generally not suitable
for bulk throughput traffic.
Signed-off-by: Jesse Brandeburg <jesse.brandeburg@intel.com>
Cc: Rick Jones <rick.jones2@hp.com>
Signed-off-by: Auke Kok <auke-jan.h.kok@intel.com>
2006-11-01 16:48:13 +00:00
|
|
|
adapter->total_rx_packets += total_rx_packets;
|
|
|
|
adapter->total_rx_bytes += total_rx_bytes;
|
2009-10-07 02:42:23 +00:00
|
|
|
netdev->stats.rx_bytes += total_rx_bytes;
|
|
|
|
netdev->stats.rx_packets += total_rx_packets;
|
2005-04-29 02:43:52 +00:00
|
|
|
return cleaned;
|
|
|
|
}
|
|
|
|
|
2009-07-06 10:44:39 +00:00
|
|
|
/**
|
|
|
|
* e1000_alloc_jumbo_rx_buffers - Replace used jumbo receive buffers
|
|
|
|
* @adapter: address of board private structure
|
|
|
|
* @rx_ring: pointer to receive ring structure
|
|
|
|
* @cleaned_count: number of buffers to allocate this pass
|
|
|
|
**/
|
|
|
|
static void
|
|
|
|
e1000_alloc_jumbo_rx_buffers(struct e1000_adapter *adapter,
|
2013-02-09 12:49:21 +00:00
|
|
|
struct e1000_rx_ring *rx_ring, int cleaned_count)
|
2009-07-06 10:44:39 +00:00
|
|
|
{
|
|
|
|
struct net_device *netdev = adapter->netdev;
|
|
|
|
struct pci_dev *pdev = adapter->pdev;
|
|
|
|
struct e1000_rx_desc *rx_desc;
|
|
|
|
struct e1000_buffer *buffer_info;
|
|
|
|
struct sk_buff *skb;
|
|
|
|
unsigned int i;
|
2009-10-13 05:34:20 +00:00
|
|
|
unsigned int bufsz = 256 - 16 /*for skb_reserve */ ;
|
2009-07-06 10:44:39 +00:00
|
|
|
|
|
|
|
i = rx_ring->next_to_use;
|
|
|
|
buffer_info = &rx_ring->buffer_info[i];
|
|
|
|
|
|
|
|
while (cleaned_count--) {
|
|
|
|
skb = buffer_info->skb;
|
|
|
|
if (skb) {
|
|
|
|
skb_trim(skb, 0);
|
|
|
|
goto check_page;
|
|
|
|
}
|
|
|
|
|
2009-10-13 05:34:20 +00:00
|
|
|
skb = netdev_alloc_skb_ip_align(netdev, bufsz);
|
2009-07-06 10:44:39 +00:00
|
|
|
if (unlikely(!skb)) {
|
|
|
|
/* Better luck next round */
|
|
|
|
adapter->alloc_rx_buff_failed++;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
buffer_info->skb = skb;
|
|
|
|
buffer_info->length = adapter->rx_buffer_len;
|
|
|
|
check_page:
|
|
|
|
/* allocate a new page if necessary */
|
|
|
|
if (!buffer_info->page) {
|
|
|
|
buffer_info->page = alloc_page(GFP_ATOMIC);
|
|
|
|
if (unlikely(!buffer_info->page)) {
|
|
|
|
adapter->alloc_rx_buff_failed++;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-02-19 17:54:53 +00:00
|
|
|
if (!buffer_info->dma) {
|
2010-04-27 13:08:45 +00:00
|
|
|
buffer_info->dma = dma_map_page(&pdev->dev,
|
2013-02-09 12:49:21 +00:00
|
|
|
buffer_info->page, 0,
|
2010-04-27 13:08:45 +00:00
|
|
|
buffer_info->length,
|
|
|
|
DMA_FROM_DEVICE);
|
|
|
|
if (dma_mapping_error(&pdev->dev, buffer_info->dma)) {
|
2010-02-19 17:54:53 +00:00
|
|
|
put_page(buffer_info->page);
|
|
|
|
dev_kfree_skb(skb);
|
|
|
|
buffer_info->page = NULL;
|
|
|
|
buffer_info->skb = NULL;
|
|
|
|
buffer_info->dma = 0;
|
|
|
|
adapter->alloc_rx_buff_failed++;
|
|
|
|
break; /* while !buffer_info->skb */
|
|
|
|
}
|
|
|
|
}
|
2009-07-06 10:44:39 +00:00
|
|
|
|
|
|
|
rx_desc = E1000_RX_DESC(*rx_ring, i);
|
|
|
|
rx_desc->buffer_addr = cpu_to_le64(buffer_info->dma);
|
|
|
|
|
|
|
|
if (unlikely(++i == rx_ring->count))
|
|
|
|
i = 0;
|
|
|
|
buffer_info = &rx_ring->buffer_info[i];
|
|
|
|
}
|
|
|
|
|
|
|
|
if (likely(rx_ring->next_to_use != i)) {
|
|
|
|
rx_ring->next_to_use = i;
|
|
|
|
if (unlikely(i-- == 0))
|
|
|
|
i = (rx_ring->count - 1);
|
|
|
|
|
|
|
|
/* Force memory writes to complete before letting h/w
|
|
|
|
* know there are new descriptors to fetch. (Only
|
|
|
|
* applicable for weak-ordered memory model archs,
|
2013-02-09 12:49:21 +00:00
|
|
|
* such as IA-64).
|
|
|
|
*/
|
2009-07-06 10:44:39 +00:00
|
|
|
wmb();
|
|
|
|
writel(i, adapter->hw.hw_addr + rx_ring->rdt);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/**
|
2005-04-29 02:43:52 +00:00
|
|
|
* e1000_alloc_rx_buffers - Replace used receive buffers; legacy & extended
|
2005-04-16 22:20:36 +00:00
|
|
|
* @adapter: address of board private structure
|
|
|
|
**/
|
2008-07-11 22:17:02 +00:00
|
|
|
static void e1000_alloc_rx_buffers(struct e1000_adapter *adapter,
|
|
|
|
struct e1000_rx_ring *rx_ring,
|
|
|
|
int cleaned_count)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2008-07-11 22:17:08 +00:00
|
|
|
struct e1000_hw *hw = &adapter->hw;
|
2005-04-16 22:20:36 +00:00
|
|
|
struct net_device *netdev = adapter->netdev;
|
|
|
|
struct pci_dev *pdev = adapter->pdev;
|
|
|
|
struct e1000_rx_desc *rx_desc;
|
|
|
|
struct e1000_buffer *buffer_info;
|
|
|
|
struct sk_buff *skb;
|
2005-04-29 02:44:46 +00:00
|
|
|
unsigned int i;
|
2009-10-13 05:34:20 +00:00
|
|
|
unsigned int bufsz = adapter->rx_buffer_len;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
i = rx_ring->next_to_use;
|
|
|
|
buffer_info = &rx_ring->buffer_info[i];
|
|
|
|
|
2006-01-13 00:51:30 +00:00
|
|
|
while (cleaned_count--) {
|
2006-08-31 21:27:47 +00:00
|
|
|
skb = buffer_info->skb;
|
|
|
|
if (skb) {
|
2006-01-13 00:51:30 +00:00
|
|
|
skb_trim(skb, 0);
|
|
|
|
goto map_skb;
|
|
|
|
}
|
|
|
|
|
2009-10-13 05:34:20 +00:00
|
|
|
skb = netdev_alloc_skb_ip_align(netdev, bufsz);
|
2006-01-18 21:01:39 +00:00
|
|
|
if (unlikely(!skb)) {
|
2005-04-16 22:20:36 +00:00
|
|
|
/* Better luck next round */
|
2006-01-13 00:51:19 +00:00
|
|
|
adapter->alloc_rx_buff_failed++;
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2005-04-29 02:44:46 +00:00
|
|
|
/* Fix for errata 23, can't cross 64kB boundary */
|
2005-04-16 22:20:36 +00:00
|
|
|
if (!e1000_check_64k_bound(adapter, skb->data, bufsz)) {
|
|
|
|
struct sk_buff *oldskb = skb;
|
2010-07-27 06:37:21 +00:00
|
|
|
e_err(rx_err, "skb align check failed: %u bytes at "
|
|
|
|
"%p\n", bufsz, skb->data);
|
2005-04-29 02:44:46 +00:00
|
|
|
/* Try again, without freeing the previous */
|
2009-10-13 05:34:20 +00:00
|
|
|
skb = netdev_alloc_skb_ip_align(netdev, bufsz);
|
2005-04-29 02:44:46 +00:00
|
|
|
/* Failed allocation, critical failure */
|
2005-04-16 22:20:36 +00:00
|
|
|
if (!skb) {
|
|
|
|
dev_kfree_skb(oldskb);
|
2009-07-06 10:44:39 +00:00
|
|
|
adapter->alloc_rx_buff_failed++;
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
|
|
|
}
|
2005-04-29 02:44:46 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
if (!e1000_check_64k_bound(adapter, skb->data, bufsz)) {
|
|
|
|
/* give up */
|
|
|
|
dev_kfree_skb(skb);
|
|
|
|
dev_kfree_skb(oldskb);
|
2009-07-06 10:44:39 +00:00
|
|
|
adapter->alloc_rx_buff_failed++;
|
2005-04-16 22:20:36 +00:00
|
|
|
break; /* while !buffer_info->skb */
|
|
|
|
}
|
2006-08-31 21:27:47 +00:00
|
|
|
|
|
|
|
/* Use new allocation */
|
|
|
|
dev_kfree_skb(oldskb);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
buffer_info->skb = skb;
|
|
|
|
buffer_info->length = adapter->rx_buffer_len;
|
2006-01-13 00:51:30 +00:00
|
|
|
map_skb:
|
2010-04-27 13:08:45 +00:00
|
|
|
buffer_info->dma = dma_map_single(&pdev->dev,
|
2005-04-16 22:20:36 +00:00
|
|
|
skb->data,
|
2009-07-06 10:44:39 +00:00
|
|
|
buffer_info->length,
|
2010-04-27 13:08:45 +00:00
|
|
|
DMA_FROM_DEVICE);
|
|
|
|
if (dma_mapping_error(&pdev->dev, buffer_info->dma)) {
|
2010-02-19 17:54:53 +00:00
|
|
|
dev_kfree_skb(skb);
|
|
|
|
buffer_info->skb = NULL;
|
|
|
|
buffer_info->dma = 0;
|
|
|
|
adapter->alloc_rx_buff_failed++;
|
|
|
|
break; /* while !buffer_info->skb */
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2013-02-09 12:49:21 +00:00
|
|
|
/* XXX if it was allocated cleanly it will never map to a
|
2009-07-06 10:44:39 +00:00
|
|
|
* boundary crossing
|
|
|
|
*/
|
|
|
|
|
2005-04-29 02:44:46 +00:00
|
|
|
/* Fix for errata 23, can't cross 64kB boundary */
|
|
|
|
if (!e1000_check_64k_bound(adapter,
|
|
|
|
(void *)(unsigned long)buffer_info->dma,
|
|
|
|
adapter->rx_buffer_len)) {
|
2010-07-27 06:37:21 +00:00
|
|
|
e_err(rx_err, "dma align check failed: %u bytes at "
|
|
|
|
"%p\n", adapter->rx_buffer_len,
|
2010-04-27 14:02:58 +00:00
|
|
|
(void *)(unsigned long)buffer_info->dma);
|
2005-04-16 22:20:36 +00:00
|
|
|
dev_kfree_skb(skb);
|
|
|
|
buffer_info->skb = NULL;
|
|
|
|
|
2010-04-27 13:08:45 +00:00
|
|
|
dma_unmap_single(&pdev->dev, buffer_info->dma,
|
2005-04-16 22:20:36 +00:00
|
|
|
adapter->rx_buffer_len,
|
2010-04-27 13:08:45 +00:00
|
|
|
DMA_FROM_DEVICE);
|
2009-06-30 12:45:34 +00:00
|
|
|
buffer_info->dma = 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-07-06 10:44:39 +00:00
|
|
|
adapter->alloc_rx_buff_failed++;
|
2005-04-16 22:20:36 +00:00
|
|
|
break; /* while !buffer_info->skb */
|
|
|
|
}
|
|
|
|
rx_desc = E1000_RX_DESC(*rx_ring, i);
|
|
|
|
rx_desc->buffer_addr = cpu_to_le64(buffer_info->dma);
|
|
|
|
|
2006-01-18 21:01:39 +00:00
|
|
|
if (unlikely(++i == rx_ring->count))
|
|
|
|
i = 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
buffer_info = &rx_ring->buffer_info[i];
|
|
|
|
}
|
|
|
|
|
2006-01-18 21:01:32 +00:00
|
|
|
if (likely(rx_ring->next_to_use != i)) {
|
|
|
|
rx_ring->next_to_use = i;
|
|
|
|
if (unlikely(i-- == 0))
|
|
|
|
i = (rx_ring->count - 1);
|
|
|
|
|
|
|
|
/* Force memory writes to complete before letting h/w
|
|
|
|
* know there are new descriptors to fetch. (Only
|
|
|
|
* applicable for weak-ordered memory model archs,
|
2013-02-09 12:49:21 +00:00
|
|
|
* such as IA-64).
|
|
|
|
*/
|
2006-01-18 21:01:32 +00:00
|
|
|
wmb();
|
2008-07-11 22:17:08 +00:00
|
|
|
writel(i, hw->hw_addr + rx_ring->rdt);
|
2006-01-18 21:01:32 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* e1000_smartspeed - Workaround for SmartSpeed on 82541 and 82547 controllers.
|
|
|
|
* @adapter:
|
|
|
|
**/
|
2008-07-11 22:17:02 +00:00
|
|
|
static void e1000_smartspeed(struct e1000_adapter *adapter)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2008-07-11 22:17:08 +00:00
|
|
|
struct e1000_hw *hw = &adapter->hw;
|
2008-04-03 17:06:32 +00:00
|
|
|
u16 phy_status;
|
|
|
|
u16 phy_ctrl;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-07-11 22:17:08 +00:00
|
|
|
if ((hw->phy_type != e1000_phy_igp) || !hw->autoneg ||
|
|
|
|
!(hw->autoneg_advertised & ADVERTISE_1000_FULL))
|
2005-04-16 22:20:36 +00:00
|
|
|
return;
|
|
|
|
|
2006-01-18 21:01:39 +00:00
|
|
|
if (adapter->smartspeed == 0) {
|
2005-04-16 22:20:36 +00:00
|
|
|
/* If Master/Slave config fault is asserted twice,
|
2013-02-09 12:49:21 +00:00
|
|
|
* we assume back-to-back
|
|
|
|
*/
|
2008-07-11 22:17:08 +00:00
|
|
|
e1000_read_phy_reg(hw, PHY_1000T_STATUS, &phy_status);
|
2006-01-18 21:01:39 +00:00
|
|
|
if (!(phy_status & SR_1000T_MS_CONFIG_FAULT)) return;
|
2008-07-11 22:17:08 +00:00
|
|
|
e1000_read_phy_reg(hw, PHY_1000T_STATUS, &phy_status);
|
2006-01-18 21:01:39 +00:00
|
|
|
if (!(phy_status & SR_1000T_MS_CONFIG_FAULT)) return;
|
2008-07-11 22:17:08 +00:00
|
|
|
e1000_read_phy_reg(hw, PHY_1000T_CTRL, &phy_ctrl);
|
2006-01-18 21:01:39 +00:00
|
|
|
if (phy_ctrl & CR_1000T_MS_ENABLE) {
|
2005-04-16 22:20:36 +00:00
|
|
|
phy_ctrl &= ~CR_1000T_MS_ENABLE;
|
2008-07-11 22:17:08 +00:00
|
|
|
e1000_write_phy_reg(hw, PHY_1000T_CTRL,
|
2005-04-16 22:20:36 +00:00
|
|
|
phy_ctrl);
|
|
|
|
adapter->smartspeed++;
|
2008-07-11 22:17:08 +00:00
|
|
|
if (!e1000_phy_setup_autoneg(hw) &&
|
|
|
|
!e1000_read_phy_reg(hw, PHY_CTRL,
|
2013-02-09 12:49:21 +00:00
|
|
|
&phy_ctrl)) {
|
2005-04-16 22:20:36 +00:00
|
|
|
phy_ctrl |= (MII_CR_AUTO_NEG_EN |
|
|
|
|
MII_CR_RESTART_AUTO_NEG);
|
2008-07-11 22:17:08 +00:00
|
|
|
e1000_write_phy_reg(hw, PHY_CTRL,
|
2005-04-16 22:20:36 +00:00
|
|
|
phy_ctrl);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return;
|
2006-01-18 21:01:39 +00:00
|
|
|
} else if (adapter->smartspeed == E1000_SMARTSPEED_DOWNSHIFT) {
|
2005-04-16 22:20:36 +00:00
|
|
|
/* If still no link, perhaps using 2/3 pair cable */
|
2008-07-11 22:17:08 +00:00
|
|
|
e1000_read_phy_reg(hw, PHY_1000T_CTRL, &phy_ctrl);
|
2005-04-16 22:20:36 +00:00
|
|
|
phy_ctrl |= CR_1000T_MS_ENABLE;
|
2008-07-11 22:17:08 +00:00
|
|
|
e1000_write_phy_reg(hw, PHY_1000T_CTRL, phy_ctrl);
|
|
|
|
if (!e1000_phy_setup_autoneg(hw) &&
|
|
|
|
!e1000_read_phy_reg(hw, PHY_CTRL, &phy_ctrl)) {
|
2005-04-16 22:20:36 +00:00
|
|
|
phy_ctrl |= (MII_CR_AUTO_NEG_EN |
|
|
|
|
MII_CR_RESTART_AUTO_NEG);
|
2008-07-11 22:17:08 +00:00
|
|
|
e1000_write_phy_reg(hw, PHY_CTRL, phy_ctrl);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
/* Restart process after E1000_SMARTSPEED_MAX iterations */
|
2006-01-18 21:01:39 +00:00
|
|
|
if (adapter->smartspeed++ == E1000_SMARTSPEED_MAX)
|
2005-04-16 22:20:36 +00:00
|
|
|
adapter->smartspeed = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* e1000_ioctl -
|
|
|
|
* @netdev:
|
|
|
|
* @ifreq:
|
|
|
|
* @cmd:
|
|
|
|
**/
|
2008-07-11 22:17:02 +00:00
|
|
|
static int e1000_ioctl(struct net_device *netdev, struct ifreq *ifr, int cmd)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
switch (cmd) {
|
|
|
|
case SIOCGMIIPHY:
|
|
|
|
case SIOCGMIIREG:
|
|
|
|
case SIOCSMIIREG:
|
|
|
|
return e1000_mii_ioctl(netdev, ifr, cmd);
|
|
|
|
default:
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* e1000_mii_ioctl -
|
|
|
|
* @netdev:
|
|
|
|
* @ifreq:
|
|
|
|
* @cmd:
|
|
|
|
**/
|
2008-07-11 22:17:02 +00:00
|
|
|
static int e1000_mii_ioctl(struct net_device *netdev, struct ifreq *ifr,
|
|
|
|
int cmd)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2005-06-18 00:41:45 +00:00
|
|
|
struct e1000_adapter *adapter = netdev_priv(netdev);
|
2008-07-11 22:17:08 +00:00
|
|
|
struct e1000_hw *hw = &adapter->hw;
|
2005-04-16 22:20:36 +00:00
|
|
|
struct mii_ioctl_data *data = if_mii(ifr);
|
|
|
|
int retval;
|
2008-04-03 17:06:32 +00:00
|
|
|
u16 mii_reg;
|
2005-06-18 00:40:19 +00:00
|
|
|
unsigned long flags;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-07-11 22:17:08 +00:00
|
|
|
if (hw->media_type != e1000_media_type_copper)
|
2005-04-16 22:20:36 +00:00
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
|
|
|
switch (cmd) {
|
|
|
|
case SIOCGMIIPHY:
|
2008-07-11 22:17:08 +00:00
|
|
|
data->phy_id = hw->phy_addr;
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
|
|
|
case SIOCGMIIREG:
|
2005-06-18 00:40:19 +00:00
|
|
|
spin_lock_irqsave(&adapter->stats_lock, flags);
|
2008-07-11 22:17:08 +00:00
|
|
|
if (e1000_read_phy_reg(hw, data->reg_num & 0x1F,
|
2005-06-18 00:40:19 +00:00
|
|
|
&data->val_out)) {
|
|
|
|
spin_unlock_irqrestore(&adapter->stats_lock, flags);
|
2005-04-16 22:20:36 +00:00
|
|
|
return -EIO;
|
2005-06-18 00:40:19 +00:00
|
|
|
}
|
|
|
|
spin_unlock_irqrestore(&adapter->stats_lock, flags);
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
|
|
|
case SIOCSMIIREG:
|
2006-01-18 21:01:39 +00:00
|
|
|
if (data->reg_num & ~(0x1F))
|
2005-04-16 22:20:36 +00:00
|
|
|
return -EFAULT;
|
|
|
|
mii_reg = data->val_in;
|
2005-06-18 00:40:19 +00:00
|
|
|
spin_lock_irqsave(&adapter->stats_lock, flags);
|
2008-07-11 22:17:08 +00:00
|
|
|
if (e1000_write_phy_reg(hw, data->reg_num,
|
2005-06-18 00:40:19 +00:00
|
|
|
mii_reg)) {
|
|
|
|
spin_unlock_irqrestore(&adapter->stats_lock, flags);
|
2005-04-16 22:20:36 +00:00
|
|
|
return -EIO;
|
2005-06-18 00:40:19 +00:00
|
|
|
}
|
2007-11-14 05:00:09 +00:00
|
|
|
spin_unlock_irqrestore(&adapter->stats_lock, flags);
|
2008-07-11 22:17:08 +00:00
|
|
|
if (hw->media_type == e1000_media_type_copper) {
|
2005-04-16 22:20:36 +00:00
|
|
|
switch (data->reg_num) {
|
|
|
|
case PHY_CTRL:
|
2006-01-18 21:01:39 +00:00
|
|
|
if (mii_reg & MII_CR_POWER_DOWN)
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
2006-01-18 21:01:39 +00:00
|
|
|
if (mii_reg & MII_CR_AUTO_NEG_EN) {
|
2008-07-11 22:17:08 +00:00
|
|
|
hw->autoneg = 1;
|
|
|
|
hw->autoneg_advertised = 0x2F;
|
2005-04-16 22:20:36 +00:00
|
|
|
} else {
|
2011-04-27 18:32:43 +00:00
|
|
|
u32 speed;
|
2005-04-16 22:20:36 +00:00
|
|
|
if (mii_reg & 0x40)
|
2011-04-27 18:32:43 +00:00
|
|
|
speed = SPEED_1000;
|
2005-04-16 22:20:36 +00:00
|
|
|
else if (mii_reg & 0x2000)
|
2011-04-27 18:32:43 +00:00
|
|
|
speed = SPEED_100;
|
2005-04-16 22:20:36 +00:00
|
|
|
else
|
2011-04-27 18:32:43 +00:00
|
|
|
speed = SPEED_10;
|
|
|
|
retval = e1000_set_spd_dplx(
|
|
|
|
adapter, speed,
|
|
|
|
((mii_reg & 0x100)
|
|
|
|
? DUPLEX_FULL :
|
|
|
|
DUPLEX_HALF));
|
2007-11-14 05:00:09 +00:00
|
|
|
if (retval)
|
2005-04-16 22:20:36 +00:00
|
|
|
return retval;
|
|
|
|
}
|
2006-06-27 16:06:28 +00:00
|
|
|
if (netif_running(adapter->netdev))
|
|
|
|
e1000_reinit_locked(adapter);
|
|
|
|
else
|
2005-04-16 22:20:36 +00:00
|
|
|
e1000_reset(adapter);
|
|
|
|
break;
|
|
|
|
case M88E1000_PHY_SPEC_CTRL:
|
|
|
|
case M88E1000_EXT_PHY_SPEC_CTRL:
|
2008-07-11 22:17:08 +00:00
|
|
|
if (e1000_phy_reset(hw))
|
2005-04-16 22:20:36 +00:00
|
|
|
return -EIO;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
switch (data->reg_num) {
|
|
|
|
case PHY_CTRL:
|
2006-01-18 21:01:39 +00:00
|
|
|
if (mii_reg & MII_CR_POWER_DOWN)
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
2006-06-27 16:06:28 +00:00
|
|
|
if (netif_running(adapter->netdev))
|
|
|
|
e1000_reinit_locked(adapter);
|
|
|
|
else
|
2005-04-16 22:20:36 +00:00
|
|
|
e1000_reset(adapter);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
}
|
|
|
|
return E1000_SUCCESS;
|
|
|
|
}
|
|
|
|
|
2008-07-11 22:17:02 +00:00
|
|
|
void e1000_pci_set_mwi(struct e1000_hw *hw)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct e1000_adapter *adapter = hw->back;
|
2005-04-29 02:44:46 +00:00
|
|
|
int ret_val = pci_set_mwi(adapter->pdev);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-01-18 21:01:39 +00:00
|
|
|
if (ret_val)
|
2010-07-27 06:37:21 +00:00
|
|
|
e_err(probe, "Error in setting MWI\n");
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2008-07-11 22:17:02 +00:00
|
|
|
void e1000_pci_clear_mwi(struct e1000_hw *hw)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct e1000_adapter *adapter = hw->back;
|
|
|
|
|
|
|
|
pci_clear_mwi(adapter->pdev);
|
|
|
|
}
|
|
|
|
|
2008-07-11 22:17:02 +00:00
|
|
|
int e1000_pcix_get_mmrbc(struct e1000_hw *hw)
|
2007-09-29 05:42:06 +00:00
|
|
|
{
|
|
|
|
struct e1000_adapter *adapter = hw->back;
|
|
|
|
return pcix_get_mmrbc(adapter->pdev);
|
|
|
|
}
|
|
|
|
|
2008-07-11 22:17:02 +00:00
|
|
|
void e1000_pcix_set_mmrbc(struct e1000_hw *hw, int mmrbc)
|
2007-09-29 05:42:06 +00:00
|
|
|
{
|
|
|
|
struct e1000_adapter *adapter = hw->back;
|
|
|
|
pcix_set_mmrbc(adapter->pdev, mmrbc);
|
|
|
|
}
|
|
|
|
|
2008-07-11 22:17:02 +00:00
|
|
|
void e1000_io_write(struct e1000_hw *hw, unsigned long port, u32 value)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
outl(value, port);
|
|
|
|
}
|
|
|
|
|
2011-07-21 03:26:31 +00:00
|
|
|
static bool e1000_vlan_used(struct e1000_adapter *adapter)
|
|
|
|
{
|
|
|
|
u16 vid;
|
|
|
|
|
|
|
|
for_each_set_bit(vid, adapter->active_vlans, VLAN_N_VID)
|
|
|
|
return true;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2012-03-20 18:10:01 +00:00
|
|
|
static void __e1000_vlan_mode(struct e1000_adapter *adapter,
|
|
|
|
netdev_features_t features)
|
|
|
|
{
|
|
|
|
struct e1000_hw *hw = &adapter->hw;
|
|
|
|
u32 ctrl;
|
|
|
|
|
|
|
|
ctrl = er32(CTRL);
|
2013-04-19 02:04:27 +00:00
|
|
|
if (features & NETIF_F_HW_VLAN_CTAG_RX) {
|
2012-03-20 18:10:01 +00:00
|
|
|
/* enable VLAN tag insert/strip */
|
|
|
|
ctrl |= E1000_CTRL_VME;
|
|
|
|
} else {
|
|
|
|
/* disable VLAN tag insert/strip */
|
|
|
|
ctrl &= ~E1000_CTRL_VME;
|
|
|
|
}
|
|
|
|
ew32(CTRL, ctrl);
|
|
|
|
}
|
2011-07-21 03:26:31 +00:00
|
|
|
static void e1000_vlan_filter_on_off(struct e1000_adapter *adapter,
|
|
|
|
bool filter_on)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2008-07-11 22:17:08 +00:00
|
|
|
struct e1000_hw *hw = &adapter->hw;
|
2011-07-21 03:26:31 +00:00
|
|
|
u32 rctl;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-03-21 18:06:58 +00:00
|
|
|
if (!test_bit(__E1000_DOWN, &adapter->flags))
|
|
|
|
e1000_irq_disable(adapter);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2012-03-20 18:10:01 +00:00
|
|
|
__e1000_vlan_mode(adapter, adapter->netdev->features);
|
2011-07-21 03:26:31 +00:00
|
|
|
if (filter_on) {
|
2009-09-25 12:16:14 +00:00
|
|
|
/* enable VLAN receive filtering */
|
|
|
|
rctl = er32(RCTL);
|
|
|
|
rctl &= ~E1000_RCTL_CFIEN;
|
2011-07-21 03:26:31 +00:00
|
|
|
if (!(adapter->netdev->flags & IFF_PROMISC))
|
2009-09-25 12:16:14 +00:00
|
|
|
rctl |= E1000_RCTL_VFE;
|
|
|
|
ew32(RCTL, rctl);
|
|
|
|
e1000_update_mng_vlan(adapter);
|
2005-04-16 22:20:36 +00:00
|
|
|
} else {
|
2009-09-25 12:16:14 +00:00
|
|
|
/* disable VLAN receive filtering */
|
|
|
|
rctl = er32(RCTL);
|
|
|
|
rctl &= ~E1000_RCTL_VFE;
|
|
|
|
ew32(RCTL, rctl);
|
2011-07-21 03:26:31 +00:00
|
|
|
}
|
e1000: Fix for e1000 kills IPMI on a tagged vlan.
Enabling VLAN filters (VFE) when the primary interface is brought up
(per commit 78ed11a) has caused problems for some users who manage
their systems using IPMI over a VLAN. This is because when the driver
enables the VLAN filter, this same filter table is enabled for the
management channel, and the table is initially empty, which means that
the IPMI/VLAN packets are filtered out and not received by the BMC.
This is a problem only on e1000 class adapters, as it is only
on e1000 that the filter table is common to the management and host
streams.
With this change, filtering is only enabled when one or more host VLANs
exist, and is disabled when the last host VLAN is removed. VLAN filtering
is always disabled when the primary interface is in promiscuous mode,
and will be (re)enabled if VLANs exist when the interface exits
promiscuous mode.
Note that this does not completely resolve the issue for those using VLAN
management, because if the host adds a VLAN, then the above problem
occurs when that VLAN is enabled. However, it does mean the there is no
problem for configurations where management is on a VLAN and the host is
not.
A complete solution to this issue would require further driver changes.
The driver would need to discover if (and which) management VLANs are
active before enabling VLAN filtering, so that it could ensure that the
managed VLANs are included in the VLAN filter table. This discovery
requires that the BMC identifies its VLAN in registers accessible
to the driver, and at least on Dell PE2850 systems the BMC does not
identify its VLAN to allow such discovery. Intel is pursuing this issue
with the BMC vendor.
Signed-off-by: Dave Graham <david.graham@intel.com>
Signed-off-by: Jeff Kirsher <jeffrey.t.kirsher@intel.com>
Tested-by: Krzysztof Piotr Oledzki <ole@ans.pl>
Signed-off-by: David S. Miller <davem@davemloft.net>
2009-08-31 14:12:51 +00:00
|
|
|
|
2011-07-21 03:26:31 +00:00
|
|
|
if (!test_bit(__E1000_DOWN, &adapter->flags))
|
|
|
|
e1000_irq_enable(adapter);
|
|
|
|
}
|
|
|
|
|
2011-11-15 15:29:55 +00:00
|
|
|
static void e1000_vlan_mode(struct net_device *netdev,
|
2012-03-20 18:10:01 +00:00
|
|
|
netdev_features_t features)
|
2011-07-21 03:26:31 +00:00
|
|
|
{
|
|
|
|
struct e1000_adapter *adapter = netdev_priv(netdev);
|
|
|
|
|
|
|
|
if (!test_bit(__E1000_DOWN, &adapter->flags))
|
|
|
|
e1000_irq_disable(adapter);
|
|
|
|
|
2012-03-20 18:10:01 +00:00
|
|
|
__e1000_vlan_mode(adapter, features);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-03-21 18:06:58 +00:00
|
|
|
if (!test_bit(__E1000_DOWN, &adapter->flags))
|
|
|
|
e1000_irq_enable(adapter);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2013-04-19 02:04:28 +00:00
|
|
|
static int e1000_vlan_rx_add_vid(struct net_device *netdev,
|
|
|
|
__be16 proto, u16 vid)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2005-06-18 00:41:45 +00:00
|
|
|
struct e1000_adapter *adapter = netdev_priv(netdev);
|
2008-07-11 22:17:08 +00:00
|
|
|
struct e1000_hw *hw = &adapter->hw;
|
2008-04-03 17:06:32 +00:00
|
|
|
u32 vfta, index;
|
2006-01-18 21:01:39 +00:00
|
|
|
|
2008-07-11 22:17:08 +00:00
|
|
|
if ((hw->mng_cookie.status &
|
2006-01-18 21:01:39 +00:00
|
|
|
E1000_MNG_DHCP_COOKIE_STATUS_VLAN_SUPPORT) &&
|
|
|
|
(vid == adapter->mng_vlan_id))
|
2011-12-09 00:52:37 +00:00
|
|
|
return 0;
|
2011-07-21 03:26:31 +00:00
|
|
|
|
|
|
|
if (!e1000_vlan_used(adapter))
|
|
|
|
e1000_vlan_filter_on_off(adapter, true);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* add VID to filter table */
|
|
|
|
index = (vid >> 5) & 0x7F;
|
2008-07-11 22:17:08 +00:00
|
|
|
vfta = E1000_READ_REG_ARRAY(hw, VFTA, index);
|
2005-04-16 22:20:36 +00:00
|
|
|
vfta |= (1 << (vid & 0x1F));
|
2008-07-11 22:17:08 +00:00
|
|
|
e1000_write_vfta(hw, index, vfta);
|
2011-07-21 03:26:31 +00:00
|
|
|
|
|
|
|
set_bit(vid, adapter->active_vlans);
|
2011-12-09 00:52:37 +00:00
|
|
|
|
|
|
|
return 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2013-04-19 02:04:28 +00:00
|
|
|
static int e1000_vlan_rx_kill_vid(struct net_device *netdev,
|
|
|
|
__be16 proto, u16 vid)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2005-06-18 00:41:45 +00:00
|
|
|
struct e1000_adapter *adapter = netdev_priv(netdev);
|
2008-07-11 22:17:08 +00:00
|
|
|
struct e1000_hw *hw = &adapter->hw;
|
2008-04-03 17:06:32 +00:00
|
|
|
u32 vfta, index;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-03-21 18:06:58 +00:00
|
|
|
if (!test_bit(__E1000_DOWN, &adapter->flags))
|
|
|
|
e1000_irq_disable(adapter);
|
|
|
|
if (!test_bit(__E1000_DOWN, &adapter->flags))
|
|
|
|
e1000_irq_enable(adapter);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* remove VID from filter table */
|
|
|
|
index = (vid >> 5) & 0x7F;
|
2008-07-11 22:17:08 +00:00
|
|
|
vfta = E1000_READ_REG_ARRAY(hw, VFTA, index);
|
2005-04-16 22:20:36 +00:00
|
|
|
vfta &= ~(1 << (vid & 0x1F));
|
2008-07-11 22:17:08 +00:00
|
|
|
e1000_write_vfta(hw, index, vfta);
|
2011-07-21 03:26:31 +00:00
|
|
|
|
|
|
|
clear_bit(vid, adapter->active_vlans);
|
|
|
|
|
|
|
|
if (!e1000_vlan_used(adapter))
|
|
|
|
e1000_vlan_filter_on_off(adapter, false);
|
2011-12-09 00:52:37 +00:00
|
|
|
|
|
|
|
return 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2008-07-11 22:17:02 +00:00
|
|
|
static void e1000_restore_vlan(struct e1000_adapter *adapter)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2011-07-21 03:26:31 +00:00
|
|
|
u16 vid;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2011-07-21 03:26:31 +00:00
|
|
|
if (!e1000_vlan_used(adapter))
|
|
|
|
return;
|
|
|
|
|
|
|
|
e1000_vlan_filter_on_off(adapter, true);
|
|
|
|
for_each_set_bit(vid, adapter->active_vlans, VLAN_N_VID)
|
2013-04-19 02:04:28 +00:00
|
|
|
e1000_vlan_rx_add_vid(adapter->netdev, htons(ETH_P_8021Q), vid);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2011-04-27 18:32:43 +00:00
|
|
|
int e1000_set_spd_dplx(struct e1000_adapter *adapter, u32 spd, u8 dplx)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2008-07-11 22:17:08 +00:00
|
|
|
struct e1000_hw *hw = &adapter->hw;
|
|
|
|
|
|
|
|
hw->autoneg = 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2011-04-27 18:32:43 +00:00
|
|
|
/* Make sure dplx is at most 1 bit and lsb of speed is not set
|
2013-02-09 12:49:21 +00:00
|
|
|
* for the switch() below to work
|
|
|
|
*/
|
2011-04-27 18:32:43 +00:00
|
|
|
if ((spd & 1) || (dplx & ~1))
|
|
|
|
goto err_inval;
|
|
|
|
|
2005-06-18 00:44:20 +00:00
|
|
|
/* Fiber NICs only allow 1000 gbps Full duplex */
|
2008-07-11 22:17:08 +00:00
|
|
|
if ((hw->media_type == e1000_media_type_fiber) &&
|
2011-04-27 18:32:43 +00:00
|
|
|
spd != SPEED_1000 &&
|
|
|
|
dplx != DUPLEX_FULL)
|
|
|
|
goto err_inval;
|
2005-06-18 00:44:20 +00:00
|
|
|
|
2011-04-27 18:32:43 +00:00
|
|
|
switch (spd + dplx) {
|
2005-04-16 22:20:36 +00:00
|
|
|
case SPEED_10 + DUPLEX_HALF:
|
2008-07-11 22:17:08 +00:00
|
|
|
hw->forced_speed_duplex = e1000_10_half;
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
|
|
|
case SPEED_10 + DUPLEX_FULL:
|
2008-07-11 22:17:08 +00:00
|
|
|
hw->forced_speed_duplex = e1000_10_full;
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
|
|
|
case SPEED_100 + DUPLEX_HALF:
|
2008-07-11 22:17:08 +00:00
|
|
|
hw->forced_speed_duplex = e1000_100_half;
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
|
|
|
case SPEED_100 + DUPLEX_FULL:
|
2008-07-11 22:17:08 +00:00
|
|
|
hw->forced_speed_duplex = e1000_100_full;
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
|
|
|
case SPEED_1000 + DUPLEX_FULL:
|
2008-07-11 22:17:08 +00:00
|
|
|
hw->autoneg = 1;
|
|
|
|
hw->autoneg_advertised = ADVERTISE_1000_FULL;
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
|
|
|
case SPEED_1000 + DUPLEX_HALF: /* not supported */
|
|
|
|
default:
|
2011-04-27 18:32:43 +00:00
|
|
|
goto err_inval;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2012-07-26 02:31:09 +00:00
|
|
|
|
|
|
|
/* clear MDI, MDI(-X) override is only allowed when autoneg enabled */
|
|
|
|
hw->mdix = AUTO_ALL_MODES;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
return 0;
|
2011-04-27 18:32:43 +00:00
|
|
|
|
|
|
|
err_inval:
|
|
|
|
e_err(probe, "Unsupported Speed/Duplex configuration\n");
|
|
|
|
return -EINVAL;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2009-04-15 17:43:24 +00:00
|
|
|
static int __e1000_shutdown(struct pci_dev *pdev, bool *enable_wake)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct net_device *netdev = pci_get_drvdata(pdev);
|
2005-06-18 00:41:45 +00:00
|
|
|
struct e1000_adapter *adapter = netdev_priv(netdev);
|
2008-07-11 22:17:08 +00:00
|
|
|
struct e1000_hw *hw = &adapter->hw;
|
2008-04-03 17:06:32 +00:00
|
|
|
u32 ctrl, ctrl_ext, rctl, status;
|
|
|
|
u32 wufc = adapter->wol;
|
2006-06-27 16:06:36 +00:00
|
|
|
#ifdef CONFIG_PM
|
2006-01-13 00:51:28 +00:00
|
|
|
int retval = 0;
|
2006-06-27 16:06:36 +00:00
|
|
|
#endif
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
netif_device_detach(netdev);
|
|
|
|
|
2006-06-27 16:06:28 +00:00
|
|
|
if (netif_running(netdev)) {
|
2013-11-23 07:07:40 +00:00
|
|
|
int count = E1000_CHECK_RESET_COUNT;
|
|
|
|
|
|
|
|
while (test_bit(__E1000_RESETTING, &adapter->flags) && count--)
|
|
|
|
usleep_range(10000, 20000);
|
|
|
|
|
2006-06-27 16:06:28 +00:00
|
|
|
WARN_ON(test_bit(__E1000_RESETTING, &adapter->flags));
|
2005-04-16 22:20:36 +00:00
|
|
|
e1000_down(adapter);
|
2006-06-27 16:06:28 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-01-18 21:01:34 +00:00
|
|
|
#ifdef CONFIG_PM
|
2007-02-16 22:39:28 +00:00
|
|
|
retval = pci_save_state(pdev);
|
2012-01-04 20:23:33 +00:00
|
|
|
if (retval)
|
2006-01-18 21:01:34 +00:00
|
|
|
return retval;
|
|
|
|
#endif
|
|
|
|
|
2008-07-11 22:17:08 +00:00
|
|
|
status = er32(STATUS);
|
2006-01-18 21:01:39 +00:00
|
|
|
if (status & E1000_STATUS_LU)
|
2005-04-16 22:20:36 +00:00
|
|
|
wufc &= ~E1000_WUFC_LNKC;
|
|
|
|
|
2006-01-18 21:01:39 +00:00
|
|
|
if (wufc) {
|
2005-04-16 22:20:36 +00:00
|
|
|
e1000_setup_rctl(adapter);
|
2007-11-14 04:54:59 +00:00
|
|
|
e1000_set_rx_mode(netdev);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2012-01-19 17:47:24 +00:00
|
|
|
rctl = er32(RCTL);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* turn on all-multi mode if wake on multicast is enabled */
|
2012-01-19 17:47:24 +00:00
|
|
|
if (wufc & E1000_WUFC_MC)
|
2005-04-16 22:20:36 +00:00
|
|
|
rctl |= E1000_RCTL_MPE;
|
2012-01-19 17:47:24 +00:00
|
|
|
|
|
|
|
/* enable receives in the hardware */
|
|
|
|
ew32(RCTL, rctl | E1000_RCTL_EN);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-07-11 22:17:08 +00:00
|
|
|
if (hw->mac_type >= e1000_82540) {
|
|
|
|
ctrl = er32(CTRL);
|
2005-04-16 22:20:36 +00:00
|
|
|
/* advertise wake from D3Cold */
|
|
|
|
#define E1000_CTRL_ADVD3WUC 0x00100000
|
|
|
|
/* phy power management enable */
|
|
|
|
#define E1000_CTRL_EN_PHY_PWR_MGMT 0x00200000
|
|
|
|
ctrl |= E1000_CTRL_ADVD3WUC |
|
|
|
|
E1000_CTRL_EN_PHY_PWR_MGMT;
|
2008-07-11 22:17:08 +00:00
|
|
|
ew32(CTRL, ctrl);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2008-07-11 22:17:08 +00:00
|
|
|
if (hw->media_type == e1000_media_type_fiber ||
|
2009-09-25 12:16:14 +00:00
|
|
|
hw->media_type == e1000_media_type_internal_serdes) {
|
2005-04-16 22:20:36 +00:00
|
|
|
/* keep the laser running in D3 */
|
2008-07-11 22:17:08 +00:00
|
|
|
ctrl_ext = er32(CTRL_EXT);
|
2005-04-16 22:20:36 +00:00
|
|
|
ctrl_ext |= E1000_CTRL_EXT_SDP7_DATA;
|
2008-07-11 22:17:08 +00:00
|
|
|
ew32(CTRL_EXT, ctrl_ext);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2008-07-11 22:17:08 +00:00
|
|
|
ew32(WUC, E1000_WUC_PME_EN);
|
|
|
|
ew32(WUFC, wufc);
|
2005-04-16 22:20:36 +00:00
|
|
|
} else {
|
2008-07-11 22:17:08 +00:00
|
|
|
ew32(WUC, 0);
|
|
|
|
ew32(WUFC, 0);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2006-12-15 15:56:10 +00:00
|
|
|
e1000_release_manageability(adapter);
|
|
|
|
|
2009-04-15 17:43:24 +00:00
|
|
|
*enable_wake = !!wufc;
|
|
|
|
|
2006-12-15 15:56:10 +00:00
|
|
|
/* make sure adapter isn't asleep if manageability is enabled */
|
2009-04-15 17:43:24 +00:00
|
|
|
if (adapter->en_mng_pt)
|
|
|
|
*enable_wake = true;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-11-06 16:57:12 +00:00
|
|
|
if (netif_running(netdev))
|
|
|
|
e1000_free_irq(adapter);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
pci_disable_device(pdev);
|
2006-01-13 00:51:28 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-01-18 21:01:34 +00:00
|
|
|
#ifdef CONFIG_PM
|
2009-04-15 17:43:24 +00:00
|
|
|
static int e1000_suspend(struct pci_dev *pdev, pm_message_t state)
|
|
|
|
{
|
|
|
|
int retval;
|
|
|
|
bool wake;
|
|
|
|
|
|
|
|
retval = __e1000_shutdown(pdev, &wake);
|
|
|
|
if (retval)
|
|
|
|
return retval;
|
|
|
|
|
|
|
|
if (wake) {
|
|
|
|
pci_prepare_to_sleep(pdev);
|
|
|
|
} else {
|
|
|
|
pci_wake_from_d3(pdev, false);
|
|
|
|
pci_set_power_state(pdev, PCI_D3hot);
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-07-11 22:17:02 +00:00
|
|
|
static int e1000_resume(struct pci_dev *pdev)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct net_device *netdev = pci_get_drvdata(pdev);
|
2005-06-18 00:41:45 +00:00
|
|
|
struct e1000_adapter *adapter = netdev_priv(netdev);
|
2008-07-11 22:17:08 +00:00
|
|
|
struct e1000_hw *hw = &adapter->hw;
|
2008-04-03 17:06:32 +00:00
|
|
|
u32 err;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-04-15 02:04:40 +00:00
|
|
|
pci_set_power_state(pdev, PCI_D0);
|
2007-02-16 22:39:28 +00:00
|
|
|
pci_restore_state(pdev);
|
2010-02-03 14:49:48 +00:00
|
|
|
pci_save_state(pdev);
|
2008-07-11 22:17:44 +00:00
|
|
|
|
|
|
|
if (adapter->need_ioport)
|
|
|
|
err = pci_enable_device(pdev);
|
|
|
|
else
|
|
|
|
err = pci_enable_device_mem(pdev);
|
2008-07-11 22:17:28 +00:00
|
|
|
if (err) {
|
2010-04-27 14:02:58 +00:00
|
|
|
pr_err("Cannot enable PCI device from suspend\n");
|
2006-08-28 21:56:27 +00:00
|
|
|
return err;
|
|
|
|
}
|
2005-04-29 02:41:28 +00:00
|
|
|
pci_set_master(pdev);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-04-15 02:04:40 +00:00
|
|
|
pci_enable_wake(pdev, PCI_D3hot, 0);
|
|
|
|
pci_enable_wake(pdev, PCI_D3cold, 0);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-07-11 22:17:28 +00:00
|
|
|
if (netif_running(netdev)) {
|
|
|
|
err = e1000_request_irq(adapter);
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
}
|
2006-11-06 16:57:12 +00:00
|
|
|
|
|
|
|
e1000_power_up_phy(adapter);
|
2005-04-16 22:20:36 +00:00
|
|
|
e1000_reset(adapter);
|
2008-07-11 22:17:08 +00:00
|
|
|
ew32(WUS, ~0);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-12-15 15:56:10 +00:00
|
|
|
e1000_init_manageability(adapter);
|
|
|
|
|
2006-01-18 21:01:39 +00:00
|
|
|
if (netif_running(netdev))
|
2005-04-16 22:20:36 +00:00
|
|
|
e1000_up(adapter);
|
|
|
|
|
|
|
|
netif_device_attach(netdev);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
#endif
|
2006-05-23 20:35:57 +00:00
|
|
|
|
|
|
|
static void e1000_shutdown(struct pci_dev *pdev)
|
|
|
|
{
|
2009-04-15 17:43:24 +00:00
|
|
|
bool wake;
|
|
|
|
|
|
|
|
__e1000_shutdown(pdev, &wake);
|
|
|
|
|
|
|
|
if (system_state == SYSTEM_POWER_OFF) {
|
|
|
|
pci_wake_from_d3(pdev, wake);
|
|
|
|
pci_set_power_state(pdev, PCI_D3hot);
|
|
|
|
}
|
2006-05-23 20:35:57 +00:00
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
#ifdef CONFIG_NET_POLL_CONTROLLER
|
2013-02-09 12:49:21 +00:00
|
|
|
/* Polling 'interrupt' - used by things like netconsole to send skbs
|
2005-04-16 22:20:36 +00:00
|
|
|
* without having to re-enable interrupts. It's not called while
|
|
|
|
* the interrupt routine is executing.
|
|
|
|
*/
|
2008-07-11 22:17:02 +00:00
|
|
|
static void e1000_netpoll(struct net_device *netdev)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2005-06-18 00:41:45 +00:00
|
|
|
struct e1000_adapter *adapter = netdev_priv(netdev);
|
2006-07-14 23:14:23 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
disable_irq(adapter->pdev->irq);
|
IRQ: Maintain regs pointer globally rather than passing to IRQ handlers
Maintain a per-CPU global "struct pt_regs *" variable which can be used instead
of passing regs around manually through all ~1800 interrupt handlers in the
Linux kernel.
The regs pointer is used in few places, but it potentially costs both stack
space and code to pass it around. On the FRV arch, removing the regs parameter
from all the genirq function results in a 20% speed up of the IRQ exit path
(ie: from leaving timer_interrupt() to leaving do_IRQ()).
Where appropriate, an arch may override the generic storage facility and do
something different with the variable. On FRV, for instance, the address is
maintained in GR28 at all times inside the kernel as part of general exception
handling.
Having looked over the code, it appears that the parameter may be handed down
through up to twenty or so layers of functions. Consider a USB character
device attached to a USB hub, attached to a USB controller that posts its
interrupts through a cascaded auxiliary interrupt controller. A character
device driver may want to pass regs to the sysrq handler through the input
layer which adds another few layers of parameter passing.
I've build this code with allyesconfig for x86_64 and i386. I've runtested the
main part of the code on FRV and i386, though I can't test most of the drivers.
I've also done partial conversion for powerpc and MIPS - these at least compile
with minimal configurations.
This will affect all archs. Mostly the changes should be relatively easy.
Take do_IRQ(), store the regs pointer at the beginning, saving the old one:
struct pt_regs *old_regs = set_irq_regs(regs);
And put the old one back at the end:
set_irq_regs(old_regs);
Don't pass regs through to generic_handle_irq() or __do_IRQ().
In timer_interrupt(), this sort of change will be necessary:
- update_process_times(user_mode(regs));
- profile_tick(CPU_PROFILING, regs);
+ update_process_times(user_mode(get_irq_regs()));
+ profile_tick(CPU_PROFILING);
I'd like to move update_process_times()'s use of get_irq_regs() into itself,
except that i386, alone of the archs, uses something other than user_mode().
Some notes on the interrupt handling in the drivers:
(*) input_dev() is now gone entirely. The regs pointer is no longer stored in
the input_dev struct.
(*) finish_unlinks() in drivers/usb/host/ohci-q.c needs checking. It does
something different depending on whether it's been supplied with a regs
pointer or not.
(*) Various IRQ handler function pointers have been moved to type
irq_handler_t.
Signed-Off-By: David Howells <dhowells@redhat.com>
(cherry picked from 1b16e7ac850969f38b375e511e3fa2f474a33867 commit)
2006-10-05 13:55:46 +00:00
|
|
|
e1000_intr(adapter->pdev->irq, netdev);
|
2005-04-16 22:20:36 +00:00
|
|
|
enable_irq(adapter->pdev->irq);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2006-06-08 16:30:24 +00:00
|
|
|
/**
|
|
|
|
* e1000_io_error_detected - called when PCI error is detected
|
|
|
|
* @pdev: Pointer to PCI device
|
2009-09-25 22:19:46 +00:00
|
|
|
* @state: The current pci connection state
|
2006-06-08 16:30:24 +00:00
|
|
|
*
|
|
|
|
* This function is called after a PCI bus error affecting
|
|
|
|
* this device has been detected.
|
|
|
|
*/
|
2008-07-11 22:17:02 +00:00
|
|
|
static pci_ers_result_t e1000_io_error_detected(struct pci_dev *pdev,
|
|
|
|
pci_channel_state_t state)
|
2006-06-08 16:30:24 +00:00
|
|
|
{
|
|
|
|
struct net_device *netdev = pci_get_drvdata(pdev);
|
2008-11-13 07:38:14 +00:00
|
|
|
struct e1000_adapter *adapter = netdev_priv(netdev);
|
2006-06-08 16:30:24 +00:00
|
|
|
|
|
|
|
netif_device_detach(netdev);
|
|
|
|
|
2009-06-30 12:46:13 +00:00
|
|
|
if (state == pci_channel_io_perm_failure)
|
|
|
|
return PCI_ERS_RESULT_DISCONNECT;
|
|
|
|
|
2006-06-08 16:30:24 +00:00
|
|
|
if (netif_running(netdev))
|
|
|
|
e1000_down(adapter);
|
2006-09-19 03:58:06 +00:00
|
|
|
pci_disable_device(pdev);
|
2006-06-08 16:30:24 +00:00
|
|
|
|
|
|
|
/* Request a slot slot reset. */
|
|
|
|
return PCI_ERS_RESULT_NEED_RESET;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* e1000_io_slot_reset - called after the pci bus has been reset.
|
|
|
|
* @pdev: Pointer to PCI device
|
|
|
|
*
|
|
|
|
* Restart the card from scratch, as if from a cold-boot. Implementation
|
|
|
|
* resembles the first-half of the e1000_resume routine.
|
|
|
|
*/
|
|
|
|
static pci_ers_result_t e1000_io_slot_reset(struct pci_dev *pdev)
|
|
|
|
{
|
|
|
|
struct net_device *netdev = pci_get_drvdata(pdev);
|
2008-11-13 07:38:14 +00:00
|
|
|
struct e1000_adapter *adapter = netdev_priv(netdev);
|
2008-07-11 22:17:08 +00:00
|
|
|
struct e1000_hw *hw = &adapter->hw;
|
2008-07-11 22:17:44 +00:00
|
|
|
int err;
|
2006-06-08 16:30:24 +00:00
|
|
|
|
2008-07-11 22:17:44 +00:00
|
|
|
if (adapter->need_ioport)
|
|
|
|
err = pci_enable_device(pdev);
|
|
|
|
else
|
|
|
|
err = pci_enable_device_mem(pdev);
|
|
|
|
if (err) {
|
2010-04-27 14:02:58 +00:00
|
|
|
pr_err("Cannot re-enable PCI device after reset.\n");
|
2006-06-08 16:30:24 +00:00
|
|
|
return PCI_ERS_RESULT_DISCONNECT;
|
|
|
|
}
|
|
|
|
pci_set_master(pdev);
|
|
|
|
|
2006-09-27 19:54:11 +00:00
|
|
|
pci_enable_wake(pdev, PCI_D3hot, 0);
|
|
|
|
pci_enable_wake(pdev, PCI_D3cold, 0);
|
2006-06-08 16:30:24 +00:00
|
|
|
|
|
|
|
e1000_reset(adapter);
|
2008-07-11 22:17:08 +00:00
|
|
|
ew32(WUS, ~0);
|
2006-06-08 16:30:24 +00:00
|
|
|
|
|
|
|
return PCI_ERS_RESULT_RECOVERED;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* e1000_io_resume - called when traffic can start flowing again.
|
|
|
|
* @pdev: Pointer to PCI device
|
|
|
|
*
|
|
|
|
* This callback is called when the error recovery driver tells us that
|
|
|
|
* its OK to resume normal operation. Implementation resembles the
|
|
|
|
* second-half of the e1000_resume routine.
|
|
|
|
*/
|
|
|
|
static void e1000_io_resume(struct pci_dev *pdev)
|
|
|
|
{
|
|
|
|
struct net_device *netdev = pci_get_drvdata(pdev);
|
2008-11-13 07:38:14 +00:00
|
|
|
struct e1000_adapter *adapter = netdev_priv(netdev);
|
2006-12-15 15:56:10 +00:00
|
|
|
|
|
|
|
e1000_init_manageability(adapter);
|
2006-06-08 16:30:24 +00:00
|
|
|
|
|
|
|
if (netif_running(netdev)) {
|
|
|
|
if (e1000_up(adapter)) {
|
2010-04-27 14:02:58 +00:00
|
|
|
pr_info("can't bring device back up after reset\n");
|
2006-06-08 16:30:24 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
netif_device_attach(netdev);
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* e1000_main.c */
|