blob: ebd4c19e30ae9d2d637ce5e5d2f24012324b3dd8 [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>
Linus Torvalds1da177e2005-04-16 15:20:36 -070080#include <linux/interrupt.h>
81#include <linux/pci.h>
82#include <linux/mii.h>
83#include <linux/init.h>
84#include <linux/netdevice.h>
85#include <linux/etherdevice.h>
86#include <linux/skbuff.h>
87#include <linux/ethtool.h>
88#include <linux/highmem.h>
89#include <linux/eisa.h>
90#include <linux/bitops.h>
Marcelo Feitoza Parisiff5688a2006-01-09 18:37:15 -080091#include <linux/jiffies.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090092#include <linux/gfp.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
Alexey Dobriyana3aa1882010-01-07 11:58:11 +0000378static DEFINE_PCI_DEVICE_TABLE(vortex_pci_tbl) = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379 { 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 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700438#define EL3_CMD 0x0e
439#define EL3_STATUS 0x0e
440
441/* The top five bits written to EL3_CMD are a command, the lower
442 11 bits are the parameter, if applicable.
443 Note that 11 parameters bits was fine for ethernet, but the new chip
444 can handle FDDI length frames (~4500 octets) and now parameters count
445 32-bit 'Dwords' rather than octets. */
446
447enum vortex_cmd {
448 TotalReset = 0<<11, SelectWindow = 1<<11, StartCoax = 2<<11,
449 RxDisable = 3<<11, RxEnable = 4<<11, RxReset = 5<<11,
450 UpStall = 6<<11, UpUnstall = (6<<11)+1,
451 DownStall = (6<<11)+2, DownUnstall = (6<<11)+3,
452 RxDiscard = 8<<11, TxEnable = 9<<11, TxDisable = 10<<11, TxReset = 11<<11,
453 FakeIntr = 12<<11, AckIntr = 13<<11, SetIntrEnb = 14<<11,
454 SetStatusEnb = 15<<11, SetRxFilter = 16<<11, SetRxThreshold = 17<<11,
455 SetTxThreshold = 18<<11, SetTxStart = 19<<11,
456 StartDMAUp = 20<<11, StartDMADown = (20<<11)+1, StatsEnable = 21<<11,
457 StatsDisable = 22<<11, StopCoax = 23<<11, SetFilterBit = 25<<11,};
458
459/* The SetRxFilter command accepts the following classes: */
460enum RxFilter {
461 RxStation = 1, RxMulticast = 2, RxBroadcast = 4, RxProm = 8 };
462
463/* Bits in the general status register. */
464enum vortex_status {
465 IntLatch = 0x0001, HostError = 0x0002, TxComplete = 0x0004,
466 TxAvailable = 0x0008, RxComplete = 0x0010, RxEarly = 0x0020,
467 IntReq = 0x0040, StatsFull = 0x0080,
468 DMADone = 1<<8, DownComplete = 1<<9, UpComplete = 1<<10,
469 DMAInProgress = 1<<11, /* DMA controller is still busy.*/
470 CmdInProgress = 1<<12, /* EL3_CMD is still busy.*/
471};
472
473/* Register window 1 offsets, the window used in normal operation.
474 On the Vortex this window is always mapped at offsets 0x10-0x1f. */
475enum Window1 {
476 TX_FIFO = 0x10, RX_FIFO = 0x10, RxErrors = 0x14,
477 RxStatus = 0x18, Timer=0x1A, TxStatus = 0x1B,
478 TxFree = 0x1C, /* Remaining free bytes in Tx buffer. */
479};
480enum Window0 {
481 Wn0EepromCmd = 10, /* Window 0: EEPROM command register. */
482 Wn0EepromData = 12, /* Window 0: EEPROM results register. */
483 IntrStatus=0x0E, /* Valid in all windows. */
484};
485enum Win0_EEPROM_bits {
486 EEPROM_Read = 0x80, EEPROM_WRITE = 0x40, EEPROM_ERASE = 0xC0,
487 EEPROM_EWENB = 0x30, /* Enable erasing/writing for 10 msec. */
488 EEPROM_EWDIS = 0x00, /* Disable EWENB before 10 msec timeout. */
489};
490/* EEPROM locations. */
491enum eeprom_offset {
492 PhysAddr01=0, PhysAddr23=1, PhysAddr45=2, ModelID=3,
493 EtherLink3ID=7, IFXcvrIO=8, IRQLine=9,
494 NodeAddr01=10, NodeAddr23=11, NodeAddr45=12,
495 DriverTune=13, Checksum=15};
496
497enum Window2 { /* Window 2. */
498 Wn2_ResetOptions=12,
499};
500enum Window3 { /* Window 3: MAC/config bits. */
501 Wn3_Config=0, Wn3_MaxPktSize=4, Wn3_MAC_Ctrl=6, Wn3_Options=8,
502};
503
504#define BFEXT(value, offset, bitcount) \
505 ((((unsigned long)(value)) >> (offset)) & ((1 << (bitcount)) - 1))
506
507#define BFINS(lhs, rhs, offset, bitcount) \
508 (((lhs) & ~((((1 << (bitcount)) - 1)) << (offset))) | \
509 (((rhs) & ((1 << (bitcount)) - 1)) << (offset)))
510
511#define RAM_SIZE(v) BFEXT(v, 0, 3)
512#define RAM_WIDTH(v) BFEXT(v, 3, 1)
513#define RAM_SPEED(v) BFEXT(v, 4, 2)
514#define ROM_SIZE(v) BFEXT(v, 6, 2)
515#define RAM_SPLIT(v) BFEXT(v, 16, 2)
516#define XCVR(v) BFEXT(v, 20, 4)
517#define AUTOSELECT(v) BFEXT(v, 24, 1)
518
519enum Window4 { /* Window 4: Xcvr/media bits. */
520 Wn4_FIFODiag = 4, Wn4_NetDiag = 6, Wn4_PhysicalMgmt=8, Wn4_Media = 10,
521};
522enum Win4_Media_bits {
523 Media_SQE = 0x0008, /* Enable SQE error counting for AUI. */
524 Media_10TP = 0x00C0, /* Enable link beat and jabber for 10baseT. */
525 Media_Lnk = 0x0080, /* Enable just link beat for 100TX/100FX. */
526 Media_LnkBeat = 0x0800,
527};
528enum Window7 { /* Window 7: Bus Master control. */
529 Wn7_MasterAddr = 0, Wn7_VlanEtherType=4, Wn7_MasterLen = 6,
530 Wn7_MasterStatus = 12,
531};
532/* Boomerang bus master control registers. */
533enum MasterCtrl {
534 PktStatus = 0x20, DownListPtr = 0x24, FragAddr = 0x28, FragLen = 0x2c,
535 TxFreeThreshold = 0x2f, UpPktStatus = 0x30, UpListPtr = 0x38,
536};
537
538/* The Rx and Tx descriptor lists.
539 Caution Alpha hackers: these types are 32 bits! Note also the 8 byte
540 alignment contraint on tx_ring[] and rx_ring[]. */
541#define LAST_FRAG 0x80000000 /* Last Addr/Len pair in descriptor. */
542#define DN_COMPLETE 0x00010000 /* This packet has been downloaded */
543struct boom_rx_desc {
Al Virocc2d6592007-08-22 21:34:46 -0400544 __le32 next; /* Last entry points to 0. */
545 __le32 status;
546 __le32 addr; /* Up to 63 addr/len pairs possible. */
547 __le32 length; /* Set LAST_FRAG to indicate last pair. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700548};
549/* Values for the Rx status entry. */
550enum rx_desc_status {
551 RxDComplete=0x00008000, RxDError=0x4000,
552 /* See boomerang_rx() for actual error bits */
553 IPChksumErr=1<<25, TCPChksumErr=1<<26, UDPChksumErr=1<<27,
554 IPChksumValid=1<<29, TCPChksumValid=1<<30, UDPChksumValid=1<<31,
555};
556
557#ifdef MAX_SKB_FRAGS
558#define DO_ZEROCOPY 1
559#else
560#define DO_ZEROCOPY 0
561#endif
562
563struct boom_tx_desc {
Al Virocc2d6592007-08-22 21:34:46 -0400564 __le32 next; /* Last entry points to 0. */
565 __le32 status; /* bits 0:12 length, others see below. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700566#if DO_ZEROCOPY
567 struct {
Al Virocc2d6592007-08-22 21:34:46 -0400568 __le32 addr;
569 __le32 length;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700570 } frag[1+MAX_SKB_FRAGS];
571#else
Al Virocc2d6592007-08-22 21:34:46 -0400572 __le32 addr;
573 __le32 length;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700574#endif
575};
576
577/* Values for the Tx status entry. */
578enum tx_desc_status {
579 CRCDisable=0x2000, TxDComplete=0x8000,
580 AddIPChksum=0x02000000, AddTCPChksum=0x04000000, AddUDPChksum=0x08000000,
581 TxIntrUploaded=0x80000000, /* IRQ when in FIFO, but maybe not sent. */
582};
583
584/* Chip features we care about in vp->capabilities, read from the EEPROM. */
585enum ChipCaps { CapBusMaster=0x20, CapPwrMgmt=0x2000 };
586
587struct vortex_extra_stats {
Steffen Klassert8d1d0342006-02-03 03:03:57 -0800588 unsigned long tx_deferred;
589 unsigned long tx_max_collisions;
590 unsigned long tx_multiple_collisions;
591 unsigned long tx_single_collisions;
592 unsigned long rx_bad_ssd;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700593};
594
595struct vortex_private {
596 /* The Rx and Tx rings should be quad-word-aligned. */
597 struct boom_rx_desc* rx_ring;
598 struct boom_tx_desc* tx_ring;
599 dma_addr_t rx_ring_dma;
600 dma_addr_t tx_ring_dma;
601 /* The addresses of transmit- and receive-in-place skbuffs. */
602 struct sk_buff* rx_skbuff[RX_RING_SIZE];
603 struct sk_buff* tx_skbuff[TX_RING_SIZE];
604 unsigned int cur_rx, cur_tx; /* The next free ring entry */
605 unsigned int dirty_rx, dirty_tx; /* The ring entries to be free()ed. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700606 struct vortex_extra_stats xstats; /* NIC-specific extra stats */
607 struct sk_buff *tx_skb; /* Packet being eaten by bus master ctrl. */
608 dma_addr_t tx_skb_dma; /* Allocated DMA address for bus master ctrl DMA. */
609
610 /* PCI configuration space information. */
611 struct device *gendev;
John W. Linville62afe592005-11-07 00:58:02 -0800612 void __iomem *ioaddr; /* IO address space */
613 void __iomem *cb_fn_base; /* CardBus function status addr space. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700614
615 /* Some values here only for performance evaluation and path-coverage */
616 int rx_nocopy, rx_copy, queued_packet, rx_csumhits;
617 int card_idx;
618
619 /* The remainder are related to chip state, mostly media selection. */
620 struct timer_list timer; /* Media selection timer. */
621 struct timer_list rx_oom_timer; /* Rx skb allocation retry timer */
622 int options; /* User-settable misc. driver options. */
623 unsigned int media_override:4, /* Passed-in media type. */
624 default_media:4, /* Read from the EEPROM/Wn3_Config. */
Steffen Klassert09ce3512006-03-31 02:30:48 -0800625 full_duplex:1, autoselect:1,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700626 bus_master:1, /* Vortex can only do a fragment bus-m. */
627 full_bus_master_tx:1, full_bus_master_rx:2, /* Boomerang */
628 flow_ctrl:1, /* Use 802.3x flow control (PAUSE only) */
629 partner_flow_ctrl:1, /* Partner supports flow control */
630 has_nway:1,
631 enable_wol:1, /* Wake-on-LAN is enabled */
632 pm_state_valid:1, /* pci_dev->saved_config_space has sane contents */
633 open:1,
634 medialock:1,
635 must_free_region:1, /* Flag: if zero, Cardbus owns the I/O region */
636 large_frames:1; /* accept large frames */
637 int drv_flags;
638 u16 status_enable;
639 u16 intr_enable;
640 u16 available_media; /* From Wn3_Options. */
641 u16 capabilities, info1, info2; /* Various, from EEPROM. */
642 u16 advertising; /* NWay media advertisement */
643 unsigned char phys[2]; /* MII device addresses. */
644 u16 deferred; /* Resend these interrupts when we
645 * bale from the ISR */
646 u16 io_size; /* Size of PCI region (for release_region) */
Ben Hutchingsde847272010-06-29 15:26:56 +0000647
648 /* Serialises access to hardware other than MII and variables below.
649 * The lock hierarchy is rtnl_lock > lock > mii_lock > window_lock. */
650 spinlock_t lock;
651
652 spinlock_t mii_lock; /* Serialises access to MII */
653 struct mii_if_info mii; /* MII lib hooks/info */
654 spinlock_t window_lock; /* Serialises access to windowed regs */
655 int window; /* Register window */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700656};
657
Ben Hutchingsa095cfc2010-06-23 13:54:31 +0000658static void window_set(struct vortex_private *vp, int window)
659{
660 if (window != vp->window) {
661 iowrite16(SelectWindow + window, vp->ioaddr + EL3_CMD);
662 vp->window = window;
663 }
664}
665
666#define DEFINE_WINDOW_IO(size) \
667static u ## size \
668window_read ## size(struct vortex_private *vp, int window, int addr) \
669{ \
Ben Hutchingsde847272010-06-29 15:26:56 +0000670 unsigned long flags; \
671 u ## size ret; \
672 spin_lock_irqsave(&vp->window_lock, flags); \
Ben Hutchingsa095cfc2010-06-23 13:54:31 +0000673 window_set(vp, window); \
Ben Hutchingsde847272010-06-29 15:26:56 +0000674 ret = ioread ## size(vp->ioaddr + addr); \
675 spin_unlock_irqrestore(&vp->window_lock, flags); \
676 return ret; \
Ben Hutchingsa095cfc2010-06-23 13:54:31 +0000677} \
678static void \
679window_write ## size(struct vortex_private *vp, u ## size value, \
680 int window, int addr) \
681{ \
Ben Hutchingsde847272010-06-29 15:26:56 +0000682 unsigned long flags; \
683 spin_lock_irqsave(&vp->window_lock, flags); \
Ben Hutchingsa095cfc2010-06-23 13:54:31 +0000684 window_set(vp, window); \
685 iowrite ## size(value, vp->ioaddr + addr); \
Ben Hutchingsde847272010-06-29 15:26:56 +0000686 spin_unlock_irqrestore(&vp->window_lock, flags); \
Ben Hutchingsa095cfc2010-06-23 13:54:31 +0000687}
688DEFINE_WINDOW_IO(8)
689DEFINE_WINDOW_IO(16)
690DEFINE_WINDOW_IO(32)
691
Linus Torvalds1da177e2005-04-16 15:20:36 -0700692#ifdef CONFIG_PCI
693#define DEVICE_PCI(dev) (((dev)->bus == &pci_bus_type) ? to_pci_dev((dev)) : NULL)
694#else
695#define DEVICE_PCI(dev) NULL
696#endif
697
698#define VORTEX_PCI(vp) (((vp)->gendev) ? DEVICE_PCI((vp)->gendev) : NULL)
699
700#ifdef CONFIG_EISA
701#define DEVICE_EISA(dev) (((dev)->bus == &eisa_bus_type) ? to_eisa_device((dev)) : NULL)
702#else
703#define DEVICE_EISA(dev) NULL
704#endif
705
706#define VORTEX_EISA(vp) (((vp)->gendev) ? DEVICE_EISA((vp)->gendev) : NULL)
707
708/* The action to take with a media selection timer tick.
709 Note that we deviate from the 3Com order by checking 10base2 before AUI.
710 */
711enum xcvr_types {
712 XCVR_10baseT=0, XCVR_AUI, XCVR_10baseTOnly, XCVR_10base2, XCVR_100baseTx,
713 XCVR_100baseFx, XCVR_MII=6, XCVR_NWAY=8, XCVR_ExtMII=9, XCVR_Default=10,
714};
715
Arjan van de Venf71e1302006-03-03 21:33:57 -0500716static const struct media_table {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700717 char *name;
718 unsigned int media_bits:16, /* Bits to set in Wn4_Media register. */
719 mask:8, /* The transceiver-present bit in Wn3_Config.*/
720 next:8; /* The media type to try next. */
721 int wait; /* Time before we check media status. */
722} media_tbl[] = {
723 { "10baseT", Media_10TP,0x08, XCVR_10base2, (14*HZ)/10},
724 { "10Mbs AUI", Media_SQE, 0x20, XCVR_Default, (1*HZ)/10},
725 { "undefined", 0, 0x80, XCVR_10baseT, 10000},
726 { "10base2", 0, 0x10, XCVR_AUI, (1*HZ)/10},
727 { "100baseTX", Media_Lnk, 0x02, XCVR_100baseFx, (14*HZ)/10},
728 { "100baseFX", Media_Lnk, 0x04, XCVR_MII, (14*HZ)/10},
729 { "MII", 0, 0x41, XCVR_10baseT, 3*HZ },
730 { "undefined", 0, 0x01, XCVR_10baseT, 10000},
731 { "Autonegotiate", 0, 0x41, XCVR_10baseT, 3*HZ},
732 { "MII-External", 0, 0x41, XCVR_10baseT, 3*HZ },
733 { "Default", 0, 0xFF, XCVR_10baseT, 10000},
734};
735
736static struct {
737 const char str[ETH_GSTRING_LEN];
738} ethtool_stats_keys[] = {
739 { "tx_deferred" },
Steffen Klassert8d1d0342006-02-03 03:03:57 -0800740 { "tx_max_collisions" },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700741 { "tx_multiple_collisions" },
Steffen Klassert8d1d0342006-02-03 03:03:57 -0800742 { "tx_single_collisions" },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700743 { "rx_bad_ssd" },
744};
745
746/* number of ETHTOOL_GSTATS u64's */
Steffen Klassert8d1d0342006-02-03 03:03:57 -0800747#define VORTEX_NUM_STATS 5
Linus Torvalds1da177e2005-04-16 15:20:36 -0700748
John W. Linville62afe592005-11-07 00:58:02 -0800749static int vortex_probe1(struct device *gendev, void __iomem *ioaddr, int irq,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700750 int chip_idx, int card_idx);
Mark Hindleyc8303d12007-08-16 11:28:40 +0100751static int vortex_up(struct net_device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700752static void vortex_down(struct net_device *dev, int final);
753static int vortex_open(struct net_device *dev);
Ben Hutchingsa095cfc2010-06-23 13:54:31 +0000754static void mdio_sync(struct vortex_private *vp, int bits);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700755static int mdio_read(struct net_device *dev, int phy_id, int location);
756static void mdio_write(struct net_device *vp, int phy_id, int location, int value);
757static void vortex_timer(unsigned long arg);
758static void rx_oom_timer(unsigned long arg);
Stephen Hemminger27a1de92009-08-31 19:50:54 +0000759static netdev_tx_t vortex_start_xmit(struct sk_buff *skb,
760 struct net_device *dev);
761static netdev_tx_t boomerang_start_xmit(struct sk_buff *skb,
762 struct net_device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700763static int vortex_rx(struct net_device *dev);
764static int boomerang_rx(struct net_device *dev);
David Howells7d12e782006-10-05 14:55:46 +0100765static irqreturn_t vortex_interrupt(int irq, void *dev_id);
766static irqreturn_t boomerang_interrupt(int irq, void *dev_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700767static int vortex_close(struct net_device *dev);
768static void dump_tx_ring(struct net_device *dev);
John W. Linville62afe592005-11-07 00:58:02 -0800769static void update_stats(void __iomem *ioaddr, struct net_device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700770static struct net_device_stats *vortex_get_stats(struct net_device *dev);
771static void set_rx_mode(struct net_device *dev);
772#ifdef CONFIG_PCI
773static int vortex_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
774#endif
775static void vortex_tx_timeout(struct net_device *dev);
776static void acpi_set_WOL(struct net_device *dev);
Jeff Garzik7282d492006-09-13 14:30:00 -0400777static const struct ethtool_ops vortex_ethtool_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700778static void set_8021q_mode(struct net_device *dev, int enable);
779
Linus Torvalds1da177e2005-04-16 15:20:36 -0700780/* This driver uses 'options' to pass the media type, full-duplex flag, etc. */
781/* Option count limit only -- unlimited interfaces are supported. */
782#define MAX_UNITS 8
John W. Linville9954ab72005-11-07 00:58:06 -0800783static int options[MAX_UNITS] = { [0 ... MAX_UNITS-1] = -1 };
784static int full_duplex[MAX_UNITS] = {[0 ... MAX_UNITS-1] = -1 };
785static int hw_checksums[MAX_UNITS] = {[0 ... MAX_UNITS-1] = -1 };
786static int flow_ctrl[MAX_UNITS] = {[0 ... MAX_UNITS-1] = -1 };
787static int enable_wol[MAX_UNITS] = {[0 ... MAX_UNITS-1] = -1 };
John W. Linville900fd172005-11-07 00:58:08 -0800788static int use_mmio[MAX_UNITS] = {[0 ... MAX_UNITS-1] = -1 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700789static int global_options = -1;
790static int global_full_duplex = -1;
791static int global_enable_wol = -1;
John W. Linville900fd172005-11-07 00:58:08 -0800792static int global_use_mmio = -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700793
Linus Torvalds1da177e2005-04-16 15:20:36 -0700794/* Variables to work-around the Compaq PCI BIOS32 problem. */
795static int compaq_ioaddr, compaq_irq, compaq_device_id = 0x5900;
796static struct net_device *compaq_net_device;
797
798static int vortex_cards_found;
799
800module_param(debug, int, 0);
801module_param(global_options, int, 0);
802module_param_array(options, int, NULL, 0);
803module_param(global_full_duplex, int, 0);
804module_param_array(full_duplex, int, NULL, 0);
805module_param_array(hw_checksums, int, NULL, 0);
806module_param_array(flow_ctrl, int, NULL, 0);
807module_param(global_enable_wol, int, 0);
808module_param_array(enable_wol, int, NULL, 0);
809module_param(rx_copybreak, int, 0);
810module_param(max_interrupt_work, int, 0);
811module_param(compaq_ioaddr, int, 0);
812module_param(compaq_irq, int, 0);
813module_param(compaq_device_id, int, 0);
814module_param(watchdog, int, 0);
John W. Linville900fd172005-11-07 00:58:08 -0800815module_param(global_use_mmio, int, 0);
816module_param_array(use_mmio, int, NULL, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700817MODULE_PARM_DESC(debug, "3c59x debug level (0-6)");
818MODULE_PARM_DESC(options, "3c59x: Bits 0-3: media type, bit 4: bus mastering, bit 9: full duplex");
819MODULE_PARM_DESC(global_options, "3c59x: same as options, but applies to all NICs if options is unset");
820MODULE_PARM_DESC(full_duplex, "3c59x full duplex setting(s) (1)");
John W. Linville46e5e4a2005-11-07 00:58:06 -0800821MODULE_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 -0700822MODULE_PARM_DESC(hw_checksums, "3c59x Hardware checksum checking by adapter(s) (0-1)");
823MODULE_PARM_DESC(flow_ctrl, "3c59x 802.3x flow control usage (PAUSE only) (0-1)");
824MODULE_PARM_DESC(enable_wol, "3c59x: Turn on Wake-on-LAN for adapter(s) (0-1)");
John W. Linville46e5e4a2005-11-07 00:58:06 -0800825MODULE_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 -0700826MODULE_PARM_DESC(rx_copybreak, "3c59x copy breakpoint for copy-only-tiny-frames");
827MODULE_PARM_DESC(max_interrupt_work, "3c59x maximum events handled per interrupt");
828MODULE_PARM_DESC(compaq_ioaddr, "3c59x PCI I/O base address (Compaq BIOS problem workaround)");
829MODULE_PARM_DESC(compaq_irq, "3c59x PCI IRQ number (Compaq BIOS problem workaround)");
830MODULE_PARM_DESC(compaq_device_id, "3c59x PCI device ID (Compaq BIOS problem workaround)");
831MODULE_PARM_DESC(watchdog, "3c59x transmit timeout in milliseconds");
John W. Linville900fd172005-11-07 00:58:08 -0800832MODULE_PARM_DESC(global_use_mmio, "3c59x: same as use_mmio, but applies to all NICs if options is unset");
833MODULE_PARM_DESC(use_mmio, "3c59x: use memory-mapped PCI I/O resource (0-1)");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700834
835#ifdef CONFIG_NET_POLL_CONTROLLER
836static void poll_vortex(struct net_device *dev)
837{
838 struct vortex_private *vp = netdev_priv(dev);
839 unsigned long flags;
Jiri Kosina0d38ff12007-02-05 16:29:48 -0800840 local_irq_save(flags);
David Howells7d12e782006-10-05 14:55:46 +0100841 (vp->full_bus_master_rx ? boomerang_interrupt:vortex_interrupt)(dev->irq,dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700842 local_irq_restore(flags);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400843}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700844#endif
845
846#ifdef CONFIG_PM
847
Anton Vorontsov7bfc4ab2009-09-30 20:11:11 -0700848static int vortex_suspend(struct device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700849{
Anton Vorontsov7bfc4ab2009-09-30 20:11:11 -0700850 struct pci_dev *pdev = to_pci_dev(dev);
851 struct net_device *ndev = pci_get_drvdata(pdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700852
Anton Vorontsov7bfc4ab2009-09-30 20:11:11 -0700853 if (!ndev || !netif_running(ndev))
854 return 0;
855
856 netif_device_detach(ndev);
857 vortex_down(ndev, 1);
858
Linus Torvalds1da177e2005-04-16 15:20:36 -0700859 return 0;
860}
861
Anton Vorontsov7bfc4ab2009-09-30 20:11:11 -0700862static int vortex_resume(struct device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700863{
Anton Vorontsov7bfc4ab2009-09-30 20:11:11 -0700864 struct pci_dev *pdev = to_pci_dev(dev);
865 struct net_device *ndev = pci_get_drvdata(pdev);
Dmitriy Monakhove1265152007-03-06 02:41:59 -0800866 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700867
Anton Vorontsov7bfc4ab2009-09-30 20:11:11 -0700868 if (!ndev || !netif_running(ndev))
869 return 0;
870
871 err = vortex_up(ndev);
872 if (err)
873 return err;
874
875 netif_device_attach(ndev);
876
Linus Torvalds1da177e2005-04-16 15:20:36 -0700877 return 0;
878}
879
Alexey Dobriyan47145212009-12-14 18:00:08 -0800880static const struct dev_pm_ops vortex_pm_ops = {
Anton Vorontsov7bfc4ab2009-09-30 20:11:11 -0700881 .suspend = vortex_suspend,
882 .resume = vortex_resume,
883 .freeze = vortex_suspend,
884 .thaw = vortex_resume,
885 .poweroff = vortex_suspend,
886 .restore = vortex_resume,
887};
888
889#define VORTEX_PM_OPS (&vortex_pm_ops)
890
891#else /* !CONFIG_PM */
892
893#define VORTEX_PM_OPS NULL
894
895#endif /* !CONFIG_PM */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700896
897#ifdef CONFIG_EISA
898static struct eisa_device_id vortex_eisa_ids[] = {
899 { "TCM5920", CH_3C592 },
900 { "TCM5970", CH_3C597 },
901 { "" }
902};
Michael Tokarev07563c72006-09-27 01:50:56 -0700903MODULE_DEVICE_TABLE(eisa, vortex_eisa_ids);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700904
Ralf Baechle95c408a2007-03-08 15:33:16 +0000905static int __init vortex_eisa_probe(struct device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700906{
John W. Linville62afe592005-11-07 00:58:02 -0800907 void __iomem *ioaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700908 struct eisa_device *edev;
909
Steffen Klasserta880c4c2006-03-26 01:37:43 -0800910 edev = to_eisa_device(device);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700911
John W. Linville62afe592005-11-07 00:58:02 -0800912 if (!request_region(edev->base_addr, VORTEX_TOTAL_SIZE, DRV_NAME))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700913 return -EBUSY;
914
John W. Linville62afe592005-11-07 00:58:02 -0800915 ioaddr = ioport_map(edev->base_addr, VORTEX_TOTAL_SIZE);
916
917 if (vortex_probe1(device, ioaddr, ioread16(ioaddr + 0xC88) >> 12,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700918 edev->id.driver_data, vortex_cards_found)) {
Steffen Klasserta880c4c2006-03-26 01:37:43 -0800919 release_region(edev->base_addr, VORTEX_TOTAL_SIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700920 return -ENODEV;
921 }
922
923 vortex_cards_found++;
924
925 return 0;
926}
927
Ralf Baechle95c408a2007-03-08 15:33:16 +0000928static int __devexit vortex_eisa_remove(struct device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700929{
930 struct eisa_device *edev;
931 struct net_device *dev;
932 struct vortex_private *vp;
John W. Linville62afe592005-11-07 00:58:02 -0800933 void __iomem *ioaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700934
Steffen Klasserta880c4c2006-03-26 01:37:43 -0800935 edev = to_eisa_device(device);
936 dev = eisa_get_drvdata(edev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700937
938 if (!dev) {
Alexander Beregalov39738e12009-05-26 12:35:26 +0000939 pr_err("vortex_eisa_remove called for Compaq device!\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700940 BUG();
941 }
942
943 vp = netdev_priv(dev);
John W. Linville62afe592005-11-07 00:58:02 -0800944 ioaddr = vp->ioaddr;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400945
Steffen Klasserta880c4c2006-03-26 01:37:43 -0800946 unregister_netdev(dev);
947 iowrite16(TotalReset|0x14, ioaddr + EL3_CMD);
948 release_region(dev->base_addr, VORTEX_TOTAL_SIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700949
Steffen Klasserta880c4c2006-03-26 01:37:43 -0800950 free_netdev(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700951 return 0;
952}
Ralf Baechle95c408a2007-03-08 15:33:16 +0000953
954static struct eisa_driver vortex_eisa_driver = {
955 .id_table = vortex_eisa_ids,
956 .driver = {
957 .name = "3c59x",
958 .probe = vortex_eisa_probe,
959 .remove = __devexit_p(vortex_eisa_remove)
960 }
961};
962
963#endif /* CONFIG_EISA */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700964
965/* returns count found (>= 0), or negative on error */
Steffen Klasserta880c4c2006-03-26 01:37:43 -0800966static int __init vortex_eisa_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700967{
968 int eisa_found = 0;
969 int orig_cards_found = vortex_cards_found;
970
971#ifdef CONFIG_EISA
Bjorn Helgaasc2f6fab2006-03-25 03:07:19 -0800972 int err;
973
974 err = eisa_driver_register (&vortex_eisa_driver);
975 if (!err) {
976 /*
977 * Because of the way EISA bus is probed, we cannot assume
978 * any device have been found when we exit from
979 * eisa_driver_register (the bus root driver may not be
980 * initialized yet). So we blindly assume something was
981 * found, and let the sysfs magic happend...
982 */
983 eisa_found = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700984 }
985#endif
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400986
Linus Torvalds1da177e2005-04-16 15:20:36 -0700987 /* Special code to work-around the Compaq PCI BIOS32 problem. */
988 if (compaq_ioaddr) {
John W. Linville62afe592005-11-07 00:58:02 -0800989 vortex_probe1(NULL, ioport_map(compaq_ioaddr, VORTEX_TOTAL_SIZE),
990 compaq_irq, compaq_device_id, vortex_cards_found++);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700991 }
992
993 return vortex_cards_found - orig_cards_found + eisa_found;
994}
995
996/* returns count (>= 0), or negative on error */
Steffen Klasserta880c4c2006-03-26 01:37:43 -0800997static int __devinit vortex_init_one(struct pci_dev *pdev,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700998 const struct pci_device_id *ent)
999{
John W. Linville900fd172005-11-07 00:58:08 -08001000 int rc, unit, pci_bar;
1001 struct vortex_chip_info *vci;
1002 void __iomem *ioaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001003
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001004 /* wake up and enable device */
Steffen Klasserta880c4c2006-03-26 01:37:43 -08001005 rc = pci_enable_device(pdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001006 if (rc < 0)
1007 goto out;
1008
John W. Linville900fd172005-11-07 00:58:08 -08001009 unit = vortex_cards_found;
1010
1011 if (global_use_mmio < 0 && (unit >= MAX_UNITS || use_mmio[unit] < 0)) {
1012 /* Determine the default if the user didn't override us */
1013 vci = &vortex_info_tbl[ent->driver_data];
1014 pci_bar = vci->drv_flags & (IS_CYCLONE | IS_TORNADO) ? 1 : 0;
1015 } else if (unit < MAX_UNITS && use_mmio[unit] >= 0)
1016 pci_bar = use_mmio[unit] ? 1 : 0;
1017 else
1018 pci_bar = global_use_mmio ? 1 : 0;
1019
1020 ioaddr = pci_iomap(pdev, pci_bar, 0);
1021 if (!ioaddr) /* If mapping fails, fall-back to BAR 0... */
1022 ioaddr = pci_iomap(pdev, 0, 0);
Kulikov Vasiliy8cd47ea2010-07-21 02:00:36 +00001023 if (!ioaddr) {
1024 pci_disable_device(pdev);
1025 rc = -ENOMEM;
1026 goto out;
1027 }
John W. Linville900fd172005-11-07 00:58:08 -08001028
1029 rc = vortex_probe1(&pdev->dev, ioaddr, pdev->irq,
1030 ent->driver_data, unit);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001031 if (rc < 0) {
Kulikov Vasiliyf89f5d02010-07-23 06:44:44 +00001032 pci_iounmap(pdev, ioaddr);
Steffen Klasserta880c4c2006-03-26 01:37:43 -08001033 pci_disable_device(pdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001034 goto out;
1035 }
1036
1037 vortex_cards_found++;
1038
1039out:
1040 return rc;
1041}
1042
Stephen Hemminger48b47a52009-01-09 13:01:18 +00001043static const struct net_device_ops boomrang_netdev_ops = {
1044 .ndo_open = vortex_open,
1045 .ndo_stop = vortex_close,
1046 .ndo_start_xmit = boomerang_start_xmit,
1047 .ndo_tx_timeout = vortex_tx_timeout,
1048 .ndo_get_stats = vortex_get_stats,
1049#ifdef CONFIG_PCI
1050 .ndo_do_ioctl = vortex_ioctl,
1051#endif
1052 .ndo_set_multicast_list = set_rx_mode,
1053 .ndo_change_mtu = eth_change_mtu,
1054 .ndo_set_mac_address = eth_mac_addr,
1055 .ndo_validate_addr = eth_validate_addr,
1056#ifdef CONFIG_NET_POLL_CONTROLLER
1057 .ndo_poll_controller = poll_vortex,
1058#endif
1059};
1060
1061static const struct net_device_ops vortex_netdev_ops = {
1062 .ndo_open = vortex_open,
1063 .ndo_stop = vortex_close,
1064 .ndo_start_xmit = vortex_start_xmit,
1065 .ndo_tx_timeout = vortex_tx_timeout,
1066 .ndo_get_stats = vortex_get_stats,
1067#ifdef CONFIG_PCI
1068 .ndo_do_ioctl = vortex_ioctl,
1069#endif
1070 .ndo_set_multicast_list = set_rx_mode,
1071 .ndo_change_mtu = eth_change_mtu,
1072 .ndo_set_mac_address = eth_mac_addr,
1073 .ndo_validate_addr = eth_validate_addr,
1074#ifdef CONFIG_NET_POLL_CONTROLLER
1075 .ndo_poll_controller = poll_vortex,
1076#endif
1077};
1078
Linus Torvalds1da177e2005-04-16 15:20:36 -07001079/*
1080 * Start up the PCI/EISA device which is described by *gendev.
1081 * Return 0 on success.
1082 *
1083 * NOTE: pdev can be NULL, for the case of a Compaq device
1084 */
1085static int __devinit vortex_probe1(struct device *gendev,
John W. Linville62afe592005-11-07 00:58:02 -08001086 void __iomem *ioaddr, int irq,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001087 int chip_idx, int card_idx)
1088{
1089 struct vortex_private *vp;
1090 int option;
1091 unsigned int eeprom[0x40], checksum = 0; /* EEPROM contents */
1092 int i, step;
1093 struct net_device *dev;
1094 static int printed_version;
1095 int retval, print_info;
1096 struct vortex_chip_info * const vci = &vortex_info_tbl[chip_idx];
Greg Kroah-Hartman361d5ee2008-07-02 12:46:22 -07001097 const char *print_name = "3c59x";
Linus Torvalds1da177e2005-04-16 15:20:36 -07001098 struct pci_dev *pdev = NULL;
1099 struct eisa_device *edev = NULL;
1100
1101 if (!printed_version) {
Alexander Beregalov39738e12009-05-26 12:35:26 +00001102 pr_info("%s", version);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001103 printed_version = 1;
1104 }
1105
1106 if (gendev) {
1107 if ((pdev = DEVICE_PCI(gendev))) {
1108 print_name = pci_name(pdev);
1109 }
1110
1111 if ((edev = DEVICE_EISA(gendev))) {
Kay Sieversfb28ad32008-11-10 13:55:14 -08001112 print_name = dev_name(&edev->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001113 }
1114 }
1115
1116 dev = alloc_etherdev(sizeof(*vp));
1117 retval = -ENOMEM;
1118 if (!dev) {
Alexander Beregalov39738e12009-05-26 12:35:26 +00001119 pr_err(PFX "unable to allocate etherdev, aborting\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001120 goto out;
1121 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001122 SET_NETDEV_DEV(dev, gendev);
1123 vp = netdev_priv(dev);
1124
1125 option = global_options;
1126
1127 /* The lower four bits are the media type. */
1128 if (dev->mem_start) {
1129 /*
1130 * The 'options' param is passed in as the third arg to the
1131 * LILO 'ether=' argument for non-modular use
1132 */
1133 option = dev->mem_start;
1134 }
1135 else if (card_idx < MAX_UNITS) {
1136 if (options[card_idx] >= 0)
1137 option = options[card_idx];
1138 }
1139
1140 if (option > 0) {
1141 if (option & 0x8000)
1142 vortex_debug = 7;
1143 if (option & 0x4000)
1144 vortex_debug = 2;
1145 if (option & 0x0400)
1146 vp->enable_wol = 1;
1147 }
1148
1149 print_info = (vortex_debug > 1);
1150 if (print_info)
Alexander Beregalov39738e12009-05-26 12:35:26 +00001151 pr_info("See Documentation/networking/vortex.txt\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001152
Alexander Beregalov39738e12009-05-26 12:35:26 +00001153 pr_info("%s: 3Com %s %s at %p.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001154 print_name,
1155 pdev ? "PCI" : "EISA",
1156 vci->name,
1157 ioaddr);
1158
John W. Linville62afe592005-11-07 00:58:02 -08001159 dev->base_addr = (unsigned long)ioaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001160 dev->irq = irq;
1161 dev->mtu = mtu;
John W. Linville62afe592005-11-07 00:58:02 -08001162 vp->ioaddr = ioaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001163 vp->large_frames = mtu > 1500;
1164 vp->drv_flags = vci->drv_flags;
1165 vp->has_nway = (vci->drv_flags & HAS_NWAY) ? 1 : 0;
1166 vp->io_size = vci->io_size;
1167 vp->card_idx = card_idx;
Ben Hutchingsa095cfc2010-06-23 13:54:31 +00001168 vp->window = -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001169
1170 /* module list only for Compaq device */
1171 if (gendev == NULL) {
1172 compaq_net_device = dev;
1173 }
1174
1175 /* PCI-only startup logic */
1176 if (pdev) {
1177 /* EISA resources already marked, so only PCI needs to do this here */
1178 /* Ignore return value, because Cardbus drivers already allocate for us */
John W. Linville62afe592005-11-07 00:58:02 -08001179 if (request_region(dev->base_addr, vci->io_size, print_name) != NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001180 vp->must_free_region = 1;
1181
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001182 /* enable bus-mastering if necessary */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001183 if (vci->flags & PCI_USES_MASTER)
Steffen Klasserta880c4c2006-03-26 01:37:43 -08001184 pci_set_master(pdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001185
1186 if (vci->drv_flags & IS_VORTEX) {
1187 u8 pci_latency;
1188 u8 new_latency = 248;
1189
1190 /* Check the PCI latency value. On the 3c590 series the latency timer
1191 must be set to the maximum value to avoid data corruption that occurs
1192 when the timer expires during a transfer. This bug exists the Vortex
1193 chip only. */
1194 pci_read_config_byte(pdev, PCI_LATENCY_TIMER, &pci_latency);
1195 if (pci_latency < new_latency) {
Alexander Beregalov39738e12009-05-26 12:35:26 +00001196 pr_info("%s: Overriding PCI latency timer (CFLT) setting of %d, new value is %d.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001197 print_name, pci_latency, new_latency);
Alexander Beregalov39738e12009-05-26 12:35:26 +00001198 pci_write_config_byte(pdev, PCI_LATENCY_TIMER, new_latency);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001199 }
1200 }
1201 }
1202
1203 spin_lock_init(&vp->lock);
Ben Hutchingsde847272010-06-29 15:26:56 +00001204 spin_lock_init(&vp->mii_lock);
1205 spin_lock_init(&vp->window_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001206 vp->gendev = gendev;
1207 vp->mii.dev = dev;
1208 vp->mii.mdio_read = mdio_read;
1209 vp->mii.mdio_write = mdio_write;
1210 vp->mii.phy_id_mask = 0x1f;
1211 vp->mii.reg_num_mask = 0x1f;
1212
1213 /* Makes sure rings are at least 16 byte aligned. */
1214 vp->rx_ring = pci_alloc_consistent(pdev, sizeof(struct boom_rx_desc) * RX_RING_SIZE
1215 + sizeof(struct boom_tx_desc) * TX_RING_SIZE,
1216 &vp->rx_ring_dma);
1217 retval = -ENOMEM;
Al Virocc2d6592007-08-22 21:34:46 -04001218 if (!vp->rx_ring)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001219 goto free_region;
1220
1221 vp->tx_ring = (struct boom_tx_desc *)(vp->rx_ring + RX_RING_SIZE);
1222 vp->tx_ring_dma = vp->rx_ring_dma + sizeof(struct boom_rx_desc) * RX_RING_SIZE;
1223
1224 /* if we are a PCI driver, we store info in pdev->driver_data
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001225 * instead of a module list */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001226 if (pdev)
1227 pci_set_drvdata(pdev, dev);
1228 if (edev)
Steffen Klasserta880c4c2006-03-26 01:37:43 -08001229 eisa_set_drvdata(edev, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001230
1231 vp->media_override = 7;
1232 if (option >= 0) {
1233 vp->media_override = ((option & 7) == 2) ? 0 : option & 15;
1234 if (vp->media_override != 7)
1235 vp->medialock = 1;
1236 vp->full_duplex = (option & 0x200) ? 1 : 0;
1237 vp->bus_master = (option & 16) ? 1 : 0;
1238 }
1239
1240 if (global_full_duplex > 0)
1241 vp->full_duplex = 1;
1242 if (global_enable_wol > 0)
1243 vp->enable_wol = 1;
1244
1245 if (card_idx < MAX_UNITS) {
1246 if (full_duplex[card_idx] > 0)
1247 vp->full_duplex = 1;
1248 if (flow_ctrl[card_idx] > 0)
1249 vp->flow_ctrl = 1;
1250 if (enable_wol[card_idx] > 0)
1251 vp->enable_wol = 1;
1252 }
1253
Steffen Klassert125d5ce2006-03-26 01:37:39 -08001254 vp->mii.force_media = vp->full_duplex;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001255 vp->options = option;
1256 /* Read the station address from the EEPROM. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001257 {
1258 int base;
1259
1260 if (vci->drv_flags & EEPROM_8BIT)
1261 base = 0x230;
1262 else if (vci->drv_flags & EEPROM_OFFSET)
1263 base = EEPROM_Read + 0x30;
1264 else
1265 base = EEPROM_Read;
1266
1267 for (i = 0; i < 0x40; i++) {
1268 int timer;
Ben Hutchingsa095cfc2010-06-23 13:54:31 +00001269 window_write16(vp, base + i, 0, Wn0EepromCmd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001270 /* Pause for at least 162 us. for the read to take place. */
1271 for (timer = 10; timer >= 0; timer--) {
1272 udelay(162);
Ben Hutchingsa095cfc2010-06-23 13:54:31 +00001273 if ((window_read16(vp, 0, Wn0EepromCmd) &
1274 0x8000) == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001275 break;
1276 }
Ben Hutchingsa095cfc2010-06-23 13:54:31 +00001277 eeprom[i] = window_read16(vp, 0, Wn0EepromData);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001278 }
1279 }
1280 for (i = 0; i < 0x18; i++)
1281 checksum ^= eeprom[i];
1282 checksum = (checksum ^ (checksum >> 8)) & 0xff;
1283 if (checksum != 0x00) { /* Grrr, needless incompatible change 3Com. */
1284 while (i < 0x21)
1285 checksum ^= eeprom[i++];
1286 checksum = (checksum ^ (checksum >> 8)) & 0xff;
1287 }
1288 if ((checksum != 0x00) && !(vci->drv_flags & IS_TORNADO))
Alexander Beregalov39738e12009-05-26 12:35:26 +00001289 pr_cont(" ***INVALID CHECKSUM %4.4x*** ", checksum);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001290 for (i = 0; i < 3; i++)
Al Virocc2d6592007-08-22 21:34:46 -04001291 ((__be16 *)dev->dev_addr)[i] = htons(eeprom[i + 10]);
John W. Linvillebb531fc2005-11-07 00:58:07 -08001292 memcpy(dev->perm_addr, dev->dev_addr, dev->addr_len);
Joe Perches0795af52007-10-03 17:59:30 -07001293 if (print_info)
Alexander Beregalov39738e12009-05-26 12:35:26 +00001294 pr_cont(" %pM", dev->dev_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001295 /* Unfortunately an all zero eeprom passes the checksum and this
1296 gets found in the wild in failure cases. Crypto is hard 8) */
1297 if (!is_valid_ether_addr(dev->dev_addr)) {
1298 retval = -EINVAL;
Alexander Beregalov39738e12009-05-26 12:35:26 +00001299 pr_err("*** EEPROM MAC address is invalid.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001300 goto free_ring; /* With every pack */
1301 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001302 for (i = 0; i < 6; i++)
Ben Hutchingsa095cfc2010-06-23 13:54:31 +00001303 window_write8(vp, dev->dev_addr[i], 2, i);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001304
Linus Torvalds1da177e2005-04-16 15:20:36 -07001305 if (print_info)
Alexander Beregalov39738e12009-05-26 12:35:26 +00001306 pr_cont(", IRQ %d\n", dev->irq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001307 /* Tell them about an invalid IRQ. */
Yinghai Lu60e4ad72008-08-19 20:49:50 -07001308 if (dev->irq <= 0 || dev->irq >= nr_irqs)
Alexander Beregalov39738e12009-05-26 12:35:26 +00001309 pr_warning(" *** Warning: IRQ %d is unlikely to work! ***\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001310 dev->irq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001311
Ben Hutchingsa095cfc2010-06-23 13:54:31 +00001312 step = (window_read8(vp, 4, Wn4_NetDiag) & 0x1e) >> 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001313 if (print_info) {
Alexander Beregalov39738e12009-05-26 12:35:26 +00001314 pr_info(" product code %02x%02x rev %02x.%d date %02d-%02d-%02d\n",
1315 eeprom[6]&0xff, eeprom[6]>>8, eeprom[0x14],
Linus Torvalds1da177e2005-04-16 15:20:36 -07001316 step, (eeprom[4]>>5) & 15, eeprom[4] & 31, eeprom[4]>>9);
1317 }
1318
1319
1320 if (pdev && vci->drv_flags & HAS_CB_FNS) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001321 unsigned short n;
1322
John W. Linville62afe592005-11-07 00:58:02 -08001323 vp->cb_fn_base = pci_iomap(pdev, 2, 0);
1324 if (!vp->cb_fn_base) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001325 retval = -ENOMEM;
John W. Linville62afe592005-11-07 00:58:02 -08001326 goto free_ring;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001327 }
John W. Linville62afe592005-11-07 00:58:02 -08001328
Linus Torvalds1da177e2005-04-16 15:20:36 -07001329 if (print_info) {
Alexander Beregalov39738e12009-05-26 12:35:26 +00001330 pr_info("%s: CardBus functions mapped %16.16llx->%p\n",
Greg Kroah-Hartman7c7459d2006-06-12 15:13:08 -07001331 print_name,
1332 (unsigned long long)pci_resource_start(pdev, 2),
John W. Linville62afe592005-11-07 00:58:02 -08001333 vp->cb_fn_base);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001334 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001335
Ben Hutchingsa095cfc2010-06-23 13:54:31 +00001336 n = window_read16(vp, 2, Wn2_ResetOptions) & ~0x4010;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001337 if (vp->drv_flags & INVERT_LED_PWR)
1338 n |= 0x10;
1339 if (vp->drv_flags & INVERT_MII_PWR)
1340 n |= 0x4000;
Ben Hutchingsa095cfc2010-06-23 13:54:31 +00001341 window_write16(vp, n, 2, Wn2_ResetOptions);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001342 if (vp->drv_flags & WNO_XCVR_PWR) {
Ben Hutchingsa095cfc2010-06-23 13:54:31 +00001343 window_write16(vp, 0x0800, 0, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001344 }
1345 }
1346
1347 /* Extract our information from the EEPROM data. */
1348 vp->info1 = eeprom[13];
1349 vp->info2 = eeprom[15];
1350 vp->capabilities = eeprom[16];
1351
1352 if (vp->info1 & 0x8000) {
1353 vp->full_duplex = 1;
1354 if (print_info)
Alexander Beregalov39738e12009-05-26 12:35:26 +00001355 pr_info("Full duplex capable\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001356 }
1357
1358 {
Arjan van de Venf71e1302006-03-03 21:33:57 -05001359 static const char * const ram_split[] = {"5:3", "3:1", "1:1", "3:5"};
Linus Torvalds1da177e2005-04-16 15:20:36 -07001360 unsigned int config;
Ben Hutchingsa095cfc2010-06-23 13:54:31 +00001361 vp->available_media = window_read16(vp, 3, Wn3_Options);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001362 if ((vp->available_media & 0xff) == 0) /* Broken 3c916 */
1363 vp->available_media = 0x40;
Ben Hutchingsa095cfc2010-06-23 13:54:31 +00001364 config = window_read32(vp, 3, Wn3_Config);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001365 if (print_info) {
Alexander Beregalov39738e12009-05-26 12:35:26 +00001366 pr_debug(" Internal config register is %4.4x, transceivers %#x.\n",
Ben Hutchingsa095cfc2010-06-23 13:54:31 +00001367 config, window_read16(vp, 3, Wn3_Options));
Alexander Beregalov39738e12009-05-26 12:35:26 +00001368 pr_info(" %dK %s-wide RAM %s Rx:Tx split, %s%s interface.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001369 8 << RAM_SIZE(config),
1370 RAM_WIDTH(config) ? "word" : "byte",
1371 ram_split[RAM_SPLIT(config)],
1372 AUTOSELECT(config) ? "autoselect/" : "",
1373 XCVR(config) > XCVR_ExtMII ? "<invalid transceiver>" :
1374 media_tbl[XCVR(config)].name);
1375 }
1376 vp->default_media = XCVR(config);
1377 if (vp->default_media == XCVR_NWAY)
1378 vp->has_nway = 1;
1379 vp->autoselect = AUTOSELECT(config);
1380 }
1381
1382 if (vp->media_override != 7) {
Alexander Beregalov39738e12009-05-26 12:35:26 +00001383 pr_info("%s: Media override to transceiver type %d (%s).\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001384 print_name, vp->media_override,
1385 media_tbl[vp->media_override].name);
1386 dev->if_port = vp->media_override;
1387 } else
1388 dev->if_port = vp->default_media;
1389
1390 if ((vp->available_media & 0x40) || (vci->drv_flags & HAS_NWAY) ||
1391 dev->if_port == XCVR_MII || dev->if_port == XCVR_NWAY) {
1392 int phy, phy_idx = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001393 mii_preamble_required++;
1394 if (vp->drv_flags & EXTRA_PREAMBLE)
1395 mii_preamble_required++;
1396 mdio_sync(ioaddr, 32);
Neil Horman106427e2005-11-07 00:58:03 -08001397 mdio_read(dev, 24, MII_BMSR);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001398 for (phy = 0; phy < 32 && phy_idx < 1; phy++) {
1399 int mii_status, phyx;
1400
1401 /*
1402 * For the 3c905CX we look at index 24 first, because it bogusly
1403 * reports an external PHY at all indices
1404 */
1405 if (phy == 0)
1406 phyx = 24;
1407 else if (phy <= 24)
1408 phyx = phy - 1;
1409 else
1410 phyx = phy;
Neil Horman106427e2005-11-07 00:58:03 -08001411 mii_status = mdio_read(dev, phyx, MII_BMSR);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001412 if (mii_status && mii_status != 0xffff) {
1413 vp->phys[phy_idx++] = phyx;
1414 if (print_info) {
Alexander Beregalov39738e12009-05-26 12:35:26 +00001415 pr_info(" MII transceiver found at address %d, status %4x.\n",
1416 phyx, mii_status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001417 }
1418 if ((mii_status & 0x0040) == 0)
1419 mii_preamble_required++;
1420 }
1421 }
1422 mii_preamble_required--;
1423 if (phy_idx == 0) {
Alexander Beregalov39738e12009-05-26 12:35:26 +00001424 pr_warning(" ***WARNING*** No MII transceivers found!\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001425 vp->phys[0] = 24;
1426 } else {
Neil Horman106427e2005-11-07 00:58:03 -08001427 vp->advertising = mdio_read(dev, vp->phys[0], MII_ADVERTISE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001428 if (vp->full_duplex) {
1429 /* Only advertise the FD media types. */
1430 vp->advertising &= ~0x02A0;
1431 mdio_write(dev, vp->phys[0], 4, vp->advertising);
1432 }
1433 }
1434 vp->mii.phy_id = vp->phys[0];
1435 }
1436
1437 if (vp->capabilities & CapBusMaster) {
1438 vp->full_bus_master_tx = 1;
1439 if (print_info) {
Alexander Beregalov39738e12009-05-26 12:35:26 +00001440 pr_info(" Enabling bus-master transmits and %s receives.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001441 (vp->info2 & 1) ? "early" : "whole-frame" );
1442 }
1443 vp->full_bus_master_rx = (vp->info2 & 1) ? 1 : 2;
1444 vp->bus_master = 0; /* AKPM: vortex only */
1445 }
1446
1447 /* The 3c59x-specific entries in the device structure. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001448 if (vp->full_bus_master_tx) {
Stephen Hemminger48b47a52009-01-09 13:01:18 +00001449 dev->netdev_ops = &boomrang_netdev_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001450 /* Actually, it still should work with iommu. */
John W. Linville32fb5f02005-11-07 00:58:05 -08001451 if (card_idx < MAX_UNITS &&
1452 ((hw_checksums[card_idx] == -1 && (vp->drv_flags & HAS_HWCKSM)) ||
1453 hw_checksums[card_idx] == 1)) {
Stephen Hemmingerd311b0d2005-11-07 00:58:09 -08001454 dev->features |= NETIF_F_IP_CSUM | NETIF_F_SG;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001455 }
Stephen Hemminger48b47a52009-01-09 13:01:18 +00001456 } else
1457 dev->netdev_ops = &vortex_netdev_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001458
1459 if (print_info) {
Alexander Beregalov39738e12009-05-26 12:35:26 +00001460 pr_info("%s: scatter/gather %sabled. h/w checksums %sabled\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001461 print_name,
1462 (dev->features & NETIF_F_SG) ? "en":"dis",
1463 (dev->features & NETIF_F_IP_CSUM) ? "en":"dis");
1464 }
1465
Linus Torvalds1da177e2005-04-16 15:20:36 -07001466 dev->ethtool_ops = &vortex_ethtool_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001467 dev->watchdog_timeo = (watchdog * HZ) / 1000;
Stephen Hemminger48b47a52009-01-09 13:01:18 +00001468
Linus Torvalds1da177e2005-04-16 15:20:36 -07001469 if (pdev) {
1470 vp->pm_state_valid = 1;
1471 pci_save_state(VORTEX_PCI(vp));
1472 acpi_set_WOL(dev);
1473 }
1474 retval = register_netdev(dev);
1475 if (retval == 0)
1476 return 0;
1477
1478free_ring:
1479 pci_free_consistent(pdev,
1480 sizeof(struct boom_rx_desc) * RX_RING_SIZE
1481 + sizeof(struct boom_tx_desc) * TX_RING_SIZE,
1482 vp->rx_ring,
1483 vp->rx_ring_dma);
1484free_region:
1485 if (vp->must_free_region)
John W. Linville62afe592005-11-07 00:58:02 -08001486 release_region(dev->base_addr, vci->io_size);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001487 free_netdev(dev);
Alexander Beregalov39738e12009-05-26 12:35:26 +00001488 pr_err(PFX "vortex_probe1 fails. Returns %d\n", retval);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001489out:
1490 return retval;
1491}
1492
1493static void
1494issue_and_wait(struct net_device *dev, int cmd)
1495{
John W. Linville62afe592005-11-07 00:58:02 -08001496 struct vortex_private *vp = netdev_priv(dev);
1497 void __iomem *ioaddr = vp->ioaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001498 int i;
1499
John W. Linville62afe592005-11-07 00:58:02 -08001500 iowrite16(cmd, ioaddr + EL3_CMD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001501 for (i = 0; i < 2000; i++) {
John W. Linville62afe592005-11-07 00:58:02 -08001502 if (!(ioread16(ioaddr + EL3_STATUS) & CmdInProgress))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001503 return;
1504 }
1505
1506 /* OK, that didn't work. Do it the slow way. One second */
1507 for (i = 0; i < 100000; i++) {
John W. Linville62afe592005-11-07 00:58:02 -08001508 if (!(ioread16(ioaddr + EL3_STATUS) & CmdInProgress)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001509 if (vortex_debug > 1)
Alexander Beregalov39738e12009-05-26 12:35:26 +00001510 pr_info("%s: command 0x%04x took %d usecs\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001511 dev->name, cmd, i * 10);
1512 return;
1513 }
1514 udelay(10);
1515 }
Alexander Beregalov39738e12009-05-26 12:35:26 +00001516 pr_err("%s: command 0x%04x did not complete! Status=0x%x\n",
John W. Linville62afe592005-11-07 00:58:02 -08001517 dev->name, cmd, ioread16(ioaddr + EL3_STATUS));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001518}
1519
1520static void
Steffen Klassert125d5ce2006-03-26 01:37:39 -08001521vortex_set_duplex(struct net_device *dev)
1522{
1523 struct vortex_private *vp = netdev_priv(dev);
Steffen Klassert125d5ce2006-03-26 01:37:39 -08001524
Alexander Beregalov39738e12009-05-26 12:35:26 +00001525 pr_info("%s: setting %s-duplex.\n",
Steffen Klassert125d5ce2006-03-26 01:37:39 -08001526 dev->name, (vp->full_duplex) ? "full" : "half");
1527
Steffen Klassert125d5ce2006-03-26 01:37:39 -08001528 /* Set the full-duplex bit. */
Ben Hutchingsa095cfc2010-06-23 13:54:31 +00001529 window_write16(vp,
1530 ((vp->info1 & 0x8000) || vp->full_duplex ? 0x20 : 0) |
1531 (vp->large_frames ? 0x40 : 0) |
1532 ((vp->full_duplex && vp->flow_ctrl && vp->partner_flow_ctrl) ?
1533 0x100 : 0),
1534 3, Wn3_MAC_Ctrl);
Steffen Klassert125d5ce2006-03-26 01:37:39 -08001535}
1536
1537static void vortex_check_media(struct net_device *dev, unsigned int init)
1538{
1539 struct vortex_private *vp = netdev_priv(dev);
1540 unsigned int ok_to_print = 0;
1541
1542 if (vortex_debug > 3)
1543 ok_to_print = 1;
1544
1545 if (mii_check_media(&vp->mii, ok_to_print, init)) {
1546 vp->full_duplex = vp->mii.full_duplex;
1547 vortex_set_duplex(dev);
1548 } else if (init) {
1549 vortex_set_duplex(dev);
1550 }
1551}
1552
Mark Hindleyc8303d12007-08-16 11:28:40 +01001553static int
Linus Torvalds1da177e2005-04-16 15:20:36 -07001554vortex_up(struct net_device *dev)
1555{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001556 struct vortex_private *vp = netdev_priv(dev);
John W. Linville62afe592005-11-07 00:58:02 -08001557 void __iomem *ioaddr = vp->ioaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001558 unsigned int config;
Badari Pulavarty0280f9f2007-10-17 16:15:56 -07001559 int i, mii_reg1, mii_reg5, err = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001560
1561 if (VORTEX_PCI(vp)) {
1562 pci_set_power_state(VORTEX_PCI(vp), PCI_D0); /* Go active */
Daniel Ritz3c8fad12005-05-05 16:15:44 -07001563 if (vp->pm_state_valid)
1564 pci_restore_state(VORTEX_PCI(vp));
Mark Hindleyc8303d12007-08-16 11:28:40 +01001565 err = pci_enable_device(VORTEX_PCI(vp));
1566 if (err) {
Alexander Beregalov39738e12009-05-26 12:35:26 +00001567 pr_warning("%s: Could not enable device\n",
Mark Hindleyc8303d12007-08-16 11:28:40 +01001568 dev->name);
1569 goto err_out;
1570 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001571 }
1572
1573 /* Before initializing select the active media port. */
Ben Hutchingsa095cfc2010-06-23 13:54:31 +00001574 config = window_read32(vp, 3, Wn3_Config);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001575
1576 if (vp->media_override != 7) {
Alexander Beregalov39738e12009-05-26 12:35:26 +00001577 pr_info("%s: Media override to transceiver %d (%s).\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001578 dev->name, vp->media_override,
1579 media_tbl[vp->media_override].name);
1580 dev->if_port = vp->media_override;
1581 } else if (vp->autoselect) {
1582 if (vp->has_nway) {
1583 if (vortex_debug > 1)
Alexander Beregalov39738e12009-05-26 12:35:26 +00001584 pr_info("%s: using NWAY device table, not %d\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001585 dev->name, dev->if_port);
1586 dev->if_port = XCVR_NWAY;
1587 } else {
1588 /* Find first available media type, starting with 100baseTx. */
1589 dev->if_port = XCVR_100baseTx;
1590 while (! (vp->available_media & media_tbl[dev->if_port].mask))
1591 dev->if_port = media_tbl[dev->if_port].next;
1592 if (vortex_debug > 1)
Alexander Beregalov39738e12009-05-26 12:35:26 +00001593 pr_info("%s: first available media type: %s\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001594 dev->name, media_tbl[dev->if_port].name);
1595 }
1596 } else {
1597 dev->if_port = vp->default_media;
1598 if (vortex_debug > 1)
Alexander Beregalov39738e12009-05-26 12:35:26 +00001599 pr_info("%s: using default media %s\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001600 dev->name, media_tbl[dev->if_port].name);
1601 }
1602
1603 init_timer(&vp->timer);
1604 vp->timer.expires = RUN_AT(media_tbl[dev->if_port].wait);
1605 vp->timer.data = (unsigned long)dev;
1606 vp->timer.function = vortex_timer; /* timer handler */
1607 add_timer(&vp->timer);
1608
1609 init_timer(&vp->rx_oom_timer);
1610 vp->rx_oom_timer.data = (unsigned long)dev;
1611 vp->rx_oom_timer.function = rx_oom_timer;
1612
1613 if (vortex_debug > 1)
Alexander Beregalov39738e12009-05-26 12:35:26 +00001614 pr_debug("%s: Initial media type %s.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001615 dev->name, media_tbl[dev->if_port].name);
1616
Steffen Klassert125d5ce2006-03-26 01:37:39 -08001617 vp->full_duplex = vp->mii.force_media;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001618 config = BFINS(config, dev->if_port, 20, 4);
1619 if (vortex_debug > 6)
Alexander Beregalov39738e12009-05-26 12:35:26 +00001620 pr_debug("vortex_up(): writing 0x%x to InternalConfig\n", config);
Ben Hutchingsa095cfc2010-06-23 13:54:31 +00001621 window_write32(vp, config, 3, Wn3_Config);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001622
1623 if (dev->if_port == XCVR_MII || dev->if_port == XCVR_NWAY) {
Steffen Klassert09ce3512006-03-31 02:30:48 -08001624 mii_reg1 = mdio_read(dev, vp->phys[0], MII_BMSR);
1625 mii_reg5 = mdio_read(dev, vp->phys[0], MII_LPA);
1626 vp->partner_flow_ctrl = ((mii_reg5 & 0x0400) != 0);
Steffen Klassert373492d2007-08-10 14:05:26 -07001627 vp->mii.full_duplex = vp->full_duplex;
Steffen Klassert09ce3512006-03-31 02:30:48 -08001628
Steffen Klassert125d5ce2006-03-26 01:37:39 -08001629 vortex_check_media(dev, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001630 }
Steffen Klassert125d5ce2006-03-26 01:37:39 -08001631 else
1632 vortex_set_duplex(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001633
Steffen Klassert09ce3512006-03-31 02:30:48 -08001634 issue_and_wait(dev, TxReset);
1635 /*
1636 * Don't reset the PHY - that upsets autonegotiation during DHCP operations.
1637 */
1638 issue_and_wait(dev, RxReset|0x04);
1639
Linus Torvalds1da177e2005-04-16 15:20:36 -07001640
John W. Linville62afe592005-11-07 00:58:02 -08001641 iowrite16(SetStatusEnb | 0x00, ioaddr + EL3_CMD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001642
1643 if (vortex_debug > 1) {
Alexander Beregalov39738e12009-05-26 12:35:26 +00001644 pr_debug("%s: vortex_up() irq %d media status %4.4x.\n",
Ben Hutchingsa095cfc2010-06-23 13:54:31 +00001645 dev->name, dev->irq, window_read16(vp, 4, Wn4_Media));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001646 }
1647
1648 /* Set the station address and mask in window 2 each time opened. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001649 for (i = 0; i < 6; i++)
Ben Hutchingsa095cfc2010-06-23 13:54:31 +00001650 window_write8(vp, dev->dev_addr[i], 2, i);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001651 for (; i < 12; i+=2)
Ben Hutchingsa095cfc2010-06-23 13:54:31 +00001652 window_write16(vp, 0, 2, i);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001653
1654 if (vp->cb_fn_base) {
Ben Hutchingsa095cfc2010-06-23 13:54:31 +00001655 unsigned short n = window_read16(vp, 2, Wn2_ResetOptions) & ~0x4010;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001656 if (vp->drv_flags & INVERT_LED_PWR)
1657 n |= 0x10;
1658 if (vp->drv_flags & INVERT_MII_PWR)
1659 n |= 0x4000;
Ben Hutchingsa095cfc2010-06-23 13:54:31 +00001660 window_write16(vp, n, 2, Wn2_ResetOptions);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001661 }
1662
1663 if (dev->if_port == XCVR_10base2)
1664 /* Start the thinnet transceiver. We should really wait 50ms...*/
John W. Linville62afe592005-11-07 00:58:02 -08001665 iowrite16(StartCoax, ioaddr + EL3_CMD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001666 if (dev->if_port != XCVR_NWAY) {
Ben Hutchingsa095cfc2010-06-23 13:54:31 +00001667 window_write16(vp,
1668 (window_read16(vp, 4, Wn4_Media) &
1669 ~(Media_10TP|Media_SQE)) |
1670 media_tbl[dev->if_port].media_bits,
1671 4, Wn4_Media);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001672 }
1673
1674 /* Switch to the stats window, and clear all stats by reading. */
John W. Linville62afe592005-11-07 00:58:02 -08001675 iowrite16(StatsDisable, ioaddr + EL3_CMD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001676 for (i = 0; i < 10; i++)
Ben Hutchingsa095cfc2010-06-23 13:54:31 +00001677 window_read8(vp, 6, i);
1678 window_read16(vp, 6, 10);
1679 window_read16(vp, 6, 12);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001680 /* New: On the Vortex we must also clear the BadSSD counter. */
Ben Hutchingsa095cfc2010-06-23 13:54:31 +00001681 window_read8(vp, 4, 12);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001682 /* ..and on the Boomerang we enable the extra statistics bits. */
Ben Hutchingsa095cfc2010-06-23 13:54:31 +00001683 window_write16(vp, 0x0040, 4, Wn4_NetDiag);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001684
1685 if (vp->full_bus_master_rx) { /* Boomerang bus master. */
1686 vp->cur_rx = vp->dirty_rx = 0;
1687 /* Initialize the RxEarly register as recommended. */
John W. Linville62afe592005-11-07 00:58:02 -08001688 iowrite16(SetRxThreshold + (1536>>2), ioaddr + EL3_CMD);
1689 iowrite32(0x0020, ioaddr + PktStatus);
1690 iowrite32(vp->rx_ring_dma, ioaddr + UpListPtr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001691 }
1692 if (vp->full_bus_master_tx) { /* Boomerang bus master Tx. */
1693 vp->cur_tx = vp->dirty_tx = 0;
1694 if (vp->drv_flags & IS_BOOMERANG)
John W. Linville62afe592005-11-07 00:58:02 -08001695 iowrite8(PKT_BUF_SZ>>8, ioaddr + TxFreeThreshold); /* Room for a packet. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001696 /* Clear the Rx, Tx rings. */
1697 for (i = 0; i < RX_RING_SIZE; i++) /* AKPM: this is done in vortex_open, too */
1698 vp->rx_ring[i].status = 0;
1699 for (i = 0; i < TX_RING_SIZE; i++)
1700 vp->tx_skbuff[i] = NULL;
John W. Linville62afe592005-11-07 00:58:02 -08001701 iowrite32(0, ioaddr + DownListPtr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001702 }
1703 /* Set receiver mode: presumably accept b-case and phys addr only. */
1704 set_rx_mode(dev);
1705 /* enable 802.1q tagged frames */
1706 set_8021q_mode(dev, 1);
John W. Linville62afe592005-11-07 00:58:02 -08001707 iowrite16(StatsEnable, ioaddr + EL3_CMD); /* Turn on statistics. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001708
John W. Linville62afe592005-11-07 00:58:02 -08001709 iowrite16(RxEnable, ioaddr + EL3_CMD); /* Enable the receiver. */
1710 iowrite16(TxEnable, ioaddr + EL3_CMD); /* Enable transmitter. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001711 /* Allow status bits to be seen. */
1712 vp->status_enable = SetStatusEnb | HostError|IntReq|StatsFull|TxComplete|
1713 (vp->full_bus_master_tx ? DownComplete : TxAvailable) |
1714 (vp->full_bus_master_rx ? UpComplete : RxComplete) |
1715 (vp->bus_master ? DMADone : 0);
1716 vp->intr_enable = SetIntrEnb | IntLatch | TxAvailable |
1717 (vp->full_bus_master_rx ? 0 : RxComplete) |
1718 StatsFull | HostError | TxComplete | IntReq
1719 | (vp->bus_master ? DMADone : 0) | UpComplete | DownComplete;
John W. Linville62afe592005-11-07 00:58:02 -08001720 iowrite16(vp->status_enable, ioaddr + EL3_CMD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001721 /* Ack all pending events, and set active indicator mask. */
John W. Linville62afe592005-11-07 00:58:02 -08001722 iowrite16(AckIntr | IntLatch | TxAvailable | RxEarly | IntReq,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001723 ioaddr + EL3_CMD);
John W. Linville62afe592005-11-07 00:58:02 -08001724 iowrite16(vp->intr_enable, ioaddr + EL3_CMD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001725 if (vp->cb_fn_base) /* The PCMCIA people are idiots. */
John W. Linville62afe592005-11-07 00:58:02 -08001726 iowrite32(0x8000, vp->cb_fn_base + 4);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001727 netif_start_queue (dev);
Mark Hindleyc8303d12007-08-16 11:28:40 +01001728err_out:
1729 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001730}
1731
1732static int
1733vortex_open(struct net_device *dev)
1734{
1735 struct vortex_private *vp = netdev_priv(dev);
1736 int i;
1737 int retval;
1738
1739 /* Use the now-standard shared IRQ implementation. */
1740 if ((retval = request_irq(dev->irq, vp->full_bus_master_rx ?
Thomas Gleixner1fb9df52006-07-01 19:29:39 -07001741 &boomerang_interrupt : &vortex_interrupt, IRQF_SHARED, dev->name, dev))) {
Alexander Beregalov39738e12009-05-26 12:35:26 +00001742 pr_err("%s: Could not reserve IRQ %d\n", dev->name, dev->irq);
Mark Hindleyc8303d12007-08-16 11:28:40 +01001743 goto err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001744 }
1745
1746 if (vp->full_bus_master_rx) { /* Boomerang bus master. */
1747 if (vortex_debug > 2)
Alexander Beregalov39738e12009-05-26 12:35:26 +00001748 pr_debug("%s: Filling in the Rx ring.\n", dev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001749 for (i = 0; i < RX_RING_SIZE; i++) {
1750 struct sk_buff *skb;
1751 vp->rx_ring[i].next = cpu_to_le32(vp->rx_ring_dma + sizeof(struct boom_rx_desc) * (i+1));
1752 vp->rx_ring[i].status = 0; /* Clear complete bit. */
1753 vp->rx_ring[i].length = cpu_to_le32(PKT_BUF_SZ | LAST_FRAG);
Stephen Hemminger9a5d34142008-07-25 12:07:22 -07001754
1755 skb = __netdev_alloc_skb(dev, PKT_BUF_SZ + NET_IP_ALIGN,
1756 GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001757 vp->rx_skbuff[i] = skb;
1758 if (skb == NULL)
1759 break; /* Bad news! */
Stephen Hemminger9a5d34142008-07-25 12:07:22 -07001760
1761 skb_reserve(skb, NET_IP_ALIGN); /* Align IP on 16 byte boundaries */
David S. Miller689be432005-06-28 15:25:31 -07001762 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 -07001763 }
1764 if (i != RX_RING_SIZE) {
1765 int j;
Alexander Beregalov39738e12009-05-26 12:35:26 +00001766 pr_emerg("%s: no memory for rx ring\n", dev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001767 for (j = 0; j < i; j++) {
1768 if (vp->rx_skbuff[j]) {
1769 dev_kfree_skb(vp->rx_skbuff[j]);
1770 vp->rx_skbuff[j] = NULL;
1771 }
1772 }
1773 retval = -ENOMEM;
Mark Hindleyc8303d12007-08-16 11:28:40 +01001774 goto err_free_irq;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001775 }
1776 /* Wrap the ring. */
1777 vp->rx_ring[i-1].next = cpu_to_le32(vp->rx_ring_dma);
1778 }
1779
Mark Hindleyc8303d12007-08-16 11:28:40 +01001780 retval = vortex_up(dev);
1781 if (!retval)
1782 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001783
Mark Hindleyc8303d12007-08-16 11:28:40 +01001784err_free_irq:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001785 free_irq(dev->irq, dev);
Mark Hindleyc8303d12007-08-16 11:28:40 +01001786err:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001787 if (vortex_debug > 1)
Alexander Beregalov39738e12009-05-26 12:35:26 +00001788 pr_err("%s: vortex_open() fails: returning %d\n", dev->name, retval);
Mark Hindleyc8303d12007-08-16 11:28:40 +01001789out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001790 return retval;
1791}
1792
1793static void
1794vortex_timer(unsigned long data)
1795{
1796 struct net_device *dev = (struct net_device *)data;
1797 struct vortex_private *vp = netdev_priv(dev);
John W. Linville62afe592005-11-07 00:58:02 -08001798 void __iomem *ioaddr = vp->ioaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001799 int next_tick = 60*HZ;
1800 int ok = 0;
Ben Hutchingsa095cfc2010-06-23 13:54:31 +00001801 int media_status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001802
1803 if (vortex_debug > 2) {
Alexander Beregalov39738e12009-05-26 12:35:26 +00001804 pr_debug("%s: Media selection timer tick happened, %s.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001805 dev->name, media_tbl[dev->if_port].name);
Alexander Beregalov39738e12009-05-26 12:35:26 +00001806 pr_debug("dev->watchdog_timeo=%d\n", dev->watchdog_timeo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001807 }
1808
Ben Hutchingsa095cfc2010-06-23 13:54:31 +00001809 media_status = window_read16(vp, 4, Wn4_Media);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001810 switch (dev->if_port) {
1811 case XCVR_10baseT: case XCVR_100baseTx: case XCVR_100baseFx:
1812 if (media_status & Media_LnkBeat) {
1813 netif_carrier_on(dev);
1814 ok = 1;
1815 if (vortex_debug > 1)
Alexander Beregalov39738e12009-05-26 12:35:26 +00001816 pr_debug("%s: Media %s has link beat, %x.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001817 dev->name, media_tbl[dev->if_port].name, media_status);
1818 } else {
1819 netif_carrier_off(dev);
1820 if (vortex_debug > 1) {
Alexander Beregalov39738e12009-05-26 12:35:26 +00001821 pr_debug("%s: Media %s has no link beat, %x.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001822 dev->name, media_tbl[dev->if_port].name, media_status);
1823 }
1824 }
1825 break;
1826 case XCVR_MII: case XCVR_NWAY:
1827 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001828 ok = 1;
Steffen Klassert125d5ce2006-03-26 01:37:39 -08001829 vortex_check_media(dev, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001830 }
1831 break;
1832 default: /* Other media types handled by Tx timeouts. */
1833 if (vortex_debug > 1)
Alexander Beregalov39738e12009-05-26 12:35:26 +00001834 pr_debug("%s: Media %s has no indication, %x.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001835 dev->name, media_tbl[dev->if_port].name, media_status);
1836 ok = 1;
1837 }
Steffen Klassertb4ff6452006-03-26 01:37:40 -08001838
1839 if (!netif_carrier_ok(dev))
1840 next_tick = 5*HZ;
1841
Steffen Klasserte94d10e2006-03-26 01:37:41 -08001842 if (vp->medialock)
1843 goto leave_media_alone;
1844
Steffen Klasserta880c4c2006-03-26 01:37:43 -08001845 if (!ok) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001846 unsigned int config;
1847
Ben Hutchingsde847272010-06-29 15:26:56 +00001848 spin_lock_irq(&vp->lock);
1849
Linus Torvalds1da177e2005-04-16 15:20:36 -07001850 do {
1851 dev->if_port = media_tbl[dev->if_port].next;
1852 } while ( ! (vp->available_media & media_tbl[dev->if_port].mask));
1853 if (dev->if_port == XCVR_Default) { /* Go back to default. */
1854 dev->if_port = vp->default_media;
1855 if (vortex_debug > 1)
Alexander Beregalov39738e12009-05-26 12:35:26 +00001856 pr_debug("%s: Media selection failing, using default %s port.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001857 dev->name, media_tbl[dev->if_port].name);
1858 } else {
1859 if (vortex_debug > 1)
Alexander Beregalov39738e12009-05-26 12:35:26 +00001860 pr_debug("%s: Media selection failed, now trying %s port.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001861 dev->name, media_tbl[dev->if_port].name);
1862 next_tick = media_tbl[dev->if_port].wait;
1863 }
Ben Hutchingsa095cfc2010-06-23 13:54:31 +00001864 window_write16(vp,
1865 (media_status & ~(Media_10TP|Media_SQE)) |
1866 media_tbl[dev->if_port].media_bits,
1867 4, Wn4_Media);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001868
Ben Hutchingsa095cfc2010-06-23 13:54:31 +00001869 config = window_read32(vp, 3, Wn3_Config);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001870 config = BFINS(config, dev->if_port, 20, 4);
Ben Hutchingsa095cfc2010-06-23 13:54:31 +00001871 window_write32(vp, config, 3, Wn3_Config);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001872
John W. Linville62afe592005-11-07 00:58:02 -08001873 iowrite16(dev->if_port == XCVR_10base2 ? StartCoax : StopCoax,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001874 ioaddr + EL3_CMD);
1875 if (vortex_debug > 1)
Alexander Beregalov39738e12009-05-26 12:35:26 +00001876 pr_debug("wrote 0x%08x to Wn3_Config\n", config);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001877 /* AKPM: FIXME: Should reset Rx & Tx here. P60 of 3c90xc.pdf */
Ben Hutchingsde847272010-06-29 15:26:56 +00001878
1879 spin_unlock_irq(&vp->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001880 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001881
1882leave_media_alone:
1883 if (vortex_debug > 2)
Alexander Beregalov39738e12009-05-26 12:35:26 +00001884 pr_debug("%s: Media selection timer finished, %s.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001885 dev->name, media_tbl[dev->if_port].name);
1886
1887 mod_timer(&vp->timer, RUN_AT(next_tick));
1888 if (vp->deferred)
John W. Linville62afe592005-11-07 00:58:02 -08001889 iowrite16(FakeIntr, ioaddr + EL3_CMD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001890}
1891
1892static void vortex_tx_timeout(struct net_device *dev)
1893{
1894 struct vortex_private *vp = netdev_priv(dev);
John W. Linville62afe592005-11-07 00:58:02 -08001895 void __iomem *ioaddr = vp->ioaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001896
Alexander Beregalov39738e12009-05-26 12:35:26 +00001897 pr_err("%s: transmit timed out, tx_status %2.2x status %4.4x.\n",
John W. Linville62afe592005-11-07 00:58:02 -08001898 dev->name, ioread8(ioaddr + TxStatus),
1899 ioread16(ioaddr + EL3_STATUS));
Alexander Beregalov39738e12009-05-26 12:35:26 +00001900 pr_err(" diagnostics: net %04x media %04x dma %08x fifo %04x\n",
Ben Hutchingsa095cfc2010-06-23 13:54:31 +00001901 window_read16(vp, 4, Wn4_NetDiag),
1902 window_read16(vp, 4, Wn4_Media),
John W. Linville62afe592005-11-07 00:58:02 -08001903 ioread32(ioaddr + PktStatus),
Ben Hutchingsa095cfc2010-06-23 13:54:31 +00001904 window_read16(vp, 4, Wn4_FIFODiag));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001905 /* Slight code bloat to be user friendly. */
John W. Linville62afe592005-11-07 00:58:02 -08001906 if ((ioread8(ioaddr + TxStatus) & 0x88) == 0x88)
Alexander Beregalov39738e12009-05-26 12:35:26 +00001907 pr_err("%s: Transmitter encountered 16 collisions --"
Linus Torvalds1da177e2005-04-16 15:20:36 -07001908 " network cable problem?\n", dev->name);
John W. Linville62afe592005-11-07 00:58:02 -08001909 if (ioread16(ioaddr + EL3_STATUS) & IntLatch) {
Alexander Beregalov39738e12009-05-26 12:35:26 +00001910 pr_err("%s: Interrupt posted but not delivered --"
Linus Torvalds1da177e2005-04-16 15:20:36 -07001911 " IRQ blocked by another device?\n", dev->name);
1912 /* Bad idea here.. but we might as well handle a few events. */
1913 {
1914 /*
1915 * Block interrupts because vortex_interrupt does a bare spin_lock()
1916 */
1917 unsigned long flags;
1918 local_irq_save(flags);
1919 if (vp->full_bus_master_tx)
David Howells7d12e782006-10-05 14:55:46 +01001920 boomerang_interrupt(dev->irq, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001921 else
David Howells7d12e782006-10-05 14:55:46 +01001922 vortex_interrupt(dev->irq, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001923 local_irq_restore(flags);
1924 }
1925 }
1926
1927 if (vortex_debug > 0)
1928 dump_tx_ring(dev);
1929
1930 issue_and_wait(dev, TxReset);
1931
Paulius Zaleckas1daad052008-05-05 14:01:29 +02001932 dev->stats.tx_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001933 if (vp->full_bus_master_tx) {
Alexander Beregalov39738e12009-05-26 12:35:26 +00001934 pr_debug("%s: Resetting the Tx ring pointer.\n", dev->name);
John W. Linville62afe592005-11-07 00:58:02 -08001935 if (vp->cur_tx - vp->dirty_tx > 0 && ioread32(ioaddr + DownListPtr) == 0)
1936 iowrite32(vp->tx_ring_dma + (vp->dirty_tx % TX_RING_SIZE) * sizeof(struct boom_tx_desc),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001937 ioaddr + DownListPtr);
1938 if (vp->cur_tx - vp->dirty_tx < TX_RING_SIZE)
1939 netif_wake_queue (dev);
1940 if (vp->drv_flags & IS_BOOMERANG)
John W. Linville62afe592005-11-07 00:58:02 -08001941 iowrite8(PKT_BUF_SZ>>8, ioaddr + TxFreeThreshold);
1942 iowrite16(DownUnstall, ioaddr + EL3_CMD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001943 } else {
Paulius Zaleckas1daad052008-05-05 14:01:29 +02001944 dev->stats.tx_dropped++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001945 netif_wake_queue(dev);
1946 }
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001947
Linus Torvalds1da177e2005-04-16 15:20:36 -07001948 /* Issue Tx Enable */
John W. Linville62afe592005-11-07 00:58:02 -08001949 iowrite16(TxEnable, ioaddr + EL3_CMD);
Eric Dumazet1ae5dc32010-05-10 05:01:31 -07001950 dev->trans_start = jiffies; /* prevent tx timeout */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001951}
1952
1953/*
1954 * Handle uncommon interrupt sources. This is a separate routine to minimize
1955 * the cache impact.
1956 */
1957static void
1958vortex_error(struct net_device *dev, int status)
1959{
1960 struct vortex_private *vp = netdev_priv(dev);
John W. Linville62afe592005-11-07 00:58:02 -08001961 void __iomem *ioaddr = vp->ioaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001962 int do_tx_reset = 0, reset_mask = 0;
1963 unsigned char tx_status = 0;
1964
1965 if (vortex_debug > 2) {
Alexander Beregalov39738e12009-05-26 12:35:26 +00001966 pr_err("%s: vortex_error(), status=0x%x\n", dev->name, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001967 }
1968
1969 if (status & TxComplete) { /* Really "TxError" for us. */
John W. Linville62afe592005-11-07 00:58:02 -08001970 tx_status = ioread8(ioaddr + TxStatus);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001971 /* Presumably a tx-timeout. We must merely re-enable. */
Joe Perches8e95a202009-12-03 07:58:21 +00001972 if (vortex_debug > 2 ||
1973 (tx_status != 0x88 && vortex_debug > 0)) {
Alexander Beregalov39738e12009-05-26 12:35:26 +00001974 pr_err("%s: Transmit error, Tx status register %2.2x.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001975 dev->name, tx_status);
1976 if (tx_status == 0x82) {
Alexander Beregalov39738e12009-05-26 12:35:26 +00001977 pr_err("Probably a duplex mismatch. See "
Linus Torvalds1da177e2005-04-16 15:20:36 -07001978 "Documentation/networking/vortex.txt\n");
1979 }
1980 dump_tx_ring(dev);
1981 }
Paulius Zaleckas1daad052008-05-05 14:01:29 +02001982 if (tx_status & 0x14) dev->stats.tx_fifo_errors++;
1983 if (tx_status & 0x38) dev->stats.tx_aborted_errors++;
Andrew Morton00007542006-03-31 02:30:47 -08001984 if (tx_status & 0x08) vp->xstats.tx_max_collisions++;
John W. Linville62afe592005-11-07 00:58:02 -08001985 iowrite8(0, ioaddr + TxStatus);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001986 if (tx_status & 0x30) { /* txJabber or txUnderrun */
1987 do_tx_reset = 1;
Andrew Morton00007542006-03-31 02:30:47 -08001988 } else if ((tx_status & 0x08) && (vp->drv_flags & MAX_COLLISION_RESET)) { /* maxCollisions */
1989 do_tx_reset = 1;
1990 reset_mask = 0x0108; /* Reset interface logic, but not download logic */
1991 } else { /* Merely re-enable the transmitter. */
John W. Linville62afe592005-11-07 00:58:02 -08001992 iowrite16(TxEnable, ioaddr + EL3_CMD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001993 }
1994 }
1995
1996 if (status & RxEarly) { /* Rx early is unused. */
1997 vortex_rx(dev);
John W. Linville62afe592005-11-07 00:58:02 -08001998 iowrite16(AckIntr | RxEarly, ioaddr + EL3_CMD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001999 }
2000 if (status & StatsFull) { /* Empty statistics. */
2001 static int DoneDidThat;
2002 if (vortex_debug > 4)
Alexander Beregalov39738e12009-05-26 12:35:26 +00002003 pr_debug("%s: Updating stats.\n", dev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002004 update_stats(ioaddr, dev);
2005 /* HACK: Disable statistics as an interrupt source. */
2006 /* This occurs when we have the wrong media type! */
2007 if (DoneDidThat == 0 &&
John W. Linville62afe592005-11-07 00:58:02 -08002008 ioread16(ioaddr + EL3_STATUS) & StatsFull) {
Alexander Beregalov39738e12009-05-26 12:35:26 +00002009 pr_warning("%s: Updating statistics failed, disabling "
Linus Torvalds1da177e2005-04-16 15:20:36 -07002010 "stats as an interrupt source.\n", dev->name);
Ben Hutchingsa095cfc2010-06-23 13:54:31 +00002011 iowrite16(SetIntrEnb |
2012 (window_read16(vp, 5, 10) & ~StatsFull),
2013 ioaddr + EL3_CMD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002014 vp->intr_enable &= ~StatsFull;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002015 DoneDidThat++;
2016 }
2017 }
2018 if (status & IntReq) { /* Restore all interrupt sources. */
John W. Linville62afe592005-11-07 00:58:02 -08002019 iowrite16(vp->status_enable, ioaddr + EL3_CMD);
2020 iowrite16(vp->intr_enable, ioaddr + EL3_CMD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002021 }
2022 if (status & HostError) {
2023 u16 fifo_diag;
Ben Hutchingsa095cfc2010-06-23 13:54:31 +00002024 fifo_diag = window_read16(vp, 4, Wn4_FIFODiag);
Alexander Beregalov39738e12009-05-26 12:35:26 +00002025 pr_err("%s: Host error, FIFO diagnostic register %4.4x.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002026 dev->name, fifo_diag);
2027 /* Adapter failure requires Tx/Rx reset and reinit. */
2028 if (vp->full_bus_master_tx) {
John W. Linville62afe592005-11-07 00:58:02 -08002029 int bus_status = ioread32(ioaddr + PktStatus);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002030 /* 0x80000000 PCI master abort. */
2031 /* 0x40000000 PCI target abort. */
2032 if (vortex_debug)
Alexander Beregalov39738e12009-05-26 12:35:26 +00002033 pr_err("%s: PCI bus error, bus status %8.8x\n", dev->name, bus_status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002034
2035 /* In this case, blow the card away */
2036 /* Must not enter D3 or we can't legally issue the reset! */
2037 vortex_down(dev, 0);
2038 issue_and_wait(dev, TotalReset | 0xff);
2039 vortex_up(dev); /* AKPM: bug. vortex_up() assumes that the rx ring is full. It may not be. */
2040 } else if (fifo_diag & 0x0400)
2041 do_tx_reset = 1;
2042 if (fifo_diag & 0x3000) {
2043 /* Reset Rx fifo and upload logic */
2044 issue_and_wait(dev, RxReset|0x07);
2045 /* Set the Rx filter to the current state. */
2046 set_rx_mode(dev);
2047 /* enable 802.1q VLAN tagged frames */
2048 set_8021q_mode(dev, 1);
John W. Linville62afe592005-11-07 00:58:02 -08002049 iowrite16(RxEnable, ioaddr + EL3_CMD); /* Re-enable the receiver. */
2050 iowrite16(AckIntr | HostError, ioaddr + EL3_CMD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002051 }
2052 }
2053
2054 if (do_tx_reset) {
2055 issue_and_wait(dev, TxReset|reset_mask);
John W. Linville62afe592005-11-07 00:58:02 -08002056 iowrite16(TxEnable, ioaddr + EL3_CMD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002057 if (!vp->full_bus_master_tx)
2058 netif_wake_queue(dev);
2059 }
2060}
2061
Stephen Hemminger27a1de92009-08-31 19:50:54 +00002062static netdev_tx_t
Linus Torvalds1da177e2005-04-16 15:20:36 -07002063vortex_start_xmit(struct sk_buff *skb, struct net_device *dev)
2064{
2065 struct vortex_private *vp = netdev_priv(dev);
John W. Linville62afe592005-11-07 00:58:02 -08002066 void __iomem *ioaddr = vp->ioaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002067
2068 /* Put out the doubleword header... */
John W. Linville62afe592005-11-07 00:58:02 -08002069 iowrite32(skb->len, ioaddr + TX_FIFO);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002070 if (vp->bus_master) {
2071 /* Set the bus-master controller to transfer the packet. */
2072 int len = (skb->len + 3) & ~3;
Ben Hutchingsa095cfc2010-06-23 13:54:31 +00002073 vp->tx_skb_dma = pci_map_single(VORTEX_PCI(vp), skb->data, len,
2074 PCI_DMA_TODEVICE);
Ben Hutchingsde847272010-06-29 15:26:56 +00002075 spin_lock_irq(&vp->window_lock);
Ben Hutchingsa095cfc2010-06-23 13:54:31 +00002076 window_set(vp, 7);
2077 iowrite32(vp->tx_skb_dma, ioaddr + Wn7_MasterAddr);
John W. Linville62afe592005-11-07 00:58:02 -08002078 iowrite16(len, ioaddr + Wn7_MasterLen);
Ben Hutchingsde847272010-06-29 15:26:56 +00002079 spin_unlock_irq(&vp->window_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002080 vp->tx_skb = skb;
John W. Linville62afe592005-11-07 00:58:02 -08002081 iowrite16(StartDMADown, ioaddr + EL3_CMD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002082 /* netif_wake_queue() will be called at the DMADone interrupt. */
2083 } else {
2084 /* ... and the packet rounded to a doubleword. */
John W. Linville62afe592005-11-07 00:58:02 -08002085 iowrite32_rep(ioaddr + TX_FIFO, skb->data, (skb->len + 3) >> 2);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002086 dev_kfree_skb (skb);
John W. Linville62afe592005-11-07 00:58:02 -08002087 if (ioread16(ioaddr + TxFree) > 1536) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002088 netif_start_queue (dev); /* AKPM: redundant? */
2089 } else {
2090 /* Interrupt us when the FIFO has room for max-sized packet. */
2091 netif_stop_queue(dev);
John W. Linville62afe592005-11-07 00:58:02 -08002092 iowrite16(SetTxThreshold + (1536>>2), ioaddr + EL3_CMD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002093 }
2094 }
2095
Linus Torvalds1da177e2005-04-16 15:20:36 -07002096
2097 /* Clear the Tx status stack. */
2098 {
2099 int tx_status;
2100 int i = 32;
2101
John W. Linville62afe592005-11-07 00:58:02 -08002102 while (--i > 0 && (tx_status = ioread8(ioaddr + TxStatus)) > 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002103 if (tx_status & 0x3C) { /* A Tx-disabling error occurred. */
2104 if (vortex_debug > 2)
Alexander Beregalov39738e12009-05-26 12:35:26 +00002105 pr_debug("%s: Tx error, status %2.2x.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002106 dev->name, tx_status);
Paulius Zaleckas1daad052008-05-05 14:01:29 +02002107 if (tx_status & 0x04) dev->stats.tx_fifo_errors++;
2108 if (tx_status & 0x38) dev->stats.tx_aborted_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002109 if (tx_status & 0x30) {
2110 issue_and_wait(dev, TxReset);
2111 }
John W. Linville62afe592005-11-07 00:58:02 -08002112 iowrite16(TxEnable, ioaddr + EL3_CMD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002113 }
John W. Linville62afe592005-11-07 00:58:02 -08002114 iowrite8(0x00, ioaddr + TxStatus); /* Pop the status stack. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002115 }
2116 }
Patrick McHardy6ed10652009-06-23 06:03:08 +00002117 return NETDEV_TX_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002118}
2119
Stephen Hemminger27a1de92009-08-31 19:50:54 +00002120static netdev_tx_t
Linus Torvalds1da177e2005-04-16 15:20:36 -07002121boomerang_start_xmit(struct sk_buff *skb, struct net_device *dev)
2122{
2123 struct vortex_private *vp = netdev_priv(dev);
John W. Linville62afe592005-11-07 00:58:02 -08002124 void __iomem *ioaddr = vp->ioaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002125 /* Calculate the next Tx descriptor entry. */
2126 int entry = vp->cur_tx % TX_RING_SIZE;
2127 struct boom_tx_desc *prev_entry = &vp->tx_ring[(vp->cur_tx-1) % TX_RING_SIZE];
2128 unsigned long flags;
2129
2130 if (vortex_debug > 6) {
Alexander Beregalov39738e12009-05-26 12:35:26 +00002131 pr_debug("boomerang_start_xmit()\n");
2132 pr_debug("%s: Trying to send a packet, Tx index %d.\n",
John W. Linville0f667ff2005-06-21 17:15:14 -07002133 dev->name, vp->cur_tx);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002134 }
2135
2136 if (vp->cur_tx - vp->dirty_tx >= TX_RING_SIZE) {
2137 if (vortex_debug > 0)
Alexander Beregalov39738e12009-05-26 12:35:26 +00002138 pr_warning("%s: BUG! Tx Ring full, refusing to send buffer.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002139 dev->name);
2140 netif_stop_queue(dev);
Patrick McHardy5b548142009-06-12 06:22:29 +00002141 return NETDEV_TX_BUSY;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002142 }
2143
2144 vp->tx_skbuff[entry] = skb;
2145
2146 vp->tx_ring[entry].next = 0;
2147#if DO_ZEROCOPY
Patrick McHardy84fa7932006-08-29 16:44:56 -07002148 if (skb->ip_summed != CHECKSUM_PARTIAL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002149 vp->tx_ring[entry].status = cpu_to_le32(skb->len | TxIntrUploaded);
2150 else
2151 vp->tx_ring[entry].status = cpu_to_le32(skb->len | TxIntrUploaded | AddTCPChksum | AddUDPChksum);
2152
2153 if (!skb_shinfo(skb)->nr_frags) {
2154 vp->tx_ring[entry].frag[0].addr = cpu_to_le32(pci_map_single(VORTEX_PCI(vp), skb->data,
2155 skb->len, PCI_DMA_TODEVICE));
2156 vp->tx_ring[entry].frag[0].length = cpu_to_le32(skb->len | LAST_FRAG);
2157 } else {
2158 int i;
2159
2160 vp->tx_ring[entry].frag[0].addr = cpu_to_le32(pci_map_single(VORTEX_PCI(vp), skb->data,
Eric Dumazete743d312010-04-14 15:59:40 -07002161 skb_headlen(skb), PCI_DMA_TODEVICE));
2162 vp->tx_ring[entry].frag[0].length = cpu_to_le32(skb_headlen(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002163
2164 for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
2165 skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
2166
2167 vp->tx_ring[entry].frag[i+1].addr =
2168 cpu_to_le32(pci_map_single(VORTEX_PCI(vp),
2169 (void*)page_address(frag->page) + frag->page_offset,
2170 frag->size, PCI_DMA_TODEVICE));
2171
2172 if (i == skb_shinfo(skb)->nr_frags-1)
2173 vp->tx_ring[entry].frag[i+1].length = cpu_to_le32(frag->size|LAST_FRAG);
2174 else
2175 vp->tx_ring[entry].frag[i+1].length = cpu_to_le32(frag->size);
2176 }
2177 }
2178#else
2179 vp->tx_ring[entry].addr = cpu_to_le32(pci_map_single(VORTEX_PCI(vp), skb->data, skb->len, PCI_DMA_TODEVICE));
2180 vp->tx_ring[entry].length = cpu_to_le32(skb->len | LAST_FRAG);
2181 vp->tx_ring[entry].status = cpu_to_le32(skb->len | TxIntrUploaded);
2182#endif
2183
2184 spin_lock_irqsave(&vp->lock, flags);
2185 /* Wait for the stall to complete. */
2186 issue_and_wait(dev, DownStall);
2187 prev_entry->next = cpu_to_le32(vp->tx_ring_dma + entry * sizeof(struct boom_tx_desc));
John W. Linville62afe592005-11-07 00:58:02 -08002188 if (ioread32(ioaddr + DownListPtr) == 0) {
2189 iowrite32(vp->tx_ring_dma + entry * sizeof(struct boom_tx_desc), ioaddr + DownListPtr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002190 vp->queued_packet++;
2191 }
2192
2193 vp->cur_tx++;
2194 if (vp->cur_tx - vp->dirty_tx > TX_RING_SIZE - 1) {
2195 netif_stop_queue (dev);
2196 } else { /* Clear previous interrupt enable. */
2197#if defined(tx_interrupt_mitigation)
2198 /* Dubious. If in boomeang_interrupt "faster" cyclone ifdef
2199 * were selected, this would corrupt DN_COMPLETE. No?
2200 */
2201 prev_entry->status &= cpu_to_le32(~TxIntrUploaded);
2202#endif
2203 }
John W. Linville62afe592005-11-07 00:58:02 -08002204 iowrite16(DownUnstall, ioaddr + EL3_CMD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002205 spin_unlock_irqrestore(&vp->lock, flags);
Patrick McHardy6ed10652009-06-23 06:03:08 +00002206 return NETDEV_TX_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002207}
2208
2209/* The interrupt handler does all of the Rx thread work and cleans up
2210 after the Tx thread. */
2211
2212/*
2213 * This is the ISR for the vortex series chips.
2214 * full_bus_master_tx == 0 && full_bus_master_rx == 0
2215 */
2216
2217static irqreturn_t
David Howells7d12e782006-10-05 14:55:46 +01002218vortex_interrupt(int irq, void *dev_id)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002219{
2220 struct net_device *dev = dev_id;
2221 struct vortex_private *vp = netdev_priv(dev);
John W. Linville62afe592005-11-07 00:58:02 -08002222 void __iomem *ioaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002223 int status;
2224 int work_done = max_interrupt_work;
2225 int handled = 0;
2226
John W. Linville62afe592005-11-07 00:58:02 -08002227 ioaddr = vp->ioaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002228 spin_lock(&vp->lock);
2229
John W. Linville62afe592005-11-07 00:58:02 -08002230 status = ioread16(ioaddr + EL3_STATUS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002231
2232 if (vortex_debug > 6)
Alexander Beregalov39738e12009-05-26 12:35:26 +00002233 pr_debug("vortex_interrupt(). status=0x%4x\n", status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002234
2235 if ((status & IntLatch) == 0)
2236 goto handler_exit; /* No interrupt: shared IRQs cause this */
2237 handled = 1;
2238
2239 if (status & IntReq) {
2240 status |= vp->deferred;
2241 vp->deferred = 0;
2242 }
2243
2244 if (status == 0xffff) /* h/w no longer present (hotplug)? */
2245 goto handler_exit;
2246
2247 if (vortex_debug > 4)
Alexander Beregalov39738e12009-05-26 12:35:26 +00002248 pr_debug("%s: interrupt, status %4.4x, latency %d ticks.\n",
John W. Linville62afe592005-11-07 00:58:02 -08002249 dev->name, status, ioread8(ioaddr + Timer));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002250
Ben Hutchingsde847272010-06-29 15:26:56 +00002251 spin_lock(&vp->window_lock);
Ben Hutchingsa095cfc2010-06-23 13:54:31 +00002252 window_set(vp, 7);
2253
Linus Torvalds1da177e2005-04-16 15:20:36 -07002254 do {
2255 if (vortex_debug > 5)
Alexander Beregalov39738e12009-05-26 12:35:26 +00002256 pr_debug("%s: In interrupt loop, status %4.4x.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002257 dev->name, status);
2258 if (status & RxComplete)
2259 vortex_rx(dev);
2260
2261 if (status & TxAvailable) {
2262 if (vortex_debug > 5)
Alexander Beregalov39738e12009-05-26 12:35:26 +00002263 pr_debug(" TX room bit was handled.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002264 /* There's room in the FIFO for a full-sized packet. */
John W. Linville62afe592005-11-07 00:58:02 -08002265 iowrite16(AckIntr | TxAvailable, ioaddr + EL3_CMD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002266 netif_wake_queue (dev);
2267 }
2268
2269 if (status & DMADone) {
John W. Linville62afe592005-11-07 00:58:02 -08002270 if (ioread16(ioaddr + Wn7_MasterStatus) & 0x1000) {
2271 iowrite16(0x1000, ioaddr + Wn7_MasterStatus); /* Ack the event. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002272 pci_unmap_single(VORTEX_PCI(vp), vp->tx_skb_dma, (vp->tx_skb->len + 3) & ~3, PCI_DMA_TODEVICE);
2273 dev_kfree_skb_irq(vp->tx_skb); /* Release the transferred buffer */
John W. Linville62afe592005-11-07 00:58:02 -08002274 if (ioread16(ioaddr + TxFree) > 1536) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002275 /*
2276 * AKPM: FIXME: I don't think we need this. If the queue was stopped due to
2277 * insufficient FIFO room, the TxAvailable test will succeed and call
2278 * netif_wake_queue()
2279 */
2280 netif_wake_queue(dev);
2281 } else { /* Interrupt when FIFO has room for max-sized packet. */
John W. Linville62afe592005-11-07 00:58:02 -08002282 iowrite16(SetTxThreshold + (1536>>2), ioaddr + EL3_CMD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002283 netif_stop_queue(dev);
2284 }
2285 }
2286 }
2287 /* Check for all uncommon interrupts at once. */
2288 if (status & (HostError | RxEarly | StatsFull | TxComplete | IntReq)) {
2289 if (status == 0xffff)
2290 break;
2291 vortex_error(dev, status);
2292 }
2293
2294 if (--work_done < 0) {
Alexander Beregalov39738e12009-05-26 12:35:26 +00002295 pr_warning("%s: Too much work in interrupt, status %4.4x.\n",
2296 dev->name, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002297 /* Disable all pending interrupts. */
2298 do {
2299 vp->deferred |= status;
John W. Linville62afe592005-11-07 00:58:02 -08002300 iowrite16(SetStatusEnb | (~vp->deferred & vp->status_enable),
Linus Torvalds1da177e2005-04-16 15:20:36 -07002301 ioaddr + EL3_CMD);
John W. Linville62afe592005-11-07 00:58:02 -08002302 iowrite16(AckIntr | (vp->deferred & 0x7ff), ioaddr + EL3_CMD);
2303 } while ((status = ioread16(ioaddr + EL3_CMD)) & IntLatch);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002304 /* The timer will reenable interrupts. */
2305 mod_timer(&vp->timer, jiffies + 1*HZ);
2306 break;
2307 }
2308 /* Acknowledge the IRQ. */
John W. Linville62afe592005-11-07 00:58:02 -08002309 iowrite16(AckIntr | IntReq | IntLatch, ioaddr + EL3_CMD);
2310 } while ((status = ioread16(ioaddr + EL3_STATUS)) & (IntLatch | RxComplete));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002311
Ben Hutchingsde847272010-06-29 15:26:56 +00002312 spin_unlock(&vp->window_lock);
2313
Linus Torvalds1da177e2005-04-16 15:20:36 -07002314 if (vortex_debug > 4)
Alexander Beregalov39738e12009-05-26 12:35:26 +00002315 pr_debug("%s: exiting interrupt, status %4.4x.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002316 dev->name, status);
2317handler_exit:
2318 spin_unlock(&vp->lock);
2319 return IRQ_RETVAL(handled);
2320}
2321
2322/*
2323 * This is the ISR for the boomerang series chips.
2324 * full_bus_master_tx == 1 && full_bus_master_rx == 1
2325 */
2326
2327static irqreturn_t
David Howells7d12e782006-10-05 14:55:46 +01002328boomerang_interrupt(int irq, void *dev_id)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002329{
2330 struct net_device *dev = dev_id;
2331 struct vortex_private *vp = netdev_priv(dev);
John W. Linville62afe592005-11-07 00:58:02 -08002332 void __iomem *ioaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002333 int status;
2334 int work_done = max_interrupt_work;
2335
John W. Linville62afe592005-11-07 00:58:02 -08002336 ioaddr = vp->ioaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002337
2338 /*
2339 * It seems dopey to put the spinlock this early, but we could race against vortex_tx_timeout
2340 * and boomerang_start_xmit
2341 */
2342 spin_lock(&vp->lock);
2343
John W. Linville62afe592005-11-07 00:58:02 -08002344 status = ioread16(ioaddr + EL3_STATUS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002345
2346 if (vortex_debug > 6)
Alexander Beregalov39738e12009-05-26 12:35:26 +00002347 pr_debug("boomerang_interrupt. status=0x%4x\n", status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002348
2349 if ((status & IntLatch) == 0)
2350 goto handler_exit; /* No interrupt: shared IRQs can cause this */
2351
2352 if (status == 0xffff) { /* h/w no longer present (hotplug)? */
2353 if (vortex_debug > 1)
Alexander Beregalov39738e12009-05-26 12:35:26 +00002354 pr_debug("boomerang_interrupt(1): status = 0xffff\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002355 goto handler_exit;
2356 }
2357
2358 if (status & IntReq) {
2359 status |= vp->deferred;
2360 vp->deferred = 0;
2361 }
2362
2363 if (vortex_debug > 4)
Alexander Beregalov39738e12009-05-26 12:35:26 +00002364 pr_debug("%s: interrupt, status %4.4x, latency %d ticks.\n",
John W. Linville62afe592005-11-07 00:58:02 -08002365 dev->name, status, ioread8(ioaddr + Timer));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002366 do {
2367 if (vortex_debug > 5)
Alexander Beregalov39738e12009-05-26 12:35:26 +00002368 pr_debug("%s: In interrupt loop, status %4.4x.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002369 dev->name, status);
2370 if (status & UpComplete) {
John W. Linville62afe592005-11-07 00:58:02 -08002371 iowrite16(AckIntr | UpComplete, ioaddr + EL3_CMD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002372 if (vortex_debug > 5)
Alexander Beregalov39738e12009-05-26 12:35:26 +00002373 pr_debug("boomerang_interrupt->boomerang_rx\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002374 boomerang_rx(dev);
2375 }
2376
2377 if (status & DownComplete) {
2378 unsigned int dirty_tx = vp->dirty_tx;
2379
John W. Linville62afe592005-11-07 00:58:02 -08002380 iowrite16(AckIntr | DownComplete, ioaddr + EL3_CMD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002381 while (vp->cur_tx - dirty_tx > 0) {
2382 int entry = dirty_tx % TX_RING_SIZE;
2383#if 1 /* AKPM: the latter is faster, but cyclone-only */
John W. Linville62afe592005-11-07 00:58:02 -08002384 if (ioread32(ioaddr + DownListPtr) ==
Linus Torvalds1da177e2005-04-16 15:20:36 -07002385 vp->tx_ring_dma + entry * sizeof(struct boom_tx_desc))
2386 break; /* It still hasn't been processed. */
2387#else
2388 if ((vp->tx_ring[entry].status & DN_COMPLETE) == 0)
2389 break; /* It still hasn't been processed. */
2390#endif
Jeff Garzik6aa20a22006-09-13 13:24:59 -04002391
Linus Torvalds1da177e2005-04-16 15:20:36 -07002392 if (vp->tx_skbuff[entry]) {
2393 struct sk_buff *skb = vp->tx_skbuff[entry];
Jeff Garzik6aa20a22006-09-13 13:24:59 -04002394#if DO_ZEROCOPY
Linus Torvalds1da177e2005-04-16 15:20:36 -07002395 int i;
2396 for (i=0; i<=skb_shinfo(skb)->nr_frags; i++)
2397 pci_unmap_single(VORTEX_PCI(vp),
2398 le32_to_cpu(vp->tx_ring[entry].frag[i].addr),
2399 le32_to_cpu(vp->tx_ring[entry].frag[i].length)&0xFFF,
2400 PCI_DMA_TODEVICE);
2401#else
2402 pci_unmap_single(VORTEX_PCI(vp),
2403 le32_to_cpu(vp->tx_ring[entry].addr), skb->len, PCI_DMA_TODEVICE);
2404#endif
2405 dev_kfree_skb_irq(skb);
2406 vp->tx_skbuff[entry] = NULL;
2407 } else {
Alexander Beregalov39738e12009-05-26 12:35:26 +00002408 pr_debug("boomerang_interrupt: no skb!\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002409 }
Paulius Zaleckas1daad052008-05-05 14:01:29 +02002410 /* dev->stats.tx_packets++; Counted below. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002411 dirty_tx++;
2412 }
2413 vp->dirty_tx = dirty_tx;
2414 if (vp->cur_tx - dirty_tx <= TX_RING_SIZE - 1) {
2415 if (vortex_debug > 6)
Alexander Beregalov39738e12009-05-26 12:35:26 +00002416 pr_debug("boomerang_interrupt: wake queue\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002417 netif_wake_queue (dev);
2418 }
2419 }
2420
2421 /* Check for all uncommon interrupts at once. */
2422 if (status & (HostError | RxEarly | StatsFull | TxComplete | IntReq))
2423 vortex_error(dev, status);
2424
2425 if (--work_done < 0) {
Alexander Beregalov39738e12009-05-26 12:35:26 +00002426 pr_warning("%s: Too much work in interrupt, status %4.4x.\n",
2427 dev->name, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002428 /* Disable all pending interrupts. */
2429 do {
2430 vp->deferred |= status;
John W. Linville62afe592005-11-07 00:58:02 -08002431 iowrite16(SetStatusEnb | (~vp->deferred & vp->status_enable),
Linus Torvalds1da177e2005-04-16 15:20:36 -07002432 ioaddr + EL3_CMD);
John W. Linville62afe592005-11-07 00:58:02 -08002433 iowrite16(AckIntr | (vp->deferred & 0x7ff), ioaddr + EL3_CMD);
2434 } while ((status = ioread16(ioaddr + EL3_CMD)) & IntLatch);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002435 /* The timer will reenable interrupts. */
2436 mod_timer(&vp->timer, jiffies + 1*HZ);
2437 break;
2438 }
2439 /* Acknowledge the IRQ. */
John W. Linville62afe592005-11-07 00:58:02 -08002440 iowrite16(AckIntr | IntReq | IntLatch, ioaddr + EL3_CMD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002441 if (vp->cb_fn_base) /* The PCMCIA people are idiots. */
John W. Linville62afe592005-11-07 00:58:02 -08002442 iowrite32(0x8000, vp->cb_fn_base + 4);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002443
John W. Linville62afe592005-11-07 00:58:02 -08002444 } while ((status = ioread16(ioaddr + EL3_STATUS)) & IntLatch);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002445
2446 if (vortex_debug > 4)
Alexander Beregalov39738e12009-05-26 12:35:26 +00002447 pr_debug("%s: exiting interrupt, status %4.4x.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002448 dev->name, status);
2449handler_exit:
2450 spin_unlock(&vp->lock);
2451 return IRQ_HANDLED;
2452}
2453
2454static int vortex_rx(struct net_device *dev)
2455{
2456 struct vortex_private *vp = netdev_priv(dev);
John W. Linville62afe592005-11-07 00:58:02 -08002457 void __iomem *ioaddr = vp->ioaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002458 int i;
2459 short rx_status;
2460
2461 if (vortex_debug > 5)
Alexander Beregalov39738e12009-05-26 12:35:26 +00002462 pr_debug("vortex_rx(): status %4.4x, rx_status %4.4x.\n",
John W. Linville62afe592005-11-07 00:58:02 -08002463 ioread16(ioaddr+EL3_STATUS), ioread16(ioaddr+RxStatus));
2464 while ((rx_status = ioread16(ioaddr + RxStatus)) > 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002465 if (rx_status & 0x4000) { /* Error, update stats. */
John W. Linville62afe592005-11-07 00:58:02 -08002466 unsigned char rx_error = ioread8(ioaddr + RxErrors);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002467 if (vortex_debug > 2)
Alexander Beregalov39738e12009-05-26 12:35:26 +00002468 pr_debug(" Rx error: status %2.2x.\n", rx_error);
Paulius Zaleckas1daad052008-05-05 14:01:29 +02002469 dev->stats.rx_errors++;
2470 if (rx_error & 0x01) dev->stats.rx_over_errors++;
2471 if (rx_error & 0x02) dev->stats.rx_length_errors++;
2472 if (rx_error & 0x04) dev->stats.rx_frame_errors++;
2473 if (rx_error & 0x08) dev->stats.rx_crc_errors++;
2474 if (rx_error & 0x10) dev->stats.rx_length_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002475 } else {
2476 /* The packet length: up to 4.5K!. */
2477 int pkt_len = rx_status & 0x1fff;
2478 struct sk_buff *skb;
2479
2480 skb = dev_alloc_skb(pkt_len + 5);
2481 if (vortex_debug > 4)
Alexander Beregalov39738e12009-05-26 12:35:26 +00002482 pr_debug("Receiving packet size %d status %4.4x.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002483 pkt_len, rx_status);
2484 if (skb != NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002485 skb_reserve(skb, 2); /* Align IP on 16 byte boundaries */
2486 /* 'skb_put()' points to the start of sk_buff data area. */
2487 if (vp->bus_master &&
John W. Linville62afe592005-11-07 00:58:02 -08002488 ! (ioread16(ioaddr + Wn7_MasterStatus) & 0x8000)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002489 dma_addr_t dma = pci_map_single(VORTEX_PCI(vp), skb_put(skb, pkt_len),
2490 pkt_len, PCI_DMA_FROMDEVICE);
John W. Linville62afe592005-11-07 00:58:02 -08002491 iowrite32(dma, ioaddr + Wn7_MasterAddr);
2492 iowrite16((skb->len + 3) & ~3, ioaddr + Wn7_MasterLen);
2493 iowrite16(StartDMAUp, ioaddr + EL3_CMD);
2494 while (ioread16(ioaddr + Wn7_MasterStatus) & 0x8000)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002495 ;
2496 pci_unmap_single(VORTEX_PCI(vp), dma, pkt_len, PCI_DMA_FROMDEVICE);
2497 } else {
John W. Linville62afe592005-11-07 00:58:02 -08002498 ioread32_rep(ioaddr + RX_FIFO,
2499 skb_put(skb, pkt_len),
2500 (pkt_len + 3) >> 2);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002501 }
John W. Linville62afe592005-11-07 00:58:02 -08002502 iowrite16(RxDiscard, ioaddr + EL3_CMD); /* Pop top Rx packet. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002503 skb->protocol = eth_type_trans(skb, dev);
2504 netif_rx(skb);
Paulius Zaleckas1daad052008-05-05 14:01:29 +02002505 dev->stats.rx_packets++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002506 /* Wait a limited time to go to next packet. */
2507 for (i = 200; i >= 0; i--)
John W. Linville62afe592005-11-07 00:58:02 -08002508 if ( ! (ioread16(ioaddr + EL3_STATUS) & CmdInProgress))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002509 break;
2510 continue;
2511 } else if (vortex_debug > 0)
Alexander Beregalov39738e12009-05-26 12:35:26 +00002512 pr_notice("%s: No memory to allocate a sk_buff of size %d.\n",
2513 dev->name, pkt_len);
Paulius Zaleckas1daad052008-05-05 14:01:29 +02002514 dev->stats.rx_dropped++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002515 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002516 issue_and_wait(dev, RxDiscard);
2517 }
2518
2519 return 0;
2520}
2521
2522static int
2523boomerang_rx(struct net_device *dev)
2524{
2525 struct vortex_private *vp = netdev_priv(dev);
2526 int entry = vp->cur_rx % RX_RING_SIZE;
John W. Linville62afe592005-11-07 00:58:02 -08002527 void __iomem *ioaddr = vp->ioaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002528 int rx_status;
2529 int rx_work_limit = vp->dirty_rx + RX_RING_SIZE - vp->cur_rx;
2530
2531 if (vortex_debug > 5)
Alexander Beregalov39738e12009-05-26 12:35:26 +00002532 pr_debug("boomerang_rx(): status %4.4x\n", ioread16(ioaddr+EL3_STATUS));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002533
2534 while ((rx_status = le32_to_cpu(vp->rx_ring[entry].status)) & RxDComplete){
2535 if (--rx_work_limit < 0)
2536 break;
2537 if (rx_status & RxDError) { /* Error, update stats. */
2538 unsigned char rx_error = rx_status >> 16;
2539 if (vortex_debug > 2)
Alexander Beregalov39738e12009-05-26 12:35:26 +00002540 pr_debug(" Rx error: status %2.2x.\n", rx_error);
Paulius Zaleckas1daad052008-05-05 14:01:29 +02002541 dev->stats.rx_errors++;
2542 if (rx_error & 0x01) dev->stats.rx_over_errors++;
2543 if (rx_error & 0x02) dev->stats.rx_length_errors++;
2544 if (rx_error & 0x04) dev->stats.rx_frame_errors++;
2545 if (rx_error & 0x08) dev->stats.rx_crc_errors++;
2546 if (rx_error & 0x10) dev->stats.rx_length_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002547 } else {
2548 /* The packet length: up to 4.5K!. */
2549 int pkt_len = rx_status & 0x1fff;
2550 struct sk_buff *skb;
2551 dma_addr_t dma = le32_to_cpu(vp->rx_ring[entry].addr);
2552
2553 if (vortex_debug > 4)
Alexander Beregalov39738e12009-05-26 12:35:26 +00002554 pr_debug("Receiving packet size %d status %4.4x.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002555 pkt_len, rx_status);
2556
2557 /* Check if the packet is long enough to just accept without
2558 copying to a properly sized skbuff. */
Al Virocc2d6592007-08-22 21:34:46 -04002559 if (pkt_len < rx_copybreak && (skb = dev_alloc_skb(pkt_len + 2)) != NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002560 skb_reserve(skb, 2); /* Align IP on 16 byte boundaries */
2561 pci_dma_sync_single_for_cpu(VORTEX_PCI(vp), dma, PKT_BUF_SZ, PCI_DMA_FROMDEVICE);
2562 /* 'skb_put()' points to the start of sk_buff data area. */
2563 memcpy(skb_put(skb, pkt_len),
David S. Miller689be432005-06-28 15:25:31 -07002564 vp->rx_skbuff[entry]->data,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002565 pkt_len);
2566 pci_dma_sync_single_for_device(VORTEX_PCI(vp), dma, PKT_BUF_SZ, PCI_DMA_FROMDEVICE);
2567 vp->rx_copy++;
2568 } else {
2569 /* Pass up the skbuff already on the Rx ring. */
2570 skb = vp->rx_skbuff[entry];
2571 vp->rx_skbuff[entry] = NULL;
2572 skb_put(skb, pkt_len);
2573 pci_unmap_single(VORTEX_PCI(vp), dma, PKT_BUF_SZ, PCI_DMA_FROMDEVICE);
2574 vp->rx_nocopy++;
2575 }
2576 skb->protocol = eth_type_trans(skb, dev);
2577 { /* Use hardware checksum info. */
2578 int csum_bits = rx_status & 0xee000000;
2579 if (csum_bits &&
2580 (csum_bits == (IPChksumValid | TCPChksumValid) ||
2581 csum_bits == (IPChksumValid | UDPChksumValid))) {
2582 skb->ip_summed = CHECKSUM_UNNECESSARY;
2583 vp->rx_csumhits++;
2584 }
2585 }
2586 netif_rx(skb);
Paulius Zaleckas1daad052008-05-05 14:01:29 +02002587 dev->stats.rx_packets++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002588 }
2589 entry = (++vp->cur_rx) % RX_RING_SIZE;
2590 }
2591 /* Refill the Rx ring buffers. */
2592 for (; vp->cur_rx - vp->dirty_rx > 0; vp->dirty_rx++) {
2593 struct sk_buff *skb;
2594 entry = vp->dirty_rx % RX_RING_SIZE;
2595 if (vp->rx_skbuff[entry] == NULL) {
Eric Dumazet89d71a62009-10-13 05:34:20 +00002596 skb = netdev_alloc_skb_ip_align(dev, PKT_BUF_SZ);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002597 if (skb == NULL) {
2598 static unsigned long last_jif;
Marcelo Feitoza Parisiff5688a2006-01-09 18:37:15 -08002599 if (time_after(jiffies, last_jif + 10 * HZ)) {
Alexander Beregalov39738e12009-05-26 12:35:26 +00002600 pr_warning("%s: memory shortage\n", dev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002601 last_jif = jiffies;
2602 }
2603 if ((vp->cur_rx - vp->dirty_rx) == RX_RING_SIZE)
2604 mod_timer(&vp->rx_oom_timer, RUN_AT(HZ * 1));
2605 break; /* Bad news! */
2606 }
Stephen Hemminger9a5d34142008-07-25 12:07:22 -07002607
David S. Miller689be432005-06-28 15:25:31 -07002608 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 -07002609 vp->rx_skbuff[entry] = skb;
2610 }
2611 vp->rx_ring[entry].status = 0; /* Clear complete bit. */
John W. Linville62afe592005-11-07 00:58:02 -08002612 iowrite16(UpUnstall, ioaddr + EL3_CMD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002613 }
2614 return 0;
2615}
2616
2617/*
2618 * If we've hit a total OOM refilling the Rx ring we poll once a second
2619 * for some memory. Otherwise there is no way to restart the rx process.
2620 */
2621static void
2622rx_oom_timer(unsigned long arg)
2623{
2624 struct net_device *dev = (struct net_device *)arg;
2625 struct vortex_private *vp = netdev_priv(dev);
2626
2627 spin_lock_irq(&vp->lock);
2628 if ((vp->cur_rx - vp->dirty_rx) == RX_RING_SIZE) /* This test is redundant, but makes me feel good */
2629 boomerang_rx(dev);
2630 if (vortex_debug > 1) {
Alexander Beregalov39738e12009-05-26 12:35:26 +00002631 pr_debug("%s: rx_oom_timer %s\n", dev->name,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002632 ((vp->cur_rx - vp->dirty_rx) != RX_RING_SIZE) ? "succeeded" : "retrying");
2633 }
2634 spin_unlock_irq(&vp->lock);
2635}
2636
2637static void
2638vortex_down(struct net_device *dev, int final_down)
2639{
2640 struct vortex_private *vp = netdev_priv(dev);
John W. Linville62afe592005-11-07 00:58:02 -08002641 void __iomem *ioaddr = vp->ioaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002642
2643 netif_stop_queue (dev);
2644
2645 del_timer_sync(&vp->rx_oom_timer);
2646 del_timer_sync(&vp->timer);
2647
Paulius Zaleckas1daad052008-05-05 14:01:29 +02002648 /* Turn off statistics ASAP. We update dev->stats below. */
John W. Linville62afe592005-11-07 00:58:02 -08002649 iowrite16(StatsDisable, ioaddr + EL3_CMD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002650
2651 /* Disable the receiver and transmitter. */
John W. Linville62afe592005-11-07 00:58:02 -08002652 iowrite16(RxDisable, ioaddr + EL3_CMD);
2653 iowrite16(TxDisable, ioaddr + EL3_CMD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002654
2655 /* Disable receiving 802.1q tagged frames */
2656 set_8021q_mode(dev, 0);
2657
2658 if (dev->if_port == XCVR_10base2)
2659 /* Turn off thinnet power. Green! */
John W. Linville62afe592005-11-07 00:58:02 -08002660 iowrite16(StopCoax, ioaddr + EL3_CMD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002661
John W. Linville62afe592005-11-07 00:58:02 -08002662 iowrite16(SetIntrEnb | 0x0000, ioaddr + EL3_CMD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002663
2664 update_stats(ioaddr, dev);
2665 if (vp->full_bus_master_rx)
John W. Linville62afe592005-11-07 00:58:02 -08002666 iowrite32(0, ioaddr + UpListPtr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002667 if (vp->full_bus_master_tx)
John W. Linville62afe592005-11-07 00:58:02 -08002668 iowrite32(0, ioaddr + DownListPtr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002669
2670 if (final_down && VORTEX_PCI(vp)) {
Daniel Ritz3c8fad12005-05-05 16:15:44 -07002671 vp->pm_state_valid = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002672 pci_save_state(VORTEX_PCI(vp));
2673 acpi_set_WOL(dev);
2674 }
2675}
2676
2677static int
2678vortex_close(struct net_device *dev)
2679{
2680 struct vortex_private *vp = netdev_priv(dev);
John W. Linville62afe592005-11-07 00:58:02 -08002681 void __iomem *ioaddr = vp->ioaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002682 int i;
2683
2684 if (netif_device_present(dev))
2685 vortex_down(dev, 1);
2686
2687 if (vortex_debug > 1) {
Alexander Beregalov39738e12009-05-26 12:35:26 +00002688 pr_debug("%s: vortex_close() status %4.4x, Tx status %2.2x.\n",
John W. Linville62afe592005-11-07 00:58:02 -08002689 dev->name, ioread16(ioaddr + EL3_STATUS), ioread8(ioaddr + TxStatus));
Alexander Beregalov39738e12009-05-26 12:35:26 +00002690 pr_debug("%s: vortex close stats: rx_nocopy %d rx_copy %d"
Linus Torvalds1da177e2005-04-16 15:20:36 -07002691 " tx_queued %d Rx pre-checksummed %d.\n",
2692 dev->name, vp->rx_nocopy, vp->rx_copy, vp->queued_packet, vp->rx_csumhits);
2693 }
2694
2695#if DO_ZEROCOPY
John W. Linville32fb5f02005-11-07 00:58:05 -08002696 if (vp->rx_csumhits &&
2697 (vp->drv_flags & HAS_HWCKSM) == 0 &&
2698 (vp->card_idx >= MAX_UNITS || hw_checksums[vp->card_idx] == -1)) {
Alexander Beregalov39738e12009-05-26 12:35:26 +00002699 pr_warning("%s supports hardware checksums, and we're not using them!\n", dev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002700 }
2701#endif
Jeff Garzik6aa20a22006-09-13 13:24:59 -04002702
Linus Torvalds1da177e2005-04-16 15:20:36 -07002703 free_irq(dev->irq, dev);
2704
2705 if (vp->full_bus_master_rx) { /* Free Boomerang bus master Rx buffers. */
2706 for (i = 0; i < RX_RING_SIZE; i++)
2707 if (vp->rx_skbuff[i]) {
2708 pci_unmap_single( VORTEX_PCI(vp), le32_to_cpu(vp->rx_ring[i].addr),
2709 PKT_BUF_SZ, PCI_DMA_FROMDEVICE);
2710 dev_kfree_skb(vp->rx_skbuff[i]);
2711 vp->rx_skbuff[i] = NULL;
2712 }
2713 }
2714 if (vp->full_bus_master_tx) { /* Free Boomerang bus master Tx buffers. */
2715 for (i = 0; i < TX_RING_SIZE; i++) {
2716 if (vp->tx_skbuff[i]) {
2717 struct sk_buff *skb = vp->tx_skbuff[i];
2718#if DO_ZEROCOPY
2719 int k;
2720
2721 for (k=0; k<=skb_shinfo(skb)->nr_frags; k++)
2722 pci_unmap_single(VORTEX_PCI(vp),
2723 le32_to_cpu(vp->tx_ring[i].frag[k].addr),
2724 le32_to_cpu(vp->tx_ring[i].frag[k].length)&0xFFF,
2725 PCI_DMA_TODEVICE);
2726#else
2727 pci_unmap_single(VORTEX_PCI(vp), le32_to_cpu(vp->tx_ring[i].addr), skb->len, PCI_DMA_TODEVICE);
2728#endif
2729 dev_kfree_skb(skb);
2730 vp->tx_skbuff[i] = NULL;
2731 }
2732 }
2733 }
2734
2735 return 0;
2736}
2737
2738static void
2739dump_tx_ring(struct net_device *dev)
2740{
2741 if (vortex_debug > 0) {
2742 struct vortex_private *vp = netdev_priv(dev);
John W. Linville62afe592005-11-07 00:58:02 -08002743 void __iomem *ioaddr = vp->ioaddr;
Jeff Garzik6aa20a22006-09-13 13:24:59 -04002744
Linus Torvalds1da177e2005-04-16 15:20:36 -07002745 if (vp->full_bus_master_tx) {
2746 int i;
John W. Linville62afe592005-11-07 00:58:02 -08002747 int stalled = ioread32(ioaddr + PktStatus) & 0x04; /* Possible racy. But it's only debug stuff */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002748
Alexander Beregalov39738e12009-05-26 12:35:26 +00002749 pr_err(" Flags; bus-master %d, dirty %d(%d) current %d(%d)\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002750 vp->full_bus_master_tx,
2751 vp->dirty_tx, vp->dirty_tx % TX_RING_SIZE,
2752 vp->cur_tx, vp->cur_tx % TX_RING_SIZE);
Alexander Beregalov39738e12009-05-26 12:35:26 +00002753 pr_err(" Transmit list %8.8x vs. %p.\n",
John W. Linville62afe592005-11-07 00:58:02 -08002754 ioread32(ioaddr + DownListPtr),
Linus Torvalds1da177e2005-04-16 15:20:36 -07002755 &vp->tx_ring[vp->dirty_tx % TX_RING_SIZE]);
2756 issue_and_wait(dev, DownStall);
2757 for (i = 0; i < TX_RING_SIZE; i++) {
Jean Delvare0cb13532009-08-03 21:10:01 -07002758 unsigned int length;
2759
Linus Torvalds1da177e2005-04-16 15:20:36 -07002760#if DO_ZEROCOPY
Jean Delvare0cb13532009-08-03 21:10:01 -07002761 length = le32_to_cpu(vp->tx_ring[i].frag[0].length);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002762#else
Jean Delvare0cb13532009-08-03 21:10:01 -07002763 length = le32_to_cpu(vp->tx_ring[i].length);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002764#endif
Jean Delvare0cb13532009-08-03 21:10:01 -07002765 pr_err(" %d: @%p length %8.8x status %8.8x\n",
2766 i, &vp->tx_ring[i], length,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002767 le32_to_cpu(vp->tx_ring[i].status));
2768 }
2769 if (!stalled)
John W. Linville62afe592005-11-07 00:58:02 -08002770 iowrite16(DownUnstall, ioaddr + EL3_CMD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002771 }
2772 }
2773}
2774
2775static struct net_device_stats *vortex_get_stats(struct net_device *dev)
2776{
2777 struct vortex_private *vp = netdev_priv(dev);
John W. Linville62afe592005-11-07 00:58:02 -08002778 void __iomem *ioaddr = vp->ioaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002779 unsigned long flags;
2780
2781 if (netif_device_present(dev)) { /* AKPM: Used to be netif_running */
2782 spin_lock_irqsave (&vp->lock, flags);
John W. Linville62afe592005-11-07 00:58:02 -08002783 update_stats(ioaddr, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002784 spin_unlock_irqrestore (&vp->lock, flags);
2785 }
Paulius Zaleckas1daad052008-05-05 14:01:29 +02002786 return &dev->stats;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002787}
2788
2789/* Update statistics.
2790 Unlike with the EL3 we need not worry about interrupts changing
2791 the window setting from underneath us, but we must still guard
2792 against a race condition with a StatsUpdate interrupt updating the
2793 table. This is done by checking that the ASM (!) code generated uses
2794 atomic updates with '+='.
2795 */
John W. Linville62afe592005-11-07 00:58:02 -08002796static void update_stats(void __iomem *ioaddr, struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002797{
2798 struct vortex_private *vp = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002799
Linus Torvalds1da177e2005-04-16 15:20:36 -07002800 /* Unlike the 3c5x9 we need not turn off stats updates while reading. */
2801 /* Switch to the stats window, and read everything. */
Ben Hutchingsa095cfc2010-06-23 13:54:31 +00002802 dev->stats.tx_carrier_errors += window_read8(vp, 6, 0);
2803 dev->stats.tx_heartbeat_errors += window_read8(vp, 6, 1);
2804 dev->stats.tx_window_errors += window_read8(vp, 6, 4);
2805 dev->stats.rx_fifo_errors += window_read8(vp, 6, 5);
2806 dev->stats.tx_packets += window_read8(vp, 6, 6);
2807 dev->stats.tx_packets += (window_read8(vp, 6, 9) &
2808 0x30) << 4;
2809 /* Rx packets */ window_read8(vp, 6, 7); /* Must read to clear */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002810 /* Don't bother with register 9, an extension of registers 6&7.
2811 If we do use the 6&7 values the atomic update assumption above
2812 is invalid. */
Ben Hutchingsa095cfc2010-06-23 13:54:31 +00002813 dev->stats.rx_bytes += window_read16(vp, 6, 10);
2814 dev->stats.tx_bytes += window_read16(vp, 6, 12);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002815 /* Extra stats for get_ethtool_stats() */
Ben Hutchingsa095cfc2010-06-23 13:54:31 +00002816 vp->xstats.tx_multiple_collisions += window_read8(vp, 6, 2);
2817 vp->xstats.tx_single_collisions += window_read8(vp, 6, 3);
2818 vp->xstats.tx_deferred += window_read8(vp, 6, 8);
2819 vp->xstats.rx_bad_ssd += window_read8(vp, 4, 12);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002820
Paulius Zaleckas1daad052008-05-05 14:01:29 +02002821 dev->stats.collisions = vp->xstats.tx_multiple_collisions
Steffen Klassert8d1d0342006-02-03 03:03:57 -08002822 + vp->xstats.tx_single_collisions
2823 + vp->xstats.tx_max_collisions;
2824
Linus Torvalds1da177e2005-04-16 15:20:36 -07002825 {
Ben Hutchingsa095cfc2010-06-23 13:54:31 +00002826 u8 up = window_read8(vp, 4, 13);
Paulius Zaleckas1daad052008-05-05 14:01:29 +02002827 dev->stats.rx_bytes += (up & 0x0f) << 16;
2828 dev->stats.tx_bytes += (up & 0xf0) << 12;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002829 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002830}
2831
2832static int vortex_nway_reset(struct net_device *dev)
2833{
2834 struct vortex_private *vp = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002835
Ben Hutchingsde847272010-06-29 15:26:56 +00002836 return mii_nway_restart(&vp->mii);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002837}
2838
Linus Torvalds1da177e2005-04-16 15:20:36 -07002839static int vortex_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
2840{
2841 struct vortex_private *vp = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002842
Ben Hutchingsde847272010-06-29 15:26:56 +00002843 return mii_ethtool_gset(&vp->mii, cmd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002844}
2845
2846static int vortex_set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
2847{
2848 struct vortex_private *vp = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002849
Ben Hutchingsde847272010-06-29 15:26:56 +00002850 return mii_ethtool_sset(&vp->mii, cmd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002851}
2852
2853static u32 vortex_get_msglevel(struct net_device *dev)
2854{
2855 return vortex_debug;
2856}
2857
2858static void vortex_set_msglevel(struct net_device *dev, u32 dbg)
2859{
2860 vortex_debug = dbg;
2861}
2862
Jeff Garzikb9f2c042007-10-03 18:07:32 -07002863static int vortex_get_sset_count(struct net_device *dev, int sset)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002864{
Jeff Garzikb9f2c042007-10-03 18:07:32 -07002865 switch (sset) {
2866 case ETH_SS_STATS:
2867 return VORTEX_NUM_STATS;
2868 default:
2869 return -EOPNOTSUPP;
2870 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002871}
2872
2873static void vortex_get_ethtool_stats(struct net_device *dev,
2874 struct ethtool_stats *stats, u64 *data)
2875{
2876 struct vortex_private *vp = netdev_priv(dev);
John W. Linville62afe592005-11-07 00:58:02 -08002877 void __iomem *ioaddr = vp->ioaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002878 unsigned long flags;
2879
2880 spin_lock_irqsave(&vp->lock, flags);
John W. Linville62afe592005-11-07 00:58:02 -08002881 update_stats(ioaddr, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002882 spin_unlock_irqrestore(&vp->lock, flags);
2883
2884 data[0] = vp->xstats.tx_deferred;
Steffen Klassert8d1d0342006-02-03 03:03:57 -08002885 data[1] = vp->xstats.tx_max_collisions;
2886 data[2] = vp->xstats.tx_multiple_collisions;
2887 data[3] = vp->xstats.tx_single_collisions;
2888 data[4] = vp->xstats.rx_bad_ssd;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002889}
2890
2891
2892static void vortex_get_strings(struct net_device *dev, u32 stringset, u8 *data)
2893{
2894 switch (stringset) {
2895 case ETH_SS_STATS:
2896 memcpy(data, &ethtool_stats_keys, sizeof(ethtool_stats_keys));
2897 break;
2898 default:
2899 WARN_ON(1);
2900 break;
2901 }
2902}
2903
2904static void vortex_get_drvinfo(struct net_device *dev,
2905 struct ethtool_drvinfo *info)
2906{
2907 struct vortex_private *vp = netdev_priv(dev);
2908
2909 strcpy(info->driver, DRV_NAME);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002910 if (VORTEX_PCI(vp)) {
2911 strcpy(info->bus_info, pci_name(VORTEX_PCI(vp)));
2912 } else {
2913 if (VORTEX_EISA(vp))
Stephen Hemminger86de79b2009-02-26 10:19:24 +00002914 strcpy(info->bus_info, dev_name(vp->gendev));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002915 else
2916 sprintf(info->bus_info, "EISA 0x%lx %d",
2917 dev->base_addr, dev->irq);
2918 }
2919}
2920
Jeff Garzik7282d492006-09-13 14:30:00 -04002921static const struct ethtool_ops vortex_ethtool_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002922 .get_drvinfo = vortex_get_drvinfo,
2923 .get_strings = vortex_get_strings,
2924 .get_msglevel = vortex_get_msglevel,
2925 .set_msglevel = vortex_set_msglevel,
2926 .get_ethtool_stats = vortex_get_ethtool_stats,
Jeff Garzikb9f2c042007-10-03 18:07:32 -07002927 .get_sset_count = vortex_get_sset_count,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002928 .get_settings = vortex_get_settings,
2929 .set_settings = vortex_set_settings,
Steffen Klassert373a6882006-03-26 01:37:41 -08002930 .get_link = ethtool_op_get_link,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002931 .nway_reset = vortex_nway_reset,
2932};
2933
2934#ifdef CONFIG_PCI
2935/*
2936 * Must power the device up to do MDIO operations
2937 */
2938static int vortex_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
2939{
2940 int err;
2941 struct vortex_private *vp = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002942 unsigned long flags;
Al Virocc2d6592007-08-22 21:34:46 -04002943 pci_power_t state = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002944
2945 if(VORTEX_PCI(vp))
2946 state = VORTEX_PCI(vp)->current_state;
2947
2948 /* The kernel core really should have pci_get_power_state() */
2949
2950 if(state != 0)
2951 pci_set_power_state(VORTEX_PCI(vp), PCI_D0);
2952 spin_lock_irqsave(&vp->lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002953 err = generic_mii_ioctl(&vp->mii, if_mii(rq), cmd, NULL);
2954 spin_unlock_irqrestore(&vp->lock, flags);
2955 if(state != 0)
2956 pci_set_power_state(VORTEX_PCI(vp), state);
2957
2958 return err;
2959}
2960#endif
2961
2962
2963/* Pre-Cyclone chips have no documented multicast filter, so the only
2964 multicast setting is to receive all multicast frames. At least
2965 the chip has a very clean way to set the mode, unlike many others. */
2966static void set_rx_mode(struct net_device *dev)
2967{
John W. Linville62afe592005-11-07 00:58:02 -08002968 struct vortex_private *vp = netdev_priv(dev);
2969 void __iomem *ioaddr = vp->ioaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002970 int new_mode;
2971
2972 if (dev->flags & IFF_PROMISC) {
Andy Gospodarekd5b20692006-09-11 17:39:18 -04002973 if (vortex_debug > 3)
Alexander Beregalov39738e12009-05-26 12:35:26 +00002974 pr_notice("%s: Setting promiscuous mode.\n", dev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002975 new_mode = SetRxFilter|RxStation|RxMulticast|RxBroadcast|RxProm;
Jiri Pirko59ce25d2010-02-17 23:12:15 +00002976 } else if (!netdev_mc_empty(dev) || dev->flags & IFF_ALLMULTI) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002977 new_mode = SetRxFilter|RxStation|RxMulticast|RxBroadcast;
2978 } else
2979 new_mode = SetRxFilter | RxStation | RxBroadcast;
2980
John W. Linville62afe592005-11-07 00:58:02 -08002981 iowrite16(new_mode, ioaddr + EL3_CMD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002982}
2983
2984#if defined(CONFIG_VLAN_8021Q) || defined(CONFIG_VLAN_8021Q_MODULE)
2985/* Setup the card so that it can receive frames with an 802.1q VLAN tag.
2986 Note that this must be done after each RxReset due to some backwards
2987 compatibility logic in the Cyclone and Tornado ASICs */
2988
2989/* The Ethernet Type used for 802.1q tagged frames */
2990#define VLAN_ETHER_TYPE 0x8100
2991
2992static void set_8021q_mode(struct net_device *dev, int enable)
2993{
2994 struct vortex_private *vp = netdev_priv(dev);
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
Ben Hutchingsa095cfc2010-06-23 13:54:31 +00003005 window_write16(vp, max_pkt_size, 3, Wn3_MaxPktSize);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003006
3007 /* set VlanEtherType to let the hardware checksumming
3008 treat tagged frames correctly */
Ben Hutchingsa095cfc2010-06-23 13:54:31 +00003009 window_write16(vp, VLAN_ETHER_TYPE, 7, Wn7_VlanEtherType);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003010 } else {
3011 /* on older cards we have to enable large frames */
3012
3013 vp->large_frames = dev->mtu > 1500 || enable;
3014
Ben Hutchingsa095cfc2010-06-23 13:54:31 +00003015 mac_ctrl = window_read16(vp, 3, Wn3_MAC_Ctrl);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003016 if (vp->large_frames)
3017 mac_ctrl |= 0x40;
3018 else
3019 mac_ctrl &= ~0x40;
Ben Hutchingsa095cfc2010-06-23 13:54:31 +00003020 window_write16(vp, mac_ctrl, 3, Wn3_MAC_Ctrl);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003021 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003022}
3023#else
3024
3025static void set_8021q_mode(struct net_device *dev, int enable)
3026{
3027}
3028
3029
3030#endif
3031
3032/* MII transceiver control section.
3033 Read and write the MII registers using software-generated serial
3034 MDIO protocol. See the MII specifications or DP83840A data sheet
3035 for details. */
3036
3037/* The maximum data clock rate is 2.5 Mhz. The minimum timing is usually
3038 met by back-to-back PCI I/O cycles, but we insert a delay to avoid
3039 "overclocking" issues. */
Ben Hutchingsa095cfc2010-06-23 13:54:31 +00003040static void mdio_delay(struct vortex_private *vp)
3041{
3042 window_read32(vp, 4, Wn4_PhysicalMgmt);
3043}
Linus Torvalds1da177e2005-04-16 15:20:36 -07003044
3045#define MDIO_SHIFT_CLK 0x01
3046#define MDIO_DIR_WRITE 0x04
3047#define MDIO_DATA_WRITE0 (0x00 | MDIO_DIR_WRITE)
3048#define MDIO_DATA_WRITE1 (0x02 | MDIO_DIR_WRITE)
3049#define MDIO_DATA_READ 0x02
3050#define MDIO_ENB_IN 0x00
3051
3052/* Generate the preamble required for initial synchronization and
3053 a few older transceivers. */
Ben Hutchingsa095cfc2010-06-23 13:54:31 +00003054static void mdio_sync(struct vortex_private *vp, int bits)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003055{
Linus Torvalds1da177e2005-04-16 15:20:36 -07003056 /* Establish sync by sending at least 32 logic ones. */
3057 while (-- bits >= 0) {
Ben Hutchingsa095cfc2010-06-23 13:54:31 +00003058 window_write16(vp, MDIO_DATA_WRITE1, 4, Wn4_PhysicalMgmt);
3059 mdio_delay(vp);
3060 window_write16(vp, MDIO_DATA_WRITE1 | MDIO_SHIFT_CLK,
3061 4, Wn4_PhysicalMgmt);
3062 mdio_delay(vp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003063 }
3064}
3065
3066static int mdio_read(struct net_device *dev, int phy_id, int location)
3067{
3068 int i;
John W. Linville62afe592005-11-07 00:58:02 -08003069 struct vortex_private *vp = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003070 int read_cmd = (0xf6 << 10) | (phy_id << 5) | location;
3071 unsigned int retval = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003072
Ben Hutchingsde847272010-06-29 15:26:56 +00003073 spin_lock_bh(&vp->mii_lock);
3074
Linus Torvalds1da177e2005-04-16 15:20:36 -07003075 if (mii_preamble_required)
Ben Hutchingsa095cfc2010-06-23 13:54:31 +00003076 mdio_sync(vp, 32);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003077
3078 /* Shift the read command bits out. */
3079 for (i = 14; i >= 0; i--) {
3080 int dataval = (read_cmd&(1<<i)) ? MDIO_DATA_WRITE1 : MDIO_DATA_WRITE0;
Ben Hutchingsa095cfc2010-06-23 13:54:31 +00003081 window_write16(vp, dataval, 4, Wn4_PhysicalMgmt);
3082 mdio_delay(vp);
3083 window_write16(vp, dataval | MDIO_SHIFT_CLK,
3084 4, Wn4_PhysicalMgmt);
3085 mdio_delay(vp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003086 }
3087 /* Read the two transition, 16 data, and wire-idle bits. */
3088 for (i = 19; i > 0; i--) {
Ben Hutchingsa095cfc2010-06-23 13:54:31 +00003089 window_write16(vp, MDIO_ENB_IN, 4, Wn4_PhysicalMgmt);
3090 mdio_delay(vp);
3091 retval = (retval << 1) |
3092 ((window_read16(vp, 4, Wn4_PhysicalMgmt) &
3093 MDIO_DATA_READ) ? 1 : 0);
3094 window_write16(vp, MDIO_ENB_IN | MDIO_SHIFT_CLK,
3095 4, Wn4_PhysicalMgmt);
3096 mdio_delay(vp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003097 }
Ben Hutchingsde847272010-06-29 15:26:56 +00003098
3099 spin_unlock_bh(&vp->mii_lock);
3100
Linus Torvalds1da177e2005-04-16 15:20:36 -07003101 return retval & 0x20000 ? 0xffff : retval>>1 & 0xffff;
3102}
3103
3104static void mdio_write(struct net_device *dev, int phy_id, int location, int value)
3105{
John W. Linville62afe592005-11-07 00:58:02 -08003106 struct vortex_private *vp = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003107 int write_cmd = 0x50020000 | (phy_id << 23) | (location << 18) | value;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003108 int i;
3109
Ben Hutchingsde847272010-06-29 15:26:56 +00003110 spin_lock_bh(&vp->mii_lock);
3111
Linus Torvalds1da177e2005-04-16 15:20:36 -07003112 if (mii_preamble_required)
Ben Hutchingsa095cfc2010-06-23 13:54:31 +00003113 mdio_sync(vp, 32);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003114
3115 /* Shift the command bits out. */
3116 for (i = 31; i >= 0; i--) {
3117 int dataval = (write_cmd&(1<<i)) ? MDIO_DATA_WRITE1 : MDIO_DATA_WRITE0;
Ben Hutchingsa095cfc2010-06-23 13:54:31 +00003118 window_write16(vp, dataval, 4, Wn4_PhysicalMgmt);
3119 mdio_delay(vp);
3120 window_write16(vp, dataval | MDIO_SHIFT_CLK,
3121 4, Wn4_PhysicalMgmt);
3122 mdio_delay(vp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003123 }
3124 /* Leave the interface idle. */
3125 for (i = 1; i >= 0; i--) {
Ben Hutchingsa095cfc2010-06-23 13:54:31 +00003126 window_write16(vp, MDIO_ENB_IN, 4, Wn4_PhysicalMgmt);
3127 mdio_delay(vp);
3128 window_write16(vp, MDIO_ENB_IN | MDIO_SHIFT_CLK,
3129 4, Wn4_PhysicalMgmt);
3130 mdio_delay(vp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003131 }
Ben Hutchingsde847272010-06-29 15:26:56 +00003132
3133 spin_unlock_bh(&vp->mii_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003134}
Steffen Klasserta880c4c2006-03-26 01:37:43 -08003135
Linus Torvalds1da177e2005-04-16 15:20:36 -07003136/* ACPI: Advanced Configuration and Power Interface. */
3137/* Set Wake-On-LAN mode and put the board into D3 (power-down) state. */
3138static void acpi_set_WOL(struct net_device *dev)
3139{
3140 struct vortex_private *vp = netdev_priv(dev);
John W. Linville62afe592005-11-07 00:58:02 -08003141 void __iomem *ioaddr = vp->ioaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003142
Steffen Klassertc17931c2009-01-09 03:53:17 +00003143 device_set_wakeup_enable(vp->gendev, vp->enable_wol);
3144
Linus Torvalds1da177e2005-04-16 15:20:36 -07003145 if (vp->enable_wol) {
3146 /* Power up on: 1==Downloaded Filter, 2==Magic Packets, 4==Link Status. */
Ben Hutchingsa095cfc2010-06-23 13:54:31 +00003147 window_write16(vp, 2, 7, 0x0c);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003148 /* The RxFilter must accept the WOL frames. */
John W. Linville62afe592005-11-07 00:58:02 -08003149 iowrite16(SetRxFilter|RxStation|RxMulticast|RxBroadcast, ioaddr + EL3_CMD);
3150 iowrite16(RxEnable, ioaddr + EL3_CMD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003151
Steffen Klassert1a1769f2007-10-16 14:24:09 -07003152 if (pci_enable_wake(VORTEX_PCI(vp), PCI_D3hot, 1)) {
Alexander Beregalov39738e12009-05-26 12:35:26 +00003153 pr_info("%s: WOL not supported.\n", pci_name(VORTEX_PCI(vp)));
Steffen Klassert1a1769f2007-10-16 14:24:09 -07003154
3155 vp->enable_wol = 0;
3156 return;
3157 }
Daniel Ritz3c8fad12005-05-05 16:15:44 -07003158
3159 /* Change the power state to D3; RxEnable doesn't take effect. */
3160 pci_set_power_state(VORTEX_PCI(vp), PCI_D3hot);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003161 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003162}
3163
3164
Steffen Klasserta880c4c2006-03-26 01:37:43 -08003165static void __devexit vortex_remove_one(struct pci_dev *pdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003166{
3167 struct net_device *dev = pci_get_drvdata(pdev);
3168 struct vortex_private *vp;
3169
3170 if (!dev) {
Alexander Beregalov39738e12009-05-26 12:35:26 +00003171 pr_err("vortex_remove_one called for Compaq device!\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07003172 BUG();
3173 }
3174
3175 vp = netdev_priv(dev);
3176
John W. Linville62afe592005-11-07 00:58:02 -08003177 if (vp->cb_fn_base)
3178 pci_iounmap(VORTEX_PCI(vp), vp->cb_fn_base);
3179
Linus Torvalds1da177e2005-04-16 15:20:36 -07003180 unregister_netdev(dev);
3181
3182 if (VORTEX_PCI(vp)) {
3183 pci_set_power_state(VORTEX_PCI(vp), PCI_D0); /* Go active */
3184 if (vp->pm_state_valid)
3185 pci_restore_state(VORTEX_PCI(vp));
3186 pci_disable_device(VORTEX_PCI(vp));
3187 }
3188 /* Should really use issue_and_wait() here */
John W. Linville62afe592005-11-07 00:58:02 -08003189 iowrite16(TotalReset | ((vp->drv_flags & EEPROM_RESET) ? 0x04 : 0x14),
3190 vp->ioaddr + EL3_CMD);
3191
3192 pci_iounmap(VORTEX_PCI(vp), vp->ioaddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003193
3194 pci_free_consistent(pdev,
3195 sizeof(struct boom_rx_desc) * RX_RING_SIZE
3196 + sizeof(struct boom_tx_desc) * TX_RING_SIZE,
3197 vp->rx_ring,
3198 vp->rx_ring_dma);
3199 if (vp->must_free_region)
3200 release_region(dev->base_addr, vp->io_size);
3201 free_netdev(dev);
3202}
3203
3204
3205static struct pci_driver vortex_driver = {
3206 .name = "3c59x",
3207 .probe = vortex_init_one,
3208 .remove = __devexit_p(vortex_remove_one),
3209 .id_table = vortex_pci_tbl,
Anton Vorontsov7bfc4ab2009-09-30 20:11:11 -07003210 .driver.pm = VORTEX_PM_OPS,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003211};
3212
3213
3214static int vortex_have_pci;
3215static int vortex_have_eisa;
3216
3217
Steffen Klasserta880c4c2006-03-26 01:37:43 -08003218static int __init vortex_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003219{
3220 int pci_rc, eisa_rc;
3221
Jeff Garzik29917622006-08-19 17:48:59 -04003222 pci_rc = pci_register_driver(&vortex_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003223 eisa_rc = vortex_eisa_init();
3224
3225 if (pci_rc == 0)
3226 vortex_have_pci = 1;
3227 if (eisa_rc > 0)
3228 vortex_have_eisa = 1;
3229
3230 return (vortex_have_pci + vortex_have_eisa) ? 0 : -ENODEV;
3231}
3232
3233
Steffen Klasserta880c4c2006-03-26 01:37:43 -08003234static void __exit vortex_eisa_cleanup(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003235{
3236 struct vortex_private *vp;
John W. Linville62afe592005-11-07 00:58:02 -08003237 void __iomem *ioaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003238
3239#ifdef CONFIG_EISA
3240 /* Take care of the EISA devices */
Steffen Klasserta880c4c2006-03-26 01:37:43 -08003241 eisa_driver_unregister(&vortex_eisa_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003242#endif
Jeff Garzik6aa20a22006-09-13 13:24:59 -04003243
Linus Torvalds1da177e2005-04-16 15:20:36 -07003244 if (compaq_net_device) {
Wang Chen454d7c92008-11-12 23:37:49 -08003245 vp = netdev_priv(compaq_net_device);
John W. Linville62afe592005-11-07 00:58:02 -08003246 ioaddr = ioport_map(compaq_net_device->base_addr,
3247 VORTEX_TOTAL_SIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003248
Steffen Klasserta880c4c2006-03-26 01:37:43 -08003249 unregister_netdev(compaq_net_device);
3250 iowrite16(TotalReset, ioaddr + EL3_CMD);
John W. Linville62afe592005-11-07 00:58:02 -08003251 release_region(compaq_net_device->base_addr,
3252 VORTEX_TOTAL_SIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003253
Steffen Klasserta880c4c2006-03-26 01:37:43 -08003254 free_netdev(compaq_net_device);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003255 }
3256}
3257
3258
Steffen Klasserta880c4c2006-03-26 01:37:43 -08003259static void __exit vortex_cleanup(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003260{
3261 if (vortex_have_pci)
Steffen Klasserta880c4c2006-03-26 01:37:43 -08003262 pci_unregister_driver(&vortex_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003263 if (vortex_have_eisa)
Steffen Klasserta880c4c2006-03-26 01:37:43 -08003264 vortex_eisa_cleanup();
Linus Torvalds1da177e2005-04-16 15:20:36 -07003265}
3266
3267
3268module_init(vortex_init);
3269module_exit(vortex_cleanup);