2005-04-16 16:20:36 -06:00
|
|
|
/* typhoon.c: A Linux Ethernet device driver for 3Com 3CR990 family of NICs */
|
|
|
|
/*
|
|
|
|
Written 2002-2004 by David Dillow <dave@thedillows.org>
|
|
|
|
Based on code written 1998-2000 by Donald Becker <becker@scyld.com> and
|
|
|
|
Linux 2.2.x driver by David P. McLean <davidpmclean@yahoo.com>.
|
|
|
|
|
|
|
|
This software may be used and distributed according to the terms of
|
|
|
|
the GNU General Public License (GPL), incorporated herein by reference.
|
|
|
|
Drivers based on or derived from this code fall under the GPL and must
|
|
|
|
retain the authorship, copyright and license notice. This file is not
|
|
|
|
a complete program and may only be used when the entire operating
|
|
|
|
system is licensed under the GPL.
|
|
|
|
|
|
|
|
This software is available on a public web site. It may enable
|
|
|
|
cryptographic capabilities of the 3Com hardware, and may be
|
|
|
|
exported from the United States under License Exception "TSU"
|
|
|
|
pursuant to 15 C.F.R. Section 740.13(e).
|
|
|
|
|
|
|
|
This work was funded by the National Library of Medicine under
|
|
|
|
the Department of Energy project number 0274DD06D1 and NLM project
|
|
|
|
number Y1-LM-2015-01.
|
|
|
|
|
|
|
|
This driver is designed for the 3Com 3CR990 Family of cards with the
|
|
|
|
3XP Processor. It has been tested on x86 and sparc64.
|
|
|
|
|
|
|
|
KNOWN ISSUES:
|
|
|
|
*) The current firmware always strips the VLAN tag off, even if
|
|
|
|
we tell it not to. You should filter VLANs at the switch
|
|
|
|
as a workaround (good practice in any event) until we can
|
|
|
|
get this fixed.
|
|
|
|
*) Cannot DMA Rx packets to a 2 byte aligned address. Also firmware
|
|
|
|
issue. Hopefully 3Com will fix it.
|
|
|
|
*) Waiting for a command response takes 8ms due to non-preemptable
|
|
|
|
polling. Only significant for getting stats and creating
|
|
|
|
SAs, but an ugly wart never the less.
|
|
|
|
|
|
|
|
TODO:
|
|
|
|
*) Doesn't do IPSEC offloading. Yet. Keep yer pants on, it's coming.
|
|
|
|
*) Add more support for ethtool (especially for NIC stats)
|
|
|
|
*) Allow disabling of RX checksum offloading
|
|
|
|
*) Fix MAC changing to work while the interface is up
|
|
|
|
(Need to put commands on the TX ring, which changes
|
|
|
|
the locking)
|
|
|
|
*) Add in FCS to {rx,tx}_bytes, since the hardware doesn't. See
|
|
|
|
http://oss.sgi.com/cgi-bin/mesg.cgi?a=netdev&i=20031215152211.7003fe8e.rddunlap%40osdl.org
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* Set the copy breakpoint for the copy-only-tiny-frames scheme.
|
|
|
|
* Setting to > 1518 effectively disables this feature.
|
|
|
|
*/
|
|
|
|
static int rx_copybreak = 200;
|
|
|
|
|
|
|
|
/* Should we use MMIO or Port IO?
|
|
|
|
* 0: Port IO
|
|
|
|
* 1: MMIO
|
|
|
|
* 2: Try MMIO, fallback to Port IO
|
|
|
|
*/
|
|
|
|
static unsigned int use_mmio = 2;
|
|
|
|
|
|
|
|
/* end user-configurable values */
|
|
|
|
|
|
|
|
/* Maximum number of multicast addresses to filter (vs. rx-all-multicast).
|
|
|
|
*/
|
|
|
|
static const int multicast_filter_limit = 32;
|
|
|
|
|
|
|
|
/* Operational parameters that are set at compile time. */
|
|
|
|
|
|
|
|
/* Keep the ring sizes a power of two for compile efficiency.
|
|
|
|
* The compiler will convert <unsigned>'%'<2^N> into a bit mask.
|
|
|
|
* Making the Tx ring too large decreases the effectiveness of channel
|
|
|
|
* bonding and packet priority.
|
|
|
|
* There are no ill effects from too-large receive rings.
|
|
|
|
*
|
|
|
|
* We don't currently use the Hi Tx ring so, don't make it very big.
|
|
|
|
*
|
|
|
|
* Beware that if we start using the Hi Tx ring, we will need to change
|
|
|
|
* typhoon_num_free_tx() and typhoon_tx_complete() to account for that.
|
|
|
|
*/
|
|
|
|
#define TXHI_ENTRIES 2
|
|
|
|
#define TXLO_ENTRIES 128
|
|
|
|
#define RX_ENTRIES 32
|
|
|
|
#define COMMAND_ENTRIES 16
|
|
|
|
#define RESPONSE_ENTRIES 32
|
|
|
|
|
|
|
|
#define COMMAND_RING_SIZE (COMMAND_ENTRIES * sizeof(struct cmd_desc))
|
|
|
|
#define RESPONSE_RING_SIZE (RESPONSE_ENTRIES * sizeof(struct resp_desc))
|
|
|
|
|
|
|
|
/* The 3XP will preload and remove 64 entries from the free buffer
|
2006-09-13 11:24:59 -06:00
|
|
|
* list, and we need one entry to keep the ring from wrapping, so
|
2005-04-16 16:20:36 -06:00
|
|
|
* to keep this a power of two, we use 128 entries.
|
|
|
|
*/
|
|
|
|
#define RXFREE_ENTRIES 128
|
|
|
|
#define RXENT_ENTRIES (RXFREE_ENTRIES - 1)
|
|
|
|
|
|
|
|
/* Operational parameters that usually are not changed. */
|
|
|
|
|
|
|
|
/* Time in jiffies before concluding the transmitter is hung. */
|
|
|
|
#define TX_TIMEOUT (2*HZ)
|
|
|
|
|
|
|
|
#define PKT_BUF_SZ 1536
|
|
|
|
|
|
|
|
#define DRV_MODULE_NAME "typhoon"
|
2006-09-11 15:39:18 -06:00
|
|
|
#define DRV_MODULE_VERSION "1.5.8"
|
|
|
|
#define DRV_MODULE_RELDATE "06/11/09"
|
2005-04-16 16:20:36 -06:00
|
|
|
#define PFX DRV_MODULE_NAME ": "
|
|
|
|
#define ERR_PFX KERN_ERR PFX
|
|
|
|
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/string.h>
|
|
|
|
#include <linux/timer.h>
|
|
|
|
#include <linux/errno.h>
|
|
|
|
#include <linux/ioport.h>
|
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/interrupt.h>
|
|
|
|
#include <linux/pci.h>
|
|
|
|
#include <linux/netdevice.h>
|
|
|
|
#include <linux/etherdevice.h>
|
|
|
|
#include <linux/skbuff.h>
|
2006-12-03 21:15:30 -07:00
|
|
|
#include <linux/mm.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/delay.h>
|
|
|
|
#include <linux/ethtool.h>
|
|
|
|
#include <linux/if_vlan.h>
|
|
|
|
#include <linux/crc32.h>
|
|
|
|
#include <linux/bitops.h>
|
|
|
|
#include <asm/processor.h>
|
|
|
|
#include <asm/io.h>
|
|
|
|
#include <asm/uaccess.h>
|
|
|
|
#include <linux/in6.h>
|
|
|
|
#include <linux/dma-mapping.h>
|
|
|
|
|
|
|
|
#include "typhoon.h"
|
|
|
|
#include "typhoon-firmware.h"
|
|
|
|
|
2008-02-10 00:40:34 -07:00
|
|
|
static char version[] __devinitdata =
|
2005-04-16 16:20:36 -06:00
|
|
|
"typhoon.c: version " DRV_MODULE_VERSION " (" DRV_MODULE_RELDATE ")\n";
|
|
|
|
|
|
|
|
MODULE_AUTHOR("David Dillow <dave@thedillows.org>");
|
|
|
|
MODULE_VERSION(DRV_MODULE_VERSION);
|
|
|
|
MODULE_LICENSE("GPL");
|
|
|
|
MODULE_DESCRIPTION("3Com Typhoon Family (3C990, 3CR990, and variants)");
|
|
|
|
MODULE_PARM_DESC(rx_copybreak, "Packets smaller than this are copied and "
|
|
|
|
"the buffer given back to the NIC. Default "
|
|
|
|
"is 200.");
|
|
|
|
MODULE_PARM_DESC(use_mmio, "Use MMIO (1) or PIO(0) to access the NIC. "
|
|
|
|
"Default is to try MMIO and fallback to PIO.");
|
|
|
|
module_param(rx_copybreak, int, 0);
|
|
|
|
module_param(use_mmio, int, 0);
|
|
|
|
|
|
|
|
#if defined(NETIF_F_TSO) && MAX_SKB_FRAGS > 32
|
|
|
|
#warning Typhoon only supports 32 entries in its SG list for TSO, disabling TSO
|
|
|
|
#undef NETIF_F_TSO
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if TXLO_ENTRIES <= (2 * MAX_SKB_FRAGS)
|
|
|
|
#error TX ring too small!
|
|
|
|
#endif
|
|
|
|
|
|
|
|
struct typhoon_card_info {
|
|
|
|
char *name;
|
|
|
|
int capabilities;
|
|
|
|
};
|
|
|
|
|
|
|
|
#define TYPHOON_CRYPTO_NONE 0x00
|
|
|
|
#define TYPHOON_CRYPTO_DES 0x01
|
|
|
|
#define TYPHOON_CRYPTO_3DES 0x02
|
|
|
|
#define TYPHOON_CRYPTO_VARIABLE 0x04
|
|
|
|
#define TYPHOON_FIBER 0x08
|
|
|
|
#define TYPHOON_WAKEUP_NEEDS_RESET 0x10
|
|
|
|
|
|
|
|
enum typhoon_cards {
|
|
|
|
TYPHOON_TX = 0, TYPHOON_TX95, TYPHOON_TX97, TYPHOON_SVR,
|
|
|
|
TYPHOON_SVR95, TYPHOON_SVR97, TYPHOON_TXM, TYPHOON_BSVR,
|
|
|
|
TYPHOON_FX95, TYPHOON_FX97, TYPHOON_FX95SVR, TYPHOON_FX97SVR,
|
|
|
|
TYPHOON_FXM,
|
|
|
|
};
|
|
|
|
|
|
|
|
/* directly indexed by enum typhoon_cards, above */
|
2008-02-10 00:40:34 -07:00
|
|
|
static struct typhoon_card_info typhoon_card_info[] __devinitdata = {
|
2005-04-16 16:20:36 -06:00
|
|
|
{ "3Com Typhoon (3C990-TX)",
|
|
|
|
TYPHOON_CRYPTO_NONE},
|
|
|
|
{ "3Com Typhoon (3CR990-TX-95)",
|
|
|
|
TYPHOON_CRYPTO_DES},
|
|
|
|
{ "3Com Typhoon (3CR990-TX-97)",
|
|
|
|
TYPHOON_CRYPTO_DES | TYPHOON_CRYPTO_3DES},
|
|
|
|
{ "3Com Typhoon (3C990SVR)",
|
|
|
|
TYPHOON_CRYPTO_NONE},
|
|
|
|
{ "3Com Typhoon (3CR990SVR95)",
|
|
|
|
TYPHOON_CRYPTO_DES},
|
|
|
|
{ "3Com Typhoon (3CR990SVR97)",
|
|
|
|
TYPHOON_CRYPTO_DES | TYPHOON_CRYPTO_3DES},
|
|
|
|
{ "3Com Typhoon2 (3C990B-TX-M)",
|
|
|
|
TYPHOON_CRYPTO_VARIABLE},
|
|
|
|
{ "3Com Typhoon2 (3C990BSVR)",
|
|
|
|
TYPHOON_CRYPTO_VARIABLE},
|
|
|
|
{ "3Com Typhoon (3CR990-FX-95)",
|
|
|
|
TYPHOON_CRYPTO_DES | TYPHOON_FIBER},
|
|
|
|
{ "3Com Typhoon (3CR990-FX-97)",
|
|
|
|
TYPHOON_CRYPTO_DES | TYPHOON_CRYPTO_3DES | TYPHOON_FIBER},
|
|
|
|
{ "3Com Typhoon (3CR990-FX-95 Server)",
|
|
|
|
TYPHOON_CRYPTO_DES | TYPHOON_FIBER},
|
|
|
|
{ "3Com Typhoon (3CR990-FX-97 Server)",
|
|
|
|
TYPHOON_CRYPTO_DES | TYPHOON_CRYPTO_3DES | TYPHOON_FIBER},
|
|
|
|
{ "3Com Typhoon2 (3C990B-FX-97)",
|
|
|
|
TYPHOON_CRYPTO_VARIABLE | TYPHOON_FIBER},
|
|
|
|
};
|
|
|
|
|
|
|
|
/* Notes on the new subsystem numbering scheme:
|
2006-03-28 02:56:53 -07:00
|
|
|
* bits 0-1 indicate crypto capabilities: (0) variable, (1) DES, or (2) 3DES
|
2005-04-16 16:20:36 -06:00
|
|
|
* bit 4 indicates if this card has secured firmware (we don't support it)
|
|
|
|
* bit 8 indicates if this is a (0) copper or (1) fiber card
|
|
|
|
* bits 12-16 indicate card type: (0) client and (1) server
|
|
|
|
*/
|
|
|
|
static struct pci_device_id typhoon_pci_tbl[] = {
|
|
|
|
{ PCI_VENDOR_ID_3COM, PCI_DEVICE_ID_3COM_3CR990,
|
|
|
|
PCI_ANY_ID, PCI_ANY_ID, 0, 0,TYPHOON_TX },
|
|
|
|
{ PCI_VENDOR_ID_3COM, PCI_DEVICE_ID_3COM_3CR990_TX_95,
|
|
|
|
PCI_ANY_ID, PCI_ANY_ID, 0, 0, TYPHOON_TX95 },
|
|
|
|
{ PCI_VENDOR_ID_3COM, PCI_DEVICE_ID_3COM_3CR990_TX_97,
|
|
|
|
PCI_ANY_ID, PCI_ANY_ID, 0, 0, TYPHOON_TX97 },
|
|
|
|
{ PCI_VENDOR_ID_3COM, PCI_DEVICE_ID_3COM_3CR990B,
|
|
|
|
PCI_ANY_ID, 0x1000, 0, 0, TYPHOON_TXM },
|
|
|
|
{ PCI_VENDOR_ID_3COM, PCI_DEVICE_ID_3COM_3CR990B,
|
|
|
|
PCI_ANY_ID, 0x1102, 0, 0, TYPHOON_FXM },
|
|
|
|
{ PCI_VENDOR_ID_3COM, PCI_DEVICE_ID_3COM_3CR990B,
|
|
|
|
PCI_ANY_ID, 0x2000, 0, 0, TYPHOON_BSVR },
|
|
|
|
{ PCI_VENDOR_ID_3COM, PCI_DEVICE_ID_3COM_3CR990_FX,
|
|
|
|
PCI_ANY_ID, 0x1101, 0, 0, TYPHOON_FX95 },
|
|
|
|
{ PCI_VENDOR_ID_3COM, PCI_DEVICE_ID_3COM_3CR990_FX,
|
|
|
|
PCI_ANY_ID, 0x1102, 0, 0, TYPHOON_FX97 },
|
|
|
|
{ PCI_VENDOR_ID_3COM, PCI_DEVICE_ID_3COM_3CR990_FX,
|
|
|
|
PCI_ANY_ID, 0x2101, 0, 0, TYPHOON_FX95SVR },
|
|
|
|
{ PCI_VENDOR_ID_3COM, PCI_DEVICE_ID_3COM_3CR990_FX,
|
|
|
|
PCI_ANY_ID, 0x2102, 0, 0, TYPHOON_FX97SVR },
|
|
|
|
{ PCI_VENDOR_ID_3COM, PCI_DEVICE_ID_3COM_3CR990SVR95,
|
|
|
|
PCI_ANY_ID, PCI_ANY_ID, 0, 0, TYPHOON_SVR95 },
|
|
|
|
{ PCI_VENDOR_ID_3COM, PCI_DEVICE_ID_3COM_3CR990SVR97,
|
|
|
|
PCI_ANY_ID, PCI_ANY_ID, 0, 0, TYPHOON_SVR97 },
|
|
|
|
{ PCI_VENDOR_ID_3COM, PCI_DEVICE_ID_3COM_3CR990SVR,
|
|
|
|
PCI_ANY_ID, PCI_ANY_ID, 0, 0, TYPHOON_SVR },
|
|
|
|
{ 0, }
|
|
|
|
};
|
|
|
|
MODULE_DEVICE_TABLE(pci, typhoon_pci_tbl);
|
|
|
|
|
|
|
|
/* Define the shared memory area
|
|
|
|
* Align everything the 3XP will normally be using.
|
|
|
|
* We'll need to move/align txHi if we start using that ring.
|
|
|
|
*/
|
|
|
|
#define __3xp_aligned ____cacheline_aligned
|
|
|
|
struct typhoon_shared {
|
|
|
|
struct typhoon_interface iface;
|
|
|
|
struct typhoon_indexes indexes __3xp_aligned;
|
|
|
|
struct tx_desc txLo[TXLO_ENTRIES] __3xp_aligned;
|
|
|
|
struct rx_desc rxLo[RX_ENTRIES] __3xp_aligned;
|
|
|
|
struct rx_desc rxHi[RX_ENTRIES] __3xp_aligned;
|
|
|
|
struct cmd_desc cmd[COMMAND_ENTRIES] __3xp_aligned;
|
|
|
|
struct resp_desc resp[RESPONSE_ENTRIES] __3xp_aligned;
|
|
|
|
struct rx_free rxBuff[RXFREE_ENTRIES] __3xp_aligned;
|
|
|
|
u32 zeroWord;
|
|
|
|
struct tx_desc txHi[TXHI_ENTRIES];
|
|
|
|
} __attribute__ ((packed));
|
|
|
|
|
|
|
|
struct rxbuff_ent {
|
|
|
|
struct sk_buff *skb;
|
|
|
|
dma_addr_t dma_addr;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct typhoon {
|
|
|
|
/* Tx cache line section */
|
2006-09-13 11:24:59 -06:00
|
|
|
struct transmit_ring txLoRing ____cacheline_aligned;
|
2005-04-16 16:20:36 -06:00
|
|
|
struct pci_dev * tx_pdev;
|
|
|
|
void __iomem *tx_ioaddr;
|
|
|
|
u32 txlo_dma_addr;
|
|
|
|
|
|
|
|
/* Irq/Rx cache line section */
|
|
|
|
void __iomem *ioaddr ____cacheline_aligned;
|
|
|
|
struct typhoon_indexes *indexes;
|
|
|
|
u8 awaiting_resp;
|
|
|
|
u8 duplex;
|
|
|
|
u8 speed;
|
|
|
|
u8 card_state;
|
|
|
|
struct basic_ring rxLoRing;
|
|
|
|
struct pci_dev * pdev;
|
|
|
|
struct net_device * dev;
|
[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 17:41:36 -06:00
|
|
|
struct napi_struct napi;
|
2005-04-16 16:20:36 -06:00
|
|
|
spinlock_t state_lock;
|
|
|
|
struct vlan_group * vlgrp;
|
|
|
|
struct basic_ring rxHiRing;
|
|
|
|
struct basic_ring rxBuffRing;
|
|
|
|
struct rxbuff_ent rxbuffers[RXENT_ENTRIES];
|
|
|
|
|
|
|
|
/* general section */
|
|
|
|
spinlock_t command_lock ____cacheline_aligned;
|
|
|
|
struct basic_ring cmdRing;
|
|
|
|
struct basic_ring respRing;
|
|
|
|
struct net_device_stats stats;
|
|
|
|
struct net_device_stats stats_saved;
|
|
|
|
const char * name;
|
|
|
|
struct typhoon_shared * shared;
|
|
|
|
dma_addr_t shared_dma;
|
2007-08-22 22:44:39 -06:00
|
|
|
__le16 xcvr_select;
|
|
|
|
__le16 wol_events;
|
|
|
|
__le32 offload;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* unused stuff (future use) */
|
|
|
|
int capabilities;
|
|
|
|
struct transmit_ring txHiRing;
|
|
|
|
};
|
|
|
|
|
|
|
|
enum completion_wait_values {
|
|
|
|
NoWait = 0, WaitNoSleep, WaitSleep,
|
|
|
|
};
|
|
|
|
|
|
|
|
/* These are the values for the typhoon.card_state variable.
|
|
|
|
* These determine where the statistics will come from in get_stats().
|
|
|
|
* The sleep image does not support the statistics we need.
|
|
|
|
*/
|
|
|
|
enum state_values {
|
|
|
|
Sleeping = 0, Running,
|
|
|
|
};
|
|
|
|
|
|
|
|
/* PCI writes are not guaranteed to be posted in order, but outstanding writes
|
|
|
|
* cannot pass a read, so this forces current writes to post.
|
|
|
|
*/
|
|
|
|
#define typhoon_post_pci_writes(x) \
|
|
|
|
do { if(likely(use_mmio)) ioread32(x+TYPHOON_REG_HEARTBEAT); } while(0)
|
|
|
|
|
|
|
|
/* We'll wait up to six seconds for a reset, and half a second normally.
|
|
|
|
*/
|
|
|
|
#define TYPHOON_UDELAY 50
|
|
|
|
#define TYPHOON_RESET_TIMEOUT_SLEEP (6 * HZ)
|
|
|
|
#define TYPHOON_RESET_TIMEOUT_NOSLEEP ((6 * 1000000) / TYPHOON_UDELAY)
|
|
|
|
#define TYPHOON_WAIT_TIMEOUT ((1000000 / 2) / TYPHOON_UDELAY)
|
|
|
|
|
|
|
|
#if defined(NETIF_F_TSO)
|
2006-06-22 03:40:14 -06:00
|
|
|
#define skb_tso_size(x) (skb_shinfo(x)->gso_size)
|
2005-04-16 16:20:36 -06:00
|
|
|
#define TSO_NUM_DESCRIPTORS 2
|
|
|
|
#define TSO_OFFLOAD_ON TYPHOON_OFFLOAD_TCP_SEGMENT
|
|
|
|
#else
|
|
|
|
#define NETIF_F_TSO 0
|
|
|
|
#define skb_tso_size(x) 0
|
|
|
|
#define TSO_NUM_DESCRIPTORS 0
|
|
|
|
#define TSO_OFFLOAD_ON 0
|
|
|
|
#endif
|
|
|
|
|
|
|
|
static inline void
|
|
|
|
typhoon_inc_index(u32 *index, const int count, const int num_entries)
|
|
|
|
{
|
|
|
|
/* Increment a ring index -- we can use this for all rings execept
|
|
|
|
* the Rx rings, as they use different size descriptors
|
|
|
|
* otherwise, everything is the same size as a cmd_desc
|
|
|
|
*/
|
|
|
|
*index += count * sizeof(struct cmd_desc);
|
|
|
|
*index %= num_entries * sizeof(struct cmd_desc);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void
|
|
|
|
typhoon_inc_cmd_index(u32 *index, const int count)
|
|
|
|
{
|
|
|
|
typhoon_inc_index(index, count, COMMAND_ENTRIES);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void
|
|
|
|
typhoon_inc_resp_index(u32 *index, const int count)
|
|
|
|
{
|
|
|
|
typhoon_inc_index(index, count, RESPONSE_ENTRIES);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void
|
|
|
|
typhoon_inc_rxfree_index(u32 *index, const int count)
|
|
|
|
{
|
|
|
|
typhoon_inc_index(index, count, RXFREE_ENTRIES);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void
|
|
|
|
typhoon_inc_tx_index(u32 *index, const int count)
|
|
|
|
{
|
|
|
|
/* if we start using the Hi Tx ring, this needs updateing */
|
|
|
|
typhoon_inc_index(index, count, TXLO_ENTRIES);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void
|
|
|
|
typhoon_inc_rx_index(u32 *index, const int count)
|
|
|
|
{
|
|
|
|
/* sizeof(struct rx_desc) != sizeof(struct cmd_desc) */
|
|
|
|
*index += count * sizeof(struct rx_desc);
|
|
|
|
*index %= RX_ENTRIES * sizeof(struct rx_desc);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
typhoon_reset(void __iomem *ioaddr, int wait_type)
|
|
|
|
{
|
|
|
|
int i, err = 0;
|
|
|
|
int timeout;
|
|
|
|
|
|
|
|
if(wait_type == WaitNoSleep)
|
|
|
|
timeout = TYPHOON_RESET_TIMEOUT_NOSLEEP;
|
|
|
|
else
|
|
|
|
timeout = TYPHOON_RESET_TIMEOUT_SLEEP;
|
|
|
|
|
|
|
|
iowrite32(TYPHOON_INTR_ALL, ioaddr + TYPHOON_REG_INTR_MASK);
|
|
|
|
iowrite32(TYPHOON_INTR_ALL, ioaddr + TYPHOON_REG_INTR_STATUS);
|
|
|
|
|
|
|
|
iowrite32(TYPHOON_RESET_ALL, ioaddr + TYPHOON_REG_SOFT_RESET);
|
|
|
|
typhoon_post_pci_writes(ioaddr);
|
|
|
|
udelay(1);
|
|
|
|
iowrite32(TYPHOON_RESET_NONE, ioaddr + TYPHOON_REG_SOFT_RESET);
|
|
|
|
|
|
|
|
if(wait_type != NoWait) {
|
|
|
|
for(i = 0; i < timeout; i++) {
|
|
|
|
if(ioread32(ioaddr + TYPHOON_REG_STATUS) ==
|
|
|
|
TYPHOON_STATUS_WAITING_FOR_HOST)
|
|
|
|
goto out;
|
|
|
|
|
2005-09-11 03:09:55 -06:00
|
|
|
if(wait_type == WaitSleep)
|
|
|
|
schedule_timeout_uninterruptible(1);
|
|
|
|
else
|
2005-04-16 16:20:36 -06:00
|
|
|
udelay(TYPHOON_UDELAY);
|
|
|
|
}
|
|
|
|
|
|
|
|
err = -ETIMEDOUT;
|
|
|
|
}
|
|
|
|
|
|
|
|
out:
|
|
|
|
iowrite32(TYPHOON_INTR_ALL, ioaddr + TYPHOON_REG_INTR_MASK);
|
|
|
|
iowrite32(TYPHOON_INTR_ALL, ioaddr + TYPHOON_REG_INTR_STATUS);
|
|
|
|
|
|
|
|
/* The 3XP seems to need a little extra time to complete the load
|
|
|
|
* of the sleep image before we can reliably boot it. Failure to
|
|
|
|
* do this occasionally results in a hung adapter after boot in
|
|
|
|
* typhoon_init_one() while trying to read the MAC address or
|
|
|
|
* putting the card to sleep. 3Com's driver waits 5ms, but
|
|
|
|
* that seems to be overkill. However, if we can sleep, we might
|
|
|
|
* as well give it that much time. Otherwise, we'll give it 500us,
|
|
|
|
* which should be enough (I've see it work well at 100us, but still
|
|
|
|
* saw occasional problems.)
|
|
|
|
*/
|
|
|
|
if(wait_type == WaitSleep)
|
|
|
|
msleep(5);
|
|
|
|
else
|
|
|
|
udelay(500);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
typhoon_wait_status(void __iomem *ioaddr, u32 wait_value)
|
|
|
|
{
|
|
|
|
int i, err = 0;
|
|
|
|
|
|
|
|
for(i = 0; i < TYPHOON_WAIT_TIMEOUT; i++) {
|
|
|
|
if(ioread32(ioaddr + TYPHOON_REG_STATUS) == wait_value)
|
|
|
|
goto out;
|
|
|
|
udelay(TYPHOON_UDELAY);
|
|
|
|
}
|
|
|
|
|
|
|
|
err = -ETIMEDOUT;
|
|
|
|
|
|
|
|
out:
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void
|
|
|
|
typhoon_media_status(struct net_device *dev, struct resp_desc *resp)
|
|
|
|
{
|
|
|
|
if(resp->parm1 & TYPHOON_MEDIA_STAT_NO_LINK)
|
|
|
|
netif_carrier_off(dev);
|
|
|
|
else
|
|
|
|
netif_carrier_on(dev);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void
|
|
|
|
typhoon_hello(struct typhoon *tp)
|
|
|
|
{
|
|
|
|
struct basic_ring *ring = &tp->cmdRing;
|
|
|
|
struct cmd_desc *cmd;
|
|
|
|
|
|
|
|
/* We only get a hello request if we've not sent anything to the
|
|
|
|
* card in a long while. If the lock is held, then we're in the
|
|
|
|
* process of issuing a command, so we don't need to respond.
|
|
|
|
*/
|
|
|
|
if(spin_trylock(&tp->command_lock)) {
|
|
|
|
cmd = (struct cmd_desc *)(ring->ringBase + ring->lastWrite);
|
|
|
|
typhoon_inc_cmd_index(&ring->lastWrite, 1);
|
|
|
|
|
|
|
|
INIT_COMMAND_NO_RESPONSE(cmd, TYPHOON_CMD_HELLO_RESP);
|
|
|
|
smp_wmb();
|
|
|
|
iowrite32(ring->lastWrite, tp->ioaddr + TYPHOON_REG_CMD_READY);
|
|
|
|
spin_unlock(&tp->command_lock);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
typhoon_process_response(struct typhoon *tp, int resp_size,
|
|
|
|
struct resp_desc *resp_save)
|
|
|
|
{
|
|
|
|
struct typhoon_indexes *indexes = tp->indexes;
|
|
|
|
struct resp_desc *resp;
|
|
|
|
u8 *base = tp->respRing.ringBase;
|
|
|
|
int count, len, wrap_len;
|
|
|
|
u32 cleared;
|
|
|
|
u32 ready;
|
|
|
|
|
|
|
|
cleared = le32_to_cpu(indexes->respCleared);
|
|
|
|
ready = le32_to_cpu(indexes->respReady);
|
|
|
|
while(cleared != ready) {
|
|
|
|
resp = (struct resp_desc *)(base + cleared);
|
|
|
|
count = resp->numDesc + 1;
|
|
|
|
if(resp_save && resp->seqNo) {
|
|
|
|
if(count > resp_size) {
|
|
|
|
resp_save->flags = TYPHOON_RESP_ERROR;
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
|
|
|
wrap_len = 0;
|
|
|
|
len = count * sizeof(*resp);
|
|
|
|
if(unlikely(cleared + len > RESPONSE_RING_SIZE)) {
|
|
|
|
wrap_len = cleared + len - RESPONSE_RING_SIZE;
|
|
|
|
len = RESPONSE_RING_SIZE - cleared;
|
|
|
|
}
|
|
|
|
|
|
|
|
memcpy(resp_save, resp, len);
|
|
|
|
if(unlikely(wrap_len)) {
|
|
|
|
resp_save += len / sizeof(*resp);
|
|
|
|
memcpy(resp_save, base, wrap_len);
|
|
|
|
}
|
|
|
|
|
|
|
|
resp_save = NULL;
|
|
|
|
} else if(resp->cmd == TYPHOON_CMD_READ_MEDIA_STATUS) {
|
|
|
|
typhoon_media_status(tp->dev, resp);
|
|
|
|
} else if(resp->cmd == TYPHOON_CMD_HELLO_RESP) {
|
|
|
|
typhoon_hello(tp);
|
|
|
|
} else {
|
|
|
|
printk(KERN_ERR "%s: dumping unexpected response "
|
|
|
|
"0x%04x:%d:0x%02x:0x%04x:%08x:%08x\n",
|
|
|
|
tp->name, le16_to_cpu(resp->cmd),
|
|
|
|
resp->numDesc, resp->flags,
|
|
|
|
le16_to_cpu(resp->parm1),
|
|
|
|
le32_to_cpu(resp->parm2),
|
|
|
|
le32_to_cpu(resp->parm3));
|
|
|
|
}
|
|
|
|
|
|
|
|
cleanup:
|
|
|
|
typhoon_inc_resp_index(&cleared, count);
|
|
|
|
}
|
|
|
|
|
|
|
|
indexes->respCleared = cpu_to_le32(cleared);
|
|
|
|
wmb();
|
|
|
|
return (resp_save == NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int
|
|
|
|
typhoon_num_free(int lastWrite, int lastRead, int ringSize)
|
|
|
|
{
|
|
|
|
/* this works for all descriptors but rx_desc, as they are a
|
|
|
|
* different size than the cmd_desc -- everyone else is the same
|
|
|
|
*/
|
|
|
|
lastWrite /= sizeof(struct cmd_desc);
|
|
|
|
lastRead /= sizeof(struct cmd_desc);
|
|
|
|
return (ringSize + lastRead - lastWrite - 1) % ringSize;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int
|
|
|
|
typhoon_num_free_cmd(struct typhoon *tp)
|
|
|
|
{
|
|
|
|
int lastWrite = tp->cmdRing.lastWrite;
|
|
|
|
int cmdCleared = le32_to_cpu(tp->indexes->cmdCleared);
|
|
|
|
|
|
|
|
return typhoon_num_free(lastWrite, cmdCleared, COMMAND_ENTRIES);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int
|
|
|
|
typhoon_num_free_resp(struct typhoon *tp)
|
|
|
|
{
|
|
|
|
int respReady = le32_to_cpu(tp->indexes->respReady);
|
|
|
|
int respCleared = le32_to_cpu(tp->indexes->respCleared);
|
|
|
|
|
|
|
|
return typhoon_num_free(respReady, respCleared, RESPONSE_ENTRIES);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int
|
|
|
|
typhoon_num_free_tx(struct transmit_ring *ring)
|
|
|
|
{
|
|
|
|
/* if we start using the Hi Tx ring, this needs updating */
|
|
|
|
return typhoon_num_free(ring->lastWrite, ring->lastRead, TXLO_ENTRIES);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
typhoon_issue_command(struct typhoon *tp, int num_cmd, struct cmd_desc *cmd,
|
|
|
|
int num_resp, struct resp_desc *resp)
|
|
|
|
{
|
|
|
|
struct typhoon_indexes *indexes = tp->indexes;
|
|
|
|
struct basic_ring *ring = &tp->cmdRing;
|
|
|
|
struct resp_desc local_resp;
|
|
|
|
int i, err = 0;
|
|
|
|
int got_resp;
|
|
|
|
int freeCmd, freeResp;
|
|
|
|
int len, wrap_len;
|
|
|
|
|
|
|
|
spin_lock(&tp->command_lock);
|
|
|
|
|
|
|
|
freeCmd = typhoon_num_free_cmd(tp);
|
|
|
|
freeResp = typhoon_num_free_resp(tp);
|
|
|
|
|
|
|
|
if(freeCmd < num_cmd || freeResp < num_resp) {
|
|
|
|
printk("%s: no descs for cmd, had (needed) %d (%d) cmd, "
|
|
|
|
"%d (%d) resp\n", tp->name, freeCmd, num_cmd,
|
|
|
|
freeResp, num_resp);
|
|
|
|
err = -ENOMEM;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if(cmd->flags & TYPHOON_CMD_RESPOND) {
|
|
|
|
/* If we're expecting a response, but the caller hasn't given
|
|
|
|
* us a place to put it, we'll provide one.
|
|
|
|
*/
|
|
|
|
tp->awaiting_resp = 1;
|
|
|
|
if(resp == NULL) {
|
|
|
|
resp = &local_resp;
|
|
|
|
num_resp = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
wrap_len = 0;
|
|
|
|
len = num_cmd * sizeof(*cmd);
|
|
|
|
if(unlikely(ring->lastWrite + len > COMMAND_RING_SIZE)) {
|
|
|
|
wrap_len = ring->lastWrite + len - COMMAND_RING_SIZE;
|
|
|
|
len = COMMAND_RING_SIZE - ring->lastWrite;
|
|
|
|
}
|
|
|
|
|
|
|
|
memcpy(ring->ringBase + ring->lastWrite, cmd, len);
|
|
|
|
if(unlikely(wrap_len)) {
|
|
|
|
struct cmd_desc *wrap_ptr = cmd;
|
|
|
|
wrap_ptr += len / sizeof(*cmd);
|
|
|
|
memcpy(ring->ringBase, wrap_ptr, wrap_len);
|
|
|
|
}
|
|
|
|
|
|
|
|
typhoon_inc_cmd_index(&ring->lastWrite, num_cmd);
|
|
|
|
|
2007-05-09 00:57:56 -06:00
|
|
|
/* "I feel a presence... another warrior is on the mesa."
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
wmb();
|
|
|
|
iowrite32(ring->lastWrite, tp->ioaddr + TYPHOON_REG_CMD_READY);
|
|
|
|
typhoon_post_pci_writes(tp->ioaddr);
|
|
|
|
|
|
|
|
if((cmd->flags & TYPHOON_CMD_RESPOND) == 0)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
/* Ugh. We'll be here about 8ms, spinning our thumbs, unable to
|
|
|
|
* preempt or do anything other than take interrupts. So, don't
|
|
|
|
* wait for a response unless you have to.
|
|
|
|
*
|
|
|
|
* I've thought about trying to sleep here, but we're called
|
|
|
|
* from many contexts that don't allow that. Also, given the way
|
|
|
|
* 3Com has implemented irq coalescing, we would likely timeout --
|
|
|
|
* this has been observed in real life!
|
|
|
|
*
|
|
|
|
* The big killer is we have to wait to get stats from the card,
|
|
|
|
* though we could go to a periodic refresh of those if we don't
|
|
|
|
* mind them getting somewhat stale. The rest of the waiting
|
|
|
|
* commands occur during open/close/suspend/resume, so they aren't
|
|
|
|
* time critical. Creating SAs in the future will also have to
|
|
|
|
* wait here.
|
|
|
|
*/
|
|
|
|
got_resp = 0;
|
|
|
|
for(i = 0; i < TYPHOON_WAIT_TIMEOUT && !got_resp; i++) {
|
|
|
|
if(indexes->respCleared != indexes->respReady)
|
|
|
|
got_resp = typhoon_process_response(tp, num_resp,
|
|
|
|
resp);
|
|
|
|
udelay(TYPHOON_UDELAY);
|
|
|
|
}
|
|
|
|
|
|
|
|
if(!got_resp) {
|
|
|
|
err = -ETIMEDOUT;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Collect the error response even if we don't care about the
|
|
|
|
* rest of the response
|
|
|
|
*/
|
|
|
|
if(resp->flags & TYPHOON_RESP_ERROR)
|
|
|
|
err = -EIO;
|
|
|
|
|
|
|
|
out:
|
|
|
|
if(tp->awaiting_resp) {
|
|
|
|
tp->awaiting_resp = 0;
|
|
|
|
smp_wmb();
|
|
|
|
|
|
|
|
/* Ugh. If a response was added to the ring between
|
|
|
|
* the call to typhoon_process_response() and the clearing
|
|
|
|
* of tp->awaiting_resp, we could have missed the interrupt
|
|
|
|
* and it could hang in the ring an indeterminate amount of
|
|
|
|
* time. So, check for it, and interrupt ourselves if this
|
|
|
|
* is the case.
|
|
|
|
*/
|
|
|
|
if(indexes->respCleared != indexes->respReady)
|
|
|
|
iowrite32(1, tp->ioaddr + TYPHOON_REG_SELF_INTERRUPT);
|
|
|
|
}
|
|
|
|
|
|
|
|
spin_unlock(&tp->command_lock);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
typhoon_vlan_rx_register(struct net_device *dev, struct vlan_group *grp)
|
|
|
|
{
|
|
|
|
struct typhoon *tp = netdev_priv(dev);
|
|
|
|
struct cmd_desc xp_cmd;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
spin_lock_bh(&tp->state_lock);
|
|
|
|
if(!tp->vlgrp != !grp) {
|
|
|
|
/* We've either been turned on for the first time, or we've
|
|
|
|
* been turned off. Update the 3XP.
|
|
|
|
*/
|
|
|
|
if(grp)
|
|
|
|
tp->offload |= TYPHOON_OFFLOAD_VLAN;
|
|
|
|
else
|
|
|
|
tp->offload &= ~TYPHOON_OFFLOAD_VLAN;
|
|
|
|
|
|
|
|
/* If the interface is up, the runtime is running -- and we
|
|
|
|
* must be up for the vlan core to call us.
|
|
|
|
*
|
|
|
|
* Do the command outside of the spin lock, as it is slow.
|
|
|
|
*/
|
|
|
|
INIT_COMMAND_WITH_RESPONSE(&xp_cmd,
|
|
|
|
TYPHOON_CMD_SET_OFFLOAD_TASKS);
|
|
|
|
xp_cmd.parm2 = tp->offload;
|
|
|
|
xp_cmd.parm3 = tp->offload;
|
|
|
|
spin_unlock_bh(&tp->state_lock);
|
|
|
|
err = typhoon_issue_command(tp, 1, &xp_cmd, 0, NULL);
|
|
|
|
if(err < 0)
|
|
|
|
printk("%s: vlan offload error %d\n", tp->name, -err);
|
|
|
|
spin_lock_bh(&tp->state_lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* now make the change visible */
|
|
|
|
tp->vlgrp = grp;
|
|
|
|
spin_unlock_bh(&tp->state_lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void
|
|
|
|
typhoon_tso_fill(struct sk_buff *skb, struct transmit_ring *txRing,
|
|
|
|
u32 ring_dma)
|
|
|
|
{
|
|
|
|
struct tcpopt_desc *tcpd;
|
|
|
|
u32 tcpd_offset = ring_dma;
|
|
|
|
|
|
|
|
tcpd = (struct tcpopt_desc *) (txRing->ringBase + txRing->lastWrite);
|
|
|
|
tcpd_offset += txRing->lastWrite;
|
|
|
|
tcpd_offset += offsetof(struct tcpopt_desc, bytesTx);
|
|
|
|
typhoon_inc_tx_index(&txRing->lastWrite, 1);
|
|
|
|
|
|
|
|
tcpd->flags = TYPHOON_OPT_DESC | TYPHOON_OPT_TCP_SEG;
|
|
|
|
tcpd->numDesc = 1;
|
|
|
|
tcpd->mss_flags = cpu_to_le16(skb_tso_size(skb));
|
|
|
|
tcpd->mss_flags |= TYPHOON_TSO_FIRST | TYPHOON_TSO_LAST;
|
|
|
|
tcpd->respAddrLo = cpu_to_le32(tcpd_offset);
|
|
|
|
tcpd->bytesTx = cpu_to_le32(skb->len);
|
|
|
|
tcpd->status = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
typhoon_start_tx(struct sk_buff *skb, struct net_device *dev)
|
|
|
|
{
|
|
|
|
struct typhoon *tp = netdev_priv(dev);
|
|
|
|
struct transmit_ring *txRing;
|
|
|
|
struct tx_desc *txd, *first_txd;
|
|
|
|
dma_addr_t skb_dma;
|
|
|
|
int numDesc;
|
|
|
|
|
|
|
|
/* we have two rings to choose from, but we only use txLo for now
|
|
|
|
* If we start using the Hi ring as well, we'll need to update
|
|
|
|
* typhoon_stop_runtime(), typhoon_interrupt(), typhoon_num_free_tx(),
|
2006-03-28 02:56:53 -07:00
|
|
|
* and TXHI_ENTRIES to match, as well as update the TSO code below
|
2005-04-16 16:20:36 -06:00
|
|
|
* to get the right DMA address
|
|
|
|
*/
|
|
|
|
txRing = &tp->txLoRing;
|
|
|
|
|
|
|
|
/* We need one descriptor for each fragment of the sk_buff, plus the
|
|
|
|
* one for the ->data area of it.
|
|
|
|
*
|
|
|
|
* The docs say a maximum of 16 fragment descriptors per TCP option
|
|
|
|
* descriptor, then make a new packet descriptor and option descriptor
|
|
|
|
* for the next 16 fragments. The engineers say just an option
|
|
|
|
* descriptor is needed. I've tested up to 26 fragments with a single
|
|
|
|
* packet descriptor/option descriptor combo, so I use that for now.
|
|
|
|
*
|
|
|
|
* If problems develop with TSO, check this first.
|
|
|
|
*/
|
|
|
|
numDesc = skb_shinfo(skb)->nr_frags + 1;
|
2006-07-08 14:34:32 -06:00
|
|
|
if (skb_is_gso(skb))
|
2005-04-16 16:20:36 -06:00
|
|
|
numDesc++;
|
|
|
|
|
|
|
|
/* When checking for free space in the ring, we need to also
|
|
|
|
* account for the initial Tx descriptor, and we always must leave
|
|
|
|
* at least one descriptor unused in the ring so that it doesn't
|
|
|
|
* wrap and look empty.
|
|
|
|
*
|
|
|
|
* The only time we should loop here is when we hit the race
|
|
|
|
* between marking the queue awake and updating the cleared index.
|
|
|
|
* Just loop and it will appear. This comes from the acenic driver.
|
|
|
|
*/
|
|
|
|
while(unlikely(typhoon_num_free_tx(txRing) < (numDesc + 2)))
|
|
|
|
smp_rmb();
|
|
|
|
|
|
|
|
first_txd = (struct tx_desc *) (txRing->ringBase + txRing->lastWrite);
|
|
|
|
typhoon_inc_tx_index(&txRing->lastWrite, 1);
|
|
|
|
|
|
|
|
first_txd->flags = TYPHOON_TX_DESC | TYPHOON_DESC_VALID;
|
|
|
|
first_txd->numDesc = 0;
|
|
|
|
first_txd->len = 0;
|
2007-12-20 23:21:14 -07:00
|
|
|
first_txd->tx_addr = (u64)((unsigned long) skb);
|
2005-04-16 16:20:36 -06:00
|
|
|
first_txd->processFlags = 0;
|
|
|
|
|
2006-08-29 17:44:56 -06:00
|
|
|
if(skb->ip_summed == CHECKSUM_PARTIAL) {
|
2005-04-16 16:20:36 -06:00
|
|
|
/* The 3XP will figure out if this is UDP/TCP */
|
|
|
|
first_txd->processFlags |= TYPHOON_TX_PF_TCP_CHKSUM;
|
|
|
|
first_txd->processFlags |= TYPHOON_TX_PF_UDP_CHKSUM;
|
|
|
|
first_txd->processFlags |= TYPHOON_TX_PF_IP_CHKSUM;
|
|
|
|
}
|
|
|
|
|
|
|
|
if(vlan_tx_tag_present(skb)) {
|
|
|
|
first_txd->processFlags |=
|
|
|
|
TYPHOON_TX_PF_INSERT_VLAN | TYPHOON_TX_PF_VLAN_PRIORITY;
|
|
|
|
first_txd->processFlags |=
|
2007-08-22 22:44:39 -06:00
|
|
|
cpu_to_le32(ntohs(vlan_tx_tag_get(skb)) <<
|
2005-04-16 16:20:36 -06:00
|
|
|
TYPHOON_TX_PF_VLAN_TAG_SHIFT);
|
|
|
|
}
|
|
|
|
|
2006-07-08 14:34:32 -06:00
|
|
|
if (skb_is_gso(skb)) {
|
2005-04-16 16:20:36 -06:00
|
|
|
first_txd->processFlags |= TYPHOON_TX_PF_TCP_SEGMENT;
|
|
|
|
first_txd->numDesc++;
|
|
|
|
|
|
|
|
typhoon_tso_fill(skb, txRing, tp->txlo_dma_addr);
|
|
|
|
}
|
|
|
|
|
|
|
|
txd = (struct tx_desc *) (txRing->ringBase + txRing->lastWrite);
|
|
|
|
typhoon_inc_tx_index(&txRing->lastWrite, 1);
|
|
|
|
|
|
|
|
/* No need to worry about padding packet -- the firmware pads
|
|
|
|
* it with zeros to ETH_ZLEN for us.
|
|
|
|
*/
|
|
|
|
if(skb_shinfo(skb)->nr_frags == 0) {
|
|
|
|
skb_dma = pci_map_single(tp->tx_pdev, skb->data, skb->len,
|
|
|
|
PCI_DMA_TODEVICE);
|
|
|
|
txd->flags = TYPHOON_FRAG_DESC | TYPHOON_DESC_VALID;
|
|
|
|
txd->len = cpu_to_le16(skb->len);
|
2007-12-20 23:21:14 -07:00
|
|
|
txd->frag.addr = cpu_to_le32(skb_dma);
|
|
|
|
txd->frag.addrHi = 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
first_txd->numDesc++;
|
|
|
|
} else {
|
|
|
|
int i, len;
|
|
|
|
|
|
|
|
len = skb_headlen(skb);
|
|
|
|
skb_dma = pci_map_single(tp->tx_pdev, skb->data, len,
|
|
|
|
PCI_DMA_TODEVICE);
|
|
|
|
txd->flags = TYPHOON_FRAG_DESC | TYPHOON_DESC_VALID;
|
|
|
|
txd->len = cpu_to_le16(len);
|
2007-12-20 23:21:14 -07:00
|
|
|
txd->frag.addr = cpu_to_le32(skb_dma);
|
|
|
|
txd->frag.addrHi = 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
first_txd->numDesc++;
|
|
|
|
|
|
|
|
for(i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
|
|
|
|
skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
|
|
|
|
void *frag_addr;
|
|
|
|
|
|
|
|
txd = (struct tx_desc *) (txRing->ringBase +
|
|
|
|
txRing->lastWrite);
|
|
|
|
typhoon_inc_tx_index(&txRing->lastWrite, 1);
|
|
|
|
|
|
|
|
len = frag->size;
|
|
|
|
frag_addr = (void *) page_address(frag->page) +
|
|
|
|
frag->page_offset;
|
|
|
|
skb_dma = pci_map_single(tp->tx_pdev, frag_addr, len,
|
|
|
|
PCI_DMA_TODEVICE);
|
|
|
|
txd->flags = TYPHOON_FRAG_DESC | TYPHOON_DESC_VALID;
|
|
|
|
txd->len = cpu_to_le16(len);
|
2007-12-20 23:21:14 -07:00
|
|
|
txd->frag.addr = cpu_to_le32(skb_dma);
|
|
|
|
txd->frag.addrHi = 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
first_txd->numDesc++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Kick the 3XP
|
|
|
|
*/
|
|
|
|
wmb();
|
|
|
|
iowrite32(txRing->lastWrite, tp->tx_ioaddr + txRing->writeRegister);
|
|
|
|
|
|
|
|
dev->trans_start = jiffies;
|
|
|
|
|
|
|
|
/* If we don't have room to put the worst case packet on the
|
|
|
|
* queue, then we must stop the queue. We need 2 extra
|
|
|
|
* descriptors -- one to prevent ring wrap, and one for the
|
|
|
|
* Tx header.
|
|
|
|
*/
|
|
|
|
numDesc = MAX_SKB_FRAGS + TSO_NUM_DESCRIPTORS + 1;
|
|
|
|
|
|
|
|
if(typhoon_num_free_tx(txRing) < (numDesc + 2)) {
|
|
|
|
netif_stop_queue(dev);
|
|
|
|
|
|
|
|
/* A Tx complete IRQ could have gotten inbetween, making
|
|
|
|
* the ring free again. Only need to recheck here, since
|
|
|
|
* Tx is serialized.
|
|
|
|
*/
|
|
|
|
if(typhoon_num_free_tx(txRing) >= (numDesc + 2))
|
|
|
|
netif_wake_queue(dev);
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
typhoon_set_rx_mode(struct net_device *dev)
|
|
|
|
{
|
|
|
|
struct typhoon *tp = netdev_priv(dev);
|
|
|
|
struct cmd_desc xp_cmd;
|
|
|
|
u32 mc_filter[2];
|
2007-08-22 22:44:39 -06:00
|
|
|
__le16 filter;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
filter = TYPHOON_RX_FILTER_DIRECTED | TYPHOON_RX_FILTER_BROADCAST;
|
|
|
|
if(dev->flags & IFF_PROMISC) {
|
|
|
|
filter |= TYPHOON_RX_FILTER_PROMISCOUS;
|
|
|
|
} else if((dev->mc_count > multicast_filter_limit) ||
|
|
|
|
(dev->flags & IFF_ALLMULTI)) {
|
|
|
|
/* Too many to match, or accept all multicasts. */
|
|
|
|
filter |= TYPHOON_RX_FILTER_ALL_MCAST;
|
|
|
|
} else if(dev->mc_count) {
|
|
|
|
struct dev_mc_list *mclist;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
memset(mc_filter, 0, sizeof(mc_filter));
|
|
|
|
for(i = 0, mclist = dev->mc_list; mclist && i < dev->mc_count;
|
|
|
|
i++, mclist = mclist->next) {
|
|
|
|
int bit = ether_crc(ETH_ALEN, mclist->dmi_addr) & 0x3f;
|
|
|
|
mc_filter[bit >> 5] |= 1 << (bit & 0x1f);
|
|
|
|
}
|
|
|
|
|
|
|
|
INIT_COMMAND_NO_RESPONSE(&xp_cmd,
|
|
|
|
TYPHOON_CMD_SET_MULTICAST_HASH);
|
|
|
|
xp_cmd.parm1 = TYPHOON_MCAST_HASH_SET;
|
|
|
|
xp_cmd.parm2 = cpu_to_le32(mc_filter[0]);
|
|
|
|
xp_cmd.parm3 = cpu_to_le32(mc_filter[1]);
|
|
|
|
typhoon_issue_command(tp, 1, &xp_cmd, 0, NULL);
|
|
|
|
|
|
|
|
filter |= TYPHOON_RX_FILTER_MCAST_HASH;
|
|
|
|
}
|
|
|
|
|
|
|
|
INIT_COMMAND_NO_RESPONSE(&xp_cmd, TYPHOON_CMD_SET_RX_FILTER);
|
|
|
|
xp_cmd.parm1 = filter;
|
|
|
|
typhoon_issue_command(tp, 1, &xp_cmd, 0, NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
typhoon_do_get_stats(struct typhoon *tp)
|
|
|
|
{
|
|
|
|
struct net_device_stats *stats = &tp->stats;
|
|
|
|
struct net_device_stats *saved = &tp->stats_saved;
|
|
|
|
struct cmd_desc xp_cmd;
|
|
|
|
struct resp_desc xp_resp[7];
|
|
|
|
struct stats_resp *s = (struct stats_resp *) xp_resp;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
INIT_COMMAND_WITH_RESPONSE(&xp_cmd, TYPHOON_CMD_READ_STATS);
|
|
|
|
err = typhoon_issue_command(tp, 1, &xp_cmd, 7, xp_resp);
|
|
|
|
if(err < 0)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
/* 3Com's Linux driver uses txMultipleCollisions as it's
|
|
|
|
* collisions value, but there is some other collision info as well...
|
|
|
|
*
|
|
|
|
* The extra status reported would be a good candidate for
|
|
|
|
* ethtool_ops->get_{strings,stats}()
|
|
|
|
*/
|
|
|
|
stats->tx_packets = le32_to_cpu(s->txPackets);
|
2007-12-20 23:20:23 -07:00
|
|
|
stats->tx_bytes = le64_to_cpu(s->txBytes);
|
2005-04-16 16:20:36 -06:00
|
|
|
stats->tx_errors = le32_to_cpu(s->txCarrierLost);
|
|
|
|
stats->tx_carrier_errors = le32_to_cpu(s->txCarrierLost);
|
|
|
|
stats->collisions = le32_to_cpu(s->txMultipleCollisions);
|
|
|
|
stats->rx_packets = le32_to_cpu(s->rxPacketsGood);
|
2007-12-20 23:20:23 -07:00
|
|
|
stats->rx_bytes = le64_to_cpu(s->rxBytesGood);
|
2005-04-16 16:20:36 -06:00
|
|
|
stats->rx_fifo_errors = le32_to_cpu(s->rxFifoOverruns);
|
|
|
|
stats->rx_errors = le32_to_cpu(s->rxFifoOverruns) +
|
|
|
|
le32_to_cpu(s->BadSSD) + le32_to_cpu(s->rxCrcErrors);
|
|
|
|
stats->rx_crc_errors = le32_to_cpu(s->rxCrcErrors);
|
|
|
|
stats->rx_length_errors = le32_to_cpu(s->rxOversized);
|
|
|
|
tp->speed = (s->linkStatus & TYPHOON_LINK_100MBPS) ?
|
|
|
|
SPEED_100 : SPEED_10;
|
|
|
|
tp->duplex = (s->linkStatus & TYPHOON_LINK_FULL_DUPLEX) ?
|
|
|
|
DUPLEX_FULL : DUPLEX_HALF;
|
|
|
|
|
|
|
|
/* add in the saved statistics
|
|
|
|
*/
|
|
|
|
stats->tx_packets += saved->tx_packets;
|
|
|
|
stats->tx_bytes += saved->tx_bytes;
|
|
|
|
stats->tx_errors += saved->tx_errors;
|
|
|
|
stats->collisions += saved->collisions;
|
|
|
|
stats->rx_packets += saved->rx_packets;
|
|
|
|
stats->rx_bytes += saved->rx_bytes;
|
|
|
|
stats->rx_fifo_errors += saved->rx_fifo_errors;
|
|
|
|
stats->rx_errors += saved->rx_errors;
|
|
|
|
stats->rx_crc_errors += saved->rx_crc_errors;
|
|
|
|
stats->rx_length_errors += saved->rx_length_errors;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct net_device_stats *
|
|
|
|
typhoon_get_stats(struct net_device *dev)
|
|
|
|
{
|
|
|
|
struct typhoon *tp = netdev_priv(dev);
|
|
|
|
struct net_device_stats *stats = &tp->stats;
|
|
|
|
struct net_device_stats *saved = &tp->stats_saved;
|
|
|
|
|
|
|
|
smp_rmb();
|
|
|
|
if(tp->card_state == Sleeping)
|
|
|
|
return saved;
|
|
|
|
|
|
|
|
if(typhoon_do_get_stats(tp) < 0) {
|
|
|
|
printk(KERN_ERR "%s: error getting stats\n", dev->name);
|
|
|
|
return saved;
|
|
|
|
}
|
|
|
|
|
|
|
|
return stats;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
typhoon_set_mac_address(struct net_device *dev, void *addr)
|
|
|
|
{
|
|
|
|
struct sockaddr *saddr = (struct sockaddr *) addr;
|
|
|
|
|
|
|
|
if(netif_running(dev))
|
|
|
|
return -EBUSY;
|
|
|
|
|
|
|
|
memcpy(dev->dev_addr, saddr->sa_data, dev->addr_len);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
typhoon_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
|
|
|
|
{
|
|
|
|
struct typhoon *tp = netdev_priv(dev);
|
|
|
|
struct pci_dev *pci_dev = tp->pdev;
|
|
|
|
struct cmd_desc xp_cmd;
|
|
|
|
struct resp_desc xp_resp[3];
|
|
|
|
|
|
|
|
smp_rmb();
|
|
|
|
if(tp->card_state == Sleeping) {
|
|
|
|
strcpy(info->fw_version, "Sleep image");
|
|
|
|
} else {
|
|
|
|
INIT_COMMAND_WITH_RESPONSE(&xp_cmd, TYPHOON_CMD_READ_VERSIONS);
|
|
|
|
if(typhoon_issue_command(tp, 1, &xp_cmd, 3, xp_resp) < 0) {
|
|
|
|
strcpy(info->fw_version, "Unknown runtime");
|
|
|
|
} else {
|
2007-12-20 23:20:33 -07:00
|
|
|
u32 sleep_ver = le32_to_cpu(xp_resp[0].parm2);
|
2005-04-16 16:20:36 -06:00
|
|
|
snprintf(info->fw_version, 32, "%02x.%03x.%03x",
|
2006-09-13 11:24:59 -06:00
|
|
|
sleep_ver >> 24, (sleep_ver >> 12) & 0xfff,
|
2005-04-16 16:20:36 -06:00
|
|
|
sleep_ver & 0xfff);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
strcpy(info->driver, DRV_MODULE_NAME);
|
|
|
|
strcpy(info->version, DRV_MODULE_VERSION);
|
|
|
|
strcpy(info->bus_info, pci_name(pci_dev));
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
typhoon_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
|
|
|
|
{
|
|
|
|
struct typhoon *tp = netdev_priv(dev);
|
|
|
|
|
|
|
|
cmd->supported = SUPPORTED_100baseT_Half | SUPPORTED_100baseT_Full |
|
|
|
|
SUPPORTED_Autoneg;
|
|
|
|
|
|
|
|
switch (tp->xcvr_select) {
|
|
|
|
case TYPHOON_XCVR_10HALF:
|
|
|
|
cmd->advertising = ADVERTISED_10baseT_Half;
|
|
|
|
break;
|
|
|
|
case TYPHOON_XCVR_10FULL:
|
|
|
|
cmd->advertising = ADVERTISED_10baseT_Full;
|
|
|
|
break;
|
|
|
|
case TYPHOON_XCVR_100HALF:
|
|
|
|
cmd->advertising = ADVERTISED_100baseT_Half;
|
|
|
|
break;
|
|
|
|
case TYPHOON_XCVR_100FULL:
|
|
|
|
cmd->advertising = ADVERTISED_100baseT_Full;
|
|
|
|
break;
|
|
|
|
case TYPHOON_XCVR_AUTONEG:
|
|
|
|
cmd->advertising = ADVERTISED_10baseT_Half |
|
|
|
|
ADVERTISED_10baseT_Full |
|
|
|
|
ADVERTISED_100baseT_Half |
|
|
|
|
ADVERTISED_100baseT_Full |
|
|
|
|
ADVERTISED_Autoneg;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if(tp->capabilities & TYPHOON_FIBER) {
|
|
|
|
cmd->supported |= SUPPORTED_FIBRE;
|
|
|
|
cmd->advertising |= ADVERTISED_FIBRE;
|
|
|
|
cmd->port = PORT_FIBRE;
|
|
|
|
} else {
|
|
|
|
cmd->supported |= SUPPORTED_10baseT_Half |
|
|
|
|
SUPPORTED_10baseT_Full |
|
|
|
|
SUPPORTED_TP;
|
|
|
|
cmd->advertising |= ADVERTISED_TP;
|
|
|
|
cmd->port = PORT_TP;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* need to get stats to make these link speed/duplex valid */
|
|
|
|
typhoon_do_get_stats(tp);
|
|
|
|
cmd->speed = tp->speed;
|
|
|
|
cmd->duplex = tp->duplex;
|
|
|
|
cmd->phy_address = 0;
|
|
|
|
cmd->transceiver = XCVR_INTERNAL;
|
|
|
|
if(tp->xcvr_select == TYPHOON_XCVR_AUTONEG)
|
|
|
|
cmd->autoneg = AUTONEG_ENABLE;
|
|
|
|
else
|
|
|
|
cmd->autoneg = AUTONEG_DISABLE;
|
|
|
|
cmd->maxtxpkt = 1;
|
|
|
|
cmd->maxrxpkt = 1;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
typhoon_set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
|
|
|
|
{
|
|
|
|
struct typhoon *tp = netdev_priv(dev);
|
|
|
|
struct cmd_desc xp_cmd;
|
2007-08-22 22:44:39 -06:00
|
|
|
__le16 xcvr;
|
2005-04-16 16:20:36 -06:00
|
|
|
int err;
|
|
|
|
|
|
|
|
err = -EINVAL;
|
|
|
|
if(cmd->autoneg == AUTONEG_ENABLE) {
|
|
|
|
xcvr = TYPHOON_XCVR_AUTONEG;
|
|
|
|
} else {
|
|
|
|
if(cmd->duplex == DUPLEX_HALF) {
|
|
|
|
if(cmd->speed == SPEED_10)
|
|
|
|
xcvr = TYPHOON_XCVR_10HALF;
|
|
|
|
else if(cmd->speed == SPEED_100)
|
|
|
|
xcvr = TYPHOON_XCVR_100HALF;
|
|
|
|
else
|
|
|
|
goto out;
|
|
|
|
} else if(cmd->duplex == DUPLEX_FULL) {
|
|
|
|
if(cmd->speed == SPEED_10)
|
|
|
|
xcvr = TYPHOON_XCVR_10FULL;
|
|
|
|
else if(cmd->speed == SPEED_100)
|
|
|
|
xcvr = TYPHOON_XCVR_100FULL;
|
|
|
|
else
|
|
|
|
goto out;
|
|
|
|
} else
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
INIT_COMMAND_NO_RESPONSE(&xp_cmd, TYPHOON_CMD_XCVR_SELECT);
|
2007-12-20 23:20:43 -07:00
|
|
|
xp_cmd.parm1 = xcvr;
|
2005-04-16 16:20:36 -06:00
|
|
|
err = typhoon_issue_command(tp, 1, &xp_cmd, 0, NULL);
|
|
|
|
if(err < 0)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
tp->xcvr_select = xcvr;
|
|
|
|
if(cmd->autoneg == AUTONEG_ENABLE) {
|
|
|
|
tp->speed = 0xff; /* invalid */
|
|
|
|
tp->duplex = 0xff; /* invalid */
|
|
|
|
} else {
|
|
|
|
tp->speed = cmd->speed;
|
|
|
|
tp->duplex = cmd->duplex;
|
|
|
|
}
|
|
|
|
|
|
|
|
out:
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
typhoon_get_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
|
|
|
|
{
|
|
|
|
struct typhoon *tp = netdev_priv(dev);
|
|
|
|
|
|
|
|
wol->supported = WAKE_PHY | WAKE_MAGIC;
|
|
|
|
wol->wolopts = 0;
|
|
|
|
if(tp->wol_events & TYPHOON_WAKE_LINK_EVENT)
|
|
|
|
wol->wolopts |= WAKE_PHY;
|
|
|
|
if(tp->wol_events & TYPHOON_WAKE_MAGIC_PKT)
|
|
|
|
wol->wolopts |= WAKE_MAGIC;
|
|
|
|
memset(&wol->sopass, 0, sizeof(wol->sopass));
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
typhoon_set_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
|
|
|
|
{
|
|
|
|
struct typhoon *tp = netdev_priv(dev);
|
|
|
|
|
|
|
|
if(wol->wolopts & ~(WAKE_PHY | WAKE_MAGIC))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
tp->wol_events = 0;
|
|
|
|
if(wol->wolopts & WAKE_PHY)
|
|
|
|
tp->wol_events |= TYPHOON_WAKE_LINK_EVENT;
|
|
|
|
if(wol->wolopts & WAKE_MAGIC)
|
|
|
|
tp->wol_events |= TYPHOON_WAKE_MAGIC_PKT;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static u32
|
|
|
|
typhoon_get_rx_csum(struct net_device *dev)
|
|
|
|
{
|
|
|
|
/* For now, we don't allow turning off RX checksums.
|
|
|
|
*/
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
typhoon_get_ringparam(struct net_device *dev, struct ethtool_ringparam *ering)
|
|
|
|
{
|
|
|
|
ering->rx_max_pending = RXENT_ENTRIES;
|
|
|
|
ering->rx_mini_max_pending = 0;
|
|
|
|
ering->rx_jumbo_max_pending = 0;
|
|
|
|
ering->tx_max_pending = TXLO_ENTRIES - 1;
|
|
|
|
|
|
|
|
ering->rx_pending = RXENT_ENTRIES;
|
|
|
|
ering->rx_mini_pending = 0;
|
|
|
|
ering->rx_jumbo_pending = 0;
|
|
|
|
ering->tx_pending = TXLO_ENTRIES - 1;
|
|
|
|
}
|
|
|
|
|
2006-09-13 12:30:00 -06:00
|
|
|
static const struct ethtool_ops typhoon_ethtool_ops = {
|
2005-04-16 16:20:36 -06:00
|
|
|
.get_settings = typhoon_get_settings,
|
|
|
|
.set_settings = typhoon_set_settings,
|
|
|
|
.get_drvinfo = typhoon_get_drvinfo,
|
|
|
|
.get_wol = typhoon_get_wol,
|
|
|
|
.set_wol = typhoon_set_wol,
|
|
|
|
.get_link = ethtool_op_get_link,
|
|
|
|
.get_rx_csum = typhoon_get_rx_csum,
|
|
|
|
.set_tx_csum = ethtool_op_set_tx_csum,
|
|
|
|
.set_sg = ethtool_op_set_sg,
|
|
|
|
.set_tso = ethtool_op_set_tso,
|
|
|
|
.get_ringparam = typhoon_get_ringparam,
|
|
|
|
};
|
|
|
|
|
|
|
|
static int
|
|
|
|
typhoon_wait_interrupt(void __iomem *ioaddr)
|
|
|
|
{
|
|
|
|
int i, err = 0;
|
|
|
|
|
|
|
|
for(i = 0; i < TYPHOON_WAIT_TIMEOUT; i++) {
|
|
|
|
if(ioread32(ioaddr + TYPHOON_REG_INTR_STATUS) &
|
|
|
|
TYPHOON_INTR_BOOTCMD)
|
|
|
|
goto out;
|
|
|
|
udelay(TYPHOON_UDELAY);
|
|
|
|
}
|
|
|
|
|
|
|
|
err = -ETIMEDOUT;
|
|
|
|
|
|
|
|
out:
|
|
|
|
iowrite32(TYPHOON_INTR_BOOTCMD, ioaddr + TYPHOON_REG_INTR_STATUS);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
#define shared_offset(x) offsetof(struct typhoon_shared, x)
|
|
|
|
|
|
|
|
static void
|
|
|
|
typhoon_init_interface(struct typhoon *tp)
|
|
|
|
{
|
|
|
|
struct typhoon_interface *iface = &tp->shared->iface;
|
|
|
|
dma_addr_t shared_dma;
|
|
|
|
|
|
|
|
memset(tp->shared, 0, sizeof(struct typhoon_shared));
|
|
|
|
|
|
|
|
/* The *Hi members of iface are all init'd to zero by the memset().
|
|
|
|
*/
|
|
|
|
shared_dma = tp->shared_dma + shared_offset(indexes);
|
|
|
|
iface->ringIndex = cpu_to_le32(shared_dma);
|
|
|
|
|
|
|
|
shared_dma = tp->shared_dma + shared_offset(txLo);
|
|
|
|
iface->txLoAddr = cpu_to_le32(shared_dma);
|
|
|
|
iface->txLoSize = cpu_to_le32(TXLO_ENTRIES * sizeof(struct tx_desc));
|
|
|
|
|
|
|
|
shared_dma = tp->shared_dma + shared_offset(txHi);
|
|
|
|
iface->txHiAddr = cpu_to_le32(shared_dma);
|
|
|
|
iface->txHiSize = cpu_to_le32(TXHI_ENTRIES * sizeof(struct tx_desc));
|
|
|
|
|
|
|
|
shared_dma = tp->shared_dma + shared_offset(rxBuff);
|
|
|
|
iface->rxBuffAddr = cpu_to_le32(shared_dma);
|
|
|
|
iface->rxBuffSize = cpu_to_le32(RXFREE_ENTRIES *
|
|
|
|
sizeof(struct rx_free));
|
|
|
|
|
|
|
|
shared_dma = tp->shared_dma + shared_offset(rxLo);
|
|
|
|
iface->rxLoAddr = cpu_to_le32(shared_dma);
|
|
|
|
iface->rxLoSize = cpu_to_le32(RX_ENTRIES * sizeof(struct rx_desc));
|
|
|
|
|
|
|
|
shared_dma = tp->shared_dma + shared_offset(rxHi);
|
|
|
|
iface->rxHiAddr = cpu_to_le32(shared_dma);
|
|
|
|
iface->rxHiSize = cpu_to_le32(RX_ENTRIES * sizeof(struct rx_desc));
|
|
|
|
|
|
|
|
shared_dma = tp->shared_dma + shared_offset(cmd);
|
|
|
|
iface->cmdAddr = cpu_to_le32(shared_dma);
|
|
|
|
iface->cmdSize = cpu_to_le32(COMMAND_RING_SIZE);
|
|
|
|
|
|
|
|
shared_dma = tp->shared_dma + shared_offset(resp);
|
|
|
|
iface->respAddr = cpu_to_le32(shared_dma);
|
|
|
|
iface->respSize = cpu_to_le32(RESPONSE_RING_SIZE);
|
|
|
|
|
|
|
|
shared_dma = tp->shared_dma + shared_offset(zeroWord);
|
|
|
|
iface->zeroAddr = cpu_to_le32(shared_dma);
|
|
|
|
|
|
|
|
tp->indexes = &tp->shared->indexes;
|
|
|
|
tp->txLoRing.ringBase = (u8 *) tp->shared->txLo;
|
|
|
|
tp->txHiRing.ringBase = (u8 *) tp->shared->txHi;
|
|
|
|
tp->rxLoRing.ringBase = (u8 *) tp->shared->rxLo;
|
|
|
|
tp->rxHiRing.ringBase = (u8 *) tp->shared->rxHi;
|
|
|
|
tp->rxBuffRing.ringBase = (u8 *) tp->shared->rxBuff;
|
|
|
|
tp->cmdRing.ringBase = (u8 *) tp->shared->cmd;
|
|
|
|
tp->respRing.ringBase = (u8 *) tp->shared->resp;
|
|
|
|
|
|
|
|
tp->txLoRing.writeRegister = TYPHOON_REG_TX_LO_READY;
|
|
|
|
tp->txHiRing.writeRegister = TYPHOON_REG_TX_HI_READY;
|
|
|
|
|
2007-12-20 23:21:03 -07:00
|
|
|
tp->txlo_dma_addr = le32_to_cpu(iface->txLoAddr);
|
2005-04-16 16:20:36 -06:00
|
|
|
tp->card_state = Sleeping;
|
|
|
|
smp_wmb();
|
|
|
|
|
|
|
|
tp->offload = TYPHOON_OFFLOAD_IP_CHKSUM | TYPHOON_OFFLOAD_TCP_CHKSUM;
|
|
|
|
tp->offload |= TYPHOON_OFFLOAD_UDP_CHKSUM | TSO_OFFLOAD_ON;
|
|
|
|
|
|
|
|
spin_lock_init(&tp->command_lock);
|
|
|
|
spin_lock_init(&tp->state_lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
typhoon_init_rings(struct typhoon *tp)
|
|
|
|
{
|
|
|
|
memset(tp->indexes, 0, sizeof(struct typhoon_indexes));
|
|
|
|
|
|
|
|
tp->txLoRing.lastWrite = 0;
|
|
|
|
tp->txHiRing.lastWrite = 0;
|
|
|
|
tp->rxLoRing.lastWrite = 0;
|
|
|
|
tp->rxHiRing.lastWrite = 0;
|
|
|
|
tp->rxBuffRing.lastWrite = 0;
|
|
|
|
tp->cmdRing.lastWrite = 0;
|
|
|
|
tp->cmdRing.lastWrite = 0;
|
|
|
|
|
|
|
|
tp->txLoRing.lastRead = 0;
|
|
|
|
tp->txHiRing.lastRead = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
typhoon_download_firmware(struct typhoon *tp)
|
|
|
|
{
|
|
|
|
void __iomem *ioaddr = tp->ioaddr;
|
|
|
|
struct pci_dev *pdev = tp->pdev;
|
|
|
|
struct typhoon_file_header *fHdr;
|
|
|
|
struct typhoon_section_header *sHdr;
|
|
|
|
u8 *image_data;
|
|
|
|
void *dpage;
|
|
|
|
dma_addr_t dpage_dma;
|
2007-12-20 23:21:14 -07:00
|
|
|
__sum16 csum;
|
2005-04-16 16:20:36 -06:00
|
|
|
u32 irqEnabled;
|
|
|
|
u32 irqMasked;
|
|
|
|
u32 numSections;
|
|
|
|
u32 section_len;
|
|
|
|
u32 len;
|
|
|
|
u32 load_addr;
|
|
|
|
u32 hmac;
|
|
|
|
int i;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
err = -EINVAL;
|
|
|
|
fHdr = (struct typhoon_file_header *) typhoon_firmware_image;
|
|
|
|
image_data = (u8 *) fHdr;
|
|
|
|
|
|
|
|
if(memcmp(fHdr->tag, "TYPHOON", 8)) {
|
|
|
|
printk(KERN_ERR "%s: Invalid firmware image!\n", tp->name);
|
|
|
|
goto err_out;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Cannot just map the firmware image using pci_map_single() as
|
|
|
|
* the firmware is part of the kernel/module image, so we allocate
|
|
|
|
* some consistent memory to copy the sections into, as it is simpler,
|
|
|
|
* and short-lived. If we ever split out and require a userland
|
|
|
|
* firmware loader, then we can revisit this.
|
|
|
|
*/
|
|
|
|
err = -ENOMEM;
|
|
|
|
dpage = pci_alloc_consistent(pdev, PAGE_SIZE, &dpage_dma);
|
|
|
|
if(!dpage) {
|
|
|
|
printk(KERN_ERR "%s: no DMA mem for firmware\n", tp->name);
|
|
|
|
goto err_out;
|
|
|
|
}
|
|
|
|
|
|
|
|
irqEnabled = ioread32(ioaddr + TYPHOON_REG_INTR_ENABLE);
|
|
|
|
iowrite32(irqEnabled | TYPHOON_INTR_BOOTCMD,
|
|
|
|
ioaddr + TYPHOON_REG_INTR_ENABLE);
|
|
|
|
irqMasked = ioread32(ioaddr + TYPHOON_REG_INTR_MASK);
|
|
|
|
iowrite32(irqMasked | TYPHOON_INTR_BOOTCMD,
|
|
|
|
ioaddr + TYPHOON_REG_INTR_MASK);
|
|
|
|
|
|
|
|
err = -ETIMEDOUT;
|
|
|
|
if(typhoon_wait_status(ioaddr, TYPHOON_STATUS_WAITING_FOR_HOST) < 0) {
|
|
|
|
printk(KERN_ERR "%s: card ready timeout\n", tp->name);
|
|
|
|
goto err_out_irq;
|
|
|
|
}
|
|
|
|
|
|
|
|
numSections = le32_to_cpu(fHdr->numSections);
|
|
|
|
load_addr = le32_to_cpu(fHdr->startAddr);
|
|
|
|
|
|
|
|
iowrite32(TYPHOON_INTR_BOOTCMD, ioaddr + TYPHOON_REG_INTR_STATUS);
|
|
|
|
iowrite32(load_addr, ioaddr + TYPHOON_REG_DOWNLOAD_BOOT_ADDR);
|
|
|
|
hmac = le32_to_cpu(fHdr->hmacDigest[0]);
|
|
|
|
iowrite32(hmac, ioaddr + TYPHOON_REG_DOWNLOAD_HMAC_0);
|
|
|
|
hmac = le32_to_cpu(fHdr->hmacDigest[1]);
|
|
|
|
iowrite32(hmac, ioaddr + TYPHOON_REG_DOWNLOAD_HMAC_1);
|
|
|
|
hmac = le32_to_cpu(fHdr->hmacDigest[2]);
|
|
|
|
iowrite32(hmac, ioaddr + TYPHOON_REG_DOWNLOAD_HMAC_2);
|
|
|
|
hmac = le32_to_cpu(fHdr->hmacDigest[3]);
|
|
|
|
iowrite32(hmac, ioaddr + TYPHOON_REG_DOWNLOAD_HMAC_3);
|
|
|
|
hmac = le32_to_cpu(fHdr->hmacDigest[4]);
|
|
|
|
iowrite32(hmac, ioaddr + TYPHOON_REG_DOWNLOAD_HMAC_4);
|
|
|
|
typhoon_post_pci_writes(ioaddr);
|
|
|
|
iowrite32(TYPHOON_BOOTCMD_RUNTIME_IMAGE, ioaddr + TYPHOON_REG_COMMAND);
|
|
|
|
|
|
|
|
image_data += sizeof(struct typhoon_file_header);
|
|
|
|
|
|
|
|
/* The ioread32() in typhoon_wait_interrupt() will force the
|
|
|
|
* last write to the command register to post, so
|
|
|
|
* we don't need a typhoon_post_pci_writes() after it.
|
|
|
|
*/
|
|
|
|
for(i = 0; i < numSections; i++) {
|
|
|
|
sHdr = (struct typhoon_section_header *) image_data;
|
|
|
|
image_data += sizeof(struct typhoon_section_header);
|
|
|
|
load_addr = le32_to_cpu(sHdr->startAddr);
|
|
|
|
section_len = le32_to_cpu(sHdr->len);
|
|
|
|
|
|
|
|
while(section_len) {
|
|
|
|
len = min_t(u32, section_len, PAGE_SIZE);
|
|
|
|
|
|
|
|
if(typhoon_wait_interrupt(ioaddr) < 0 ||
|
|
|
|
ioread32(ioaddr + TYPHOON_REG_STATUS) !=
|
|
|
|
TYPHOON_STATUS_WAITING_FOR_SEGMENT) {
|
|
|
|
printk(KERN_ERR "%s: segment ready timeout\n",
|
|
|
|
tp->name);
|
|
|
|
goto err_out_irq;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Do an pseudo IPv4 checksum on the data -- first
|
|
|
|
* need to convert each u16 to cpu order before
|
|
|
|
* summing. Fortunately, due to the properties of
|
|
|
|
* the checksum, we can do this once, at the end.
|
|
|
|
*/
|
2007-12-20 23:21:14 -07:00
|
|
|
csum = csum_fold(csum_partial_copy_nocheck(image_data,
|
|
|
|
dpage, len,
|
|
|
|
0));
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
iowrite32(len, ioaddr + TYPHOON_REG_BOOT_LENGTH);
|
2007-12-20 23:21:14 -07:00
|
|
|
iowrite32(le16_to_cpu((__force __le16)csum),
|
|
|
|
ioaddr + TYPHOON_REG_BOOT_CHECKSUM);
|
2005-04-16 16:20:36 -06:00
|
|
|
iowrite32(load_addr,
|
|
|
|
ioaddr + TYPHOON_REG_BOOT_DEST_ADDR);
|
|
|
|
iowrite32(0, ioaddr + TYPHOON_REG_BOOT_DATA_HI);
|
|
|
|
iowrite32(dpage_dma, ioaddr + TYPHOON_REG_BOOT_DATA_LO);
|
|
|
|
typhoon_post_pci_writes(ioaddr);
|
|
|
|
iowrite32(TYPHOON_BOOTCMD_SEG_AVAILABLE,
|
|
|
|
ioaddr + TYPHOON_REG_COMMAND);
|
|
|
|
|
|
|
|
image_data += len;
|
|
|
|
load_addr += len;
|
|
|
|
section_len -= len;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if(typhoon_wait_interrupt(ioaddr) < 0 ||
|
|
|
|
ioread32(ioaddr + TYPHOON_REG_STATUS) !=
|
|
|
|
TYPHOON_STATUS_WAITING_FOR_SEGMENT) {
|
|
|
|
printk(KERN_ERR "%s: final segment ready timeout\n", tp->name);
|
|
|
|
goto err_out_irq;
|
|
|
|
}
|
|
|
|
|
|
|
|
iowrite32(TYPHOON_BOOTCMD_DNLD_COMPLETE, ioaddr + TYPHOON_REG_COMMAND);
|
|
|
|
|
|
|
|
if(typhoon_wait_status(ioaddr, TYPHOON_STATUS_WAITING_FOR_BOOT) < 0) {
|
|
|
|
printk(KERN_ERR "%s: boot ready timeout, status 0x%0x\n",
|
|
|
|
tp->name, ioread32(ioaddr + TYPHOON_REG_STATUS));
|
|
|
|
goto err_out_irq;
|
|
|
|
}
|
|
|
|
|
|
|
|
err = 0;
|
|
|
|
|
|
|
|
err_out_irq:
|
|
|
|
iowrite32(irqMasked, ioaddr + TYPHOON_REG_INTR_MASK);
|
|
|
|
iowrite32(irqEnabled, ioaddr + TYPHOON_REG_INTR_ENABLE);
|
|
|
|
|
|
|
|
pci_free_consistent(pdev, PAGE_SIZE, dpage, dpage_dma);
|
|
|
|
|
|
|
|
err_out:
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
typhoon_boot_3XP(struct typhoon *tp, u32 initial_status)
|
|
|
|
{
|
|
|
|
void __iomem *ioaddr = tp->ioaddr;
|
|
|
|
|
|
|
|
if(typhoon_wait_status(ioaddr, initial_status) < 0) {
|
|
|
|
printk(KERN_ERR "%s: boot ready timeout\n", tp->name);
|
|
|
|
goto out_timeout;
|
|
|
|
}
|
|
|
|
|
|
|
|
iowrite32(0, ioaddr + TYPHOON_REG_BOOT_RECORD_ADDR_HI);
|
|
|
|
iowrite32(tp->shared_dma, ioaddr + TYPHOON_REG_BOOT_RECORD_ADDR_LO);
|
|
|
|
typhoon_post_pci_writes(ioaddr);
|
|
|
|
iowrite32(TYPHOON_BOOTCMD_REG_BOOT_RECORD,
|
|
|
|
ioaddr + TYPHOON_REG_COMMAND);
|
|
|
|
|
|
|
|
if(typhoon_wait_status(ioaddr, TYPHOON_STATUS_RUNNING) < 0) {
|
|
|
|
printk(KERN_ERR "%s: boot finish timeout (status 0x%x)\n",
|
|
|
|
tp->name, ioread32(ioaddr + TYPHOON_REG_STATUS));
|
|
|
|
goto out_timeout;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Clear the Transmit and Command ready registers
|
|
|
|
*/
|
|
|
|
iowrite32(0, ioaddr + TYPHOON_REG_TX_HI_READY);
|
|
|
|
iowrite32(0, ioaddr + TYPHOON_REG_CMD_READY);
|
|
|
|
iowrite32(0, ioaddr + TYPHOON_REG_TX_LO_READY);
|
|
|
|
typhoon_post_pci_writes(ioaddr);
|
|
|
|
iowrite32(TYPHOON_BOOTCMD_BOOT, ioaddr + TYPHOON_REG_COMMAND);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
out_timeout:
|
|
|
|
return -ETIMEDOUT;
|
|
|
|
}
|
|
|
|
|
|
|
|
static u32
|
|
|
|
typhoon_clean_tx(struct typhoon *tp, struct transmit_ring *txRing,
|
2007-08-22 22:44:39 -06:00
|
|
|
volatile __le32 * index)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
u32 lastRead = txRing->lastRead;
|
|
|
|
struct tx_desc *tx;
|
|
|
|
dma_addr_t skb_dma;
|
|
|
|
int dma_len;
|
|
|
|
int type;
|
|
|
|
|
|
|
|
while(lastRead != le32_to_cpu(*index)) {
|
|
|
|
tx = (struct tx_desc *) (txRing->ringBase + lastRead);
|
|
|
|
type = tx->flags & TYPHOON_TYPE_MASK;
|
|
|
|
|
|
|
|
if(type == TYPHOON_TX_DESC) {
|
|
|
|
/* This tx_desc describes a packet.
|
|
|
|
*/
|
2007-12-20 23:21:14 -07:00
|
|
|
unsigned long ptr = tx->tx_addr;
|
2005-04-16 16:20:36 -06:00
|
|
|
struct sk_buff *skb = (struct sk_buff *) ptr;
|
|
|
|
dev_kfree_skb_irq(skb);
|
|
|
|
} else if(type == TYPHOON_FRAG_DESC) {
|
|
|
|
/* This tx_desc describes a memory mapping. Free it.
|
|
|
|
*/
|
2007-12-20 23:21:14 -07:00
|
|
|
skb_dma = (dma_addr_t) le32_to_cpu(tx->frag.addr);
|
2005-04-16 16:20:36 -06:00
|
|
|
dma_len = le16_to_cpu(tx->len);
|
|
|
|
pci_unmap_single(tp->pdev, skb_dma, dma_len,
|
|
|
|
PCI_DMA_TODEVICE);
|
|
|
|
}
|
|
|
|
|
|
|
|
tx->flags = 0;
|
|
|
|
typhoon_inc_tx_index(&lastRead, 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
return lastRead;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
typhoon_tx_complete(struct typhoon *tp, struct transmit_ring *txRing,
|
2007-08-22 22:44:39 -06:00
|
|
|
volatile __le32 * index)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
u32 lastRead;
|
|
|
|
int numDesc = MAX_SKB_FRAGS + 1;
|
|
|
|
|
|
|
|
/* This will need changing if we start to use the Hi Tx ring. */
|
|
|
|
lastRead = typhoon_clean_tx(tp, txRing, index);
|
|
|
|
if(netif_queue_stopped(tp->dev) && typhoon_num_free(txRing->lastWrite,
|
|
|
|
lastRead, TXLO_ENTRIES) > (numDesc + 2))
|
|
|
|
netif_wake_queue(tp->dev);
|
|
|
|
|
|
|
|
txRing->lastRead = lastRead;
|
|
|
|
smp_wmb();
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
typhoon_recycle_rx_skb(struct typhoon *tp, u32 idx)
|
|
|
|
{
|
|
|
|
struct typhoon_indexes *indexes = tp->indexes;
|
|
|
|
struct rxbuff_ent *rxb = &tp->rxbuffers[idx];
|
|
|
|
struct basic_ring *ring = &tp->rxBuffRing;
|
|
|
|
struct rx_free *r;
|
|
|
|
|
|
|
|
if((ring->lastWrite + sizeof(*r)) % (RXFREE_ENTRIES * sizeof(*r)) ==
|
2007-12-20 23:20:53 -07:00
|
|
|
le32_to_cpu(indexes->rxBuffCleared)) {
|
2005-04-16 16:20:36 -06:00
|
|
|
/* no room in ring, just drop the skb
|
|
|
|
*/
|
|
|
|
dev_kfree_skb_any(rxb->skb);
|
|
|
|
rxb->skb = NULL;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
r = (struct rx_free *) (ring->ringBase + ring->lastWrite);
|
|
|
|
typhoon_inc_rxfree_index(&ring->lastWrite, 1);
|
|
|
|
r->virtAddr = idx;
|
|
|
|
r->physAddr = cpu_to_le32(rxb->dma_addr);
|
|
|
|
|
|
|
|
/* Tell the card about it */
|
|
|
|
wmb();
|
|
|
|
indexes->rxBuffReady = cpu_to_le32(ring->lastWrite);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
typhoon_alloc_rx_skb(struct typhoon *tp, u32 idx)
|
|
|
|
{
|
|
|
|
struct typhoon_indexes *indexes = tp->indexes;
|
|
|
|
struct rxbuff_ent *rxb = &tp->rxbuffers[idx];
|
|
|
|
struct basic_ring *ring = &tp->rxBuffRing;
|
|
|
|
struct rx_free *r;
|
|
|
|
struct sk_buff *skb;
|
|
|
|
dma_addr_t dma_addr;
|
|
|
|
|
|
|
|
rxb->skb = NULL;
|
|
|
|
|
|
|
|
if((ring->lastWrite + sizeof(*r)) % (RXFREE_ENTRIES * sizeof(*r)) ==
|
2007-12-20 23:20:53 -07:00
|
|
|
le32_to_cpu(indexes->rxBuffCleared))
|
2005-04-16 16:20:36 -06:00
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
skb = dev_alloc_skb(PKT_BUF_SZ);
|
|
|
|
if(!skb)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
#if 0
|
|
|
|
/* Please, 3com, fix the firmware to allow DMA to a unaligned
|
|
|
|
* address! Pretty please?
|
|
|
|
*/
|
|
|
|
skb_reserve(skb, 2);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
skb->dev = tp->dev;
|
2005-06-28 16:25:31 -06:00
|
|
|
dma_addr = pci_map_single(tp->pdev, skb->data,
|
2005-04-16 16:20:36 -06:00
|
|
|
PKT_BUF_SZ, PCI_DMA_FROMDEVICE);
|
|
|
|
|
|
|
|
/* Since no card does 64 bit DAC, the high bits will never
|
|
|
|
* change from zero.
|
|
|
|
*/
|
|
|
|
r = (struct rx_free *) (ring->ringBase + ring->lastWrite);
|
|
|
|
typhoon_inc_rxfree_index(&ring->lastWrite, 1);
|
|
|
|
r->virtAddr = idx;
|
|
|
|
r->physAddr = cpu_to_le32(dma_addr);
|
|
|
|
rxb->skb = skb;
|
|
|
|
rxb->dma_addr = dma_addr;
|
|
|
|
|
|
|
|
/* Tell the card about it */
|
|
|
|
wmb();
|
|
|
|
indexes->rxBuffReady = cpu_to_le32(ring->lastWrite);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2007-08-22 22:44:39 -06:00
|
|
|
typhoon_rx(struct typhoon *tp, struct basic_ring *rxRing, volatile __le32 * ready,
|
|
|
|
volatile __le32 * cleared, int budget)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct rx_desc *rx;
|
|
|
|
struct sk_buff *skb, *new_skb;
|
|
|
|
struct rxbuff_ent *rxb;
|
|
|
|
dma_addr_t dma_addr;
|
|
|
|
u32 local_ready;
|
|
|
|
u32 rxaddr;
|
|
|
|
int pkt_len;
|
|
|
|
u32 idx;
|
2007-08-22 22:44:39 -06:00
|
|
|
__le32 csum_bits;
|
2005-04-16 16:20:36 -06:00
|
|
|
int received;
|
|
|
|
|
|
|
|
received = 0;
|
|
|
|
local_ready = le32_to_cpu(*ready);
|
|
|
|
rxaddr = le32_to_cpu(*cleared);
|
|
|
|
while(rxaddr != local_ready && budget > 0) {
|
|
|
|
rx = (struct rx_desc *) (rxRing->ringBase + rxaddr);
|
|
|
|
idx = rx->addr;
|
|
|
|
rxb = &tp->rxbuffers[idx];
|
|
|
|
skb = rxb->skb;
|
|
|
|
dma_addr = rxb->dma_addr;
|
|
|
|
|
|
|
|
typhoon_inc_rx_index(&rxaddr, 1);
|
|
|
|
|
|
|
|
if(rx->flags & TYPHOON_RX_ERROR) {
|
|
|
|
typhoon_recycle_rx_skb(tp, idx);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
pkt_len = le16_to_cpu(rx->frameLen);
|
|
|
|
|
|
|
|
if(pkt_len < rx_copybreak &&
|
|
|
|
(new_skb = dev_alloc_skb(pkt_len + 2)) != NULL) {
|
|
|
|
skb_reserve(new_skb, 2);
|
|
|
|
pci_dma_sync_single_for_cpu(tp->pdev, dma_addr,
|
|
|
|
PKT_BUF_SZ,
|
|
|
|
PCI_DMA_FROMDEVICE);
|
2007-07-10 23:08:12 -06:00
|
|
|
skb_copy_to_linear_data(new_skb, skb->data, pkt_len);
|
2005-04-16 16:20:36 -06:00
|
|
|
pci_dma_sync_single_for_device(tp->pdev, dma_addr,
|
|
|
|
PKT_BUF_SZ,
|
|
|
|
PCI_DMA_FROMDEVICE);
|
|
|
|
skb_put(new_skb, pkt_len);
|
|
|
|
typhoon_recycle_rx_skb(tp, idx);
|
|
|
|
} else {
|
|
|
|
new_skb = skb;
|
|
|
|
skb_put(new_skb, pkt_len);
|
|
|
|
pci_unmap_single(tp->pdev, dma_addr, PKT_BUF_SZ,
|
|
|
|
PCI_DMA_FROMDEVICE);
|
|
|
|
typhoon_alloc_rx_skb(tp, idx);
|
|
|
|
}
|
|
|
|
new_skb->protocol = eth_type_trans(new_skb, tp->dev);
|
|
|
|
csum_bits = rx->rxStatus & (TYPHOON_RX_IP_CHK_GOOD |
|
|
|
|
TYPHOON_RX_UDP_CHK_GOOD | TYPHOON_RX_TCP_CHK_GOOD);
|
|
|
|
if(csum_bits ==
|
|
|
|
(TYPHOON_RX_IP_CHK_GOOD | TYPHOON_RX_TCP_CHK_GOOD)
|
|
|
|
|| csum_bits ==
|
|
|
|
(TYPHOON_RX_IP_CHK_GOOD | TYPHOON_RX_UDP_CHK_GOOD)) {
|
|
|
|
new_skb->ip_summed = CHECKSUM_UNNECESSARY;
|
|
|
|
} else
|
|
|
|
new_skb->ip_summed = CHECKSUM_NONE;
|
|
|
|
|
|
|
|
spin_lock(&tp->state_lock);
|
|
|
|
if(tp->vlgrp != NULL && rx->rxStatus & TYPHOON_RX_VLAN)
|
|
|
|
vlan_hwaccel_receive_skb(new_skb, tp->vlgrp,
|
|
|
|
ntohl(rx->vlanTag) & 0xffff);
|
|
|
|
else
|
|
|
|
netif_receive_skb(new_skb);
|
|
|
|
spin_unlock(&tp->state_lock);
|
|
|
|
|
|
|
|
tp->dev->last_rx = jiffies;
|
|
|
|
received++;
|
|
|
|
budget--;
|
|
|
|
}
|
|
|
|
*cleared = cpu_to_le32(rxaddr);
|
|
|
|
|
|
|
|
return received;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
typhoon_fill_free_ring(struct typhoon *tp)
|
|
|
|
{
|
|
|
|
u32 i;
|
|
|
|
|
|
|
|
for(i = 0; i < RXENT_ENTRIES; i++) {
|
|
|
|
struct rxbuff_ent *rxb = &tp->rxbuffers[i];
|
|
|
|
if(rxb->skb)
|
|
|
|
continue;
|
|
|
|
if(typhoon_alloc_rx_skb(tp, i) < 0)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
[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 17:41:36 -06:00
|
|
|
typhoon_poll(struct napi_struct *napi, int budget)
|
2005-04-16 16:20:36 -06: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 17:41:36 -06:00
|
|
|
struct typhoon *tp = container_of(napi, struct typhoon, napi);
|
|
|
|
struct net_device *dev = tp->dev;
|
2005-04-16 16:20:36 -06:00
|
|
|
struct typhoon_indexes *indexes = tp->indexes;
|
[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 17:41:36 -06:00
|
|
|
int work_done;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
rmb();
|
|
|
|
if(!tp->awaiting_resp && indexes->respReady != indexes->respCleared)
|
|
|
|
typhoon_process_response(tp, 0, NULL);
|
|
|
|
|
|
|
|
if(le32_to_cpu(indexes->txLoCleared) != tp->txLoRing.lastRead)
|
|
|
|
typhoon_tx_complete(tp, &tp->txLoRing, &indexes->txLoCleared);
|
|
|
|
|
|
|
|
work_done = 0;
|
|
|
|
|
|
|
|
if(indexes->rxHiCleared != indexes->rxHiReady) {
|
[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 17:41:36 -06:00
|
|
|
work_done += typhoon_rx(tp, &tp->rxHiRing, &indexes->rxHiReady,
|
2005-04-16 16:20:36 -06:00
|
|
|
&indexes->rxHiCleared, budget);
|
|
|
|
}
|
|
|
|
|
|
|
|
if(indexes->rxLoCleared != indexes->rxLoReady) {
|
|
|
|
work_done += typhoon_rx(tp, &tp->rxLoRing, &indexes->rxLoReady,
|
[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 17:41:36 -06:00
|
|
|
&indexes->rxLoCleared, budget - work_done);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
if(le32_to_cpu(indexes->rxBuffCleared) == tp->rxBuffRing.lastWrite) {
|
|
|
|
/* rxBuff ring is empty, try to fill it. */
|
|
|
|
typhoon_fill_free_ring(tp);
|
|
|
|
}
|
|
|
|
|
[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 17:41:36 -06:00
|
|
|
if (work_done < budget) {
|
|
|
|
netif_rx_complete(dev, napi);
|
2005-04-16 16:20:36 -06:00
|
|
|
iowrite32(TYPHOON_INTR_NONE,
|
|
|
|
tp->ioaddr + TYPHOON_REG_INTR_MASK);
|
|
|
|
typhoon_post_pci_writes(tp->ioaddr);
|
|
|
|
}
|
|
|
|
|
[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 17:41:36 -06:00
|
|
|
return work_done;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static irqreturn_t
|
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 07:55:46 -06:00
|
|
|
typhoon_interrupt(int irq, void *dev_instance)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2007-10-19 01:10:11 -06:00
|
|
|
struct net_device *dev = dev_instance;
|
2005-04-16 16:20:36 -06:00
|
|
|
struct typhoon *tp = dev->priv;
|
|
|
|
void __iomem *ioaddr = tp->ioaddr;
|
|
|
|
u32 intr_status;
|
|
|
|
|
|
|
|
intr_status = ioread32(ioaddr + TYPHOON_REG_INTR_STATUS);
|
|
|
|
if(!(intr_status & TYPHOON_INTR_HOST_INT))
|
|
|
|
return IRQ_NONE;
|
|
|
|
|
|
|
|
iowrite32(intr_status, ioaddr + TYPHOON_REG_INTR_STATUS);
|
|
|
|
|
[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 17:41:36 -06:00
|
|
|
if (netif_rx_schedule_prep(dev, &tp->napi)) {
|
2005-04-16 16:20:36 -06:00
|
|
|
iowrite32(TYPHOON_INTR_ALL, ioaddr + TYPHOON_REG_INTR_MASK);
|
|
|
|
typhoon_post_pci_writes(ioaddr);
|
[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 17:41:36 -06:00
|
|
|
__netif_rx_schedule(dev, &tp->napi);
|
2005-04-16 16:20:36 -06:00
|
|
|
} else {
|
|
|
|
printk(KERN_ERR "%s: Error, poll already scheduled\n",
|
|
|
|
dev->name);
|
|
|
|
}
|
|
|
|
return IRQ_HANDLED;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
typhoon_free_rx_rings(struct typhoon *tp)
|
|
|
|
{
|
|
|
|
u32 i;
|
|
|
|
|
|
|
|
for(i = 0; i < RXENT_ENTRIES; i++) {
|
|
|
|
struct rxbuff_ent *rxb = &tp->rxbuffers[i];
|
|
|
|
if(rxb->skb) {
|
|
|
|
pci_unmap_single(tp->pdev, rxb->dma_addr, PKT_BUF_SZ,
|
|
|
|
PCI_DMA_FROMDEVICE);
|
|
|
|
dev_kfree_skb(rxb->skb);
|
|
|
|
rxb->skb = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2007-08-22 22:44:39 -06:00
|
|
|
typhoon_sleep(struct typhoon *tp, pci_power_t state, __le16 events)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct pci_dev *pdev = tp->pdev;
|
|
|
|
void __iomem *ioaddr = tp->ioaddr;
|
|
|
|
struct cmd_desc xp_cmd;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
INIT_COMMAND_WITH_RESPONSE(&xp_cmd, TYPHOON_CMD_ENABLE_WAKE_EVENTS);
|
|
|
|
xp_cmd.parm1 = events;
|
|
|
|
err = typhoon_issue_command(tp, 1, &xp_cmd, 0, NULL);
|
|
|
|
if(err < 0) {
|
|
|
|
printk(KERN_ERR "%s: typhoon_sleep(): wake events cmd err %d\n",
|
|
|
|
tp->name, err);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
INIT_COMMAND_NO_RESPONSE(&xp_cmd, TYPHOON_CMD_GOTO_SLEEP);
|
|
|
|
err = typhoon_issue_command(tp, 1, &xp_cmd, 0, NULL);
|
|
|
|
if(err < 0) {
|
|
|
|
printk(KERN_ERR "%s: typhoon_sleep(): sleep cmd err %d\n",
|
|
|
|
tp->name, err);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
if(typhoon_wait_status(ioaddr, TYPHOON_STATUS_SLEEPING) < 0)
|
|
|
|
return -ETIMEDOUT;
|
|
|
|
|
|
|
|
/* Since we cannot monitor the status of the link while sleeping,
|
|
|
|
* tell the world it went away.
|
|
|
|
*/
|
|
|
|
netif_carrier_off(tp->dev);
|
|
|
|
|
2005-07-07 18:56:40 -06:00
|
|
|
pci_enable_wake(tp->pdev, state, 1);
|
2005-04-16 16:20:36 -06:00
|
|
|
pci_disable_device(pdev);
|
2005-07-07 18:56:40 -06:00
|
|
|
return pci_set_power_state(pdev, state);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
typhoon_wakeup(struct typhoon *tp, int wait_type)
|
|
|
|
{
|
|
|
|
struct pci_dev *pdev = tp->pdev;
|
|
|
|
void __iomem *ioaddr = tp->ioaddr;
|
|
|
|
|
|
|
|
pci_set_power_state(pdev, PCI_D0);
|
|
|
|
pci_restore_state(pdev);
|
|
|
|
|
|
|
|
/* Post 2.x.x versions of the Sleep Image require a reset before
|
|
|
|
* we can download the Runtime Image. But let's not make users of
|
|
|
|
* the old firmware pay for the reset.
|
|
|
|
*/
|
|
|
|
iowrite32(TYPHOON_BOOTCMD_WAKEUP, ioaddr + TYPHOON_REG_COMMAND);
|
|
|
|
if(typhoon_wait_status(ioaddr, TYPHOON_STATUS_WAITING_FOR_HOST) < 0 ||
|
|
|
|
(tp->capabilities & TYPHOON_WAKEUP_NEEDS_RESET))
|
|
|
|
return typhoon_reset(ioaddr, wait_type);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
typhoon_start_runtime(struct typhoon *tp)
|
|
|
|
{
|
|
|
|
struct net_device *dev = tp->dev;
|
|
|
|
void __iomem *ioaddr = tp->ioaddr;
|
|
|
|
struct cmd_desc xp_cmd;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
typhoon_init_rings(tp);
|
|
|
|
typhoon_fill_free_ring(tp);
|
|
|
|
|
|
|
|
err = typhoon_download_firmware(tp);
|
|
|
|
if(err < 0) {
|
|
|
|
printk("%s: cannot load runtime on 3XP\n", tp->name);
|
|
|
|
goto error_out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if(typhoon_boot_3XP(tp, TYPHOON_STATUS_WAITING_FOR_BOOT) < 0) {
|
|
|
|
printk("%s: cannot boot 3XP\n", tp->name);
|
|
|
|
err = -EIO;
|
|
|
|
goto error_out;
|
|
|
|
}
|
|
|
|
|
|
|
|
INIT_COMMAND_NO_RESPONSE(&xp_cmd, TYPHOON_CMD_SET_MAX_PKT_SIZE);
|
|
|
|
xp_cmd.parm1 = cpu_to_le16(PKT_BUF_SZ);
|
|
|
|
err = typhoon_issue_command(tp, 1, &xp_cmd, 0, NULL);
|
|
|
|
if(err < 0)
|
|
|
|
goto error_out;
|
|
|
|
|
|
|
|
INIT_COMMAND_NO_RESPONSE(&xp_cmd, TYPHOON_CMD_SET_MAC_ADDRESS);
|
2007-08-22 22:44:39 -06:00
|
|
|
xp_cmd.parm1 = cpu_to_le16(ntohs(*(__be16 *)&dev->dev_addr[0]));
|
|
|
|
xp_cmd.parm2 = cpu_to_le32(ntohl(*(__be32 *)&dev->dev_addr[2]));
|
2005-04-16 16:20:36 -06:00
|
|
|
err = typhoon_issue_command(tp, 1, &xp_cmd, 0, NULL);
|
|
|
|
if(err < 0)
|
|
|
|
goto error_out;
|
|
|
|
|
|
|
|
/* Disable IRQ coalescing -- we can reenable it when 3Com gives
|
|
|
|
* us some more information on how to control it.
|
|
|
|
*/
|
|
|
|
INIT_COMMAND_WITH_RESPONSE(&xp_cmd, TYPHOON_CMD_IRQ_COALESCE_CTRL);
|
|
|
|
xp_cmd.parm1 = 0;
|
|
|
|
err = typhoon_issue_command(tp, 1, &xp_cmd, 0, NULL);
|
|
|
|
if(err < 0)
|
|
|
|
goto error_out;
|
|
|
|
|
|
|
|
INIT_COMMAND_NO_RESPONSE(&xp_cmd, TYPHOON_CMD_XCVR_SELECT);
|
|
|
|
xp_cmd.parm1 = tp->xcvr_select;
|
|
|
|
err = typhoon_issue_command(tp, 1, &xp_cmd, 0, NULL);
|
|
|
|
if(err < 0)
|
|
|
|
goto error_out;
|
|
|
|
|
|
|
|
INIT_COMMAND_NO_RESPONSE(&xp_cmd, TYPHOON_CMD_VLAN_TYPE_WRITE);
|
|
|
|
xp_cmd.parm1 = __constant_cpu_to_le16(ETH_P_8021Q);
|
|
|
|
err = typhoon_issue_command(tp, 1, &xp_cmd, 0, NULL);
|
|
|
|
if(err < 0)
|
|
|
|
goto error_out;
|
|
|
|
|
|
|
|
INIT_COMMAND_NO_RESPONSE(&xp_cmd, TYPHOON_CMD_SET_OFFLOAD_TASKS);
|
|
|
|
spin_lock_bh(&tp->state_lock);
|
|
|
|
xp_cmd.parm2 = tp->offload;
|
|
|
|
xp_cmd.parm3 = tp->offload;
|
|
|
|
err = typhoon_issue_command(tp, 1, &xp_cmd, 0, NULL);
|
|
|
|
spin_unlock_bh(&tp->state_lock);
|
|
|
|
if(err < 0)
|
|
|
|
goto error_out;
|
|
|
|
|
|
|
|
typhoon_set_rx_mode(dev);
|
|
|
|
|
|
|
|
INIT_COMMAND_NO_RESPONSE(&xp_cmd, TYPHOON_CMD_TX_ENABLE);
|
|
|
|
err = typhoon_issue_command(tp, 1, &xp_cmd, 0, NULL);
|
|
|
|
if(err < 0)
|
|
|
|
goto error_out;
|
|
|
|
|
|
|
|
INIT_COMMAND_WITH_RESPONSE(&xp_cmd, TYPHOON_CMD_RX_ENABLE);
|
|
|
|
err = typhoon_issue_command(tp, 1, &xp_cmd, 0, NULL);
|
|
|
|
if(err < 0)
|
|
|
|
goto error_out;
|
|
|
|
|
|
|
|
tp->card_state = Running;
|
|
|
|
smp_wmb();
|
|
|
|
|
|
|
|
iowrite32(TYPHOON_INTR_ENABLE_ALL, ioaddr + TYPHOON_REG_INTR_ENABLE);
|
|
|
|
iowrite32(TYPHOON_INTR_NONE, ioaddr + TYPHOON_REG_INTR_MASK);
|
|
|
|
typhoon_post_pci_writes(ioaddr);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
error_out:
|
|
|
|
typhoon_reset(ioaddr, WaitNoSleep);
|
|
|
|
typhoon_free_rx_rings(tp);
|
|
|
|
typhoon_init_rings(tp);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
typhoon_stop_runtime(struct typhoon *tp, int wait_type)
|
|
|
|
{
|
|
|
|
struct typhoon_indexes *indexes = tp->indexes;
|
|
|
|
struct transmit_ring *txLo = &tp->txLoRing;
|
|
|
|
void __iomem *ioaddr = tp->ioaddr;
|
|
|
|
struct cmd_desc xp_cmd;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
/* Disable interrupts early, since we can't schedule a poll
|
|
|
|
* when called with !netif_running(). This will be posted
|
|
|
|
* when we force the posting of the command.
|
|
|
|
*/
|
|
|
|
iowrite32(TYPHOON_INTR_NONE, ioaddr + TYPHOON_REG_INTR_ENABLE);
|
|
|
|
|
|
|
|
INIT_COMMAND_NO_RESPONSE(&xp_cmd, TYPHOON_CMD_RX_DISABLE);
|
|
|
|
typhoon_issue_command(tp, 1, &xp_cmd, 0, NULL);
|
|
|
|
|
|
|
|
/* Wait 1/2 sec for any outstanding transmits to occur
|
|
|
|
* We'll cleanup after the reset if this times out.
|
|
|
|
*/
|
|
|
|
for(i = 0; i < TYPHOON_WAIT_TIMEOUT; i++) {
|
|
|
|
if(indexes->txLoCleared == cpu_to_le32(txLo->lastWrite))
|
|
|
|
break;
|
|
|
|
udelay(TYPHOON_UDELAY);
|
|
|
|
}
|
|
|
|
|
|
|
|
if(i == TYPHOON_WAIT_TIMEOUT)
|
|
|
|
printk(KERN_ERR
|
|
|
|
"%s: halt timed out waiting for Tx to complete\n",
|
|
|
|
tp->name);
|
|
|
|
|
|
|
|
INIT_COMMAND_NO_RESPONSE(&xp_cmd, TYPHOON_CMD_TX_DISABLE);
|
|
|
|
typhoon_issue_command(tp, 1, &xp_cmd, 0, NULL);
|
|
|
|
|
|
|
|
/* save the statistics so when we bring the interface up again,
|
|
|
|
* the values reported to userspace are correct.
|
|
|
|
*/
|
|
|
|
tp->card_state = Sleeping;
|
|
|
|
smp_wmb();
|
|
|
|
typhoon_do_get_stats(tp);
|
|
|
|
memcpy(&tp->stats_saved, &tp->stats, sizeof(struct net_device_stats));
|
|
|
|
|
|
|
|
INIT_COMMAND_NO_RESPONSE(&xp_cmd, TYPHOON_CMD_HALT);
|
|
|
|
typhoon_issue_command(tp, 1, &xp_cmd, 0, NULL);
|
|
|
|
|
|
|
|
if(typhoon_wait_status(ioaddr, TYPHOON_STATUS_HALTED) < 0)
|
|
|
|
printk(KERN_ERR "%s: timed out waiting for 3XP to halt\n",
|
|
|
|
tp->name);
|
|
|
|
|
|
|
|
if(typhoon_reset(ioaddr, wait_type) < 0) {
|
|
|
|
printk(KERN_ERR "%s: unable to reset 3XP\n", tp->name);
|
|
|
|
return -ETIMEDOUT;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* cleanup any outstanding Tx packets */
|
|
|
|
if(indexes->txLoCleared != cpu_to_le32(txLo->lastWrite)) {
|
|
|
|
indexes->txLoCleared = cpu_to_le32(txLo->lastWrite);
|
|
|
|
typhoon_clean_tx(tp, &tp->txLoRing, &indexes->txLoCleared);
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
typhoon_tx_timeout(struct net_device *dev)
|
|
|
|
{
|
|
|
|
struct typhoon *tp = netdev_priv(dev);
|
|
|
|
|
|
|
|
if(typhoon_reset(tp->ioaddr, WaitNoSleep) < 0) {
|
|
|
|
printk(KERN_WARNING "%s: could not reset in tx timeout\n",
|
|
|
|
dev->name);
|
|
|
|
goto truely_dead;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* If we ever start using the Hi ring, it will need cleaning too */
|
|
|
|
typhoon_clean_tx(tp, &tp->txLoRing, &tp->indexes->txLoCleared);
|
|
|
|
typhoon_free_rx_rings(tp);
|
|
|
|
|
|
|
|
if(typhoon_start_runtime(tp) < 0) {
|
|
|
|
printk(KERN_ERR "%s: could not start runtime in tx timeout\n",
|
|
|
|
dev->name);
|
|
|
|
goto truely_dead;
|
|
|
|
}
|
|
|
|
|
|
|
|
netif_wake_queue(dev);
|
|
|
|
return;
|
|
|
|
|
|
|
|
truely_dead:
|
|
|
|
/* Reset the hardware, and turn off carrier to avoid more timeouts */
|
|
|
|
typhoon_reset(tp->ioaddr, NoWait);
|
|
|
|
netif_carrier_off(dev);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
typhoon_open(struct net_device *dev)
|
|
|
|
{
|
|
|
|
struct typhoon *tp = netdev_priv(dev);
|
|
|
|
int err;
|
|
|
|
|
|
|
|
err = typhoon_wakeup(tp, WaitSleep);
|
|
|
|
if(err < 0) {
|
|
|
|
printk(KERN_ERR "%s: unable to wakeup device\n", dev->name);
|
|
|
|
goto out_sleep;
|
|
|
|
}
|
|
|
|
|
2006-07-01 20:29:39 -06:00
|
|
|
err = request_irq(dev->irq, &typhoon_interrupt, IRQF_SHARED,
|
2005-04-16 16:20:36 -06:00
|
|
|
dev->name, dev);
|
|
|
|
if(err < 0)
|
|
|
|
goto out_sleep;
|
|
|
|
|
[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 17:41:36 -06:00
|
|
|
napi_enable(&tp->napi);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
err = typhoon_start_runtime(tp);
|
[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 17:41:36 -06:00
|
|
|
if(err < 0) {
|
|
|
|
napi_disable(&tp->napi);
|
2005-04-16 16:20:36 -06:00
|
|
|
goto out_irq;
|
[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 17:41:36 -06:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
netif_start_queue(dev);
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
out_irq:
|
|
|
|
free_irq(dev->irq, dev);
|
|
|
|
|
|
|
|
out_sleep:
|
|
|
|
if(typhoon_boot_3XP(tp, TYPHOON_STATUS_WAITING_FOR_HOST) < 0) {
|
|
|
|
printk(KERN_ERR "%s: unable to reboot into sleep img\n",
|
|
|
|
dev->name);
|
|
|
|
typhoon_reset(tp->ioaddr, NoWait);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2006-09-13 11:24:59 -06:00
|
|
|
if(typhoon_sleep(tp, PCI_D3hot, 0) < 0)
|
2005-04-16 16:20:36 -06:00
|
|
|
printk(KERN_ERR "%s: unable to go back to sleep\n", dev->name);
|
|
|
|
|
|
|
|
out:
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
typhoon_close(struct net_device *dev)
|
|
|
|
{
|
|
|
|
struct typhoon *tp = netdev_priv(dev);
|
|
|
|
|
|
|
|
netif_stop_queue(dev);
|
[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 17:41:36 -06:00
|
|
|
napi_disable(&tp->napi);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if(typhoon_stop_runtime(tp, WaitSleep) < 0)
|
|
|
|
printk(KERN_ERR "%s: unable to stop runtime\n", dev->name);
|
|
|
|
|
|
|
|
/* Make sure there is no irq handler running on a different CPU. */
|
|
|
|
free_irq(dev->irq, dev);
|
|
|
|
|
|
|
|
typhoon_free_rx_rings(tp);
|
|
|
|
typhoon_init_rings(tp);
|
|
|
|
|
|
|
|
if(typhoon_boot_3XP(tp, TYPHOON_STATUS_WAITING_FOR_HOST) < 0)
|
|
|
|
printk(KERN_ERR "%s: unable to boot sleep image\n", dev->name);
|
|
|
|
|
|
|
|
if(typhoon_sleep(tp, PCI_D3hot, 0) < 0)
|
|
|
|
printk(KERN_ERR "%s: unable to put card to sleep\n", dev->name);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_PM
|
|
|
|
static int
|
|
|
|
typhoon_resume(struct pci_dev *pdev)
|
|
|
|
{
|
|
|
|
struct net_device *dev = pci_get_drvdata(pdev);
|
|
|
|
struct typhoon *tp = netdev_priv(dev);
|
|
|
|
|
|
|
|
/* If we're down, resume when we are upped.
|
|
|
|
*/
|
|
|
|
if(!netif_running(dev))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if(typhoon_wakeup(tp, WaitNoSleep) < 0) {
|
|
|
|
printk(KERN_ERR "%s: critical: could not wake up in resume\n",
|
|
|
|
dev->name);
|
|
|
|
goto reset;
|
|
|
|
}
|
|
|
|
|
|
|
|
if(typhoon_start_runtime(tp) < 0) {
|
|
|
|
printk(KERN_ERR "%s: critical: could not start runtime in "
|
|
|
|
"resume\n", dev->name);
|
|
|
|
goto reset;
|
|
|
|
}
|
|
|
|
|
|
|
|
netif_device_attach(dev);
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
reset:
|
|
|
|
typhoon_reset(tp->ioaddr, NoWait);
|
|
|
|
return -EBUSY;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
typhoon_suspend(struct pci_dev *pdev, pm_message_t state)
|
|
|
|
{
|
|
|
|
struct net_device *dev = pci_get_drvdata(pdev);
|
|
|
|
struct typhoon *tp = netdev_priv(dev);
|
|
|
|
struct cmd_desc xp_cmd;
|
|
|
|
|
|
|
|
/* If we're down, we're already suspended.
|
|
|
|
*/
|
|
|
|
if(!netif_running(dev))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
spin_lock_bh(&tp->state_lock);
|
|
|
|
if(tp->vlgrp && tp->wol_events & TYPHOON_WAKE_MAGIC_PKT) {
|
|
|
|
spin_unlock_bh(&tp->state_lock);
|
|
|
|
printk(KERN_ERR "%s: cannot do WAKE_MAGIC with VLANS\n",
|
|
|
|
dev->name);
|
|
|
|
return -EBUSY;
|
|
|
|
}
|
|
|
|
spin_unlock_bh(&tp->state_lock);
|
|
|
|
|
|
|
|
netif_device_detach(dev);
|
|
|
|
|
|
|
|
if(typhoon_stop_runtime(tp, WaitNoSleep) < 0) {
|
|
|
|
printk(KERN_ERR "%s: unable to stop runtime\n", dev->name);
|
|
|
|
goto need_resume;
|
|
|
|
}
|
|
|
|
|
|
|
|
typhoon_free_rx_rings(tp);
|
|
|
|
typhoon_init_rings(tp);
|
|
|
|
|
|
|
|
if(typhoon_boot_3XP(tp, TYPHOON_STATUS_WAITING_FOR_HOST) < 0) {
|
|
|
|
printk(KERN_ERR "%s: unable to boot sleep image\n", dev->name);
|
|
|
|
goto need_resume;
|
|
|
|
}
|
|
|
|
|
|
|
|
INIT_COMMAND_NO_RESPONSE(&xp_cmd, TYPHOON_CMD_SET_MAC_ADDRESS);
|
2007-08-22 22:44:39 -06:00
|
|
|
xp_cmd.parm1 = cpu_to_le16(ntohs(*(__be16 *)&dev->dev_addr[0]));
|
|
|
|
xp_cmd.parm2 = cpu_to_le32(ntohl(*(__be32 *)&dev->dev_addr[2]));
|
2005-04-16 16:20:36 -06:00
|
|
|
if(typhoon_issue_command(tp, 1, &xp_cmd, 0, NULL) < 0) {
|
|
|
|
printk(KERN_ERR "%s: unable to set mac address in suspend\n",
|
|
|
|
dev->name);
|
|
|
|
goto need_resume;
|
|
|
|
}
|
|
|
|
|
|
|
|
INIT_COMMAND_NO_RESPONSE(&xp_cmd, TYPHOON_CMD_SET_RX_FILTER);
|
|
|
|
xp_cmd.parm1 = TYPHOON_RX_FILTER_DIRECTED | TYPHOON_RX_FILTER_BROADCAST;
|
|
|
|
if(typhoon_issue_command(tp, 1, &xp_cmd, 0, NULL) < 0) {
|
|
|
|
printk(KERN_ERR "%s: unable to set rx filter in suspend\n",
|
|
|
|
dev->name);
|
|
|
|
goto need_resume;
|
|
|
|
}
|
|
|
|
|
2005-07-07 18:56:40 -06:00
|
|
|
if(typhoon_sleep(tp, pci_choose_state(pdev, state), tp->wol_events) < 0) {
|
2005-04-16 16:20:36 -06:00
|
|
|
printk(KERN_ERR "%s: unable to put card to sleep\n", dev->name);
|
|
|
|
goto need_resume;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
need_resume:
|
|
|
|
typhoon_resume(pdev);
|
|
|
|
return -EBUSY;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
static int __devinit
|
|
|
|
typhoon_test_mmio(struct pci_dev *pdev)
|
|
|
|
{
|
|
|
|
void __iomem *ioaddr = pci_iomap(pdev, 1, 128);
|
|
|
|
int mode = 0;
|
|
|
|
u32 val;
|
|
|
|
|
|
|
|
if(!ioaddr)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
if(ioread32(ioaddr + TYPHOON_REG_STATUS) !=
|
|
|
|
TYPHOON_STATUS_WAITING_FOR_HOST)
|
|
|
|
goto out_unmap;
|
|
|
|
|
|
|
|
iowrite32(TYPHOON_INTR_ALL, ioaddr + TYPHOON_REG_INTR_MASK);
|
|
|
|
iowrite32(TYPHOON_INTR_ALL, ioaddr + TYPHOON_REG_INTR_STATUS);
|
|
|
|
iowrite32(TYPHOON_INTR_ALL, ioaddr + TYPHOON_REG_INTR_ENABLE);
|
|
|
|
|
|
|
|
/* Ok, see if we can change our interrupt status register by
|
|
|
|
* sending ourselves an interrupt. If so, then MMIO works.
|
|
|
|
* The 50usec delay is arbitrary -- it could probably be smaller.
|
|
|
|
*/
|
|
|
|
val = ioread32(ioaddr + TYPHOON_REG_INTR_STATUS);
|
|
|
|
if((val & TYPHOON_INTR_SELF) == 0) {
|
|
|
|
iowrite32(1, ioaddr + TYPHOON_REG_SELF_INTERRUPT);
|
|
|
|
ioread32(ioaddr + TYPHOON_REG_INTR_STATUS);
|
|
|
|
udelay(50);
|
|
|
|
val = ioread32(ioaddr + TYPHOON_REG_INTR_STATUS);
|
|
|
|
if(val & TYPHOON_INTR_SELF)
|
|
|
|
mode = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
iowrite32(TYPHOON_INTR_ALL, ioaddr + TYPHOON_REG_INTR_MASK);
|
|
|
|
iowrite32(TYPHOON_INTR_ALL, ioaddr + TYPHOON_REG_INTR_STATUS);
|
|
|
|
iowrite32(TYPHOON_INTR_NONE, ioaddr + TYPHOON_REG_INTR_ENABLE);
|
|
|
|
ioread32(ioaddr + TYPHOON_REG_INTR_STATUS);
|
|
|
|
|
|
|
|
out_unmap:
|
|
|
|
pci_iounmap(pdev, ioaddr);
|
|
|
|
|
|
|
|
out:
|
|
|
|
if(!mode)
|
|
|
|
printk(KERN_INFO PFX "falling back to port IO\n");
|
|
|
|
return mode;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int __devinit
|
|
|
|
typhoon_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
|
|
|
|
{
|
|
|
|
static int did_version = 0;
|
|
|
|
struct net_device *dev;
|
|
|
|
struct typhoon *tp;
|
|
|
|
int card_id = (int) ent->driver_data;
|
|
|
|
void __iomem *ioaddr;
|
|
|
|
void *shared;
|
|
|
|
dma_addr_t shared_dma;
|
|
|
|
struct cmd_desc xp_cmd;
|
|
|
|
struct resp_desc xp_resp[3];
|
|
|
|
int err = 0;
|
|
|
|
|
|
|
|
if(!did_version++)
|
|
|
|
printk(KERN_INFO "%s", version);
|
|
|
|
|
|
|
|
dev = alloc_etherdev(sizeof(*tp));
|
|
|
|
if(dev == NULL) {
|
|
|
|
printk(ERR_PFX "%s: unable to alloc new net device\n",
|
|
|
|
pci_name(pdev));
|
|
|
|
err = -ENOMEM;
|
|
|
|
goto error_out;
|
|
|
|
}
|
|
|
|
SET_NETDEV_DEV(dev, &pdev->dev);
|
|
|
|
|
|
|
|
err = pci_enable_device(pdev);
|
|
|
|
if(err < 0) {
|
|
|
|
printk(ERR_PFX "%s: unable to enable device\n",
|
|
|
|
pci_name(pdev));
|
|
|
|
goto error_out_dev;
|
|
|
|
}
|
|
|
|
|
|
|
|
err = pci_set_mwi(pdev);
|
|
|
|
if(err < 0) {
|
|
|
|
printk(ERR_PFX "%s: unable to set MWI\n", pci_name(pdev));
|
|
|
|
goto error_out_disable;
|
|
|
|
}
|
|
|
|
|
|
|
|
err = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
|
|
|
|
if(err < 0) {
|
|
|
|
printk(ERR_PFX "%s: No usable DMA configuration\n",
|
|
|
|
pci_name(pdev));
|
|
|
|
goto error_out_mwi;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* sanity checks on IO and MMIO BARs
|
|
|
|
*/
|
|
|
|
if(!(pci_resource_flags(pdev, 0) & IORESOURCE_IO)) {
|
|
|
|
printk(ERR_PFX
|
|
|
|
"%s: region #1 not a PCI IO resource, aborting\n",
|
|
|
|
pci_name(pdev));
|
|
|
|
err = -ENODEV;
|
|
|
|
goto error_out_mwi;
|
|
|
|
}
|
|
|
|
if(pci_resource_len(pdev, 0) < 128) {
|
|
|
|
printk(ERR_PFX "%s: Invalid PCI IO region size, aborting\n",
|
|
|
|
pci_name(pdev));
|
|
|
|
err = -ENODEV;
|
|
|
|
goto error_out_mwi;
|
|
|
|
}
|
|
|
|
if(!(pci_resource_flags(pdev, 1) & IORESOURCE_MEM)) {
|
|
|
|
printk(ERR_PFX
|
|
|
|
"%s: region #1 not a PCI MMIO resource, aborting\n",
|
|
|
|
pci_name(pdev));
|
|
|
|
err = -ENODEV;
|
|
|
|
goto error_out_mwi;
|
|
|
|
}
|
|
|
|
if(pci_resource_len(pdev, 1) < 128) {
|
|
|
|
printk(ERR_PFX "%s: Invalid PCI MMIO region size, aborting\n",
|
|
|
|
pci_name(pdev));
|
|
|
|
err = -ENODEV;
|
|
|
|
goto error_out_mwi;
|
|
|
|
}
|
|
|
|
|
|
|
|
err = pci_request_regions(pdev, "typhoon");
|
|
|
|
if(err < 0) {
|
|
|
|
printk(ERR_PFX "%s: could not request regions\n",
|
|
|
|
pci_name(pdev));
|
|
|
|
goto error_out_mwi;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* map our registers
|
|
|
|
*/
|
|
|
|
if(use_mmio != 0 && use_mmio != 1)
|
|
|
|
use_mmio = typhoon_test_mmio(pdev);
|
|
|
|
|
|
|
|
ioaddr = pci_iomap(pdev, use_mmio, 128);
|
|
|
|
if (!ioaddr) {
|
|
|
|
printk(ERR_PFX "%s: cannot remap registers, aborting\n",
|
|
|
|
pci_name(pdev));
|
|
|
|
err = -EIO;
|
|
|
|
goto error_out_regions;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* allocate pci dma space for rx and tx descriptor rings
|
|
|
|
*/
|
|
|
|
shared = pci_alloc_consistent(pdev, sizeof(struct typhoon_shared),
|
|
|
|
&shared_dma);
|
|
|
|
if(!shared) {
|
|
|
|
printk(ERR_PFX "%s: could not allocate DMA memory\n",
|
|
|
|
pci_name(pdev));
|
|
|
|
err = -ENOMEM;
|
|
|
|
goto error_out_remap;
|
|
|
|
}
|
|
|
|
|
|
|
|
dev->irq = pdev->irq;
|
|
|
|
tp = netdev_priv(dev);
|
|
|
|
tp->shared = (struct typhoon_shared *) shared;
|
|
|
|
tp->shared_dma = shared_dma;
|
|
|
|
tp->pdev = pdev;
|
|
|
|
tp->tx_pdev = pdev;
|
|
|
|
tp->ioaddr = ioaddr;
|
|
|
|
tp->tx_ioaddr = ioaddr;
|
|
|
|
tp->dev = dev;
|
|
|
|
|
|
|
|
/* Init sequence:
|
|
|
|
* 1) Reset the adapter to clear any bad juju
|
|
|
|
* 2) Reload the sleep image
|
|
|
|
* 3) Boot the sleep image
|
|
|
|
* 4) Get the hardware address.
|
|
|
|
* 5) Put the card to sleep.
|
|
|
|
*/
|
|
|
|
if (typhoon_reset(ioaddr, WaitSleep) < 0) {
|
|
|
|
printk(ERR_PFX "%s: could not reset 3XP\n", pci_name(pdev));
|
|
|
|
err = -EIO;
|
|
|
|
goto error_out_dma;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Now that we've reset the 3XP and are sure it's not going to
|
|
|
|
* write all over memory, enable bus mastering, and save our
|
|
|
|
* state for resuming after a suspend.
|
|
|
|
*/
|
|
|
|
pci_set_master(pdev);
|
|
|
|
pci_save_state(pdev);
|
|
|
|
|
|
|
|
/* dev->name is not valid until we register, but we need to
|
|
|
|
* use some common routines to initialize the card. So that those
|
|
|
|
* routines print the right name, we keep our oun pointer to the name
|
|
|
|
*/
|
|
|
|
tp->name = pci_name(pdev);
|
|
|
|
|
|
|
|
typhoon_init_interface(tp);
|
|
|
|
typhoon_init_rings(tp);
|
|
|
|
|
|
|
|
if(typhoon_boot_3XP(tp, TYPHOON_STATUS_WAITING_FOR_HOST) < 0) {
|
|
|
|
printk(ERR_PFX "%s: cannot boot 3XP sleep image\n",
|
|
|
|
pci_name(pdev));
|
|
|
|
err = -EIO;
|
|
|
|
goto error_out_reset;
|
|
|
|
}
|
|
|
|
|
|
|
|
INIT_COMMAND_WITH_RESPONSE(&xp_cmd, TYPHOON_CMD_READ_MAC_ADDRESS);
|
|
|
|
if(typhoon_issue_command(tp, 1, &xp_cmd, 1, xp_resp) < 0) {
|
|
|
|
printk(ERR_PFX "%s: cannot read MAC address\n",
|
|
|
|
pci_name(pdev));
|
|
|
|
err = -EIO;
|
|
|
|
goto error_out_reset;
|
|
|
|
}
|
|
|
|
|
2007-08-22 22:44:39 -06:00
|
|
|
*(__be16 *)&dev->dev_addr[0] = htons(le16_to_cpu(xp_resp[0].parm1));
|
|
|
|
*(__be32 *)&dev->dev_addr[2] = htonl(le32_to_cpu(xp_resp[0].parm2));
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if(!is_valid_ether_addr(dev->dev_addr)) {
|
|
|
|
printk(ERR_PFX "%s: Could not obtain valid ethernet address, "
|
|
|
|
"aborting\n", pci_name(pdev));
|
|
|
|
goto error_out_reset;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Read the Sleep Image version last, so the response is valid
|
|
|
|
* later when we print out the version reported.
|
|
|
|
*/
|
|
|
|
INIT_COMMAND_WITH_RESPONSE(&xp_cmd, TYPHOON_CMD_READ_VERSIONS);
|
|
|
|
if(typhoon_issue_command(tp, 1, &xp_cmd, 3, xp_resp) < 0) {
|
|
|
|
printk(ERR_PFX "%s: Could not get Sleep Image version\n",
|
|
|
|
pci_name(pdev));
|
|
|
|
goto error_out_reset;
|
|
|
|
}
|
|
|
|
|
|
|
|
tp->capabilities = typhoon_card_info[card_id].capabilities;
|
|
|
|
tp->xcvr_select = TYPHOON_XCVR_AUTONEG;
|
|
|
|
|
|
|
|
/* Typhoon 1.0 Sleep Images return one response descriptor to the
|
|
|
|
* READ_VERSIONS command. Those versions are OK after waking up
|
|
|
|
* from sleep without needing a reset. Typhoon 1.1+ Sleep Images
|
|
|
|
* seem to need a little extra help to get started. Since we don't
|
|
|
|
* know how to nudge it along, just kick it.
|
|
|
|
*/
|
|
|
|
if(xp_resp[0].numDesc != 0)
|
|
|
|
tp->capabilities |= TYPHOON_WAKEUP_NEEDS_RESET;
|
|
|
|
|
|
|
|
if(typhoon_sleep(tp, PCI_D3hot, 0) < 0) {
|
|
|
|
printk(ERR_PFX "%s: cannot put adapter to sleep\n",
|
|
|
|
pci_name(pdev));
|
|
|
|
err = -EIO;
|
|
|
|
goto error_out_reset;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* The chip-specific entries in the device structure. */
|
|
|
|
dev->open = typhoon_open;
|
|
|
|
dev->hard_start_xmit = typhoon_start_tx;
|
|
|
|
dev->stop = typhoon_close;
|
|
|
|
dev->set_multicast_list = typhoon_set_rx_mode;
|
|
|
|
dev->tx_timeout = typhoon_tx_timeout;
|
[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 17:41:36 -06:00
|
|
|
netif_napi_add(dev, &tp->napi, typhoon_poll, 16);
|
2005-04-16 16:20:36 -06:00
|
|
|
dev->watchdog_timeo = TX_TIMEOUT;
|
|
|
|
dev->get_stats = typhoon_get_stats;
|
|
|
|
dev->set_mac_address = typhoon_set_mac_address;
|
|
|
|
dev->vlan_rx_register = typhoon_vlan_rx_register;
|
2007-06-01 10:44:01 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
SET_ETHTOOL_OPS(dev, &typhoon_ethtool_ops);
|
|
|
|
|
|
|
|
/* We can handle scatter gather, up to 16 entries, and
|
|
|
|
* we can do IP checksumming (only version 4, doh...)
|
|
|
|
*/
|
|
|
|
dev->features |= NETIF_F_SG | NETIF_F_IP_CSUM;
|
|
|
|
dev->features |= NETIF_F_HW_VLAN_TX | NETIF_F_HW_VLAN_RX;
|
|
|
|
dev->features |= NETIF_F_TSO;
|
|
|
|
|
|
|
|
if(register_netdev(dev) < 0)
|
|
|
|
goto error_out_reset;
|
|
|
|
|
|
|
|
/* fixup our local name */
|
|
|
|
tp->name = dev->name;
|
|
|
|
|
|
|
|
pci_set_drvdata(pdev, dev);
|
|
|
|
|
2008-10-27 16:59:26 -06:00
|
|
|
printk(KERN_INFO "%s: %s at %s 0x%llx, %pM\n",
|
2005-04-16 16:20:36 -06:00
|
|
|
dev->name, typhoon_card_info[card_id].name,
|
2006-06-12 16:13:08 -06:00
|
|
|
use_mmio ? "MMIO" : "IO",
|
2007-10-03 18:59:30 -06:00
|
|
|
(unsigned long long)pci_resource_start(pdev, use_mmio),
|
2008-10-27 16:59:26 -06:00
|
|
|
dev->dev_addr);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* xp_resp still contains the response to the READ_VERSIONS command.
|
|
|
|
* For debugging, let the user know what version he has.
|
|
|
|
*/
|
|
|
|
if(xp_resp[0].numDesc == 0) {
|
|
|
|
/* This is the Typhoon 1.0 type Sleep Image, last 16 bits
|
|
|
|
* of version is Month/Day of build.
|
|
|
|
*/
|
|
|
|
u16 monthday = le32_to_cpu(xp_resp[0].parm2) & 0xffff;
|
|
|
|
printk(KERN_INFO "%s: Typhoon 1.0 Sleep Image built "
|
|
|
|
"%02u/%02u/2000\n", dev->name, monthday >> 8,
|
|
|
|
monthday & 0xff);
|
|
|
|
} else if(xp_resp[0].numDesc == 2) {
|
|
|
|
/* This is the Typhoon 1.1+ type Sleep Image
|
|
|
|
*/
|
|
|
|
u32 sleep_ver = le32_to_cpu(xp_resp[0].parm2);
|
|
|
|
u8 *ver_string = (u8 *) &xp_resp[1];
|
|
|
|
ver_string[25] = 0;
|
|
|
|
printk(KERN_INFO "%s: Typhoon 1.1+ Sleep Image version "
|
|
|
|
"%02x.%03x.%03x %s\n", dev->name, sleep_ver >> 24,
|
|
|
|
(sleep_ver >> 12) & 0xfff, sleep_ver & 0xfff,
|
|
|
|
ver_string);
|
|
|
|
} else {
|
|
|
|
printk(KERN_WARNING "%s: Unknown Sleep Image version "
|
|
|
|
"(%u:%04x)\n", dev->name, xp_resp[0].numDesc,
|
|
|
|
le32_to_cpu(xp_resp[0].parm2));
|
|
|
|
}
|
2006-09-13 11:24:59 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
error_out_reset:
|
|
|
|
typhoon_reset(ioaddr, NoWait);
|
|
|
|
|
|
|
|
error_out_dma:
|
|
|
|
pci_free_consistent(pdev, sizeof(struct typhoon_shared),
|
|
|
|
shared, shared_dma);
|
|
|
|
error_out_remap:
|
|
|
|
pci_iounmap(pdev, ioaddr);
|
|
|
|
error_out_regions:
|
|
|
|
pci_release_regions(pdev);
|
|
|
|
error_out_mwi:
|
|
|
|
pci_clear_mwi(pdev);
|
|
|
|
error_out_disable:
|
|
|
|
pci_disable_device(pdev);
|
|
|
|
error_out_dev:
|
|
|
|
free_netdev(dev);
|
|
|
|
error_out:
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __devexit
|
|
|
|
typhoon_remove_one(struct pci_dev *pdev)
|
|
|
|
{
|
|
|
|
struct net_device *dev = pci_get_drvdata(pdev);
|
|
|
|
struct typhoon *tp = netdev_priv(dev);
|
|
|
|
|
|
|
|
unregister_netdev(dev);
|
|
|
|
pci_set_power_state(pdev, PCI_D0);
|
|
|
|
pci_restore_state(pdev);
|
|
|
|
typhoon_reset(tp->ioaddr, NoWait);
|
|
|
|
pci_iounmap(pdev, tp->ioaddr);
|
|
|
|
pci_free_consistent(pdev, sizeof(struct typhoon_shared),
|
|
|
|
tp->shared, tp->shared_dma);
|
|
|
|
pci_release_regions(pdev);
|
|
|
|
pci_clear_mwi(pdev);
|
|
|
|
pci_disable_device(pdev);
|
|
|
|
pci_set_drvdata(pdev, NULL);
|
|
|
|
free_netdev(dev);
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct pci_driver typhoon_driver = {
|
|
|
|
.name = DRV_MODULE_NAME,
|
|
|
|
.id_table = typhoon_pci_tbl,
|
|
|
|
.probe = typhoon_init_one,
|
|
|
|
.remove = __devexit_p(typhoon_remove_one),
|
|
|
|
#ifdef CONFIG_PM
|
|
|
|
.suspend = typhoon_suspend,
|
|
|
|
.resume = typhoon_resume,
|
|
|
|
#endif
|
|
|
|
};
|
|
|
|
|
|
|
|
static int __init
|
|
|
|
typhoon_init(void)
|
|
|
|
{
|
2006-08-19 15:48:59 -06:00
|
|
|
return pci_register_driver(&typhoon_driver);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static void __exit
|
|
|
|
typhoon_cleanup(void)
|
|
|
|
{
|
|
|
|
pci_unregister_driver(&typhoon_driver);
|
|
|
|
}
|
|
|
|
|
|
|
|
module_init(typhoon_init);
|
|
|
|
module_exit(typhoon_cleanup);
|