blob: 975e25b19ebe8a19502366c0c2763b3f6298058b [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/* EtherLinkXL.c: A 3Com EtherLink PCI III/XL ethernet driver for linux. */
2/*
3 Written 1996-1999 by Donald Becker.
4
5 This software may be used and distributed according to the terms
6 of the GNU General Public License, incorporated herein by reference.
7
8 This driver is for the 3Com "Vortex" and "Boomerang" series ethercards.
9 Members of the series include Fast EtherLink 3c590/3c592/3c595/3c597
10 and the EtherLink XL 3c900 and 3c905 cards.
11
12 Problem reports and questions should be directed to
13 vortex@scyld.com
14
15 The author may be reached as becker@scyld.com, or C/O
16 Scyld Computing Corporation
17 410 Severn Ave., Suite 210
18 Annapolis MD 21403
19
Linus Torvalds1da177e2005-04-16 15:20:36 -070020*/
21
22/*
23 * FIXME: This driver _could_ support MTU changing, but doesn't. See Don's hamachi.c implementation
24 * as well as other drivers
25 *
26 * NOTE: If you make 'vortex_debug' a constant (#define vortex_debug 0) the driver shrinks by 2k
27 * due to dead code elimination. There will be some performance benefits from this due to
28 * elimination of all the tests and reduced cache footprint.
29 */
30
31
32#define DRV_NAME "3c59x"
Linus Torvalds1da177e2005-04-16 15:20:36 -070033
34
35
36/* A few values that may be tweaked. */
37/* Keep the ring sizes a power of two for efficiency. */
38#define TX_RING_SIZE 16
39#define RX_RING_SIZE 32
40#define PKT_BUF_SZ 1536 /* Size of each temporary Rx buffer.*/
41
42/* "Knobs" that adjust features and parameters. */
43/* Set the copy breakpoint for the copy-only-tiny-frames scheme.
44 Setting to > 1512 effectively disables this feature. */
45#ifndef __arm__
46static int rx_copybreak = 200;
47#else
48/* ARM systems perform better by disregarding the bus-master
49 transfer capability of these cards. -- rmk */
50static int rx_copybreak = 1513;
51#endif
52/* Allow setting MTU to a larger size, bypassing the normal ethernet setup. */
53static const int mtu = 1500;
54/* Maximum events (Rx packets, etc.) to handle at each interrupt. */
55static int max_interrupt_work = 32;
56/* Tx timeout interval (millisecs) */
57static int watchdog = 5000;
58
59/* Allow aggregation of Tx interrupts. Saves CPU load at the cost
60 * of possible Tx stalls if the system is blocking interrupts
61 * somewhere else. Undefine this to disable.
62 */
63#define tx_interrupt_mitigation 1
64
65/* Put out somewhat more debugging messages. (0: no msg, 1 minimal .. 6). */
66#define vortex_debug debug
67#ifdef VORTEX_DEBUG
68static int vortex_debug = VORTEX_DEBUG;
69#else
70static int vortex_debug = 1;
71#endif
72
Linus Torvalds1da177e2005-04-16 15:20:36 -070073#include <linux/module.h>
74#include <linux/kernel.h>
75#include <linux/string.h>
76#include <linux/timer.h>
77#include <linux/errno.h>
78#include <linux/in.h>
79#include <linux/ioport.h>
80#include <linux/slab.h>
81#include <linux/interrupt.h>
82#include <linux/pci.h>
83#include <linux/mii.h>
84#include <linux/init.h>
85#include <linux/netdevice.h>
86#include <linux/etherdevice.h>
87#include <linux/skbuff.h>
88#include <linux/ethtool.h>
89#include <linux/highmem.h>
90#include <linux/eisa.h>
91#include <linux/bitops.h>
Marcelo Feitoza Parisiff5688a2006-01-09 18:37:15 -080092#include <linux/jiffies.h>
Yinghai Lu60e4ad72008-08-19 20:49:50 -070093#include <asm/irq.h> /* For nr_irqs only. */
Linus Torvalds1da177e2005-04-16 15:20:36 -070094#include <asm/io.h>
95#include <asm/uaccess.h>
96
97/* Kernel compatibility defines, some common to David Hinds' PCMCIA package.
98 This is only in the support-all-kernels source code. */
99
100#define RUN_AT(x) (jiffies + (x))
101
102#include <linux/delay.h>
103
104
Stephen Hemminger86de79b2009-02-26 10:19:24 +0000105static const char version[] __devinitconst =
106 DRV_NAME ": Donald Becker and others.\n";
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107
108MODULE_AUTHOR("Donald Becker <becker@scyld.com>");
Steffen Klassert61238602006-03-26 01:37:42 -0800109MODULE_DESCRIPTION("3Com 3c59x/3c9xx ethernet driver ");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110MODULE_LICENSE("GPL");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111
112
113/* Operational parameter that usually are not changed. */
114
115/* The Vortex size is twice that of the original EtherLinkIII series: the
116 runtime register window, window 1, is now always mapped in.
117 The Boomerang size is twice as large as the Vortex -- it has additional
118 bus master control registers. */
119#define VORTEX_TOTAL_SIZE 0x20
120#define BOOMERANG_TOTAL_SIZE 0x40
121
122/* Set iff a MII transceiver on any interface requires mdio preamble.
123 This only set with the original DP83840 on older 3c905 boards, so the extra
124 code size of a per-interface flag is not worthwhile. */
125static char mii_preamble_required;
126
127#define PFX DRV_NAME ": "
128
129
130
131/*
132 Theory of Operation
133
134I. Board Compatibility
135
136This device driver is designed for the 3Com FastEtherLink and FastEtherLink
137XL, 3Com's PCI to 10/100baseT adapters. It also works with the 10Mbs
138versions of the FastEtherLink cards. The supported product IDs are
139 3c590, 3c592, 3c595, 3c597, 3c900, 3c905
140
141The related ISA 3c515 is supported with a separate driver, 3c515.c, included
142with the kernel source or available from
143 cesdis.gsfc.nasa.gov:/pub/linux/drivers/3c515.html
144
145II. Board-specific settings
146
147PCI bus devices are configured by the system at boot time, so no jumpers
148need to be set on the board. The system BIOS should be set to assign the
149PCI INTA signal to an otherwise unused system IRQ line.
150
151The EEPROM settings for media type and forced-full-duplex are observed.
152The EEPROM media type should be left at the default "autoselect" unless using
15310base2 or AUI connections which cannot be reliably detected.
154
155III. Driver operation
156
157The 3c59x series use an interface that's very similar to the previous 3c5x9
158series. The primary interface is two programmed-I/O FIFOs, with an
159alternate single-contiguous-region bus-master transfer (see next).
160
161The 3c900 "Boomerang" series uses a full-bus-master interface with separate
162lists of transmit and receive descriptors, similar to the AMD LANCE/PCnet,
163DEC Tulip and Intel Speedo3. The first chip version retains a compatible
164programmed-I/O interface that has been removed in 'B' and subsequent board
165revisions.
166
167One extension that is advertised in a very large font is that the adapters
168are capable of being bus masters. On the Vortex chip this capability was
169only for a single contiguous region making it far less useful than the full
170bus master capability. There is a significant performance impact of taking
171an extra interrupt or polling for the completion of each transfer, as well
172as difficulty sharing the single transfer engine between the transmit and
173receive threads. Using DMA transfers is a win only with large blocks or
174with the flawed versions of the Intel Orion motherboard PCI controller.
175
176The Boomerang chip's full-bus-master interface is useful, and has the
177currently-unused advantages over other similar chips that queued transmit
178packets may be reordered and receive buffer groups are associated with a
179single frame.
180
181With full-bus-master support, this driver uses a "RX_COPYBREAK" scheme.
182Rather than a fixed intermediate receive buffer, this scheme allocates
183full-sized skbuffs as receive buffers. The value RX_COPYBREAK is used as
184the copying breakpoint: it is chosen to trade-off the memory wasted by
185passing the full-sized skbuff to the queue layer for all frames vs. the
186copying cost of copying a frame to a correctly-sized skbuff.
187
188IIIC. Synchronization
189The driver runs as two independent, single-threaded flows of control. One
190is the send-packet routine, which enforces single-threaded use by the
191dev->tbusy flag. The other thread is the interrupt handler, which is single
192threaded by the hardware and other software.
193
194IV. Notes
195
196Thanks to Cameron Spitzer and Terry Murphy of 3Com for providing development
1973c590, 3c595, and 3c900 boards.
198The name "Vortex" is the internal 3Com project name for the PCI ASIC, and
199the EISA version is called "Demon". According to Terry these names come
200from rides at the local amusement park.
201
202The new chips support both ethernet (1.5K) and FDDI (4.5K) packet sizes!
203This driver only supports ethernet packets because of the skbuff allocation
204limit of 4K.
205*/
206
207/* This table drives the PCI probe routines. It's mostly boilerplate in all
208 of the drivers, and will likely be provided by some future kernel.
209*/
210enum pci_flags_bit {
Jeff Garzik1f1bd5f2006-06-26 23:47:50 -0400211 PCI_USES_MASTER=4,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700212};
213
214enum { IS_VORTEX=1, IS_BOOMERANG=2, IS_CYCLONE=4, IS_TORNADO=8,
215 EEPROM_8BIT=0x10, /* AKPM: Uses 0x230 as the base bitmaps for EEPROM reads */
216 HAS_PWR_CTRL=0x20, HAS_MII=0x40, HAS_NWAY=0x80, HAS_CB_FNS=0x100,
217 INVERT_MII_PWR=0x200, INVERT_LED_PWR=0x400, MAX_COLLISION_RESET=0x800,
218 EEPROM_OFFSET=0x1000, HAS_HWCKSM=0x2000, WNO_XCVR_PWR=0x4000,
219 EXTRA_PREAMBLE=0x8000, EEPROM_RESET=0x10000, };
220
221enum vortex_chips {
222 CH_3C590 = 0,
223 CH_3C592,
224 CH_3C597,
225 CH_3C595_1,
226 CH_3C595_2,
227
228 CH_3C595_3,
229 CH_3C900_1,
230 CH_3C900_2,
231 CH_3C900_3,
232 CH_3C900_4,
233
234 CH_3C900_5,
235 CH_3C900B_FL,
236 CH_3C905_1,
237 CH_3C905_2,
Pascal Terjanb4adbb42009-08-05 04:11:39 +0000238 CH_3C905B_TX,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700239 CH_3C905B_1,
240
241 CH_3C905B_2,
242 CH_3C905B_FX,
243 CH_3C905C,
244 CH_3C9202,
245 CH_3C980,
246 CH_3C9805,
247
248 CH_3CSOHO100_TX,
249 CH_3C555,
250 CH_3C556,
251 CH_3C556B,
252 CH_3C575,
253
254 CH_3C575_1,
255 CH_3CCFE575,
256 CH_3CCFE575CT,
257 CH_3CCFE656,
258 CH_3CCFEM656,
259
260 CH_3CCFEM656_1,
261 CH_3C450,
262 CH_3C920,
263 CH_3C982A,
264 CH_3C982B,
265
266 CH_905BT4,
267 CH_920B_EMB_WNM,
268};
269
270
271/* note: this array directly indexed by above enums, and MUST
272 * be kept in sync with both the enums above, and the PCI device
273 * table below
274 */
275static struct vortex_chip_info {
276 const char *name;
277 int flags;
278 int drv_flags;
279 int io_size;
280} vortex_info_tbl[] __devinitdata = {
281 {"3c590 Vortex 10Mbps",
Jeff Garzik1f1bd5f2006-06-26 23:47:50 -0400282 PCI_USES_MASTER, IS_VORTEX, 32, },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700283 {"3c592 EISA 10Mbps Demon/Vortex", /* AKPM: from Don's 3c59x_cb.c 0.49H */
Jeff Garzik1f1bd5f2006-06-26 23:47:50 -0400284 PCI_USES_MASTER, IS_VORTEX, 32, },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700285 {"3c597 EISA Fast Demon/Vortex", /* AKPM: from Don's 3c59x_cb.c 0.49H */
Jeff Garzik1f1bd5f2006-06-26 23:47:50 -0400286 PCI_USES_MASTER, IS_VORTEX, 32, },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700287 {"3c595 Vortex 100baseTx",
Jeff Garzik1f1bd5f2006-06-26 23:47:50 -0400288 PCI_USES_MASTER, IS_VORTEX, 32, },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700289 {"3c595 Vortex 100baseT4",
Jeff Garzik1f1bd5f2006-06-26 23:47:50 -0400290 PCI_USES_MASTER, IS_VORTEX, 32, },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291
292 {"3c595 Vortex 100base-MII",
Jeff Garzik1f1bd5f2006-06-26 23:47:50 -0400293 PCI_USES_MASTER, IS_VORTEX, 32, },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700294 {"3c900 Boomerang 10baseT",
Jeff Garzik1f1bd5f2006-06-26 23:47:50 -0400295 PCI_USES_MASTER, IS_BOOMERANG|EEPROM_RESET, 64, },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700296 {"3c900 Boomerang 10Mbps Combo",
Jeff Garzik1f1bd5f2006-06-26 23:47:50 -0400297 PCI_USES_MASTER, IS_BOOMERANG|EEPROM_RESET, 64, },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700298 {"3c900 Cyclone 10Mbps TPO", /* AKPM: from Don's 0.99M */
Jeff Garzik1f1bd5f2006-06-26 23:47:50 -0400299 PCI_USES_MASTER, IS_CYCLONE|HAS_HWCKSM, 128, },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700300 {"3c900 Cyclone 10Mbps Combo",
Jeff Garzik1f1bd5f2006-06-26 23:47:50 -0400301 PCI_USES_MASTER, IS_CYCLONE|HAS_HWCKSM, 128, },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700302
303 {"3c900 Cyclone 10Mbps TPC", /* AKPM: from Don's 0.99M */
Jeff Garzik1f1bd5f2006-06-26 23:47:50 -0400304 PCI_USES_MASTER, IS_CYCLONE|HAS_HWCKSM, 128, },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700305 {"3c900B-FL Cyclone 10base-FL",
Jeff Garzik1f1bd5f2006-06-26 23:47:50 -0400306 PCI_USES_MASTER, IS_CYCLONE|HAS_HWCKSM, 128, },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700307 {"3c905 Boomerang 100baseTx",
Jeff Garzik1f1bd5f2006-06-26 23:47:50 -0400308 PCI_USES_MASTER, IS_BOOMERANG|HAS_MII|EEPROM_RESET, 64, },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700309 {"3c905 Boomerang 100baseT4",
Jeff Garzik1f1bd5f2006-06-26 23:47:50 -0400310 PCI_USES_MASTER, IS_BOOMERANG|HAS_MII|EEPROM_RESET, 64, },
Pascal Terjanb4adbb42009-08-05 04:11:39 +0000311 {"3C905B-TX Fast Etherlink XL PCI",
312 PCI_USES_MASTER, IS_CYCLONE|HAS_NWAY|HAS_HWCKSM|EXTRA_PREAMBLE, 128, },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313 {"3c905B Cyclone 100baseTx",
Jeff Garzik1f1bd5f2006-06-26 23:47:50 -0400314 PCI_USES_MASTER, IS_CYCLONE|HAS_NWAY|HAS_HWCKSM|EXTRA_PREAMBLE, 128, },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700315
316 {"3c905B Cyclone 10/100/BNC",
Jeff Garzik1f1bd5f2006-06-26 23:47:50 -0400317 PCI_USES_MASTER, IS_CYCLONE|HAS_NWAY|HAS_HWCKSM, 128, },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700318 {"3c905B-FX Cyclone 100baseFx",
Jeff Garzik1f1bd5f2006-06-26 23:47:50 -0400319 PCI_USES_MASTER, IS_CYCLONE|HAS_HWCKSM, 128, },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700320 {"3c905C Tornado",
Jeff Garzik1f1bd5f2006-06-26 23:47:50 -0400321 PCI_USES_MASTER, IS_TORNADO|HAS_NWAY|HAS_HWCKSM|EXTRA_PREAMBLE, 128, },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700322 {"3c920B-EMB-WNM (ATI Radeon 9100 IGP)",
Jeff Garzik1f1bd5f2006-06-26 23:47:50 -0400323 PCI_USES_MASTER, IS_TORNADO|HAS_MII|HAS_HWCKSM, 128, },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700324 {"3c980 Cyclone",
Gunnar Larischaa807f72008-05-05 14:01:28 +0200325 PCI_USES_MASTER, IS_CYCLONE|HAS_HWCKSM|EXTRA_PREAMBLE, 128, },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700326
327 {"3c980C Python-T",
Jeff Garzik1f1bd5f2006-06-26 23:47:50 -0400328 PCI_USES_MASTER, IS_CYCLONE|HAS_NWAY|HAS_HWCKSM, 128, },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700329 {"3cSOHO100-TX Hurricane",
Steffen Klassertb8a1fce2007-07-09 11:50:23 -0700330 PCI_USES_MASTER, IS_CYCLONE|HAS_NWAY|HAS_HWCKSM|EXTRA_PREAMBLE, 128, },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700331 {"3c555 Laptop Hurricane",
Jeff Garzik1f1bd5f2006-06-26 23:47:50 -0400332 PCI_USES_MASTER, IS_CYCLONE|EEPROM_8BIT|HAS_HWCKSM, 128, },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700333 {"3c556 Laptop Tornado",
Jeff Garzik1f1bd5f2006-06-26 23:47:50 -0400334 PCI_USES_MASTER, IS_TORNADO|HAS_NWAY|EEPROM_8BIT|HAS_CB_FNS|INVERT_MII_PWR|
Linus Torvalds1da177e2005-04-16 15:20:36 -0700335 HAS_HWCKSM, 128, },
336 {"3c556B Laptop Hurricane",
Jeff Garzik1f1bd5f2006-06-26 23:47:50 -0400337 PCI_USES_MASTER, IS_TORNADO|HAS_NWAY|EEPROM_OFFSET|HAS_CB_FNS|INVERT_MII_PWR|
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338 WNO_XCVR_PWR|HAS_HWCKSM, 128, },
339
340 {"3c575 [Megahertz] 10/100 LAN CardBus",
Jeff Garzik1f1bd5f2006-06-26 23:47:50 -0400341 PCI_USES_MASTER, IS_BOOMERANG|HAS_MII|EEPROM_8BIT, 128, },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700342 {"3c575 Boomerang CardBus",
Jeff Garzik1f1bd5f2006-06-26 23:47:50 -0400343 PCI_USES_MASTER, IS_BOOMERANG|HAS_MII|EEPROM_8BIT, 128, },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700344 {"3CCFE575BT Cyclone CardBus",
Jeff Garzik1f1bd5f2006-06-26 23:47:50 -0400345 PCI_USES_MASTER, IS_CYCLONE|HAS_NWAY|HAS_CB_FNS|EEPROM_8BIT|
Linus Torvalds1da177e2005-04-16 15:20:36 -0700346 INVERT_LED_PWR|HAS_HWCKSM, 128, },
347 {"3CCFE575CT Tornado CardBus",
Jeff Garzik1f1bd5f2006-06-26 23:47:50 -0400348 PCI_USES_MASTER, IS_TORNADO|HAS_NWAY|HAS_CB_FNS|EEPROM_8BIT|INVERT_MII_PWR|
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349 MAX_COLLISION_RESET|HAS_HWCKSM, 128, },
350 {"3CCFE656 Cyclone CardBus",
Jeff Garzik1f1bd5f2006-06-26 23:47:50 -0400351 PCI_USES_MASTER, IS_CYCLONE|HAS_NWAY|HAS_CB_FNS|EEPROM_8BIT|INVERT_MII_PWR|
Linus Torvalds1da177e2005-04-16 15:20:36 -0700352 INVERT_LED_PWR|HAS_HWCKSM, 128, },
353
354 {"3CCFEM656B Cyclone+Winmodem CardBus",
Jeff Garzik1f1bd5f2006-06-26 23:47:50 -0400355 PCI_USES_MASTER, IS_CYCLONE|HAS_NWAY|HAS_CB_FNS|EEPROM_8BIT|INVERT_MII_PWR|
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356 INVERT_LED_PWR|HAS_HWCKSM, 128, },
357 {"3CXFEM656C Tornado+Winmodem CardBus", /* From pcmcia-cs-3.1.5 */
Jeff Garzik1f1bd5f2006-06-26 23:47:50 -0400358 PCI_USES_MASTER, IS_TORNADO|HAS_NWAY|HAS_CB_FNS|EEPROM_8BIT|INVERT_MII_PWR|
Linus Torvalds1da177e2005-04-16 15:20:36 -0700359 MAX_COLLISION_RESET|HAS_HWCKSM, 128, },
360 {"3c450 HomePNA Tornado", /* AKPM: from Don's 0.99Q */
Jeff Garzik1f1bd5f2006-06-26 23:47:50 -0400361 PCI_USES_MASTER, IS_TORNADO|HAS_NWAY|HAS_HWCKSM, 128, },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362 {"3c920 Tornado",
Jeff Garzik1f1bd5f2006-06-26 23:47:50 -0400363 PCI_USES_MASTER, IS_TORNADO|HAS_NWAY|HAS_HWCKSM, 128, },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700364 {"3c982 Hydra Dual Port A",
Jeff Garzik1f1bd5f2006-06-26 23:47:50 -0400365 PCI_USES_MASTER, IS_TORNADO|HAS_HWCKSM|HAS_NWAY, 128, },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700366
367 {"3c982 Hydra Dual Port B",
Jeff Garzik1f1bd5f2006-06-26 23:47:50 -0400368 PCI_USES_MASTER, IS_TORNADO|HAS_HWCKSM|HAS_NWAY, 128, },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369 {"3c905B-T4",
Jeff Garzik1f1bd5f2006-06-26 23:47:50 -0400370 PCI_USES_MASTER, IS_CYCLONE|HAS_NWAY|HAS_HWCKSM|EXTRA_PREAMBLE, 128, },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371 {"3c920B-EMB-WNM Tornado",
Jeff Garzik1f1bd5f2006-06-26 23:47:50 -0400372 PCI_USES_MASTER, IS_TORNADO|HAS_NWAY|HAS_HWCKSM, 128, },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700373
374 {NULL,}, /* NULL terminated list. */
375};
376
377
378static struct pci_device_id vortex_pci_tbl[] = {
379 { 0x10B7, 0x5900, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3C590 },
380 { 0x10B7, 0x5920, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3C592 },
381 { 0x10B7, 0x5970, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3C597 },
382 { 0x10B7, 0x5950, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3C595_1 },
383 { 0x10B7, 0x5951, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3C595_2 },
384
385 { 0x10B7, 0x5952, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3C595_3 },
386 { 0x10B7, 0x9000, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3C900_1 },
387 { 0x10B7, 0x9001, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3C900_2 },
388 { 0x10B7, 0x9004, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3C900_3 },
389 { 0x10B7, 0x9005, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3C900_4 },
390
391 { 0x10B7, 0x9006, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3C900_5 },
392 { 0x10B7, 0x900A, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3C900B_FL },
393 { 0x10B7, 0x9050, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3C905_1 },
394 { 0x10B7, 0x9051, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3C905_2 },
Pascal Terjanb4adbb42009-08-05 04:11:39 +0000395 { 0x10B7, 0x9054, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3C905B_TX },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700396 { 0x10B7, 0x9055, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3C905B_1 },
397
398 { 0x10B7, 0x9058, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3C905B_2 },
399 { 0x10B7, 0x905A, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3C905B_FX },
400 { 0x10B7, 0x9200, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3C905C },
401 { 0x10B7, 0x9202, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3C9202 },
402 { 0x10B7, 0x9800, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3C980 },
403 { 0x10B7, 0x9805, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3C9805 },
404
405 { 0x10B7, 0x7646, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3CSOHO100_TX },
406 { 0x10B7, 0x5055, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3C555 },
407 { 0x10B7, 0x6055, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3C556 },
408 { 0x10B7, 0x6056, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3C556B },
409 { 0x10B7, 0x5b57, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3C575 },
410
411 { 0x10B7, 0x5057, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3C575_1 },
412 { 0x10B7, 0x5157, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3CCFE575 },
413 { 0x10B7, 0x5257, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3CCFE575CT },
414 { 0x10B7, 0x6560, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3CCFE656 },
415 { 0x10B7, 0x6562, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3CCFEM656 },
416
417 { 0x10B7, 0x6564, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3CCFEM656_1 },
418 { 0x10B7, 0x4500, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3C450 },
419 { 0x10B7, 0x9201, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3C920 },
420 { 0x10B7, 0x1201, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3C982A },
421 { 0x10B7, 0x1202, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3C982B },
422
423 { 0x10B7, 0x9056, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_905BT4 },
424 { 0x10B7, 0x9210, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_920B_EMB_WNM },
425
426 {0,} /* 0 terminated list. */
427};
428MODULE_DEVICE_TABLE(pci, vortex_pci_tbl);
429
430
431/* Operational definitions.
432 These are not used by other compilation units and thus are not
433 exported in a ".h" file.
434
435 First the windows. There are eight register windows, with the command
436 and status registers available in each.
437 */
John W. Linville62afe592005-11-07 00:58:02 -0800438#define EL3WINDOW(win_num) iowrite16(SelectWindow + (win_num), ioaddr + EL3_CMD)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700439#define EL3_CMD 0x0e
440#define EL3_STATUS 0x0e
441
442/* The top five bits written to EL3_CMD are a command, the lower
443 11 bits are the parameter, if applicable.
444 Note that 11 parameters bits was fine for ethernet, but the new chip
445 can handle FDDI length frames (~4500 octets) and now parameters count
446 32-bit 'Dwords' rather than octets. */
447
448enum vortex_cmd {
449 TotalReset = 0<<11, SelectWindow = 1<<11, StartCoax = 2<<11,
450 RxDisable = 3<<11, RxEnable = 4<<11, RxReset = 5<<11,
451 UpStall = 6<<11, UpUnstall = (6<<11)+1,
452 DownStall = (6<<11)+2, DownUnstall = (6<<11)+3,
453 RxDiscard = 8<<11, TxEnable = 9<<11, TxDisable = 10<<11, TxReset = 11<<11,
454 FakeIntr = 12<<11, AckIntr = 13<<11, SetIntrEnb = 14<<11,
455 SetStatusEnb = 15<<11, SetRxFilter = 16<<11, SetRxThreshold = 17<<11,
456 SetTxThreshold = 18<<11, SetTxStart = 19<<11,
457 StartDMAUp = 20<<11, StartDMADown = (20<<11)+1, StatsEnable = 21<<11,
458 StatsDisable = 22<<11, StopCoax = 23<<11, SetFilterBit = 25<<11,};
459
460/* The SetRxFilter command accepts the following classes: */
461enum RxFilter {
462 RxStation = 1, RxMulticast = 2, RxBroadcast = 4, RxProm = 8 };
463
464/* Bits in the general status register. */
465enum vortex_status {
466 IntLatch = 0x0001, HostError = 0x0002, TxComplete = 0x0004,
467 TxAvailable = 0x0008, RxComplete = 0x0010, RxEarly = 0x0020,
468 IntReq = 0x0040, StatsFull = 0x0080,
469 DMADone = 1<<8, DownComplete = 1<<9, UpComplete = 1<<10,
470 DMAInProgress = 1<<11, /* DMA controller is still busy.*/
471 CmdInProgress = 1<<12, /* EL3_CMD is still busy.*/
472};
473
474/* Register window 1 offsets, the window used in normal operation.
475 On the Vortex this window is always mapped at offsets 0x10-0x1f. */
476enum Window1 {
477 TX_FIFO = 0x10, RX_FIFO = 0x10, RxErrors = 0x14,
478 RxStatus = 0x18, Timer=0x1A, TxStatus = 0x1B,
479 TxFree = 0x1C, /* Remaining free bytes in Tx buffer. */
480};
481enum Window0 {
482 Wn0EepromCmd = 10, /* Window 0: EEPROM command register. */
483 Wn0EepromData = 12, /* Window 0: EEPROM results register. */
484 IntrStatus=0x0E, /* Valid in all windows. */
485};
486enum Win0_EEPROM_bits {
487 EEPROM_Read = 0x80, EEPROM_WRITE = 0x40, EEPROM_ERASE = 0xC0,
488 EEPROM_EWENB = 0x30, /* Enable erasing/writing for 10 msec. */
489 EEPROM_EWDIS = 0x00, /* Disable EWENB before 10 msec timeout. */
490};
491/* EEPROM locations. */
492enum eeprom_offset {
493 PhysAddr01=0, PhysAddr23=1, PhysAddr45=2, ModelID=3,
494 EtherLink3ID=7, IFXcvrIO=8, IRQLine=9,
495 NodeAddr01=10, NodeAddr23=11, NodeAddr45=12,
496 DriverTune=13, Checksum=15};
497
498enum Window2 { /* Window 2. */
499 Wn2_ResetOptions=12,
500};
501enum Window3 { /* Window 3: MAC/config bits. */
502 Wn3_Config=0, Wn3_MaxPktSize=4, Wn3_MAC_Ctrl=6, Wn3_Options=8,
503};
504
505#define BFEXT(value, offset, bitcount) \
506 ((((unsigned long)(value)) >> (offset)) & ((1 << (bitcount)) - 1))
507
508#define BFINS(lhs, rhs, offset, bitcount) \
509 (((lhs) & ~((((1 << (bitcount)) - 1)) << (offset))) | \
510 (((rhs) & ((1 << (bitcount)) - 1)) << (offset)))
511
512#define RAM_SIZE(v) BFEXT(v, 0, 3)
513#define RAM_WIDTH(v) BFEXT(v, 3, 1)
514#define RAM_SPEED(v) BFEXT(v, 4, 2)
515#define ROM_SIZE(v) BFEXT(v, 6, 2)
516#define RAM_SPLIT(v) BFEXT(v, 16, 2)
517#define XCVR(v) BFEXT(v, 20, 4)
518#define AUTOSELECT(v) BFEXT(v, 24, 1)
519
520enum Window4 { /* Window 4: Xcvr/media bits. */
521 Wn4_FIFODiag = 4, Wn4_NetDiag = 6, Wn4_PhysicalMgmt=8, Wn4_Media = 10,
522};
523enum Win4_Media_bits {
524 Media_SQE = 0x0008, /* Enable SQE error counting for AUI. */
525 Media_10TP = 0x00C0, /* Enable link beat and jabber for 10baseT. */
526 Media_Lnk = 0x0080, /* Enable just link beat for 100TX/100FX. */
527 Media_LnkBeat = 0x0800,
528};
529enum Window7 { /* Window 7: Bus Master control. */
530 Wn7_MasterAddr = 0, Wn7_VlanEtherType=4, Wn7_MasterLen = 6,
531 Wn7_MasterStatus = 12,
532};
533/* Boomerang bus master control registers. */
534enum MasterCtrl {
535 PktStatus = 0x20, DownListPtr = 0x24, FragAddr = 0x28, FragLen = 0x2c,
536 TxFreeThreshold = 0x2f, UpPktStatus = 0x30, UpListPtr = 0x38,
537};
538
539/* The Rx and Tx descriptor lists.
540 Caution Alpha hackers: these types are 32 bits! Note also the 8 byte
541 alignment contraint on tx_ring[] and rx_ring[]. */
542#define LAST_FRAG 0x80000000 /* Last Addr/Len pair in descriptor. */
543#define DN_COMPLETE 0x00010000 /* This packet has been downloaded */
544struct boom_rx_desc {
Al Virocc2d6592007-08-22 21:34:46 -0400545 __le32 next; /* Last entry points to 0. */
546 __le32 status;
547 __le32 addr; /* Up to 63 addr/len pairs possible. */
548 __le32 length; /* Set LAST_FRAG to indicate last pair. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700549};
550/* Values for the Rx status entry. */
551enum rx_desc_status {
552 RxDComplete=0x00008000, RxDError=0x4000,
553 /* See boomerang_rx() for actual error bits */
554 IPChksumErr=1<<25, TCPChksumErr=1<<26, UDPChksumErr=1<<27,
555 IPChksumValid=1<<29, TCPChksumValid=1<<30, UDPChksumValid=1<<31,
556};
557
558#ifdef MAX_SKB_FRAGS
559#define DO_ZEROCOPY 1
560#else
561#define DO_ZEROCOPY 0
562#endif
563
564struct boom_tx_desc {
Al Virocc2d6592007-08-22 21:34:46 -0400565 __le32 next; /* Last entry points to 0. */
566 __le32 status; /* bits 0:12 length, others see below. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700567#if DO_ZEROCOPY
568 struct {
Al Virocc2d6592007-08-22 21:34:46 -0400569 __le32 addr;
570 __le32 length;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700571 } frag[1+MAX_SKB_FRAGS];
572#else
Al Virocc2d6592007-08-22 21:34:46 -0400573 __le32 addr;
574 __le32 length;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700575#endif
576};
577
578/* Values for the Tx status entry. */
579enum tx_desc_status {
580 CRCDisable=0x2000, TxDComplete=0x8000,
581 AddIPChksum=0x02000000, AddTCPChksum=0x04000000, AddUDPChksum=0x08000000,
582 TxIntrUploaded=0x80000000, /* IRQ when in FIFO, but maybe not sent. */
583};
584
585/* Chip features we care about in vp->capabilities, read from the EEPROM. */
586enum ChipCaps { CapBusMaster=0x20, CapPwrMgmt=0x2000 };
587
588struct vortex_extra_stats {
Steffen Klassert8d1d0342006-02-03 03:03:57 -0800589 unsigned long tx_deferred;
590 unsigned long tx_max_collisions;
591 unsigned long tx_multiple_collisions;
592 unsigned long tx_single_collisions;
593 unsigned long rx_bad_ssd;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700594};
595
596struct vortex_private {
597 /* The Rx and Tx rings should be quad-word-aligned. */
598 struct boom_rx_desc* rx_ring;
599 struct boom_tx_desc* tx_ring;
600 dma_addr_t rx_ring_dma;
601 dma_addr_t tx_ring_dma;
602 /* The addresses of transmit- and receive-in-place skbuffs. */
603 struct sk_buff* rx_skbuff[RX_RING_SIZE];
604 struct sk_buff* tx_skbuff[TX_RING_SIZE];
605 unsigned int cur_rx, cur_tx; /* The next free ring entry */
606 unsigned int dirty_rx, dirty_tx; /* The ring entries to be free()ed. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700607 struct vortex_extra_stats xstats; /* NIC-specific extra stats */
608 struct sk_buff *tx_skb; /* Packet being eaten by bus master ctrl. */
609 dma_addr_t tx_skb_dma; /* Allocated DMA address for bus master ctrl DMA. */
610
611 /* PCI configuration space information. */
612 struct device *gendev;
John W. Linville62afe592005-11-07 00:58:02 -0800613 void __iomem *ioaddr; /* IO address space */
614 void __iomem *cb_fn_base; /* CardBus function status addr space. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700615
616 /* Some values here only for performance evaluation and path-coverage */
617 int rx_nocopy, rx_copy, queued_packet, rx_csumhits;
618 int card_idx;
619
620 /* The remainder are related to chip state, mostly media selection. */
621 struct timer_list timer; /* Media selection timer. */
622 struct timer_list rx_oom_timer; /* Rx skb allocation retry timer */
623 int options; /* User-settable misc. driver options. */
624 unsigned int media_override:4, /* Passed-in media type. */
625 default_media:4, /* Read from the EEPROM/Wn3_Config. */
Steffen Klassert09ce3512006-03-31 02:30:48 -0800626 full_duplex:1, autoselect:1,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700627 bus_master:1, /* Vortex can only do a fragment bus-m. */
628 full_bus_master_tx:1, full_bus_master_rx:2, /* Boomerang */
629 flow_ctrl:1, /* Use 802.3x flow control (PAUSE only) */
630 partner_flow_ctrl:1, /* Partner supports flow control */
631 has_nway:1,
632 enable_wol:1, /* Wake-on-LAN is enabled */
633 pm_state_valid:1, /* pci_dev->saved_config_space has sane contents */
634 open:1,
635 medialock:1,
636 must_free_region:1, /* Flag: if zero, Cardbus owns the I/O region */
637 large_frames:1; /* accept large frames */
638 int drv_flags;
639 u16 status_enable;
640 u16 intr_enable;
641 u16 available_media; /* From Wn3_Options. */
642 u16 capabilities, info1, info2; /* Various, from EEPROM. */
643 u16 advertising; /* NWay media advertisement */
644 unsigned char phys[2]; /* MII device addresses. */
645 u16 deferred; /* Resend these interrupts when we
646 * bale from the ISR */
647 u16 io_size; /* Size of PCI region (for release_region) */
648 spinlock_t lock; /* Serialise access to device & its vortex_private */
649 struct mii_if_info mii; /* MII lib hooks/info */
650};
651
652#ifdef CONFIG_PCI
653#define DEVICE_PCI(dev) (((dev)->bus == &pci_bus_type) ? to_pci_dev((dev)) : NULL)
654#else
655#define DEVICE_PCI(dev) NULL
656#endif
657
658#define VORTEX_PCI(vp) (((vp)->gendev) ? DEVICE_PCI((vp)->gendev) : NULL)
659
660#ifdef CONFIG_EISA
661#define DEVICE_EISA(dev) (((dev)->bus == &eisa_bus_type) ? to_eisa_device((dev)) : NULL)
662#else
663#define DEVICE_EISA(dev) NULL
664#endif
665
666#define VORTEX_EISA(vp) (((vp)->gendev) ? DEVICE_EISA((vp)->gendev) : NULL)
667
668/* The action to take with a media selection timer tick.
669 Note that we deviate from the 3Com order by checking 10base2 before AUI.
670 */
671enum xcvr_types {
672 XCVR_10baseT=0, XCVR_AUI, XCVR_10baseTOnly, XCVR_10base2, XCVR_100baseTx,
673 XCVR_100baseFx, XCVR_MII=6, XCVR_NWAY=8, XCVR_ExtMII=9, XCVR_Default=10,
674};
675
Arjan van de Venf71e1302006-03-03 21:33:57 -0500676static const struct media_table {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700677 char *name;
678 unsigned int media_bits:16, /* Bits to set in Wn4_Media register. */
679 mask:8, /* The transceiver-present bit in Wn3_Config.*/
680 next:8; /* The media type to try next. */
681 int wait; /* Time before we check media status. */
682} media_tbl[] = {
683 { "10baseT", Media_10TP,0x08, XCVR_10base2, (14*HZ)/10},
684 { "10Mbs AUI", Media_SQE, 0x20, XCVR_Default, (1*HZ)/10},
685 { "undefined", 0, 0x80, XCVR_10baseT, 10000},
686 { "10base2", 0, 0x10, XCVR_AUI, (1*HZ)/10},
687 { "100baseTX", Media_Lnk, 0x02, XCVR_100baseFx, (14*HZ)/10},
688 { "100baseFX", Media_Lnk, 0x04, XCVR_MII, (14*HZ)/10},
689 { "MII", 0, 0x41, XCVR_10baseT, 3*HZ },
690 { "undefined", 0, 0x01, XCVR_10baseT, 10000},
691 { "Autonegotiate", 0, 0x41, XCVR_10baseT, 3*HZ},
692 { "MII-External", 0, 0x41, XCVR_10baseT, 3*HZ },
693 { "Default", 0, 0xFF, XCVR_10baseT, 10000},
694};
695
696static struct {
697 const char str[ETH_GSTRING_LEN];
698} ethtool_stats_keys[] = {
699 { "tx_deferred" },
Steffen Klassert8d1d0342006-02-03 03:03:57 -0800700 { "tx_max_collisions" },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700701 { "tx_multiple_collisions" },
Steffen Klassert8d1d0342006-02-03 03:03:57 -0800702 { "tx_single_collisions" },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700703 { "rx_bad_ssd" },
704};
705
706/* number of ETHTOOL_GSTATS u64's */
Steffen Klassert8d1d0342006-02-03 03:03:57 -0800707#define VORTEX_NUM_STATS 5
Linus Torvalds1da177e2005-04-16 15:20:36 -0700708
John W. Linville62afe592005-11-07 00:58:02 -0800709static int vortex_probe1(struct device *gendev, void __iomem *ioaddr, int irq,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700710 int chip_idx, int card_idx);
Mark Hindleyc8303d12007-08-16 11:28:40 +0100711static int vortex_up(struct net_device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700712static void vortex_down(struct net_device *dev, int final);
713static int vortex_open(struct net_device *dev);
John W. Linville62afe592005-11-07 00:58:02 -0800714static void mdio_sync(void __iomem *ioaddr, int bits);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700715static int mdio_read(struct net_device *dev, int phy_id, int location);
716static void mdio_write(struct net_device *vp, int phy_id, int location, int value);
717static void vortex_timer(unsigned long arg);
718static void rx_oom_timer(unsigned long arg);
Stephen Hemminger27a1de92009-08-31 19:50:54 +0000719static netdev_tx_t vortex_start_xmit(struct sk_buff *skb,
720 struct net_device *dev);
721static netdev_tx_t boomerang_start_xmit(struct sk_buff *skb,
722 struct net_device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700723static int vortex_rx(struct net_device *dev);
724static int boomerang_rx(struct net_device *dev);
David Howells7d12e782006-10-05 14:55:46 +0100725static irqreturn_t vortex_interrupt(int irq, void *dev_id);
726static irqreturn_t boomerang_interrupt(int irq, void *dev_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700727static int vortex_close(struct net_device *dev);
728static void dump_tx_ring(struct net_device *dev);
John W. Linville62afe592005-11-07 00:58:02 -0800729static void update_stats(void __iomem *ioaddr, struct net_device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700730static struct net_device_stats *vortex_get_stats(struct net_device *dev);
731static void set_rx_mode(struct net_device *dev);
732#ifdef CONFIG_PCI
733static int vortex_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
734#endif
735static void vortex_tx_timeout(struct net_device *dev);
736static void acpi_set_WOL(struct net_device *dev);
Jeff Garzik7282d492006-09-13 14:30:00 -0400737static const struct ethtool_ops vortex_ethtool_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700738static void set_8021q_mode(struct net_device *dev, int enable);
739
Linus Torvalds1da177e2005-04-16 15:20:36 -0700740/* This driver uses 'options' to pass the media type, full-duplex flag, etc. */
741/* Option count limit only -- unlimited interfaces are supported. */
742#define MAX_UNITS 8
John W. Linville9954ab72005-11-07 00:58:06 -0800743static int options[MAX_UNITS] = { [0 ... MAX_UNITS-1] = -1 };
744static int full_duplex[MAX_UNITS] = {[0 ... MAX_UNITS-1] = -1 };
745static int hw_checksums[MAX_UNITS] = {[0 ... MAX_UNITS-1] = -1 };
746static int flow_ctrl[MAX_UNITS] = {[0 ... MAX_UNITS-1] = -1 };
747static int enable_wol[MAX_UNITS] = {[0 ... MAX_UNITS-1] = -1 };
John W. Linville900fd172005-11-07 00:58:08 -0800748static int use_mmio[MAX_UNITS] = {[0 ... MAX_UNITS-1] = -1 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700749static int global_options = -1;
750static int global_full_duplex = -1;
751static int global_enable_wol = -1;
John W. Linville900fd172005-11-07 00:58:08 -0800752static int global_use_mmio = -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700753
Linus Torvalds1da177e2005-04-16 15:20:36 -0700754/* Variables to work-around the Compaq PCI BIOS32 problem. */
755static int compaq_ioaddr, compaq_irq, compaq_device_id = 0x5900;
756static struct net_device *compaq_net_device;
757
758static int vortex_cards_found;
759
760module_param(debug, int, 0);
761module_param(global_options, int, 0);
762module_param_array(options, int, NULL, 0);
763module_param(global_full_duplex, int, 0);
764module_param_array(full_duplex, int, NULL, 0);
765module_param_array(hw_checksums, int, NULL, 0);
766module_param_array(flow_ctrl, int, NULL, 0);
767module_param(global_enable_wol, int, 0);
768module_param_array(enable_wol, int, NULL, 0);
769module_param(rx_copybreak, int, 0);
770module_param(max_interrupt_work, int, 0);
771module_param(compaq_ioaddr, int, 0);
772module_param(compaq_irq, int, 0);
773module_param(compaq_device_id, int, 0);
774module_param(watchdog, int, 0);
John W. Linville900fd172005-11-07 00:58:08 -0800775module_param(global_use_mmio, int, 0);
776module_param_array(use_mmio, int, NULL, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700777MODULE_PARM_DESC(debug, "3c59x debug level (0-6)");
778MODULE_PARM_DESC(options, "3c59x: Bits 0-3: media type, bit 4: bus mastering, bit 9: full duplex");
779MODULE_PARM_DESC(global_options, "3c59x: same as options, but applies to all NICs if options is unset");
780MODULE_PARM_DESC(full_duplex, "3c59x full duplex setting(s) (1)");
John W. Linville46e5e4a2005-11-07 00:58:06 -0800781MODULE_PARM_DESC(global_full_duplex, "3c59x: same as full_duplex, but applies to all NICs if full_duplex is unset");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700782MODULE_PARM_DESC(hw_checksums, "3c59x Hardware checksum checking by adapter(s) (0-1)");
783MODULE_PARM_DESC(flow_ctrl, "3c59x 802.3x flow control usage (PAUSE only) (0-1)");
784MODULE_PARM_DESC(enable_wol, "3c59x: Turn on Wake-on-LAN for adapter(s) (0-1)");
John W. Linville46e5e4a2005-11-07 00:58:06 -0800785MODULE_PARM_DESC(global_enable_wol, "3c59x: same as enable_wol, but applies to all NICs if enable_wol is unset");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700786MODULE_PARM_DESC(rx_copybreak, "3c59x copy breakpoint for copy-only-tiny-frames");
787MODULE_PARM_DESC(max_interrupt_work, "3c59x maximum events handled per interrupt");
788MODULE_PARM_DESC(compaq_ioaddr, "3c59x PCI I/O base address (Compaq BIOS problem workaround)");
789MODULE_PARM_DESC(compaq_irq, "3c59x PCI IRQ number (Compaq BIOS problem workaround)");
790MODULE_PARM_DESC(compaq_device_id, "3c59x PCI device ID (Compaq BIOS problem workaround)");
791MODULE_PARM_DESC(watchdog, "3c59x transmit timeout in milliseconds");
John W. Linville900fd172005-11-07 00:58:08 -0800792MODULE_PARM_DESC(global_use_mmio, "3c59x: same as use_mmio, but applies to all NICs if options is unset");
793MODULE_PARM_DESC(use_mmio, "3c59x: use memory-mapped PCI I/O resource (0-1)");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700794
795#ifdef CONFIG_NET_POLL_CONTROLLER
796static void poll_vortex(struct net_device *dev)
797{
798 struct vortex_private *vp = netdev_priv(dev);
799 unsigned long flags;
Jiri Kosina0d38ff12007-02-05 16:29:48 -0800800 local_irq_save(flags);
David Howells7d12e782006-10-05 14:55:46 +0100801 (vp->full_bus_master_rx ? boomerang_interrupt:vortex_interrupt)(dev->irq,dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700802 local_irq_restore(flags);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400803}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700804#endif
805
806#ifdef CONFIG_PM
807
Anton Vorontsov7bfc4ab2009-09-30 20:11:11 -0700808static int vortex_suspend(struct device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700809{
Anton Vorontsov7bfc4ab2009-09-30 20:11:11 -0700810 struct pci_dev *pdev = to_pci_dev(dev);
811 struct net_device *ndev = pci_get_drvdata(pdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700812
Anton Vorontsov7bfc4ab2009-09-30 20:11:11 -0700813 if (!ndev || !netif_running(ndev))
814 return 0;
815
816 netif_device_detach(ndev);
817 vortex_down(ndev, 1);
818
Linus Torvalds1da177e2005-04-16 15:20:36 -0700819 return 0;
820}
821
Anton Vorontsov7bfc4ab2009-09-30 20:11:11 -0700822static int vortex_resume(struct device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700823{
Anton Vorontsov7bfc4ab2009-09-30 20:11:11 -0700824 struct pci_dev *pdev = to_pci_dev(dev);
825 struct net_device *ndev = pci_get_drvdata(pdev);
Dmitriy Monakhove1265152007-03-06 02:41:59 -0800826 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700827
Anton Vorontsov7bfc4ab2009-09-30 20:11:11 -0700828 if (!ndev || !netif_running(ndev))
829 return 0;
830
831 err = vortex_up(ndev);
832 if (err)
833 return err;
834
835 netif_device_attach(ndev);
836
Linus Torvalds1da177e2005-04-16 15:20:36 -0700837 return 0;
838}
839
Anton Vorontsov7bfc4ab2009-09-30 20:11:11 -0700840static struct dev_pm_ops vortex_pm_ops = {
841 .suspend = vortex_suspend,
842 .resume = vortex_resume,
843 .freeze = vortex_suspend,
844 .thaw = vortex_resume,
845 .poweroff = vortex_suspend,
846 .restore = vortex_resume,
847};
848
849#define VORTEX_PM_OPS (&vortex_pm_ops)
850
851#else /* !CONFIG_PM */
852
853#define VORTEX_PM_OPS NULL
854
855#endif /* !CONFIG_PM */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700856
857#ifdef CONFIG_EISA
858static struct eisa_device_id vortex_eisa_ids[] = {
859 { "TCM5920", CH_3C592 },
860 { "TCM5970", CH_3C597 },
861 { "" }
862};
Michael Tokarev07563c72006-09-27 01:50:56 -0700863MODULE_DEVICE_TABLE(eisa, vortex_eisa_ids);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700864
Ralf Baechle95c408a2007-03-08 15:33:16 +0000865static int __init vortex_eisa_probe(struct device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700866{
John W. Linville62afe592005-11-07 00:58:02 -0800867 void __iomem *ioaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700868 struct eisa_device *edev;
869
Steffen Klasserta880c4c2006-03-26 01:37:43 -0800870 edev = to_eisa_device(device);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700871
John W. Linville62afe592005-11-07 00:58:02 -0800872 if (!request_region(edev->base_addr, VORTEX_TOTAL_SIZE, DRV_NAME))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700873 return -EBUSY;
874
John W. Linville62afe592005-11-07 00:58:02 -0800875 ioaddr = ioport_map(edev->base_addr, VORTEX_TOTAL_SIZE);
876
877 if (vortex_probe1(device, ioaddr, ioread16(ioaddr + 0xC88) >> 12,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700878 edev->id.driver_data, vortex_cards_found)) {
Steffen Klasserta880c4c2006-03-26 01:37:43 -0800879 release_region(edev->base_addr, VORTEX_TOTAL_SIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700880 return -ENODEV;
881 }
882
883 vortex_cards_found++;
884
885 return 0;
886}
887
Ralf Baechle95c408a2007-03-08 15:33:16 +0000888static int __devexit vortex_eisa_remove(struct device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700889{
890 struct eisa_device *edev;
891 struct net_device *dev;
892 struct vortex_private *vp;
John W. Linville62afe592005-11-07 00:58:02 -0800893 void __iomem *ioaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700894
Steffen Klasserta880c4c2006-03-26 01:37:43 -0800895 edev = to_eisa_device(device);
896 dev = eisa_get_drvdata(edev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700897
898 if (!dev) {
Alexander Beregalov39738e12009-05-26 12:35:26 +0000899 pr_err("vortex_eisa_remove called for Compaq device!\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700900 BUG();
901 }
902
903 vp = netdev_priv(dev);
John W. Linville62afe592005-11-07 00:58:02 -0800904 ioaddr = vp->ioaddr;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400905
Steffen Klasserta880c4c2006-03-26 01:37:43 -0800906 unregister_netdev(dev);
907 iowrite16(TotalReset|0x14, ioaddr + EL3_CMD);
908 release_region(dev->base_addr, VORTEX_TOTAL_SIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700909
Steffen Klasserta880c4c2006-03-26 01:37:43 -0800910 free_netdev(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700911 return 0;
912}
Ralf Baechle95c408a2007-03-08 15:33:16 +0000913
914static struct eisa_driver vortex_eisa_driver = {
915 .id_table = vortex_eisa_ids,
916 .driver = {
917 .name = "3c59x",
918 .probe = vortex_eisa_probe,
919 .remove = __devexit_p(vortex_eisa_remove)
920 }
921};
922
923#endif /* CONFIG_EISA */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700924
925/* returns count found (>= 0), or negative on error */
Steffen Klasserta880c4c2006-03-26 01:37:43 -0800926static int __init vortex_eisa_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700927{
928 int eisa_found = 0;
929 int orig_cards_found = vortex_cards_found;
930
931#ifdef CONFIG_EISA
Bjorn Helgaasc2f6fab2006-03-25 03:07:19 -0800932 int err;
933
934 err = eisa_driver_register (&vortex_eisa_driver);
935 if (!err) {
936 /*
937 * Because of the way EISA bus is probed, we cannot assume
938 * any device have been found when we exit from
939 * eisa_driver_register (the bus root driver may not be
940 * initialized yet). So we blindly assume something was
941 * found, and let the sysfs magic happend...
942 */
943 eisa_found = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700944 }
945#endif
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400946
Linus Torvalds1da177e2005-04-16 15:20:36 -0700947 /* Special code to work-around the Compaq PCI BIOS32 problem. */
948 if (compaq_ioaddr) {
John W. Linville62afe592005-11-07 00:58:02 -0800949 vortex_probe1(NULL, ioport_map(compaq_ioaddr, VORTEX_TOTAL_SIZE),
950 compaq_irq, compaq_device_id, vortex_cards_found++);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700951 }
952
953 return vortex_cards_found - orig_cards_found + eisa_found;
954}
955
956/* returns count (>= 0), or negative on error */
Steffen Klasserta880c4c2006-03-26 01:37:43 -0800957static int __devinit vortex_init_one(struct pci_dev *pdev,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700958 const struct pci_device_id *ent)
959{
John W. Linville900fd172005-11-07 00:58:08 -0800960 int rc, unit, pci_bar;
961 struct vortex_chip_info *vci;
962 void __iomem *ioaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700963
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400964 /* wake up and enable device */
Steffen Klasserta880c4c2006-03-26 01:37:43 -0800965 rc = pci_enable_device(pdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700966 if (rc < 0)
967 goto out;
968
John W. Linville900fd172005-11-07 00:58:08 -0800969 unit = vortex_cards_found;
970
971 if (global_use_mmio < 0 && (unit >= MAX_UNITS || use_mmio[unit] < 0)) {
972 /* Determine the default if the user didn't override us */
973 vci = &vortex_info_tbl[ent->driver_data];
974 pci_bar = vci->drv_flags & (IS_CYCLONE | IS_TORNADO) ? 1 : 0;
975 } else if (unit < MAX_UNITS && use_mmio[unit] >= 0)
976 pci_bar = use_mmio[unit] ? 1 : 0;
977 else
978 pci_bar = global_use_mmio ? 1 : 0;
979
980 ioaddr = pci_iomap(pdev, pci_bar, 0);
981 if (!ioaddr) /* If mapping fails, fall-back to BAR 0... */
982 ioaddr = pci_iomap(pdev, 0, 0);
983
984 rc = vortex_probe1(&pdev->dev, ioaddr, pdev->irq,
985 ent->driver_data, unit);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700986 if (rc < 0) {
Steffen Klasserta880c4c2006-03-26 01:37:43 -0800987 pci_disable_device(pdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700988 goto out;
989 }
990
991 vortex_cards_found++;
992
993out:
994 return rc;
995}
996
Stephen Hemminger48b47a52009-01-09 13:01:18 +0000997static const struct net_device_ops boomrang_netdev_ops = {
998 .ndo_open = vortex_open,
999 .ndo_stop = vortex_close,
1000 .ndo_start_xmit = boomerang_start_xmit,
1001 .ndo_tx_timeout = vortex_tx_timeout,
1002 .ndo_get_stats = vortex_get_stats,
1003#ifdef CONFIG_PCI
1004 .ndo_do_ioctl = vortex_ioctl,
1005#endif
1006 .ndo_set_multicast_list = set_rx_mode,
1007 .ndo_change_mtu = eth_change_mtu,
1008 .ndo_set_mac_address = eth_mac_addr,
1009 .ndo_validate_addr = eth_validate_addr,
1010#ifdef CONFIG_NET_POLL_CONTROLLER
1011 .ndo_poll_controller = poll_vortex,
1012#endif
1013};
1014
1015static const struct net_device_ops vortex_netdev_ops = {
1016 .ndo_open = vortex_open,
1017 .ndo_stop = vortex_close,
1018 .ndo_start_xmit = vortex_start_xmit,
1019 .ndo_tx_timeout = vortex_tx_timeout,
1020 .ndo_get_stats = vortex_get_stats,
1021#ifdef CONFIG_PCI
1022 .ndo_do_ioctl = vortex_ioctl,
1023#endif
1024 .ndo_set_multicast_list = set_rx_mode,
1025 .ndo_change_mtu = eth_change_mtu,
1026 .ndo_set_mac_address = eth_mac_addr,
1027 .ndo_validate_addr = eth_validate_addr,
1028#ifdef CONFIG_NET_POLL_CONTROLLER
1029 .ndo_poll_controller = poll_vortex,
1030#endif
1031};
1032
Linus Torvalds1da177e2005-04-16 15:20:36 -07001033/*
1034 * Start up the PCI/EISA device which is described by *gendev.
1035 * Return 0 on success.
1036 *
1037 * NOTE: pdev can be NULL, for the case of a Compaq device
1038 */
1039static int __devinit vortex_probe1(struct device *gendev,
John W. Linville62afe592005-11-07 00:58:02 -08001040 void __iomem *ioaddr, int irq,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001041 int chip_idx, int card_idx)
1042{
1043 struct vortex_private *vp;
1044 int option;
1045 unsigned int eeprom[0x40], checksum = 0; /* EEPROM contents */
1046 int i, step;
1047 struct net_device *dev;
1048 static int printed_version;
1049 int retval, print_info;
1050 struct vortex_chip_info * const vci = &vortex_info_tbl[chip_idx];
Greg Kroah-Hartman361d5ee2008-07-02 12:46:22 -07001051 const char *print_name = "3c59x";
Linus Torvalds1da177e2005-04-16 15:20:36 -07001052 struct pci_dev *pdev = NULL;
1053 struct eisa_device *edev = NULL;
1054
1055 if (!printed_version) {
Alexander Beregalov39738e12009-05-26 12:35:26 +00001056 pr_info("%s", version);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001057 printed_version = 1;
1058 }
1059
1060 if (gendev) {
1061 if ((pdev = DEVICE_PCI(gendev))) {
1062 print_name = pci_name(pdev);
1063 }
1064
1065 if ((edev = DEVICE_EISA(gendev))) {
Kay Sieversfb28ad32008-11-10 13:55:14 -08001066 print_name = dev_name(&edev->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001067 }
1068 }
1069
1070 dev = alloc_etherdev(sizeof(*vp));
1071 retval = -ENOMEM;
1072 if (!dev) {
Alexander Beregalov39738e12009-05-26 12:35:26 +00001073 pr_err(PFX "unable to allocate etherdev, aborting\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001074 goto out;
1075 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001076 SET_NETDEV_DEV(dev, gendev);
1077 vp = netdev_priv(dev);
1078
1079 option = global_options;
1080
1081 /* The lower four bits are the media type. */
1082 if (dev->mem_start) {
1083 /*
1084 * The 'options' param is passed in as the third arg to the
1085 * LILO 'ether=' argument for non-modular use
1086 */
1087 option = dev->mem_start;
1088 }
1089 else if (card_idx < MAX_UNITS) {
1090 if (options[card_idx] >= 0)
1091 option = options[card_idx];
1092 }
1093
1094 if (option > 0) {
1095 if (option & 0x8000)
1096 vortex_debug = 7;
1097 if (option & 0x4000)
1098 vortex_debug = 2;
1099 if (option & 0x0400)
1100 vp->enable_wol = 1;
1101 }
1102
1103 print_info = (vortex_debug > 1);
1104 if (print_info)
Alexander Beregalov39738e12009-05-26 12:35:26 +00001105 pr_info("See Documentation/networking/vortex.txt\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001106
Alexander Beregalov39738e12009-05-26 12:35:26 +00001107 pr_info("%s: 3Com %s %s at %p.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001108 print_name,
1109 pdev ? "PCI" : "EISA",
1110 vci->name,
1111 ioaddr);
1112
John W. Linville62afe592005-11-07 00:58:02 -08001113 dev->base_addr = (unsigned long)ioaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001114 dev->irq = irq;
1115 dev->mtu = mtu;
John W. Linville62afe592005-11-07 00:58:02 -08001116 vp->ioaddr = ioaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001117 vp->large_frames = mtu > 1500;
1118 vp->drv_flags = vci->drv_flags;
1119 vp->has_nway = (vci->drv_flags & HAS_NWAY) ? 1 : 0;
1120 vp->io_size = vci->io_size;
1121 vp->card_idx = card_idx;
1122
1123 /* module list only for Compaq device */
1124 if (gendev == NULL) {
1125 compaq_net_device = dev;
1126 }
1127
1128 /* PCI-only startup logic */
1129 if (pdev) {
1130 /* EISA resources already marked, so only PCI needs to do this here */
1131 /* Ignore return value, because Cardbus drivers already allocate for us */
John W. Linville62afe592005-11-07 00:58:02 -08001132 if (request_region(dev->base_addr, vci->io_size, print_name) != NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001133 vp->must_free_region = 1;
1134
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001135 /* enable bus-mastering if necessary */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001136 if (vci->flags & PCI_USES_MASTER)
Steffen Klasserta880c4c2006-03-26 01:37:43 -08001137 pci_set_master(pdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001138
1139 if (vci->drv_flags & IS_VORTEX) {
1140 u8 pci_latency;
1141 u8 new_latency = 248;
1142
1143 /* Check the PCI latency value. On the 3c590 series the latency timer
1144 must be set to the maximum value to avoid data corruption that occurs
1145 when the timer expires during a transfer. This bug exists the Vortex
1146 chip only. */
1147 pci_read_config_byte(pdev, PCI_LATENCY_TIMER, &pci_latency);
1148 if (pci_latency < new_latency) {
Alexander Beregalov39738e12009-05-26 12:35:26 +00001149 pr_info("%s: Overriding PCI latency timer (CFLT) setting of %d, new value is %d.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001150 print_name, pci_latency, new_latency);
Alexander Beregalov39738e12009-05-26 12:35:26 +00001151 pci_write_config_byte(pdev, PCI_LATENCY_TIMER, new_latency);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001152 }
1153 }
1154 }
1155
1156 spin_lock_init(&vp->lock);
1157 vp->gendev = gendev;
1158 vp->mii.dev = dev;
1159 vp->mii.mdio_read = mdio_read;
1160 vp->mii.mdio_write = mdio_write;
1161 vp->mii.phy_id_mask = 0x1f;
1162 vp->mii.reg_num_mask = 0x1f;
1163
1164 /* Makes sure rings are at least 16 byte aligned. */
1165 vp->rx_ring = pci_alloc_consistent(pdev, sizeof(struct boom_rx_desc) * RX_RING_SIZE
1166 + sizeof(struct boom_tx_desc) * TX_RING_SIZE,
1167 &vp->rx_ring_dma);
1168 retval = -ENOMEM;
Al Virocc2d6592007-08-22 21:34:46 -04001169 if (!vp->rx_ring)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001170 goto free_region;
1171
1172 vp->tx_ring = (struct boom_tx_desc *)(vp->rx_ring + RX_RING_SIZE);
1173 vp->tx_ring_dma = vp->rx_ring_dma + sizeof(struct boom_rx_desc) * RX_RING_SIZE;
1174
1175 /* if we are a PCI driver, we store info in pdev->driver_data
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001176 * instead of a module list */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001177 if (pdev)
1178 pci_set_drvdata(pdev, dev);
1179 if (edev)
Steffen Klasserta880c4c2006-03-26 01:37:43 -08001180 eisa_set_drvdata(edev, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001181
1182 vp->media_override = 7;
1183 if (option >= 0) {
1184 vp->media_override = ((option & 7) == 2) ? 0 : option & 15;
1185 if (vp->media_override != 7)
1186 vp->medialock = 1;
1187 vp->full_duplex = (option & 0x200) ? 1 : 0;
1188 vp->bus_master = (option & 16) ? 1 : 0;
1189 }
1190
1191 if (global_full_duplex > 0)
1192 vp->full_duplex = 1;
1193 if (global_enable_wol > 0)
1194 vp->enable_wol = 1;
1195
1196 if (card_idx < MAX_UNITS) {
1197 if (full_duplex[card_idx] > 0)
1198 vp->full_duplex = 1;
1199 if (flow_ctrl[card_idx] > 0)
1200 vp->flow_ctrl = 1;
1201 if (enable_wol[card_idx] > 0)
1202 vp->enable_wol = 1;
1203 }
1204
Steffen Klassert125d5ce2006-03-26 01:37:39 -08001205 vp->mii.force_media = vp->full_duplex;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001206 vp->options = option;
1207 /* Read the station address from the EEPROM. */
1208 EL3WINDOW(0);
1209 {
1210 int base;
1211
1212 if (vci->drv_flags & EEPROM_8BIT)
1213 base = 0x230;
1214 else if (vci->drv_flags & EEPROM_OFFSET)
1215 base = EEPROM_Read + 0x30;
1216 else
1217 base = EEPROM_Read;
1218
1219 for (i = 0; i < 0x40; i++) {
1220 int timer;
John W. Linville62afe592005-11-07 00:58:02 -08001221 iowrite16(base + i, ioaddr + Wn0EepromCmd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001222 /* Pause for at least 162 us. for the read to take place. */
1223 for (timer = 10; timer >= 0; timer--) {
1224 udelay(162);
John W. Linville62afe592005-11-07 00:58:02 -08001225 if ((ioread16(ioaddr + Wn0EepromCmd) & 0x8000) == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001226 break;
1227 }
John W. Linville62afe592005-11-07 00:58:02 -08001228 eeprom[i] = ioread16(ioaddr + Wn0EepromData);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001229 }
1230 }
1231 for (i = 0; i < 0x18; i++)
1232 checksum ^= eeprom[i];
1233 checksum = (checksum ^ (checksum >> 8)) & 0xff;
1234 if (checksum != 0x00) { /* Grrr, needless incompatible change 3Com. */
1235 while (i < 0x21)
1236 checksum ^= eeprom[i++];
1237 checksum = (checksum ^ (checksum >> 8)) & 0xff;
1238 }
1239 if ((checksum != 0x00) && !(vci->drv_flags & IS_TORNADO))
Alexander Beregalov39738e12009-05-26 12:35:26 +00001240 pr_cont(" ***INVALID CHECKSUM %4.4x*** ", checksum);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001241 for (i = 0; i < 3; i++)
Al Virocc2d6592007-08-22 21:34:46 -04001242 ((__be16 *)dev->dev_addr)[i] = htons(eeprom[i + 10]);
John W. Linvillebb531fc2005-11-07 00:58:07 -08001243 memcpy(dev->perm_addr, dev->dev_addr, dev->addr_len);
Joe Perches0795af52007-10-03 17:59:30 -07001244 if (print_info)
Alexander Beregalov39738e12009-05-26 12:35:26 +00001245 pr_cont(" %pM", dev->dev_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001246 /* Unfortunately an all zero eeprom passes the checksum and this
1247 gets found in the wild in failure cases. Crypto is hard 8) */
1248 if (!is_valid_ether_addr(dev->dev_addr)) {
1249 retval = -EINVAL;
Alexander Beregalov39738e12009-05-26 12:35:26 +00001250 pr_err("*** EEPROM MAC address is invalid.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001251 goto free_ring; /* With every pack */
1252 }
1253 EL3WINDOW(2);
1254 for (i = 0; i < 6; i++)
John W. Linville62afe592005-11-07 00:58:02 -08001255 iowrite8(dev->dev_addr[i], ioaddr + i);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001256
Linus Torvalds1da177e2005-04-16 15:20:36 -07001257 if (print_info)
Alexander Beregalov39738e12009-05-26 12:35:26 +00001258 pr_cont(", IRQ %d\n", dev->irq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001259 /* Tell them about an invalid IRQ. */
Yinghai Lu60e4ad72008-08-19 20:49:50 -07001260 if (dev->irq <= 0 || dev->irq >= nr_irqs)
Alexander Beregalov39738e12009-05-26 12:35:26 +00001261 pr_warning(" *** Warning: IRQ %d is unlikely to work! ***\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001262 dev->irq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001263
1264 EL3WINDOW(4);
John W. Linville62afe592005-11-07 00:58:02 -08001265 step = (ioread8(ioaddr + Wn4_NetDiag) & 0x1e) >> 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001266 if (print_info) {
Alexander Beregalov39738e12009-05-26 12:35:26 +00001267 pr_info(" product code %02x%02x rev %02x.%d date %02d-%02d-%02d\n",
1268 eeprom[6]&0xff, eeprom[6]>>8, eeprom[0x14],
Linus Torvalds1da177e2005-04-16 15:20:36 -07001269 step, (eeprom[4]>>5) & 15, eeprom[4] & 31, eeprom[4]>>9);
1270 }
1271
1272
1273 if (pdev && vci->drv_flags & HAS_CB_FNS) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001274 unsigned short n;
1275
John W. Linville62afe592005-11-07 00:58:02 -08001276 vp->cb_fn_base = pci_iomap(pdev, 2, 0);
1277 if (!vp->cb_fn_base) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001278 retval = -ENOMEM;
John W. Linville62afe592005-11-07 00:58:02 -08001279 goto free_ring;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001280 }
John W. Linville62afe592005-11-07 00:58:02 -08001281
Linus Torvalds1da177e2005-04-16 15:20:36 -07001282 if (print_info) {
Alexander Beregalov39738e12009-05-26 12:35:26 +00001283 pr_info("%s: CardBus functions mapped %16.16llx->%p\n",
Greg Kroah-Hartman7c7459d2006-06-12 15:13:08 -07001284 print_name,
1285 (unsigned long long)pci_resource_start(pdev, 2),
John W. Linville62afe592005-11-07 00:58:02 -08001286 vp->cb_fn_base);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001287 }
1288 EL3WINDOW(2);
1289
John W. Linville62afe592005-11-07 00:58:02 -08001290 n = ioread16(ioaddr + Wn2_ResetOptions) & ~0x4010;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001291 if (vp->drv_flags & INVERT_LED_PWR)
1292 n |= 0x10;
1293 if (vp->drv_flags & INVERT_MII_PWR)
1294 n |= 0x4000;
John W. Linville62afe592005-11-07 00:58:02 -08001295 iowrite16(n, ioaddr + Wn2_ResetOptions);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001296 if (vp->drv_flags & WNO_XCVR_PWR) {
1297 EL3WINDOW(0);
John W. Linville62afe592005-11-07 00:58:02 -08001298 iowrite16(0x0800, ioaddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001299 }
1300 }
1301
1302 /* Extract our information from the EEPROM data. */
1303 vp->info1 = eeprom[13];
1304 vp->info2 = eeprom[15];
1305 vp->capabilities = eeprom[16];
1306
1307 if (vp->info1 & 0x8000) {
1308 vp->full_duplex = 1;
1309 if (print_info)
Alexander Beregalov39738e12009-05-26 12:35:26 +00001310 pr_info("Full duplex capable\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001311 }
1312
1313 {
Arjan van de Venf71e1302006-03-03 21:33:57 -05001314 static const char * const ram_split[] = {"5:3", "3:1", "1:1", "3:5"};
Linus Torvalds1da177e2005-04-16 15:20:36 -07001315 unsigned int config;
1316 EL3WINDOW(3);
John W. Linville62afe592005-11-07 00:58:02 -08001317 vp->available_media = ioread16(ioaddr + Wn3_Options);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001318 if ((vp->available_media & 0xff) == 0) /* Broken 3c916 */
1319 vp->available_media = 0x40;
John W. Linville62afe592005-11-07 00:58:02 -08001320 config = ioread32(ioaddr + Wn3_Config);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001321 if (print_info) {
Alexander Beregalov39738e12009-05-26 12:35:26 +00001322 pr_debug(" Internal config register is %4.4x, transceivers %#x.\n",
1323 config, ioread16(ioaddr + Wn3_Options));
1324 pr_info(" %dK %s-wide RAM %s Rx:Tx split, %s%s interface.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001325 8 << RAM_SIZE(config),
1326 RAM_WIDTH(config) ? "word" : "byte",
1327 ram_split[RAM_SPLIT(config)],
1328 AUTOSELECT(config) ? "autoselect/" : "",
1329 XCVR(config) > XCVR_ExtMII ? "<invalid transceiver>" :
1330 media_tbl[XCVR(config)].name);
1331 }
1332 vp->default_media = XCVR(config);
1333 if (vp->default_media == XCVR_NWAY)
1334 vp->has_nway = 1;
1335 vp->autoselect = AUTOSELECT(config);
1336 }
1337
1338 if (vp->media_override != 7) {
Alexander Beregalov39738e12009-05-26 12:35:26 +00001339 pr_info("%s: Media override to transceiver type %d (%s).\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001340 print_name, vp->media_override,
1341 media_tbl[vp->media_override].name);
1342 dev->if_port = vp->media_override;
1343 } else
1344 dev->if_port = vp->default_media;
1345
1346 if ((vp->available_media & 0x40) || (vci->drv_flags & HAS_NWAY) ||
1347 dev->if_port == XCVR_MII || dev->if_port == XCVR_NWAY) {
1348 int phy, phy_idx = 0;
1349 EL3WINDOW(4);
1350 mii_preamble_required++;
1351 if (vp->drv_flags & EXTRA_PREAMBLE)
1352 mii_preamble_required++;
1353 mdio_sync(ioaddr, 32);
Neil Horman106427e2005-11-07 00:58:03 -08001354 mdio_read(dev, 24, MII_BMSR);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001355 for (phy = 0; phy < 32 && phy_idx < 1; phy++) {
1356 int mii_status, phyx;
1357
1358 /*
1359 * For the 3c905CX we look at index 24 first, because it bogusly
1360 * reports an external PHY at all indices
1361 */
1362 if (phy == 0)
1363 phyx = 24;
1364 else if (phy <= 24)
1365 phyx = phy - 1;
1366 else
1367 phyx = phy;
Neil Horman106427e2005-11-07 00:58:03 -08001368 mii_status = mdio_read(dev, phyx, MII_BMSR);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001369 if (mii_status && mii_status != 0xffff) {
1370 vp->phys[phy_idx++] = phyx;
1371 if (print_info) {
Alexander Beregalov39738e12009-05-26 12:35:26 +00001372 pr_info(" MII transceiver found at address %d, status %4x.\n",
1373 phyx, mii_status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001374 }
1375 if ((mii_status & 0x0040) == 0)
1376 mii_preamble_required++;
1377 }
1378 }
1379 mii_preamble_required--;
1380 if (phy_idx == 0) {
Alexander Beregalov39738e12009-05-26 12:35:26 +00001381 pr_warning(" ***WARNING*** No MII transceivers found!\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001382 vp->phys[0] = 24;
1383 } else {
Neil Horman106427e2005-11-07 00:58:03 -08001384 vp->advertising = mdio_read(dev, vp->phys[0], MII_ADVERTISE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001385 if (vp->full_duplex) {
1386 /* Only advertise the FD media types. */
1387 vp->advertising &= ~0x02A0;
1388 mdio_write(dev, vp->phys[0], 4, vp->advertising);
1389 }
1390 }
1391 vp->mii.phy_id = vp->phys[0];
1392 }
1393
1394 if (vp->capabilities & CapBusMaster) {
1395 vp->full_bus_master_tx = 1;
1396 if (print_info) {
Alexander Beregalov39738e12009-05-26 12:35:26 +00001397 pr_info(" Enabling bus-master transmits and %s receives.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001398 (vp->info2 & 1) ? "early" : "whole-frame" );
1399 }
1400 vp->full_bus_master_rx = (vp->info2 & 1) ? 1 : 2;
1401 vp->bus_master = 0; /* AKPM: vortex only */
1402 }
1403
1404 /* The 3c59x-specific entries in the device structure. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001405 if (vp->full_bus_master_tx) {
Stephen Hemminger48b47a52009-01-09 13:01:18 +00001406 dev->netdev_ops = &boomrang_netdev_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001407 /* Actually, it still should work with iommu. */
John W. Linville32fb5f02005-11-07 00:58:05 -08001408 if (card_idx < MAX_UNITS &&
1409 ((hw_checksums[card_idx] == -1 && (vp->drv_flags & HAS_HWCKSM)) ||
1410 hw_checksums[card_idx] == 1)) {
Stephen Hemmingerd311b0d2005-11-07 00:58:09 -08001411 dev->features |= NETIF_F_IP_CSUM | NETIF_F_SG;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001412 }
Stephen Hemminger48b47a52009-01-09 13:01:18 +00001413 } else
1414 dev->netdev_ops = &vortex_netdev_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001415
1416 if (print_info) {
Alexander Beregalov39738e12009-05-26 12:35:26 +00001417 pr_info("%s: scatter/gather %sabled. h/w checksums %sabled\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001418 print_name,
1419 (dev->features & NETIF_F_SG) ? "en":"dis",
1420 (dev->features & NETIF_F_IP_CSUM) ? "en":"dis");
1421 }
1422
Linus Torvalds1da177e2005-04-16 15:20:36 -07001423 dev->ethtool_ops = &vortex_ethtool_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001424 dev->watchdog_timeo = (watchdog * HZ) / 1000;
Stephen Hemminger48b47a52009-01-09 13:01:18 +00001425
Linus Torvalds1da177e2005-04-16 15:20:36 -07001426 if (pdev) {
1427 vp->pm_state_valid = 1;
1428 pci_save_state(VORTEX_PCI(vp));
1429 acpi_set_WOL(dev);
1430 }
1431 retval = register_netdev(dev);
1432 if (retval == 0)
1433 return 0;
1434
1435free_ring:
1436 pci_free_consistent(pdev,
1437 sizeof(struct boom_rx_desc) * RX_RING_SIZE
1438 + sizeof(struct boom_tx_desc) * TX_RING_SIZE,
1439 vp->rx_ring,
1440 vp->rx_ring_dma);
1441free_region:
1442 if (vp->must_free_region)
John W. Linville62afe592005-11-07 00:58:02 -08001443 release_region(dev->base_addr, vci->io_size);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001444 free_netdev(dev);
Alexander Beregalov39738e12009-05-26 12:35:26 +00001445 pr_err(PFX "vortex_probe1 fails. Returns %d\n", retval);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001446out:
1447 return retval;
1448}
1449
1450static void
1451issue_and_wait(struct net_device *dev, int cmd)
1452{
John W. Linville62afe592005-11-07 00:58:02 -08001453 struct vortex_private *vp = netdev_priv(dev);
1454 void __iomem *ioaddr = vp->ioaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001455 int i;
1456
John W. Linville62afe592005-11-07 00:58:02 -08001457 iowrite16(cmd, ioaddr + EL3_CMD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001458 for (i = 0; i < 2000; i++) {
John W. Linville62afe592005-11-07 00:58:02 -08001459 if (!(ioread16(ioaddr + EL3_STATUS) & CmdInProgress))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001460 return;
1461 }
1462
1463 /* OK, that didn't work. Do it the slow way. One second */
1464 for (i = 0; i < 100000; i++) {
John W. Linville62afe592005-11-07 00:58:02 -08001465 if (!(ioread16(ioaddr + EL3_STATUS) & CmdInProgress)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001466 if (vortex_debug > 1)
Alexander Beregalov39738e12009-05-26 12:35:26 +00001467 pr_info("%s: command 0x%04x took %d usecs\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001468 dev->name, cmd, i * 10);
1469 return;
1470 }
1471 udelay(10);
1472 }
Alexander Beregalov39738e12009-05-26 12:35:26 +00001473 pr_err("%s: command 0x%04x did not complete! Status=0x%x\n",
John W. Linville62afe592005-11-07 00:58:02 -08001474 dev->name, cmd, ioread16(ioaddr + EL3_STATUS));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001475}
1476
1477static void
Steffen Klassert125d5ce2006-03-26 01:37:39 -08001478vortex_set_duplex(struct net_device *dev)
1479{
1480 struct vortex_private *vp = netdev_priv(dev);
1481 void __iomem *ioaddr = vp->ioaddr;
1482
Alexander Beregalov39738e12009-05-26 12:35:26 +00001483 pr_info("%s: setting %s-duplex.\n",
Steffen Klassert125d5ce2006-03-26 01:37:39 -08001484 dev->name, (vp->full_duplex) ? "full" : "half");
1485
1486 EL3WINDOW(3);
1487 /* Set the full-duplex bit. */
1488 iowrite16(((vp->info1 & 0x8000) || vp->full_duplex ? 0x20 : 0) |
1489 (vp->large_frames ? 0x40 : 0) |
1490 ((vp->full_duplex && vp->flow_ctrl && vp->partner_flow_ctrl) ?
1491 0x100 : 0),
1492 ioaddr + Wn3_MAC_Ctrl);
Steffen Klassert125d5ce2006-03-26 01:37:39 -08001493}
1494
1495static void vortex_check_media(struct net_device *dev, unsigned int init)
1496{
1497 struct vortex_private *vp = netdev_priv(dev);
1498 unsigned int ok_to_print = 0;
1499
1500 if (vortex_debug > 3)
1501 ok_to_print = 1;
1502
1503 if (mii_check_media(&vp->mii, ok_to_print, init)) {
1504 vp->full_duplex = vp->mii.full_duplex;
1505 vortex_set_duplex(dev);
1506 } else if (init) {
1507 vortex_set_duplex(dev);
1508 }
1509}
1510
Mark Hindleyc8303d12007-08-16 11:28:40 +01001511static int
Linus Torvalds1da177e2005-04-16 15:20:36 -07001512vortex_up(struct net_device *dev)
1513{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001514 struct vortex_private *vp = netdev_priv(dev);
John W. Linville62afe592005-11-07 00:58:02 -08001515 void __iomem *ioaddr = vp->ioaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001516 unsigned int config;
Badari Pulavarty0280f9f2007-10-17 16:15:56 -07001517 int i, mii_reg1, mii_reg5, err = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001518
1519 if (VORTEX_PCI(vp)) {
1520 pci_set_power_state(VORTEX_PCI(vp), PCI_D0); /* Go active */
Daniel Ritz3c8fad12005-05-05 16:15:44 -07001521 if (vp->pm_state_valid)
1522 pci_restore_state(VORTEX_PCI(vp));
Mark Hindleyc8303d12007-08-16 11:28:40 +01001523 err = pci_enable_device(VORTEX_PCI(vp));
1524 if (err) {
Alexander Beregalov39738e12009-05-26 12:35:26 +00001525 pr_warning("%s: Could not enable device\n",
Mark Hindleyc8303d12007-08-16 11:28:40 +01001526 dev->name);
1527 goto err_out;
1528 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001529 }
1530
1531 /* Before initializing select the active media port. */
1532 EL3WINDOW(3);
John W. Linville62afe592005-11-07 00:58:02 -08001533 config = ioread32(ioaddr + Wn3_Config);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001534
1535 if (vp->media_override != 7) {
Alexander Beregalov39738e12009-05-26 12:35:26 +00001536 pr_info("%s: Media override to transceiver %d (%s).\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001537 dev->name, vp->media_override,
1538 media_tbl[vp->media_override].name);
1539 dev->if_port = vp->media_override;
1540 } else if (vp->autoselect) {
1541 if (vp->has_nway) {
1542 if (vortex_debug > 1)
Alexander Beregalov39738e12009-05-26 12:35:26 +00001543 pr_info("%s: using NWAY device table, not %d\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001544 dev->name, dev->if_port);
1545 dev->if_port = XCVR_NWAY;
1546 } else {
1547 /* Find first available media type, starting with 100baseTx. */
1548 dev->if_port = XCVR_100baseTx;
1549 while (! (vp->available_media & media_tbl[dev->if_port].mask))
1550 dev->if_port = media_tbl[dev->if_port].next;
1551 if (vortex_debug > 1)
Alexander Beregalov39738e12009-05-26 12:35:26 +00001552 pr_info("%s: first available media type: %s\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001553 dev->name, media_tbl[dev->if_port].name);
1554 }
1555 } else {
1556 dev->if_port = vp->default_media;
1557 if (vortex_debug > 1)
Alexander Beregalov39738e12009-05-26 12:35:26 +00001558 pr_info("%s: using default media %s\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001559 dev->name, media_tbl[dev->if_port].name);
1560 }
1561
1562 init_timer(&vp->timer);
1563 vp->timer.expires = RUN_AT(media_tbl[dev->if_port].wait);
1564 vp->timer.data = (unsigned long)dev;
1565 vp->timer.function = vortex_timer; /* timer handler */
1566 add_timer(&vp->timer);
1567
1568 init_timer(&vp->rx_oom_timer);
1569 vp->rx_oom_timer.data = (unsigned long)dev;
1570 vp->rx_oom_timer.function = rx_oom_timer;
1571
1572 if (vortex_debug > 1)
Alexander Beregalov39738e12009-05-26 12:35:26 +00001573 pr_debug("%s: Initial media type %s.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001574 dev->name, media_tbl[dev->if_port].name);
1575
Steffen Klassert125d5ce2006-03-26 01:37:39 -08001576 vp->full_duplex = vp->mii.force_media;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001577 config = BFINS(config, dev->if_port, 20, 4);
1578 if (vortex_debug > 6)
Alexander Beregalov39738e12009-05-26 12:35:26 +00001579 pr_debug("vortex_up(): writing 0x%x to InternalConfig\n", config);
John W. Linville62afe592005-11-07 00:58:02 -08001580 iowrite32(config, ioaddr + Wn3_Config);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001581
1582 if (dev->if_port == XCVR_MII || dev->if_port == XCVR_NWAY) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001583 EL3WINDOW(4);
Steffen Klassert09ce3512006-03-31 02:30:48 -08001584 mii_reg1 = mdio_read(dev, vp->phys[0], MII_BMSR);
1585 mii_reg5 = mdio_read(dev, vp->phys[0], MII_LPA);
1586 vp->partner_flow_ctrl = ((mii_reg5 & 0x0400) != 0);
Steffen Klassert373492d2007-08-10 14:05:26 -07001587 vp->mii.full_duplex = vp->full_duplex;
Steffen Klassert09ce3512006-03-31 02:30:48 -08001588
Steffen Klassert125d5ce2006-03-26 01:37:39 -08001589 vortex_check_media(dev, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001590 }
Steffen Klassert125d5ce2006-03-26 01:37:39 -08001591 else
1592 vortex_set_duplex(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001593
Steffen Klassert09ce3512006-03-31 02:30:48 -08001594 issue_and_wait(dev, TxReset);
1595 /*
1596 * Don't reset the PHY - that upsets autonegotiation during DHCP operations.
1597 */
1598 issue_and_wait(dev, RxReset|0x04);
1599
Linus Torvalds1da177e2005-04-16 15:20:36 -07001600
John W. Linville62afe592005-11-07 00:58:02 -08001601 iowrite16(SetStatusEnb | 0x00, ioaddr + EL3_CMD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001602
1603 if (vortex_debug > 1) {
1604 EL3WINDOW(4);
Alexander Beregalov39738e12009-05-26 12:35:26 +00001605 pr_debug("%s: vortex_up() irq %d media status %4.4x.\n",
John W. Linville62afe592005-11-07 00:58:02 -08001606 dev->name, dev->irq, ioread16(ioaddr + Wn4_Media));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001607 }
1608
1609 /* Set the station address and mask in window 2 each time opened. */
1610 EL3WINDOW(2);
1611 for (i = 0; i < 6; i++)
John W. Linville62afe592005-11-07 00:58:02 -08001612 iowrite8(dev->dev_addr[i], ioaddr + i);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001613 for (; i < 12; i+=2)
John W. Linville62afe592005-11-07 00:58:02 -08001614 iowrite16(0, ioaddr + i);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001615
1616 if (vp->cb_fn_base) {
John W. Linville62afe592005-11-07 00:58:02 -08001617 unsigned short n = ioread16(ioaddr + Wn2_ResetOptions) & ~0x4010;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001618 if (vp->drv_flags & INVERT_LED_PWR)
1619 n |= 0x10;
1620 if (vp->drv_flags & INVERT_MII_PWR)
1621 n |= 0x4000;
John W. Linville62afe592005-11-07 00:58:02 -08001622 iowrite16(n, ioaddr + Wn2_ResetOptions);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001623 }
1624
1625 if (dev->if_port == XCVR_10base2)
1626 /* Start the thinnet transceiver. We should really wait 50ms...*/
John W. Linville62afe592005-11-07 00:58:02 -08001627 iowrite16(StartCoax, ioaddr + EL3_CMD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001628 if (dev->if_port != XCVR_NWAY) {
1629 EL3WINDOW(4);
John W. Linville62afe592005-11-07 00:58:02 -08001630 iowrite16((ioread16(ioaddr + Wn4_Media) & ~(Media_10TP|Media_SQE)) |
Linus Torvalds1da177e2005-04-16 15:20:36 -07001631 media_tbl[dev->if_port].media_bits, ioaddr + Wn4_Media);
1632 }
1633
1634 /* Switch to the stats window, and clear all stats by reading. */
John W. Linville62afe592005-11-07 00:58:02 -08001635 iowrite16(StatsDisable, ioaddr + EL3_CMD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001636 EL3WINDOW(6);
1637 for (i = 0; i < 10; i++)
John W. Linville62afe592005-11-07 00:58:02 -08001638 ioread8(ioaddr + i);
1639 ioread16(ioaddr + 10);
1640 ioread16(ioaddr + 12);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001641 /* New: On the Vortex we must also clear the BadSSD counter. */
1642 EL3WINDOW(4);
John W. Linville62afe592005-11-07 00:58:02 -08001643 ioread8(ioaddr + 12);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001644 /* ..and on the Boomerang we enable the extra statistics bits. */
John W. Linville62afe592005-11-07 00:58:02 -08001645 iowrite16(0x0040, ioaddr + Wn4_NetDiag);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001646
1647 /* Switch to register set 7 for normal use. */
1648 EL3WINDOW(7);
1649
1650 if (vp->full_bus_master_rx) { /* Boomerang bus master. */
1651 vp->cur_rx = vp->dirty_rx = 0;
1652 /* Initialize the RxEarly register as recommended. */
John W. Linville62afe592005-11-07 00:58:02 -08001653 iowrite16(SetRxThreshold + (1536>>2), ioaddr + EL3_CMD);
1654 iowrite32(0x0020, ioaddr + PktStatus);
1655 iowrite32(vp->rx_ring_dma, ioaddr + UpListPtr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001656 }
1657 if (vp->full_bus_master_tx) { /* Boomerang bus master Tx. */
1658 vp->cur_tx = vp->dirty_tx = 0;
1659 if (vp->drv_flags & IS_BOOMERANG)
John W. Linville62afe592005-11-07 00:58:02 -08001660 iowrite8(PKT_BUF_SZ>>8, ioaddr + TxFreeThreshold); /* Room for a packet. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001661 /* Clear the Rx, Tx rings. */
1662 for (i = 0; i < RX_RING_SIZE; i++) /* AKPM: this is done in vortex_open, too */
1663 vp->rx_ring[i].status = 0;
1664 for (i = 0; i < TX_RING_SIZE; i++)
1665 vp->tx_skbuff[i] = NULL;
John W. Linville62afe592005-11-07 00:58:02 -08001666 iowrite32(0, ioaddr + DownListPtr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001667 }
1668 /* Set receiver mode: presumably accept b-case and phys addr only. */
1669 set_rx_mode(dev);
1670 /* enable 802.1q tagged frames */
1671 set_8021q_mode(dev, 1);
John W. Linville62afe592005-11-07 00:58:02 -08001672 iowrite16(StatsEnable, ioaddr + EL3_CMD); /* Turn on statistics. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001673
John W. Linville62afe592005-11-07 00:58:02 -08001674 iowrite16(RxEnable, ioaddr + EL3_CMD); /* Enable the receiver. */
1675 iowrite16(TxEnable, ioaddr + EL3_CMD); /* Enable transmitter. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001676 /* Allow status bits to be seen. */
1677 vp->status_enable = SetStatusEnb | HostError|IntReq|StatsFull|TxComplete|
1678 (vp->full_bus_master_tx ? DownComplete : TxAvailable) |
1679 (vp->full_bus_master_rx ? UpComplete : RxComplete) |
1680 (vp->bus_master ? DMADone : 0);
1681 vp->intr_enable = SetIntrEnb | IntLatch | TxAvailable |
1682 (vp->full_bus_master_rx ? 0 : RxComplete) |
1683 StatsFull | HostError | TxComplete | IntReq
1684 | (vp->bus_master ? DMADone : 0) | UpComplete | DownComplete;
John W. Linville62afe592005-11-07 00:58:02 -08001685 iowrite16(vp->status_enable, ioaddr + EL3_CMD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001686 /* Ack all pending events, and set active indicator mask. */
John W. Linville62afe592005-11-07 00:58:02 -08001687 iowrite16(AckIntr | IntLatch | TxAvailable | RxEarly | IntReq,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001688 ioaddr + EL3_CMD);
John W. Linville62afe592005-11-07 00:58:02 -08001689 iowrite16(vp->intr_enable, ioaddr + EL3_CMD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001690 if (vp->cb_fn_base) /* The PCMCIA people are idiots. */
John W. Linville62afe592005-11-07 00:58:02 -08001691 iowrite32(0x8000, vp->cb_fn_base + 4);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001692 netif_start_queue (dev);
Mark Hindleyc8303d12007-08-16 11:28:40 +01001693err_out:
1694 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001695}
1696
1697static int
1698vortex_open(struct net_device *dev)
1699{
1700 struct vortex_private *vp = netdev_priv(dev);
1701 int i;
1702 int retval;
1703
1704 /* Use the now-standard shared IRQ implementation. */
1705 if ((retval = request_irq(dev->irq, vp->full_bus_master_rx ?
Thomas Gleixner1fb9df52006-07-01 19:29:39 -07001706 &boomerang_interrupt : &vortex_interrupt, IRQF_SHARED, dev->name, dev))) {
Alexander Beregalov39738e12009-05-26 12:35:26 +00001707 pr_err("%s: Could not reserve IRQ %d\n", dev->name, dev->irq);
Mark Hindleyc8303d12007-08-16 11:28:40 +01001708 goto err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001709 }
1710
1711 if (vp->full_bus_master_rx) { /* Boomerang bus master. */
1712 if (vortex_debug > 2)
Alexander Beregalov39738e12009-05-26 12:35:26 +00001713 pr_debug("%s: Filling in the Rx ring.\n", dev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001714 for (i = 0; i < RX_RING_SIZE; i++) {
1715 struct sk_buff *skb;
1716 vp->rx_ring[i].next = cpu_to_le32(vp->rx_ring_dma + sizeof(struct boom_rx_desc) * (i+1));
1717 vp->rx_ring[i].status = 0; /* Clear complete bit. */
1718 vp->rx_ring[i].length = cpu_to_le32(PKT_BUF_SZ | LAST_FRAG);
Stephen Hemminger9a5d34142008-07-25 12:07:22 -07001719
1720 skb = __netdev_alloc_skb(dev, PKT_BUF_SZ + NET_IP_ALIGN,
1721 GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001722 vp->rx_skbuff[i] = skb;
1723 if (skb == NULL)
1724 break; /* Bad news! */
Stephen Hemminger9a5d34142008-07-25 12:07:22 -07001725
1726 skb_reserve(skb, NET_IP_ALIGN); /* Align IP on 16 byte boundaries */
David S. Miller689be432005-06-28 15:25:31 -07001727 vp->rx_ring[i].addr = cpu_to_le32(pci_map_single(VORTEX_PCI(vp), skb->data, PKT_BUF_SZ, PCI_DMA_FROMDEVICE));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001728 }
1729 if (i != RX_RING_SIZE) {
1730 int j;
Alexander Beregalov39738e12009-05-26 12:35:26 +00001731 pr_emerg("%s: no memory for rx ring\n", dev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001732 for (j = 0; j < i; j++) {
1733 if (vp->rx_skbuff[j]) {
1734 dev_kfree_skb(vp->rx_skbuff[j]);
1735 vp->rx_skbuff[j] = NULL;
1736 }
1737 }
1738 retval = -ENOMEM;
Mark Hindleyc8303d12007-08-16 11:28:40 +01001739 goto err_free_irq;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001740 }
1741 /* Wrap the ring. */
1742 vp->rx_ring[i-1].next = cpu_to_le32(vp->rx_ring_dma);
1743 }
1744
Mark Hindleyc8303d12007-08-16 11:28:40 +01001745 retval = vortex_up(dev);
1746 if (!retval)
1747 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001748
Mark Hindleyc8303d12007-08-16 11:28:40 +01001749err_free_irq:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001750 free_irq(dev->irq, dev);
Mark Hindleyc8303d12007-08-16 11:28:40 +01001751err:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001752 if (vortex_debug > 1)
Alexander Beregalov39738e12009-05-26 12:35:26 +00001753 pr_err("%s: vortex_open() fails: returning %d\n", dev->name, retval);
Mark Hindleyc8303d12007-08-16 11:28:40 +01001754out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001755 return retval;
1756}
1757
1758static void
1759vortex_timer(unsigned long data)
1760{
1761 struct net_device *dev = (struct net_device *)data;
1762 struct vortex_private *vp = netdev_priv(dev);
John W. Linville62afe592005-11-07 00:58:02 -08001763 void __iomem *ioaddr = vp->ioaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001764 int next_tick = 60*HZ;
1765 int ok = 0;
Steffen Klassert125d5ce2006-03-26 01:37:39 -08001766 int media_status, old_window;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001767
1768 if (vortex_debug > 2) {
Alexander Beregalov39738e12009-05-26 12:35:26 +00001769 pr_debug("%s: Media selection timer tick happened, %s.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001770 dev->name, media_tbl[dev->if_port].name);
Alexander Beregalov39738e12009-05-26 12:35:26 +00001771 pr_debug("dev->watchdog_timeo=%d\n", dev->watchdog_timeo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001772 }
1773
Ingo Molnar0a9da4b2006-07-03 00:25:24 -07001774 disable_irq_lockdep(dev->irq);
John W. Linville62afe592005-11-07 00:58:02 -08001775 old_window = ioread16(ioaddr + EL3_CMD) >> 13;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001776 EL3WINDOW(4);
John W. Linville62afe592005-11-07 00:58:02 -08001777 media_status = ioread16(ioaddr + Wn4_Media);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001778 switch (dev->if_port) {
1779 case XCVR_10baseT: case XCVR_100baseTx: case XCVR_100baseFx:
1780 if (media_status & Media_LnkBeat) {
1781 netif_carrier_on(dev);
1782 ok = 1;
1783 if (vortex_debug > 1)
Alexander Beregalov39738e12009-05-26 12:35:26 +00001784 pr_debug("%s: Media %s has link beat, %x.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001785 dev->name, media_tbl[dev->if_port].name, media_status);
1786 } else {
1787 netif_carrier_off(dev);
1788 if (vortex_debug > 1) {
Alexander Beregalov39738e12009-05-26 12:35:26 +00001789 pr_debug("%s: Media %s has no link beat, %x.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001790 dev->name, media_tbl[dev->if_port].name, media_status);
1791 }
1792 }
1793 break;
1794 case XCVR_MII: case XCVR_NWAY:
1795 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001796 ok = 1;
Ingo Molnarc5643ca2008-06-23 10:41:23 +02001797 /* Interrupts are already disabled */
1798 spin_lock(&vp->lock);
Steffen Klassert125d5ce2006-03-26 01:37:39 -08001799 vortex_check_media(dev, 0);
Ingo Molnarc5643ca2008-06-23 10:41:23 +02001800 spin_unlock(&vp->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001801 }
1802 break;
1803 default: /* Other media types handled by Tx timeouts. */
1804 if (vortex_debug > 1)
Alexander Beregalov39738e12009-05-26 12:35:26 +00001805 pr_debug("%s: Media %s has no indication, %x.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001806 dev->name, media_tbl[dev->if_port].name, media_status);
1807 ok = 1;
1808 }
Steffen Klassertb4ff6452006-03-26 01:37:40 -08001809
1810 if (!netif_carrier_ok(dev))
1811 next_tick = 5*HZ;
1812
Steffen Klasserte94d10e2006-03-26 01:37:41 -08001813 if (vp->medialock)
1814 goto leave_media_alone;
1815
Steffen Klasserta880c4c2006-03-26 01:37:43 -08001816 if (!ok) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001817 unsigned int config;
1818
1819 do {
1820 dev->if_port = media_tbl[dev->if_port].next;
1821 } while ( ! (vp->available_media & media_tbl[dev->if_port].mask));
1822 if (dev->if_port == XCVR_Default) { /* Go back to default. */
1823 dev->if_port = vp->default_media;
1824 if (vortex_debug > 1)
Alexander Beregalov39738e12009-05-26 12:35:26 +00001825 pr_debug("%s: Media selection failing, using default %s port.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001826 dev->name, media_tbl[dev->if_port].name);
1827 } else {
1828 if (vortex_debug > 1)
Alexander Beregalov39738e12009-05-26 12:35:26 +00001829 pr_debug("%s: Media selection failed, now trying %s port.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001830 dev->name, media_tbl[dev->if_port].name);
1831 next_tick = media_tbl[dev->if_port].wait;
1832 }
John W. Linville62afe592005-11-07 00:58:02 -08001833 iowrite16((media_status & ~(Media_10TP|Media_SQE)) |
Linus Torvalds1da177e2005-04-16 15:20:36 -07001834 media_tbl[dev->if_port].media_bits, ioaddr + Wn4_Media);
1835
1836 EL3WINDOW(3);
John W. Linville62afe592005-11-07 00:58:02 -08001837 config = ioread32(ioaddr + Wn3_Config);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001838 config = BFINS(config, dev->if_port, 20, 4);
John W. Linville62afe592005-11-07 00:58:02 -08001839 iowrite32(config, ioaddr + Wn3_Config);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001840
John W. Linville62afe592005-11-07 00:58:02 -08001841 iowrite16(dev->if_port == XCVR_10base2 ? StartCoax : StopCoax,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001842 ioaddr + EL3_CMD);
1843 if (vortex_debug > 1)
Alexander Beregalov39738e12009-05-26 12:35:26 +00001844 pr_debug("wrote 0x%08x to Wn3_Config\n", config);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001845 /* AKPM: FIXME: Should reset Rx & Tx here. P60 of 3c90xc.pdf */
1846 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001847
1848leave_media_alone:
1849 if (vortex_debug > 2)
Alexander Beregalov39738e12009-05-26 12:35:26 +00001850 pr_debug("%s: Media selection timer finished, %s.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001851 dev->name, media_tbl[dev->if_port].name);
1852
Steffen Klasserte94d10e2006-03-26 01:37:41 -08001853 EL3WINDOW(old_window);
Ingo Molnar0a9da4b2006-07-03 00:25:24 -07001854 enable_irq_lockdep(dev->irq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001855 mod_timer(&vp->timer, RUN_AT(next_tick));
1856 if (vp->deferred)
John W. Linville62afe592005-11-07 00:58:02 -08001857 iowrite16(FakeIntr, ioaddr + EL3_CMD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001858 return;
1859}
1860
1861static void vortex_tx_timeout(struct net_device *dev)
1862{
1863 struct vortex_private *vp = netdev_priv(dev);
John W. Linville62afe592005-11-07 00:58:02 -08001864 void __iomem *ioaddr = vp->ioaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001865
Alexander Beregalov39738e12009-05-26 12:35:26 +00001866 pr_err("%s: transmit timed out, tx_status %2.2x status %4.4x.\n",
John W. Linville62afe592005-11-07 00:58:02 -08001867 dev->name, ioread8(ioaddr + TxStatus),
1868 ioread16(ioaddr + EL3_STATUS));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001869 EL3WINDOW(4);
Alexander Beregalov39738e12009-05-26 12:35:26 +00001870 pr_err(" diagnostics: net %04x media %04x dma %08x fifo %04x\n",
John W. Linville62afe592005-11-07 00:58:02 -08001871 ioread16(ioaddr + Wn4_NetDiag),
1872 ioread16(ioaddr + Wn4_Media),
1873 ioread32(ioaddr + PktStatus),
1874 ioread16(ioaddr + Wn4_FIFODiag));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001875 /* Slight code bloat to be user friendly. */
John W. Linville62afe592005-11-07 00:58:02 -08001876 if ((ioread8(ioaddr + TxStatus) & 0x88) == 0x88)
Alexander Beregalov39738e12009-05-26 12:35:26 +00001877 pr_err("%s: Transmitter encountered 16 collisions --"
Linus Torvalds1da177e2005-04-16 15:20:36 -07001878 " network cable problem?\n", dev->name);
John W. Linville62afe592005-11-07 00:58:02 -08001879 if (ioread16(ioaddr + EL3_STATUS) & IntLatch) {
Alexander Beregalov39738e12009-05-26 12:35:26 +00001880 pr_err("%s: Interrupt posted but not delivered --"
Linus Torvalds1da177e2005-04-16 15:20:36 -07001881 " IRQ blocked by another device?\n", dev->name);
1882 /* Bad idea here.. but we might as well handle a few events. */
1883 {
1884 /*
1885 * Block interrupts because vortex_interrupt does a bare spin_lock()
1886 */
1887 unsigned long flags;
1888 local_irq_save(flags);
1889 if (vp->full_bus_master_tx)
David Howells7d12e782006-10-05 14:55:46 +01001890 boomerang_interrupt(dev->irq, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001891 else
David Howells7d12e782006-10-05 14:55:46 +01001892 vortex_interrupt(dev->irq, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001893 local_irq_restore(flags);
1894 }
1895 }
1896
1897 if (vortex_debug > 0)
1898 dump_tx_ring(dev);
1899
1900 issue_and_wait(dev, TxReset);
1901
Paulius Zaleckas1daad052008-05-05 14:01:29 +02001902 dev->stats.tx_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001903 if (vp->full_bus_master_tx) {
Alexander Beregalov39738e12009-05-26 12:35:26 +00001904 pr_debug("%s: Resetting the Tx ring pointer.\n", dev->name);
John W. Linville62afe592005-11-07 00:58:02 -08001905 if (vp->cur_tx - vp->dirty_tx > 0 && ioread32(ioaddr + DownListPtr) == 0)
1906 iowrite32(vp->tx_ring_dma + (vp->dirty_tx % TX_RING_SIZE) * sizeof(struct boom_tx_desc),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001907 ioaddr + DownListPtr);
1908 if (vp->cur_tx - vp->dirty_tx < TX_RING_SIZE)
1909 netif_wake_queue (dev);
1910 if (vp->drv_flags & IS_BOOMERANG)
John W. Linville62afe592005-11-07 00:58:02 -08001911 iowrite8(PKT_BUF_SZ>>8, ioaddr + TxFreeThreshold);
1912 iowrite16(DownUnstall, ioaddr + EL3_CMD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001913 } else {
Paulius Zaleckas1daad052008-05-05 14:01:29 +02001914 dev->stats.tx_dropped++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001915 netif_wake_queue(dev);
1916 }
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001917
Linus Torvalds1da177e2005-04-16 15:20:36 -07001918 /* Issue Tx Enable */
John W. Linville62afe592005-11-07 00:58:02 -08001919 iowrite16(TxEnable, ioaddr + EL3_CMD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001920 dev->trans_start = jiffies;
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001921
Linus Torvalds1da177e2005-04-16 15:20:36 -07001922 /* Switch to register set 7 for normal use. */
1923 EL3WINDOW(7);
1924}
1925
1926/*
1927 * Handle uncommon interrupt sources. This is a separate routine to minimize
1928 * the cache impact.
1929 */
1930static void
1931vortex_error(struct net_device *dev, int status)
1932{
1933 struct vortex_private *vp = netdev_priv(dev);
John W. Linville62afe592005-11-07 00:58:02 -08001934 void __iomem *ioaddr = vp->ioaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001935 int do_tx_reset = 0, reset_mask = 0;
1936 unsigned char tx_status = 0;
1937
1938 if (vortex_debug > 2) {
Alexander Beregalov39738e12009-05-26 12:35:26 +00001939 pr_err("%s: vortex_error(), status=0x%x\n", dev->name, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001940 }
1941
1942 if (status & TxComplete) { /* Really "TxError" for us. */
John W. Linville62afe592005-11-07 00:58:02 -08001943 tx_status = ioread8(ioaddr + TxStatus);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001944 /* Presumably a tx-timeout. We must merely re-enable. */
1945 if (vortex_debug > 2
1946 || (tx_status != 0x88 && vortex_debug > 0)) {
Alexander Beregalov39738e12009-05-26 12:35:26 +00001947 pr_err("%s: Transmit error, Tx status register %2.2x.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001948 dev->name, tx_status);
1949 if (tx_status == 0x82) {
Alexander Beregalov39738e12009-05-26 12:35:26 +00001950 pr_err("Probably a duplex mismatch. See "
Linus Torvalds1da177e2005-04-16 15:20:36 -07001951 "Documentation/networking/vortex.txt\n");
1952 }
1953 dump_tx_ring(dev);
1954 }
Paulius Zaleckas1daad052008-05-05 14:01:29 +02001955 if (tx_status & 0x14) dev->stats.tx_fifo_errors++;
1956 if (tx_status & 0x38) dev->stats.tx_aborted_errors++;
Andrew Morton00007542006-03-31 02:30:47 -08001957 if (tx_status & 0x08) vp->xstats.tx_max_collisions++;
John W. Linville62afe592005-11-07 00:58:02 -08001958 iowrite8(0, ioaddr + TxStatus);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001959 if (tx_status & 0x30) { /* txJabber or txUnderrun */
1960 do_tx_reset = 1;
Andrew Morton00007542006-03-31 02:30:47 -08001961 } else if ((tx_status & 0x08) && (vp->drv_flags & MAX_COLLISION_RESET)) { /* maxCollisions */
1962 do_tx_reset = 1;
1963 reset_mask = 0x0108; /* Reset interface logic, but not download logic */
1964 } else { /* Merely re-enable the transmitter. */
John W. Linville62afe592005-11-07 00:58:02 -08001965 iowrite16(TxEnable, ioaddr + EL3_CMD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001966 }
1967 }
1968
1969 if (status & RxEarly) { /* Rx early is unused. */
1970 vortex_rx(dev);
John W. Linville62afe592005-11-07 00:58:02 -08001971 iowrite16(AckIntr | RxEarly, ioaddr + EL3_CMD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001972 }
1973 if (status & StatsFull) { /* Empty statistics. */
1974 static int DoneDidThat;
1975 if (vortex_debug > 4)
Alexander Beregalov39738e12009-05-26 12:35:26 +00001976 pr_debug("%s: Updating stats.\n", dev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001977 update_stats(ioaddr, dev);
1978 /* HACK: Disable statistics as an interrupt source. */
1979 /* This occurs when we have the wrong media type! */
1980 if (DoneDidThat == 0 &&
John W. Linville62afe592005-11-07 00:58:02 -08001981 ioread16(ioaddr + EL3_STATUS) & StatsFull) {
Alexander Beregalov39738e12009-05-26 12:35:26 +00001982 pr_warning("%s: Updating statistics failed, disabling "
Linus Torvalds1da177e2005-04-16 15:20:36 -07001983 "stats as an interrupt source.\n", dev->name);
1984 EL3WINDOW(5);
John W. Linville62afe592005-11-07 00:58:02 -08001985 iowrite16(SetIntrEnb | (ioread16(ioaddr + 10) & ~StatsFull), ioaddr + EL3_CMD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001986 vp->intr_enable &= ~StatsFull;
1987 EL3WINDOW(7);
1988 DoneDidThat++;
1989 }
1990 }
1991 if (status & IntReq) { /* Restore all interrupt sources. */
John W. Linville62afe592005-11-07 00:58:02 -08001992 iowrite16(vp->status_enable, ioaddr + EL3_CMD);
1993 iowrite16(vp->intr_enable, ioaddr + EL3_CMD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001994 }
1995 if (status & HostError) {
1996 u16 fifo_diag;
1997 EL3WINDOW(4);
John W. Linville62afe592005-11-07 00:58:02 -08001998 fifo_diag = ioread16(ioaddr + Wn4_FIFODiag);
Alexander Beregalov39738e12009-05-26 12:35:26 +00001999 pr_err("%s: Host error, FIFO diagnostic register %4.4x.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002000 dev->name, fifo_diag);
2001 /* Adapter failure requires Tx/Rx reset and reinit. */
2002 if (vp->full_bus_master_tx) {
John W. Linville62afe592005-11-07 00:58:02 -08002003 int bus_status = ioread32(ioaddr + PktStatus);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002004 /* 0x80000000 PCI master abort. */
2005 /* 0x40000000 PCI target abort. */
2006 if (vortex_debug)
Alexander Beregalov39738e12009-05-26 12:35:26 +00002007 pr_err("%s: PCI bus error, bus status %8.8x\n", dev->name, bus_status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002008
2009 /* In this case, blow the card away */
2010 /* Must not enter D3 or we can't legally issue the reset! */
2011 vortex_down(dev, 0);
2012 issue_and_wait(dev, TotalReset | 0xff);
2013 vortex_up(dev); /* AKPM: bug. vortex_up() assumes that the rx ring is full. It may not be. */
2014 } else if (fifo_diag & 0x0400)
2015 do_tx_reset = 1;
2016 if (fifo_diag & 0x3000) {
2017 /* Reset Rx fifo and upload logic */
2018 issue_and_wait(dev, RxReset|0x07);
2019 /* Set the Rx filter to the current state. */
2020 set_rx_mode(dev);
2021 /* enable 802.1q VLAN tagged frames */
2022 set_8021q_mode(dev, 1);
John W. Linville62afe592005-11-07 00:58:02 -08002023 iowrite16(RxEnable, ioaddr + EL3_CMD); /* Re-enable the receiver. */
2024 iowrite16(AckIntr | HostError, ioaddr + EL3_CMD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002025 }
2026 }
2027
2028 if (do_tx_reset) {
2029 issue_and_wait(dev, TxReset|reset_mask);
John W. Linville62afe592005-11-07 00:58:02 -08002030 iowrite16(TxEnable, ioaddr + EL3_CMD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002031 if (!vp->full_bus_master_tx)
2032 netif_wake_queue(dev);
2033 }
2034}
2035
Stephen Hemminger27a1de92009-08-31 19:50:54 +00002036static netdev_tx_t
Linus Torvalds1da177e2005-04-16 15:20:36 -07002037vortex_start_xmit(struct sk_buff *skb, struct net_device *dev)
2038{
2039 struct vortex_private *vp = netdev_priv(dev);
John W. Linville62afe592005-11-07 00:58:02 -08002040 void __iomem *ioaddr = vp->ioaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002041
2042 /* Put out the doubleword header... */
John W. Linville62afe592005-11-07 00:58:02 -08002043 iowrite32(skb->len, ioaddr + TX_FIFO);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002044 if (vp->bus_master) {
2045 /* Set the bus-master controller to transfer the packet. */
2046 int len = (skb->len + 3) & ~3;
Steffen Klasserta880c4c2006-03-26 01:37:43 -08002047 iowrite32(vp->tx_skb_dma = pci_map_single(VORTEX_PCI(vp), skb->data, len, PCI_DMA_TODEVICE),
Linus Torvalds1da177e2005-04-16 15:20:36 -07002048 ioaddr + Wn7_MasterAddr);
John W. Linville62afe592005-11-07 00:58:02 -08002049 iowrite16(len, ioaddr + Wn7_MasterLen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002050 vp->tx_skb = skb;
John W. Linville62afe592005-11-07 00:58:02 -08002051 iowrite16(StartDMADown, ioaddr + EL3_CMD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002052 /* netif_wake_queue() will be called at the DMADone interrupt. */
2053 } else {
2054 /* ... and the packet rounded to a doubleword. */
John W. Linville62afe592005-11-07 00:58:02 -08002055 iowrite32_rep(ioaddr + TX_FIFO, skb->data, (skb->len + 3) >> 2);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002056 dev_kfree_skb (skb);
John W. Linville62afe592005-11-07 00:58:02 -08002057 if (ioread16(ioaddr + TxFree) > 1536) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002058 netif_start_queue (dev); /* AKPM: redundant? */
2059 } else {
2060 /* Interrupt us when the FIFO has room for max-sized packet. */
2061 netif_stop_queue(dev);
John W. Linville62afe592005-11-07 00:58:02 -08002062 iowrite16(SetTxThreshold + (1536>>2), ioaddr + EL3_CMD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002063 }
2064 }
2065
2066 dev->trans_start = jiffies;
2067
2068 /* Clear the Tx status stack. */
2069 {
2070 int tx_status;
2071 int i = 32;
2072
John W. Linville62afe592005-11-07 00:58:02 -08002073 while (--i > 0 && (tx_status = ioread8(ioaddr + TxStatus)) > 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002074 if (tx_status & 0x3C) { /* A Tx-disabling error occurred. */
2075 if (vortex_debug > 2)
Alexander Beregalov39738e12009-05-26 12:35:26 +00002076 pr_debug("%s: Tx error, status %2.2x.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002077 dev->name, tx_status);
Paulius Zaleckas1daad052008-05-05 14:01:29 +02002078 if (tx_status & 0x04) dev->stats.tx_fifo_errors++;
2079 if (tx_status & 0x38) dev->stats.tx_aborted_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002080 if (tx_status & 0x30) {
2081 issue_and_wait(dev, TxReset);
2082 }
John W. Linville62afe592005-11-07 00:58:02 -08002083 iowrite16(TxEnable, ioaddr + EL3_CMD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002084 }
John W. Linville62afe592005-11-07 00:58:02 -08002085 iowrite8(0x00, ioaddr + TxStatus); /* Pop the status stack. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002086 }
2087 }
Patrick McHardy6ed10652009-06-23 06:03:08 +00002088 return NETDEV_TX_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002089}
2090
Stephen Hemminger27a1de92009-08-31 19:50:54 +00002091static netdev_tx_t
Linus Torvalds1da177e2005-04-16 15:20:36 -07002092boomerang_start_xmit(struct sk_buff *skb, struct net_device *dev)
2093{
2094 struct vortex_private *vp = netdev_priv(dev);
John W. Linville62afe592005-11-07 00:58:02 -08002095 void __iomem *ioaddr = vp->ioaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002096 /* Calculate the next Tx descriptor entry. */
2097 int entry = vp->cur_tx % TX_RING_SIZE;
2098 struct boom_tx_desc *prev_entry = &vp->tx_ring[(vp->cur_tx-1) % TX_RING_SIZE];
2099 unsigned long flags;
2100
2101 if (vortex_debug > 6) {
Alexander Beregalov39738e12009-05-26 12:35:26 +00002102 pr_debug("boomerang_start_xmit()\n");
2103 pr_debug("%s: Trying to send a packet, Tx index %d.\n",
John W. Linville0f667ff2005-06-21 17:15:14 -07002104 dev->name, vp->cur_tx);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002105 }
2106
2107 if (vp->cur_tx - vp->dirty_tx >= TX_RING_SIZE) {
2108 if (vortex_debug > 0)
Alexander Beregalov39738e12009-05-26 12:35:26 +00002109 pr_warning("%s: BUG! Tx Ring full, refusing to send buffer.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002110 dev->name);
2111 netif_stop_queue(dev);
Patrick McHardy5b548142009-06-12 06:22:29 +00002112 return NETDEV_TX_BUSY;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002113 }
2114
2115 vp->tx_skbuff[entry] = skb;
2116
2117 vp->tx_ring[entry].next = 0;
2118#if DO_ZEROCOPY
Patrick McHardy84fa7932006-08-29 16:44:56 -07002119 if (skb->ip_summed != CHECKSUM_PARTIAL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002120 vp->tx_ring[entry].status = cpu_to_le32(skb->len | TxIntrUploaded);
2121 else
2122 vp->tx_ring[entry].status = cpu_to_le32(skb->len | TxIntrUploaded | AddTCPChksum | AddUDPChksum);
2123
2124 if (!skb_shinfo(skb)->nr_frags) {
2125 vp->tx_ring[entry].frag[0].addr = cpu_to_le32(pci_map_single(VORTEX_PCI(vp), skb->data,
2126 skb->len, PCI_DMA_TODEVICE));
2127 vp->tx_ring[entry].frag[0].length = cpu_to_le32(skb->len | LAST_FRAG);
2128 } else {
2129 int i;
2130
2131 vp->tx_ring[entry].frag[0].addr = cpu_to_le32(pci_map_single(VORTEX_PCI(vp), skb->data,
2132 skb->len-skb->data_len, PCI_DMA_TODEVICE));
2133 vp->tx_ring[entry].frag[0].length = cpu_to_le32(skb->len-skb->data_len);
2134
2135 for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
2136 skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
2137
2138 vp->tx_ring[entry].frag[i+1].addr =
2139 cpu_to_le32(pci_map_single(VORTEX_PCI(vp),
2140 (void*)page_address(frag->page) + frag->page_offset,
2141 frag->size, PCI_DMA_TODEVICE));
2142
2143 if (i == skb_shinfo(skb)->nr_frags-1)
2144 vp->tx_ring[entry].frag[i+1].length = cpu_to_le32(frag->size|LAST_FRAG);
2145 else
2146 vp->tx_ring[entry].frag[i+1].length = cpu_to_le32(frag->size);
2147 }
2148 }
2149#else
2150 vp->tx_ring[entry].addr = cpu_to_le32(pci_map_single(VORTEX_PCI(vp), skb->data, skb->len, PCI_DMA_TODEVICE));
2151 vp->tx_ring[entry].length = cpu_to_le32(skb->len | LAST_FRAG);
2152 vp->tx_ring[entry].status = cpu_to_le32(skb->len | TxIntrUploaded);
2153#endif
2154
2155 spin_lock_irqsave(&vp->lock, flags);
2156 /* Wait for the stall to complete. */
2157 issue_and_wait(dev, DownStall);
2158 prev_entry->next = cpu_to_le32(vp->tx_ring_dma + entry * sizeof(struct boom_tx_desc));
John W. Linville62afe592005-11-07 00:58:02 -08002159 if (ioread32(ioaddr + DownListPtr) == 0) {
2160 iowrite32(vp->tx_ring_dma + entry * sizeof(struct boom_tx_desc), ioaddr + DownListPtr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002161 vp->queued_packet++;
2162 }
2163
2164 vp->cur_tx++;
2165 if (vp->cur_tx - vp->dirty_tx > TX_RING_SIZE - 1) {
2166 netif_stop_queue (dev);
2167 } else { /* Clear previous interrupt enable. */
2168#if defined(tx_interrupt_mitigation)
2169 /* Dubious. If in boomeang_interrupt "faster" cyclone ifdef
2170 * were selected, this would corrupt DN_COMPLETE. No?
2171 */
2172 prev_entry->status &= cpu_to_le32(~TxIntrUploaded);
2173#endif
2174 }
John W. Linville62afe592005-11-07 00:58:02 -08002175 iowrite16(DownUnstall, ioaddr + EL3_CMD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002176 spin_unlock_irqrestore(&vp->lock, flags);
2177 dev->trans_start = jiffies;
Patrick McHardy6ed10652009-06-23 06:03:08 +00002178 return NETDEV_TX_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002179}
2180
2181/* The interrupt handler does all of the Rx thread work and cleans up
2182 after the Tx thread. */
2183
2184/*
2185 * This is the ISR for the vortex series chips.
2186 * full_bus_master_tx == 0 && full_bus_master_rx == 0
2187 */
2188
2189static irqreturn_t
David Howells7d12e782006-10-05 14:55:46 +01002190vortex_interrupt(int irq, void *dev_id)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002191{
2192 struct net_device *dev = dev_id;
2193 struct vortex_private *vp = netdev_priv(dev);
John W. Linville62afe592005-11-07 00:58:02 -08002194 void __iomem *ioaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002195 int status;
2196 int work_done = max_interrupt_work;
2197 int handled = 0;
2198
John W. Linville62afe592005-11-07 00:58:02 -08002199 ioaddr = vp->ioaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002200 spin_lock(&vp->lock);
2201
John W. Linville62afe592005-11-07 00:58:02 -08002202 status = ioread16(ioaddr + EL3_STATUS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002203
2204 if (vortex_debug > 6)
Alexander Beregalov39738e12009-05-26 12:35:26 +00002205 pr_debug("vortex_interrupt(). status=0x%4x\n", status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002206
2207 if ((status & IntLatch) == 0)
2208 goto handler_exit; /* No interrupt: shared IRQs cause this */
2209 handled = 1;
2210
2211 if (status & IntReq) {
2212 status |= vp->deferred;
2213 vp->deferred = 0;
2214 }
2215
2216 if (status == 0xffff) /* h/w no longer present (hotplug)? */
2217 goto handler_exit;
2218
2219 if (vortex_debug > 4)
Alexander Beregalov39738e12009-05-26 12:35:26 +00002220 pr_debug("%s: interrupt, status %4.4x, latency %d ticks.\n",
John W. Linville62afe592005-11-07 00:58:02 -08002221 dev->name, status, ioread8(ioaddr + Timer));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002222
2223 do {
2224 if (vortex_debug > 5)
Alexander Beregalov39738e12009-05-26 12:35:26 +00002225 pr_debug("%s: In interrupt loop, status %4.4x.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002226 dev->name, status);
2227 if (status & RxComplete)
2228 vortex_rx(dev);
2229
2230 if (status & TxAvailable) {
2231 if (vortex_debug > 5)
Alexander Beregalov39738e12009-05-26 12:35:26 +00002232 pr_debug(" TX room bit was handled.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002233 /* There's room in the FIFO for a full-sized packet. */
John W. Linville62afe592005-11-07 00:58:02 -08002234 iowrite16(AckIntr | TxAvailable, ioaddr + EL3_CMD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002235 netif_wake_queue (dev);
2236 }
2237
2238 if (status & DMADone) {
John W. Linville62afe592005-11-07 00:58:02 -08002239 if (ioread16(ioaddr + Wn7_MasterStatus) & 0x1000) {
2240 iowrite16(0x1000, ioaddr + Wn7_MasterStatus); /* Ack the event. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002241 pci_unmap_single(VORTEX_PCI(vp), vp->tx_skb_dma, (vp->tx_skb->len + 3) & ~3, PCI_DMA_TODEVICE);
2242 dev_kfree_skb_irq(vp->tx_skb); /* Release the transferred buffer */
John W. Linville62afe592005-11-07 00:58:02 -08002243 if (ioread16(ioaddr + TxFree) > 1536) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002244 /*
2245 * AKPM: FIXME: I don't think we need this. If the queue was stopped due to
2246 * insufficient FIFO room, the TxAvailable test will succeed and call
2247 * netif_wake_queue()
2248 */
2249 netif_wake_queue(dev);
2250 } else { /* Interrupt when FIFO has room for max-sized packet. */
John W. Linville62afe592005-11-07 00:58:02 -08002251 iowrite16(SetTxThreshold + (1536>>2), ioaddr + EL3_CMD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002252 netif_stop_queue(dev);
2253 }
2254 }
2255 }
2256 /* Check for all uncommon interrupts at once. */
2257 if (status & (HostError | RxEarly | StatsFull | TxComplete | IntReq)) {
2258 if (status == 0xffff)
2259 break;
2260 vortex_error(dev, status);
2261 }
2262
2263 if (--work_done < 0) {
Alexander Beregalov39738e12009-05-26 12:35:26 +00002264 pr_warning("%s: Too much work in interrupt, status %4.4x.\n",
2265 dev->name, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002266 /* Disable all pending interrupts. */
2267 do {
2268 vp->deferred |= status;
John W. Linville62afe592005-11-07 00:58:02 -08002269 iowrite16(SetStatusEnb | (~vp->deferred & vp->status_enable),
Linus Torvalds1da177e2005-04-16 15:20:36 -07002270 ioaddr + EL3_CMD);
John W. Linville62afe592005-11-07 00:58:02 -08002271 iowrite16(AckIntr | (vp->deferred & 0x7ff), ioaddr + EL3_CMD);
2272 } while ((status = ioread16(ioaddr + EL3_CMD)) & IntLatch);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002273 /* The timer will reenable interrupts. */
2274 mod_timer(&vp->timer, jiffies + 1*HZ);
2275 break;
2276 }
2277 /* Acknowledge the IRQ. */
John W. Linville62afe592005-11-07 00:58:02 -08002278 iowrite16(AckIntr | IntReq | IntLatch, ioaddr + EL3_CMD);
2279 } while ((status = ioread16(ioaddr + EL3_STATUS)) & (IntLatch | RxComplete));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002280
2281 if (vortex_debug > 4)
Alexander Beregalov39738e12009-05-26 12:35:26 +00002282 pr_debug("%s: exiting interrupt, status %4.4x.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002283 dev->name, status);
2284handler_exit:
2285 spin_unlock(&vp->lock);
2286 return IRQ_RETVAL(handled);
2287}
2288
2289/*
2290 * This is the ISR for the boomerang series chips.
2291 * full_bus_master_tx == 1 && full_bus_master_rx == 1
2292 */
2293
2294static irqreturn_t
David Howells7d12e782006-10-05 14:55:46 +01002295boomerang_interrupt(int irq, void *dev_id)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002296{
2297 struct net_device *dev = dev_id;
2298 struct vortex_private *vp = netdev_priv(dev);
John W. Linville62afe592005-11-07 00:58:02 -08002299 void __iomem *ioaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002300 int status;
2301 int work_done = max_interrupt_work;
2302
John W. Linville62afe592005-11-07 00:58:02 -08002303 ioaddr = vp->ioaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002304
2305 /*
2306 * It seems dopey to put the spinlock this early, but we could race against vortex_tx_timeout
2307 * and boomerang_start_xmit
2308 */
2309 spin_lock(&vp->lock);
2310
John W. Linville62afe592005-11-07 00:58:02 -08002311 status = ioread16(ioaddr + EL3_STATUS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002312
2313 if (vortex_debug > 6)
Alexander Beregalov39738e12009-05-26 12:35:26 +00002314 pr_debug("boomerang_interrupt. status=0x%4x\n", status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002315
2316 if ((status & IntLatch) == 0)
2317 goto handler_exit; /* No interrupt: shared IRQs can cause this */
2318
2319 if (status == 0xffff) { /* h/w no longer present (hotplug)? */
2320 if (vortex_debug > 1)
Alexander Beregalov39738e12009-05-26 12:35:26 +00002321 pr_debug("boomerang_interrupt(1): status = 0xffff\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002322 goto handler_exit;
2323 }
2324
2325 if (status & IntReq) {
2326 status |= vp->deferred;
2327 vp->deferred = 0;
2328 }
2329
2330 if (vortex_debug > 4)
Alexander Beregalov39738e12009-05-26 12:35:26 +00002331 pr_debug("%s: interrupt, status %4.4x, latency %d ticks.\n",
John W. Linville62afe592005-11-07 00:58:02 -08002332 dev->name, status, ioread8(ioaddr + Timer));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002333 do {
2334 if (vortex_debug > 5)
Alexander Beregalov39738e12009-05-26 12:35:26 +00002335 pr_debug("%s: In interrupt loop, status %4.4x.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002336 dev->name, status);
2337 if (status & UpComplete) {
John W. Linville62afe592005-11-07 00:58:02 -08002338 iowrite16(AckIntr | UpComplete, ioaddr + EL3_CMD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002339 if (vortex_debug > 5)
Alexander Beregalov39738e12009-05-26 12:35:26 +00002340 pr_debug("boomerang_interrupt->boomerang_rx\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002341 boomerang_rx(dev);
2342 }
2343
2344 if (status & DownComplete) {
2345 unsigned int dirty_tx = vp->dirty_tx;
2346
John W. Linville62afe592005-11-07 00:58:02 -08002347 iowrite16(AckIntr | DownComplete, ioaddr + EL3_CMD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002348 while (vp->cur_tx - dirty_tx > 0) {
2349 int entry = dirty_tx % TX_RING_SIZE;
2350#if 1 /* AKPM: the latter is faster, but cyclone-only */
John W. Linville62afe592005-11-07 00:58:02 -08002351 if (ioread32(ioaddr + DownListPtr) ==
Linus Torvalds1da177e2005-04-16 15:20:36 -07002352 vp->tx_ring_dma + entry * sizeof(struct boom_tx_desc))
2353 break; /* It still hasn't been processed. */
2354#else
2355 if ((vp->tx_ring[entry].status & DN_COMPLETE) == 0)
2356 break; /* It still hasn't been processed. */
2357#endif
Jeff Garzik6aa20a22006-09-13 13:24:59 -04002358
Linus Torvalds1da177e2005-04-16 15:20:36 -07002359 if (vp->tx_skbuff[entry]) {
2360 struct sk_buff *skb = vp->tx_skbuff[entry];
Jeff Garzik6aa20a22006-09-13 13:24:59 -04002361#if DO_ZEROCOPY
Linus Torvalds1da177e2005-04-16 15:20:36 -07002362 int i;
2363 for (i=0; i<=skb_shinfo(skb)->nr_frags; i++)
2364 pci_unmap_single(VORTEX_PCI(vp),
2365 le32_to_cpu(vp->tx_ring[entry].frag[i].addr),
2366 le32_to_cpu(vp->tx_ring[entry].frag[i].length)&0xFFF,
2367 PCI_DMA_TODEVICE);
2368#else
2369 pci_unmap_single(VORTEX_PCI(vp),
2370 le32_to_cpu(vp->tx_ring[entry].addr), skb->len, PCI_DMA_TODEVICE);
2371#endif
2372 dev_kfree_skb_irq(skb);
2373 vp->tx_skbuff[entry] = NULL;
2374 } else {
Alexander Beregalov39738e12009-05-26 12:35:26 +00002375 pr_debug("boomerang_interrupt: no skb!\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002376 }
Paulius Zaleckas1daad052008-05-05 14:01:29 +02002377 /* dev->stats.tx_packets++; Counted below. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002378 dirty_tx++;
2379 }
2380 vp->dirty_tx = dirty_tx;
2381 if (vp->cur_tx - dirty_tx <= TX_RING_SIZE - 1) {
2382 if (vortex_debug > 6)
Alexander Beregalov39738e12009-05-26 12:35:26 +00002383 pr_debug("boomerang_interrupt: wake queue\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002384 netif_wake_queue (dev);
2385 }
2386 }
2387
2388 /* Check for all uncommon interrupts at once. */
2389 if (status & (HostError | RxEarly | StatsFull | TxComplete | IntReq))
2390 vortex_error(dev, status);
2391
2392 if (--work_done < 0) {
Alexander Beregalov39738e12009-05-26 12:35:26 +00002393 pr_warning("%s: Too much work in interrupt, status %4.4x.\n",
2394 dev->name, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002395 /* Disable all pending interrupts. */
2396 do {
2397 vp->deferred |= status;
John W. Linville62afe592005-11-07 00:58:02 -08002398 iowrite16(SetStatusEnb | (~vp->deferred & vp->status_enable),
Linus Torvalds1da177e2005-04-16 15:20:36 -07002399 ioaddr + EL3_CMD);
John W. Linville62afe592005-11-07 00:58:02 -08002400 iowrite16(AckIntr | (vp->deferred & 0x7ff), ioaddr + EL3_CMD);
2401 } while ((status = ioread16(ioaddr + EL3_CMD)) & IntLatch);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002402 /* The timer will reenable interrupts. */
2403 mod_timer(&vp->timer, jiffies + 1*HZ);
2404 break;
2405 }
2406 /* Acknowledge the IRQ. */
John W. Linville62afe592005-11-07 00:58:02 -08002407 iowrite16(AckIntr | IntReq | IntLatch, ioaddr + EL3_CMD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002408 if (vp->cb_fn_base) /* The PCMCIA people are idiots. */
John W. Linville62afe592005-11-07 00:58:02 -08002409 iowrite32(0x8000, vp->cb_fn_base + 4);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002410
John W. Linville62afe592005-11-07 00:58:02 -08002411 } while ((status = ioread16(ioaddr + EL3_STATUS)) & IntLatch);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002412
2413 if (vortex_debug > 4)
Alexander Beregalov39738e12009-05-26 12:35:26 +00002414 pr_debug("%s: exiting interrupt, status %4.4x.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002415 dev->name, status);
2416handler_exit:
2417 spin_unlock(&vp->lock);
2418 return IRQ_HANDLED;
2419}
2420
2421static int vortex_rx(struct net_device *dev)
2422{
2423 struct vortex_private *vp = netdev_priv(dev);
John W. Linville62afe592005-11-07 00:58:02 -08002424 void __iomem *ioaddr = vp->ioaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002425 int i;
2426 short rx_status;
2427
2428 if (vortex_debug > 5)
Alexander Beregalov39738e12009-05-26 12:35:26 +00002429 pr_debug("vortex_rx(): status %4.4x, rx_status %4.4x.\n",
John W. Linville62afe592005-11-07 00:58:02 -08002430 ioread16(ioaddr+EL3_STATUS), ioread16(ioaddr+RxStatus));
2431 while ((rx_status = ioread16(ioaddr + RxStatus)) > 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002432 if (rx_status & 0x4000) { /* Error, update stats. */
John W. Linville62afe592005-11-07 00:58:02 -08002433 unsigned char rx_error = ioread8(ioaddr + RxErrors);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002434 if (vortex_debug > 2)
Alexander Beregalov39738e12009-05-26 12:35:26 +00002435 pr_debug(" Rx error: status %2.2x.\n", rx_error);
Paulius Zaleckas1daad052008-05-05 14:01:29 +02002436 dev->stats.rx_errors++;
2437 if (rx_error & 0x01) dev->stats.rx_over_errors++;
2438 if (rx_error & 0x02) dev->stats.rx_length_errors++;
2439 if (rx_error & 0x04) dev->stats.rx_frame_errors++;
2440 if (rx_error & 0x08) dev->stats.rx_crc_errors++;
2441 if (rx_error & 0x10) dev->stats.rx_length_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002442 } else {
2443 /* The packet length: up to 4.5K!. */
2444 int pkt_len = rx_status & 0x1fff;
2445 struct sk_buff *skb;
2446
2447 skb = dev_alloc_skb(pkt_len + 5);
2448 if (vortex_debug > 4)
Alexander Beregalov39738e12009-05-26 12:35:26 +00002449 pr_debug("Receiving packet size %d status %4.4x.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002450 pkt_len, rx_status);
2451 if (skb != NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002452 skb_reserve(skb, 2); /* Align IP on 16 byte boundaries */
2453 /* 'skb_put()' points to the start of sk_buff data area. */
2454 if (vp->bus_master &&
John W. Linville62afe592005-11-07 00:58:02 -08002455 ! (ioread16(ioaddr + Wn7_MasterStatus) & 0x8000)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002456 dma_addr_t dma = pci_map_single(VORTEX_PCI(vp), skb_put(skb, pkt_len),
2457 pkt_len, PCI_DMA_FROMDEVICE);
John W. Linville62afe592005-11-07 00:58:02 -08002458 iowrite32(dma, ioaddr + Wn7_MasterAddr);
2459 iowrite16((skb->len + 3) & ~3, ioaddr + Wn7_MasterLen);
2460 iowrite16(StartDMAUp, ioaddr + EL3_CMD);
2461 while (ioread16(ioaddr + Wn7_MasterStatus) & 0x8000)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002462 ;
2463 pci_unmap_single(VORTEX_PCI(vp), dma, pkt_len, PCI_DMA_FROMDEVICE);
2464 } else {
John W. Linville62afe592005-11-07 00:58:02 -08002465 ioread32_rep(ioaddr + RX_FIFO,
2466 skb_put(skb, pkt_len),
2467 (pkt_len + 3) >> 2);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002468 }
John W. Linville62afe592005-11-07 00:58:02 -08002469 iowrite16(RxDiscard, ioaddr + EL3_CMD); /* Pop top Rx packet. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002470 skb->protocol = eth_type_trans(skb, dev);
2471 netif_rx(skb);
Paulius Zaleckas1daad052008-05-05 14:01:29 +02002472 dev->stats.rx_packets++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002473 /* Wait a limited time to go to next packet. */
2474 for (i = 200; i >= 0; i--)
John W. Linville62afe592005-11-07 00:58:02 -08002475 if ( ! (ioread16(ioaddr + EL3_STATUS) & CmdInProgress))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002476 break;
2477 continue;
2478 } else if (vortex_debug > 0)
Alexander Beregalov39738e12009-05-26 12:35:26 +00002479 pr_notice("%s: No memory to allocate a sk_buff of size %d.\n",
2480 dev->name, pkt_len);
Paulius Zaleckas1daad052008-05-05 14:01:29 +02002481 dev->stats.rx_dropped++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002482 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002483 issue_and_wait(dev, RxDiscard);
2484 }
2485
2486 return 0;
2487}
2488
2489static int
2490boomerang_rx(struct net_device *dev)
2491{
2492 struct vortex_private *vp = netdev_priv(dev);
2493 int entry = vp->cur_rx % RX_RING_SIZE;
John W. Linville62afe592005-11-07 00:58:02 -08002494 void __iomem *ioaddr = vp->ioaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002495 int rx_status;
2496 int rx_work_limit = vp->dirty_rx + RX_RING_SIZE - vp->cur_rx;
2497
2498 if (vortex_debug > 5)
Alexander Beregalov39738e12009-05-26 12:35:26 +00002499 pr_debug("boomerang_rx(): status %4.4x\n", ioread16(ioaddr+EL3_STATUS));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002500
2501 while ((rx_status = le32_to_cpu(vp->rx_ring[entry].status)) & RxDComplete){
2502 if (--rx_work_limit < 0)
2503 break;
2504 if (rx_status & RxDError) { /* Error, update stats. */
2505 unsigned char rx_error = rx_status >> 16;
2506 if (vortex_debug > 2)
Alexander Beregalov39738e12009-05-26 12:35:26 +00002507 pr_debug(" Rx error: status %2.2x.\n", rx_error);
Paulius Zaleckas1daad052008-05-05 14:01:29 +02002508 dev->stats.rx_errors++;
2509 if (rx_error & 0x01) dev->stats.rx_over_errors++;
2510 if (rx_error & 0x02) dev->stats.rx_length_errors++;
2511 if (rx_error & 0x04) dev->stats.rx_frame_errors++;
2512 if (rx_error & 0x08) dev->stats.rx_crc_errors++;
2513 if (rx_error & 0x10) dev->stats.rx_length_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002514 } else {
2515 /* The packet length: up to 4.5K!. */
2516 int pkt_len = rx_status & 0x1fff;
2517 struct sk_buff *skb;
2518 dma_addr_t dma = le32_to_cpu(vp->rx_ring[entry].addr);
2519
2520 if (vortex_debug > 4)
Alexander Beregalov39738e12009-05-26 12:35:26 +00002521 pr_debug("Receiving packet size %d status %4.4x.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002522 pkt_len, rx_status);
2523
2524 /* Check if the packet is long enough to just accept without
2525 copying to a properly sized skbuff. */
Al Virocc2d6592007-08-22 21:34:46 -04002526 if (pkt_len < rx_copybreak && (skb = dev_alloc_skb(pkt_len + 2)) != NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002527 skb_reserve(skb, 2); /* Align IP on 16 byte boundaries */
2528 pci_dma_sync_single_for_cpu(VORTEX_PCI(vp), dma, PKT_BUF_SZ, PCI_DMA_FROMDEVICE);
2529 /* 'skb_put()' points to the start of sk_buff data area. */
2530 memcpy(skb_put(skb, pkt_len),
David S. Miller689be432005-06-28 15:25:31 -07002531 vp->rx_skbuff[entry]->data,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002532 pkt_len);
2533 pci_dma_sync_single_for_device(VORTEX_PCI(vp), dma, PKT_BUF_SZ, PCI_DMA_FROMDEVICE);
2534 vp->rx_copy++;
2535 } else {
2536 /* Pass up the skbuff already on the Rx ring. */
2537 skb = vp->rx_skbuff[entry];
2538 vp->rx_skbuff[entry] = NULL;
2539 skb_put(skb, pkt_len);
2540 pci_unmap_single(VORTEX_PCI(vp), dma, PKT_BUF_SZ, PCI_DMA_FROMDEVICE);
2541 vp->rx_nocopy++;
2542 }
2543 skb->protocol = eth_type_trans(skb, dev);
2544 { /* Use hardware checksum info. */
2545 int csum_bits = rx_status & 0xee000000;
2546 if (csum_bits &&
2547 (csum_bits == (IPChksumValid | TCPChksumValid) ||
2548 csum_bits == (IPChksumValid | UDPChksumValid))) {
2549 skb->ip_summed = CHECKSUM_UNNECESSARY;
2550 vp->rx_csumhits++;
2551 }
2552 }
2553 netif_rx(skb);
Paulius Zaleckas1daad052008-05-05 14:01:29 +02002554 dev->stats.rx_packets++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002555 }
2556 entry = (++vp->cur_rx) % RX_RING_SIZE;
2557 }
2558 /* Refill the Rx ring buffers. */
2559 for (; vp->cur_rx - vp->dirty_rx > 0; vp->dirty_rx++) {
2560 struct sk_buff *skb;
2561 entry = vp->dirty_rx % RX_RING_SIZE;
2562 if (vp->rx_skbuff[entry] == NULL) {
Stephen Hemminger9a5d34142008-07-25 12:07:22 -07002563 skb = netdev_alloc_skb(dev, PKT_BUF_SZ + NET_IP_ALIGN);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002564 if (skb == NULL) {
2565 static unsigned long last_jif;
Marcelo Feitoza Parisiff5688a2006-01-09 18:37:15 -08002566 if (time_after(jiffies, last_jif + 10 * HZ)) {
Alexander Beregalov39738e12009-05-26 12:35:26 +00002567 pr_warning("%s: memory shortage\n", dev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002568 last_jif = jiffies;
2569 }
2570 if ((vp->cur_rx - vp->dirty_rx) == RX_RING_SIZE)
2571 mod_timer(&vp->rx_oom_timer, RUN_AT(HZ * 1));
2572 break; /* Bad news! */
2573 }
Stephen Hemminger9a5d34142008-07-25 12:07:22 -07002574
2575 skb_reserve(skb, NET_IP_ALIGN);
David S. Miller689be432005-06-28 15:25:31 -07002576 vp->rx_ring[entry].addr = cpu_to_le32(pci_map_single(VORTEX_PCI(vp), skb->data, PKT_BUF_SZ, PCI_DMA_FROMDEVICE));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002577 vp->rx_skbuff[entry] = skb;
2578 }
2579 vp->rx_ring[entry].status = 0; /* Clear complete bit. */
John W. Linville62afe592005-11-07 00:58:02 -08002580 iowrite16(UpUnstall, ioaddr + EL3_CMD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002581 }
2582 return 0;
2583}
2584
2585/*
2586 * If we've hit a total OOM refilling the Rx ring we poll once a second
2587 * for some memory. Otherwise there is no way to restart the rx process.
2588 */
2589static void
2590rx_oom_timer(unsigned long arg)
2591{
2592 struct net_device *dev = (struct net_device *)arg;
2593 struct vortex_private *vp = netdev_priv(dev);
2594
2595 spin_lock_irq(&vp->lock);
2596 if ((vp->cur_rx - vp->dirty_rx) == RX_RING_SIZE) /* This test is redundant, but makes me feel good */
2597 boomerang_rx(dev);
2598 if (vortex_debug > 1) {
Alexander Beregalov39738e12009-05-26 12:35:26 +00002599 pr_debug("%s: rx_oom_timer %s\n", dev->name,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002600 ((vp->cur_rx - vp->dirty_rx) != RX_RING_SIZE) ? "succeeded" : "retrying");
2601 }
2602 spin_unlock_irq(&vp->lock);
2603}
2604
2605static void
2606vortex_down(struct net_device *dev, int final_down)
2607{
2608 struct vortex_private *vp = netdev_priv(dev);
John W. Linville62afe592005-11-07 00:58:02 -08002609 void __iomem *ioaddr = vp->ioaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002610
2611 netif_stop_queue (dev);
2612
2613 del_timer_sync(&vp->rx_oom_timer);
2614 del_timer_sync(&vp->timer);
2615
Paulius Zaleckas1daad052008-05-05 14:01:29 +02002616 /* Turn off statistics ASAP. We update dev->stats below. */
John W. Linville62afe592005-11-07 00:58:02 -08002617 iowrite16(StatsDisable, ioaddr + EL3_CMD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002618
2619 /* Disable the receiver and transmitter. */
John W. Linville62afe592005-11-07 00:58:02 -08002620 iowrite16(RxDisable, ioaddr + EL3_CMD);
2621 iowrite16(TxDisable, ioaddr + EL3_CMD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002622
2623 /* Disable receiving 802.1q tagged frames */
2624 set_8021q_mode(dev, 0);
2625
2626 if (dev->if_port == XCVR_10base2)
2627 /* Turn off thinnet power. Green! */
John W. Linville62afe592005-11-07 00:58:02 -08002628 iowrite16(StopCoax, ioaddr + EL3_CMD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002629
John W. Linville62afe592005-11-07 00:58:02 -08002630 iowrite16(SetIntrEnb | 0x0000, ioaddr + EL3_CMD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002631
2632 update_stats(ioaddr, dev);
2633 if (vp->full_bus_master_rx)
John W. Linville62afe592005-11-07 00:58:02 -08002634 iowrite32(0, ioaddr + UpListPtr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002635 if (vp->full_bus_master_tx)
John W. Linville62afe592005-11-07 00:58:02 -08002636 iowrite32(0, ioaddr + DownListPtr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002637
2638 if (final_down && VORTEX_PCI(vp)) {
Daniel Ritz3c8fad12005-05-05 16:15:44 -07002639 vp->pm_state_valid = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002640 pci_save_state(VORTEX_PCI(vp));
2641 acpi_set_WOL(dev);
2642 }
2643}
2644
2645static int
2646vortex_close(struct net_device *dev)
2647{
2648 struct vortex_private *vp = netdev_priv(dev);
John W. Linville62afe592005-11-07 00:58:02 -08002649 void __iomem *ioaddr = vp->ioaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002650 int i;
2651
2652 if (netif_device_present(dev))
2653 vortex_down(dev, 1);
2654
2655 if (vortex_debug > 1) {
Alexander Beregalov39738e12009-05-26 12:35:26 +00002656 pr_debug("%s: vortex_close() status %4.4x, Tx status %2.2x.\n",
John W. Linville62afe592005-11-07 00:58:02 -08002657 dev->name, ioread16(ioaddr + EL3_STATUS), ioread8(ioaddr + TxStatus));
Alexander Beregalov39738e12009-05-26 12:35:26 +00002658 pr_debug("%s: vortex close stats: rx_nocopy %d rx_copy %d"
Linus Torvalds1da177e2005-04-16 15:20:36 -07002659 " tx_queued %d Rx pre-checksummed %d.\n",
2660 dev->name, vp->rx_nocopy, vp->rx_copy, vp->queued_packet, vp->rx_csumhits);
2661 }
2662
2663#if DO_ZEROCOPY
John W. Linville32fb5f02005-11-07 00:58:05 -08002664 if (vp->rx_csumhits &&
2665 (vp->drv_flags & HAS_HWCKSM) == 0 &&
2666 (vp->card_idx >= MAX_UNITS || hw_checksums[vp->card_idx] == -1)) {
Alexander Beregalov39738e12009-05-26 12:35:26 +00002667 pr_warning("%s supports hardware checksums, and we're not using them!\n", dev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002668 }
2669#endif
Jeff Garzik6aa20a22006-09-13 13:24:59 -04002670
Linus Torvalds1da177e2005-04-16 15:20:36 -07002671 free_irq(dev->irq, dev);
2672
2673 if (vp->full_bus_master_rx) { /* Free Boomerang bus master Rx buffers. */
2674 for (i = 0; i < RX_RING_SIZE; i++)
2675 if (vp->rx_skbuff[i]) {
2676 pci_unmap_single( VORTEX_PCI(vp), le32_to_cpu(vp->rx_ring[i].addr),
2677 PKT_BUF_SZ, PCI_DMA_FROMDEVICE);
2678 dev_kfree_skb(vp->rx_skbuff[i]);
2679 vp->rx_skbuff[i] = NULL;
2680 }
2681 }
2682 if (vp->full_bus_master_tx) { /* Free Boomerang bus master Tx buffers. */
2683 for (i = 0; i < TX_RING_SIZE; i++) {
2684 if (vp->tx_skbuff[i]) {
2685 struct sk_buff *skb = vp->tx_skbuff[i];
2686#if DO_ZEROCOPY
2687 int k;
2688
2689 for (k=0; k<=skb_shinfo(skb)->nr_frags; k++)
2690 pci_unmap_single(VORTEX_PCI(vp),
2691 le32_to_cpu(vp->tx_ring[i].frag[k].addr),
2692 le32_to_cpu(vp->tx_ring[i].frag[k].length)&0xFFF,
2693 PCI_DMA_TODEVICE);
2694#else
2695 pci_unmap_single(VORTEX_PCI(vp), le32_to_cpu(vp->tx_ring[i].addr), skb->len, PCI_DMA_TODEVICE);
2696#endif
2697 dev_kfree_skb(skb);
2698 vp->tx_skbuff[i] = NULL;
2699 }
2700 }
2701 }
2702
2703 return 0;
2704}
2705
2706static void
2707dump_tx_ring(struct net_device *dev)
2708{
2709 if (vortex_debug > 0) {
2710 struct vortex_private *vp = netdev_priv(dev);
John W. Linville62afe592005-11-07 00:58:02 -08002711 void __iomem *ioaddr = vp->ioaddr;
Jeff Garzik6aa20a22006-09-13 13:24:59 -04002712
Linus Torvalds1da177e2005-04-16 15:20:36 -07002713 if (vp->full_bus_master_tx) {
2714 int i;
John W. Linville62afe592005-11-07 00:58:02 -08002715 int stalled = ioread32(ioaddr + PktStatus) & 0x04; /* Possible racy. But it's only debug stuff */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002716
Alexander Beregalov39738e12009-05-26 12:35:26 +00002717 pr_err(" Flags; bus-master %d, dirty %d(%d) current %d(%d)\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002718 vp->full_bus_master_tx,
2719 vp->dirty_tx, vp->dirty_tx % TX_RING_SIZE,
2720 vp->cur_tx, vp->cur_tx % TX_RING_SIZE);
Alexander Beregalov39738e12009-05-26 12:35:26 +00002721 pr_err(" Transmit list %8.8x vs. %p.\n",
John W. Linville62afe592005-11-07 00:58:02 -08002722 ioread32(ioaddr + DownListPtr),
Linus Torvalds1da177e2005-04-16 15:20:36 -07002723 &vp->tx_ring[vp->dirty_tx % TX_RING_SIZE]);
2724 issue_and_wait(dev, DownStall);
2725 for (i = 0; i < TX_RING_SIZE; i++) {
Jean Delvare0cb13532009-08-03 21:10:01 -07002726 unsigned int length;
2727
Linus Torvalds1da177e2005-04-16 15:20:36 -07002728#if DO_ZEROCOPY
Jean Delvare0cb13532009-08-03 21:10:01 -07002729 length = le32_to_cpu(vp->tx_ring[i].frag[0].length);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002730#else
Jean Delvare0cb13532009-08-03 21:10:01 -07002731 length = le32_to_cpu(vp->tx_ring[i].length);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002732#endif
Jean Delvare0cb13532009-08-03 21:10:01 -07002733 pr_err(" %d: @%p length %8.8x status %8.8x\n",
2734 i, &vp->tx_ring[i], length,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002735 le32_to_cpu(vp->tx_ring[i].status));
2736 }
2737 if (!stalled)
John W. Linville62afe592005-11-07 00:58:02 -08002738 iowrite16(DownUnstall, ioaddr + EL3_CMD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002739 }
2740 }
2741}
2742
2743static struct net_device_stats *vortex_get_stats(struct net_device *dev)
2744{
2745 struct vortex_private *vp = netdev_priv(dev);
John W. Linville62afe592005-11-07 00:58:02 -08002746 void __iomem *ioaddr = vp->ioaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002747 unsigned long flags;
2748
2749 if (netif_device_present(dev)) { /* AKPM: Used to be netif_running */
2750 spin_lock_irqsave (&vp->lock, flags);
John W. Linville62afe592005-11-07 00:58:02 -08002751 update_stats(ioaddr, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002752 spin_unlock_irqrestore (&vp->lock, flags);
2753 }
Paulius Zaleckas1daad052008-05-05 14:01:29 +02002754 return &dev->stats;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002755}
2756
2757/* Update statistics.
2758 Unlike with the EL3 we need not worry about interrupts changing
2759 the window setting from underneath us, but we must still guard
2760 against a race condition with a StatsUpdate interrupt updating the
2761 table. This is done by checking that the ASM (!) code generated uses
2762 atomic updates with '+='.
2763 */
John W. Linville62afe592005-11-07 00:58:02 -08002764static void update_stats(void __iomem *ioaddr, struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002765{
2766 struct vortex_private *vp = netdev_priv(dev);
John W. Linville62afe592005-11-07 00:58:02 -08002767 int old_window = ioread16(ioaddr + EL3_CMD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002768
2769 if (old_window == 0xffff) /* Chip suspended or ejected. */
2770 return;
2771 /* Unlike the 3c5x9 we need not turn off stats updates while reading. */
2772 /* Switch to the stats window, and read everything. */
2773 EL3WINDOW(6);
Paulius Zaleckas1daad052008-05-05 14:01:29 +02002774 dev->stats.tx_carrier_errors += ioread8(ioaddr + 0);
2775 dev->stats.tx_heartbeat_errors += ioread8(ioaddr + 1);
2776 dev->stats.tx_window_errors += ioread8(ioaddr + 4);
2777 dev->stats.rx_fifo_errors += ioread8(ioaddr + 5);
2778 dev->stats.tx_packets += ioread8(ioaddr + 6);
2779 dev->stats.tx_packets += (ioread8(ioaddr + 9)&0x30) << 4;
John W. Linville62afe592005-11-07 00:58:02 -08002780 /* Rx packets */ ioread8(ioaddr + 7); /* Must read to clear */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002781 /* Don't bother with register 9, an extension of registers 6&7.
2782 If we do use the 6&7 values the atomic update assumption above
2783 is invalid. */
Paulius Zaleckas1daad052008-05-05 14:01:29 +02002784 dev->stats.rx_bytes += ioread16(ioaddr + 10);
2785 dev->stats.tx_bytes += ioread16(ioaddr + 12);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002786 /* Extra stats for get_ethtool_stats() */
John W. Linville62afe592005-11-07 00:58:02 -08002787 vp->xstats.tx_multiple_collisions += ioread8(ioaddr + 2);
Steffen Klassert8d1d0342006-02-03 03:03:57 -08002788 vp->xstats.tx_single_collisions += ioread8(ioaddr + 3);
John W. Linville62afe592005-11-07 00:58:02 -08002789 vp->xstats.tx_deferred += ioread8(ioaddr + 8);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002790 EL3WINDOW(4);
John W. Linville62afe592005-11-07 00:58:02 -08002791 vp->xstats.rx_bad_ssd += ioread8(ioaddr + 12);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002792
Paulius Zaleckas1daad052008-05-05 14:01:29 +02002793 dev->stats.collisions = vp->xstats.tx_multiple_collisions
Steffen Klassert8d1d0342006-02-03 03:03:57 -08002794 + vp->xstats.tx_single_collisions
2795 + vp->xstats.tx_max_collisions;
2796
Linus Torvalds1da177e2005-04-16 15:20:36 -07002797 {
John W. Linville62afe592005-11-07 00:58:02 -08002798 u8 up = ioread8(ioaddr + 13);
Paulius Zaleckas1daad052008-05-05 14:01:29 +02002799 dev->stats.rx_bytes += (up & 0x0f) << 16;
2800 dev->stats.tx_bytes += (up & 0xf0) << 12;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002801 }
2802
2803 EL3WINDOW(old_window >> 13);
2804 return;
2805}
2806
2807static int vortex_nway_reset(struct net_device *dev)
2808{
2809 struct vortex_private *vp = netdev_priv(dev);
John W. Linville62afe592005-11-07 00:58:02 -08002810 void __iomem *ioaddr = vp->ioaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002811 unsigned long flags;
2812 int rc;
2813
2814 spin_lock_irqsave(&vp->lock, flags);
2815 EL3WINDOW(4);
2816 rc = mii_nway_restart(&vp->mii);
2817 spin_unlock_irqrestore(&vp->lock, flags);
2818 return rc;
2819}
2820
Linus Torvalds1da177e2005-04-16 15:20:36 -07002821static int vortex_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
2822{
2823 struct vortex_private *vp = netdev_priv(dev);
John W. Linville62afe592005-11-07 00:58:02 -08002824 void __iomem *ioaddr = vp->ioaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002825 unsigned long flags;
2826 int rc;
2827
2828 spin_lock_irqsave(&vp->lock, flags);
2829 EL3WINDOW(4);
2830 rc = mii_ethtool_gset(&vp->mii, cmd);
2831 spin_unlock_irqrestore(&vp->lock, flags);
2832 return rc;
2833}
2834
2835static int vortex_set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
2836{
2837 struct vortex_private *vp = netdev_priv(dev);
John W. Linville62afe592005-11-07 00:58:02 -08002838 void __iomem *ioaddr = vp->ioaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002839 unsigned long flags;
2840 int rc;
2841
2842 spin_lock_irqsave(&vp->lock, flags);
2843 EL3WINDOW(4);
2844 rc = mii_ethtool_sset(&vp->mii, cmd);
2845 spin_unlock_irqrestore(&vp->lock, flags);
2846 return rc;
2847}
2848
2849static u32 vortex_get_msglevel(struct net_device *dev)
2850{
2851 return vortex_debug;
2852}
2853
2854static void vortex_set_msglevel(struct net_device *dev, u32 dbg)
2855{
2856 vortex_debug = dbg;
2857}
2858
Jeff Garzikb9f2c042007-10-03 18:07:32 -07002859static int vortex_get_sset_count(struct net_device *dev, int sset)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002860{
Jeff Garzikb9f2c042007-10-03 18:07:32 -07002861 switch (sset) {
2862 case ETH_SS_STATS:
2863 return VORTEX_NUM_STATS;
2864 default:
2865 return -EOPNOTSUPP;
2866 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002867}
2868
2869static void vortex_get_ethtool_stats(struct net_device *dev,
2870 struct ethtool_stats *stats, u64 *data)
2871{
2872 struct vortex_private *vp = netdev_priv(dev);
John W. Linville62afe592005-11-07 00:58:02 -08002873 void __iomem *ioaddr = vp->ioaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002874 unsigned long flags;
2875
2876 spin_lock_irqsave(&vp->lock, flags);
John W. Linville62afe592005-11-07 00:58:02 -08002877 update_stats(ioaddr, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002878 spin_unlock_irqrestore(&vp->lock, flags);
2879
2880 data[0] = vp->xstats.tx_deferred;
Steffen Klassert8d1d0342006-02-03 03:03:57 -08002881 data[1] = vp->xstats.tx_max_collisions;
2882 data[2] = vp->xstats.tx_multiple_collisions;
2883 data[3] = vp->xstats.tx_single_collisions;
2884 data[4] = vp->xstats.rx_bad_ssd;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002885}
2886
2887
2888static void vortex_get_strings(struct net_device *dev, u32 stringset, u8 *data)
2889{
2890 switch (stringset) {
2891 case ETH_SS_STATS:
2892 memcpy(data, &ethtool_stats_keys, sizeof(ethtool_stats_keys));
2893 break;
2894 default:
2895 WARN_ON(1);
2896 break;
2897 }
2898}
2899
2900static void vortex_get_drvinfo(struct net_device *dev,
2901 struct ethtool_drvinfo *info)
2902{
2903 struct vortex_private *vp = netdev_priv(dev);
2904
2905 strcpy(info->driver, DRV_NAME);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002906 if (VORTEX_PCI(vp)) {
2907 strcpy(info->bus_info, pci_name(VORTEX_PCI(vp)));
2908 } else {
2909 if (VORTEX_EISA(vp))
Stephen Hemminger86de79b2009-02-26 10:19:24 +00002910 strcpy(info->bus_info, dev_name(vp->gendev));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002911 else
2912 sprintf(info->bus_info, "EISA 0x%lx %d",
2913 dev->base_addr, dev->irq);
2914 }
2915}
2916
Jeff Garzik7282d492006-09-13 14:30:00 -04002917static const struct ethtool_ops vortex_ethtool_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002918 .get_drvinfo = vortex_get_drvinfo,
2919 .get_strings = vortex_get_strings,
2920 .get_msglevel = vortex_get_msglevel,
2921 .set_msglevel = vortex_set_msglevel,
2922 .get_ethtool_stats = vortex_get_ethtool_stats,
Jeff Garzikb9f2c042007-10-03 18:07:32 -07002923 .get_sset_count = vortex_get_sset_count,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002924 .get_settings = vortex_get_settings,
2925 .set_settings = vortex_set_settings,
Steffen Klassert373a6882006-03-26 01:37:41 -08002926 .get_link = ethtool_op_get_link,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002927 .nway_reset = vortex_nway_reset,
2928};
2929
2930#ifdef CONFIG_PCI
2931/*
2932 * Must power the device up to do MDIO operations
2933 */
2934static int vortex_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
2935{
2936 int err;
2937 struct vortex_private *vp = netdev_priv(dev);
John W. Linville62afe592005-11-07 00:58:02 -08002938 void __iomem *ioaddr = vp->ioaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002939 unsigned long flags;
Al Virocc2d6592007-08-22 21:34:46 -04002940 pci_power_t state = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002941
2942 if(VORTEX_PCI(vp))
2943 state = VORTEX_PCI(vp)->current_state;
2944
2945 /* The kernel core really should have pci_get_power_state() */
2946
2947 if(state != 0)
2948 pci_set_power_state(VORTEX_PCI(vp), PCI_D0);
2949 spin_lock_irqsave(&vp->lock, flags);
2950 EL3WINDOW(4);
2951 err = generic_mii_ioctl(&vp->mii, if_mii(rq), cmd, NULL);
2952 spin_unlock_irqrestore(&vp->lock, flags);
2953 if(state != 0)
2954 pci_set_power_state(VORTEX_PCI(vp), state);
2955
2956 return err;
2957}
2958#endif
2959
2960
2961/* Pre-Cyclone chips have no documented multicast filter, so the only
2962 multicast setting is to receive all multicast frames. At least
2963 the chip has a very clean way to set the mode, unlike many others. */
2964static void set_rx_mode(struct net_device *dev)
2965{
John W. Linville62afe592005-11-07 00:58:02 -08002966 struct vortex_private *vp = netdev_priv(dev);
2967 void __iomem *ioaddr = vp->ioaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002968 int new_mode;
2969
2970 if (dev->flags & IFF_PROMISC) {
Andy Gospodarekd5b20692006-09-11 17:39:18 -04002971 if (vortex_debug > 3)
Alexander Beregalov39738e12009-05-26 12:35:26 +00002972 pr_notice("%s: Setting promiscuous mode.\n", dev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002973 new_mode = SetRxFilter|RxStation|RxMulticast|RxBroadcast|RxProm;
2974 } else if ((dev->mc_list) || (dev->flags & IFF_ALLMULTI)) {
2975 new_mode = SetRxFilter|RxStation|RxMulticast|RxBroadcast;
2976 } else
2977 new_mode = SetRxFilter | RxStation | RxBroadcast;
2978
John W. Linville62afe592005-11-07 00:58:02 -08002979 iowrite16(new_mode, ioaddr + EL3_CMD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002980}
2981
2982#if defined(CONFIG_VLAN_8021Q) || defined(CONFIG_VLAN_8021Q_MODULE)
2983/* Setup the card so that it can receive frames with an 802.1q VLAN tag.
2984 Note that this must be done after each RxReset due to some backwards
2985 compatibility logic in the Cyclone and Tornado ASICs */
2986
2987/* The Ethernet Type used for 802.1q tagged frames */
2988#define VLAN_ETHER_TYPE 0x8100
2989
2990static void set_8021q_mode(struct net_device *dev, int enable)
2991{
2992 struct vortex_private *vp = netdev_priv(dev);
John W. Linville62afe592005-11-07 00:58:02 -08002993 void __iomem *ioaddr = vp->ioaddr;
2994 int old_window = ioread16(ioaddr + EL3_CMD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002995 int mac_ctrl;
2996
2997 if ((vp->drv_flags&IS_CYCLONE) || (vp->drv_flags&IS_TORNADO)) {
2998 /* cyclone and tornado chipsets can recognize 802.1q
2999 * tagged frames and treat them correctly */
3000
3001 int max_pkt_size = dev->mtu+14; /* MTU+Ethernet header */
3002 if (enable)
3003 max_pkt_size += 4; /* 802.1Q VLAN tag */
3004
3005 EL3WINDOW(3);
John W. Linville62afe592005-11-07 00:58:02 -08003006 iowrite16(max_pkt_size, ioaddr+Wn3_MaxPktSize);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003007
3008 /* set VlanEtherType to let the hardware checksumming
3009 treat tagged frames correctly */
3010 EL3WINDOW(7);
John W. Linville62afe592005-11-07 00:58:02 -08003011 iowrite16(VLAN_ETHER_TYPE, ioaddr+Wn7_VlanEtherType);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003012 } else {
3013 /* on older cards we have to enable large frames */
3014
3015 vp->large_frames = dev->mtu > 1500 || enable;
3016
3017 EL3WINDOW(3);
John W. Linville62afe592005-11-07 00:58:02 -08003018 mac_ctrl = ioread16(ioaddr+Wn3_MAC_Ctrl);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003019 if (vp->large_frames)
3020 mac_ctrl |= 0x40;
3021 else
3022 mac_ctrl &= ~0x40;
John W. Linville62afe592005-11-07 00:58:02 -08003023 iowrite16(mac_ctrl, ioaddr+Wn3_MAC_Ctrl);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003024 }
3025
3026 EL3WINDOW(old_window);
3027}
3028#else
3029
3030static void set_8021q_mode(struct net_device *dev, int enable)
3031{
3032}
3033
3034
3035#endif
3036
3037/* MII transceiver control section.
3038 Read and write the MII registers using software-generated serial
3039 MDIO protocol. See the MII specifications or DP83840A data sheet
3040 for details. */
3041
3042/* The maximum data clock rate is 2.5 Mhz. The minimum timing is usually
3043 met by back-to-back PCI I/O cycles, but we insert a delay to avoid
3044 "overclocking" issues. */
John W. Linville62afe592005-11-07 00:58:02 -08003045#define mdio_delay() ioread32(mdio_addr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003046
3047#define MDIO_SHIFT_CLK 0x01
3048#define MDIO_DIR_WRITE 0x04
3049#define MDIO_DATA_WRITE0 (0x00 | MDIO_DIR_WRITE)
3050#define MDIO_DATA_WRITE1 (0x02 | MDIO_DIR_WRITE)
3051#define MDIO_DATA_READ 0x02
3052#define MDIO_ENB_IN 0x00
3053
3054/* Generate the preamble required for initial synchronization and
3055 a few older transceivers. */
John W. Linville62afe592005-11-07 00:58:02 -08003056static void mdio_sync(void __iomem *ioaddr, int bits)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003057{
John W. Linville62afe592005-11-07 00:58:02 -08003058 void __iomem *mdio_addr = ioaddr + Wn4_PhysicalMgmt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003059
3060 /* Establish sync by sending at least 32 logic ones. */
3061 while (-- bits >= 0) {
John W. Linville62afe592005-11-07 00:58:02 -08003062 iowrite16(MDIO_DATA_WRITE1, mdio_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003063 mdio_delay();
John W. Linville62afe592005-11-07 00:58:02 -08003064 iowrite16(MDIO_DATA_WRITE1 | MDIO_SHIFT_CLK, mdio_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003065 mdio_delay();
3066 }
3067}
3068
3069static int mdio_read(struct net_device *dev, int phy_id, int location)
3070{
3071 int i;
John W. Linville62afe592005-11-07 00:58:02 -08003072 struct vortex_private *vp = netdev_priv(dev);
3073 void __iomem *ioaddr = vp->ioaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003074 int read_cmd = (0xf6 << 10) | (phy_id << 5) | location;
3075 unsigned int retval = 0;
John W. Linville62afe592005-11-07 00:58:02 -08003076 void __iomem *mdio_addr = ioaddr + Wn4_PhysicalMgmt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003077
3078 if (mii_preamble_required)
3079 mdio_sync(ioaddr, 32);
3080
3081 /* Shift the read command bits out. */
3082 for (i = 14; i >= 0; i--) {
3083 int dataval = (read_cmd&(1<<i)) ? MDIO_DATA_WRITE1 : MDIO_DATA_WRITE0;
John W. Linville62afe592005-11-07 00:58:02 -08003084 iowrite16(dataval, mdio_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003085 mdio_delay();
John W. Linville62afe592005-11-07 00:58:02 -08003086 iowrite16(dataval | MDIO_SHIFT_CLK, mdio_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003087 mdio_delay();
3088 }
3089 /* Read the two transition, 16 data, and wire-idle bits. */
3090 for (i = 19; i > 0; i--) {
John W. Linville62afe592005-11-07 00:58:02 -08003091 iowrite16(MDIO_ENB_IN, mdio_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003092 mdio_delay();
John W. Linville62afe592005-11-07 00:58:02 -08003093 retval = (retval << 1) | ((ioread16(mdio_addr) & MDIO_DATA_READ) ? 1 : 0);
3094 iowrite16(MDIO_ENB_IN | MDIO_SHIFT_CLK, mdio_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003095 mdio_delay();
3096 }
3097 return retval & 0x20000 ? 0xffff : retval>>1 & 0xffff;
3098}
3099
3100static void mdio_write(struct net_device *dev, int phy_id, int location, int value)
3101{
John W. Linville62afe592005-11-07 00:58:02 -08003102 struct vortex_private *vp = netdev_priv(dev);
3103 void __iomem *ioaddr = vp->ioaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003104 int write_cmd = 0x50020000 | (phy_id << 23) | (location << 18) | value;
John W. Linville62afe592005-11-07 00:58:02 -08003105 void __iomem *mdio_addr = ioaddr + Wn4_PhysicalMgmt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003106 int i;
3107
3108 if (mii_preamble_required)
3109 mdio_sync(ioaddr, 32);
3110
3111 /* Shift the command bits out. */
3112 for (i = 31; i >= 0; i--) {
3113 int dataval = (write_cmd&(1<<i)) ? MDIO_DATA_WRITE1 : MDIO_DATA_WRITE0;
John W. Linville62afe592005-11-07 00:58:02 -08003114 iowrite16(dataval, mdio_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003115 mdio_delay();
John W. Linville62afe592005-11-07 00:58:02 -08003116 iowrite16(dataval | MDIO_SHIFT_CLK, mdio_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003117 mdio_delay();
3118 }
3119 /* Leave the interface idle. */
3120 for (i = 1; i >= 0; i--) {
John W. Linville62afe592005-11-07 00:58:02 -08003121 iowrite16(MDIO_ENB_IN, mdio_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003122 mdio_delay();
John W. Linville62afe592005-11-07 00:58:02 -08003123 iowrite16(MDIO_ENB_IN | MDIO_SHIFT_CLK, mdio_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003124 mdio_delay();
3125 }
3126 return;
3127}
Steffen Klasserta880c4c2006-03-26 01:37:43 -08003128
Linus Torvalds1da177e2005-04-16 15:20:36 -07003129/* ACPI: Advanced Configuration and Power Interface. */
3130/* Set Wake-On-LAN mode and put the board into D3 (power-down) state. */
3131static void acpi_set_WOL(struct net_device *dev)
3132{
3133 struct vortex_private *vp = netdev_priv(dev);
John W. Linville62afe592005-11-07 00:58:02 -08003134 void __iomem *ioaddr = vp->ioaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003135
Steffen Klassertc17931c2009-01-09 03:53:17 +00003136 device_set_wakeup_enable(vp->gendev, vp->enable_wol);
3137
Linus Torvalds1da177e2005-04-16 15:20:36 -07003138 if (vp->enable_wol) {
3139 /* Power up on: 1==Downloaded Filter, 2==Magic Packets, 4==Link Status. */
3140 EL3WINDOW(7);
John W. Linville62afe592005-11-07 00:58:02 -08003141 iowrite16(2, ioaddr + 0x0c);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003142 /* The RxFilter must accept the WOL frames. */
John W. Linville62afe592005-11-07 00:58:02 -08003143 iowrite16(SetRxFilter|RxStation|RxMulticast|RxBroadcast, ioaddr + EL3_CMD);
3144 iowrite16(RxEnable, ioaddr + EL3_CMD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003145
Steffen Klassert1a1769f2007-10-16 14:24:09 -07003146 if (pci_enable_wake(VORTEX_PCI(vp), PCI_D3hot, 1)) {
Alexander Beregalov39738e12009-05-26 12:35:26 +00003147 pr_info("%s: WOL not supported.\n", pci_name(VORTEX_PCI(vp)));
Steffen Klassert1a1769f2007-10-16 14:24:09 -07003148
3149 vp->enable_wol = 0;
3150 return;
3151 }
Daniel Ritz3c8fad12005-05-05 16:15:44 -07003152
3153 /* Change the power state to D3; RxEnable doesn't take effect. */
3154 pci_set_power_state(VORTEX_PCI(vp), PCI_D3hot);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003155 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003156}
3157
3158
Steffen Klasserta880c4c2006-03-26 01:37:43 -08003159static void __devexit vortex_remove_one(struct pci_dev *pdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003160{
3161 struct net_device *dev = pci_get_drvdata(pdev);
3162 struct vortex_private *vp;
3163
3164 if (!dev) {
Alexander Beregalov39738e12009-05-26 12:35:26 +00003165 pr_err("vortex_remove_one called for Compaq device!\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07003166 BUG();
3167 }
3168
3169 vp = netdev_priv(dev);
3170
John W. Linville62afe592005-11-07 00:58:02 -08003171 if (vp->cb_fn_base)
3172 pci_iounmap(VORTEX_PCI(vp), vp->cb_fn_base);
3173
Linus Torvalds1da177e2005-04-16 15:20:36 -07003174 unregister_netdev(dev);
3175
3176 if (VORTEX_PCI(vp)) {
3177 pci_set_power_state(VORTEX_PCI(vp), PCI_D0); /* Go active */
3178 if (vp->pm_state_valid)
3179 pci_restore_state(VORTEX_PCI(vp));
3180 pci_disable_device(VORTEX_PCI(vp));
3181 }
3182 /* Should really use issue_and_wait() here */
John W. Linville62afe592005-11-07 00:58:02 -08003183 iowrite16(TotalReset | ((vp->drv_flags & EEPROM_RESET) ? 0x04 : 0x14),
3184 vp->ioaddr + EL3_CMD);
3185
3186 pci_iounmap(VORTEX_PCI(vp), vp->ioaddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003187
3188 pci_free_consistent(pdev,
3189 sizeof(struct boom_rx_desc) * RX_RING_SIZE
3190 + sizeof(struct boom_tx_desc) * TX_RING_SIZE,
3191 vp->rx_ring,
3192 vp->rx_ring_dma);
3193 if (vp->must_free_region)
3194 release_region(dev->base_addr, vp->io_size);
3195 free_netdev(dev);
3196}
3197
3198
3199static struct pci_driver vortex_driver = {
3200 .name = "3c59x",
3201 .probe = vortex_init_one,
3202 .remove = __devexit_p(vortex_remove_one),
3203 .id_table = vortex_pci_tbl,
Anton Vorontsov7bfc4ab2009-09-30 20:11:11 -07003204 .driver.pm = VORTEX_PM_OPS,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003205};
3206
3207
3208static int vortex_have_pci;
3209static int vortex_have_eisa;
3210
3211
Steffen Klasserta880c4c2006-03-26 01:37:43 -08003212static int __init vortex_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003213{
3214 int pci_rc, eisa_rc;
3215
Jeff Garzik29917622006-08-19 17:48:59 -04003216 pci_rc = pci_register_driver(&vortex_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003217 eisa_rc = vortex_eisa_init();
3218
3219 if (pci_rc == 0)
3220 vortex_have_pci = 1;
3221 if (eisa_rc > 0)
3222 vortex_have_eisa = 1;
3223
3224 return (vortex_have_pci + vortex_have_eisa) ? 0 : -ENODEV;
3225}
3226
3227
Steffen Klasserta880c4c2006-03-26 01:37:43 -08003228static void __exit vortex_eisa_cleanup(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003229{
3230 struct vortex_private *vp;
John W. Linville62afe592005-11-07 00:58:02 -08003231 void __iomem *ioaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003232
3233#ifdef CONFIG_EISA
3234 /* Take care of the EISA devices */
Steffen Klasserta880c4c2006-03-26 01:37:43 -08003235 eisa_driver_unregister(&vortex_eisa_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003236#endif
Jeff Garzik6aa20a22006-09-13 13:24:59 -04003237
Linus Torvalds1da177e2005-04-16 15:20:36 -07003238 if (compaq_net_device) {
Wang Chen454d7c92008-11-12 23:37:49 -08003239 vp = netdev_priv(compaq_net_device);
John W. Linville62afe592005-11-07 00:58:02 -08003240 ioaddr = ioport_map(compaq_net_device->base_addr,
3241 VORTEX_TOTAL_SIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003242
Steffen Klasserta880c4c2006-03-26 01:37:43 -08003243 unregister_netdev(compaq_net_device);
3244 iowrite16(TotalReset, ioaddr + EL3_CMD);
John W. Linville62afe592005-11-07 00:58:02 -08003245 release_region(compaq_net_device->base_addr,
3246 VORTEX_TOTAL_SIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003247
Steffen Klasserta880c4c2006-03-26 01:37:43 -08003248 free_netdev(compaq_net_device);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003249 }
3250}
3251
3252
Steffen Klasserta880c4c2006-03-26 01:37:43 -08003253static void __exit vortex_cleanup(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003254{
3255 if (vortex_have_pci)
Steffen Klasserta880c4c2006-03-26 01:37:43 -08003256 pci_unregister_driver(&vortex_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003257 if (vortex_have_eisa)
Steffen Klasserta880c4c2006-03-26 01:37:43 -08003258 vortex_eisa_cleanup();
Linus Torvalds1da177e2005-04-16 15:20:36 -07003259}
3260
3261
3262module_init(vortex_init);
3263module_exit(vortex_cleanup);